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