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