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