1 /* st.c -- Implementation File (module.c template V1.0)
2 Copyright (C) 1995 Free Software Foundation, Inc.
3 Contributed by James Craig Burley.
4
5 This file is part of GNU Fortran.
6
7 GNU Fortran is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GNU Fortran is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Fortran; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.
21
22 Related Modules:
23 None
24
25 Description:
26 The high-level input level to statement handling for the rest of the
27 FFE. ffest_first is the first state for the lexer to invoke to start
28 a statement. A statement normally starts with a NUMBER token (to indicate
29 a label def) followed by a NAME token (to indicate what kind of statement
30 it is), though of course the NUMBER token may be omitted. ffest_first
31 gathers the first NAME token and returns a state of ffest_second_,
32 where the trailing underscore means "internal to ffest" and thus outside
33 users should not depend on this. ffest_second_ then looks at the second
34 token in conjunction with the first, decides what possible statements are
35 meant, and tries each possible statement in turn, from most likely to
36 least likely. A successful attempt currently is recorded, and further
37 successful attempts by other possibilities raise an assertion error in
38 ffest_confirmed (this is to detect ambiguities). A failure in an
39 attempt is signaled by calling ffest_ffebad_start; this results in the
40 next token sent by ffest_save_ (the intermediary when more than one
41 possible statement exists) being EOS to shut down processing and the next
42 possibility tried.
43
44 When all possibilities have been tried, the successful one is retried with
45 inhibition turned off (FALSE) as reported by ffest_is_inhibited(). If
46 there is no successful one, the first one is retried so the user gets to
47 see the error messages.
48
49 In the future, after syntactic bugs have been reasonably shaken out and
50 ambiguities thus detected, the first successful possibility will be
51 enabled (inhibited goes FALSE) as soon as it confirms success by calling
52 ffest_confirmed, thus retrying the possibility will not be necessary.
53
54 The only complication in all this is that expression handling is
55 happening while possibilities are inhibited. It is up to the expression
56 handler, conceptually, to not make any changes to its knowledge base for
57 variable names and so on when inhibited that cannot be undone if
58 the current possibility fails (shuts down via ffest_ffebad_start). In
59 fact, this business is handled not be ffeexpr, but by lower levels.
60
61 ffesta functions serve only to provide information used in syntactic
62 processing of possible statements, and thus may not make changes to the
63 knowledge base for variables and such.
64
65 ffestb functions perform the syntactic analysis for possible statements,
66 and thus again may not make changes to the knowledge base except under the
67 auspices of ffeexpr and its subordinates, changes which can be undone when
68 necessary.
69
70 ffestc functions perform the semantic analysis for the chosen statement,
71 and thus may change the knowledge base as necessary since they are invoked
72 by ffestb functions only after a given statement is confirmed and
73 enabled. Note, however, that a few ffestc functions (identified by
74 their statement names rather than grammar numbers) indicate valid forms
75 that are, outside of any context, ambiguous, such as ELSE WHERE and
76 PRIVATE; these functions should make a quick decision as to what is
77 intended and dispatch to the appropriate specific ffestc function.
78
79 ffestd functions actually implement statements. When called, the
80 statement is considered valid and is either an executable statement or
81 a nonexecutable statement with direct-output results. For example, CALL,
82 GOTO, and assignment statements pass through ffestd because they are
83 executable; DATA statements pass through because they map directly to the
84 output file (or at least might so map); ENTRY statements also pass through
85 because they essentially affect code generation in an immediate way;
86 whereas INTEGER, SAVE, and SUBROUTINE statements do not go through
87 ffestd functions because they merely update the knowledge base.
88
89 Modifications:
90 */
91
92 /* Include files. */
93
94 #include "proj.h"
95 #include "st.h"
96 #include "bad.h"
97 #include "lex.h"
98 #include "sta.h"
99 #include "stb.h"
100 #include "stc.h"
101 #include "std.h"
102 #include "ste.h"
103 #include "stp.h"
104 #include "str.h"
105 #include "sts.h"
106 #include "stt.h"
107 #include "stu.h"
108 #include "stv.h"
109 #include "stw.h"
110
111 /* Externals defined here. */
112
113
114 /* Simple definitions and enumerations. */
115
116
117 /* Internal typedefs. */
118
119
120 /* Private include files. */
121
122
123 /* Internal structure definitions. */
124
125
126 /* Static objects accessed by functions in this module. */
127
128
129 /* Static functions (internal). */
130
131
132 /* Internal macros. */
133
134
135 /* ffest_confirmed -- Confirm current possibility as only one
136
137 ffest_confirmed();
138
139 Sets the confirmation flag. During debugging for ambiguous constructs,
140 asserts that the confirmation flag for a previous possibility has not
141 yet been set. */
142
143 void
ffest_confirmed()144 ffest_confirmed ()
145 {
146 ffesta_confirmed ();
147 }
148
149 /* ffest_eof -- End of (non-INCLUDEd) source file
150
151 ffest_eof();
152
153 Call after piping tokens through ffest_first, where the most recent
154 token sent through must be EOS.
155
156 20-Feb-91 JCB 1.1
157 Put new EOF token in ffesta_tokens[0], not NULL, because too much
158 code expects something there for error reporting and the like. Also,
159 do basically the same things ffest_second and ffesta_zero do for
160 processing a statement (make and destroy pools, et cetera). */
161
162 void
ffest_eof()163 ffest_eof ()
164 {
165 ffesta_eof ();
166 }
167
168 /* ffest_ffebad_here_current_stmt -- ffebad_here with ptr to current stmt
169
170 ffest_ffebad_here_current_stmt(0);
171
172 Outsiders can call this fn if they have no more convenient place to
173 point to (via a token or pair of ffewhere objects) and they know a
174 current, useful statement is being evaluted by ffest (i.e. they are
175 being called from ffestb, ffestc, ffestd, ... functions). */
176
177 void
ffest_ffebad_here_current_stmt(ffebadIndex i)178 ffest_ffebad_here_current_stmt (ffebadIndex i)
179 {
180 ffesta_ffebad_here_current_stmt (i);
181 }
182
183 /* ffest_ffebad_here_doiter -- Calls ffebad_here with ptr to DO iter var
184
185 ffesymbol s;
186 // call ffebad_start first, of course.
187 ffest_ffebad_here_doiter(0,s);
188 // call ffebad_finish afterwards, naturally.
189
190 Searches the stack of blocks backwards for a DO loop that has s
191 as its iteration variable, then calls ffebad_here with pointers to
192 that particular reference to the variable. Crashes if the DO loop
193 can't be found. */
194
195 void
ffest_ffebad_here_doiter(ffebadIndex i,ffesymbol s)196 ffest_ffebad_here_doiter (ffebadIndex i, ffesymbol s)
197 {
198 ffestc_ffebad_here_doiter (i, s);
199 }
200
201 /* ffest_ffebad_start -- Start a possibly inhibited error report
202
203 if (ffest_ffebad_start(FFEBAD_SOME_ERROR))
204 {
205 ffebad_here, ffebad_string ...;
206 ffebad_finish();
207 }
208
209 Call if the error might indicate that ffest is evaluating the wrong
210 statement form, instead of calling ffebad_start directly. If ffest
211 is choosing between forms, it will return FALSE, send an EOS/SEMICOLON
212 token through as the next token (if the current one isn't already one
213 of those), and try another possible form. Otherwise, ffebad_start is
214 called with the argument and TRUE returned. */
215
216 bool
ffest_ffebad_start(ffebad errnum)217 ffest_ffebad_start (ffebad errnum)
218 {
219 return ffesta_ffebad_start (errnum);
220 }
221
222 /* ffest_first -- Parse the first token in a statement
223
224 return ffest_first; // to lexer. */
225
226 ffelexHandler
ffest_first(ffelexToken t)227 ffest_first (ffelexToken t)
228 {
229 return ffesta_first (t);
230 }
231
232 /* ffest_init_0 -- Initialize for entire image invocation
233
234 ffest_init_0();
235
236 Call just once per invocation of the compiler (not once per invocation
237 of the front end).
238
239 Gets memory for the list of possibles once and for all, since this
240 list never gets larger than a certain size (FFEST_maxPOSSIBLES_)
241 and is not particularly large. Initializes the array of pointers to
242 this list. Initializes the executable and nonexecutable lists. */
243
244 void
ffest_init_0()245 ffest_init_0 ()
246 {
247 ffesta_init_0 ();
248 ffestb_init_0 ();
249 ffestc_init_0 ();
250 ffestd_init_0 ();
251 ffeste_init_0 ();
252 ffestp_init_0 ();
253 ffestr_init_0 ();
254 ffests_init_0 ();
255 ffestt_init_0 ();
256 ffestu_init_0 ();
257 ffestv_init_0 ();
258 ffestw_init_0 ();
259 }
260
261 /* ffest_init_1 -- Initialize for entire image invocation
262
263 ffest_init_1();
264
265 Call just once per invocation of the compiler (not once per invocation
266 of the front end).
267
268 Gets memory for the list of possibles once and for all, since this
269 list never gets larger than a certain size (FFEST_maxPOSSIBLES_)
270 and is not particularly large. Initializes the array of pointers to
271 this list. Initializes the executable and nonexecutable lists. */
272
273 void
ffest_init_1()274 ffest_init_1 ()
275 {
276 ffesta_init_1 ();
277 ffestb_init_1 ();
278 ffestc_init_1 ();
279 ffestd_init_1 ();
280 ffeste_init_1 ();
281 ffestp_init_1 ();
282 ffestr_init_1 ();
283 ffests_init_1 ();
284 ffestt_init_1 ();
285 ffestu_init_1 ();
286 ffestv_init_1 ();
287 ffestw_init_1 ();
288 }
289
290 /* ffest_init_2 -- Initialize for entire image invocation
291
292 ffest_init_2();
293
294 Call just once per invocation of the compiler (not once per invocation
295 of the front end).
296
297 Gets memory for the list of possibles once and for all, since this
298 list never gets larger than a certain size (FFEST_maxPOSSIBLES_)
299 and is not particularly large. Initializes the array of pointers to
300 this list. Initializes the executable and nonexecutable lists. */
301
302 void
ffest_init_2()303 ffest_init_2 ()
304 {
305 ffesta_init_2 ();
306 ffestb_init_2 ();
307 ffestc_init_2 ();
308 ffestd_init_2 ();
309 ffeste_init_2 ();
310 ffestp_init_2 ();
311 ffestr_init_2 ();
312 ffests_init_2 ();
313 ffestt_init_2 ();
314 ffestu_init_2 ();
315 ffestv_init_2 ();
316 ffestw_init_2 ();
317 }
318
319 /* ffest_init_3 -- Initialize for any program unit
320
321 ffest_init_3(); */
322
323 void
ffest_init_3()324 ffest_init_3 ()
325 {
326 ffesta_init_3 ();
327 ffestb_init_3 ();
328 ffestc_init_3 ();
329 ffestd_init_3 ();
330 ffeste_init_3 ();
331 ffestp_init_3 ();
332 ffestr_init_3 ();
333 ffests_init_3 ();
334 ffestt_init_3 ();
335 ffestu_init_3 ();
336 ffestv_init_3 ();
337 ffestw_init_3 ();
338
339 ffestw_display_state ();
340 }
341
342 /* ffest_init_4 -- Initialize for statement functions
343
344 ffest_init_4(); */
345
346 void
ffest_init_4()347 ffest_init_4 ()
348 {
349 ffesta_init_4 ();
350 ffestb_init_4 ();
351 ffestc_init_4 ();
352 ffestd_init_4 ();
353 ffeste_init_4 ();
354 ffestp_init_4 ();
355 ffestr_init_4 ();
356 ffests_init_4 ();
357 ffestt_init_4 ();
358 ffestu_init_4 ();
359 ffestv_init_4 ();
360 ffestw_init_4 ();
361 }
362
363 /* Test whether ENTRY statement is valid.
364
365 Returns TRUE if current program unit is known to be FUNCTION or SUBROUTINE.
366 Else returns FALSE. */
367
368 bool
ffest_is_entry_valid()369 ffest_is_entry_valid ()
370 {
371 return ffesta_is_entry_valid;
372 }
373
374 /* ffest_is_inhibited -- Test whether the current possibility is inhibited
375
376 if (!ffest_is_inhibited())
377 // implement the statement.
378
379 Just make sure the current possibility has been confirmed. If anyone
380 really needs to test whether the current possibility is inhibited prior
381 to confirming it, that indicates a need to begin statement processing
382 before it is certain that the given possibility is indeed the statement
383 to be processed. As of this writing, there does not appear to be such
384 a need. If there is, then when confirming a statement would normally
385 immediately disable the inhibition (whereas currently we leave the
386 confirmed statement disabled until we've tried the other possibilities,
387 to check for ambiguities), we must check to see if the possibility has
388 already tested for inhibition prior to confirmation and, if so, maintain
389 inhibition until the end of the statement (which may be forced right
390 away) and then rerun the entire statement from the beginning. Otherwise,
391 initial calls to ffestb functions won't have been made, but subsequent
392 calls (after confirmation) will, which is wrong. Of course, this all
393 applies only to those statements implemented via multiple calls to
394 ffestb, although if a statement requiring only a single ffestb call
395 tested for inhibition prior to confirmation, it would likely mean that
396 the ffestb call would be completely dropped without this mechanism. */
397
398 bool
ffest_is_inhibited()399 ffest_is_inhibited ()
400 {
401 return ffesta_is_inhibited ();
402 }
403
404 /* ffest_seen_first_exec -- Test whether first executable stmt has been seen
405
406 if (ffest_seen_first_exec())
407 // No more spec stmts can be seen.
408
409 In a case where, say, the first statement is PARAMETER(A)=B, FALSE
410 will be returned while the PARAMETER statement is being run, and TRUE
411 will be returned if it doesn't confirm and the assignment statement
412 is being run. */
413
414 bool
ffest_seen_first_exec()415 ffest_seen_first_exec ()
416 {
417 return ffesta_seen_first_exec;
418 }
419
420 /* Shut down current parsing possibility, but without bothering the
421 user with a diagnostic if we're not inhibited. */
422
423 void
ffest_shutdown()424 ffest_shutdown ()
425 {
426 ffesta_shutdown ();
427 }
428
429 /* ffest_sym_end_transition -- Update symbol info just before end of unit
430
431 ffesymbol s;
432 ffest_sym_end_transition(s); */
433
434 ffesymbol
ffest_sym_end_transition(ffesymbol s)435 ffest_sym_end_transition (ffesymbol s)
436 {
437 return ffestu_sym_end_transition (s);
438 }
439
440 /* ffest_sym_exec_transition -- Update symbol just before first exec stmt
441
442 ffesymbol s;
443 ffest_sym_exec_transition(s); */
444
445 ffesymbol
ffest_sym_exec_transition(ffesymbol s)446 ffest_sym_exec_transition (ffesymbol s)
447 {
448 return ffestu_sym_exec_transition (s);
449 }
450
451 /* ffest_terminate_0 -- Terminate for entire image invocation
452
453 ffest_terminate_0(); */
454
455 void
ffest_terminate_0()456 ffest_terminate_0 ()
457 {
458 ffesta_terminate_0 ();
459 ffestb_terminate_0 ();
460 ffestc_terminate_0 ();
461 ffestd_terminate_0 ();
462 ffeste_terminate_0 ();
463 ffestp_terminate_0 ();
464 ffestr_terminate_0 ();
465 ffests_terminate_0 ();
466 ffestt_terminate_0 ();
467 ffestu_terminate_0 ();
468 ffestv_terminate_0 ();
469 ffestw_terminate_0 ();
470 }
471
472 /* ffest_terminate_1 -- Terminate for source file
473
474 ffest_terminate_1(); */
475
476 void
ffest_terminate_1()477 ffest_terminate_1 ()
478 {
479 ffesta_terminate_1 ();
480 ffestb_terminate_1 ();
481 ffestc_terminate_1 ();
482 ffestd_terminate_1 ();
483 ffeste_terminate_1 ();
484 ffestp_terminate_1 ();
485 ffestr_terminate_1 ();
486 ffests_terminate_1 ();
487 ffestt_terminate_1 ();
488 ffestu_terminate_1 ();
489 ffestv_terminate_1 ();
490 ffestw_terminate_1 ();
491 }
492
493 /* ffest_terminate_2 -- Terminate for outer program unit
494
495 ffest_terminate_2(); */
496
497 void
ffest_terminate_2()498 ffest_terminate_2 ()
499 {
500 ffesta_terminate_2 ();
501 ffestb_terminate_2 ();
502 ffestc_terminate_2 ();
503 ffestd_terminate_2 ();
504 ffeste_terminate_2 ();
505 ffestp_terminate_2 ();
506 ffestr_terminate_2 ();
507 ffests_terminate_2 ();
508 ffestt_terminate_2 ();
509 ffestu_terminate_2 ();
510 ffestv_terminate_2 ();
511 ffestw_terminate_2 ();
512 }
513
514 /* ffest_terminate_3 -- Terminate for any program unit
515
516 ffest_terminate_3(); */
517
518 void
ffest_terminate_3()519 ffest_terminate_3 ()
520 {
521 ffesta_terminate_3 ();
522 ffestb_terminate_3 ();
523 ffestc_terminate_3 ();
524 ffestd_terminate_3 ();
525 ffeste_terminate_3 ();
526 ffestp_terminate_3 ();
527 ffestr_terminate_3 ();
528 ffests_terminate_3 ();
529 ffestt_terminate_3 ();
530 ffestu_terminate_3 ();
531 ffestv_terminate_3 ();
532 ffestw_terminate_3 ();
533 }
534
535 /* ffest_terminate_4 -- Terminate for statement functions
536
537 ffest_terminate_4(); */
538
539 void
ffest_terminate_4()540 ffest_terminate_4 ()
541 {
542 ffesta_terminate_4 ();
543 ffestb_terminate_4 ();
544 ffestc_terminate_4 ();
545 ffestd_terminate_4 ();
546 ffeste_terminate_4 ();
547 ffestp_terminate_4 ();
548 ffestr_terminate_4 ();
549 ffests_terminate_4 ();
550 ffestt_terminate_4 ();
551 ffestu_terminate_4 ();
552 ffestv_terminate_4 ();
553 ffestw_terminate_4 ();
554 }
555