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