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 30 #if 0 31 #ifndef lint 32 #ident "@(#)rpc_parse.c 1.12 93/07/05 SMI" 33 static char sccsid[] = "@(#)rpc_parse.c 1.8 89/02/22 (C) 1987 SMI"; 34 #endif 35 #endif 36 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD$"); 39 40 /* 41 * rpc_parse.c, Parser for the RPC protocol compiler 42 * Copyright (C) 1987 Sun Microsystems, Inc. 43 */ 44 #include <stdio.h> 45 #include <string.h> 46 #include "rpc/types.h" 47 #include "rpc_parse.h" 48 #include "rpc_scan.h" 49 #include "rpc_util.h" 50 51 #define ARGNAME "arg" 52 53 static void isdefined( definition * ); 54 static void def_struct( definition * ); 55 static void def_program( definition * ); 56 static void def_enum( definition * ); 57 static void def_const( definition * ); 58 static void def_union( definition * ); 59 static void def_typedef( definition * ); 60 static void get_declaration( declaration *, defkind ); 61 static void get_prog_declaration( declaration *, defkind, int ); 62 static void get_type(const char **, const char **, defkind); 63 static void unsigned_dec(const char ** ); 64 65 /* 66 * return the next definition you see 67 */ 68 definition * 69 get_definition(void) 70 { 71 definition *defp; 72 token tok; 73 74 defp = XALLOC(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(definition *defp) 107 { 108 STOREVAL(&defined, defp); 109 } 110 111 static void 112 def_struct(definition *defp) 113 { 114 token tok; 115 declaration dec; 116 decl_list *decls; 117 decl_list **tailp; 118 119 defp->def_kind = DEF_STRUCT; 120 121 scan(TOK_IDENT, &tok); 122 defp->def_name = tok.str; 123 scan(TOK_LBRACE, &tok); 124 tailp = &defp->def.st.decls; 125 do { 126 get_declaration(&dec, DEF_STRUCT); 127 decls = XALLOC(decl_list); 128 decls->decl = dec; 129 *tailp = decls; 130 tailp = &decls->next; 131 scan(TOK_SEMICOLON, &tok); 132 peek(&tok); 133 } while (tok.kind != TOK_RBRACE); 134 get_token(&tok); 135 *tailp = NULL; 136 } 137 138 static void 139 def_program(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 = XALLOC(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 = XALLOC(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 /* 179 * type of DEF_PROGRAM in the first 180 * get_prog_declaration and DEF_STURCT in the next 181 * allows void as argument if it is the only argument 182 */ 183 get_prog_declaration(&dec, DEF_PROGRAM, num_args); 184 if (streq(dec.type, "void")) 185 isvoid = TRUE; 186 decls = XALLOC(decl_list); 187 plist->args.decls = decls; 188 decls->decl = dec; 189 tailp = &decls->next; 190 /* get args */ 191 while (peekscan(TOK_COMMA, &tok)) { 192 num_args++; 193 get_prog_declaration(&dec, DEF_STRUCT, 194 num_args); 195 decls = XALLOC(decl_list); 196 decls->decl = dec; 197 *tailp = decls; 198 if (streq(dec.type, "void")) 199 isvoid = TRUE; 200 tailp = &decls->next; 201 } 202 /* multiple arguments are only allowed in newstyle */ 203 if (!newstyle && num_args > 1) { 204 error("only one argument is allowed"); 205 } 206 if (isvoid && num_args > 1) { 207 error("illegal use of void in program definition"); 208 } 209 *tailp = NULL; 210 scan(TOK_RPAREN, &tok); 211 scan(TOK_EQUAL, &tok); 212 scan_num(&tok); 213 scan(TOK_SEMICOLON, &tok); 214 plist->proc_num = tok.str; 215 plist->arg_num = num_args; 216 *ptailp = plist; 217 ptailp = &plist->next; 218 peek(&tok); 219 } while (tok.kind != TOK_RBRACE); 220 *ptailp = NULL; 221 *vtailp = vlist; 222 vtailp = &vlist->next; 223 scan(TOK_RBRACE, &tok); 224 scan(TOK_EQUAL, &tok); 225 scan_num(&tok); 226 vlist->vers_num = tok.str; 227 /* make the argument structure name for each arg */ 228 for (plist = vlist->procs; plist != NULL; 229 plist = plist->next) { 230 plist->args.argname = make_argname(plist->proc_name, 231 vlist->vers_num); 232 /* free the memory ?? */ 233 } 234 scan(TOK_SEMICOLON, &tok); 235 scan2(TOK_VERSION, TOK_RBRACE, &tok); 236 } while (tok.kind == TOK_VERSION); 237 scan(TOK_EQUAL, &tok); 238 scan_num(&tok); 239 defp->def.pr.prog_num = tok.str; 240 *vtailp = NULL; 241 } 242 243 244 static void 245 def_enum(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 = XALLOC(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 void 274 def_const(definition *defp) 275 { 276 token tok; 277 278 defp->def_kind = DEF_CONST; 279 scan(TOK_IDENT, &tok); 280 defp->def_name = tok.str; 281 scan(TOK_EQUAL, &tok); 282 scan2(TOK_IDENT, TOK_STRCONST, &tok); 283 defp->def.co = tok.str; 284 } 285 286 static void 287 def_union(definition *defp) 288 { 289 token tok; 290 declaration dec; 291 case_list *cases; 292 case_list **tailp; 293 int flag; 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 = XALLOC(case_list); 309 cases->case_name = tok.str; 310 scan(TOK_COLON, &tok); 311 /* now peek at next token */ 312 flag = 0; 313 if (peekscan(TOK_CASE, &tok)){ 314 do { 315 scan2(TOK_IDENT, TOK_CHARCONST, &tok); 316 cases->contflag = 1; 317 /* continued case statement */ 318 *tailp = cases; 319 tailp = &cases->next; 320 cases = XALLOC(case_list); 321 cases->case_name = tok.str; 322 scan(TOK_COLON, &tok); 323 } while (peekscan(TOK_CASE, &tok)); 324 } 325 else 326 if (flag) 327 { 328 329 *tailp = cases; 330 tailp = &cases->next; 331 cases = XALLOC(case_list); 332 } 333 334 get_declaration(&dec, DEF_UNION); 335 cases->case_decl = dec; 336 cases->contflag = 0; /* no continued case statement */ 337 *tailp = cases; 338 tailp = &cases->next; 339 scan(TOK_SEMICOLON, &tok); 340 341 scan3(TOK_CASE, TOK_DEFAULT, TOK_RBRACE, &tok); 342 } 343 *tailp = NULL; 344 if (tok.kind == TOK_DEFAULT) { 345 scan(TOK_COLON, &tok); 346 get_declaration(&dec, DEF_UNION); 347 defp->def.un.default_decl = XALLOC(declaration); 348 *defp->def.un.default_decl = dec; 349 scan(TOK_SEMICOLON, &tok); 350 scan(TOK_RBRACE, &tok); 351 } else { 352 defp->def.un.default_decl = NULL; 353 } 354 } 355 356 static const char *reserved_words[] = 357 { 358 "array", 359 "bytes", 360 "destroy", 361 "free", 362 "getpos", 363 "inline", 364 "pointer", 365 "reference", 366 "setpos", 367 "sizeof", 368 "union", 369 "vector", 370 NULL 371 }; 372 373 static const char *reserved_types[] = 374 { 375 "opaque", 376 "string", 377 NULL 378 }; 379 380 /* 381 * check that the given name is not one that would eventually result in 382 * xdr routines that would conflict with internal XDR routines. 383 */ 384 static void 385 check_type_name(const char *name, int new_type) 386 { 387 int i; 388 char tmp[100]; 389 390 for (i = 0; reserved_words[i] != NULL; i++) { 391 if (strcmp(name, reserved_words[i]) == 0) { 392 sprintf(tmp, 393 "illegal (reserved) name :\'%s\' in type definition", 394 name); 395 error(tmp); 396 } 397 } 398 if (new_type) { 399 for (i = 0; reserved_types[i] != NULL; i++) { 400 if (strcmp(name, reserved_types[i]) == 0) { 401 sprintf(tmp, 402 "illegal (reserved) name :\'%s\' in type definition", 403 name); 404 error(tmp); 405 } 406 } 407 } 408 } 409 410 411 412 static void 413 def_typedef(definition *defp) 414 { 415 declaration dec; 416 417 defp->def_kind = DEF_TYPEDEF; 418 get_declaration(&dec, DEF_TYPEDEF); 419 defp->def_name = dec.name; 420 check_type_name(dec.name, 1); 421 defp->def.ty.old_prefix = dec.prefix; 422 defp->def.ty.old_type = dec.type; 423 defp->def.ty.rel = dec.rel; 424 defp->def.ty.array_max = dec.array_max; 425 } 426 427 static void 428 get_declaration(declaration *dec, defkind dkind) 429 { 430 token tok; 431 432 get_type(&dec->prefix, &dec->type, dkind); 433 dec->rel = REL_ALIAS; 434 if (streq(dec->type, "void")) { 435 return; 436 } 437 438 check_type_name(dec->type, 0); 439 scan2(TOK_STAR, TOK_IDENT, &tok); 440 if (tok.kind == TOK_STAR) { 441 dec->rel = REL_POINTER; 442 scan(TOK_IDENT, &tok); 443 } 444 dec->name = tok.str; 445 if (peekscan(TOK_LBRACKET, &tok)) { 446 if (dec->rel == REL_POINTER) { 447 error("no array-of-pointer declarations -- use typedef"); 448 } 449 dec->rel = REL_VECTOR; 450 scan_num(&tok); 451 dec->array_max = tok.str; 452 scan(TOK_RBRACKET, &tok); 453 } else if (peekscan(TOK_LANGLE, &tok)) { 454 if (dec->rel == REL_POINTER) { 455 error("no array-of-pointer declarations -- use typedef"); 456 } 457 dec->rel = REL_ARRAY; 458 if (peekscan(TOK_RANGLE, &tok)) { 459 dec->array_max = "~0"; /* unspecified size, use max */ 460 } else { 461 scan_num(&tok); 462 dec->array_max = tok.str; 463 scan(TOK_RANGLE, &tok); 464 } 465 } 466 if (streq(dec->type, "opaque")) { 467 if (dec->rel != REL_ARRAY && dec->rel != REL_VECTOR) { 468 error("array declaration expected"); 469 } 470 } else if (streq(dec->type, "string")) { 471 if (dec->rel != REL_ARRAY) { 472 error("variable-length array declaration expected"); 473 } 474 } 475 } 476 477 478 static void 479 get_prog_declaration(declaration *dec, defkind dkind, int num) 480 { 481 token tok; 482 char name[10]; /* argument name */ 483 484 if (dkind == DEF_PROGRAM) { 485 peek(&tok); 486 if (tok.kind == TOK_RPAREN) { /* no arguments */ 487 dec->rel = REL_ALIAS; 488 dec->type = "void"; 489 dec->prefix = NULL; 490 dec->name = NULL; 491 return; 492 } 493 } 494 get_type(&dec->prefix, &dec->type, dkind); 495 dec->rel = REL_ALIAS; 496 if (peekscan(TOK_IDENT, &tok)) /* optional name of argument */ 497 strcpy(name, tok.str); 498 else 499 sprintf(name, "%s%d", ARGNAME, num); 500 /* default name of argument */ 501 502 dec->name = (char *) xstrdup(name); 503 if (streq(dec->type, "void")) { 504 return; 505 } 506 507 if (streq(dec->type, "opaque")) { 508 error("opaque -- illegal argument type"); 509 } 510 if (peekscan(TOK_STAR, &tok)) { 511 if (streq(dec->type, "string")) { 512 error("pointer to string not allowed in program arguments"); 513 } 514 dec->rel = REL_POINTER; 515 if (peekscan(TOK_IDENT, &tok)) { 516 /* optional name of argument */ 517 dec->name = xstrdup(tok.str); 518 } 519 } 520 if (peekscan(TOK_LANGLE, &tok)) { 521 if (!streq(dec->type, "string")) { 522 error("arrays cannot be declared as arguments to procedures -- use typedef"); 523 } 524 dec->rel = REL_ARRAY; 525 if (peekscan(TOK_RANGLE, &tok)) { 526 dec->array_max = "~0"; 527 /* unspecified size, use max */ 528 } else { 529 scan_num(&tok); 530 dec->array_max = tok.str; 531 scan(TOK_RANGLE, &tok); 532 } 533 } 534 if (streq(dec->type, "string")) { 535 if (dec->rel != REL_ARRAY) { 536 /* 537 * .x specifies just string as 538 * type of argument 539 * - make it string<> 540 */ 541 dec->rel = REL_ARRAY; 542 dec->array_max = "~0"; /* unspecified size, use max */ 543 } 544 } 545 } 546 547 548 549 static void 550 get_type(const char **prefixp, const char **typep, defkind dkind) 551 { 552 token tok; 553 554 *prefixp = NULL; 555 get_token(&tok); 556 switch (tok.kind) { 557 case TOK_IDENT: 558 *typep = tok.str; 559 break; 560 case TOK_STRUCT: 561 case TOK_ENUM: 562 case TOK_UNION: 563 *prefixp = tok.str; 564 scan(TOK_IDENT, &tok); 565 *typep = tok.str; 566 break; 567 case TOK_UNSIGNED: 568 unsigned_dec(typep); 569 break; 570 case TOK_SHORT: 571 *typep = "short"; 572 (void) peekscan(TOK_INT, &tok); 573 break; 574 case TOK_LONG: 575 *typep = "long"; 576 (void) peekscan(TOK_INT, &tok); 577 break; 578 case TOK_HYPER: 579 *typep = "int64_t"; 580 (void) peekscan(TOK_INT, &tok); 581 break; 582 583 case TOK_VOID: 584 if (dkind != DEF_UNION && dkind != DEF_PROGRAM) { 585 error("voids allowed only inside union and program definitions with one argument"); 586 } 587 *typep = tok.str; 588 break; 589 case TOK_STRING: 590 case TOK_OPAQUE: 591 case TOK_CHAR: 592 case TOK_INT: 593 case TOK_FLOAT: 594 case TOK_DOUBLE: 595 case TOK_BOOL: 596 case TOK_QUAD: 597 *typep = tok.str; 598 break; 599 default: 600 error("expected type specifier"); 601 } 602 } 603 604 static void 605 unsigned_dec(const char **typep) 606 { 607 token tok; 608 609 peek(&tok); 610 switch (tok.kind) { 611 case TOK_CHAR: 612 get_token(&tok); 613 *typep = "u_char"; 614 break; 615 case TOK_SHORT: 616 get_token(&tok); 617 *typep = "u_short"; 618 (void) peekscan(TOK_INT, &tok); 619 break; 620 case TOK_LONG: 621 get_token(&tok); 622 *typep = "u_long"; 623 (void) peekscan(TOK_INT, &tok); 624 break; 625 case TOK_HYPER: 626 get_token(&tok); 627 *typep = "u_int64_t"; 628 629 (void) peekscan(TOK_INT, &tok); 630 break; 631 case TOK_INT: 632 get_token(&tok); 633 *typep = "u_int"; 634 break; 635 default: 636 *typep = "u_int"; 637 break; 638 } 639 } 640