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