![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to parser.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / mig|
Return to parser.y CVS log | Up to [GnuMach] / Gnu-Mach / mig |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 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: %token sySkip
28: %token syRoutine
29: %token sySimpleRoutine
30: %token sySimpleProcedure
31: %token syProcedure
32: %token syFunction
33:
34: %token sySubsystem
35: %token syKernelUser
36: %token syKernelServer
37:
38: %token syMsgOption
39: %token syMsgSeqno
40: %token syWaitTime
41: %token syNoWaitTime
42: %token syErrorProc
43: %token syServerPrefix
44: %token syUserPrefix
45: %token syServerDemux
46: %token syRCSId
47:
48: %token syImport
49: %token syUImport
50: %token sySImport
51:
52: %token syIn
53: %token syOut
54: %token syInOut
55: %token syRequestPort
56: %token syReplyPort
57: %token sySReplyPort
58: %token syUReplyPort
59:
60: %token syType
61: %token syArray
62: %token syStruct
63: %token syOf
64:
65: %token syInTran
66: %token syOutTran
67: %token syDestructor
68: %token syCType
69: %token syCUserType
70: %token syCServerType
71:
72: %token syCString
73:
74: %token syColon
75: %token sySemi
76: %token syComma
77: %token syPlus
78: %token syMinus
79: %token syStar
80: %token syDiv
81: %token syLParen
82: %token syRParen
83: %token syEqual
84: %token syCaret
85: %token syTilde
86: %token syLAngle
87: %token syRAngle
88: %token syLBrack
89: %token syRBrack
90: %token syBar
91:
92: %token syError /* lex error */
93:
94: %token <number> syNumber
95: %token <symtype> sySymbolicType
96: %token <identifier> syIdentifier
97: %token <string> syString syQString
98: %token <string> syFileName
99: %token <flag> syIPCFlag
100:
101: %left syPlus,syMinus
102: %left syStar,syDiv
103:
104:
105: %type <statement_kind> ImportIndicant
106: %type <number> VarArrayHead ArrayHead StructHead IntExp
107: %type <type> NamedTypeSpec TransTypeSpec TypeSpec
108: %type <type> CStringSpec
109: %type <type> BasicTypeSpec PrevTypeSpec ArgumentType
110: %type <symtype> PrimIPCType IPCType
111: %type <routine> RoutineDecl Routine SimpleRoutine
112: %type <routine> Procedure SimpleProcedure Function
113: %type <direction> Direction
114: %type <argument> Argument Arguments ArgumentList
115: %type <flag> IPCFlags
116:
117: %{
118:
119: #include <stdio.h>
120:
121: #include "error.h"
122: #include "lexxer.h"
123: #include "global.h"
124: #include "mig_string.h"
125: #include "type.h"
126: #include "routine.h"
127: #include "statement.h"
128:
129: static const char *import_name(statement_kind_t sk);
130:
131: void
132: yyerror(const char *s)
133: {
134: error(s);
135: }
136: %}
137:
138: %union
139: {
140: u_int number;
141: identifier_t identifier;
142: const_string_t string;
143: statement_kind_t statement_kind;
144: ipc_type_t *type;
145: struct
146: {
147: u_int innumber; /* msgt_name value, when sending */
148: const_string_t instr;
149: u_int outnumber; /* msgt_name value, when receiving */
150: const_string_t outstr;
151: u_int size; /* 0 means there is no default size */
152: } symtype;
153: routine_t *routine;
154: arg_kind_t direction;
155: argument_t *argument;
156: ipc_flags_t flag;
157: }
158:
159: %%
160:
161: Statements : /* empty */
162: | Statements Statement
163: ;
164:
165: Statement : Subsystem sySemi
166: | WaitTime sySemi
167: | MsgOption sySemi
168: | Error sySemi
169: | ServerPrefix sySemi
170: | UserPrefix sySemi
171: | ServerDemux sySemi
172: | TypeDecl sySemi
173: | RoutineDecl sySemi
174: {
175: register statement_t *st = stAlloc();
176:
177: st->stKind = skRoutine;
178: st->stRoutine = $1;
179: rtCheckRoutine($1);
180: if (BeVerbose)
181: rtPrintRoutine($1);
182: }
183: | sySkip sySemi
184: { rtSkip(1); }
185: | sySkip syNumber sySemi
186: { rtSkip($2); }
187: | Import sySemi
188: | RCSDecl sySemi
189: | sySemi
190: | error sySemi
191: { yyerrok; }
192: ;
193:
194: Subsystem : SubsystemStart SubsystemMods
195: SubsystemName SubsystemBase
196: {
197: if (BeVerbose)
198: {
199: printf("Subsystem %s: base = %u%s%s\n\n",
200: SubsystemName, SubsystemBase,
201: IsKernelUser ? ", KernelUser" : "",
202: IsKernelServer ? ", KernelServer" : "");
203: }
204: }
205: ;
206:
207: SubsystemStart : sySubsystem
208: {
209: if (SubsystemName != strNULL)
210: {
211: warn("previous Subsystem decl (of %s) will be ignored", SubsystemName);
212: IsKernelUser = FALSE;
213: IsKernelServer = FALSE;
214: strfree((string_t) SubsystemName);
215: }
216: }
217: ;
218:
219: SubsystemMods : /* empty */
220: | SubsystemMods SubsystemMod
221: ;
222:
223: SubsystemMod : syKernelUser
224: {
225: if (IsKernelUser)
226: warn("duplicate KernelUser keyword");
227: IsKernelUser = TRUE;
228: }
229: | syKernelServer
230: {
231: if (IsKernelServer)
232: warn("duplicate KernelServer keyword");
233: IsKernelServer = TRUE;
234: }
235: ;
236:
237: SubsystemName : syIdentifier { SubsystemName = $1; }
238: ;
239:
240: SubsystemBase : syNumber { SubsystemBase = $1; }
241: ;
242:
243: MsgOption : LookString syMsgOption syString
244: {
245: if (streql($3, "MACH_MSG_OPTION_NONE"))
246: {
247: MsgOption = strNULL;
248: if (BeVerbose)
249: printf("MsgOption: canceled\n\n");
250: }
251: else
252: {
253: MsgOption = $3;
254: if (BeVerbose)
255: printf("MsgOption %s\n\n",$3);
256: }
257: }
258: ;
259:
260: WaitTime : LookString syWaitTime syString
261: {
262: WaitTime = $3;
263: if (BeVerbose)
264: printf("WaitTime %s\n\n", WaitTime);
265: }
266: | syNoWaitTime
267: {
268: WaitTime = strNULL;
269: if (BeVerbose)
270: printf("NoWaitTime\n\n");
271: }
272: ;
273:
274: Error : syErrorProc syIdentifier
275: {
276: ErrorProc = $2;
277: if (BeVerbose)
278: printf("ErrorProc %s\n\n", ErrorProc);
279: }
280: ;
281:
282: ServerPrefix : syServerPrefix syIdentifier
283: {
284: ServerPrefix = $2;
285: if (BeVerbose)
286: printf("ServerPrefix %s\n\n", ServerPrefix);
287: }
288: ;
289:
290: UserPrefix : syUserPrefix syIdentifier
291: {
292: UserPrefix = $2;
293: if (BeVerbose)
294: printf("UserPrefix %s\n\n", UserPrefix);
295: }
296: ;
297:
298: ServerDemux : syServerDemux syIdentifier
299: {
300: ServerDemux = $2;
301: if (BeVerbose)
302: printf("ServerDemux %s\n\n", ServerDemux);
303: }
304: ;
305:
306: Import : LookFileName ImportIndicant syFileName
307: {
308: register statement_t *st = stAlloc();
309: st->stKind = $2;
310: st->stFileName = $3;
311:
312: if (BeVerbose)
313: printf("%s %s\n\n", import_name($2), $3);
314: }
315: ;
316:
317: ImportIndicant : syImport { $$ = skImport; }
318: | syUImport { $$ = skUImport; }
319: | sySImport { $$ = skSImport; }
320: ;
321:
322: RCSDecl : LookQString syRCSId syQString
323: {
324: if (RCSId != strNULL)
325: warn("previous RCS decl will be ignored");
326: if (BeVerbose)
327: printf("RCSId %s\n\n", $3);
328: RCSId = $3;
329: }
330: ;
331:
332: TypeDecl : syType NamedTypeSpec
333: {
334: register identifier_t name = $2->itName;
335:
336: if (itLookUp(name) != itNULL)
337: warn("overriding previous definition of %s", name);
338: itInsert(name, $2);
339: }
340: ;
341:
342: NamedTypeSpec : syIdentifier syEqual TransTypeSpec
343: { itTypeDecl($1, $$ = $3); }
344: ;
345:
346: TransTypeSpec : TypeSpec
347: { $$ = itResetType($1); }
348: | TransTypeSpec syInTran syColon syIdentifier
349: syIdentifier syLParen syIdentifier syRParen
350: {
351: $$ = $1;
352:
353: if (($$->itTransType != strNULL) && !streql($$->itTransType, $4))
354: warn("conflicting translation types (%s, %s)",
355: $$->itTransType, $4);
356: $$->itTransType = $4;
357:
358: if (($$->itInTrans != strNULL) && !streql($$->itInTrans, $5))
359: warn("conflicting in-translation functions (%s, %s)",
360: $$->itInTrans, $5);
361: $$->itInTrans = $5;
362:
363: if (($$->itServerType != strNULL) && !streql($$->itServerType, $7))
364: warn("conflicting server types (%s, %s)",
365: $$->itServerType, $7);
366: $$->itServerType = $7;
367: }
368: | TransTypeSpec syOutTran syColon syIdentifier
369: syIdentifier syLParen syIdentifier syRParen
370: {
371: $$ = $1;
372:
373: if (($$->itServerType != strNULL) && !streql($$->itServerType, $4))
374: warn("conflicting server types (%s, %s)",
375: $$->itServerType, $4);
376: $$->itServerType = $4;
377:
378: if (($$->itOutTrans != strNULL) && !streql($$->itOutTrans, $5))
379: warn("conflicting out-translation functions (%s, %s)",
380: $$->itOutTrans, $5);
381: $$->itOutTrans = $5;
382:
383: if (($$->itTransType != strNULL) && !streql($$->itTransType, $7))
384: warn("conflicting translation types (%s, %s)",
385: $$->itTransType, $7);
386: $$->itTransType = $7;
387: }
388: | TransTypeSpec syDestructor syColon syIdentifier
389: syLParen syIdentifier syRParen
390: {
391: $$ = $1;
392:
393: if (($$->itDestructor != strNULL) && !streql($$->itDestructor, $4))
394: warn("conflicting destructor functions (%s, %s)",
395: $$->itDestructor, $4);
396: $$->itDestructor = $4;
397:
398: if (($$->itTransType != strNULL) && !streql($$->itTransType, $6))
399: warn("conflicting translation types (%s, %s)",
400: $$->itTransType, $6);
401: $$->itTransType = $6;
402: }
403: | TransTypeSpec syCType syColon syIdentifier
404: {
405: $$ = $1;
406:
407: if (($$->itUserType != strNULL) && !streql($$->itUserType, $4))
408: warn("conflicting user types (%s, %s)",
409: $$->itUserType, $4);
410: $$->itUserType = $4;
411:
412: if (($$->itServerType != strNULL) && !streql($$->itServerType, $4))
413: warn("conflicting server types (%s, %s)",
414: $$->itServerType, $4);
415: $$->itServerType = $4;
416: }
417: | TransTypeSpec syCUserType syColon syIdentifier
418: {
419: $$ = $1;
420:
421: if (($$->itUserType != strNULL) && !streql($$->itUserType, $4))
422: warn("conflicting user types (%s, %s)",
423: $$->itUserType, $4);
424: $$->itUserType = $4;
425: }
426: | TransTypeSpec syCServerType
427: syColon syIdentifier
428: {
429: $$ = $1;
430:
431: if (($$->itServerType != strNULL) && !streql($$->itServerType, $4))
432: warn("conflicting server types (%s, %s)",
433: $$->itServerType, $4);
434: $$->itServerType = $4;
435: }
436: ;
437:
438: TypeSpec : BasicTypeSpec
439: { $$ = $1; }
440: | PrevTypeSpec
441: { $$ = $1; }
442: | VarArrayHead TypeSpec
443: { $$ = itVarArrayDecl($1, $2); }
444: | ArrayHead TypeSpec
445: { $$ = itArrayDecl($1, $2); }
446: | syCaret TypeSpec
447: { $$ = itPtrDecl($2); }
448: | StructHead TypeSpec
449: { $$ = itStructDecl($1, $2); }
450: | CStringSpec
451: { $$ = $1; }
452: ;
453:
454: BasicTypeSpec : IPCType
455: {
456: $$ = itShortDecl($1.innumber, $1.instr,
457: $1.outnumber, $1.outstr,
458: $1.size);
459: }
460: | syLParen IPCType syComma IntExp
461: IPCFlags syRParen
462: {
463: $$ = itLongDecl($2.innumber, $2.instr,
464: $2.outnumber, $2.outstr,
465: $2.size, $4, $5);
466: }
467: ;
468:
469: IPCFlags : /* empty */
470: { $$ = flNone; }
471: | IPCFlags syComma syIPCFlag
472: {
473: if ($1 & $3)
474: warn("redundant IPC flag ignored");
475: else
476: $$ = $1 | $3;
477: }
478: | IPCFlags syComma syIPCFlag syLBrack syRBrack
479: {
480: if ($3 != flDealloc)
481: warn("only Dealloc is variable");
482: else
483: $$ = $1 | flMaybeDealloc;
484: }
485: ;
486:
487: PrimIPCType : syNumber
488: {
489: $$.innumber = $$.outnumber = $1;
490: $$.instr = $$.outstr = strNULL;
491: $$.size = 0;
492: }
493: | sySymbolicType
494: { $$ = $1; }
495: ;
496:
497: IPCType : PrimIPCType
498: { $$ = $1; }
499: | PrimIPCType syBar PrimIPCType
500: {
501: if ($1.size != $3.size)
502: {
503: if ($1.size == 0)
504: $$.size = $3.size;
505: else if ($3.size == 0)
506: $$.size = $1.size;
507: else
508: {
509: error("sizes in IPCTypes (%d, %d) aren't equal",
510: $1.size, $3.size);
511: $$.size = 0;
512: }
513: }
514: else
515: $$.size = $1.size;
516: $$.innumber = $1.innumber;
517: $$.instr = $1.instr;
518: $$.outnumber = $3.outnumber;
519: $$.outstr = $3.outstr;
520: }
521: ;
522:
523: PrevTypeSpec : syIdentifier
524: { $$ = itPrevDecl($1); }
525: ;
526:
527: VarArrayHead : syArray syLBrack syRBrack syOf
528: { $$ = 0; }
529: | syArray syLBrack syStar syRBrack syOf
530: { $$ = 0; }
531: | syArray syLBrack syStar syColon IntExp
532: syRBrack syOf
533: { $$ = $5; }
534: ;
535:
536: ArrayHead : syArray syLBrack IntExp syRBrack syOf
537: { $$ = $3; }
538: ;
539:
540: StructHead : syStruct syLBrack IntExp syRBrack syOf
541: { $$ = $3; }
542: ;
543:
544: CStringSpec : syCString syLBrack IntExp syRBrack
545: { $$ = itCStringDecl($3, FALSE); }
546: | syCString syLBrack syStar syColon
547: IntExp syRBrack
548: { $$ = itCStringDecl($5, TRUE); }
549: ;
550:
551: IntExp : IntExp syPlus IntExp
552: { $$ = $1 + $3; }
553: | IntExp syMinus IntExp
554: { $$ = $1 - $3; }
555: | IntExp syStar IntExp
556: { $$ = $1 * $3; }
557: | IntExp syDiv IntExp
558: { $$ = $1 / $3; }
559: | syNumber
560: { $$ = $1; }
561: | syLParen IntExp syRParen
562: { $$ = $2; }
563: ;
564:
565:
566: RoutineDecl : Routine { $$ = $1; }
567: | SimpleRoutine { $$ = $1; }
568: | Procedure { $$ = $1; }
569: | SimpleProcedure { $$ = $1; }
570: | Function { $$ = $1; }
571: ;
572:
573: Routine : syRoutine syIdentifier Arguments
574: { $$ = rtMakeRoutine($2, $3); }
575: ;
576:
577: SimpleRoutine : sySimpleRoutine syIdentifier Arguments
578: { $$ = rtMakeSimpleRoutine($2, $3); }
579: ;
580:
581: Procedure : syProcedure syIdentifier Arguments
582: { $$ = rtMakeProcedure($2, $3); }
583: ;
584:
585: SimpleProcedure : sySimpleProcedure syIdentifier Arguments
586: { $$ = rtMakeSimpleProcedure($2, $3); }
587: ;
588:
589: Function : syFunction syIdentifier Arguments ArgumentType
590: { $$ = rtMakeFunction($2, $3, $4); }
591: ;
592:
593: Arguments : syLParen syRParen
594: { $$ = argNULL; }
595: | syLParen ArgumentList syRParen
596: { $$ = $2; }
597:
598: ;
599:
600: ArgumentList : Argument
601: { $$ = $1; }
602: | Argument sySemi ArgumentList
603: {
604: $$ = $1;
605: $$->argNext = $3;
606: }
607: ;
608:
609: Argument : Direction syIdentifier ArgumentType IPCFlags
610: {
611: $$ = argAlloc();
612: $$->argKind = $1;
613: $$->argName = $2;
614: $$->argType = $3;
615: $$->argFlags = $4;
616: }
617: ;
618:
619: Direction : /* empty */ { $$ = akNone; }
620: | syIn { $$ = akIn; }
621: | syOut { $$ = akOut; }
622: | syInOut { $$ = akInOut; }
623: | syRequestPort { $$ = akRequestPort; }
624: | syReplyPort { $$ = akReplyPort; }
625: | sySReplyPort { $$ = akSReplyPort; }
626: | syUReplyPort { $$ = akUReplyPort; }
627: | syWaitTime { $$ = akWaitTime; }
628: | syMsgOption { $$ = akMsgOption; }
629: | syMsgSeqno { $$ = akMsgSeqno; }
630: ;
631:
632: ArgumentType : syColon syIdentifier
633: {
634: $$ = itLookUp($2);
635: if ($$ == itNULL)
636: error("type '%s' not defined", $2);
637: }
638: | syColon NamedTypeSpec
639: { $$ = $2; }
640: ;
641:
642: LookString : /* empty */
643: { LookString(); }
644: ;
645:
646: LookFileName : /* empty */
647: { LookFileName(); }
648: ;
649:
650: LookQString : /* empty */
651: { LookQString(); }
652: ;
653:
654: %%
655:
656: static const char *
657: import_name(statement_kind_t sk)
658: {
659: switch (sk)
660: {
661: case skImport:
662: return "Import";
663: case skSImport:
664: return "SImport";
665: case skUImport:
666: return "UImport";
667: default:
668: fatal("import_name(%d): not import statement", (int) sk);
669: /*NOTREACHED*/
670: }
671: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.