src/rxgen/rpc_main.c

   1 /* @(#)rpc_main.c       1.4 87/11/30 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_main.c, Top level of the RPC protocol compiler.
  33  * Copyright (C) 1987, Sun Microsystems, Inc.
  34  */
  35
  36 #include <afsconfig.h>
  37 #include <afs/param.h>
  38
  39 RCSID("$Header$");
  40
  41 #include <limits.h>
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <ctype.h>
  45 #ifdef HAVE_STRING_H
  46 #include <string.h>
  47 #else
  48 #ifdef HAVE_STRINGS_H
  49 #include <strings.h>
  50 #endif
  51 #endif
  52 #ifdef HAVE_SIGNAL_H
  53 #include <signal.h>
  54 #endif
  55 #ifdef HAVE_SYS_FILE_H
  56 #include <sys/file.h>
  57 #endif
  58 #include "rpc_util.h"
  59 #include "rpc_parse.h"
  60 #include "rpc_scan.h"
  61
  62 #define EXTEND  1               /* alias for TRUE */
  63
  64 struct commandline {
  65         int cflag;
  66         int hflag;
  67         int lflag;
  68         int sflag;
  69         int mflag;
  70         int Cflag;
  71         int Sflag;
  72         int rflag;
  73         int kflag;
  74         int pflag;
  75         int dflag;
  76         int xflag;
  77         int yflag;
  78         char *infile;
  79         char *outfile;
  80 };
  81
  82 #define MAXCPPARGS      256     /* maximum number of arguments to cpp */
  83 #define MAXCMDLINE      1024    /* MAX chars on a single  cmd line */
  84
  85 char *prefix="";
  86 static char *IncludeDir[MAXCPPARGS];
  87 int nincludes = 0;
  88 char *OutFileFlag="";
  89 char OutFile[256];
  90 char Sflag = 0, Cflag = 0, hflag = 0, cflag = 0, kflag = 0;
  91 char zflag = 0; /* If set, abort server stub if rpc call returns non-zero */
  92 char xflag = 0; /* if set, add stats code to stubs */
  93 char yflag = 0; /* if set, only emit function name arrays to xdr file */
  94 int debug = 0;
  95 static char *cmdname;
  96 #ifdef  AFS_SUN5_ENV
  97 static char CPP[] = "/usr/ccs/lib/cpp";
  98 #elif defined(AFS_FBSD_ENV)
  99 static char CPP[] = "/usr/bin/cpp";
 100 #elif defined(AFS_NT40_ENV)
 101 static char CPP[MAXCMDLINE];
 102 #elif defined(AFS_DARWIN_ENV)
 103 static char CPP[] = "cc -E";
 104 #else
 105 static char CPP[] = "/lib/cpp";
 106 #endif
 107 static char CPPFLAGS[] = "-C";
 108 static char *allv[] = {
 109         "rpcgen", "-s", "udp", "-s", "tcp",
 110 };
 111
 112 #ifdef  AFS_ALPHA_ENV
 113 /*
 114  * Running "cpp" directly on DEC OSF/1 does not define anything; the "cc"
 115  * driver is responsible.  To compensate (and allow for other definitions
 116  * which should always be passed to "cpp"), place definitions which whould
 117  * always be passed to "rxgen" in this table.
 118  */
 119 static char *XTRA_CPPFLAGS[] = {
 120 #ifdef  __alpha
 121     "-D__alpha",
 122 #endif  /* __alpha */
 123 #ifdef  OSF
 124     "-DOSF",
 125 #endif  /* OSF */
 126     NULL
 127 };
 128 #endif
 129
 130 static int c_output();
 131 static int h_output();
 132 static int s_output();
 133 static int l_output();
 134 static int do_registers();
 135 static int parseargs();
 136
 137 static int allc = sizeof(allv)/sizeof(allv[0]);
 138
 139 #include "AFS_component_version_number.c"
 140
 141 int
 142 main(argc, argv)
 143         int argc;
 144         char *argv[];
 145
 146 {
 147         struct commandline cmd;
 148         char *ep;
 149
 150         /* initialize CPP with the correct pre-processor on NT */
 151 #ifdef AFS_NT40_ENV
 152         ep = getenv("RXGEN_CPPCMD");
 153         if (ep)
 154           strcpy(CPP, ep);
 155         else
 156           strcpy(CPP, "cl /EP /C /nologo");
 157 #endif
 158 #ifdef  AFS_AIX32_ENV
 159         /*
 160          * The following signal action for AIX is necessary so that in case of a
 161          * crash (i.e. core is generated) we can include the user's data section
 162          * in the core dump. Unfortunately, by default, only a partial core is
 163          * generated which, in many cases, isn't too useful.
 164          */
 165         struct sigaction nsa;
 166
 167         sigemptyset(&nsa.sa_mask);
 168         nsa.sa_handler = SIG_DFL;
 169         nsa.sa_flags = SA_FULLDUMP;
 170         sigaction(SIGSEGV, &nsa, NULL);
 171 #endif
 172         reinitialize();
 173         if (!parseargs(argc, argv, &cmd)) {
 174                 f_print(stderr,
 175                         "usage: %s infile\n", cmdname);
 176                 f_print(stderr,
 177                         "       %s [-c | -h | -l | -m | -C | -S | -r | -k | -R | -p | -d | -z] [-Pprefix] [-Idir] [-o outfile] [infile]\n",
 178                         cmdname);
 179                 f_print(stderr,
 180                         "       %s [-s udp|tcp]* [-o outfile] [infile]\n",
 181                         cmdname);
 182                 exit(1);
 183         }
 184         OutFileFlag = cmd.outfile;
 185         if (OutFileFlag)
 186             strcpy(OutFile, cmd.outfile);
 187         if (cmd.cflag) {
 188             OutFileFlag = NULL;
 189             c_output(cmd.infile, "-DRPC_XDR", !EXTEND, cmd.outfile, 0);
 190         } else if (cmd.hflag) {
 191                 h_output(cmd.infile, "-DRPC_HDR", !EXTEND, cmd.outfile);
 192         } else if (cmd.lflag) {
 193                 l_output(cmd.infile, "-DRPC_CLNT", !EXTEND, cmd.outfile);
 194         } else if (cmd.sflag || cmd.mflag) {
 195                 s_output(argc, argv, cmd.infile, "-DRPC_SVC", !EXTEND,
 196                          cmd.outfile, cmd.mflag);
 197         } else if (cmd.Cflag) {
 198             OutFileFlag = NULL;
 199             C_output(cmd.infile, "-DRPC_CLIENT", !EXTEND, cmd.outfile, 1);
 200         } else if (cmd.Sflag) {
 201             OutFileFlag = NULL;
 202             S_output(cmd.infile, "-DRPC_SERVER", !EXTEND, cmd.outfile, 1);
 203         } else {
 204             if (OutFileFlag && (strrchr(OutFile,'.') == NULL))
 205                 strcat(OutFile, ".");
 206             if (cmd.rflag) {
 207                 C_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_CLIENT", EXTEND, ".cs.c", 1);
 208                 reinitialize();
 209                 S_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_SERVER", EXTEND, ".ss.c", 1);
 210                 reinitialize();
 211             } else {
 212                 reinitialize();
 213                 c_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_XDR", EXTEND, ".xdr.c", 0);
 214                 reinitialize();
 215                 h_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_HDR", EXTEND, ".h", 0);
 216                 reinitialize();
 217                 C_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_CLIENT", EXTEND, ".cs.c", 1);
 218                 reinitialize();
 219                 S_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_SERVER", EXTEND, ".ss.c", 1);
 220                 reinitialize();
 221             }
 222         }
 223         exit(0);
 224 }
 225
 226 static void
 227 write_int32_macros(fout)
 228         FILE *fout;
 229 {
 230         /*
 231          * Note that rxgen writes code that uses xdr_afs_int32() and
 232          * xdr_afs_uint32().  Systems do not provide these natively, so we
 233          * #define them to locally provided equivalents.
 234          *
 235          * Some systems do come with native xdr_int32() and xdr_uint32()
 236          * functions, but the prototypes are not always in the same
 237          * place and are not always consistent so it is less trouble to
 238          * use the original int and u_int functions.  We do check that
 239          * an int is 32 bits...
 240          *
 241          * A cleaner solution than these #defines would be to make rxgen
 242          * emit calls to xdr_int() and xdr_u_int() to process the types
 243          * afs_int32 and afs_uint32 (if, of course, an int is 32 bits).
 244          *
 245          * Note that to avoid compiler warnings we need to keep
 246          * the types of the native xdr_* routines in sync with the
 247          * definitions of afs_int32 and afs_uint32 in config/stds.h.
 248          */
 249
 250         /*
 251          * If you change the definitions of xdr_afs_int32 and xdr_afs_uint32,
 252          * be sure to change them in BOTH rx/xdr.h and rxgen/rpc_main.c.
 253          */
 254
 255 #if (INT_MAX == 0x7FFFFFFF) && (UINT_MAX == 0xFFFFFFFFu)
 256         f_print(fout, "#ifndef xdr_afs_int32\n");
 257         f_print(fout, "#define xdr_afs_int32 xdr_int\n");
 258         f_print(fout, "#endif\n");
 259         f_print(fout, "#ifndef xdr_afs_uint32\n");
 260         f_print(fout, "#define xdr_afs_uint32 xdr_u_int\n");
 261         f_print(fout, "#endif\n");
 262         f_print(fout, "#ifndef xdr_afs_int64\n");
 263         f_print(fout, "#define xdr_afs_int64 xdr_int64\n");
 264         f_print(fout, "#endif\n");
 265         f_print(fout, "#ifndef xdr_afs_uint64\n");
 266         f_print(fout, "#define xdr_afs_uint64 xdr_uint64\n");
 267         f_print(fout, "#endif\n");
 268 #else
 269 #error Need to do some work here...
 270 #endif
 271 }
 272
 273 /*
 274  * add extension to filename
 275  */
 276 static char *
 277 extendfile(file, ext)
 278         char *file;
 279         char *ext;
 280 {
 281         char *res;
 282         char *p;
 283         char *sname;
 284
 285         res = alloc(strlen(file) + strlen(ext) + 1);
 286         if (res == NULL) {
 287                 abort();
 288         }
 289         p = (char *) strrchr(file, '.');
 290         if (p == NULL) {
 291                 p = file + strlen(file);
 292         }
 293         sname = (char *) strrchr(file, '/');
 294         if (sname == NULL)
 295             sname = file;
 296         else
 297             sname++;
 298         strcpy(res,sname);
 299         strcpy(res + (p - sname),ext);
 300         return (res);
 301 }
 302
 303 /*
 304  * Open output file with given extension
 305  */
 306 static
 307 open_output(infile, outfile)
 308         char *infile;
 309         char *outfile;
 310 {
 311         if (outfile == NULL) {
 312                 fout = stdout;
 313                 return;
 314         }
 315         if (infile != NULL && streq(outfile, infile)) {
 316                 f_print(stderr, "%s: output would overwrite %s\n", cmdname,
 317                         infile);
 318                 crash();
 319         }
 320         fout = fopen(outfile, "w");
 321         if (fout == NULL) {
 322                 f_print(stderr, "%s: unable to open ", cmdname);
 323                 perror(outfile);
 324                 crash();
 325         }
 326         record_open(outfile);
 327 }
 328
 329 /*
 330  * Open input file with given define for C-preprocessor
 331  */
 332 static
 333 open_input(infile, define)
 334         char *infile;
 335         char *define;
 336 {
 337         char *exec_args[MAXCPPARGS+10];
 338         int nargs = 0;
 339         char **args;
 340         char cpp_cmdline[MAXCMDLINE];
 341
 342         int i;
 343         if (debug == 0) {
 344             infilename = (infile == NULL) ? "<stdin>" : infile;
 345             strcpy(cpp_cmdline, CPP);
 346             strcat(cpp_cmdline, " ");
 347             strcat(cpp_cmdline, CPPFLAGS);
 348             strcat(cpp_cmdline, " ");
 349             strcat(cpp_cmdline, define);
 350
 351 #ifdef  AFS_ALPHA_ENV
 352             for (i = 0;
 353                  i < (sizeof(XTRA_CPPFLAGS)/
 354                       sizeof(XTRA_CPPFLAGS[0])) - 1;
 355                  i++) {
 356               strcat(cpp_cmdline, " ");
 357               strcat(cpp_cmdline, XTRA_CPPFLAGS[i]);
 358             }
 359 #endif
 360             for (i = 0; i < nincludes; i++) {
 361               strcat(cpp_cmdline, " ");
 362               strcat(cpp_cmdline, IncludeDir[i]);
 363             }
 364
 365             strcat(cpp_cmdline, " ");
 366             strcat(cpp_cmdline, infile);
 367
 368             fin = popen(cpp_cmdline, "r");
 369             if (fin == NULL)
 370               perror("popen");
 371
 372         } else {
 373             if (infile == NULL) {
 374                 fin = stdin;
 375                 return;
 376             }
 377             fin = fopen(infile, "r");
 378         }
 379         if (fin == NULL) {
 380             f_print(stderr, "%s: ", cmdname);
 381             perror(infilename);
 382             crash();
 383         }
 384 }
 385
 386 /*
 387  * Compile into an XDR routine output file
 388  */
 389 static
 390 c_output(infile, define, extend, outfile, append)
 391         char *infile;
 392         char *define;
 393         int extend;
 394         char *outfile;
 395         int append;
 396 {
 397     definition *def;
 398     char *include;
 399     char *outfilename;
 400     long tell;
 401     char fullname[1024];
 402     char *currfile = (OutFileFlag ? OutFile : infile);
 403     int i,j;
 404
 405     open_input(infile, define);
 406     cflag = 1;
 407     memset(fullname, 0, sizeof(fullname));
 408     if (append) {
 409         strcpy(fullname, prefix);
 410         strcat(fullname, infile);
 411     } else
 412         strcpy(fullname, infile);
 413     outfilename = extend ? extendfile(fullname, outfile) : outfile;
 414     open_output(infile, outfilename);
 415     f_print(fout, "/* Machine generated file -- Do NOT edit */\n\n");
 416     if (xflag) {
 417         if (kflag) {
 418             f_print(fout, "#include \"../afs/param.h\"\n");
 419         } else {
 420             f_print(fout, "#include <afs/param.h>\n");
 421         }
 422         f_print(fout, "#ifdef AFS_NT40_ENV\n");
 423         f_print(fout, "#define AFS_RXGEN_EXPORT __declspec(dllexport)\n");
 424         f_print(fout, "#endif /* AFS_NT40_ENV */\n");
 425     }
 426     if (currfile && (include = extendfile(currfile,".h"))) {
 427         if (kflag) {
 428             f_print(fout, "#include \"../afsint/%s\"\n\n",include);
 429         } else
 430             f_print(fout, "#include \"%s\"\n\n", include);
 431         free(include);
 432     } else {
 433         /* In case we can't include the interface's own header file... */
 434         if (kflag) {
 435             f_print(fout, "#include \"../h/types.h\"\n");
 436             f_print(fout, "#include \"../h/socket.h\"\n");
 437             f_print(fout, "#include \"../h/file.h\"\n");
 438             f_print(fout, "#include \"../h/stat.h\"\n");
 439             f_print(fout, "#include \"../netinet/in.h\"\n");
 440             f_print(fout, "#include \"../h/time.h\"\n");
 441             f_print(fout, "#ifndef AFS_LINUX22_ENV\n");
 442             f_print(fout, "#include \"../rpc/types.h\"\n");
 443             f_print(fout, "#endif /* AFS_LINUX22_ENV */\n");
 444             f_print(fout, "#ifdef AFS_LINUX22_ENV\n");
 445             f_print(fout, "#include \"../rx/xdr.h\"\n");
 446             f_print(fout, "#else /* AFS_LINUX22_ENV */\n");
 447             f_print(fout, "#include \"../rpc/xdr.h\"\n");
 448             f_print(fout, "#endif /* AFS_LINUX22_ENV */\n");
 449             f_print(fout, "#include \"../afsint/rxgen_consts.h\"\n");
 450         } else {
 451             f_print(fout, "#include <rx/xdr.h>\n");
 452         }
 453     }
 454
 455     write_int32_macros(fout);
 456
 457     tell = ftell(fout);
 458     while (def = get_definition()) {
 459         extern int IsRxgenDefinition();
 460
 461         if (!yflag) {
 462             if ((!IsRxgenDefinition(def)) && def->def_kind != DEF_CUSTOMIZED)
 463                 emit(def);
 464         }
 465     }
 466
 467     /*
 468      * Print out array containing list of all functions in the interface
 469      * in order
 470      */
 471
 472     if (xflag) {
 473         for(j=0;j<=PackageIndex;j++) {
 474             f_print(fout, "AFS_RXGEN_EXPORT\n");
 475             f_print(fout, "const char *%sfunction_names[] = {\n",
 476                     PackagePrefix[j]);
 477
 478             for(i=0;i<no_of_stat_funcs_header[j];i++) {
 479                 if (i == 0) {
 480                     f_print(fout, "\t\"%s\"",
 481                             &function_list[j][i]);
 482                 } else {
 483                     f_print(fout, ",\n\t\"%s\"",
 484                             &function_list[j][i]);
 485                 }
 486             }
 487
 488             f_print(fout, "\n};\n");
 489         }
 490     }
 491
 492     if (extend && tell == ftell(fout)) {
 493             (void) unlink(outfilename);
 494     }
 495     cflag = 0;
 496 }
 497
 498 /*
 499  * Compile into an XDR header file
 500  */
 501 static
 502 h_output(infile, define, extend, outfile, append)
 503         char *infile;
 504         char *define;
 505         int extend;
 506         char *outfile;
 507         int append;
 508 {
 509         definition *def;
 510         char *outfilename;
 511         long tell;
 512         extern char *uppercase();
 513         char fullname[1024], *p;
 514         extern int h_opcode_stats();
 515
 516
 517         open_input(infile, define);
 518         hflag = 1;
 519         memset(fullname, 0, sizeof(fullname));
 520         if (append) {
 521             strcpy(fullname, prefix);
 522             strcat(fullname, infile);
 523         } else
 524             strcpy(fullname, infile);
 525         outfilename = extend ? extendfile(fullname, outfile) : outfile;
 526         open_output(infile, outfilename);
 527         strcpy(fullname, outfilename);
 528         if (p = strchr(fullname, '.')) *p = '\0';
 529         f_print(fout, "/* Machine generated file -- Do NOT edit */\n\n");
 530         f_print(fout, "#ifndef  _RXGEN_%s_\n", uppercase(fullname));
 531         f_print(fout, "#define  _RXGEN_%s_\n\n", uppercase(fullname));
 532         f_print(fout, "#ifdef   KERNEL\n");
 533         f_print(fout, "/* The following 'ifndefs' are not a good solution to the vendor's omission of surrounding all system includes with 'ifndef's since it requires that this file is included after the system includes...*/\n");
 534         f_print(fout, "#include <afsconfig.h>\n");
 535         f_print(fout, "#include \"../afs/param.h\"\n");
 536         f_print(fout, "#ifdef   UKERNEL\n");
 537         f_print(fout, "#include \"../afs/sysincludes.h\"\n");
 538         f_print(fout, "#include \"../rx/xdr.h\"\n");
 539         f_print(fout, "#include \"../rx/rx.h\"\n");
 540         if (xflag) {
 541             f_print(fout, "#include \"../rx/rx_globals.h\"\n");
 542         }
 543         f_print(fout, "#else    /* UKERNEL */\n");
 544         f_print(fout, "#include \"../h/types.h\"\n");
 545         f_print(fout, "#ifndef  SOCK_DGRAM  /* XXXXX */\n");
 546         f_print(fout, "#include \"../h/socket.h\"\n");
 547         f_print(fout, "#endif\n");
 548         f_print(fout, "#ifndef  DTYPE_SOCKET  /* XXXXX */\n");
 549         f_print(fout, "#ifdef AFS_DEC_ENV\n");
 550         f_print(fout, "#include \"../h/smp_lock.h\"\n");
 551         f_print(fout, "#endif\n");
 552         f_print(fout, "#ifndef AFS_LINUX22_ENV\n");
 553         f_print(fout, "#include \"../h/file.h\"\n");
 554         f_print(fout, "#endif\n");
 555         f_print(fout, "#endif\n");
 556         f_print(fout, "#ifndef  S_IFMT  /* XXXXX */\n");
 557         f_print(fout, "#include \"../h/stat.h\"\n");
 558         f_print(fout, "#endif\n");
 559         f_print(fout, "#ifndef  IPPROTO_UDP /* XXXXX */\n");
 560         f_print(fout, "#include \"../netinet/in.h\"\n");
 561         f_print(fout, "#endif\n");
 562         f_print(fout, "#ifndef  DST_USA  /* XXXXX */\n");
 563         f_print(fout, "#include \"../h/time.h\"\n");
 564         f_print(fout, "#endif\n");
 565         f_print(fout, "#ifndef AFS_LINUX22_ENV\n");
 566         f_print(fout, "#include \"../rpc/types.h\"\n");
 567         f_print(fout, "#endif /* AFS_LINUX22_ENV */\n");
 568         f_print(fout, "#ifndef  XDR_GETLONG /* XXXXX */\n");
 569         f_print(fout, "#ifdef AFS_LINUX22_ENV\n");
 570         f_print(fout, "#ifndef quad_t\n");
 571         f_print(fout, "#define quad_t __quad_t\n");
 572         f_print(fout, "#define u_quad_t __u_quad_t\n");
 573         f_print(fout, "#endif\n");
 574         f_print(fout, "#endif\n");
 575         f_print(fout, "#ifdef AFS_LINUX22_ENV\n");
 576         f_print(fout, "#include \"../rx/xdr.h\"\n");
 577         f_print(fout, "#else /* AFS_LINUX22_ENV */\n");
 578         f_print(fout, "extern bool_t xdr_int64();\n");
 579         f_print(fout, "extern bool_t xdr_uint64();\n");
 580         f_print(fout, "#include \"../rpc/xdr.h\"\n");
 581         f_print(fout, "#endif /* AFS_LINUX22_ENV */\n");
 582         f_print(fout, "#endif /* XDR_GETLONG */\n");
 583         f_print(fout, "#endif   /* UKERNEL */\n");
 584         f_print(fout, "#include \"../afsint/rxgen_consts.h\"\n");
 585         f_print(fout, "#include \"../afs/afs_osi.h\"\n");
 586         f_print(fout, "#include \"../rx/rx.h\"\n");
 587         if (xflag) {
 588             f_print(fout, "#include \"../rx/rx_globals.h\"\n");
 589         }
 590         f_print(fout, "#else    /* KERNEL */\n");
 591         f_print(fout, "#include <afs/param.h>\n");
 592         f_print(fout, "#include <afs/stds.h>\n");
 593         f_print(fout, "#include <sys/types.h>\n");
 594         f_print(fout, "#include <rx/xdr.h>\n");
 595         f_print(fout, "#include <rx/rx.h>\n");
 596         if (xflag) {
 597             f_print(fout, "#include <rx/rx_globals.h>\n");
 598         }
 599         f_print(fout, "#include <afs/rxgen_consts.h>\n");
 600         f_print(fout, "#endif   /* KERNEL */\n\n");
 601         f_print(fout, "#ifdef AFS_NT40_ENV\n");
 602         f_print(fout, "#ifndef AFS_RXGEN_EXPORT\n");
 603         f_print(fout, "#define AFS_RXGEN_EXPORT __declspec(dllimport)\n");
 604         f_print(fout, "#endif /* AFS_RXGEN_EXPORT */\n");
 605         f_print(fout, "#else /* AFS_NT40_ENV */\n");
 606         f_print(fout, "#define AFS_RXGEN_EXPORT\n");
 607         f_print(fout, "#endif /* AFS_NT40_ENV */\n\n");
 608         tell = ftell(fout);
 609         while (def = get_definition()) {
 610                 print_datadef(def);
 611         }
 612         h_opcode_stats();
 613         hflag = 0;
 614         f_print(fout, "#endif   /* _RXGEN_%s_ */\n", uppercase(fullname));
 615         if (extend && tell == ftell(fout)) {
 616                 (void) unlink(outfilename);
 617         }
 618 }
 619
 620 /*
 621  * Compile into an RPC service
 622  */
 623 static
 624 s_output(argc, argv, infile, define, extend, outfile, nomain)
 625         int argc;
 626         char *argv[];
 627         char *infile;
 628         char *define;
 629         int extend;
 630         char *outfile;
 631         int nomain;
 632 {
 633         char *include;
 634         definition *def;
 635         int foundprogram;
 636         char *outfilename;
 637
 638         open_input(infile, define);
 639         outfilename = extend ? extendfile(infile, outfile) : outfile;
 640         open_output(infile, outfilename);
 641         f_print(fout, "#include <stdio.h>\n");
 642         f_print(fout, "#include <rpc/rpc.h>\n");
 643         if (infile && (include = extendfile(infile, ".h"))) {
 644                 f_print(fout, "#include \"%s\"\n", include);
 645                 free(include);
 646         }
 647         foundprogram = 0;
 648         while (def = get_definition()) {
 649                 foundprogram |= (def->def_kind == DEF_PROGRAM);
 650         }
 651         if (extend && !foundprogram) {
 652                 (void) unlink(outfilename);
 653                 return;
 654         }
 655         if (nomain) {
 656                 write_programs((char *)NULL);
 657         } else {
 658                 write_most();
 659                 do_registers(argc, argv);
 660                 write_rest();
 661                 write_programs("static");
 662         }
 663 }
 664
 665 static
 666 l_output(infile, define, extend, outfile)
 667         char *infile;
 668         char *define;
 669         int extend;
 670         char *outfile;
 671 {
 672         char *include;
 673         definition *def;
 674         int foundprogram;
 675         char *outfilename;
 676
 677         open_input(infile, define);
 678         outfilename = extend ? extendfile(infile, outfile) : outfile;
 679         open_output(infile, outfilename);
 680         f_print(fout, "#include <rpc/rpc.h>\n");
 681         f_print(fout, "#include <sys/time.h>\n");
 682         if (infile && (include = extendfile(infile, ".h"))) {
 683                 f_print(fout, "#include \"%s\"\n", include);
 684                 free(include);
 685         }
 686         foundprogram = 0;
 687         while (def = get_definition()) {
 688                 foundprogram |= (def->def_kind == DEF_PROGRAM);
 689         }
 690         if (extend && !foundprogram) {
 691                 (void) unlink(outfilename);
 692                 return;
 693         }
 694         write_stubs();
 695 }
 696
 697 /*
 698  * Perform registrations for service output
 699  */
 700 static
 701 do_registers(argc, argv)
 702         int argc;
 703         char *argv[];
 704
 705 {
 706         int i;
 707
 708         for (i = 1; i < argc; i++) {
 709                 if (streq(argv[i], "-s")) {
 710                         write_register(argv[i + 1]);
 711                         i++;
 712                 }
 713         }
 714 }
 715
 716
 717 C_output(infile, define, extend, outfile, append)
 718 char *infile;
 719 char *define;
 720 int extend;
 721 char *outfile;
 722 int append;
 723 {
 724     char *include;
 725     char *outfilename;
 726     char fullname[1024];
 727     long tell;
 728     char *currfile = (OutFileFlag ? OutFile : infile);
 729
 730     Cflag = 1;
 731     open_input(infile, define);
 732     memset(fullname, 0, sizeof(fullname));
 733     if (append) {
 734         strcpy(fullname, prefix);
 735         strcat(fullname, infile);
 736     } else
 737         strcpy(fullname, infile);
 738     outfilename = extend ? extendfile(fullname, outfile) : outfile;
 739     open_output(infile, outfilename);
 740     f_print(fout, "/* Machine generated file -- Do NOT edit */\n\n");
 741     if (currfile && (include = extendfile(currfile,".h"))) {
 742         if (kflag) {
 743             f_print(fout, "#include \"../afsint/%s\"\n\n",include);
 744         } else {
 745             f_print(fout,"#include \"%s\"\n\n",include);
 746         }
 747         free(include);
 748     } else {
 749         if (kflag) {
 750             f_print(fout, "#include \"../h/types.h\"\n");
 751             f_print(fout, "#include \"../h/socket.h\"\n");
 752             f_print(fout, "#include \"../h/file.h\"\n");
 753             f_print(fout, "#include \"../h/stat.h\"\n");
 754             f_print(fout, "#include \"../netinet/in.h\"\n");
 755             f_print(fout, "#include \"../h/time.h\"\n");
 756             f_print(fout, "#include \"../rpc/types.h\"\n");
 757             f_print(fout, "#ifdef AFS_LINUX22_ENV\n");
 758             f_print(fout, "#include \"../rx/xdr.h\"\n");
 759             f_print(fout, "#else /* AFS_LINUX22_ENV */\n");
 760             f_print(fout, "#include \"../rpc/xdr.h\"\n");
 761             f_print(fout, "#endif /* AFS_LINUX22_ENV */\n");
 762             f_print(fout, "#include \"../afsint/rxgen_consts.h\"\n");
 763             f_print(fout, "#include \"../afs/afs_osi.h\"\n");
 764             f_print(fout, "#include \"../rx/rx.h\"\n");
 765             if (xflag) {
 766                 f_print(fout, "#include \"../rx/rx_globals.h\"\n");
 767             }
 768         } else {
 769             f_print(fout, "#include <sys/types.h>\n");
 770             f_print(fout, "#include <rx/xdr.h>\n");
 771             f_print(fout, "#include <rx/rx.h>\n");
 772             if (xflag) {
 773                 f_print(fout, "#include <rx/rx_globals.h>\n");
 774             }
 775             f_print(fout, "#include <afs/rxgen_consts.h>\n");
 776         }
 777     }
 778
 779     write_int32_macros(fout);
 780
 781     tell = ftell(fout);
 782     while (get_definition()) continue;
 783     if (extend && tell == ftell(fout)) {
 784         (void) unlink(outfilename);
 785     }
 786
 787     Cflag = 0;
 788 }
 789
 790 S_output(infile, define, extend, outfile, append)
 791 char *infile;
 792 char *define;
 793 int extend;
 794 char *outfile;
 795 int append;
 796 {
 797     char *include;
 798     char *outfilename;
 799     char fullname[1024];
 800     definition *def;
 801     long tell;
 802     extern int er_Proc_CodeGeneration();
 803     char *currfile = (OutFileFlag ? OutFile : infile);
 804
 805     Sflag = 1;
 806     open_input(infile, define);
 807     memset(fullname, 0, sizeof(fullname));
 808     if (append) {
 809         strcpy(fullname, prefix);
 810         strcat(fullname, infile);
 811     } else
 812         strcpy(fullname, infile);
 813     outfilename = extend ? extendfile(fullname, outfile) : outfile;
 814     open_output(infile, outfilename);
 815     f_print(fout, "/* Machine generated file -- Do NOT edit */\n\n");
 816     if (currfile && (include = extendfile(currfile,".h"))) {
 817         if (kflag) {
 818             f_print(fout, "#include \"../afsint/%s\"\n",include);
 819         } else {
 820             f_print(fout,"#include \"%s\"\n\n",include);
 821         }
 822         free(include);
 823     } else {
 824         if (kflag) {
 825             f_print(fout, "#include \"../h/types.h\"\n");
 826             f_print(fout, "#include \"../h/socket.h\"\n");
 827             f_print(fout, "#include \"../h/file.h\"\n");
 828             f_print(fout, "#include \"../h/stat.h\"\n");
 829             f_print(fout, "#include \"../netinet/in.h\"\n");
 830             f_print(fout, "#include \"../h/time.h\"\n");
 831             f_print(fout, "#include \"../rpc/types.h\"\n");
 832             f_print(fout, "#ifdef AFS_LINUX22_ENV\n");
 833             f_print(fout, "#include \"../rx/xdr.h\"\n");
 834             f_print(fout, "#else /* AFS_LINUX22_ENV */\n");
 835             f_print(fout, "#include \"../rpc/xdr.h\"\n");
 836             f_print(fout, "#endif /* AFS_LINUX22_ENV */\n");
 837             f_print(fout, "#include \"../afsint/rxgen_consts.h\"\n");
 838             f_print(fout, "#include \"../afs/afs_osi.h\"\n");
 839             f_print(fout, "#include \"../rx/rx.h\"\n");
 840             if (xflag) {
 841                 f_print(fout, "#include \"../rx/rx_globals.h\"\n");
 842             }
 843         } else {
 844             f_print(fout, "#include <sys/types.h>\n");
 845             f_print(fout, "#include <rx/xdr.h>\n");
 846             f_print(fout, "#include <rx/rx.h>\n");
 847             if (xflag) {
 848                 f_print(fout, "#include <rx/rx_globals.h>\n");
 849             }
 850             f_print(fout, "#include <afs/rxgen_consts.h>\n");
 851         }
 852     }
 853
 854     write_int32_macros(fout);
 855
 856     tell = ftell(fout);
 857     fflush(fout);
 858     while (def = get_definition()) {
 859         fflush(fout);
 860         print_datadef(def);
 861     }
 862
 863     er_Proc_CodeGeneration();
 864
 865     if (extend && tell == ftell(fout)) {
 866         (void) unlink(outfilename);
 867     }
 868     Sflag = 0;
 869 }
 870
 871 char *uppercase(str)
 872 char *str;
 873 {
 874     static char max_size[100];
 875     char *pnt;
 876     int len = strlen(str);
 877
 878     for (pnt = max_size; len > 0; len--, str++) {
 879         *pnt++ = (islower(*str) ? toupper(*str) : *str);
 880     }
 881     *pnt = '\0';
 882     return max_size;
 883 }
 884
 885 /*
 886  * Parse command line arguments
 887  */
 888 static
 889 parseargs(argc, argv, cmd)
 890         int argc;
 891         char *argv[];
 892         struct commandline *cmd;
 893
 894 {
 895         int i;
 896         int j;
 897         char c;
 898         char flag[(1 << 8 * sizeof(char))];
 899         int nflags;
 900
 901         cmdname = argv[0];
 902         cmd->infile = cmd->outfile = NULL;
 903         if (argc < 2) {
 904                 return (0);
 905         }
 906         memset(flag, 0, sizeof(flag));
 907         cmd->outfile = NULL;
 908         for (i = 1; i < argc; i++) {
 909                 if (argv[i][0] != '-') {
 910                         if (cmd->infile) {
 911                                 return (0);
 912                         }
 913                         cmd->infile = argv[i];
 914                 } else {
 915                         for (j = 1; argv[i][j] != 0; j++) {
 916                                 c = argv[i][j];
 917                                 switch (c) {
 918                                 case 'c':
 919                                 case 'h':
 920                                 case 'l':
 921                                 case 'm':
 922                                 case 'C':
 923                                 case 'S':
 924                                 case 'r':
 925                                 case 'R':
 926                                 case 'k':
 927                                 case 'p':
 928                                 case 'd':
 929                                 case 'x':
 930                                 case 'y':
 931                                 case 'z':
 932                                         if (flag[c]) {
 933                                                 return (0);
 934                                         }
 935                                         flag[c] = 1;
 936                                         break;
 937                                 case 'o':
 938                                 case 's':
 939                                         if (argv[i][j - 1] != '-' ||
 940                                             argv[i][j + 1] != 0) {
 941                                                 return (0);
 942                                         }
 943                                         flag[c] = 1;
 944                                         if (++i == argc) {
 945                                                 return (0);
 946                                         }
 947                                         if (c == 's') {
 948                                                 if (!streq(argv[i], "udp") &&
 949                                                     !streq(argv[i], "tcp")) {
 950                                                         return (0);
 951                                                 }
 952                                         } else if (c == 'o') {
 953                                                 if (cmd->outfile) {
 954                                                         return (0);
 955                                                 }
 956                                                 cmd->outfile = argv[i];
 957                                         }
 958                                         goto nextarg;
 959                                 case 'P':
 960                                         if (argv[i][j-1] != '-')
 961                                             return(0);
 962                                         prefix = &argv[i][j+1];
 963                                         goto nextarg;
 964                                 case 'I':
 965                                         if (argv[i][j-1] != '-')
 966                                             return(0);
 967                                         IncludeDir[nincludes++]= &argv[i][j-1];
 968                                         goto nextarg;
 969                                 default:
 970                                         return (0);
 971                                 }
 972                         }
 973         nextarg:
 974                         ;
 975                 }
 976         }
 977         cmd->cflag = cflag = flag['c'];
 978         cmd->hflag = hflag = flag['h'];
 979         cmd->sflag = flag['s'];
 980         cmd->lflag = flag['l'];
 981         cmd->mflag = flag['m'];
 982         cmd->xflag = xflag = flag['x'];
 983         cmd->yflag = yflag = flag['y'];
 984         cmd->Cflag = Cflag = flag['C'];
 985         cmd->Sflag = Sflag = flag['S'];
 986         cmd->rflag = flag['r'];
 987         cmd->kflag = kflag = flag['k'];
 988         cmd->pflag = flag['p'];
 989         cmd->dflag = debug = flag['d'];
 990         zflag = flag['z'];
 991         if (cmd->pflag) combinepackages = 1;
 992         nflags = cmd->cflag + cmd->hflag + cmd->sflag + cmd->lflag + cmd->mflag + cmd->Cflag + cmd->Sflag + cmd->rflag;
 993         if (nflags == 0) {
 994                 if (cmd->outfile != NULL || cmd->infile == NULL) {
 995                         return (0);
 996                 }
 997         } else if (nflags > 1) {
 998                 return (0);
 999         }
1000         return (1);
1001 }