[unix-history] / usr.bin / rpcgen / rpc_cout.c

/* @(#)rpc_cout.c	2.1 88/08/01 4.0 RPCSRC */
/*
 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
 * unrestricted use provided that this legend is included on all tape
 * media and as a part of the software program in whole or part.  Users
 * may copy or modify Sun RPC without charge, but are not authorized
 * to license or distribute it to anyone else except as part of a product or
 * program developed by the user.
 * 
 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
 * 
 * Sun RPC is provided with no support and without any obligation on the
 * part of Sun Microsystems, Inc. to assist in its use, correction,
 * modification or enhancement.
 * 
 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
 * OR ANY PART THEREOF.
 * 
 * In no event will Sun Microsystems, Inc. be liable for any lost revenue
 * or profits or other special, indirect and consequential damages, even if
 * Sun has been advised of the possibility of such damages.
 * 
 * Sun Microsystems, Inc.
 * 2550 Garcia Avenue
 * Mountain View, California  94043
 */
#ifndef lint
/*static char sccsid[] = "from: @(#)rpc_cout.c 1.8 87/06/24 (C) 1987 SMI";*/
static char rcsid[] = "$Id: rpc_cout.c,v 1.3 1993/08/01 18:09:22 mycroft Exp $";
#endif

/*
 * rpc_cout.c, XDR routine outputter for the RPC protocol compiler 
 * Copyright (C) 1987, Sun Microsystems, Inc. 
 */
#include <stdio.h>
#include <strings.h>
#include "rpc_util.h"
#include "rpc_parse.h"

static int print_header(), print_trailer(), space(), emit_enum(),
	   emit_union(), emit_struct(), emit_typedef(), print_stat();


/*
 * Emit the C-routine for the given definition 
 */
void
emit(def)
	definition *def;
{
	if (def->def_kind == DEF_PROGRAM || def->def_kind == DEF_CONST) {
		return;
	}
	print_header(def);
	switch (def->def_kind) {
	case DEF_UNION:
		emit_union(def);
		break;
	case DEF_ENUM:
		emit_enum(def);
		break;
	case DEF_STRUCT:
		emit_struct(def);
		break;
	case DEF_TYPEDEF:
		emit_typedef(def);
		break;
	}
	print_trailer();
}

static
findtype(def, type)
	definition *def;
	char *type;
{
	if (def->def_kind == DEF_PROGRAM || def->def_kind == DEF_CONST) {
		return (0);
	} else {
		return (streq(def->def_name, type));
	}
}

static
undefined(type)
	char *type;
{
	definition *def;

	def = (definition *) FINDVAL(defined, type, findtype);
	return (def == NULL);
}


static
print_header(def)
	definition *def;
{
	space();
	f_print(fout, "bool_t\n");
	f_print(fout, "xdr_%s(xdrs, objp)\n", def->def_name);
	f_print(fout, "\tXDR *xdrs;\n");
	f_print(fout, "\t%s ", def->def_name);
	if (def->def_kind != DEF_TYPEDEF ||
	    !isvectordef(def->def.ty.old_type, def->def.ty.rel)) {
		f_print(fout, "*");
	}
	f_print(fout, "objp;\n");
	f_print(fout, "{\n");
}

static
print_trailer()
{
	f_print(fout, "\treturn (TRUE);\n");
	f_print(fout, "}\n");
	space();
}


static
print_ifopen(indent, name)
	int indent;
	char *name;
{
	tabify(fout, indent);
	f_print(fout, "if (!xdr_%s(xdrs", name);
}


static
print_ifarg(arg)
	char *arg;
{
	f_print(fout, ", %s", arg);
}


static
print_ifsizeof(prefix, type)
	char *prefix;
	char *type;
{
	if (streq(type, "bool")) {
		f_print(fout, ", sizeof(bool_t), xdr_bool");
	} else {
		f_print(fout, ", sizeof(");
		if (undefined(type) && prefix) {
			f_print(fout, "%s ", prefix);
		}
		f_print(fout, "%s), xdr_%s", type, type);
	}
}

static
print_ifclose(indent)
	int indent;
{
	f_print(fout, ")) {\n");
	tabify(fout, indent);
	f_print(fout, "\treturn (FALSE);\n");
	tabify(fout, indent);
	f_print(fout, "}\n");
}

static
space()
{
	f_print(fout, "\n\n");
}

