![[BACK]](/icons/back.gif){kind=icon}
Return to rpc_cout.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / rpcgen|
Return to rpc_cout.c CVS log | Up to [local] / src / usr.bin / rpcgen |
1.1 deraadt 1: /* $NetBSD: rpc_cout.c,v 1.5 1995/08/29 23:05:49 cgd Exp $ */
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 or with the express written consent of
9: * Sun Microsystems, Inc.
10: *
11: * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
12: * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
13: * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
14: *
15: * Sun RPC is provided with no support and without any obligation on the
16: * part of Sun Microsystems, Inc. to assist in its use, correction,
17: * modification or enhancement.
18: *
19: * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
20: * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
21: * OR ANY PART THEREOF.
22: *
23: * In no event will Sun Microsystems, Inc. be liable for any lost revenue
24: * or profits or other special, indirect and consequential damages, even if
25: * Sun has been advised of the possibility of such damages.
26: *
27: * Sun Microsystems, Inc.
28: * 2550 Garcia Avenue
29: * Mountain View, California 94043
30: */
31:
32: #ifndef lint
33: static char sccsid[] = "@(#)rpc_cout.c 1.13 89/02/22 (C) 1987 SMI";
34: #endif
35:
36: /*
37: * rpc_cout.c, XDR routine outputter for the RPC protocol compiler
38: */
39: #include <sys/cdefs.h>
40: #include <stdio.h>
41: #include <stdlib.h>
42: #include <string.h>
43: #include "rpc_parse.h"
44: #include "rpc_util.h"
45:
46: static findtype __P((definition *, char *));
47: static undefined __P((char *));
48: static print_generic_header __P((char *, int));
49: static print_header __P((definition *));
50: static print_prog_header __P((proc_list *));
51: static print_trailer __P((void));
52: static print_ifopen __P((int, char *));
53: static print_ifarg __P((char *));
54: static print_ifsizeof __P((char *, char *));
55: static print_ifclose __P((int));
56: static print_ifstat __P((int, char *, char *, relation, char *, char *, char *));
57: static emit_num __P((definition *));
58: static emit_program __P((definition *));
59: static emit_enum __P((definition *));
60: static emit_union __P((definition *));
61: static emit_struct __P((definition *));
62: static emit_typedef __P((definition *));
63: static print_stat __P((int, declaration *));
64:
65:
66: /*
67: * Emit the C-routine for the given definition
68: */
69: void
70: emit(def)
71: definition *def;
72: {
73: if (def->def_kind == DEF_CONST) {
74: return;
75: }
76: if (def->def_kind == DEF_PROGRAM) {
77: emit_program(def);
78: return;
79: }
80: if (def->def_kind == DEF_TYPEDEF) {
81: /* now we need to handle declarations like struct typedef foo
82: * foo; since we dont want this to be expanded into 2 calls to
83: * xdr_foo */
84:
85: if (strcmp(def->def.ty.old_type, def->def_name) == 0)
86: return;
87: };
88:
89: print_header(def);
90: switch (def->def_kind) {
91: case DEF_UNION:
92: emit_union(def);
93: break;
94: case DEF_ENUM:
95: emit_enum(def);
96: break;
97: case DEF_STRUCT:
98: emit_struct(def);
99: break;
100: case DEF_TYPEDEF:
101: emit_typedef(def);
102: break;
103: }
104: print_trailer();
105: }
106:
107: static
108: findtype(def, type)
109: definition *def;
110: char *type;
111: {
112:
113: if (def->def_kind == DEF_PROGRAM || def->def_kind == DEF_CONST) {
114: return (0);
115: } else {
116: return (streq(def->def_name, type));
117: }
118: }
119:
120: static
121: undefined(type)
122: char *type;
123: {
124: definition *def;
125:
126: def = (definition *) FINDVAL(defined, type, findtype);
127:
128:
129: return (def == NULL);
130: }
131:
132: static
133: print_generic_header(procname, pointerp)
134: char *procname;
135: int pointerp;
136: {
137: f_print(fout, "\n");
138: f_print(fout, "bool_t\n");
139: if (Cflag) {
140: f_print(fout, "xdr_%s(", procname);
141: f_print(fout, "XDR *xdrs, ");
142: f_print(fout, "%s ", procname);
143: if (pointerp)
144: f_print(fout, "*");
145: f_print(fout, "objp)\n{\n\n");
146: } else {
147: f_print(fout, "xdr_%s(xdrs, objp)\n", procname);
148: f_print(fout, "\tXDR *xdrs;\n");
149: f_print(fout, "\t%s ", procname);
150: if (pointerp)
151: f_print(fout, "*");
152: f_print(fout, "objp;\n{\n\n");
153: }
154: }
155:
156: static
157: print_header(def)
158: definition *def;
159: {
160:
161: decl_list *dl;
162: bas_type *ptr;
163: int i;
164:
165:
166: print_generic_header(def->def_name,
167: def->def_kind != DEF_TYPEDEF ||
168: !isvectordef(def->def.ty.old_type, def->def.ty.rel));
169:
170: /* Now add Inline support */
171:
172:
173: if (inline == 0)
174: return;
175: /* May cause lint to complain. but ... */
176: f_print(fout, "\t register long *buf;\n\n");
177:
178: }
179:
180: static
181: print_prog_header(plist)
182: proc_list *plist;
183: {
184: print_generic_header(plist->args.argname, 1);
185: }
186:
187: static
188: print_trailer()
189: {
190: f_print(fout, "\treturn (TRUE);\n");
191: f_print(fout, "}\n");
192: }
193:
194:
195: static
196: print_ifopen(indent, name)
197: int indent;
198: char *name;
199: {
200: tabify(fout, indent);
201: f_print(fout, " if (!xdr_%s(xdrs", name);
202: }
203:
204: static
205: print_ifarg(arg)
206: char *arg;
207: {
208: f_print(fout, ", %s", arg);
209: }
210:
211: static
212: print_ifsizeof(prefix, type)
213: char *prefix;
214: char *type;
215: {
216: if (streq(type, "bool")) {
217: f_print(fout, ", sizeof(bool_t), (xdrproc_t)xdr_bool");
218: } else {
219: f_print(fout, ", sizeof(");
220: if (undefined(type) && prefix) {
221: f_print(fout, "%s ", prefix);
222: }
223: f_print(fout, "%s), (xdrproc_t)xdr_%s", type, type);
224: }
225: }
226:
227: static
228: print_ifclose(indent)
229: int indent;
230: {
231: f_print(fout, ")) {\n");
232: tabify(fout, indent);
233: f_print(fout, "\t return (FALSE);\n");
234: tabify(fout, indent);
235: f_print(fout, " }\n");
236: }
237:
238: static
239: print_ifstat(indent, prefix, type, rel, amax, objname, name)
240: int indent;
241: char *prefix;
242: char *type;
243: relation rel;
244: char *amax;
245: char *objname;
246: char *name;
247: {
248: char *alt = NULL;
249:
250: switch (rel) {
251: case REL_POINTER:
252: print_ifopen(indent, "pointer");
253: print_ifarg("(char **)");
254: f_print(fout, "%s", objname);
255: print_ifsizeof(prefix, type);
256: break;
257: case REL_VECTOR:
258: if (streq(type, "string")) {
259: alt = "string";
260: } else
261: if (streq(type, "opaque")) {
262: alt = "opaque";
263: }
264: if (alt) {
265: print_ifopen(indent, alt);
266: print_ifarg(objname);
267: } else {
268: print_ifopen(indent, "vector");
269: print_ifarg("(char *)");
270: f_print(fout, "%s", objname);
271: }
272: print_ifarg(amax);
273: if (!alt) {
274: print_ifsizeof(prefix, type);
275: }
276: break;
277: case REL_ARRAY:
278: if (streq(type, "string")) {
279: alt = "string";
280: } else
281: if (streq(type, "opaque")) {
282: alt = "bytes";
283: }
284: if (streq(type, "string")) {
285: print_ifopen(indent, alt);
286: print_ifarg(objname);
287: } else {
288: if (alt) {
289: print_ifopen(indent, alt);
290: } else {
291: print_ifopen(indent, "array");
292: }
293: print_ifarg("(char **)");
294: if (*objname == '&') {
295: f_print(fout, "%s.%s_val, (u_int *)%s.%s_len",
296: objname, name, objname, name);
297: } else {
298: f_print(fout, "&%s->%s_val, (u_int *)&%s->%s_len",
299: objname, name, objname, name);
300: }
301: }
302: print_ifarg(amax);
303: if (!alt) {
304: print_ifsizeof(prefix, type);
305: }
306: break;
307: case REL_ALIAS:
308: print_ifopen(indent, type);
309: print_ifarg(objname);
310: break;
311: }
312: print_ifclose(indent);
313: }
314:
315: /* ARGSUSED */
316: static
317: emit_enum(def)
318: definition *def;
319: {
320: print_ifopen(1, "enum");
321: print_ifarg("(enum_t *)objp");
322: print_ifclose(1);
323: }
324:
325: static
326: emit_program(def)
327: definition *def;
328: {
329: decl_list *dl;
330: version_list *vlist;
331: proc_list *plist;
332:
333: for (vlist = def->def.pr.versions; vlist != NULL; vlist = vlist->next)
334: for (plist = vlist->procs; plist != NULL; plist = plist->next) {
335: if (!newstyle || plist->arg_num < 2)
336: continue; /* old style, or single
337: * argument */
338: print_prog_header(plist);
339: for (dl = plist->args.decls; dl != NULL;
340: dl = dl->next)
341: print_stat(1, &dl->decl);
342: print_trailer();
343: }
344: }
345:
346:
347: static
348: emit_union(def)
349: definition *def;
350: {
351: declaration *dflt;
352: case_list *cl;
353: declaration *cs;
354: char *object;
355: char *vecformat = "objp->%s_u.%s";
356: char *format = "&objp->%s_u.%s";
357:
358: print_stat(1, &def->def.un.enum_decl);
359: f_print(fout, "\tswitch (objp->%s) {\n", def->def.un.enum_decl.name);
360: for (cl = def->def.un.cases; cl != NULL; cl = cl->next) {
361:
362: f_print(fout, "\tcase %s:\n", cl->case_name);
363: if (cl->contflag == 1) /* a continued case statement */
364: continue;
365: cs = &cl->case_decl;
366: if (!streq(cs->type, "void")) {
367: object = alloc(strlen(def->def_name) + strlen(format) +
368: strlen(cs->name) + 1);
369: if (isvectordef(cs->type, cs->rel)) {
370: s_print(object, vecformat, def->def_name,
371: cs->name);
372: } else {
373: s_print(object, format, def->def_name,
374: cs->name);
375: }
376: print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max,
377: object, cs->name);
378: free(object);
379: }
380: f_print(fout, "\t\tbreak;\n");
381: }
382: dflt = def->def.un.default_decl;
383: if (dflt != NULL) {
384: if (!streq(dflt->type, "void")) {
385: f_print(fout, "\tdefault:\n");
386: object = alloc(strlen(def->def_name) + strlen(format) +
387: strlen(dflt->name) + 1);
388: if (isvectordef(dflt->type, dflt->rel)) {
389: s_print(object, vecformat, def->def_name,
390: dflt->name);
391: } else {
392: s_print(object, format, def->def_name,
393: dflt->name);
394: }
395:
396: print_ifstat(2, dflt->prefix, dflt->type, dflt->rel,
397: dflt->array_max, object, dflt->name);
398: free(object);
399: f_print(fout, "\t\tbreak;\n");
400: }
401: } else {
402: f_print(fout, "\tdefault:\n");
403: f_print(fout, "\t\treturn (FALSE);\n");
404: }
405:
406: f_print(fout, "\t}\n");
407: }
408:
409: static
410: emit_struct(def)
411: definition *def;
412: {
413: decl_list *dl;
414: int i, j, size, flag;
415: decl_list *cur, *psav;
416: bas_type *ptr;
417: char *sizestr, *plus;
418: char ptemp[256];
419: int can_inline;
420:
421:
422: if (inline == 0) {
423: for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
424: print_stat(1, &dl->decl);
425: return;
426: }
427: for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
428: if (dl->decl.rel == REL_VECTOR) {
429: f_print(fout, "\t int i;\n");
430: break;
431: }
432: size = 0;
433: can_inline = 0;
434: for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
435: if ((dl->decl.prefix == NULL) &&
436: ((ptr = find_type(dl->decl.type)) != NULL) &&
437: ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) {
438:
439: if (dl->decl.rel == REL_ALIAS)
440: size += ptr->length;
441: else {
442: can_inline = 1;
443: break; /* can be inlined */
444: };
445: } else {
446: if (size >= inline) {
447: can_inline = 1;
448: break; /* can be inlined */
449: }
450: size = 0;
451: }
452: if (size > inline)
453: can_inline = 1;
454:
455: if (can_inline == 0) { /* can not inline, drop back to old mode */
456: for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
457: print_stat(1, &dl->decl);
458: return;
459: };
460:
461:
462:
463:
464: flag = PUT;
465: for (j = 0; j < 2; j++) {
466:
467: if (flag == PUT)
468: f_print(fout, "\n\t if (xdrs->x_op == XDR_ENCODE) {\n");
469: else
470: f_print(fout, "\n \t return (TRUE);\n\t} else if (xdrs->x_op == XDR_DECODE) {\n");
471:
472:
473: i = 0;
474: size = 0;
475: sizestr = NULL;
476: for (dl = def->def.st.decls; dl != NULL; dl = dl->next) { /* xxx */
477:
478: /* now walk down the list and check for basic types */
479: if ((dl->decl.prefix == NULL) && ((ptr = find_type(dl->decl.type)) != NULL) && ((dl->decl.rel == REL_ALIAS) || (dl->decl.rel == REL_VECTOR))) {
480: if (i == 0)
481: cur = dl;
482: i++;
483:
484: if (dl->decl.rel == REL_ALIAS)
485: size += ptr->length;
486: else {
487: /* this is required to handle arrays */
488:
489: if (sizestr == NULL)
490: plus = " ";
491: else
492: plus = "+";
493:
494: if (ptr->length != 1)
495: s_print(ptemp, " %s %s * %d", plus, dl->decl.array_max, ptr->length);
496: else
497: s_print(ptemp, " %s %s ", plus, dl->decl.array_max);
498:
499: /* now concatenate to sizestr !!!! */
500: if (sizestr == NULL)
501: sizestr = strdup(ptemp);
502: else {
503: sizestr = (char *)realloc(sizestr, strlen(sizestr) + strlen(ptemp) + 1);
504: if (sizestr == NULL) {
505:
506: f_print(stderr, "Fatal error : no memory \n");
507: crash();
508: };
509: sizestr = strcat(sizestr, ptemp); /* build up length of
510: * array */
511:
512: }
513: }
514:
515: } else {
516: if (i > 0)
517: if (sizestr == NULL && size < inline) {
518: /* don't expand into inline
519: * code if size < inline */
520: while (cur != dl) {
521: print_stat(1, &cur->decl);
522: cur = cur->next;
523: }
524: } else {
525:
526:
527:
528: /* were already looking at a
529: * xdr_inlineable structure */
530: if (sizestr == NULL)
531: f_print(fout, "\t buf = (long *)XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);",
532: size);
533: else
534: if (size == 0)
535: f_print(fout,
536: "\t buf = (long *)XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);",
537: sizestr);
538: else
539: f_print(fout,
540: "\t buf = (long *)XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);",
541: size, sizestr);
542:
543: f_print(fout, "\n\t if (buf == NULL) {\n");
544:
545: psav = cur;
546: while (cur != dl) {
547: print_stat(2, &cur->decl);
548: cur = cur->next;
549: }
550:
551: f_print(fout, "\n\t }\n\t else {\n");
552:
553: cur = psav;
554: while (cur != dl) {
555: emit_inline(&cur->decl, flag);
556: cur = cur->next;
557: }
558:
559: f_print(fout, "\t }\n");
560: }
561: size = 0;
562: i = 0;
563: sizestr = NULL;
564: print_stat(1, &dl->decl);
565: }
566:
567: }
568: if (i > 0)
569: if (sizestr == NULL && size < inline) {
570: /* don't expand into inline code if size <
571: * inline */
572: while (cur != dl) {
573: print_stat(1, &cur->decl);
574: cur = cur->next;
575: }
576: } else {
577:
578: /* were already looking at a xdr_inlineable
579: * structure */
580: if (sizestr == NULL)
581: f_print(fout, "\t\tbuf = (long *)XDR_INLINE(xdrs,%d * BYTES_PER_XDR_UNIT);",
582: size);
583: else
584: if (size == 0)
585: f_print(fout,
586: "\t\tbuf = (long *)XDR_INLINE(xdrs,%s * BYTES_PER_XDR_UNIT);",
587: sizestr);
588: else
589: f_print(fout,
590: "\t\tbuf = (long *)XDR_INLINE(xdrs,(%d + %s)* BYTES_PER_XDR_UNIT);",
591: size, sizestr);
592:
593: f_print(fout, "\n\t\tif (buf == NULL) {\n");
594:
595: psav = cur;
596: while (cur != NULL) {
597: print_stat(2, &cur->decl);
598: cur = cur->next;
599: }
600: f_print(fout, "\n\t }\n\t else {\n");
601:
602: cur = psav;
603: while (cur != dl) {
604: emit_inline(&cur->decl, flag);
605: cur = cur->next;
606: }
607:
608: f_print(fout, "\t }\n");
609:
610: }
611: flag = GET;
612: }
613: f_print(fout, "\t return(TRUE);\n\t}\n\n");
614:
615: /* now take care of XDR_FREE case */
616:
617: for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
618: print_stat(1, &dl->decl);
619: }
620:
621: static
622: emit_typedef(def)
623: definition *def;
624: {
625: char *prefix = def->def.ty.old_prefix;
626: char *type = def->def.ty.old_type;
627: char *amax = def->def.ty.array_max;
628: relation rel = def->def.ty.rel;
629:
630:
631: print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name);
632: }
633:
634: static
635: print_stat(indent, dec)
636: declaration *dec;
637: int indent;
638: {
639: char *prefix = dec->prefix;
640: char *type = dec->type;
641: char *amax = dec->array_max;
642: relation rel = dec->rel;
643: char name[256];
644:
645: if (isvectordef(type, rel)) {
646: s_print(name, "objp->%s", dec->name);
647: } else {
648: s_print(name, "&objp->%s", dec->name);
649: }
650: print_ifstat(indent, prefix, type, rel, amax, name, dec->name);
651: }
652:
653:
654: char *upcase __P((char *));
655:
656:
657: emit_inline(decl, flag)
658: declaration *decl;
659: int flag;
660: {
661:
662: /*check whether an array or not */
663:
664: switch (decl->rel) {
665: case REL_ALIAS:
666: emit_single_in_line(decl, flag, REL_ALIAS);
667: break;
668: case REL_VECTOR:
669: f_print(fout, "\t\t{ register %s *genp; \n", decl->type);
670: f_print(fout, "\t\t for ( i = 0,genp=objp->%s;\n \t\t\ti < %s; i++){\n\t\t",
671: decl->name, decl->array_max);
672: emit_single_in_line(decl, flag, REL_VECTOR);
673: f_print(fout, "\t\t }\n\t\t };\n");
674:
675: }
676: }
677:
678: emit_single_in_line(decl, flag, rel)
679: declaration *decl;
680: int flag;
681: relation rel;
682: {
683: char *upp_case;
684: int freed = 0;
685:
686:
687:
688: if (flag == PUT)
689: f_print(fout, "\t\t IXDR_PUT_");
690: else
691: if (rel == REL_ALIAS)
692: f_print(fout, "\t\t objp->%s = IXDR_GET_", decl->name);
693: else
694: f_print(fout, "\t\t *genp++ = IXDR_GET_");
695:
696: upp_case = upcase(decl->type);
697:
698: /* hack - XX */
699: if (strcmp(upp_case, "INT") == 0) {
700: free(upp_case);
701: freed = 1;
702: upp_case = "LONG";
703: }
704: if (strcmp(upp_case, "U_INT") == 0) {
705: free(upp_case);
706: freed = 1;
707: upp_case = "U_LONG";
708: }
709: if (flag == PUT)
710: if (rel == REL_ALIAS)
711: f_print(fout, "%s(buf,objp->%s);\n", upp_case, decl->name);
712: else
713: f_print(fout, "%s(buf,*genp++);\n", upp_case);
714:
715: else
716: f_print(fout, "%s(buf);\n", upp_case);
717: if (!freed)
718: free(upp_case);
719:
720: }
721:
722:
723: char *
724: upcase(str)
725: char *str;
726: {
727: char *ptr, *hptr;
728:
729:
730: ptr = (char *) malloc(strlen(str)+1);
731: if (ptr == (char *) NULL) {
732: f_print(stderr, "malloc failed \n");
733: exit(1);
734: };
735:
736: hptr = ptr;
737: while (*str != '\0')
738: *ptr++ = toupper(*str++);
739:
740: *ptr = '\0';
741: return (hptr);
742:
743: }