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