[libsigrok.git] / src / scpi / vxi_clnt.c

/*
 * Please do not edit this file.
 * It was generated using rpcgen.
 */

#include "vxi.h"
#include <memory.h> /* for memset */

/* Default timeout can be changed using clnt_control() */
static struct timeval TIMEOUT = { 25, 0 };

Device_Error *
device_abort_1(Device_Link *argp, CLIENT *clnt)
{
	static Device_Error clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_abort,
		(xdrproc_t) xdr_Device_Link, (caddr_t) argp,
		(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Create_LinkResp *
create_link_1(Create_LinkParms *argp, CLIENT *clnt)
{
	static Create_LinkResp clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, create_link,
		(xdrproc_t) xdr_Create_LinkParms, (caddr_t) argp,
		(xdrproc_t) xdr_Create_LinkResp, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_WriteResp *
device_write_1(Device_WriteParms *argp, CLIENT *clnt)
{
	static Device_WriteResp clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_write,
		(xdrproc_t) xdr_Device_WriteParms, (caddr_t) argp,
		(xdrproc_t) xdr_Device_WriteResp, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_ReadResp *
device_read_1(Device_ReadParms *argp, CLIENT *clnt)
{
	static Device_ReadResp clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_read,
		(xdrproc_t) xdr_Device_ReadParms, (caddr_t) argp,
		(xdrproc_t) xdr_Device_ReadResp, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_ReadStbResp *
device_readstb_1(Device_GenericParms *argp, CLIENT *clnt)
{
	static Device_ReadStbResp clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_readstb,
		(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
		(xdrproc_t) xdr_Device_ReadStbResp, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_Error *
device_trigger_1(Device_GenericParms *argp, CLIENT *clnt)
{
	static Device_Error clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_trigger,
		(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
		(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_Error *
device_clear_1(Device_GenericParms *argp, CLIENT *clnt)
{
	static Device_Error clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_clear,
		(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
		(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_Error *
device_remote_1(Device_GenericParms *argp, CLIENT *clnt)
{
	static Device_Error clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_remote,
		(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
		(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_Error *
device_local_1(Device_GenericParms *argp, CLIENT *clnt)
{
	static Device_Error clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_local,
		(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
		(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_Error *
device_lock_1(Device_LockParms *argp, CLIENT *clnt)
{
	static Device_Error clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_lock,
		(xdrproc_t) xdr_Device_LockParms, (caddr_t) argp,
		(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_Error *
device_unlock_1(Device_Link *argp, CLIENT *clnt)
{
	static Device_Error clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_unlock,
		(xdrproc_t) xdr_Device_Link, (caddr_t) argp,
		(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_Error *
device_enable_srq_1(Device_EnableSrqParms *argp, CLIENT *clnt)
{
	static Device_Error clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_enable_srq,
		(xdrproc_t) xdr_Device_EnableSrqParms, (caddr_t) argp,
		(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_DocmdResp *
device_docmd_1(Device_DocmdParms *argp, CLIENT *clnt)
{
	static Device_DocmdResp clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_docmd,
		(xdrproc_t) xdr_Device_DocmdParms, (caddr_t) argp,
		(xdrproc_t) xdr_Device_DocmdResp, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_Error *
destroy_link_1(Device_Link *argp, CLIENT *clnt)
{
	static Device_Error clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, destroy_link,
		(xdrproc_t) xdr_Device_Link, (caddr_t) argp,
		(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_Error *
create_intr_chan_1(Device_RemoteFunc *argp, CLIENT *clnt)
{
	static Device_Error clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, create_intr_chan,
		(xdrproc_t) xdr_Device_RemoteFunc, (caddr_t) argp,
		(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

Device_Error *
destroy_intr_chan_1(void *argp, CLIENT *clnt)
{
	static Device_Error clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, destroy_intr_chan,
		(xdrproc_t) xdr_void, (caddr_t) argp,
		(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return (&clnt_res);
}

void *
device_intr_srq_1(Device_SrqParms *argp, CLIENT *clnt)
{
	static char clnt_res;

	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	if (clnt_call (clnt, device_intr_srq,
		(xdrproc_t) xdr_Device_SrqParms, (caddr_t) argp,
		(xdrproc_t) xdr_void, (caddr_t) &clnt_res,
		TIMEOUT) != RPC_SUCCESS) {
		return (NULL);
	}
	return ((void *)&clnt_res);
}
Commit	Line	Data
c84b6ab8 AJ	1	/*
	2	* Please do not edit this file.
	3	* It was generated using rpcgen.
	4	*/
	5
c84b6ab8	6	#include "vxi.h"
d40b8557	7	#include <memory.h> /* for memset */
c84b6ab8 AJ	8
	9	/* Default timeout can be changed using clnt_control() */
	10	static struct timeval TIMEOUT = { 25, 0 };
	11
	12	Device_Error *
	13	device_abort_1(Device_Link argp, CLIENT clnt)
	14	{
	15	static Device_Error clnt_res;
	16
	17	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	18	if (clnt_call (clnt, device_abort,
	19	(xdrproc_t) xdr_Device_Link, (caddr_t) argp,
	20	(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
	21	TIMEOUT) != RPC_SUCCESS) {
	22	return (NULL);
	23	}
	24	return (&clnt_res);
	25	}
	26
	27	Create_LinkResp *
	28	create_link_1(Create_LinkParms argp, CLIENT clnt)
	29	{
	30	static Create_LinkResp clnt_res;
	31
	32	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	33	if (clnt_call (clnt, create_link,
	34	(xdrproc_t) xdr_Create_LinkParms, (caddr_t) argp,
	35	(xdrproc_t) xdr_Create_LinkResp, (caddr_t) &clnt_res,
	36	TIMEOUT) != RPC_SUCCESS) {
	37	return (NULL);
	38	}
	39	return (&clnt_res);
	40	}
	41
	42	Device_WriteResp *
	43	device_write_1(Device_WriteParms argp, CLIENT clnt)
	44	{
	45	static Device_WriteResp clnt_res;
	46
	47	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	48	if (clnt_call (clnt, device_write,
	49	(xdrproc_t) xdr_Device_WriteParms, (caddr_t) argp,
	50	(xdrproc_t) xdr_Device_WriteResp, (caddr_t) &clnt_res,
	51	TIMEOUT) != RPC_SUCCESS) {
	52	return (NULL);
	53	}
	54	return (&clnt_res);
	55	}
	56
	57	Device_ReadResp *
	58	device_read_1(Device_ReadParms argp, CLIENT clnt)
	59	{
	60	static Device_ReadResp clnt_res;
	61
	62	memset((char *)&clnt_res, 0, sizeof(clnt_res));
	63	if (clnt_call (clnt, device_read,
	64	(xdrproc_t) xdr_Device_ReadParms, (caddr_t) argp,
	65	(xdrproc_t) xdr_Device_ReadResp, (caddr_t) &clnt_res,
	66	TIMEOUT) != RPC_SUCCESS) {
	67	return (NULL);
	68	}
	69	return (&clnt_res);
	70	}
	71
72	Device_ReadStbResp *
73	device_readstb_1(Device_GenericParms argp, CLIENT clnt)
74	{
75	static Device_ReadStbResp clnt_res;
76
77	memset((char *)&clnt_res, 0, sizeof(clnt_res));
78	if (clnt_call (clnt, device_readstb,
79	(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
80	(xdrproc_t) xdr_Device_ReadStbResp, (caddr_t) &clnt_res,
81	TIMEOUT) != RPC_SUCCESS) {
82	return (NULL);
83	}
84	return (&clnt_res);
85	}
86
87	Device_Error *
88	device_trigger_1(Device_GenericParms argp, CLIENT clnt)
89	{
90	static Device_Error clnt_res;
91
92	memset((char *)&clnt_res, 0, sizeof(clnt_res));
93	if (clnt_call (clnt, device_trigger,
94	(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
95	(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
96	TIMEOUT) != RPC_SUCCESS) {
97	return (NULL);
98	}
99	return (&clnt_res);
100	}
101
102	Device_Error *
103	device_clear_1(Device_GenericParms argp, CLIENT clnt)
104	{
105	static Device_Error clnt_res;
106
107	memset((char *)&clnt_res, 0, sizeof(clnt_res));
108	if (clnt_call (clnt, device_clear,
109	(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
110	(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
111	TIMEOUT) != RPC_SUCCESS) {
112	return (NULL);
113	}
114	return (&clnt_res);
115	}
116
117	Device_Error *
118	device_remote_1(Device_GenericParms argp, CLIENT clnt)
119	{
120	static Device_Error clnt_res;
121
122	memset((char *)&clnt_res, 0, sizeof(clnt_res));
123	if (clnt_call (clnt, device_remote,
124	(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
125	(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
126	TIMEOUT) != RPC_SUCCESS) {
127	return (NULL);
128	}
129	return (&clnt_res);
130	}
131
132	Device_Error *
133	device_local_1(Device_GenericParms argp, CLIENT clnt)
134	{
135	static Device_Error clnt_res;
136
137	memset((char *)&clnt_res, 0, sizeof(clnt_res));
138	if (clnt_call (clnt, device_local,
139	(xdrproc_t) xdr_Device_GenericParms, (caddr_t) argp,
140	(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
141	TIMEOUT) != RPC_SUCCESS) {
142	return (NULL);
143	}
144	return (&clnt_res);
145	}
146
147	Device_Error *
148	device_lock_1(Device_LockParms argp, CLIENT clnt)
149	{
150	static Device_Error clnt_res;
151
152	memset((char *)&clnt_res, 0, sizeof(clnt_res));
153	if (clnt_call (clnt, device_lock,
154	(xdrproc_t) xdr_Device_LockParms, (caddr_t) argp,
155	(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
156	TIMEOUT) != RPC_SUCCESS) {
157	return (NULL);
158	}
159	return (&clnt_res);
160	}
161
162	Device_Error *
163	device_unlock_1(Device_Link argp, CLIENT clnt)
164	{
165	static Device_Error clnt_res;
166
167	memset((char *)&clnt_res, 0, sizeof(clnt_res));
168	if (clnt_call (clnt, device_unlock,
169	(xdrproc_t) xdr_Device_Link, (caddr_t) argp,
170	(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
171	TIMEOUT) != RPC_SUCCESS) {
172	return (NULL);
173	}
174	return (&clnt_res);
175	}
176
177	Device_Error *
178	device_enable_srq_1(Device_EnableSrqParms argp, CLIENT clnt)
179	{
180	static Device_Error clnt_res;
181
182	memset((char *)&clnt_res, 0, sizeof(clnt_res));
183	if (clnt_call (clnt, device_enable_srq,
184	(xdrproc_t) xdr_Device_EnableSrqParms, (caddr_t) argp,
185	(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
186	TIMEOUT) != RPC_SUCCESS) {
187	return (NULL);
188	}
189	return (&clnt_res);
190	}
191
192	Device_DocmdResp *
193	device_docmd_1(Device_DocmdParms argp, CLIENT clnt)
194	{
195	static Device_DocmdResp clnt_res;
196
197	memset((char *)&clnt_res, 0, sizeof(clnt_res));
198	if (clnt_call (clnt, device_docmd,
199	(xdrproc_t) xdr_Device_DocmdParms, (caddr_t) argp,
200	(xdrproc_t) xdr_Device_DocmdResp, (caddr_t) &clnt_res,
201	TIMEOUT) != RPC_SUCCESS) {
202	return (NULL);
203	}
204	return (&clnt_res);
205	}
206
207	Device_Error *
208	destroy_link_1(Device_Link argp, CLIENT clnt)
209	{
210	static Device_Error clnt_res;
211
212	memset((char *)&clnt_res, 0, sizeof(clnt_res));
213	if (clnt_call (clnt, destroy_link,
214	(xdrproc_t) xdr_Device_Link, (caddr_t) argp,
215	(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
216	TIMEOUT) != RPC_SUCCESS) {
217	return (NULL);
218	}
219	return (&clnt_res);
220	}
221
222	Device_Error *
223	create_intr_chan_1(Device_RemoteFunc argp, CLIENT clnt)
224	{
225	static Device_Error clnt_res;
226
227	memset((char *)&clnt_res, 0, sizeof(clnt_res));
228	if (clnt_call (clnt, create_intr_chan,
229	(xdrproc_t) xdr_Device_RemoteFunc, (caddr_t) argp,
230	(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
231	TIMEOUT) != RPC_SUCCESS) {
232	return (NULL);
233	}
234	return (&clnt_res);
235	}
236
237	Device_Error *
238	destroy_intr_chan_1(void argp, CLIENT clnt)
239	{
240	static Device_Error clnt_res;
241
242	memset((char *)&clnt_res, 0, sizeof(clnt_res));
243	if (clnt_call (clnt, destroy_intr_chan,
244	(xdrproc_t) xdr_void, (caddr_t) argp,
245	(xdrproc_t) xdr_Device_Error, (caddr_t) &clnt_res,
246	TIMEOUT) != RPC_SUCCESS) {
247	return (NULL);
248	}
249	return (&clnt_res);
250	}
251
252	void *
253	device_intr_srq_1(Device_SrqParms argp, CLIENT clnt)
254	{
255	static char clnt_res;
256
257	memset((char *)&clnt_res, 0, sizeof(clnt_res));
258	if (clnt_call (clnt, device_intr_srq,
259	(xdrproc_t) xdr_Device_SrqParms, (caddr_t) argp,
260	(xdrproc_t) xdr_void, (caddr_t) &clnt_res,
261	TIMEOUT) != RPC_SUCCESS) {
262	return (NULL);
263	}
264	return ((void *)&clnt_res);
265	}