![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to migcom.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / mig|
Return to migcom.c CVS log | Up to [GnuMach] / Gnu-Mach / mig |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1993,1991,1990 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie the
24: * rights to redistribute these changes.
25: */
26:
27: /*
28: * Switches are;
29: * -[v,Q] verbose or not quiet: prints out type
30: * and routine information as mig runs.
31: * -[V,q] not verbose or quiet : don't print
32: * information during compilation
33: * (this is the default)
34: * -[r,R] do or don't use rpc calls instead of
35: * send/receive pairs. Default is -r.
36: * -[s,S] generate symbol table or not: generate a
37: * table of rpc-name, number, routine triplets
38: * as an external data structure -- main use is
39: * for protection system's specification of rights
40: * and for protection dispatch code. Default is -s.
41: * -i <prefix>
42: * Put each user routine in its own file. The
43: * file is named <prefix><routine-name>.c.
44: * -user <name>
45: * Name the user-side file <name>
46: * -server <name>
47: * Name the server-side file <name>
48: * -header <name>
49: * Name the user-side header file <name>
50: * -iheader <name>
51: * Name the user-side internal header file <name>
52: * -sheader <name>
53: * NAme the server-side header file <name>
54: *
55: * DESIGN:
56: * Mig uses a lexxer module created by lex from lexxer.l and
57: * a parser module created by yacc from parser.y to parse an
58: * interface definitions module for a mach server.
59: * The parser module calls routines in statement.c
60: * and routines.c to build a list of statement structures.
61: * The most interesting statements are the routine definitions
62: * which contain information about the name, type, characteristics
63: * of the routine, an argument list containing information for
64: * each argument type, and a list of special arguments. The
65: * argument type structures are build by routines in type.c
66: * Once parsing is completed, the three code generation modules:
67: * header.c user.c and server.c are called sequentially. These
68: * do some code generation directly and also call the routines
69: * in utils.c for common (parameterized) code generation.
70: *
71: */
72:
73: #include <stdio.h>
74:
75: #include "error.h"
76: #include "lexxer.h"
77: #include "global.h"
78: #include "write.h"
79:
80: extern int yyparse();
81: static FILE *myfopen(const char *name, const char *mode);
82:
83: static void
84: parseArgs(int argc, char **argv)
85: {
86: while (--argc > 0)
87: if ((++argv)[0][0] == '-')
88: {
89: switch (argv[0][1])
90: {
91: case 'q':
92: BeQuiet = TRUE;
93: break;
94: case 'Q':
95: BeQuiet = FALSE;
96: break;
97: case 'v':
98: BeVerbose = TRUE;
99: break;
100: case 'V':
101: BeVerbose = FALSE;
102: break;
103: case 'r':
104: UseMsgRPC = TRUE;
105: break;
106: case 'R':
107: UseMsgRPC = FALSE;
108: break;
109: case 's':
110: if (streql(argv[0], "-server"))
111: {
112: --argc; ++argv;
113: if (argc == 0)
114: fatal("missing name for -server option");
115: ServerFileName = strmake(argv[0]);
116: }
117: else if (streql(argv[0], "-sheader"))
118: {
119: --argc; ++argv;
120: if (argc == 0)
121: fatal ("missing name for -sheader option");
122: ServerHeaderFileName = strmake(argv[0]);
123: }
124: else if (streql(argv[0], "-subrprefix"))
125: {
126: --argc; ++argv;
127: if (argc == 0)
128: fatal ("missing string for -subrprefix option");
129: SubrPrefix = strmake(argv[0]);
130: }
131: else
132: GenSymTab = TRUE;
133: break;
134: case 'S':
135: GenSymTab = FALSE;
136: break;
137: case 'i':
138: if (streql(argv[0], "-iheader"))
139: {
140: --argc; ++argv;
141: if (argc == 0)
142: fatal("missing name for -iheader option");
143: InternalHeaderFileName = strmake(argv[0]);
144: }
145: else
146: {
147: --argc; ++argv;
148: if (argc == 0)
149: fatal("missing prefix for -i option");
150: UserFilePrefix = strmake(argv[0]);
151: }
152: break;
153: case 'u':
154: if (streql(argv[0], "-user"))
155: {
156: --argc; ++argv;
157: if (argc == 0)
158: fatal("missing name for -user option");
159: UserFileName = strmake(argv[0]);
160: }
161: else
162: fatal("unknown flag: '%s'", argv[0]);
163: break;
164: case 'h':
165: if (streql(argv[0], "-header"))
166: {
167: --argc; ++argv;
168: if (argc == 0)
169: fatal("missing name for -header option");
170: UserHeaderFileName = strmake(argv[0]);
171: }
172: else
173: fatal("unknown flag: '%s'", argv[0]);
174: break;
175: case 'p':
176: if (streql(argv[0], "-prefix"))
177: {
178: if (--argc == 0)
179: fatal ("missing string for -prefix option");
180: RoutinePrefix = strmake(*++argv);
181: }
182: break;
183: default:
184: fatal("unknown flag: '%s'", argv[0]);
185: /*NOTREACHED*/
186: }
187: }
188: else
189: fatal("bad argument: '%s'", *argv);
190: }
191:
192: void
193: main(int argc, char **argv)
194: {
195: FILE *uheader, *server, *user;
196: FILE *iheader, *sheader;
197:
198: set_program_name("mig");
199: parseArgs(argc, argv);
200: init_global();
201: init_type();
202:
203: LookNormal();
204: (void) yyparse();
205:
206: if (errors > 0)
207: exit(1);
208:
209: more_global();
210:
211: uheader = myfopen(UserHeaderFileName, "w");
212: if (!UserFilePrefix)
213: user = myfopen(UserFileName, "w");
214: server = myfopen(ServerFileName, "w");
215: if (ServerHeaderFileName)
216: sheader = myfopen(ServerHeaderFileName, "w");
217: if (IsKernelServer)
218: {
219: iheader = myfopen(InternalHeaderFileName, "w");
220: }
221:
222: if (BeVerbose)
223: {
224: printf("Writing %s ... ", UserHeaderFileName);
225: fflush(stdout);
226: }
227: WriteUserHeader(uheader, StatementList);
228: fclose(uheader);
229: if (ServerHeaderFileName)
230: {
231: if (BeVerbose)
232: {
233: printf ("done.\nWriting %s ...", ServerHeaderFileName);
234: fflush (stdout);
235: }
236: WriteServerHeader(sheader, StatementList);
237: fclose(sheader);
238: }
239: if (IsKernelServer)
240: {
241: if (BeVerbose)
242: {
243: printf("done.\nWriting %s ... ", InternalHeaderFileName);
244: fflush(stdout);
245: }
246: WriteInternalHeader(iheader, StatementList);
247: fclose(iheader);
248: }
249: if (UserFilePrefix)
250: {
251: if (BeVerbose)
252: {
253: printf("done.\nWriting individual user files ... ");
254: fflush(stdout);
255: }
256: WriteUserIndividual(StatementList);
257: }
258: else
259: {
260: if (BeVerbose)
261: {
262: printf("done.\nWriting %s ... ", UserFileName);
263: fflush(stdout);
264: }
265: WriteUser(user, StatementList);
266: fclose(user);
267: }
268: if (BeVerbose)
269: {
270: printf("done.\nWriting %s ... ", ServerFileName);
271: fflush(stdout);
272: }
273: WriteServer(server, StatementList);
274: fclose(server);
275: if (BeVerbose)
276: printf("done.\n");
277:
278: exit(0);
279: }
280:
281: static FILE *
282: myfopen(const char *name, const char *mode)
283: {
284: const char *realname;
285: FILE *file;
286: extern int errno;
287:
288: if (name == strNULL)
289: realname = "/dev/null";
290: else
291: realname = name;
292:
293: file = fopen(realname, mode);
294: if (file == NULL)
295: fatal("fopen(%s): %s", realname, unix_error_string(errno));
296:
297: return file;
298: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.