static
print_ifstat(indent, prefix, type, rel, amax, objname, name)
	int indent;
	char *prefix;
	char *type;
	relation rel;
	char *amax;
	char *objname;
	char *name;
{
	char *alt = NULL;

	switch (rel) {
	case REL_POINTER:
		print_ifopen(indent, "pointer");
		print_ifarg("(char **)");
		f_print(fout, "%s", objname);
		print_ifsizeof(prefix, type);
		break;
	case REL_VECTOR:
		if (streq(type, "string")) {
			alt = "string";
		} else if (streq(type, "opaque")) {
			alt = "opaque";
		}
		if (alt) {
			print_ifopen(indent, alt);
			print_ifarg(objname);
		} else {
			print_ifopen(indent, "vector");
			print_ifarg("(char *)");
			f_print(fout, "%s", objname);
		}
		print_ifarg(amax);
		if (!alt) {
			print_ifsizeof(prefix, type);
		}
		break;
	case REL_ARRAY:
		if (streq(type, "string")) {
			alt = "string";
		} else if (streq(type, "opaque")) {
			alt = "bytes";
		}
		if (streq(type, "string")) {
			print_ifopen(indent, alt);
			print_ifarg(objname);
		} else {
			if (alt) {
				print_ifopen(indent, alt);
			} else {
				print_ifopen(indent, "array");
			}
			print_ifarg("(char **)");
			if (*objname == '&') {
				f_print(fout, "%s.%s_val, (u_int *)%s.%s_len",
					objname, name, objname, name);
			} else {
				f_print(fout, "&%s->%s_val, (u_int *)&%s->%s_len",
					objname, name, objname, name);
			}
		}
		print_ifarg(amax);
		if (!alt) {
			print_ifsizeof(prefix, type);
		}
		break;
	case REL_ALIAS:
		print_ifopen(indent, type);
		print_ifarg(objname);
		break;
	}
	print_ifclose(indent);
}


/* ARGSUSED */
static
emit_enum(def)
	definition *def;
{
	print_ifopen(1, "enum");
	print_ifarg("(enum_t *)objp");
	print_ifclose(1);
}


static
emit_union(def)
	definition *def;
{
	declaration *dflt;
	case_list *cl;
	declaration *cs;
	char *object;
	char *format = "&objp->%s_u.%s";

	print_stat(&def->def.un.enum_decl);
	f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name);
	for (cl = def->def.un.cases; cl != NULL; cl = cl->next) {
		cs = &cl->case_decl;
		f_print(fout, "\tcase %s:\n", cl->case_name);
		if (!streq(cs->type, "void")) {
			object = alloc(strlen(def->def_name) + strlen(format) +
				       strlen(cs->name) + 1);
			s_print(object, format, def->def_name, cs->name);
			print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max,
				     object, cs->name);
			free(object);
		}
		f_print(fout, "\t\tbreak;\n");
	}
	dflt = def->def.un.default_decl;
	if (dflt != NULL) {
		if (!streq(dflt->type, "void")) {
			f_print(fout, "\tdefault:\n");
			object = alloc(strlen(def->def_name) + strlen(format) +
				       strlen(dflt->name) + 1);
			s_print(object, format, def->def_name, dflt->name);
			print_ifstat(2, dflt->prefix, dflt->type, dflt->rel,
				     dflt->array_max, object, dflt->name);
			free(object);
			f_print(fout, "\t\tbreak;\n");
		}
	} else {
		f_print(fout, "\tdefault:\n");
		f_print(fout, "\t\treturn (FALSE);\n");
	}
	f_print(fout, "\t}\n");
}


static
emit_struct(def)
	definition *def;
{
	decl_list *dl;

	for (dl = def->def.st.decls; dl != NULL; dl = dl->next) {
		print_stat(&dl->decl);
	}
}


static
emit_typedef(def)
	definition *def;
{
	char *prefix = def->def.ty.old_prefix;
	char *type = def->def.ty.old_type;
	char *amax = def->def.ty.array_max;
	relation rel = def->def.ty.rel;

	print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name);
}


