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