Annotation of src/usr.bin/rpcgen/rpc_cout.c, Revision 1.15
1.15 ! deraadt 1: /* $OpenBSD: rpc_cout.c,v 1.14 2003/03/13 09:09:34 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")) {
1.14 deraadt 357: int len = strlen(def->def_name) + strlen(format) +
358: strlen(cs->name) + 1;
359:
360: object = alloc(len);
1.13 deraadt 361: if (object == NULL) {
362: fprintf(stderr, "Fatal error : no memory\n");
363: crash();
364: }
1.1 deraadt 365: if (isvectordef(cs->type, cs->rel)) {
1.14 deraadt 366: snprintf(object, len, vecformat, def->def_name,
1.1 deraadt 367: cs->name);
368: } else {
1.14 deraadt 369: snprintf(object, len, format, def->def_name,
1.1 deraadt 370: cs->name);
371: }
372: print_ifstat(2, cs->prefix, cs->type, cs->rel, cs->array_max,
373: object, cs->name);
374: free(object);
375: }
1.12 deraadt 376: fprintf(fout, "\t\tbreak;\n");
1.1 deraadt 377: }
378: dflt = def->def.un.default_decl;
379: if (dflt != NULL) {
380: if (!streq(dflt->type, "void")) {
1.14 deraadt 381: int len = strlen(def->def_name) + strlen(format) +
382: strlen(dflt->name) + 1;
383:
1.12 deraadt 384: fprintf(fout, "\tdefault:\n");
1.14 deraadt 385: object = alloc(len);
1.13 deraadt 386: if (object == NULL) {
387: fprintf(stderr, "Fatal error : no memory\n");
388: crash();
389: }
1.1 deraadt 390: if (isvectordef(dflt->type, dflt->rel)) {
1.14 deraadt 391: snprintf(object, len, vecformat, def->def_name,
1.1 deraadt 392: dflt->name);
393: } else {
1.14 deraadt 394: snprintf(object, len, format, def->def_name,
1.1 deraadt 395: dflt->name);
396: }
397:
398: print_ifstat(2, dflt->prefix, dflt->type, dflt->rel,
399: dflt->array_max, object, dflt->name);
400: free(object);
1.12 deraadt 401: fprintf(fout, "\t\tbreak;\n");
1.1 deraadt 402: }
403: } else {
1.12 deraadt 404: fprintf(fout, "\tdefault:\n");
405: fprintf(fout, "\t\treturn (FALSE);\n");
1.1 deraadt 406: }
407:
1.12 deraadt 408: fprintf(fout, "\t}\n");
1.1 deraadt 409: }
410:
1.10 deraadt 411: static void
1.1 deraadt 412: emit_struct(def)
413: definition *def;
414: {
415: decl_list *dl;
416: int i, j, size, flag;
417: decl_list *cur, *psav;
418: bas_type *ptr;
419: char *sizestr, *plus;
420: char ptemp[256];
421: int can_inline;
422:
1.4 deraadt 423: if (doinline == 0) {
1.1 deraadt 424: for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
425: print_stat(1, &dl->decl);
426: return;
427: }
428: for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
429: if (dl->decl.rel == REL_VECTOR) {
1.12 deraadt 430: fprintf(fout, "\tint i;\n");
1.1 deraadt 431: break;
432: }
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 */
456: for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
457: print_stat(1, &dl->decl);
458: return;
1.7 deraadt 459: }
1.1 deraadt 460:
461: flag = PUT;
462: for (j = 0; j < 2; j++) {
463: if (flag == PUT)
1.12 deraadt 464: fprintf(fout, "\n\tif (xdrs->x_op == XDR_ENCODE) {\n");
1.1 deraadt 465: else
1.12 deraadt 466: fprintf(fout, "\t\treturn (TRUE);\n\t} else if (xdrs->x_op == XDR_DECODE) {\n");
1.1 deraadt 467:
468: i = 0;
469: size = 0;
470: sizestr = NULL;
471: for (dl = def->def.st.decls; dl != NULL; dl = dl->next) { /* xxx */
472:
473: /* now walk down the list and check for basic types */
1.10 deraadt 474: if (dl->decl.prefix == NULL &&
475: (ptr = find_type(dl->decl.type)) != NULL &&
476: (dl->decl.rel == REL_ALIAS || dl->decl.rel == REL_VECTOR)) {
1.1 deraadt 477: if (i == 0)
478: cur = dl;
479: i++;
480:
481: if (dl->decl.rel == REL_ALIAS)
482: size += ptr->length;
483: else {
484: /* this is required to handle arrays */
485:
486: if (sizestr == NULL)
487: plus = " ";
488: else
489: plus = "+";
490:
491: if (ptr->length != 1)
1.12 deraadt 492: snprintf(ptemp, sizeof ptemp,
493: " %s %s * %d", plus,
494: dl->decl.array_max,
495: ptr->length);
1.1 deraadt 496: else
1.12 deraadt 497: snprintf(ptemp, sizeof ptemp,
498: " %s %s ", plus,
499: dl->decl.array_max);
1.1 deraadt 500:
501: /* now concatenate to sizestr !!!! */
1.13 deraadt 502: if (sizestr == NULL) {
1.1 deraadt 503: sizestr = strdup(ptemp);
504: if (sizestr == NULL) {
1.13 deraadt 505: fprintf(stderr,
506: "Fatal error : no memory\n");
1.1 deraadt 507: crash();
1.7 deraadt 508: }
1.13 deraadt 509: } else {
1.15 ! deraadt 510: size_t len;
! 511:
! 512: len = strlen(sizestr) +
! 513: strlen(ptemp) + 1;
! 514: sizestr = (char *)realloc(sizestr, len);
1.13 deraadt 515: if (sizestr == NULL) {
516: fprintf(stderr,
517: "Fatal error : no memory\n");
518: crash();
519: }
520: /* build up length of array */
1.15 ! deraadt 521: strlcat(sizestr, ptemp, len);
1.1 deraadt 522: }
523: }
524:
525: } else {
1.10 deraadt 526: if (i > 0) {
1.4 deraadt 527: if (sizestr == NULL && size < doinline) {
1.1 deraadt 528: /* don't expand into inline
1.4 deraadt 529: * code if size < doinline */
1.1 deraadt 530: while (cur != dl) {
1.7 deraadt 531: print_stat(2, &cur->decl);
1.1 deraadt 532: cur = cur->next;
533: }
534: } else {
535: /* were already looking at a
536: * xdr_inlineable structure */
537: if (sizestr == NULL)
1.12 deraadt 538: fprintf(fout, "\t\tbuf = (int32_t *)XDR_INLINE(xdrs, %d * BYTES_PER_XDR_UNIT);",
1.1 deraadt 539: size);
540: else
541: if (size == 0)
1.12 deraadt 542: fprintf(fout,
1.7 deraadt 543: "\t\tbuf = (int32_t *)XDR_INLINE(xdrs, %s * BYTES_PER_XDR_UNIT);",
1.1 deraadt 544: sizestr);
545: else
1.12 deraadt 546: fprintf(fout,
1.7 deraadt 547: "\t\tbuf = (int32_t *)XDR_INLINE(xdrs, (%d + %s)* BYTES_PER_XDR_UNIT);",
1.1 deraadt 548: size, sizestr);
549:
1.12 deraadt 550: fprintf(fout, "\n\t\tif (buf == NULL) {\n");
1.1 deraadt 551:
552: psav = cur;
553: while (cur != dl) {
1.7 deraadt 554: print_stat(3, &cur->decl);
1.1 deraadt 555: cur = cur->next;
556: }
557:
1.12 deraadt 558: fprintf(fout, "\t\t} else {\n");
1.1 deraadt 559:
560: cur = psav;
561: while (cur != dl) {
562: emit_inline(&cur->decl, flag);
563: cur = cur->next;
564: }
565:
1.12 deraadt 566: fprintf(fout, "\t\t}\n");
1.1 deraadt 567: }
1.10 deraadt 568: }
1.1 deraadt 569: size = 0;
570: i = 0;
571: sizestr = NULL;
1.7 deraadt 572: print_stat(2, &dl->decl);
1.1 deraadt 573: }
574:
575: }
1.10 deraadt 576: if (i > 0) {
1.4 deraadt 577: if (sizestr == NULL && size < doinline) {
1.1 deraadt 578: /* don't expand into inline code if size <
1.4 deraadt 579: * doinline */
1.1 deraadt 580: while (cur != dl) {
1.7 deraadt 581: print_stat(2, &cur->decl);
1.1 deraadt 582: cur = cur->next;
583: }
584: } else {
585: /* were already looking at a xdr_inlineable
586: * structure */
587: if (sizestr == NULL)
1.12 deraadt 588: fprintf(fout, "\t\tbuf = (int32_t *)XDR_INLINE(xdrs, %d * BYTES_PER_XDR_UNIT);",
1.1 deraadt 589: size);
590: else
591: if (size == 0)
1.12 deraadt 592: fprintf(fout,
1.7 deraadt 593: "\t\tbuf = (int32_t *)XDR_INLINE(xdrs, %s * BYTES_PER_XDR_UNIT);",
1.1 deraadt 594: sizestr);
595: else
1.12 deraadt 596: fprintf(fout,
1.7 deraadt 597: "\t\tbuf = (int32_t *)XDR_INLINE(xdrs, (%d + %s)* BYTES_PER_XDR_UNIT);",
1.1 deraadt 598: size, sizestr);
599:
1.12 deraadt 600: fprintf(fout, "\n\t\tif (buf == NULL) {\n");
1.1 deraadt 601:
602: psav = cur;
603: while (cur != NULL) {
1.7 deraadt 604: print_stat(3, &cur->decl);
1.1 deraadt 605: cur = cur->next;
606: }
1.12 deraadt 607: fprintf(fout, "\t\t} else {\n");
1.1 deraadt 608:
609: cur = psav;
610: while (cur != dl) {
611: emit_inline(&cur->decl, flag);
612: cur = cur->next;
613: }
614:
1.12 deraadt 615: fprintf(fout, "\t\t}\n");
1.1 deraadt 616:
617: }
1.10 deraadt 618: }
1.1 deraadt 619: flag = GET;
620: }
1.12 deraadt 621: fprintf(fout, "\t\treturn (TRUE);\n\t}\n\n");
1.1 deraadt 622:
623: /* now take care of XDR_FREE case */
624:
625: for (dl = def->def.st.decls; dl != NULL; dl = dl->next)
626: print_stat(1, &dl->decl);
627: }
628:
1.10 deraadt 629: static void
1.1 deraadt 630: emit_typedef(def)
631: definition *def;
632: {
633: char *prefix = def->def.ty.old_prefix;
634: char *type = def->def.ty.old_type;
635: char *amax = def->def.ty.array_max;
636: relation rel = def->def.ty.rel;
637:
638: print_ifstat(1, prefix, type, rel, amax, "objp", def->def_name);
639: }
640:
1.10 deraadt 641: static void
1.1 deraadt 642: print_stat(indent, dec)
643: declaration *dec;
644: int indent;
645: {
646: char *prefix = dec->prefix;
647: char *type = dec->type;
648: char *amax = dec->array_max;
649: relation rel = dec->rel;
650: char name[256];
651:
652: if (isvectordef(type, rel)) {
1.12 deraadt 653: snprintf(name, sizeof name, "objp->%s", dec->name);
1.1 deraadt 654: } else {
1.12 deraadt 655: snprintf(name, sizeof name, "&objp->%s", dec->name);
1.1 deraadt 656: }
657: print_ifstat(indent, prefix, type, rel, amax, name, dec->name);
658: }
659:
1.11 millert 660: char *upcase(char *);
1.1 deraadt 661:
1.10 deraadt 662: void
1.1 deraadt 663: emit_inline(decl, flag)
664: declaration *decl;
665: int flag;
666: {
1.10 deraadt 667: /*check whether an array or not */
1.1 deraadt 668:
669: switch (decl->rel) {
670: case REL_ALIAS:
1.12 deraadt 671: fprintf(fout, "\t");
1.1 deraadt 672: emit_single_in_line(decl, flag, REL_ALIAS);
673: break;
674: case REL_VECTOR:
1.12 deraadt 675: fprintf(fout, "\t\t\t{\n\t\t\t\t%s *genp;\n\n", decl->type);
676: 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 677: decl->name, decl->array_max);
678: emit_single_in_line(decl, flag, REL_VECTOR);
1.12 deraadt 679: fprintf(fout, "\t\t\t\t}\n\t\t\t}\n");
1.1 deraadt 680:
681: }
682: }
683:
1.10 deraadt 684: void
1.1 deraadt 685: emit_single_in_line(decl, flag, rel)
686: declaration *decl;
687: int flag;
688: relation rel;
689: {
690: char *upp_case;
691: int freed = 0;
692:
693: if (flag == PUT)
1.12 deraadt 694: fprintf(fout, "\t\tIXDR_PUT_");
1.1 deraadt 695: else
696: if (rel == REL_ALIAS)
1.12 deraadt 697: fprintf(fout, "\t\tobjp->%s = IXDR_GET_", decl->name);
1.1 deraadt 698: else
1.12 deraadt 699: fprintf(fout, "\t\t*genp++ = IXDR_GET_");
1.1 deraadt 700:
701: upp_case = upcase(decl->type);
702:
703: /* hack - XX */
704: if (strcmp(upp_case, "INT") == 0) {
705: free(upp_case);
706: freed = 1;
707: upp_case = "LONG";
708: }
709: if (strcmp(upp_case, "U_INT") == 0) {
710: free(upp_case);
711: freed = 1;
712: upp_case = "U_LONG";
713: }
714: if (flag == PUT)
715: if (rel == REL_ALIAS)
1.12 deraadt 716: fprintf(fout, "%s(buf, objp->%s);\n", upp_case, decl->name);
1.1 deraadt 717: else
1.12 deraadt 718: fprintf(fout, "%s(buf, *genp++);\n", upp_case);
1.1 deraadt 719:
720: else
1.12 deraadt 721: fprintf(fout, "%s(buf);\n", upp_case);
1.1 deraadt 722: if (!freed)
723: free(upp_case);
724: }
725:
726: char *
727: upcase(str)
728: char *str;
729: {
730: char *ptr, *hptr;
731:
732: ptr = (char *) malloc(strlen(str)+1);
733: if (ptr == (char *) NULL) {
1.12 deraadt 734: fprintf(stderr, "malloc failed\n");
1.1 deraadt 735: exit(1);
1.7 deraadt 736: }
1.1 deraadt 737:
738: hptr = ptr;
739: while (*str != '\0')
740: *ptr++ = toupper(*str++);
741:
742: *ptr = '\0';
743: return (hptr);
744: }