![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gram.exec CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / efl|
Return to gram.exec CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / efl |
1.1 root 1: exec: beginexec exec1
2: { TEST fprintf(diagfile, "exec done\n"); }
3: ;
4:
5: beginexec:
6: { $$ = bgnexec(); if(ncases > 0) ncases = 0; }
7: ;
8:
9: exec1: lhs ASGNOP expr
10: {
11: if($1->tag==TCALL)
12: {
13: dclerr("no statement functions in EFL",
14: $1->sthead->namep);
15: frexpr($1);
16: frexpr($3);
17: }
18: else exasgn($1,$2,$3);
19: }
20: | DOUBLEADDOP lhs
21: { exasgn($2, $1, mkint(1) ); }
22: | lhs1
23: { excall($1); }
24: | CALL lhs1
25: { excall($2); }
26: | debug exec enddebug
27: | LBRACK beginblock stats endblock RBRACK
28: { TEST fprintf(diagfile, "exec: { stats }\n");
29: addexec(); }
30: | labels exec1
31: { thisexec->labeled = 1; }
32: | control
33: { thisexec->uniffable = 1; popctl(); }
34: | branch
35: { thisexec->brnchend = 1; }
36: | iostat
37: { exio($1, 0); }
38: | null
39: { exnull(); }
40: | ESCAPE
41: {
42: exnull();
43: putsii(ICCOMMENT, $1);
44: cfree($1);
45: exnull();
46: }
47: ;
48:
49: null:
50: { TEST fprintf(diagfile, "exec:empty\n"); }
51: | CONTINUE
52: { TEST fprintf(diagfile, "exec: continue\n"); }
53: ;
54:
55: beginblock:
56: {
57: thisexec->copylab = 1;
58: ++blklevel;
59: dclsect = 1;
60: ndecl[blklevel] = 0;
61: nhid [blklevel] = 0;
62: }
63: ;
64:
65: endblock:
66: {
67: if(ndecl[blklevel]) unhide();
68: --blklevel;
69: dclsect = 0;
70: }
71: ;
72:
73: labels: NAME COLON contnu
74: { mklabel($1,YES); }
75: | CONST contnu
76: { mklabel(mkilab($1),YES); }
77: | CONST contnu COLON contnu
78: { mklabel(mkilab($1),YES); }
79: | DEFAULT COLON contnu
80: { brkcase(); mkcase(PNULL,1); }
81: | CASE { brkcase(); } caselist COLON contnu
82: ;
83:
84: caselist: expr
85: { mkcase($1,1); }
86: | caselist COMMA expr
87: { mkcase($3,1); }
88: ;
89:
90: control: ifclause contnu exec EOS ELSE elsecode contnu exec
91: { TEST fprintf(diagfile, "if-then-else\n");
92: i = $3->brnchend & $8->brnchend;
93: addexec();
94: $$ = addexec();
95: thisexec->brnchend = i;
96: TEST fprintf(diagfile, "exec: if(expr) exec else exec\n"); }
97: | ifclause contnu exec EOS
98: { TEST fprintf(diagfile, "if-then\n");
99: pushlex = 1;
100: yyclearin;
101: $$ = ifthen();
102: TEST fprintf(diagfile, "exec: if(expr) exec\n"); }
103: | repeat contnu exec until
104: { TEST fprintf(diagfile, "repeat done\n"); }
105: | leftcont contnu exec
106: { TEST fprintf(diagfile, "exec: control exec\n"); $$ = addexec(); }
107: ;
108:
109: ifclause: IF LPAR expr RPAR
110: { pushctl(STIF,$3); }
111: ;
112:
113: elsecode:
114: {
115: if(thisctl->breaklab == 0)
116: thisctl->breaklab = nextlab();
117: /* if(thisexec->prevexec->brnchend == 0) */
118: exgoto(thisctl->breaklab);
119: exlab( indifs[thisctl->indifn] = nextlab() );
120: }
121: ;
122:
123: repeat: REPEAT
124: { pushctl(STREPEAT, PNULL); }
125: ;
126:
127: until: EOS
128: { pushlex = 1;
129: yyclearin;
130: $$ = addexec();
131: exgoto(thisctl->xlab);
132: TEST fprintf(diagfile, " no until\n"); }
133: | EOS UNTIL LPAR expr RPAR
134: { $$ = addexec();
135: exnull();
136: exlab( indifs[thisctl->indifn] = nextlab() );
137: exifgo(mknode(TNOTOP,OPNOT,$4,PNULL), thisctl->xlab);
138: TEST fprintf(diagfile, "until\n");
139: }
140: ;
141:
142: branch: RETURN
143: { exretn(PNULL); }
144: | RETURN expr
145: { exretn($2); }
146: | break
147: | GOTO label
148: { exgoto($2); }
149: | GO NAME label
150: { if( !equals($2->namep, "to") )
151: execerr("go %s ??\n", $2->namep);
152: else exgoto($3);
153: }
154: | GOTO parlablist compgotoindex
155: { excompgoto($2, $3); }
156: | GO NAME parlablist compgotoindex
157: { if(!equals($2->namep, "to") )
158: execerr("go %s ??\n", $2->namep);
159: else excompgoto($3, $4);
160: }
161: ;
162:
163: parlablist: LPAR lablist RPAR
164: { $$ = $2; }
165: ;
166:
167:
168: lablist: label
169: { $$ = mkchain($1,CHNULL); }
170: | lablist COMMA label
171: { $$ = hookup($1, mkchain($3,CHNULL) ); }
172: ;
173:
174: compgotoindex: expr
175: | COMMA expr
176: { $$ = $2; }
177: ;
178:
179:
180: label: NAME
181: { $$ = mklabel($1,NO); }
182: | CONST
183: { $$ = mklabel(mkilab($1),NO); }
184: | CASE expr
185: { $$ = mkcase($2,0); }
186: | DEFAULT
187: { $$ = mkcase(PNULL,0); }
188: ;
189:
190: break: brk
191: { exbrk($1, PNULL, 0); }
192: | brk CONST
193: { exbrk($1, $2, 0); }
194: | brk blocktype
195: { exbrk($1, PNULL, $2); }
196: | brk CONST blocktype
197: { exbrk($1,$2,$3); }
198: | brk blocktype CONST
199: { exbrk($1,$3,$2); }
200: ;
201:
202: brk: NEXT { $$ = 1; }
203: | BREAK { $$ = 0; }
204: | EXIT { $$ = 0; }
205: ;
206:
207: blocktype: WHILE { $$ = STWHILE; }
208: | FOR { $$ = STFOR; }
209: | DO { $$ = STDO; }
210: | REPEAT { $$ = STREPEAT; }
211: | SWITCH { $$ = STSWITCH; }
212: | PROCEDURE { $$ = STPROC; }
213: ;
214:
215: leftcont: WHILE LPAR exprnull RPAR
216: { pushctl(STWHILE, $3);
217: TEST fprintf(diagfile, "while(expr)\n"); }
218: | for forinit fortest forincr
219: { exlab(thisctl->xlab);
220: if($3)
221: exifgo(mknode(TNOTOP,OPNOT,$3,PNULL),
222: thisctl->breaklab = nextlab() );
223: else exnull();
224: TEST fprintf(diagfile, "for (forlist)\n"); }
225: | SWITCH LPAR expr RPAR
226: { pushctl(STSWITCH, simple(LVAL,$3));
227: TEST fprintf(diagfile, "switch (expr)\n"); }
228: | do
229: { pushctl(STDO, $1);
230: TEST fprintf(diagfile, "do loop\n"); }
231: ;
232:
233: do: DO expr EOS contnu
234: { $$ = doloop($2, PNULL, PNULL); }
235: | DO expr contnu
236: { $$ = doloop($2, PNULL, PNULL); }
237: | DO expr COMMA expr EOS contnu
238: { $$ = doloop($2, $4, PNULL); }
239: | DO expr COMMA expr contnu
240: { $$ = doloop($2, $4, PNULL); }
241: | DO expr COMMA expr COMMA expr EOS contnu
242: { $$ = doloop($2,$4,$6); }
243: | DO expr COMMA expr COMMA expr contnu
244: { $$ = doloop($2,$4,$6); }
245: ;
246:
247: for: FOR LPAR
248: { pushctl(STFOR, PNULL); }
249: ;
250:
251: forinit: exec COMMA
252: { exgoto(thisctl->xlab);
253: exlab(thisctl->nextlab);
254: addexec();
255: }
256: | exec EOS contnu COMMA
257: { exgoto(thisctl->xlab);
258: exlab(thisctl->nextlab);
259: addexec();
260: }
261: ;
262:
263: fortest: exprnull COMMA
264: ;
265:
266: forincr: exec RPAR
267: { addexec(); }
268: | exec EOS contnu RPAR
269: { addexec(); }
270: ;
271:
272: exprnull: { $$ = 0; }
273: | expr
274: ;
275:
276: debug: DEBUG contnu
277: { if(dbgopt) ++dbglevel; }
278: ;
279:
280: enddebug:
281: { if(dbgopt) --dbglevel; }
282: ;
283:
284: iostat: iokwd LPAR iounit COMMA iolist RPAR
285: { $$ = mkiost($1, $3, $5); }
286: ;
287:
288: iokwd: READBIN { $$ = 0; }
289: | WRITEBIN { $$ = 1; }
290: | READ { $$ = 2; }
291: | WRITE { $$ = 3; }
292: ;
293:
294: iounit: expr
295: | { $$ = NULL; }
296: ;
297:
298: iolist: ioitem { $$ = mkchain($1,CHNULL); }
299: | iolist COMMA ioitem { hookup($1, mkchain($3,CHNULL)); }
300: ;
301:
302: ioitem: expr { $$ = mkioitem($1,CNULL); }
303: | expr COLON format { $$ = mkioitem($1,$3); }
304: | COLON format { $$ = mkioitem(PNULL,$2); }
305: | iobrace { $$ = mkiogroup($1, CNULL, PNULL); }
306: | do iobrace { $$ = mkiogroup($2, CNULL, $1); }
307: | do iobrace COLON format { $$ = mkiogroup($2,$4,$1); }
308: | iobrace COLON format { $$ = mkiogroup($1,$3,PNULL); }
309: ;
310:
311: iobrace: LBRACK { ++iobrlevel; } iolist RBRACK
312: { --iobrlevel; $$ = $3; }
313: ;
314:
315: format: letter
316: { $$ = mkformat($1, PNULL, PNULL); }
317: | letter LPAR expr RPAR
318: { $$ = mkformat($1, $3, PNULL); }
319: | letter LPAR expr COMMA expr RPAR
320: { $$ = mkformat($1,$3,$5); }
321: | letton CONST lettoff
322: { $$ = $2->leftp; frexpblock($2); }
323: ;
324:
325: letter: letton LETTER lettoff { $$ = $2; }
326: ;
327:
328: letton: { lettneed = YES;}
329: ;
330:
331: lettoff: { lettneed = NO; }
332: ;
333:
334: %%
335:
336: setyydeb()
337: {
338: #ifdef YYDEBUG
339: extern int yydebug;
340: yydebug = 1;
341: #endif
342: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.