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