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