Commit | Line | Data |
---|---|---|
832026c6 C |
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 | } |