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_XBSD_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         int nargs = 0;
 338         char cpp_cmdline[MAXCMDLINE];
 339
 340         int i;
 341         if (debug == 0) {
 342             infilename = (infile == NULL) ? "<stdin>" : infile;
 343             strcpy(cpp_cmdline, CPP);
 344             strcat(cpp_cmdline, " ");
 345             strcat(cpp_cmdline, CPPFLAGS);
 346             strcat(cpp_cmdline, " ");
 347             strcat(cpp_cmdline, define);
 348
 349 #ifdef  AFS_ALPHA_ENV
 350             for (i = 0;
 351                  i < (sizeof(XTRA_CPPFLAGS)/
 352                       sizeof(XTRA_CPPFLAGS[0])) - 1;
 353                  i++) {
 354               strcat(cpp_cmdline, " ");
 355               strcat(cpp_cmdline, XTRA_CPPFLAGS[i]);
 356             }
 357 #endif
 358             for (i = 0; i < nincludes; i++) {
 359               strcat(cpp_cmdline, " ");
 360               strcat(cpp_cmdline, IncludeDir[i]);
 361             }
 362
 363             strcat(cpp_cmdline, " ");
 364             strcat(cpp_cmdline, infile);
 365
 366             fin = popen(cpp_cmdline, "r");
 367             if (fin == NULL)
 368               perror("popen");
 369
 370         } else {
 371             if (infile == NULL) {
 372                 fin = stdin;
 373                 return;
 374             }
 375             fin = fopen(infile, "r");
 376         }
 377         if (fin == NULL) {
 378             f_print(stderr, "%s: ", cmdname);
 379             perror(infilename);
 380             crash();
 381         }
 382 }
 383
 384 /*
 385  * Compile into an XDR routine output file
 386  */
 387 static
 388 c_output(infile, define, extend, outfile, append)
 389         char *infile;
 390         char *define;
 391         int extend;
 392         char *outfile;
 393         int append;
 394 {
 395     definition *def;
 396     char *include;
 397     char *outfilename;
 398     long tell;
 399     char fullname[1024];
 400     char *currfile = (OutFileFlag ? OutFile : infile);
 401     int i,j;
 402
 403     open_input(infile, define);
 404     cflag = 1;
 405     memset(fullname, 0, sizeof(fullname));
 406     if (append) {
 407         strcpy(fullname, prefix);
 408         strcat(fullname, infile);
 409     } else
 410         strcpy(fullname, infile);
 411     outfilename = extend ? extendfile(fullname, outfile) : outfile;
 412     open_output(infile, outfilename);
 413     f_print(fout, "/* Machine generated file -- Do NOT edit */\n\n");
 414     if (xflag) {
 415         if (kflag) {
 416             f_print(fout, "#include \"../afs/param.h\"\n");
 417         } else {
 418             f_print(fout, "#include <afs/param.h>\n");
 419         }
 420         f_print(fout, "#ifdef AFS_NT40_ENV\n");
 421         f_print(fout, "#define AFS_RXGEN_EXPORT __declspec(dllexport)\n");
 422         f_print(fout, "#endif /* AFS_NT40_ENV */\n");
 423     }
 424     if (currfile && (include = extendfile(currfile,".h"))) {
 425         if (kflag) {
 426             f_print(fout, "#include \"../afsint/%s\"\n\n",include);
 427         } else
 428             f_print(fout, "#include \"%s\"\n\n", include);
 429         free(include);
 430     } else {
 431         /* In case we can't include the interface's own header file... */
 432         if (kflag) {
 433             f_print(fout, "#include \"../h/types.h\"\n");
 434             f_print(fout, "#include \"../h/socket.h\"\n");
 435             f_print(fout, "#include \"../h/file.h\"\n");
 436             f_print(fout, "#include \"../h/stat.h\"\n");
 437             f_print(fout, "#include \"../netinet/in.h\"\n");
 438             f_print(fout, "#include \"../h/time.h\"\n");
 439             f_print(fout, "#include \"../rx/xdr.h\"\n");
 440             f_print(fout, "#include \"../afsint/rxgen_consts.h\"\n");
 441         } else {
 442             f_print(fout, "#include <rx/xdr.h>\n");
 443         }
 444     }
 445
 446     write_int32_macros(fout);
 447
 448     tell = ftell(fout);
 449     while (def = get_definition()) {
 450         extern int IsRxgenDefinition();
 451
 452         if (!yflag) {
 453             if ((!IsRxgenDefinition(def)) && def->def_kind != DEF_CUSTOMIZED)
 454                 emit(def);
 455         }
 456     }
 457
 458     /*
 459      * Print out array containing list of all functions in the interface
 460      * in order
 461      */
 462
 463     if (xflag) {
 464         for(j=0;j<=PackageIndex;j++) {
 465             f_print(fout, "AFS_RXGEN_EXPORT\n");
 466             f_print(fout, "const char *%sfunction_names[] = {\n",
 467                     PackagePrefix[j]);
 468
 469             for(i=0;i<no_of_stat_funcs_header[j];i++) {
 470                 if (i == 0) {
 471                     f_print(fout, "\t\"%s\"",
 472                             &function_list[j][i]);
 473                 } else {
 474                     f_print(fout, ",\n\t\"%s\"",
 475                             &function_list[j][i]);
 476                 }
 477             }
 478
 479             f_print(fout, "\n};\n");
 480         }
 481     }
 482
 483     if (extend && tell == ftell(fout)) {
 484             (void) unlink(outfilename);
 485     }
 486     cflag = 0;
 487 }
 488
 489 /*
 490  * Compile into an XDR header file
 491  */
 492 static
 493 h_output(infile, define, extend, outfile, append)
 494         char *infile;
 495         char *define;
 496         int extend;
 497         char *outfile;
 498         int append;
 499 {
 500         definition *def;
 501         char *outfilename;
 502         long tell;
 503         extern char *uppercase();
 504         char fullname[1024], *p;
 505         extern int h_opcode_stats();
 506
 507
 508         open_input(infile, define);
 509         hflag = 1;
 510         memset(fullname, 0, sizeof(fullname));
 511         if (append) {
 512             strcpy(fullname, prefix);
 513             strcat(fullname, infile);
 514         } else
 515             strcpy(fullname, infile);
 516         outfilename = extend ? extendfile(fullname, outfile) : outfile;
 517         open_output(infile, outfilename);
 518         strcpy(fullname, outfilename);
 519         if (p = strchr(fullname, '.')) *p = '\0';
 520         f_print(fout, "/* Machine generated file -- Do NOT edit */\n\n");
 521         f_print(fout, "#ifndef  _RXGEN_%s_\n", uppercase(fullname));
 522         f_print(fout, "#define  _RXGEN_%s_\n\n", uppercase(fullname));
 523         f_print(fout, "#ifdef   KERNEL\n");
 524         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");
 525         f_print(fout, "#include <afsconfig.h>\n");
 526         f_print(fout, "#include \"../afs/param.h\"\n");
 527         f_print(fout, "#ifdef   UKERNEL\n");
 528         f_print(fout, "#include \"../afs/sysincludes.h\"\n");
 529         f_print(fout, "#include \"../rx/xdr.h\"\n");
 530         f_print(fout, "#include \"../rx/rx.h\"\n");
 531         if (xflag) {
 532             f_print(fout, "#include \"../rx/rx_globals.h\"\n");
 533         }
 534         f_print(fout, "#else    /* UKERNEL */\n");
 535         f_print(fout, "#include \"../h/types.h\"\n");
 536         f_print(fout, "#ifndef  SOCK_DGRAM  /* XXXXX */\n");
 537         f_print(fout, "#include \"../h/socket.h\"\n");
 538         f_print(fout, "#endif\n");
 539         f_print(fout, "#ifndef  DTYPE_SOCKET  /* XXXXX */\n");
 540         f_print(fout, "#ifdef AFS_DEC_ENV\n");
 541         f_print(fout, "#include \"../h/smp_lock.h\"\n");
 542         f_print(fout, "#endif\n");
 543         f_print(fout, "#ifndef AFS_LINUX22_ENV\n");
 544         f_print(fout, "#include \"../h/file.h\"\n");
 545         f_print(fout, "#endif\n");
 546         f_print(fout, "#endif\n");
 547         f_print(fout, "#ifndef  S_IFMT  /* XXXXX */\n");
 548         f_print(fout, "#include \"../h/stat.h\"\n");
 549         f_print(fout, "#endif\n");
 550         f_print(fout, "#ifndef  IPPROTO_UDP /* XXXXX */\n");
 551         f_print(fout, "#include \"../netinet/in.h\"\n");
 552         f_print(fout, "#endif\n");
 553         f_print(fout, "#ifndef  DST_USA  /* XXXXX */\n");
 554         f_print(fout, "#include \"../h/time.h\"\n");
 555         f_print(fout, "#endif\n");
 556         f_print(fout, "#ifndef AFS_LINUX22_ENV\n");
 557         f_print(fout, "#include \"../rpc/types.h\"\n");
 558         f_print(fout, "#endif /* AFS_LINUX22_ENV */\n");
 559         f_print(fout, "#ifndef  XDR_GETLONG /* XXXXX */\n");
 560         f_print(fout, "#ifdef AFS_LINUX22_ENV\n");
 561         f_print(fout, "#ifndef quad_t\n");
 562         f_print(fout, "#define quad_t __quad_t\n");
 563         f_print(fout, "#define u_quad_t __u_quad_t\n");
 564         f_print(fout, "#endif\n");
 565         f_print(fout, "#endif\n");
 566         f_print(fout, "#include \"../rx/xdr.h\"\n");
 567         f_print(fout, "#endif /* XDR_GETLONG */\n");
 568         f_print(fout, "#endif   /* UKERNEL */\n");
 569         f_print(fout, "#include \"../afsint/rxgen_consts.h\"\n");
 570         f_print(fout, "#include \"../afs/afs_osi.h\"\n");
 571         f_print(fout, "#include \"../rx/rx.h\"\n");
 572         if (xflag) {
 573             f_print(fout, "#include \"../rx/rx_globals.h\"\n");
 574         }
 575         f_print(fout, "#else    /* KERNEL */\n");
 576         f_print(fout, "#include <afs/param.h>\n");
 577         f_print(fout, "#include <afs/stds.h>\n");
 578         f_print(fout, "#include <sys/types.h>\n");
 579         f_print(fout, "#include <rx/xdr.h>\n");
 580         f_print(fout, "#include <rx/rx.h>\n");
 581         if (xflag) {
 582             f_print(fout, "#include <rx/rx_globals.h>\n");
 583         }
 584         f_print(fout, "#include <afs/rxgen_consts.h>\n");
 585         f_print(fout, "#endif   /* KERNEL */\n\n");
 586         f_print(fout, "#ifdef AFS_NT40_ENV\n");
 587         f_print(fout, "#ifndef AFS_RXGEN_EXPORT\n");
 588         f_print(fout, "#define AFS_RXGEN_EXPORT __declspec(dllimport)\n");
 589         f_print(fout, "#endif /* AFS_RXGEN_EXPORT */\n");
 590         f_print(fout, "#else /* AFS_NT40_ENV */\n");
 591         f_print(fout, "#define AFS_RXGEN_EXPORT\n");
 592         f_print(fout, "#endif /* AFS_NT40_ENV */\n\n");
 593         tell = ftell(fout);
 594         while (def = get_definition()) {
 595                 print_datadef(def);
 596         }
 597         h_opcode_stats();
 598         hflag = 0;
 599         f_print(fout, "#endif   /* _RXGEN_%s_ */\n", uppercase(fullname));
 600         if (extend && tell == ftell(fout)) {
 601                 (void) unlink(outfilename);
 602         }
 603 }
 604
 605 /*
 606  * Compile into an RPC service
 607  */
 608 static
 609 s_output(argc, argv, infile, define, extend, outfile, nomain)
 610         int argc;
 611         char *argv[];
 612         char *infile;
 613         char *define;
 614         int extend;
 615         char *outfile;
 616         int nomain;
 617 {
 618         char *include;
 619         definition *def;
 620         int foundprogram;
 621         char *outfilename;
 622
 623         open_input(infile, define);
 624         outfilename = extend ? extendfile(infile, outfile) : outfile;
 625         open_output(infile, outfilename);
 626         f_print(fout, "#include <stdio.h>\n");
 627         f_print(fout, "#include <rpc/rpc.h>\n");
 628         if (infile && (include = extendfile(infile, ".h"))) {
 629                 f_print(fout, "#include \"%s\"\n", include);
 630                 free(include);
 631         }
 632         foundprogram = 0;
 633         while (def = get_definition()) {
 634                 foundprogram |= (def->def_kind == DEF_PROGRAM);
 635         }
 636         if (extend && !foundprogram) {
 637                 (void) unlink(outfilename);
 638                 return;
 639         }
 640         if (nomain) {
 641                 write_programs((char *)NULL);
 642         } else {
 643                 write_most();
 644                 do_registers(argc, argv);
 645                 write_rest();
 646                 write_programs("static");
 647         }
 648 }
 649
 650 static
 651 l_output(infile, define, extend, outfile)
 652         char *infile;
 653         char *define;
 654         int extend;
 655         char *outfile;
 656 {
 657         char *include;
 658         definition *def;
 659         int foundprogram;
 660         char *outfilename;
 661
 662         open_input(infile, define);
 663         outfilename = extend ? extendfile(infile, outfile) : outfile;
 664         open_output(infile, outfilename);
 665         f_print(fout, "#include <rpc/rpc.h>\n");
 666         f_print(fout, "#include <sys/time.h>\n");
 667         if (infile && (include = extendfile(infile, ".h"))) {
 668                 f_print(fout, "#include \"%s\"\n", include);
 669                 free(include);
 670         }
 671         foundprogram = 0;
 672         while (def = get_definition()) {
 673                 foundprogram |= (def->def_kind == DEF_PROGRAM);
 674         }
 675         if (extend && !foundprogram) {
 676                 (void) unlink(outfilename);
 677                 return;
 678         }
 679         write_stubs();
 680 }
 681
 682 /*
 683  * Perform registrations for service output
 684  */
 685 static
 686 do_registers(argc, argv)
 687         int argc;
 688         char *argv[];
 689
 690 {
 691         int i;
 692
 693         for (i = 1; i < argc; i++) {
 694                 if (streq(argv[i], "-s")) {
 695                         write_register(argv[i + 1]);
 696                         i++;
 697                 }
 698         }
 699 }
 700
 701
 702 C_output(infile, define, extend, outfile, append)
 703 char *infile;
 704 char *define;
 705 int extend;
 706 char *outfile;
 707 int append;
 708 {
 709     char *include;
 710     char *outfilename;
 711     char fullname[1024];
 712     long tell;
 713     char *currfile = (OutFileFlag ? OutFile : infile);
 714
 715     Cflag = 1;
 716     open_input(infile, define);
 717     memset(fullname, 0, sizeof(fullname));
 718     if (append) {
 719         strcpy(fullname, prefix);
 720         strcat(fullname, infile);
 721     } else
 722         strcpy(fullname, infile);
 723     outfilename = extend ? extendfile(fullname, outfile) : outfile;
 724     open_output(infile, outfilename);
 725     f_print(fout, "/* Machine generated file -- Do NOT edit */\n\n");
 726     if (currfile && (include = extendfile(currfile,".h"))) {
 727         if (kflag) {
 728             f_print(fout, "#include \"../afsint/%s\"\n\n",include);
 729         } else {
 730             f_print(fout,"#include \"%s\"\n\n",include);
 731         }
 732         free(include);
 733     } else {
 734         if (kflag) {
 735             f_print(fout, "#include \"../h/types.h\"\n");
 736             f_print(fout, "#include \"../h/socket.h\"\n");
 737             f_print(fout, "#include \"../h/file.h\"\n");
 738             f_print(fout, "#include \"../h/stat.h\"\n");
 739             f_print(fout, "#include \"../netinet/in.h\"\n");
 740             f_print(fout, "#include \"../h/time.h\"\n");
 741             f_print(fout, "#include \"../rpc/types.h\"\n");
 742             f_print(fout, "#include \"../rx/xdr.h\"\n");
 743             f_print(fout, "#include \"../afsint/rxgen_consts.h\"\n");
 744             f_print(fout, "#include \"../afs/afs_osi.h\"\n");
 745             f_print(fout, "#include \"../rx/rx.h\"\n");
 746             if (xflag) {
 747                 f_print(fout, "#include \"../rx/rx_globals.h\"\n");
 748             }
 749         } else {
 750             f_print(fout, "#include <sys/types.h>\n");
 751             f_print(fout, "#include <rx/xdr.h>\n");
 752             f_print(fout, "#include <rx/rx.h>\n");
 753             if (xflag) {
 754                 f_print(fout, "#include <rx/rx_globals.h>\n");
 755             }
 756             f_print(fout, "#include <afs/rxgen_consts.h>\n");
 757         }
 758     }
 759
 760     write_int32_macros(fout);
 761
 762     tell = ftell(fout);
 763     while (get_definition()) continue;
 764     if (extend && tell == ftell(fout)) {
 765         (void) unlink(outfilename);
 766     }
 767
 768     Cflag = 0;
 769 }
 770
 771 S_output(infile, define, extend, outfile, append)
 772 char *infile;
 773 char *define;
 774 int extend;
 775 char *outfile;
 776 int append;
 777 {
 778     char *include;
 779     char *outfilename;
 780     char fullname[1024];
 781     definition *def;
 782     long tell;
 783     extern int er_Proc_CodeGeneration();
 784     char *currfile = (OutFileFlag ? OutFile : infile);
 785
 786     Sflag = 1;
 787     open_input(infile, define);
 788     memset(fullname, 0, sizeof(fullname));
 789     if (append) {
 790         strcpy(fullname, prefix);
 791         strcat(fullname, infile);
 792     } else
 793         strcpy(fullname, infile);
 794     outfilename = extend ? extendfile(fullname, outfile) : outfile;
 795     open_output(infile, outfilename);
 796     f_print(fout, "/* Machine generated file -- Do NOT edit */\n\n");
 797     if (currfile && (include = extendfile(currfile,".h"))) {
 798         if (kflag) {
 799             f_print(fout, "#include \"../afsint/%s\"\n",include);
 800         } else {
 801             f_print(fout,"#include \"%s\"\n\n",include);
 802         }
 803         free(include);
 804     } else {
 805         if (kflag) {
 806             f_print(fout, "#include \"../h/types.h\"\n");
 807             f_print(fout, "#include \"../h/socket.h\"\n");
 808             f_print(fout, "#include \"../h/file.h\"\n");
 809             f_print(fout, "#include \"../h/stat.h\"\n");
 810             f_print(fout, "#include \"../netinet/in.h\"\n");
 811             f_print(fout, "#include \"../h/time.h\"\n");
 812             f_print(fout, "#include \"../rpc/types.h\"\n");
 813             f_print(fout, "#include \"../rx/xdr.h\"\n");
 814             f_print(fout, "#include \"../afsint/rxgen_consts.h\"\n");
 815             f_print(fout, "#include \"../afs/afs_osi.h\"\n");
 816             f_print(fout, "#include \"../rx/rx.h\"\n");
 817             if (xflag) {
 818                 f_print(fout, "#include \"../rx/rx_globals.h\"\n");
 819             }
 820         } else {
 821             f_print(fout, "#include <sys/types.h>\n");
 822             f_print(fout, "#include <rx/xdr.h>\n");
 823             f_print(fout, "#include <rx/rx.h>\n");
 824             if (xflag) {
 825                 f_print(fout, "#include <rx/rx_globals.h>\n");
 826             }
 827             f_print(fout, "#include <afs/rxgen_consts.h>\n");
 828         }
 829     }
 830
 831     write_int32_macros(fout);
 832
 833     tell = ftell(fout);
 834     fflush(fout);
 835     while (def = get_definition()) {
 836         fflush(fout);
 837         print_datadef(def);
 838     }
 839
 840     er_Proc_CodeGeneration();
 841
 842     if (extend && tell == ftell(fout)) {
 843         (void) unlink(outfilename);
 844     }
 845     Sflag = 0;
 846 }
 847
 848 char *uppercase(str)
 849 char *str;
 850 {
 851     static char max_size[100];
 852     char *pnt;
 853     int len = strlen(str);
 854
 855     for (pnt = max_size; len > 0; len--, str++) {
 856         *pnt++ = (islower(*str) ? toupper(*str) : *str);
 857     }
 858     *pnt = '\0';
 859     return max_size;
 860 }
 861
 862 /*
 863  * Parse command line arguments
 864  */
 865 static
 866 parseargs(argc, argv, cmd)
 867         int argc;
 868         char *argv[];
 869         struct commandline *cmd;
 870
 871 {
 872         int i;
 873         int j;
 874         char c;
 875         char flag[(1 << 8 * sizeof(char))];
 876         int nflags;
 877
 878         cmdname = argv[0];
 879         cmd->infile = cmd->outfile = NULL;
 880         if (argc < 2) {
 881                 return (0);
 882         }
 883         memset(flag, 0, sizeof(flag));
 884         cmd->outfile = NULL;
 885         for (i = 1; i < argc; i++) {
 886                 if (argv[i][0] != '-') {
 887                         if (cmd->infile) {
 888                                 return (0);
 889                         }
 890                         cmd->infile = argv[i];
 891                 } else {
 892                         for (j = 1; argv[i][j] != 0; j++) {
 893                                 c = argv[i][j];
 894                                 switch (c) {
 895                                 case 'c':
 896                                 case 'h':
 897                                 case 'l':
 898                                 case 'm':
 899                                 case 'C':
 900                                 case 'S':
 901                                 case 'r':
 902                                 case 'R':
 903                                 case 'k':
 904                                 case 'p':
 905                                 case 'd':
 906                                 case 'x':
 907                                 case 'y':
 908                                 case 'z':
 909                                         if (flag[c]) {
 910                                                 return (0);
 911                                         }
 912                                         flag[c] = 1;
 913                                         break;
 914                                 case 'o':
 915                                 case 's':
 916                                         if (argv[i][j - 1] != '-' ||
 917                                             argv[i][j + 1] != 0) {
 918                                                 return (0);
 919                                         }
 920                                         flag[c] = 1;
 921                                         if (++i == argc) {
 922                                                 return (0);
 923                                         }
 924                                         if (c == 's') {
 925                                                 if (!streq(argv[i], "udp") &&
 926                                                     !streq(argv[i], "tcp")) {
 927                                                         return (0);
 928                                                 }
 929                                         } else if (c == 'o') {
 930                                                 if (cmd->outfile) {
 931                                                         return (0);
 932                                                 }
 933                                                 cmd->outfile = argv[i];
 934                                         }
 935                                         goto nextarg;
 936                                 case 'P':
 937                                         if (argv[i][j-1] != '-')
 938                                             return(0);
 939                                         prefix = &argv[i][j+1];
 940                                         goto nextarg;
 941                                 case 'I':
 942                                         if (argv[i][j-1] != '-')
 943                                             return(0);
 944                                         IncludeDir[nincludes++]= &argv[i][j-1];
 945                                         goto nextarg;
 946                                 default:
 947                                         return (0);
 948                                 }
 949                         }
 950         nextarg:
 951                         ;
 952                 }
 953         }
 954         cmd->cflag = cflag = flag['c'];
 955         cmd->hflag = hflag = flag['h'];
 956         cmd->sflag = flag['s'];
 957         cmd->lflag = flag['l'];
 958         cmd->mflag = flag['m'];
 959         cmd->xflag = xflag = flag['x'];
 960         cmd->yflag = yflag = flag['y'];
 961         cmd->Cflag = Cflag = flag['C'];
 962         cmd->Sflag = Sflag = flag['S'];
 963         cmd->rflag = flag['r'];
 964         cmd->kflag = kflag = flag['k'];
 965         cmd->pflag = flag['p'];
 966         cmd->dflag = debug = flag['d'];
 967         zflag = flag['z'];
 968         if (cmd->pflag) combinepackages = 1;
 969         nflags = cmd->cflag + cmd->hflag + cmd->sflag + cmd->lflag + cmd->mflag + cmd->Cflag + cmd->Sflag + cmd->rflag;
 970         if (nflags == 0) {
 971                 if (cmd->outfile != NULL || cmd->infile == NULL) {
 972                         return (0);
 973                 }
 974         } else if (nflags > 1) {
 975                 return (0);
 976         }
 977         return (1);
 978 }