src/rxgen/rpc_parse.c

   1 /* @(#)rpc_parse.c      1.1 87/11/04 3.9 RPCSRC */
   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.
   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  * rpc_parse.c, Parser for the RPC protocol compiler
  33  * Copyright (C) 1987 Sun Microsystems, Inc.
  34  */
  35 #include <afs/param.h>
  36 #include <stdio.h>
  37 #include <ctype.h>
  38 #if defined(AFS_SUN5_ENV) || defined(AFS_NT40_ENV)
  39 #include <string.h>
  40 #if defined(AFS_SUN5_ENV)
  41 #include <strings.h>
  42 #endif
  43 #else
  44 #include <strings.h>
  45 #endif
  46 #include "rpc_util.h"
  47 #include "rpc_scan.h"
  48 #include "rpc_parse.h"
  49
  50
  51 list *proc_defined[MAX_PACKAGES], *special_defined, *typedef_defined, *uniondef_defined;
  52 char *SplitStart = NULL;
  53 char *SplitEnd = NULL;
  54 char *MasterPrefix = NULL;
  55 char *ServerPrefix = "";
  56 char *PackagePrefix[MAX_PACKAGES];
  57 char *PackageStatIndex[MAX_PACKAGES];
  58 int no_of_stat_funcs = 0; /*
  59                                   * current function number in client interface
  60                                   * starts at 0
  61                                   */
  62 int no_of_stat_funcs_header[MAX_PACKAGES]; /*
  63                                          * Total number of functions in client
  64                                          * interface
  65                                          */
  66 int no_of_opcodes[MAX_PACKAGES], master_no_of_opcodes = 0;
  67 int lowest_opcode[MAX_PACKAGES], master_lowest_opcode = 99999;
  68 int highest_opcode[MAX_PACKAGES], master_highest_opcode = 0;
  69 int master_opcodenumber = 99999;
  70 int opcodesnotallowed[MAX_PACKAGES];
  71 int combinepackages = 0;
  72 int PackageIndex = -1;
  73 int PerProcCounter = 0;
  74 int Multi_Init = 0;
  75
  76 /*
  77  * Character arrays to keep list of function names as we process the file
  78  */
  79
  80 char function_list[MAX_PACKAGES]
  81                   [MAX_FUNCTIONS_PER_PACKAGE]
  82                   [MAX_FUNCTION_NAME_LEN];
  83 int function_list_index;
  84
  85 extern int pushed, scan_print;
  86
  87 static isdefined();
  88 static def_struct();
  89 static def_program();
  90 static def_enum();
  91 static def_const();
  92 static def_union();
  93 static def_typedef();
  94 static get_declaration();
  95 static get_type();
  96 static unsigned_dec();
  97 static def_package();
  98 static def_prefix();
  99 static def_startingopcode();
 100 static def_statindex();
 101 static def_split();
 102 static customize_struct();
 103 static def_special();
 104 static check_proc();
 105 static int InvalidConstant();
 106 static opcodenum_is_defined();
 107 static analyze_ProcParams();
 108 static generate_code();
 109 static handle_split_proc();
 110 static do_split();
 111 static hdle_param_tok();
 112 static get1_param_type();
 113 static get_param_type();
 114 static cs_Proc_CodeGeneration();
 115 static cs_ProcName_setup();
 116 static cs_ProcParams_setup();
 117 static cs_ProcMarshallInParams_setup();
 118 static cs_ProcSendPacket_setup();
 119 static cs_ProcUnmarshallOutParams_setup();
 120 static cs_ProcTail_setup();
 121 static ss_Proc_CodeGeneration();
 122 static ss_ProcName_setup();
 123 static ss_ProcParams_setup();
 124 static ss_ProcSpecial_setup();
 125 static ss_ProcUnmarshallInParams_setup();
 126 static ss_ProcCallRealProc_setup();
 127 static ss_ProcMarshallOutParams_setup();
 128 static ss_ProcTail_setup();
 129 static er_ProcDeclExterns_setup();
 130 static er_ProcProcsArray_setup();
 131 static er_ProcMainBody_setup();
 132 static er_HeadofOldStyleProc_setup();
 133 static er_BodyofOldStyleProc_setup();
 134 static proc_er_case();
 135 static er_TailofOldStyleProc_setup();
 136
 137 /*
 138  * return the next definition you see
 139  */
 140 definition *
 141 get_definition()
 142 {
 143         definition *defp;
 144         token tok;
 145
 146         defp = ALLOC(definition);
 147         bzero((char *)defp, sizeof(definition));
 148         get_token(&tok);
 149         switch (tok.kind) {
 150         case TOK_STRUCT:
 151                 def_struct(defp);
 152                 break;
 153         case TOK_UNION:
 154                 def_union(defp);
 155                 break;
 156         case TOK_TYPEDEF:
 157                 def_typedef(defp);
 158                 break;
 159         case TOK_ENUM:
 160                 def_enum(defp);
 161                 break;
 162         case TOK_PROGRAM:
 163                 def_program(defp);
 164                 break;
 165         case TOK_CONST:
 166                 def_const(defp);
 167                 break;
 168         case TOK_EOF:
 169                 return (NULL);
 170                 break;
 171         case TOK_PACKAGE:
 172             def_package(defp);
 173             break;
 174         case TOK_PREFIX:
 175             def_prefix(defp);
 176             break;
 177         case TOK_STATINDEX:
 178             def_statindex(defp);
 179             break;
 180         case TOK_SPECIAL:
 181             {
 182             declaration dec;
 183             def_special(&dec, defp);
 184             break;
 185             }
 186         case TOK_STARTINGOPCODE:
 187             def_startingopcode(defp);
 188             break;
 189         case TOK_CUSTOMIZED:
 190             get_token(&tok);
 191             def_struct(defp);
 192             customize_struct(defp);
 193             break;
 194         case TOK_SPLITPREFIX:
 195             def_split(defp);
 196             break;
 197         case TOK_PROC:
 198             get_token(&tok);
 199             if (tok.kind == TOK_LPAREN) {
 200                 unget_token(&tok);
 201                 check_proc(defp, &tok, 1);
 202             }
 203             else
 204                 check_proc(defp, &tok, 0);
 205             break;
 206         case TOK_IDENT:
 207             check_proc(defp, &tok, 0);
 208             break;
 209         case TOK_LPAREN:
 210             unget_token(&tok);
 211             check_proc(defp, &tok, 1);
 212             break;
 213         default:
 214                 error("definition keyword expected");
 215         }
 216         if (!IsRxgenToken(&tok))
 217         {
 218             scan(TOK_SEMICOLON,&tok);
 219             isdefined(defp);
 220         } else pushed = 0;
 221         return (defp);
 222 }
 223
 224 static
 225 isdefined(defp)
 226         definition *defp;
 227 {
 228         STOREVAL(&defined, defp);
 229 }
 230
 231
 232 static
 233 def_struct(defp)
 234         definition *defp;
 235 {
 236         token tok;
 237         declaration dec;
 238         decl_list *decls;
 239         decl_list **tailp;
 240
 241         defp->def_kind = DEF_STRUCT;
 242
 243         scan(TOK_IDENT, &tok);
 244         defp->def_name = tok.str;
 245         scan(TOK_LBRACE, &tok);
 246         tailp = &defp->def.st.decls;
 247         do {
 248                 get_declaration(&dec, DEF_STRUCT);
 249                 decls = ALLOC(decl_list);
 250                 decls->decl = dec;
 251                 *tailp = decls;
 252                 tailp = &decls->next;
 253                 scan(TOK_SEMICOLON, &tok);
 254                 peek(&tok);
 255         } while (tok.kind != TOK_RBRACE);
 256         get_token(&tok);
 257         *tailp = NULL;
 258 }
 259
 260 static
 261 def_program(defp)
 262         definition *defp;
 263 {
 264         token tok;
 265         version_list *vlist;
 266         version_list **vtailp;
 267         proc_list *plist;
 268         proc_list **ptailp;
 269
 270         defp->def_kind = DEF_PROGRAM;
 271         scan(TOK_IDENT, &tok);
 272         defp->def_name = tok.str;
 273         scan(TOK_LBRACE, &tok);
 274         vtailp = &defp->def.pr.versions;
 275         scan(TOK_VERSION, &tok);
 276         do {
 277                 scan(TOK_IDENT, &tok);
 278                 vlist = ALLOC(version_list);
 279                 vlist->vers_name = tok.str;
 280                 scan(TOK_LBRACE, &tok);
 281                 ptailp = &vlist->procs;
 282                 do {
 283                         plist = ALLOC(proc_list);
 284                         get_type(&plist->res_prefix, &plist->res_type, DEF_PROGRAM);
 285                         if (streq(plist->res_type, "opaque")) {
 286                                 error("illegal result type");
 287                         }
 288                         scan(TOK_IDENT, &tok);
 289                         plist->proc_name = tok.str;
 290                         scan(TOK_LPAREN, &tok);
 291                         get_type(&plist->arg_prefix, &plist->arg_type, DEF_PROGRAM);
 292                         if (streq(plist->arg_type, "opaque")) {
 293                                 error("illegal argument type");
 294                         }
 295                         scan(TOK_RPAREN, &tok);
 296                         scan(TOK_EQUAL, &tok);
 297                         scan_num(&tok);
 298                         scan(TOK_SEMICOLON, &tok);
 299                         plist->proc_num = tok.str;
 300                         *ptailp = plist;
 301                         ptailp = &plist->next;
 302                         peek(&tok);
 303                 } while (tok.kind != TOK_RBRACE);
 304                 *vtailp = vlist;
 305                 vtailp = &vlist->next;
 306                 scan(TOK_RBRACE, &tok);
 307                 scan(TOK_EQUAL, &tok);
 308                 scan_num(&tok);
 309                 vlist->vers_num = tok.str;
 310                 scan(TOK_SEMICOLON, &tok);
 311                 scan2(TOK_VERSION, TOK_RBRACE, &tok);
 312         } while (tok.kind == TOK_VERSION);
 313         scan(TOK_EQUAL, &tok);
 314         scan_num(&tok);
 315         defp->def.pr.prog_num = tok.str;
 316         *vtailp = NULL;
 317 }
 318
 319 static
 320 def_enum(defp)
 321         definition *defp;
 322 {
 323         token tok;
 324         enumval_list *elist;
 325         enumval_list **tailp;
 326
 327         defp->def_kind = DEF_ENUM;
 328         scan(TOK_IDENT, &tok);
 329         defp->def_name = tok.str;
 330         scan(TOK_LBRACE, &tok);
 331         tailp = &defp->def.en.vals;
 332         do {
 333                 scan(TOK_IDENT, &tok);
 334                 elist = ALLOC(enumval_list);
 335                 elist->name = tok.str;
 336                 elist->assignment = NULL;
 337                 scan3(TOK_COMMA, TOK_RBRACE, TOK_EQUAL, &tok);
 338                 if (tok.kind == TOK_EQUAL) {
 339                         scan_num(&tok);
 340                         elist->assignment = tok.str;
 341                         scan2(TOK_COMMA, TOK_RBRACE, &tok);
 342                 }
 343                 *tailp = elist;
 344                 tailp = &elist->next;
 345         } while (tok.kind != TOK_RBRACE);
 346         *tailp = NULL;
 347 }
 348
 349 static
 350 def_const(defp)
 351         definition *defp;
 352 {
 353         token tok;
 354
 355         defp->def_kind = DEF_CONST;
 356         scan(TOK_IDENT, &tok);
 357         defp->def_name = tok.str;
 358         scan(TOK_EQUAL, &tok);
 359         scan2(TOK_IDENT, TOK_STRCONST, &tok);
 360         defp->def.co = tok.str;
 361 }
 362
 363 static
 364 def_union(defp)
 365         definition *defp;
 366 {
 367         token tok;
 368         declaration dec;
 369         case_list *cases;
 370         case_list **tailp;
 371
 372         defp->def_kind = DEF_UNION;
 373         scan(TOK_IDENT, &tok);
 374         defp->def_name = tok.str;
 375         scan(TOK_SWITCH, &tok);
 376         scan(TOK_LPAREN, &tok);
 377         get_declaration(&dec, DEF_UNION);
 378         defp->def.un.enum_decl = dec;
 379         tailp = &defp->def.un.cases;
 380         scan(TOK_RPAREN, &tok);
 381         scan(TOK_LBRACE, &tok);
 382         scan(TOK_CASE, &tok);
 383         while (tok.kind == TOK_CASE) {
 384                 scan(TOK_IDENT, &tok);
 385                 cases = ALLOC(case_list);
 386                 cases->case_name = tok.str;
 387                 scan(TOK_COLON, &tok);
 388                 get_declaration(&dec, DEF_UNION);
 389                 cases->case_decl = dec;
 390                 *tailp = cases;
 391                 tailp = &cases->next;
 392                 scan(TOK_SEMICOLON, &tok);
 393                 scan3(TOK_CASE, TOK_DEFAULT, TOK_RBRACE, &tok);
 394         }
 395         *tailp = NULL;
 396         if (tok.kind == TOK_DEFAULT) {
 397                 scan(TOK_COLON, &tok);
 398                 get_declaration(&dec, DEF_UNION);
 399                 defp->def.un.default_decl = ALLOC(declaration);
 400                 *defp->def.un.default_decl = dec;
 401                 scan(TOK_SEMICOLON, &tok);
 402                 scan(TOK_RBRACE, &tok);
 403         } else {
 404                 defp->def.un.default_decl = NULL;
 405         }
 406 }
 407
 408
 409 static
 410 def_typedef(defp)
 411         definition *defp;
 412 {
 413         declaration dec;
 414
 415         defp->def_kind = DEF_TYPEDEF;
 416         get_declaration(&dec, DEF_TYPEDEF);
 417         defp->def_name = dec.name;
 418         defp->def.ty.old_prefix = dec.prefix;
 419         defp->def.ty.old_type = dec.type;
 420         defp->def.ty.rel = dec.rel;
 421         defp->def.ty.array_max = dec.array_max;
 422 }
 423
 424
 425 static
 426 get_declaration(dec, dkind)
 427         declaration *dec;
 428         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         scan2(TOK_STAR, TOK_IDENT, &tok);
 438         if (tok.kind == TOK_STAR) {
 439                 dec->rel = REL_POINTER;
 440                 scan(TOK_IDENT, &tok);
 441         }
 442         dec->name = tok.str;
 443         if (peekscan(TOK_LBRACKET, &tok)) {
 444                 if (dec->rel == REL_POINTER) {
 445                         error("no array-of-pointer declarations -- use typedef");
 446                 }
 447                 dec->rel = REL_VECTOR;
 448                 scan_num(&tok);
 449                 dec->array_max = tok.str;
 450                 scan(TOK_RBRACKET, &tok);
 451         } else if (peekscan(TOK_LANGLE, &tok)) {
 452                 if (dec->rel == REL_POINTER) {
 453                         error("no array-of-pointer declarations -- use typedef");
 454                 }
 455                 dec->rel = REL_ARRAY;
 456                 if (peekscan(TOK_RANGLE, &tok)) {
 457                         dec->array_max = "~0";  /* unspecified size, use max */
 458                 } else {
 459                         scan_num(&tok);
 460                         dec->array_max = tok.str;
 461                         scan(TOK_RANGLE, &tok);
 462                 }
 463         }
 464         if (streq(dec->type, "opaque")) {
 465                 if (dec->rel != REL_ARRAY && dec->rel != REL_VECTOR) {
 466                         error("array declaration expected");
 467                 }
 468         } else if (streq(dec->type, "string")) {
 469                 if (dec->rel != REL_ARRAY) {
 470                         error(" variable-length array declaration expected");
 471                 }
 472         }
 473 }
 474
 475
 476 static
 477 get_type(prefixp, typep, dkind)
 478         char **prefixp;
 479         char **typep;
 480         defkind dkind;
 481 {
 482         token tok;
 483
 484         *prefixp = NULL;
 485         get_token(&tok);
 486         switch (tok.kind) {
 487         case TOK_IDENT:
 488                 *typep = tok.str;
 489                 break;
 490         case TOK_STRUCT:
 491         case TOK_ENUM:
 492         case TOK_UNION:
 493                 *prefixp = tok.str;
 494                 scan(TOK_IDENT, &tok);
 495                 *typep = tok.str;
 496                 break;
 497         case TOK_UNSIGNED:
 498                 unsigned_dec(typep);
 499                 break;
 500         case TOK_SHORT:
 501                 *typep = "short";
 502                 (void) peekscan(TOK_INT, &tok);
 503                 break;
 504         case TOK_INT32:
 505                 *typep = "afs_int32";
 506                 (void) peekscan(TOK_INT, &tok);
 507                 break;
 508         case TOK_VOID:
 509                 if (dkind != DEF_UNION && dkind != DEF_PROGRAM) {
 510                         error("voids allowed only inside union and program definitions");
 511                 }
 512                 *typep = tok.str;
 513                 break;
 514         case TOK_STRING:
 515         case TOK_OPAQUE:
 516         case TOK_CHAR:
 517         case TOK_INT:
 518         case TOK_FLOAT:
 519         case TOK_DOUBLE:
 520         case TOK_BOOL:
 521         case TOK_AFSUUID:
 522                 *typep = tok.str;
 523                 break;
 524         default:
 525                 error("expected type specifier");
 526         }
 527 }
 528
 529
 530 static
 531 unsigned_dec(typep)
 532         char **typep;
 533 {
 534         token tok;
 535
 536         peek(&tok);
 537         switch (tok.kind) {
 538         case TOK_CHAR:
 539                 get_token(&tok);
 540                 *typep = "u_char";
 541                 break;
 542         case TOK_SHORT:
 543                 get_token(&tok);
 544                 *typep = "u_short";
 545                 (void) peekscan(TOK_INT, &tok);
 546                 break;
 547         case TOK_INT32:
 548                 get_token(&tok);
 549                 *typep = "afs_uint32";
 550                 (void) peekscan(TOK_INT, &tok);
 551                 break;
 552         case TOK_INT:
 553                 get_token(&tok);
 554                 *typep = "u_int";
 555                 break;
 556         default:
 557                 *typep = "u_int";
 558                 break;
 559         }
 560 }
 561
 562
 563 static
 564 def_package(defp)
 565 definition *defp;
 566 {
 567     token tok;
 568
 569     defp->def_kind = DEF_PACKAGE;
 570     scan(TOK_IDENT, &tok);
 571     defp->def_name = tok.str;
 572     no_of_stat_funcs = 0;
 573     if (PackageIndex++ >= MAX_PACKAGES)
 574         error("Exceeded upper limit of package statements\n");
 575     function_list_index = 0;
 576     PackagePrefix[PackageIndex] = tok.str;
 577     if (MasterPrefix == NULL)
 578         MasterPrefix = tok.str;
 579     no_of_opcodes[PackageIndex] = highest_opcode[PackageIndex] = opcodesnotallowed[PackageIndex] = 0;
 580     lowest_opcode[PackageIndex] = 99999;
 581     proc_defined[PackageIndex] = NULL;
 582     PackageStatIndex[PackageIndex] = NULL;
 583 }
 584
 585 static
 586 def_prefix(defp)
 587 definition *defp;
 588 {
 589     token tok;
 590
 591     defp->def_kind = DEF_PREFIX;
 592     scan(TOK_IDENT, &tok);
 593     defp->def_name = tok.str;
 594     ServerPrefix = tok.str;
 595 }
 596
 597 static
 598 def_statindex(defp)
 599 definition *defp;
 600 {
 601     token tok;
 602     char *name;
 603
 604     defp->def_kind = DEF_CONST;
 605     scan_num(&tok);
 606     if (PackageIndex < 0)
 607         error("'statindex' command must follow 'package' command!\n");
 608     if (PackageStatIndex[PackageIndex])
 609         error("Cannot have more then one 'statindex' per package!\n");
 610     if (InvalidConstant(tok.str))
 611         error("Index in 'statindex' command must be a constant!");
 612     name = alloc(strlen(PackagePrefix[PackageIndex])+strlen("STATINDEX")+1);
 613     strcpy(name, PackagePrefix[PackageIndex]);
 614     strcat(name, "STATINDEX");
 615     defp->def_name = name;
 616     defp->def.co = tok.str;
 617     PackageStatIndex[PackageIndex] = name;
 618 }
 619
 620 static
 621 def_startingopcode(defp)
 622 definition *defp;
 623 {
 624     token tok;
 625
 626     defp->def_kind = DEF_STARTINGOPCODE;
 627     scan(TOK_IDENT, &tok);
 628     defp->def_name = tok.str;
 629     if (InvalidConstant(defp->def_name))
 630         error("Opcode in 'startingopcode' command must be a constant!");
 631     lowest_opcode[PackageIndex] = master_lowest_opcode = atoi(tok.str);
 632     if (lowest_opcode[PackageIndex] < 0 || lowest_opcode[PackageIndex] > 99999)
 633         error("startingopcode number is out of bounds (must be >= 0 < 100000)");
 634     master_opcodenumber = lowest_opcode[PackageIndex];
 635     opcodesnotallowed[PackageIndex]=1;
 636 }
 637
 638 static
 639 def_split(defp)
 640 definition *defp;
 641 {
 642     token tok;
 643
 644     defp->def_kind = DEF_SPLITPREFIX;
 645     do {
 646         get_token(&tok);
 647         switch (tok.kind) {
 648                 case TOK_IN:
 649                     scan(TOK_EQUAL, &tok);
 650                     scan(TOK_IDENT, &tok);
 651                     SplitStart = tok.str;
 652                     break;
 653                 case TOK_OUT:
 654                     scan(TOK_EQUAL, &tok);
 655                     scan(TOK_IDENT, &tok);
 656                     SplitEnd = tok.str;
 657                     break;
 658                 case TOK_SEMICOLON:
 659                     break;
 660                 default:
 661                     error("syntax error in the 'splitprefix' line");
 662         }
 663     } while (tok.kind != TOK_SEMICOLON);
 664     if (!SplitStart && !SplitEnd)
 665         error("At least one param should be passed to 'splitprefix' cmd");
 666 }
 667
 668
 669 static
 670 customize_struct(defp)
 671 definition *defp;
 672 {
 673     decl_list *listp;
 674     declaration *dec;
 675     definition *defp1 = ALLOC(definition);
 676     spec_list *specs, **tailp;
 677
 678     defp->def_kind = DEF_CUSTOMIZED;
 679     defp1->def_kind = DEF_SPECIAL;
 680     tailp = &defp1->def.sd.specs;
 681     for (listp = defp->def.st.decls; listp; listp = listp->next) {
 682         dec = &listp->decl;
 683         if (streq(dec->type, "string") || (dec->rel == REL_POINTER)) {
 684             specs = ALLOC(spec_list);
 685             specs->sdef.string_name = dec->name;
 686             specs->sdef.string_value = defp->def_name;
 687             *tailp = specs;
 688             tailp = &specs->next;
 689         }
 690     }
 691     tailp = NULL;
 692     STOREVAL(&special_defined, defp1);
 693 }
 694
 695 static
 696 char *
 697 structname(name)
 698 char *name;
 699 {
 700     char namecontents[150], *pnt, *pnt1;
 701
 702     strcpy(namecontents, name);
 703     pnt = namecontents;
 704     if (!strncmp(pnt, "struct", 6)) pnt += 6;
 705     while (isspace(*pnt)) pnt++;
 706     pnt1 = pnt;
 707     while (*pnt != ' ' && *pnt != '\0') pnt++;
 708     *pnt = '\0';
 709     return pnt1;
 710 }
 711
 712
 713 static
 714 def_special(dec, defp)
 715 declaration *dec;
 716 definition *defp;
 717 {
 718     char *typename;
 719     spec_list *specs, **tailp;
 720     token tok;
 721
 722     defp->def_kind = DEF_SPECIAL;
 723     get_type(&dec->prefix, &dec->type, DEF_SPECIAL);
 724     dec->rel = REL_POINTER;
 725     scan(TOK_IDENT, &tok);
 726     tailp = &defp->def.sd.specs;
 727     do {
 728         specs = ALLOC(spec_list);
 729         specs->sdef.string_name = tok.str;
 730         get_param_type(defp, dec, &specs->sdef.string_value, &typename);
 731         *tailp = specs;
 732         tailp = &specs->next;
 733         scan2(TOK_COMMA, TOK_SEMICOLON, &tok);
 734         if (tok.kind == TOK_SEMICOLON)
 735             break;
 736         get_token(&tok);
 737     } while (tok.kind == TOK_IDENT);
 738     tailp = NULL;
 739     STOREVAL(&special_defined, defp);
 740 }
 741
 742
 743 proc1_list *Proc_list, **Proc_listp;
 744
 745 static
 746 check_proc(defp, tokp, noname)
 747 definition *defp;
 748 token *tokp;
 749 int noname;
 750 {
 751     token tok;
 752     int proc_split = 0;
 753     int proc_multi = 0;
 754
 755     tokp->kind = TOK_PROC;
 756     defp->def_kind = DEF_PROC;
 757     if (noname)
 758         defp->pc.proc_name = "";
 759     else
 760         defp->pc.proc_name = tokp->str;
 761     PerProcCounter = 0;
 762     defp->pc.proc_prefix = alloc(strlen(PackagePrefix[PackageIndex])+1);
 763     strcpy(defp->pc.proc_prefix, PackagePrefix[PackageIndex]);
 764     scan2(TOK_LPAREN, TOK_IDENT, &tok);
 765     defp->pc.proc_serverstub = NULL;
 766     if (tok.kind == TOK_IDENT) {
 767         defp->pc.proc_serverstub = tok.str;
 768         scan(TOK_LPAREN, &tok);
 769     }
 770     analyze_ProcParams(defp, &tok);
 771     defp->pc.proc_opcodenum = -1;
 772     scan4(TOK_SPLIT, TOK_MULTI, TOK_EQUAL, TOK_SEMICOLON, &tok);
 773     if (tok.kind == TOK_MULTI) {
 774         proc_multi = 1;
 775         scan2(TOK_EQUAL, TOK_SEMICOLON, &tok);
 776     }
 777     if (tok.kind  == TOK_SPLIT) {
 778         proc_split = 1;
 779         scan2(TOK_EQUAL, TOK_SEMICOLON, &tok);
 780     }
 781     if (tok.kind == TOK_EQUAL) {
 782         if (opcodesnotallowed[PackageIndex])
 783             error("Opcode assignment isn't allowed here!");
 784         scan_num(&tok);
 785         if (InvalidConstant(tok.str))
 786             error("Illegal Opcode assignment (Must be a constant opcode!)");
 787         if (opcodenum_is_defined(atoi(tok.str)))
 788             error("The opcode number is already used by a previous proc");
 789         defp->pc.proc_opcodename = tok.str;
 790         defp->pc.proc_opcodenum = atoi(tok.str);
 791         if (defp->pc.proc_opcodenum < lowest_opcode[PackageIndex])
 792             lowest_opcode[PackageIndex] = defp->pc.proc_opcodenum;
 793         if (defp->pc.proc_opcodenum < master_lowest_opcode)
 794             master_lowest_opcode = defp->pc.proc_opcodenum;
 795         if (defp->pc.proc_opcodenum > highest_opcode[PackageIndex])
 796             highest_opcode[PackageIndex] = defp->pc.proc_opcodenum;
 797         if (defp->pc.proc_opcodenum > master_highest_opcode)
 798             master_highest_opcode = defp->pc.proc_opcodenum;
 799         scan(TOK_SEMICOLON, &tok);
 800     } else {
 801         if (master_opcodenumber == 99999) master_opcodenumber = 0;
 802         defp->pc.proc_opcodenum = master_opcodenumber++;
 803         if (defp->pc.proc_opcodenum < lowest_opcode[PackageIndex])
 804             lowest_opcode[PackageIndex] = defp->pc.proc_opcodenum;
 805         if (defp->pc.proc_opcodenum > highest_opcode[PackageIndex])
 806             highest_opcode[PackageIndex] = defp->pc.proc_opcodenum;
 807         if (defp->pc.proc_opcodenum > master_highest_opcode)
 808             master_highest_opcode = defp->pc.proc_opcodenum;
 809         opcodesnotallowed[PackageIndex] = 1;    /* force it */
 810     }
 811     no_of_opcodes[PackageIndex]++, master_no_of_opcodes++;
 812     if (proc_multi) {
 813         generate_code(defp, 0, 1);
 814         if (Cflag || cflag) {
 815             generate_code(defp, 1, 1);
 816         }
 817         generate_multi_macros(defp);
 818     } else {
 819         generate_code(defp, proc_split, 0);
 820     }
 821
 822     if (function_list_index >= MAX_FUNCTIONS_PER_INTERFACE) {
 823         error("too many functions in interface, "
 824               "increase MAX_FUNCTIONS_PER_INTERFACE");
 825     }
 826     sprintf(function_list[PackageIndex][function_list_index],
 827             "%s%s%s",
 828             prefix,
 829             PackagePrefix[PackageIndex],
 830             defp->pc.proc_name);
 831
 832     function_list_index++;
 833     no_of_stat_funcs_header[PackageIndex]++;
 834     no_of_stat_funcs++;
 835     *Proc_listp = NULL;
 836 }
 837
 838
 839 #define LEGALNUMS "0123456789"
 840 static int
 841 InvalidConstant(name)
 842 char *name;
 843 {
 844     char *map;
 845     int slen;
 846
 847     map = LEGALNUMS;
 848     slen = strlen(name);
 849     return(slen != strspn(name, map));
 850 }
 851
 852 static
 853 opcodenum_is_defined(opcode_num)
 854 int opcode_num;
 855 {
 856     list *listp;
 857     definition *defp;
 858
 859     for (listp = proc_defined[PackageIndex]; listp != NULL; listp = listp->next) {
 860         defp = (definition *)listp->val;
 861         if (opcode_num == defp->pc.proc_opcodenum)
 862             return 1;
 863     }
 864     return 0;
 865 }
 866
 867
 868 static
 869 analyze_ProcParams(defp, tokp)
 870 definition *defp;
 871 token *tokp;
 872 {
 873     declaration dec;
 874     decl_list *decls, **tailp;
 875
 876     Proc_listp = &defp->pc.plists;
 877     tailp = &defp->def.st.decls;
 878     do {
 879         get_token(tokp);
 880         Proc_list = ALLOC(proc1_list);
 881         bzero((char *)Proc_list, sizeof(proc1_list));
 882         Proc_list->pl.param_flag = 0;
 883         switch (tokp->kind) {
 884             case TOK_IN:
 885                 hdle_param_tok(defp, &dec, tokp, DEF_INPARAM);
 886                 break;
 887             case TOK_OUT:
 888                 hdle_param_tok(defp, &dec, tokp, DEF_OUTPARAM);
 889                 break;
 890             case TOK_INOUT:
 891                 hdle_param_tok(defp, &dec, tokp, DEF_INOUTPARAM);
 892                 break;
 893             case TOK_RPAREN:
 894                 break;
 895             default:
 896                 unget_token(tokp);
 897                 hdle_param_tok(defp, &dec, tokp, DEF_NULL);
 898                 break;
 899         }
 900         *Proc_listp = Proc_list;
 901         Proc_listp = &Proc_list->next;
 902         decls = ALLOC(decl_list);
 903         bzero((char *)decls, sizeof(decl_list));
 904         decls->decl = dec;
 905         *tailp = decls;
 906         tailp = &decls->next;
 907     } while (tokp->kind != TOK_RPAREN);
 908     *tailp = NULL;
 909 }
 910
 911
 912 static
 913 generate_code(defp, proc_split_flag, multi_flag)
 914 definition *defp;
 915 int proc_split_flag;
 916 int multi_flag;
 917 {
 918     if (proc_split_flag)
 919         handle_split_proc(defp, multi_flag);
 920     else {
 921         if (Cflag || cflag) {
 922             cs_Proc_CodeGeneration(defp, 0, "");
 923         }
 924         if (Sflag || cflag)
 925             ss_Proc_CodeGeneration(defp);
 926     }
 927     if (Sflag)
 928         STOREVAL(&proc_defined[PackageIndex], defp);
 929 }
 930
 931
 932 static
 933 handle_split_proc(defp, multi_flag)
 934 definition *defp;
 935 int multi_flag;
 936 {
 937     char *startname = SplitStart, *endname = SplitEnd;
 938     int numofparams;
 939
 940     if (!startname)
 941         startname = "Start";
 942     if (!endname)
 943         endname = "End";
 944     if (Cflag || cflag) {
 945         if (!cflag) {
 946             do_split(defp, OUT, &numofparams, DEF_OUTPARAM, 0);
 947         }
 948         cs_Proc_CodeGeneration(defp, 1, startname);
 949         if (!cflag) {
 950             do_split(defp, OUT, &numofparams, DEF_OUTPARAM, 1);
 951             do_split(defp, IN, &numofparams, DEF_INPARAM, 0);
 952         }
 953         cs_Proc_CodeGeneration(defp, (multi_flag ? 3 : 2), endname);
 954         if (!cflag) {
 955             do_split(defp, IN, &numofparams, DEF_INPARAM, 1);
 956         }
 957     }
 958     if (Sflag || cflag)
 959         ss_Proc_CodeGeneration(defp);
 960 }
 961
 962
 963 static
 964 do_split(defp, direction, numofparams, param_kind, restore_flag)
 965 definition *defp;
 966 int direction, *numofparams, restore_flag;
 967 defkind param_kind;
 968 {
 969     proc1_list *plist;
 970
 971     if (restore_flag) {
 972         defp->pc.paramtypes[direction] = *numofparams;
 973         for (plist = defp->pc.plists; plist; plist = plist->next) {
 974             if (plist->component_kind == DEF_NULL && plist->pl.param_kind == param_kind)
 975                 plist->component_kind = DEF_PARAM;
 976         }
 977     } else {
 978         *numofparams = defp->pc.paramtypes[direction];
 979         defp->pc.paramtypes[direction] = 0;
 980         for (plist = defp->pc.plists; plist; plist = plist->next) {
 981             if (plist->component_kind == DEF_PARAM && plist->pl.param_kind == param_kind)
 982                 plist->component_kind = DEF_NULL;
 983         }
 984     }
 985 }
 986
 987
 988 static
 989 hdle_param_tok(defp, dec, tokp, par_kind)
 990 definition *defp;
 991 declaration *dec;
 992 token *tokp;
 993 defkind par_kind;
 994 {
 995     static defkind last_param_kind = DEF_NULL;
 996
 997     if (par_kind == DEF_NULL)
 998         Proc_list->pl.param_kind = last_param_kind;
 999     else
1000         Proc_list->pl.param_kind = par_kind;
1001     last_param_kind = Proc_list->pl.param_kind;
1002     defp->pc.paramtypes[(int)last_param_kind]++;
1003     Proc_list->component_kind = DEF_PARAM;
1004     Proc_list->code = alloc(250);
1005     Proc_list->scode =  alloc(250);
1006     get_declaration(dec, DEF_PARAM);
1007     Proc_list->pl.param_name = dec->name;
1008     get1_param_type(defp, dec, &Proc_list->pl.param_type);
1009     print_param(dec);
1010     scan2(TOK_COMMA, TOK_RPAREN, tokp);
1011     if (tokp->kind == TOK_COMMA)
1012         peek(tokp);
1013 }
1014
1015
1016 static
1017 get1_param_type(defp, dec, param_type)
1018 definition *defp;
1019 declaration *dec;
1020 char **param_type;
1021 {
1022     char typecontents[100];
1023
1024     if (streq(dec->type,"string")) {
1025         *param_type = "char *";
1026     } else {
1027         if (dec->prefix) {
1028             strcpy(typecontents, dec->prefix);
1029             strcat(typecontents, " ");
1030             strcat(typecontents, dec->type);
1031             strcat(typecontents, " *");
1032         } else if (dec->rel == REL_POINTER) {
1033             strcpy(typecontents, dec->type);
1034             strcat(typecontents, " *");
1035         } else
1036             strcpy(typecontents, dec->type);
1037         *param_type = alloc(100);
1038         strcpy(*param_type, typecontents);
1039     }
1040 }
1041
1042
1043 static
1044 get_param_type(defp, dec, param_type, typename)
1045 definition *defp;
1046 declaration *dec;
1047 char **param_type, **typename;
1048 {
1049     char typecontents[100];
1050
1051     if (streq(dec->type,"string")) {
1052         *typename = "wrapstring";
1053         *param_type = "char *";
1054     } else {
1055         *typename = dec->type;
1056         if (dec->prefix) {
1057             strcpy(typecontents, dec->prefix);
1058             strcat(typecontents, " ");
1059             strcat(typecontents, dec->type);
1060             strcat(typecontents, " *");
1061             dec->rel = REL_POINTER;
1062         } else if (dec->rel == REL_POINTER) {
1063             strcpy(typecontents, dec->type);
1064             strcat(typecontents, " *");
1065         } else
1066             strcpy(typecontents, dec->type);
1067         *param_type = alloc(100);
1068         strcpy(*param_type, typecontents);
1069     }
1070 }
1071
1072
1073 static
1074 hndle_param_tail(defp, dec, tokp, typename)
1075 definition *defp;
1076 declaration *dec;
1077 token *tokp;
1078 char *typename;
1079 {
1080     char *amp;
1081
1082     if (dec->rel == REL_POINTER)
1083         Proc_list->pl.param_flag |= INDIRECT_PARAM;
1084     else
1085         Proc_list->pl.param_flag &= ~INDIRECT_PARAM;
1086     amp = "";
1087     if (!(Proc_list->pl.param_flag & INDIRECT_PARAM))
1088         amp = "&";
1089
1090     sprintf(Proc_list->code, "xdr_%s(&z_xdrs, %s%s)", typename, amp, Proc_list->pl.param_name);
1091     sprintf(Proc_list->scode, "xdr_%s(z_xdrs, &%s)", typename, Proc_list->pl.param_name);
1092     scan2(TOK_COMMA, TOK_RPAREN, tokp);
1093     if (tokp->kind == TOK_COMMA)
1094         peek(tokp);
1095 }
1096
1097
1098 static
1099 cs_Proc_CodeGeneration(defp, split_flag, procheader)
1100 definition *defp;
1101 int split_flag;
1102 char *procheader;
1103 {
1104     defp->can_fail = 0;
1105     cs_ProcName_setup(defp, procheader, split_flag);
1106     if (!cflag) {
1107         cs_ProcParams_setup(defp, split_flag);
1108         cs_ProcMarshallInParams_setup(defp, split_flag);
1109         if (split_flag != 1) {
1110             cs_ProcSendPacket_setup(defp, split_flag);
1111             cs_ProcUnmarshallOutParams_setup(defp);
1112         }
1113         cs_ProcTail_setup(defp, split_flag);
1114     }
1115 }
1116
1117
1118 static
1119 cs_ProcName_setup(defp, procheader, split_flag)
1120 definition *defp;
1121 char *procheader;
1122 int split_flag;
1123 {
1124     proc1_list *plist;
1125
1126     if (!cflag) {
1127         if (split_flag) {
1128             f_print(fout, "int %s%s%s%s(z_call", procheader, prefix, PackagePrefix[PackageIndex], defp->pc.proc_name);
1129         } else {
1130             f_print(fout, "int %s%s%s%s(z_conn", procheader, prefix, PackagePrefix[PackageIndex], defp->pc.proc_name);
1131         }
1132     }
1133     if ((strlen(procheader) + strlen(prefix) + strlen(PackagePrefix[PackageIndex]) + strlen(defp->pc.proc_name)) >= MAX_FUNCTION_NAME_LEN) {
1134         error("function name is too long, increase MAX_FUNCTION_NAME_LEN");
1135     }
1136     if (!cflag) {
1137         for (plist = defp->pc.plists; plist; plist = plist->next) {
1138             if (plist->component_kind == DEF_PARAM) {
1139                 plist->pl.param_flag &= ~PROCESSED_PARAM;
1140                 f_print(fout, ", %s", plist->pl.param_name);
1141             }
1142         }
1143         f_print(fout, ")\n");
1144     }
1145 }
1146
1147
1148 static
1149 cs_ProcParams_setup(defp, split_flag)
1150 definition *defp;
1151 int split_flag;
1152 {
1153     proc1_list *plist, *plist1;
1154
1155     if (!split_flag)
1156         f_print(fout, "\tregister struct rx_connection *z_conn;\n");
1157     if (split_flag) {
1158         f_print(fout, "\tregister struct rx_call *z_call;\n");
1159     }
1160     for (plist = defp->pc.plists; plist; plist = plist->next) {
1161         if (plist->component_kind == DEF_PARAM && !(plist->pl.param_flag & PROCESSED_PARAM)) {
1162             if (plist->pl.param_flag & OUT_STRING) {
1163                 f_print(fout, "\t%s *%s", plist->pl.param_type, plist->pl.param_name);
1164             } else {
1165                 f_print(fout, "\t%s %s", plist->pl.param_type, plist->pl.param_name);
1166             }
1167             plist->pl.param_flag |= PROCESSED_PARAM;
1168             for (plist1 = defp->pc.plists; plist1; plist1 = plist1->next) {
1169                 if ((plist1->component_kind == DEF_PARAM) && streq(plist->pl.param_type, plist1->pl.param_type) && !(plist1->pl.param_flag & PROCESSED_PARAM)) {
1170                     char *star="";
1171                     char *pntr = index(plist1->pl.param_type, '*');
1172                     if (pntr) star = "*";
1173                     if (plist1->pl.param_flag & OUT_STRING) {
1174                         f_print(fout, ", *%s%s", star, plist1->pl.param_name);
1175                     } else {
1176                         f_print(fout, ", %s%s", star, plist1->pl.param_name);
1177                     }
1178                     plist1->pl.param_flag |= PROCESSED_PARAM;
1179                 }
1180             }
1181             f_print(fout, ";\n");
1182         }
1183     }
1184 }
1185
1186
1187 static
1188 cs_ProcMarshallInParams_setup(defp, split_flag)
1189 definition *defp;
1190 int split_flag;
1191 {
1192     int noofparams, i=0;
1193     proc1_list *plist;
1194     decl_list *dl;
1195     int noofallparams = defp->pc.paramtypes[IN] + defp->pc.paramtypes[INOUT] +
1196                         defp->pc.paramtypes[OUT];
1197
1198     f_print(fout, "{\n");
1199     if (!split_flag)
1200         f_print(fout, "\tstruct rx_call *z_call = rx_NewCall(z_conn);\n");
1201     if ((!split_flag) || (split_flag == 1)) {
1202         if (opcodesnotallowed[PackageIndex]) {
1203             f_print(fout, "\tstatic int z_op = %d;\n", defp->pc.proc_opcodenum);
1204         } else {
1205             f_print(fout, "\tstatic int z_op = %s;\n", defp->pc.proc_opcodename);
1206         }
1207     }
1208     f_print(fout, "\tint z_result;\n");
1209     if (!(split_flag > 1) || (noofallparams != 0)) {
1210         f_print(fout, "\tXDR z_xdrs;\n");
1211     }
1212     /*
1213      * Print out client side stat gathering call
1214      */
1215     if (xflag && split_flag != 1) {
1216         f_print(fout, "\tstruct clock __QUEUE, __EXEC;\n");
1217     }
1218
1219     if ((!split_flag) || (split_flag == 1)) {
1220         f_print(fout, "\txdrrx_create(&z_xdrs, z_call, XDR_ENCODE);\n");
1221         f_print(fout, "\n\t/* Marshal the arguments */\n");
1222         f_print(fout, "\tif ((!xdr_int(&z_xdrs, &z_op))");
1223         noofparams = defp->pc.paramtypes[IN] + defp->pc.paramtypes[INOUT];
1224         for (plist = defp->pc.plists, dl=defp->def.st.decls; plist; plist = plist->next, dl = dl->next) {
1225             if (plist->component_kind == DEF_PARAM && (plist->pl.param_kind == DEF_INPARAM || plist->pl.param_kind == DEF_INOUTPARAM)) {
1226                 f_print(fout, "\n\t     || (!%s)", plist->code);
1227                 if (++i == noofparams) {
1228                     f_print(fout, ") {\n\t\tz_result = RXGEN_CC_MARSHAL;\n\t\tgoto fail;\n\t}\n\n");
1229                     defp->can_fail = 1;
1230                 }
1231             }
1232         }
1233         if (!i) {
1234             f_print(fout, ") {\n\t\tz_result = RXGEN_CC_MARSHAL;\n\t\tgoto fail;\n\t}\n\n");
1235             defp->can_fail = 1;
1236         }
1237     }
1238 }
1239
1240
1241 static
1242 cs_ProcSendPacket_setup(defp, split_flag)
1243 definition *defp;
1244 int split_flag;
1245 {
1246     int noofoutparams = defp->pc.paramtypes[INOUT] + defp->pc.paramtypes[OUT];
1247
1248     if (noofoutparams) {
1249             f_print(fout, "\t/* Un-marshal the reply arguments */\n");
1250             if (split_flag) {
1251                 f_print(fout, "\txdrrx_create(&z_xdrs, z_call, XDR_DECODE);\n");
1252             } else {
1253                 f_print(fout, "\tz_xdrs.x_op = XDR_DECODE;\n");
1254             }
1255     }
1256 }
1257
1258
1259 static
1260 cs_ProcUnmarshallOutParams_setup(defp)
1261 definition *defp;
1262 {
1263     int noofparams, i;
1264     proc1_list *plist;
1265     decl_list *dl;
1266
1267     noofparams = defp->pc.paramtypes[INOUT] + defp->pc.paramtypes[OUT];
1268     if (noofparams)
1269         for (plist = defp->pc.plists, dl=defp->def.st.decls,i = 0; plist; plist = plist->next, dl=dl->next) {
1270             if (plist->component_kind == DEF_PARAM && (plist->pl.param_kind == DEF_OUTPARAM || plist->pl.param_kind == DEF_INOUTPARAM)) {
1271                     if (!i) {
1272                         f_print(fout, "\tif ((!%s)", plist->code);
1273                     } else {
1274                         f_print(fout, "\n\t     || (!%s)", plist->code);
1275                     }
1276                 if (++i == noofparams) {
1277                     f_print(fout, ") {\n\t\tz_result = RXGEN_CC_UNMARSHAL;\n\t\tgoto fail;\n\t}\n\n");
1278                     defp->can_fail = 1;
1279                 }
1280             }
1281         }
1282 }
1283
1284
1285 static
1286 cs_ProcTail_setup(defp, split_flag)
1287 definition *defp;
1288 int split_flag;
1289 {
1290     f_print(fout, "\tz_result = RXGEN_SUCCESS;\n");
1291     if (defp->can_fail) {
1292         f_print(fout, "fail:\n");
1293     }
1294     if (!split_flag) {
1295         f_print(fout, "\tz_result = rx_EndCall(z_call, z_result);\n");
1296     }
1297     if (xflag && split_flag != 1) {
1298         f_print(fout, "\tif (rx_enable_stats) {\n");
1299         f_print(fout, "\t    clock_GetTime(&__EXEC);\n");
1300         f_print(fout, "\t    clock_Sub(&__EXEC, &z_call->startTime);\n");
1301         f_print(fout, "\t    __QUEUE = z_call->startTime;\n");
1302         f_print(fout, "\t    clock_Sub(&__QUEUE, &z_call->queueTime);\n");
1303         if (PackageStatIndex[PackageIndex]) {
1304             if (!split_flag) {
1305                 f_print(fout,
1306                     "\t    rx_IncrementTimeAndCount(z_conn->peer, %s,\n",
1307                     PackageStatIndex[PackageIndex]);
1308             } else {
1309                 f_print(fout,
1310                     "\t    rx_IncrementTimeAndCount(z_call->conn->peer, %s,\n",
1311                     PackageStatIndex[PackageIndex]);
1312             }
1313         } else {
1314             if (!split_flag) {
1315                 f_print(fout,
1316                     "\t    rx_IncrementTimeAndCount(z_conn->peer,\n"
1317                     "\t\t(((afs_uint32)(ntohs(z_conn->serviceId) << 16)) \n"
1318                     "\t\t| ((afs_uint32)ntohs(z_conn->peer->port))),\n");
1319             } else {
1320                 f_print(fout,
1321                     "\t    rx_IncrementTimeAndCount(z_call->conn->peer,\n"
1322                     "\t\t(((afs_uint32)(ntohs(z_call->conn->serviceId) << 16)) |\n"
1323                     "\t\t((afs_uint32)ntohs(z_call->conn->peer->port))),\n");
1324             }
1325         }
1326         if (xflag) {
1327             f_print(fout, "\t\t%d, %sNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,\n",
1328                           no_of_stat_funcs,
1329                           PackagePrefix[PackageIndex]);
1330             f_print(fout, "\t\t&z_call->bytesSent, &z_call->bytesRcvd, 1);\n");
1331         }
1332         f_print(fout, "\t}\n\n");
1333     }
1334     f_print(fout, "\treturn z_result;\n}\n\n");
1335 }
1336
1337
1338 static
1339 ss_Proc_CodeGeneration(defp)
1340 definition *defp;
1341 {
1342     int somefrees=0;
1343
1344     defp->can_fail = 0;
1345     ss_ProcName_setup(defp);
1346     if (!cflag) {
1347         ss_ProcParams_setup(defp, &somefrees);
1348         ss_ProcSpecial_setup(defp, &somefrees);
1349         ss_ProcUnmarshallInParams_setup(defp);
1350         ss_ProcCallRealProc_setup(defp);
1351         ss_ProcMarshallOutParams_setup(defp);
1352         ss_ProcTail_setup(defp, somefrees);
1353     }
1354 }
1355
1356
1357 static
1358 ss_ProcName_setup(defp)
1359 definition *defp;
1360 {
1361     proc1_list *plist;
1362
1363     if ((strlen(prefix) + strlen(PackagePrefix[PackageIndex]) + strlen(defp->pc.proc_name)) >= MAX_FUNCTION_NAME_LEN) {
1364         error("function name is too long, increase MAX_FUNCTION_NAME_LEN");
1365     }
1366
1367     if (!cflag) {
1368         f_print(fout, "afs_int32 _%s%s%s(z_call, z_xdrs)\n", prefix, PackagePrefix[PackageIndex], defp->pc.proc_name);
1369         f_print(fout, "\tstruct rx_call *z_call;\n\tXDR *z_xdrs;\n{\n");
1370         f_print(fout, "\t" "afs_int32 z_result;\n");
1371         if (xflag) {
1372             f_print(fout, "\tstruct clock __QUEUE, __EXEC;\n");
1373         }
1374
1375         for (plist = defp->pc.plists; plist; plist = plist->next)
1376             if (plist->component_kind == DEF_PARAM) {
1377                 plist->pl.param_flag &= ~(PROCESSED_PARAM);
1378                 plist->pl.string_name = (char *)0;
1379             }
1380     }
1381 }
1382
1383
1384 static
1385 ss_ProcParams_setup(defp, somefrees)
1386 definition *defp;
1387 int *somefrees;
1388 {
1389     proc1_list *plist, *plist1;
1390     list *listp;
1391     definition *defp1;
1392     int preserve_flag = 0;
1393
1394     for (plist = defp->pc.plists; plist; plist = plist->next) {
1395         if ((plist->component_kind == DEF_PARAM) && !(plist->pl.param_flag & PROCESSED_PARAM)) {
1396             if (plist->pl.param_flag & INDIRECT_PARAM) {
1397                     char pres, *pntr = index(plist->pl.param_type, '*');
1398                     if (pntr){ --pntr; pres = *pntr; *pntr = (char)0; }
1399                     f_print(fout, "\t%s %s", plist->pl.param_type, plist->pl.param_name);
1400                     *pntr = pres;
1401             } else if (index(plist->pl.param_type, '*') == 0) {
1402                 f_print(fout, "\t%s %s", plist->pl.param_type, plist->pl.param_name);
1403             } else {
1404                 plist->pl.param_flag |= FREETHIS_PARAM;
1405                 *somefrees = 1;
1406                 f_print(fout, "\t%s %s=(%s)0", plist->pl.param_type, plist->pl.param_name, plist->pl.param_type);
1407             }
1408             plist->pl.param_flag |= PROCESSED_PARAM;
1409             for (plist1 = defp->pc.plists; plist1; plist1 = plist1->next) {
1410                 if ((plist1->component_kind == DEF_PARAM) && streq(plist->pl.param_type, plist1->pl.param_type) && !(plist1->pl.param_flag & PROCESSED_PARAM)) {
1411                     if (plist1->pl.param_flag & INDIRECT_PARAM) {
1412                             f_print(fout, ", %s", plist1->pl.param_name);
1413                     } else if (index(plist1->pl.param_type, '*') == 0) {
1414                         f_print(fout, ", %s", plist1->pl.param_name);
1415                     } else {
1416                         plist1->pl.param_flag |= FREETHIS_PARAM;
1417                         *somefrees = 1;
1418                         f_print(fout, ", *%s=(%s)0", plist1->pl.param_name, plist1->pl.param_type);
1419                     }
1420                     plist1->pl.param_flag |= PROCESSED_PARAM;
1421                 }
1422             }
1423             f_print(fout, ";\n");
1424         }
1425     }
1426     for (listp = typedef_defined; listp != NULL; listp = listp->next) {
1427         defp1 = (definition *)listp->val;
1428         for (plist=defp->pc.plists; plist; plist=plist->next) {
1429             if (plist->component_kind == DEF_PARAM && (plist->pl.param_kind == DEF_OUTPARAM || plist->pl.param_kind == DEF_INOUTPARAM) && !(plist->pl.param_flag & FREETHIS_PARAM)) {
1430                 if (streq(defp1->def_name, structname(plist->pl.param_type))) {
1431                     switch (defp1->pc.rel) {
1432                         case REL_ARRAY:
1433                         case REL_POINTER:
1434                             break;
1435                     }
1436                 }
1437             }
1438         }
1439     }
1440     fprintf(fout, "\n");
1441 }
1442
1443
1444 static
1445 ss_ProcSpecial_setup(defp, somefrees)
1446 definition *defp;
1447 int *somefrees;
1448 {
1449     proc1_list *plist;
1450     definition *defp1;
1451     list *listp;
1452
1453    for (listp = special_defined; listp != NULL; listp = listp->next) {
1454         defp1 = (definition *)listp->val;
1455         for (plist=defp->pc.plists; plist; plist=plist->next) {
1456             if (plist->component_kind == DEF_PARAM && (plist->pl.param_kind == DEF_INPARAM || plist->pl.param_kind == DEF_INOUTPARAM)) {
1457                 spec_list *spec = defp1->def.sd.specs;
1458                 char string[40];
1459                 strcpy(string, structname(spec->sdef.string_value));
1460                 if (streq(string, structname(plist->pl.param_type))) {
1461                     plist->pl.string_name = spec->sdef.string_name;
1462                     plist->pl.param_flag |= FREETHIS_PARAM;
1463                     *somefrees = 1;
1464                     fprintf(fout, "\n\t%s.%s = 0;", plist->pl.param_name, spec->sdef.string_name);
1465                 }
1466             }
1467         }
1468     }
1469     if (!*somefrees)
1470         fprintf(fout, "\n");
1471     for (listp = typedef_defined; listp != NULL; listp = listp->next) {
1472         defp1 = (definition *)listp->val;
1473         for (plist=defp->pc.plists; plist; plist=plist->next) {
1474             if (plist->component_kind == DEF_PARAM ) {
1475                 if (streq(defp1->def_name, structname(plist->pl.param_type))) {
1476                     plist->pl.param_flag |= FREETHIS_PARAM;
1477                     *somefrees = 1;
1478                     switch (defp1->pc.rel) {
1479                         case REL_ARRAY:
1480                             f_print(fout, "\n\t%s.%s_val = 0;", plist->pl.param_name, defp1->def_name);
1481                             f_print(fout, "\n\t%s.%s_len = 0;", plist->pl.param_name, defp1->def_name);
1482                             plist->pl.string_name = alloc(40);
1483                             s_print(plist->pl.string_name, "%s_val", defp1->def_name);
1484                             break;
1485                         case REL_POINTER:
1486                             f_print(fout, "\n\t%s = 0;", plist->pl.param_name);
1487                             plist->pl.string_name = NULL;
1488                             break;
1489                     }
1490                 }
1491             }
1492         }
1493     }
1494     f_print(fout, "\n");
1495 }
1496
1497
1498 static
1499 ss_ProcUnmarshallInParams_setup(defp)
1500 definition *defp;
1501 {
1502     int noofparams, noofoutparams, i;
1503     proc1_list *plist;
1504
1505     noofparams = defp->pc.paramtypes[IN] + defp->pc.paramtypes[INOUT];
1506     noofoutparams = defp->pc.paramtypes[INOUT] + defp->pc.paramtypes[OUT];
1507     for (plist = defp->pc.plists, i=0; plist; plist = plist->next) {
1508         if (plist->component_kind == DEF_PARAM && (plist->pl.param_kind == DEF_INPARAM || plist->pl.param_kind == DEF_INOUTPARAM)) {
1509                 if (!i) {
1510                     f_print(fout, "\n\tif ((!%s)", (plist->scode ? plist->scode : plist->code));
1511                 } else {
1512                     f_print(fout, "\n\t     || (!%s)", (plist->scode ? plist->scode : plist->code));
1513                 }
1514             if (++i == noofparams) {
1515                 if (!noofoutparams) {
1516                     f_print(fout, ") {\n");
1517                 } else {
1518                     f_print(fout, ") {\n");
1519                 }
1520                 f_print(fout, "\t\tz_result = RXGEN_SS_UNMARSHAL;\n\t\tgoto fail;\n\t}\n\n");
1521                 defp->can_fail = 1;
1522             }
1523         }
1524     }
1525 }
1526
1527
1528 static
1529 ss_ProcCallRealProc_setup(defp)
1530 definition *defp;
1531 {
1532     extern char zflag;
1533     proc1_list *plist;
1534
1535     f_print(fout, "\tz_result = %s%s%s%s(z_call", prefix, ServerPrefix, PackagePrefix[PackageIndex], defp->pc.proc_name);
1536     for (plist = defp->pc.plists; plist; plist = plist->next) {
1537         if (plist->component_kind == DEF_PARAM) {
1538             if (plist->pl.param_flag & INDIRECT_PARAM) {
1539                     f_print(fout, ", &%s", plist->pl.param_name);
1540             } else {
1541                 if (plist->pl.param_flag & OUT_STRING) {
1542                     f_print(fout, ", &%s", plist->pl.param_name);
1543                 } else {
1544                     f_print(fout, ", %s", plist->pl.param_name);
1545                 }
1546             }
1547         }
1548     }
1549     f_print(fout, ");\n");
1550     if (zflag) {
1551         f_print(fout, "\tif (z_result)\n\t\treturn z_result;\n");
1552     }
1553 }
1554
1555
1556 static
1557 ss_ProcMarshallOutParams_setup(defp)
1558 definition *defp;
1559 {
1560     proc1_list *plist;
1561     int noofparams, i;
1562
1563     noofparams = defp->pc.paramtypes[INOUT] + defp->pc.paramtypes[OUT];
1564     if (noofparams)
1565         f_print(fout, "\tz_xdrs->x_op = XDR_ENCODE;\n");
1566     if (noofparams) {
1567         for (plist = defp->pc.plists, i=0; plist; plist = plist->next) {
1568             if (plist->component_kind == DEF_PARAM && (plist->pl.param_kind == DEF_OUTPARAM || plist->pl.param_kind == DEF_INOUTPARAM)) {
1569                 if (!i) {
1570                     f_print(fout, "\tif ((!%s)", (plist->scode ? plist->scode : plist->code));
1571                 } else {
1572                     f_print(fout, "\n\t     || (!%s)", (plist->scode ? plist->scode : plist->code));
1573                 }
1574                 if (++i == noofparams) {
1575                     f_print(fout, ")\n\t\tz_result = RXGEN_SS_MARSHAL;\n");
1576                 }
1577             }
1578         }
1579     }
1580 }
1581
1582
1583 static
1584 ss_ProcTail_setup(defp, somefrees)
1585 definition *defp;
1586 int somefrees;
1587 {
1588     proc1_list *plist;
1589     definition *defp1;
1590     list *listp;
1591     int firsttime = 0;
1592
1593     if (defp->can_fail) {
1594         f_print(fout, "fail:\n");
1595     }
1596     for (plist = defp->pc.plists; plist; plist = plist->next) {
1597         if (plist->component_kind == DEF_PARAM && (plist->pl.param_flag & FREETHIS_PARAM))
1598             somefrees = 1;
1599     }
1600     if (somefrees)
1601         f_print(fout, "\tz_xdrs->x_op = XDR_FREE;\n");
1602     for (plist = defp->pc.plists; plist; plist = plist->next) {
1603         if (plist->component_kind == DEF_PARAM && (plist->pl.param_flag & FREETHIS_PARAM)) {
1604             char *dot = "", *extens = "";
1605             if (plist->pl.string_name) {
1606                 dot = ".";
1607                 extens = plist->pl.string_name;
1608             }
1609             f_print(fout, "\tif (!%s) goto fail1;\n", plist->scode);
1610         }
1611     }
1612     for (listp = typedef_defined; listp != NULL; listp = listp->next) {
1613         defp1 = (definition *)listp->val;
1614         for (plist=defp->pc.plists; plist; plist=plist->next) {
1615             if (plist->component_kind == DEF_PARAM && (plist->pl.param_kind == DEF_OUTPARAM || plist->pl.param_kind == DEF_INOUTPARAM) && !(plist->pl.param_flag & FREETHIS_PARAM)) {
1616                 if (streq(defp1->def_name, structname(plist->pl.param_type))) {
1617                     switch (defp1->pc.rel) {
1618                         case REL_ARRAY:
1619                         case REL_POINTER:
1620                             if (!somefrees && !firsttime) {
1621                                 firsttime = 1;
1622                                 f_print(fout, "\tz_xdrs->x_op = XDR_FREE;\n");
1623                             }
1624                             somefrees = 1;
1625                             f_print(fout, "\tif (!%s) goto fail1;\n", plist->scode);
1626                             break;
1627                     }
1628                 }
1629             }
1630         }
1631     }
1632     for (listp = uniondef_defined; listp != NULL; listp = listp->next) {
1633         defp1 = (definition *)listp->val;
1634         for (plist=defp->pc.plists; plist; plist=plist->next) {
1635             if (plist->component_kind == DEF_PARAM && (plist->pl.param_kind == DEF_OUTPARAM || plist->pl.param_kind == DEF_INOUTPARAM) && !(plist->pl.param_flag & FREETHIS_PARAM)) {
1636                 if (streq(defp1->def_name, structname(plist->pl.param_type))) {
1637                     if (plist->pl.param_flag & INDIRECT_PARAM) {
1638                         if (!somefrees && !firsttime) {
1639                             firsttime = 1;
1640                             f_print(fout, "\tz_xdrs->x_op = XDR_FREE;\n");
1641                         }
1642                         somefrees = 1;
1643                         f_print(fout, "\tif (!%s) goto fail1;\n", plist->scode);
1644                     }
1645                 }
1646             }
1647         }
1648     }
1649
1650     if (xflag) {
1651         f_print(fout, "\tif (rx_enable_stats) {\n");
1652         f_print(fout, "\t    clock_GetTime(&__EXEC);\n");
1653         f_print(fout, "\t    clock_Sub(&__EXEC, &z_call->startTime);\n");
1654         f_print(fout, "\t    __QUEUE = z_call->startTime;\n");
1655         f_print(fout, "\t    clock_Sub(&__QUEUE, &z_call->queueTime);\n");
1656         f_print(fout, "\t    rx_IncrementTimeAndCount(z_call->conn->peer,");
1657         if (PackageStatIndex[PackageIndex]) {
1658             f_print(fout, " %s,\n", PackageStatIndex[PackageIndex]);
1659         } else {
1660             f_print(fout,
1661                 "\n\t\t(((afs_uint32)(ntohs(z_call->conn->serviceId) << 16)) |\n"
1662                 "\t\t((afs_uint32)ntohs(z_call->conn->service->servicePort))),\n");
1663         }
1664         f_print(fout, "\t\t%d, %sNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,\n",
1665                       no_of_stat_funcs,
1666                       PackagePrefix[PackageIndex]);
1667         f_print(fout, "\t\t&z_call->bytesSent, &z_call->bytesRcvd, 0);\n");
1668         f_print(fout, "\t}\n\n");
1669     }
1670
1671     f_print(fout, "\treturn z_result;\n");
1672     if (somefrees) {
1673         f_print(fout, "fail1:\n");
1674
1675         if (xflag) {
1676             f_print(fout, "\tif (rx_enable_stats) {\n");
1677             f_print(fout, "\t    clock_GetTime(&__EXEC);\n");
1678             f_print(fout, "\t    clock_Sub(&__EXEC, &z_call->startTime);\n");
1679             f_print(fout, "\t    __QUEUE = z_call->startTime;\n");
1680             f_print(fout, "\t    clock_Sub(&__QUEUE, &z_call->queueTime);\n");
1681             f_print(fout, "\t    rx_IncrementTimeAndCount(z_call->conn->peer,");
1682             if (PackageStatIndex[PackageIndex]) {
1683                 f_print(fout, " %s,\n", PackageStatIndex[PackageIndex]);
1684             } else {
1685                 f_print(fout,
1686                     "\n\t\t(((afs_uint32)(ntohs(z_call->conn->serviceId) << 16)) |\n"
1687                     "\t\t((afs_uint32)ntohs(z_call->conn->service->servicePort))),\n");
1688             }
1689             f_print(fout, "\t\t%d, %sNO_OF_STAT_FUNCS, &__QUEUE, &__EXEC,\n",
1690                           no_of_stat_funcs,
1691                           PackagePrefix[PackageIndex]);
1692             f_print(fout, "\t\t&z_call->bytesSent, &z_call->bytesRcvd, 0);\n");
1693             f_print(fout, "\t}\n\n");
1694         }
1695
1696         f_print(fout, "\treturn RXGEN_SS_XDRFREE;\n}\n\n");
1697     } else {
1698         f_print(fout, "}\n\n");
1699     }
1700 }
1701
1702
1703 static
1704 opcode_holes_exist()
1705 {
1706     int i;
1707
1708     for (i=lowest_opcode[PackageIndex]; i<highest_opcode[PackageIndex]; i++) {
1709         if (!opcodenum_is_defined(i))
1710             return 1;
1711     }
1712     return 0;
1713 }
1714
1715
1716 int
1717 er_Proc_CodeGeneration()
1718 {
1719     int temp;
1720
1721     temp = PackageIndex;
1722     if (!combinepackages) PackageIndex = 0;
1723     for (; PackageIndex <= temp; PackageIndex++) {
1724         if (proc_defined[PackageIndex] == NULL) continue;
1725         if (combinepackages || opcode_holes_exist()) {
1726             er_HeadofOldStyleProc_setup();
1727             er_BodyofOldStyleProc_setup();
1728             er_TailofOldStyleProc_setup();
1729         } else {
1730             er_ProcDeclExterns_setup();
1731             er_ProcProcsArray_setup();
1732             er_ProcMainBody_setup();
1733         }
1734     }
1735     PackageIndex = temp;
1736 }
1737
1738
1739 static
1740 er_ProcDeclExterns_setup()
1741 {
1742     list *listp;
1743     definition *defp;
1744
1745     f_print(fout, "\n");
1746     for (listp = proc_defined[PackageIndex]; listp != NULL; listp = listp->next) {
1747         defp = (definition *)listp->val;
1748         if (defp->pc.proc_serverstub) {
1749             f_print(fout, "afs_int32 %s();\n", defp->pc.proc_serverstub);
1750         } else {
1751             f_print(fout, "afs_int32 _%s%s%s();\n", prefix, defp->pc.proc_prefix, defp->pc.proc_name);
1752         }
1753     }
1754 }
1755
1756
1757 static
1758 er_ProcProcsArray_setup()
1759 {
1760     list *listp;
1761     definition *defp;
1762
1763     if (listp = proc_defined[PackageIndex]) {
1764         defp = (definition *)listp->val;
1765         if (defp->pc.proc_serverstub){
1766             f_print(fout, "\nstatic afs_int32 (*StubProcsArray%d[])() = {%s", PackageIndex, defp->pc.proc_serverstub);
1767         } else {
1768             f_print(fout, "\nstatic afs_int32 (*StubProcsArray%d[])() = {_%s%s%s", PackageIndex, prefix, defp->pc.proc_prefix, (defp = (definition *)listp->val)->pc.proc_name);
1769         }
1770         listp = listp->next;
1771     }
1772     for (; listp != NULL; listp = listp->next) {
1773         defp = (definition *)listp->val;
1774         if (defp->pc.proc_serverstub) {
1775             f_print(fout, ",%s", defp->pc.proc_serverstub);
1776         } else {
1777             f_print(fout, ", _%s%s%s", prefix, defp->pc.proc_prefix, defp->pc.proc_name);
1778         }
1779     }
1780     f_print(fout, "};\n\n");
1781 }
1782
1783
1784 static
1785 er_ProcMainBody_setup()
1786 {
1787     f_print(fout, "%s%sExecuteRequest(z_call)\n", prefix,  PackagePrefix[PackageIndex]);
1788     f_print(fout, "\tregister struct rx_call *z_call;\n");
1789     f_print(fout, "{\n\tint op;\n");
1790     f_print(fout, "\tXDR z_xdrs;\n");
1791     f_print(fout, "\t" "afs_int32 z_result;\n\n");
1792     f_print(fout, "\txdrrx_create(&z_xdrs, z_call, XDR_DECODE);\n");
1793     f_print(fout, "\tif (!xdr_int(&z_xdrs, &op))\n\t\tz_result = RXGEN_DECODE;\n");
1794     f_print(fout, "\telse if (op < %sLOWEST_OPCODE || op > %sHIGHEST_OPCODE)\n\t\tz_result = RXGEN_OPCODE;\n", PackagePrefix[PackageIndex], PackagePrefix[PackageIndex]);
1795     f_print(fout, "\telse\n\t\tz_result = (*StubProcsArray%d[op - %sLOWEST_OPCODE])(z_call, &z_xdrs);\n", PackageIndex, PackagePrefix[PackageIndex]);
1796     f_print(fout, "\treturn hton_syserr_conv(z_result);\n}\n");
1797 }
1798
1799
1800 static
1801 er_HeadofOldStyleProc_setup()
1802 {
1803     f_print(fout, "\n%s%sExecuteRequest (z_call)\n", prefix, (combinepackages ? MasterPrefix : PackagePrefix[PackageIndex]));
1804     f_print(fout, "\tregister struct rx_call *z_call;\n");
1805     f_print(fout, "{\n");
1806     f_print(fout, "\tint op;\n");
1807     f_print(fout, "\tXDR z_xdrs;\n");
1808     f_print(fout, "\t" "afs_int32 z_result;\n\n");
1809     f_print(fout, "\txdrrx_create(&z_xdrs, z_call, XDR_DECODE);\n");
1810     f_print(fout, "\tz_result = RXGEN_DECODE;\n");
1811     f_print(fout, "\tif (!xdr_int(&z_xdrs, &op)) goto fail;\n");
1812     f_print(fout, "\tswitch (op) {\n");
1813 }
1814
1815 static
1816 er_BodyofOldStyleProc_setup()
1817 {
1818     list *listp;
1819
1820     if (combinepackages) {
1821         int temp = PackageIndex;
1822         for (PackageIndex = 0; PackageIndex <= temp; PackageIndex++) {
1823             for (listp = proc_defined[PackageIndex]; listp != NULL; listp = listp->next)
1824                 proc_er_case((definition *)listp->val);
1825         }
1826         PackageIndex = temp;
1827     } else {
1828     for (listp = proc_defined[PackageIndex]; listp != NULL; listp = listp->next)
1829         proc_er_case((definition *)listp->val);
1830     }
1831 }
1832
1833
1834 static
1835 proc_er_case(defp)
1836 definition *defp;
1837 {
1838     if (opcodesnotallowed[PackageIndex]) {
1839         f_print(fout, "\t\tcase %d: {\n", defp->pc.proc_opcodenum);
1840     } else {
1841         f_print(fout, "\t\tcase %s: {\n", defp->pc.proc_opcodename);
1842     }
1843     if (defp->pc.proc_serverstub) {
1844         f_print(fout, "\t\t\t" "afs_int32 %s();\n", defp->pc.proc_serverstub);
1845         f_print(fout, "\t\t\tz_result = %s(z_call, &z_xdrs);\n", defp->pc.proc_serverstub);
1846     } else {
1847         f_print(fout, "\t\t\t" "afs_int32 _%s%s%s();\n", prefix, defp->pc.proc_prefix, defp->pc.proc_name);
1848         f_print(fout, "\t\t\tz_result = _%s%s%s(z_call, &z_xdrs);\n", prefix, defp->pc.proc_prefix, defp->pc.proc_name);
1849     }
1850     f_print(fout, "\t\t\tbreak;\n\t\t}\n");
1851 }
1852
1853
1854 static
1855 er_TailofOldStyleProc_setup()
1856 {
1857     f_print(fout, "\t\tdefault:\n");
1858     f_print(fout, "\t\t\tz_result = RXGEN_OPCODE;\n");
1859     f_print(fout, "\t\t\tbreak;\n\t}\n");
1860     f_print(fout, "fail:\n");
1861     f_print(fout, "\treturn z_result;\n}\n");
1862 }
1863
1864
1865 int h_opcode_stats()
1866 {
1867     if (combinepackages) {
1868         f_print(fout, "\n/* Opcode-related useful stats for Master package: %s */\n", MasterPrefix);
1869         f_print(fout, "#define %sLOWEST_OPCODE   %d\n", MasterPrefix, master_lowest_opcode);
1870         f_print(fout, "#define %sHIGHEST_OPCODE %d\n", MasterPrefix, master_highest_opcode);
1871         f_print(fout, "#define %sNUMBER_OPCODES %d\n\n", MasterPrefix, master_no_of_opcodes);
1872         if (xflag) {
1873             f_print(fout, "#define %sNO_OF_STAT_FUNCS\t%d\n\n", MasterPrefix, no_of_stat_funcs_header[0]);
1874             f_print(fout, "AFS_RXGEN_EXPORT\n");
1875             f_print(fout, "extern const char *%sfunction_names[];\n\n", MasterPrefix);
1876         }
1877     } else {
1878         int i;
1879         for (i=0; i <= PackageIndex; i++) {
1880             f_print(fout, "\n/* Opcode-related useful stats for package: %s */\n", PackagePrefix[i]);
1881             f_print(fout, "#define %sLOWEST_OPCODE   %d\n", PackagePrefix[i], lowest_opcode[i]);
1882             f_print(fout, "#define %sHIGHEST_OPCODE     %d\n", PackagePrefix[i], highest_opcode[i]);
1883             f_print(fout, "#define %sNUMBER_OPCODES     %d\n\n", PackagePrefix[i], no_of_opcodes[i]);
1884             if (xflag) {
1885                 f_print(fout, "#define %sNO_OF_STAT_FUNCS\t%d\n\n", PackagePrefix[i], no_of_stat_funcs_header[i]);
1886                 f_print(fout, "AFS_RXGEN_EXPORT\n");
1887                 f_print(fout, "extern const char *%sfunction_names[];\n\n", PackagePrefix[i]);
1888             }
1889         }
1890     }
1891 }
1892
1893
1894 int generate_multi_macros(defp)
1895 definition *defp;
1896 {
1897     char *startname = SplitStart, *endname = SplitEnd;
1898     proc1_list *plist;
1899     int numofparams;
1900     int first = 0;
1901
1902     if (!hflag) return;
1903     if (!Multi_Init) {
1904         Multi_Init = 1;
1905         f_print(fout, "\n#include <rx/rx_multi.h>");
1906     }
1907     f_print(fout, "\n#define multi_%s%s(", PackagePrefix[PackageIndex],defp->pc.proc_name);
1908     for (plist = defp->pc.plists; plist; plist = plist->next) {
1909         if (plist->component_kind == DEF_PARAM) {
1910             if (!first) {
1911                 first = 1;
1912                 f_print(fout, "%s", plist->pl.param_name);
1913             } else {
1914                 f_print(fout, ", %s", plist->pl.param_name);
1915             }
1916         }
1917     }
1918     f_print(fout, ") \\\n");
1919     if (!startname) startname = "Start";
1920     if (!endname) endname = "End";
1921     f_print(fout, "\tmulti_Body(%s%s%s(multi_call", startname, PackagePrefix[PackageIndex], defp->pc.proc_name);
1922     do_split(defp, OUT, &numofparams, DEF_OUTPARAM, 0);
1923     for (plist = defp->pc.plists; plist; plist = plist->next) {
1924         if (plist->component_kind == DEF_PARAM)
1925             f_print(fout, ", %s", plist->pl.param_name);
1926     }
1927     do_split(defp, OUT, &numofparams, DEF_OUTPARAM, 1);
1928     f_print(fout, "), %s%s%s(multi_call", endname, PackagePrefix[PackageIndex], defp->pc.proc_name);
1929     do_split(defp, IN, &numofparams, DEF_INPARAM, 0);
1930     for (plist = defp->pc.plists; plist; plist = plist->next) {
1931         if (plist->component_kind == DEF_PARAM) {
1932             f_print(fout, ", %s", plist->pl.param_name);
1933         }
1934     }
1935     do_split(defp, IN, &numofparams, DEF_INPARAM, 1);
1936     f_print(fout, "))\n\n");
1937 }
1938
1939
1940 int
1941 IsRxgenToken(tokp)
1942 token *tokp;
1943 {
1944     if (tokp->kind == TOK_PACKAGE || tokp->kind == TOK_PREFIX ||
1945          tokp->kind == TOK_SPECIAL || tokp->kind == TOK_STARTINGOPCODE ||
1946          tokp->kind == TOK_SPLITPREFIX || tokp->kind == TOK_PROC ||
1947          tokp->kind == TOK_STATINDEX)
1948         return 1;
1949     return 0;
1950 }
1951
1952 int
1953 IsRxgenDefinition(def)
1954 definition *def;
1955 {
1956     if (def->def_kind == DEF_PACKAGE || def->def_kind == DEF_PREFIX || def->def_kind == DEF_SPECIAL || def->def_kind == DEF_STARTINGOPCODE || def->def_kind == DEF_SPLITPREFIX || def->def_kind == DEF_PROC)
1957         return 1;
1958     return 0;
1959 }