static
print_stat(dec)
	declaration *dec;
{
	char *prefix = dec->prefix;
	char *type = dec->type;
	char *amax = dec->array_max;
	relation rel = dec->rel;
	char name[256];

	if (isvectordef(type, rel)) {
		s_print(name, "objp->%s", dec->name);
	} else {
		s_print(name, "&objp->%s", dec->name);
	}
	print_ifstat(1, prefix, type, rel, amax, name, dec->name);
}
Commit	Line	Data
9a4767d3 C	1	/* @(#)rpc_cout.c 2.1 88/08/01 4.0 RPCSRC */
	2	/*
	3	* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
	4	* unrestricted use provided that this legend is included on all tape
	5	* media and as a part of the software program in whole or part. Users
	6	* may copy or modify Sun RPC without charge, but are not authorized
	7	* to license or distribute it to anyone else except as part of a product or
	8	* program developed by the user.
	9	*
	10	* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
	11	* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
	12	* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
	13	*
	14	* Sun RPC is provided with no support and without any obligation on the
	15	* part of Sun Microsystems, Inc. to assist in its use, correction,
	16	* modification or enhancement.
	17	*
	18	* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
	19	* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
	20	* OR ANY PART THEREOF.
	21	*
	22	* In no event will Sun Microsystems, Inc. be liable for any lost revenue
	23	* or profits or other special, indirect and consequential damages, even if
	24	* Sun has been advised of the possibility of such damages.
	25	*
	26	* Sun Microsystems, Inc.
	27	* 2550 Garcia Avenue
	28	* Mountain View, California 94043
	29	*/
	30	#ifndef lint
	31	/static char sccsid[] = "from: @(#)rpc_cout.c 1.8 87/06/24 (C) 1987 SMI";/
	32	static char rcsid[] = "$Id: rpc_cout.c,v 1.3 1993/08/01 18:09:22 mycroft Exp $";
	33	#endif
	34
	35	/*
	36	* rpc_cout.c, XDR routine outputter for the RPC protocol compiler
	37	* Copyright (C) 1987, Sun Microsystems, Inc.
	38	*/
	39	#include <stdio.h>
	40	#include <strings.h>
	41	#include "rpc_util.h"
	42	#include "rpc_parse.h"
	43
	44	static int print_header(), print_trailer(), space(), emit_enum(),
	45	emit_union(), emit_struct(), emit_typedef(), print_stat();
	46
	47
	48	/*
	49	* Emit the C-routine for the given definition
	50	*/
	51	void
	52	emit(def)
	53	definition *def;
	54	{
	55	if (def->def_kind == DEF_PROGRAM \|\| def->def_kind == DEF_CONST) {
	56	return;
	57	}
	58	print_header(def);
	59	switch (def->def_kind) {
	60	case DEF_UNION:
	61	emit_union(def);
	62	break;
	63	case DEF_ENUM:
	64	emit_enum(def);
65	break;
66	case DEF_STRUCT:
67	emit_struct(def);
68	break;
69	case DEF_TYPEDEF:
70	emit_typedef(def);
71	break;
72	}
73	print_trailer();
74	}
75
76	static
77	findtype(def, type)
78	definition *def;
79	char *type;
80	{
81	if (def->def_kind == DEF_PROGRAM \|\| def->def_kind == DEF_CONST) {
82	return (0);
83	} else {
84	return (streq(def->def_name, type));
85	}
86	}
87
88	static
89	undefined(type)
90	char *type;
91	{
92	definition *def;
93
94	def = (definition *) FINDVAL(defined, type, findtype);
95	return (def == NULL);
96	}
97
98
99	static
100	print_header(def)
101	definition *def;
102	{
103	space();
104	f_print(fout, "bool_t\n");
105	f_print(fout, "xdr_%s(xdrs, objp)\n", def->def_name);
106	f_print(fout, "\tXDR *xdrs;\n");
107	f_print(fout, "\t%s ", def->def_name);
108	if (def->def_kind != DEF_TYPEDEF \|\|
109	!isvectordef(def->def.ty.old_type, def->def.ty.rel)) {
110	f_print(fout, "*");
111	}
112	f_print(fout, "objp;\n");
113	f_print(fout, "{\n");
114	}
115
116	static
117	print_trailer()
118	{
119	f_print(fout, "\treturn (TRUE);\n");
120	f_print(fout, "}\n");
121	space();
122	}
123
124
125	static
126	print_ifopen(indent, name)
127	int indent;
128	char *name;
129	{
130	tabify(fout, indent);
131	f_print(fout, "if (!xdr_%s(xdrs", name);
132	}
133
134
135	static
136	print_ifarg(arg)
137	char *arg;
138	{
139	f_print(fout, ", %s", arg);
140	}
141
142
143	static
144	print_ifsizeof(prefix, type)
145	char *prefix;
146	char *type;
147	{
148	if (streq(type, "bool")) {
149	f_print(fout, ", sizeof(bool_t), xdr_bool");
150	} else {
151	f_print(fout, ", sizeof(");
152	if (undefined(type) && prefix) {
153	f_print(fout, "%s ", prefix);
154	}
155	f_print(fout, "%s), xdr_%s", type, type);
156	}
157	}
158
159	static
160	print_ifclose(indent)
161	int indent;
162	{
163	f_print(fout, ")) {\n");
164	tabify(fout, indent);
165	f_print(fout, "\treturn (FALSE);\n");
166	tabify(fout, indent);
167	f_print(fout, "}\n");
168	}
169
170	static
171	space()
172	{
173	f_print(fout, "\n\n");
174	}
175
176	static
177	print_ifstat(indent, prefix, type, rel, amax, objname, name)
178	int indent;
179	char *prefix;
180	char *type;
181	relation rel;
182	char *amax;
183	char *objname;
184	char *name;
185	{
186	char *alt = NULL;
187
188	switch (rel) {
189	case REL_POINTER:
190	print_ifopen(indent, "pointer");
191	print_ifarg("(char **)");
192	f_print(fout, "%s", objname);
193	print_ifsizeof(prefix, type);
194	break;
195	case REL_VECTOR:
196	if (streq(type, "string")) {
197	alt = "string";
198	} else if (streq(type, "opaque")) {
199	alt = "opaque";
200	}
201	if (alt) {
202	print_ifopen(indent, alt);
203	print_ifarg(objname);
204	} else {
205	print_ifopen(indent, "vector");
206	print_ifarg("(char *)");
207	f_print(fout, "%s", objname);
208	}
209	print_ifarg(amax);
210	if (!alt) {
211	print_ifsizeof(prefix, type);
212	}
213	break;
214	case REL_ARRAY:
215	if (streq(type, "string")) {
216	alt = "string";
217	} else if (streq(type, "opaque")) {
218	alt = "bytes";
219	}
220	if (streq(type, "string")) {
221	print_ifopen(indent, alt);
222	print_ifarg(objname);
223	} else {
224	if (alt) {
225	print_ifopen(indent, alt);
226	} else {
227	print_ifopen(indent, "array");
228	}
229	print_ifarg("(char **)");
230	if (*objname == '&') {
231	f_print(fout, "%s.%s_val, (u_int *)%s.%s_len",
232	objname, name, objname, name);
233	} else {
234	f_print(fout, "&%s->%s_val, (u_int *)&%s->%s_len",
235	objname, name, objname, name);
236	}
237	}
238	print_ifarg(amax);
239	if (!alt) {
240	print_ifsizeof(prefix, type);
241	}
242	break;
243	case REL_ALIAS:
244	print_ifopen(indent, type);
245	print_ifarg(objname);
246	break;
247	}
248	print_ifclose(indent);
249	}
250
251
252	/* ARGSUSED */
253	static
254	emit_enum(def)
255	definition *def;
256	{
257	print_ifopen(1, "enum");
258	print_ifarg("(enum_t *)objp");
259	print_ifclose(1);
260	}
261
262
263	static
264	emit_union(def)
265	definition *def;
266	{
267	declaration *dflt;
268	case_list *cl;
269	declaration *cs;
270	char *object;
271	char *format = "&objp->%s_u.%s";
272
273	print_stat(&def->def.un.enum_decl);
274	f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name);
275	for (cl = def->def.un.cases; cl != NULL; cl = cl->next) {
276	cs = &cl->case_decl;
277	f_print(fout, "\tcase %s:\n", cl->case_name);
278	if (!streq(cs->type, "void")) {
279	object = alloc(strlen(def->def_name) + strlen(format) +
280	strlen(cs->name) + 1);
281	s_print(object, format, def->def_name, cs->name);
282	print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max,
283	object, cs->name);
284	free(object);
285	}
286	f_print(fout, "\t\tbreak;\n");
287	}
288	dflt = def->def.un.default_decl;
289	if (dflt != NULL) {
290	if (!streq(dflt->type, "void")) {
291	f_print(fout, "\tdefault:\n");
292	object = alloc(strlen(def->def_name) + strlen(format) +
293	strlen(dflt->name) + 1);
294	s_print(object, format, def->def_name, dflt->name);
295	print_ifstat(2, dflt->prefix, dflt->type, dflt->rel,
296	dflt->array_max, object, dflt->name);
297	free(object);
298	f_print(fout, "\t\tbreak;\n");
299	}
300	} else {
301	f_print(fout, "\tdefault:\n");
302	f_print(fout, "\t\treturn (FALSE);\n");
303	}
304	f_print(fout, "\t}\n");
305	}
306
307
308
309	static
310	emit_struct(def)
311	definition *def;
312	{
313	decl_list *dl;
314
315	for (dl = def->def.st.decls; dl != NULL; dl = dl->next) {
316	print_stat(&dl->decl);
317	}
318	}
319
320
321
322
323	static
324	emit_typedef(def)
325	definition *def;
326	{
327	char *prefix = def->def.ty.old_prefix;
328	char *type = def->def.ty.old_type;
329	char *amax = def->def.ty.array_max;
330	relation rel = def->def.ty.rel;
331
332	print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name);
333	}
334
335
336
337
338
339	static
340	print_stat(dec)
341	declaration *dec;
342	{
343	char *prefix = dec->prefix;
344	char *type = dec->type;
345	char *amax = dec->array_max;
346	relation rel = dec->rel;
347	char name[256];
348
349	if (isvectordef(type, rel)) {
350	s_print(name, "objp->%s", dec->name);
351	} else {
352	s_print(name, "&objp->%s", dec->name);
353	}
354	print_ifstat(1, prefix, type, rel, amax, name, dec->name);
355	}