![[BACK]](/icons/back.gif){kind=icon}
Return to rpc_parse.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_parse.c CVS log | Up to [local] / src / usr.bin / rpcgen |
1.1 deraadt 1: /* $NetBSD: rpc_parse.c,v 1.5 1995/08/29 23:05:55 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_parse.c 1.8 89/02/22 (C) 1987 SMI";
34: #endif
35:
36: /*
37: * rpc_parse.c, Parser for the RPC protocol compiler
38: * Copyright (C) 1987 Sun Microsystems, Inc.
39: */
40: #include <stdio.h>
41: #include <stdlib.h>
42: #include <string.h>
43: #include "rpc/types.h"
44: #include "rpc_scan.h"
45: #include "rpc_parse.h"
46: #include "rpc_util.h"
47:
48: #define ARGNAME "arg"
49:
50: static isdefined __P((definition *));
51: static def_struct __P((definition *));
52: static def_program __P((definition *));
53: static def_enum __P((definition *));
54: static def_const __P((definition *));
55: static def_union __P((definition *));
56: static def_typedef __P((definition *));
57: static get_declaration __P((declaration *, defkind));
58: static get_prog_declaration __P((declaration *, defkind, int));
59: static get_type __P((char **, char **, defkind));
60: static unsigned_dec __P((char **));
61:
62: /*
63: * return the next definition you see
64: */
65: definition *
66: get_definition()
67: {
68: definition *defp;
69: token tok;
70:
71: defp = ALLOC(definition);
72: get_token(&tok);
73: switch (tok.kind) {
74: case TOK_STRUCT:
75: def_struct(defp);
76: break;
77: case TOK_UNION:
78: def_union(defp);
79: break;
80: case TOK_TYPEDEF:
81: def_typedef(defp);
82: break;
83: case TOK_ENUM:
84: def_enum(defp);
85: break;
86: case TOK_PROGRAM:
87: def_program(defp);
88: break;
89: case TOK_CONST:
90: def_const(defp);
91: break;
92: case TOK_EOF:
93: return (NULL);
94: default:
95: error("definition keyword expected");
96: }
97: scan(TOK_SEMICOLON, &tok);
98: isdefined(defp);
99: return (defp);
100: }
101:
102: static
103: isdefined(defp)
104: definition *defp;
105: {
106: STOREVAL(&defined, defp);
107: }
108:
109: static
110: def_struct(defp)
111: definition *defp;
112: {
113: token tok;
114: declaration dec;
115: decl_list *decls;
116: decl_list **tailp;
117:
118: defp->def_kind = DEF_STRUCT;
119:
120: scan(TOK_IDENT, &tok);
121: defp->def_name = tok.str;
122: scan(TOK_LBRACE, &tok);
123: tailp = &defp->def.st.decls;
124: do {
125: get_declaration(&dec, DEF_STRUCT);
126: decls = ALLOC(decl_list);
127: decls->decl = dec;
128: *tailp = decls;
129: tailp = &decls->next;
130: scan(TOK_SEMICOLON, &tok);
131: peek(&tok);
132: } while (tok.kind != TOK_RBRACE);
133: get_token(&tok);
134: *tailp = NULL;
135: }
136:
137: static
138: def_program(defp)
139: definition *defp;
140: {
141: token tok;
142: declaration dec;
143: decl_list *decls;
144: decl_list **tailp;
145: version_list *vlist;
146: version_list **vtailp;
147: proc_list *plist;
148: proc_list **ptailp;
149: int num_args;
150: bool_t isvoid = FALSE; /* whether first argument is void */
151: defp->def_kind = DEF_PROGRAM;
152: scan(TOK_IDENT, &tok);
153: defp->def_name = tok.str;
154: scan(TOK_LBRACE, &tok);
155: vtailp = &defp->def.pr.versions;
156: tailp = &defp->def.st.decls;
157: scan(TOK_VERSION, &tok);
158: do {
159: scan(TOK_IDENT, &tok);
160: vlist = ALLOC(version_list);
161: vlist->vers_name = tok.str;
162: scan(TOK_LBRACE, &tok);
163: ptailp = &vlist->procs;
164: do {
165: /* get result type */
166: plist = ALLOC(proc_list);
167: get_type(&plist->res_prefix, &plist->res_type,
168: DEF_PROGRAM);
169: if (streq(plist->res_type, "opaque")) {
170: error("illegal result type");
171: }
172: scan(TOK_IDENT, &tok);
173: plist->proc_name = tok.str;
174: scan(TOK_LPAREN, &tok);
175: /* get args - first one*/
176: num_args = 1;
177: isvoid = FALSE;
178: /* type of DEF_PROGRAM in the first
179: * get_prog_declaration and DEF_STURCT in the next
180: * allows void as argument if it is the only argument
181: */
182: get_prog_declaration(&dec, DEF_PROGRAM, num_args);
183: if (streq(dec.type, "void"))
184: isvoid = TRUE;
185: decls = ALLOC(decl_list);
186: plist->args.decls = decls;
187: decls->decl = dec;
188: tailp = &decls->next;
189: /* get args */
190: while(peekscan(TOK_COMMA, &tok)) {
191: num_args++;
192: get_prog_declaration(&dec, DEF_STRUCT,
193: num_args);
194: decls = ALLOC(decl_list);
195: decls->decl = dec;
196: *tailp = decls;
197: if (streq(dec.type, "void"))
198: isvoid = TRUE;
199: tailp = &decls->next;
200: }
201: /* multiple arguments are only allowed in newstyle */
202: if( !newstyle && num_args > 1 ) {
203: error("only one argument is allowed" );
204: }
205: if (isvoid && num_args > 1) {
206: error("illegal use of void in program definition");
207: }
208: *tailp = NULL;
209: scan(TOK_RPAREN, &tok);
210: scan(TOK_EQUAL, &tok);
211: scan_num(&tok);
212: scan(TOK_SEMICOLON, &tok);
213: plist->proc_num = tok.str;
214: plist->arg_num = num_args;
215: *ptailp = plist;
216: ptailp = &plist->next;
217: peek(&tok);
218: } while (tok.kind != TOK_RBRACE);
219: *ptailp = NULL;
220: *vtailp = vlist;
221: vtailp = &vlist->next;
222: scan(TOK_RBRACE, &tok);
223: scan(TOK_EQUAL, &tok);
224: scan_num(&tok);
225: vlist->vers_num = tok.str;
226: /* make the argument structure name for each arg*/
227: for(plist = vlist->procs; plist != NULL;
228: plist = plist->next) {
229: plist->args.argname = make_argname(plist->proc_name,
230: vlist->vers_num);
231: /* free the memory ??*/
232: }
233: scan(TOK_SEMICOLON, &tok);
234: scan2(TOK_VERSION, TOK_RBRACE, &tok);
235: } while (tok.kind == TOK_VERSION);
236: scan(TOK_EQUAL, &tok);
237: scan_num(&tok);
238: defp->def.pr.prog_num = tok.str;
239: *vtailp = NULL;
240: }
241:
242:
243: static
244: def_enum(defp)
245: definition *defp;
246: {
247: token tok;
248: enumval_list *elist;
249: enumval_list **tailp;
250:
251: defp->def_kind = DEF_ENUM;
252: scan(TOK_IDENT, &tok);
253: defp->def_name = tok.str;
254: scan(TOK_LBRACE, &tok);
255: tailp = &defp->def.en.vals;
256: do {
257: scan(TOK_IDENT, &tok);
258: elist = ALLOC(enumval_list);
259: elist->name = tok.str;
260: elist->assignment = NULL;
261: scan3(TOK_COMMA, TOK_RBRACE, TOK_EQUAL, &tok);
262: if (tok.kind == TOK_EQUAL) {
263: scan_num(&tok);
264: elist->assignment = tok.str;
265: scan2(TOK_COMMA, TOK_RBRACE, &tok);
266: }
267: *tailp = elist;
268: tailp = &elist->next;
269: } while (tok.kind != TOK_RBRACE);
270: *tailp = NULL;
271: }
272:
273: static
274: def_const(defp)
275: definition *defp;
276: {
277: token tok;
278:
279: defp->def_kind = DEF_CONST;
280: scan(TOK_IDENT, &tok);
281: defp->def_name = tok.str;
282: scan(TOK_EQUAL, &tok);
283: scan2(TOK_IDENT, TOK_STRCONST, &tok);
284: defp->def.co = tok.str;
285: }
286:
287: static
288: def_union(defp)
289: definition *defp;
290: {
291: token tok;
292: declaration dec;
293: case_list *cases,*tcase;
294: case_list **tailp;
295: int flag;
296:
297: defp->def_kind = DEF_UNION;
298: scan(TOK_IDENT, &tok);
299: defp->def_name = tok.str;
300: scan(TOK_SWITCH, &tok);
301: scan(TOK_LPAREN, &tok);
302: get_declaration(&dec, DEF_UNION);
303: defp->def.un.enum_decl = dec;
304: tailp = &defp->def.un.cases;
305: scan(TOK_RPAREN, &tok);
306: scan(TOK_LBRACE, &tok);
307: scan(TOK_CASE, &tok);
308: while (tok.kind == TOK_CASE) {
309: scan2(TOK_IDENT, TOK_CHARCONST, &tok);
310: cases = ALLOC(case_list);
311: cases->case_name = tok.str;
312: scan(TOK_COLON, &tok);
313: /* now peek at next token */
314: flag=0;
315: if(peekscan(TOK_CASE,&tok))
316: {
317:
318: do
319: {
320: scan2(TOK_IDENT, TOK_CHARCONST, &tok);
321: cases->contflag=1; /* continued case statement */
322: *tailp = cases;
323: tailp = &cases->next;
324: cases = ALLOC(case_list);
325: cases->case_name = tok.str;
326: scan(TOK_COLON, &tok);
327:
328: }while(peekscan(TOK_CASE,&tok));
329: }
330: else
331: if(flag)
332: {
333:
334: *tailp = cases;
335: tailp = &cases->next;
336: cases = ALLOC(case_list);
337: };
338:
339: get_declaration(&dec, DEF_UNION);
340: cases->case_decl = dec;
341: cases->contflag=0; /* no continued case statement */
342: *tailp = cases;
343: tailp = &cases->next;
344: scan(TOK_SEMICOLON, &tok);
345:
346: scan3(TOK_CASE, TOK_DEFAULT, TOK_RBRACE, &tok);
347: }
348: *tailp = NULL;
349: if (tok.kind == TOK_DEFAULT) {
350: scan(TOK_COLON, &tok);
351: get_declaration(&dec, DEF_UNION);
352: defp->def.un.default_decl = ALLOC(declaration);
353: *defp->def.un.default_decl = dec;
354: scan(TOK_SEMICOLON, &tok);
355: scan(TOK_RBRACE, &tok);
356: } else {
357: defp->def.un.default_decl = NULL;
358: }
359: }
360:
361: static char* reserved_words[] = {
362: "array",
363: "bytes",
364: "destroy",
365: "free",
366: "getpos",
367: "inline",
368: "pointer",
369: "reference",
370: "setpos",
371: "sizeof",
372: "union",
373: "vector",
374: NULL
375: };
376:
377: static char* reserved_types[] = {
378: "opaque",
379: "string",
380: NULL
381: };
382:
383: /* check that the given name is not one that would eventually result in
384: xdr routines that would conflict with internal XDR routines. */
385: static check_type_name( name, new_type )
386: int new_type;
387: char* name;
388: {
389: int i;
390: char tmp[100];
391:
392: for( i = 0; reserved_words[i] != NULL; i++ ) {
393: if( strcmp( name, reserved_words[i] ) == 0 ) {
394: sprintf(tmp,
395: "illegal (reserved) name :\'%s\' in type definition", name );
396: error(tmp);
397: }
398: }
399: if( new_type ) {
400: for( i = 0; reserved_types[i] != NULL; i++ ) {
401: if( strcmp( name, reserved_types[i] ) == 0 ) {
402: sprintf(tmp,
403: "illegal (reserved) name :\'%s\' in type definition", name );
404: error(tmp);
405: }
406: }
407: }
408: }
409:
410: static
411: def_typedef(defp)
412: definition *defp;
413: {
414: declaration dec;
415:
416: defp->def_kind = DEF_TYPEDEF;
417: get_declaration(&dec, DEF_TYPEDEF);
418: defp->def_name = dec.name;
419: check_type_name( dec.name, 1 );
420: defp->def.ty.old_prefix = dec.prefix;
421: defp->def.ty.old_type = dec.type;
422: defp->def.ty.rel = dec.rel;
423: defp->def.ty.array_max = dec.array_max;
424: }
425:
426: static
427: get_declaration(dec, dkind)
428: declaration *dec;
429: defkind dkind;
430: {
431: token tok;
432:
433: get_type(&dec->prefix, &dec->type, dkind);
434: dec->rel = REL_ALIAS;
435: if (streq(dec->type, "void")) {
436: return;
437: }
438:
439: check_type_name( dec->type, 0 );
440:
441: scan2(TOK_STAR, TOK_IDENT, &tok);
442: if (tok.kind == TOK_STAR) {
443: dec->rel = REL_POINTER;
444: scan(TOK_IDENT, &tok);
445: }
446: dec->name = tok.str;
447: if (peekscan(TOK_LBRACKET, &tok)) {
448: if (dec->rel == REL_POINTER) {
449: error("no array-of-pointer declarations -- use typedef");
450: }
451: dec->rel = REL_VECTOR;
452: scan_num(&tok);
453: dec->array_max = tok.str;
454: scan(TOK_RBRACKET, &tok);
455: } else if (peekscan(TOK_LANGLE, &tok)) {
456: if (dec->rel == REL_POINTER) {
457: error("no array-of-pointer declarations -- use typedef");
458: }
459: dec->rel = REL_ARRAY;
460: if (peekscan(TOK_RANGLE, &tok)) {
461: dec->array_max = "~0"; /* unspecified size, use max */
462: } else {
463: scan_num(&tok);
464: dec->array_max = tok.str;
465: scan(TOK_RANGLE, &tok);
466: }
467: }
468: if (streq(dec->type, "opaque")) {
469: if (dec->rel != REL_ARRAY && dec->rel != REL_VECTOR) {
470: error("array declaration expected");
471: }
472: } else if (streq(dec->type, "string")) {
473: if (dec->rel != REL_ARRAY) {
474: error("variable-length array declaration expected");
475: }
476: }
477: }
478:
479: static
480: get_prog_declaration(dec, dkind, num)
481: declaration *dec;
482: defkind dkind;
483: int num; /* arg number */
484: {
485: token tok;
486: char name[10]; /* argument name */
487:
488: if (dkind == DEF_PROGRAM) {
489: peek(&tok);
490: if (tok.kind == TOK_RPAREN) { /* no arguments */
491: dec->rel = REL_ALIAS;
492: dec->type = "void";
493: dec->prefix = NULL;
494: dec->name = NULL;
495: return;
496: }
497: }
498: get_type(&dec->prefix, &dec->type, dkind);
499: dec->rel = REL_ALIAS;
500: if (peekscan(TOK_IDENT, &tok)) /* optional name of argument */
501: strcpy(name, tok.str);
502: else
503: sprintf(name, "%s%d", ARGNAME, num); /* default name of argument */
504:
505: dec->name = (char *)strdup(name);
506:
507: if (streq(dec->type, "void")) {
508: return;
509: }
510:
511: if (streq(dec->type, "opaque")) {
512: error("opaque -- illegal argument type");
513: }
514: if (peekscan(TOK_STAR, &tok)) {
515: if (streq(dec->type, "string")) {
516: error("pointer to string not allowed in program arguments\n");
517: }
518: dec->rel = REL_POINTER;
519: if (peekscan(TOK_IDENT, &tok)) /* optional name of argument */
520: dec->name = (char *)strdup(tok.str);
521: }
522: if (peekscan(TOK_LANGLE, &tok)) {
523: if (!streq(dec->type, "string")) {
524: error("arrays cannot be declared as arguments to procedures -- use typedef");
525: }
526: dec->rel = REL_ARRAY;
527: if (peekscan(TOK_RANGLE, &tok)) {
528: dec->array_max = "~0";/* unspecified size, use max */
529: } else {
530: scan_num(&tok);
531: dec->array_max = tok.str;
532: scan(TOK_RANGLE, &tok);
533: }
534: }
535: if (streq(dec->type, "string")) {
536: if (dec->rel != REL_ARRAY) { /* .x specifies just string as
537: * type of argument
538: * - make it string<>
539: */
540: dec->rel = REL_ARRAY;
541: dec->array_max = "~0";/* unspecified size, use max */
542: }
543: }
544: }
545:
546:
547:
548: static
549: get_type(prefixp, typep, dkind)
550: char **prefixp;
551: char **typep;
552: defkind dkind;
553: {
554: token tok;
555:
556: *prefixp = NULL;
557: get_token(&tok);
558: switch (tok.kind) {
559: case TOK_IDENT:
560: *typep = tok.str;
561: break;
562: case TOK_STRUCT:
563: case TOK_ENUM:
564: case TOK_UNION:
565: *prefixp = tok.str;
566: scan(TOK_IDENT, &tok);
567: *typep = tok.str;
568: break;
569: case TOK_UNSIGNED:
570: unsigned_dec(typep);
571: break;
572: case TOK_SHORT:
573: *typep = "short";
574: (void) peekscan(TOK_INT, &tok);
575: break;
576: case TOK_LONG:
577: *typep = "long";
578: (void) peekscan(TOK_INT, &tok);
579: break;
580: case TOK_VOID:
581: if (dkind != DEF_UNION && dkind != DEF_PROGRAM) {
582: error("voids allowed only inside union and program definitions with one argument");
583: }
584: *typep = tok.str;
585: break;
586: case TOK_STRING:
587: case TOK_OPAQUE:
588: case TOK_CHAR:
589: case TOK_INT:
590: case TOK_FLOAT:
591: case TOK_DOUBLE:
592: case TOK_BOOL:
593: *typep = tok.str;
594: break;
595: default:
596: error("expected type specifier");
597: }
598: }
599:
600: static
601: unsigned_dec(typep)
602: char **typep;
603: {
604: token tok;
605:
606: peek(&tok);
607: switch (tok.kind) {
608: case TOK_CHAR:
609: get_token(&tok);
610: *typep = "u_char";
611: break;
612: case TOK_SHORT:
613: get_token(&tok);
614: *typep = "u_short";
615: (void) peekscan(TOK_INT, &tok);
616: break;
617: case TOK_LONG:
618: get_token(&tok);
619: *typep = "u_long";
620: (void) peekscan(TOK_INT, &tok);
621: break;
622: case TOK_INT:
623: get_token(&tok);
624: *typep = "u_int";
625: break;
626: default:
627: *typep = "u_int";
628: break;
629: }
630: }