?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use new tail-calling mechanism on ARM.
[official-gcc.git] / gcc / f / stb.c
blobef523c4e11740cc165ecfd57271ee84040e6ac5e
1 /* stb.c -- Implementation File (module.c template V1.0)
2 Copyright (C) 1995, 1996 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 st.c
24
25 Description:
26 Parses the proper form for statements, builds up expression trees for
27 them, but does not actually implement them. Uses ffebad (primarily via
28 ffesta_ffebad_start) to indicate errors in form. In many cases, an invalid
29 statement form indicates another possible statement needs to be looked at
30 by ffest. In a few cases, a valid statement form might not completely
31 determine the nature of the statement, as in REALFUNCTIONA(B), which is
32 a valid form for either the first statement of a function named A taking
33 an argument named B or for the declaration of a real array named FUNCTIONA
34 with an adjustable size of B. A similar (though somewhat easier) choice
35 must be made for the statement-function-def vs. assignment forms, as in
36 the case of FOO(A) = A+2.0.
37
38 A given parser consists of one or more state handlers, the first of which
39 is the initial state, and the last of which (for any given input) returns
40 control to a final state handler (ffesta_zero or ffesta_two, explained
41 below). The functions handling the states for a given parser usually have
42 the same names, differing only in the final number, as in ffestb_foo_
43 (handles the initial state), ffestb_foo_1_, ffestb_foo_2_ (handle
44 subsequent states), although liberties sometimes are taken with the "foo"
45 part either when keywords are clarified into given statements or are
46 transferred into other possible areas. (For example, the type-name
47 states can hop over to _dummy_ functions when the FUNCTION or RECURSIVE
48 keywords are seen, though this kind of thing is kept to a minimum.) Only
49 the names without numbers are exported to the rest of ffest; the others
50 are local (static).
51
52 Each initial state is provided with the first token in ffesta_tokens[0],
53 which will be killed upon return to the final state (ffesta_zero or
54 ffelex_swallow_tokens passed through to ffesta_zero), so while it may
55 be changed to another token, a valid token must be left there to be
56 killed. Also, a "convenient" array of tokens are left in
57 ffesta_tokens[1..FFESTA_tokensMAX]. The initial state of this set of
58 elements is undefined, thus, if tokens are stored here, they must be
59 killed before returning to the final state. Any parser may also use
60 cross-state local variables by sticking a structure containing storage
61 for those variables in the local union ffestb_local_ (unless the union
62 goes on strike). Furthermore, parsers that handle more than one first or
63 second tokens (like _varlist_, which handles EXTERNAL, INTENT, INTRINSIC,
64 OPTIONAL,
65 PUBLIC, or PRIVATE, and _endxyz_, which handles ENDBLOCK, ENDBLOCKDATA,
66 ENDDO, ENDIF, and so on) may expect arguments from ffest in the
67 ffest-wide union ffest_args_, the substructure specific to the parser.
68
69 A parser's responsibility is: to call either ffesta_confirmed or
70 ffest_ffebad_start before returning to the final state; to be the only
71 parser that can possibly call ffesta_confirmed for a given statement;
72 to call ffest_ffebad_start immediately upon recognizing a bad token
73 (specifically one that another statement parser might confirm upon);
74 to call ffestc functions only after calling ffesta_confirmed and only
75 when ffesta_is_inhibited returns FALSE; and to call ffesta_is_inhibited
76 only after calling ffesta_confirmed. Confirm as early as reasonably
77 possible, even when only one ffestc function is called for the statement
78 later on, because early confirmation can enhance the error-reporting
79 capabilities if a subsequent error is detected and this parser isn't
80 the first possibility for the statement.
81
82 To assist the parser, functions like ffesta_ffebad_1t and _1p_ have
83 been provided to make use of ffest_ffebad_start fairly easy.
84
85 Modifications:
86 */
87
88 /* Include files. */
89
90 #include "proj.h"
91 #include "stb.h"
92 #include "bad.h"
93 #include "expr.h"
94 #include "lex.h"
95 #include "malloc.h"
96 #include "src.h"
97 #include "sta.h"
98 #include "stc.h"
99 #include "stp.h"
100 #include "str.h"
101
102 /* Externals defined here. */
103
104 struct _ffestb_args_ ffestb_args;
105
106 /* Simple definitions and enumerations. */
107
108 #define FFESTB_KILL_EASY_ 1 /* 1 for only one _subr_kill_xyz_ fn. */
109
110 /* Internal typedefs. */
111
112 union ffestb_subrargs_u_
113 {
114 struct
115 {
116 ffesttTokenList labels; /* Input arg, must not be NULL. */
117 ffelexHandler handler; /* Input arg, call me when done. */
118 bool ok; /* Output arg, TRUE if list ended in
119 CLOSE_PAREN. */
120 }
121 label_list;
122 struct
123 {
124 ffesttDimList dims; /* Input arg, must not be NULL. */
125 ffelexHandler handler; /* Input arg, call me when done. */
126 mallocPool pool; /* Pool to allocate into. */
127 bool ok; /* Output arg, TRUE if list ended in
128 CLOSE_PAREN. */
129 ffeexprContext ctx; /* DIMLIST or DIMLISTCOMMON. */
130 #ifdef FFECOM_dimensionsMAX
131 int ndims; /* For backends that really can't have
132 infinite dims. */
133 #endif
134 }
135 dim_list;
136 struct
137 {
138 ffesttTokenList args; /* Input arg, must not be NULL. */
139 ffelexHandler handler; /* Input arg, call me when done. */
140 ffelexToken close_paren;/* Output arg if ok, CLOSE_PAREN token. */
141 bool is_subr; /* Input arg, TRUE if list in subr-def
142 context. */
143 bool ok; /* Output arg, TRUE if list ended in
144 CLOSE_PAREN. */
145 bool names; /* Do ffelex_set_names(TRUE) before return. */
146 }
147 name_list;
148 };
149
150 union ffestb_local_u_
151 {
152 struct
153 {
154 ffebld expr;
155 }
156 call_stmt;
157 struct
158 {
159 ffebld expr;
160 }
161 go_to;
162 struct
163 {
164 ffebld dest;
165 bool vxtparam; /* If assignment might really be VXT
166 PARAMETER stmt. */
167 }
168 let;
169 struct
170 {
171 ffebld expr;
172 }
173 if_stmt;
174 struct
175 {
176 ffebld expr;
177 }
178 else_stmt;
179 struct
180 {
181 ffebld expr;
182 }
183 dowhile;
184 struct
185 {
186 ffebld var;
187 ffebld start;
188 ffebld end;
189 }
190 do_stmt;
191 struct
192 {
193 bool is_cblock;
194 }
195 R522;
196 struct
197 {
198 ffebld expr;
199 bool started;
200 }
201 parameter;
202 struct
203 {
204 ffesttExprList exprs;
205 bool started;
206 }
207 equivalence;
208 struct
209 {
210 ffebld expr;
211 bool started;
212 }
213 data;
214 struct
215 {
216 ffestrOther kw;
217 }
218 varlist;
219 #if FFESTR_F90
220 struct
221 {
222 ffestrOther kw;
223 }
224 type;
225 #endif
226 struct
227 {
228 ffelexHandler next;
229 }
230 construct;
231 struct
232 {
233 ffesttFormatList f;
234 ffestpFormatType current; /* What we're currently working on. */
235 ffelexToken t; /* Token of what we're currently working on. */
236 ffesttFormatValue pre;
237 ffesttFormatValue post;
238 ffesttFormatValue dot;
239 ffesttFormatValue exp;
240 bool sign; /* _3_, pos/neg; elsewhere, signed/unsigned. */
241 bool complained; /* If run-time expr seen in nonexec context. */
242 }
243 format;
244 #if FFESTR_F90
245 struct
246 {
247 bool started;
248 }
249 moduleprocedure;
250 #endif
251 struct
252 {
253 ffebld expr;
254 }
255 selectcase;
256 struct
257 {
258 ffesttCaseList cases;
259 }
260 case_stmt;
261 #if FFESTR_F90
262 struct
263 {
264 ffesttExprList exprs;
265 ffebld expr;
266 }
267 heap;
268 #endif
269 #if FFESTR_F90
270 struct
271 {
272 ffesttExprList exprs;
273 }
274 R624;
275 #endif
276 #if FFESTR_F90
277 struct
278 {
279 ffestpDefinedOperator operator;
280 bool assignment; /* TRUE for INTERFACE ASSIGNMENT, FALSE for
281 ...OPERATOR. */
282 bool slash; /* TRUE if OPEN_ARRAY, FALSE if OPEN_PAREN. */
283 }
284 interface;
285 #endif
286 struct
287 {
288 bool is_cblock;
289 }
290 V014;
291 #if FFESTR_VXT
292 struct
293 {
294 bool started;
295 ffebld u;
296 ffebld m;
297 ffebld n;
298 ffebld asv;
299 }
300 V025;
301 #endif
302 struct
303 {
304 ffestpBeruIx ix;
305 bool label;
306 bool left;
307 ffeexprContext context;
308 }
309 beru;
310 struct
311 {
312 ffestpCloseIx ix;
313 bool label;
314 bool left;
315 ffeexprContext context;
316 }
317 close;
318 struct
319 {
320 ffestpDeleteIx ix;
321 bool label;
322 bool left;
323 ffeexprContext context;
324 }
325 delete;
326 struct
327 {
328 ffestpDeleteIx ix;
329 bool label;
330 bool left;
331 ffeexprContext context;
332 }
333 find;
334 struct
335 {
336 ffestpInquireIx ix;
337 bool label;
338 bool left;
339 ffeexprContext context;
340 bool may_be_iolength;
341 }
342 inquire;
343 struct
344 {
345 ffestpOpenIx ix;
346 bool label;
347 bool left;
348 ffeexprContext context;
349 }
350 open;
351 struct
352 {
353 ffestpReadIx ix;
354 bool label;
355 bool left;
356 ffeexprContext context;
357 }
358 read;
359 struct
360 {
361 ffestpRewriteIx ix;
362 bool label;
363 bool left;
364 ffeexprContext context;
365 }
366 rewrite;
367 struct
368 {
369 ffestpWriteIx ix;
370 bool label;
371 bool left;
372 ffeexprContext context;
373 }
374 vxtcode;
375 struct
376 {
377 ffestpWriteIx ix;
378 bool label;
379 bool left;
380 ffeexprContext context;
381 }
382 write;
383 #if FFESTR_F90
384 struct
385 {
386 bool started;
387 }
388 structure;
389 #endif
390 struct
391 {
392 bool started;
393 }
394 common;
395 struct
396 {
397 bool started;
398 }
399 dimension;
400 struct
401 {
402 bool started;
403 }
404 dimlist;
405 struct
406 {
407 const char *badname;
408 ffestrFirst first_kw;
409 bool is_subr;
410 }
411 dummy;
412 struct
413 {
414 ffebld kind; /* Kind type parameter, if any. */
415 ffelexToken kindt; /* Kind type first token, if any. */
416 ffebld len; /* Length type parameter, if any. */
417 ffelexToken lent; /* Length type parameter, if any. */
418 ffelexHandler handler;
419 ffelexToken recursive;
420 ffebld expr;
421 ffesttTokenList toklist;/* For ambiguity resolution. */
422 ffesttImpList imps; /* List of IMPLICIT letters. */
423 ffelexHandler imp_handler; /* Call if paren list wasn't letters. */
424 const char *badname;
425 ffestrOther kw; /* INTENT(IN/OUT/INOUT). */
426 ffestpType type;
427 bool parameter; /* If PARAMETER attribute seen (governs =expr
428 context). */
429 bool coloncolon; /* If COLONCOLON seen (allows =expr). */
430 bool aster_after; /* "*" seen after, not before,
431 [RECURSIVE]FUNCTIONxyz. */
432 bool empty; /* Ambig function dummy arg list empty so
433 far? */
434 bool imp_started; /* Started IMPLICIT statement already. */
435 bool imp_seen_comma; /* TRUE if next COMMA within parens means not
436 R541. */
437 }
438 decl;
439 struct
440 {
441 bool started;
442 }
443 vxtparam;
444 }; /* Merge with the one in ffestb later. */
445
446 /* Private include files. */
447
448
449 /* Internal structure definitions. */
450
451
452 /* Static objects accessed by functions in this module. */
453
454 static union ffestb_subrargs_u_ ffestb_subrargs_;
455 static union ffestb_local_u_ ffestb_local_;
456
457 /* Static functions (internal). */
458
459 static void ffestb_subr_ambig_to_ents_ (void);
460 static ffelexHandler ffestb_subr_ambig_nope_ (ffelexToken t);
461 static ffelexHandler ffestb_subr_dimlist_ (ffelexToken ft, ffebld expr,
462 ffelexToken t);
463 static ffelexHandler ffestb_subr_dimlist_1_ (ffelexToken ft, ffebld expr,
464 ffelexToken t);
465 static ffelexHandler ffestb_subr_dimlist_2_ (ffelexToken ft, ffebld expr,
466 ffelexToken t);
467 static ffelexHandler ffestb_subr_name_list_ (ffelexToken t);
468 static ffelexHandler ffestb_subr_name_list_1_ (ffelexToken t);
469 static void ffestb_subr_R1001_append_p_ (void);
470 static ffelexHandler ffestb_decl_kindparam_ (ffelexToken t);
471 static ffelexHandler ffestb_decl_kindparam_1_ (ffelexToken t);
472 static ffelexHandler ffestb_decl_kindparam_2_ (ffelexToken ft, ffebld expr,
473 ffelexToken t);
474 static ffelexHandler ffestb_decl_starkind_ (ffelexToken t);
475 static ffelexHandler ffestb_decl_starlen_ (ffelexToken t);
476 static ffelexHandler ffestb_decl_starlen_1_ (ffelexToken ft, ffebld expr,
477 ffelexToken t);
478 static ffelexHandler ffestb_decl_typeparams_ (ffelexToken t);
479 static ffelexHandler ffestb_decl_typeparams_1_ (ffelexToken t);
480 static ffelexHandler ffestb_decl_typeparams_2_ (ffelexToken ft, ffebld expr,
481 ffelexToken t);
482 static ffelexHandler ffestb_decl_typeparams_3_ (ffelexToken ft, ffebld expr,
483 ffelexToken t);
484 #if FFESTR_F90
485 static ffelexHandler ffestb_decl_typetype1_ (ffelexToken t);
486 static ffelexHandler ffestb_decl_typetype2_ (ffelexToken t);
487 #endif
488 static ffelexHandler ffestb_subr_label_list_ (ffelexToken t);
489 static ffelexHandler ffestb_subr_label_list_1_ (ffelexToken t);
490 static ffelexHandler ffestb_do1_ (ffelexToken t);
491 static ffelexHandler ffestb_do2_ (ffelexToken t);
492 static ffelexHandler ffestb_do3_ (ffelexToken t);
493 static ffelexHandler ffestb_do4_ (ffelexToken ft, ffebld expr,
494 ffelexToken t);
495 static ffelexHandler ffestb_do5_ (ffelexToken t);
496 static ffelexHandler ffestb_do6_ (ffelexToken ft, ffebld expr,
497 ffelexToken t);
498 static ffelexHandler ffestb_do7_ (ffelexToken ft, ffebld expr,
499 ffelexToken t);
500 static ffelexHandler ffestb_do8_ (ffelexToken ft, ffebld expr,
501 ffelexToken t);
502 static ffelexHandler ffestb_do9_ (ffelexToken ft, ffebld expr,
503 ffelexToken t);
504 static ffelexHandler ffestb_else1_ (ffelexToken t);
505 static ffelexHandler ffestb_else2_ (ffelexToken ft, ffebld expr,
506 ffelexToken t);
507 static ffelexHandler ffestb_else3_ (ffelexToken t);
508 static ffelexHandler ffestb_else4_ (ffelexToken t);
509 static ffelexHandler ffestb_else5_ (ffelexToken t);
510 static ffelexHandler ffestb_end1_ (ffelexToken t);
511 static ffelexHandler ffestb_end2_ (ffelexToken t);
512 static ffelexHandler ffestb_end3_ (ffelexToken t);
513 static ffelexHandler ffestb_goto1_ (ffelexToken t);
514 static ffelexHandler ffestb_goto2_ (ffelexToken t);
515 static ffelexHandler ffestb_goto3_ (ffelexToken t);
516 static ffelexHandler ffestb_goto4_ (ffelexToken ft, ffebld expr,
517 ffelexToken t);
518 static ffelexHandler ffestb_goto5_ (ffelexToken ft, ffebld expr,
519 ffelexToken t);
520 static ffelexHandler ffestb_goto6_ (ffelexToken t);
521 static ffelexHandler ffestb_goto7_ (ffelexToken t);
522 static ffelexHandler ffestb_halt1_ (ffelexToken ft, ffebld expr,
523 ffelexToken t);
524 static ffelexHandler ffestb_if1_ (ffelexToken ft, ffebld expr,
525 ffelexToken t);
526 static ffelexHandler ffestb_if2_ (ffelexToken t);
527 static ffelexHandler ffestb_if3_ (ffelexToken t);
528 static ffelexHandler ffestb_let1_ (ffelexToken ft, ffebld expr,
529 ffelexToken t);
530 static ffelexHandler ffestb_let2_ (ffelexToken ft, ffebld expr,
531 ffelexToken t);
532 #if FFESTR_F90
533 static ffelexHandler ffestb_type1_ (ffelexToken t);
534 static ffelexHandler ffestb_type2_ (ffelexToken t);
535 static ffelexHandler ffestb_type3_ (ffelexToken t);
536 static ffelexHandler ffestb_type4_ (ffelexToken t);
537 #endif
538 #if FFESTR_F90
539 static ffelexHandler ffestb_varlist1_ (ffelexToken t);
540 static ffelexHandler ffestb_varlist2_ (ffelexToken t);
541 static ffelexHandler ffestb_varlist3_ (ffelexToken t);
542 static ffelexHandler ffestb_varlist4_ (ffelexToken t);
543 #endif
544 static ffelexHandler ffestb_varlist5_ (ffelexToken t);
545 static ffelexHandler ffestb_varlist6_ (ffelexToken t);
546 #if FFESTR_F90
547 static ffelexHandler ffestb_where1_ (ffelexToken ft, ffebld expr,
548 ffelexToken t);
549 static ffelexHandler ffestb_where2_ (ffelexToken t);
550 static ffelexHandler ffestb_where3_ (ffelexToken t);
551 #endif
552 static ffelexHandler ffestb_R5221_ (ffelexToken t);
553 static ffelexHandler ffestb_R5222_ (ffelexToken t);
554 static ffelexHandler ffestb_R5223_ (ffelexToken t);
555 static ffelexHandler ffestb_R5224_ (ffelexToken t);
556 static ffelexHandler ffestb_R5281_ (ffelexToken ft, ffebld expr,
557 ffelexToken t);
558 static ffelexHandler ffestb_R5282_ (ffelexToken ft, ffebld expr,
559 ffelexToken t);
560 static ffelexHandler ffestb_R5283_ (ffelexToken ft, ffebld expr,
561 ffelexToken t);
562 static ffelexHandler ffestb_R5284_ (ffelexToken t);
563 static ffelexHandler ffestb_R5371_ (ffelexToken ft, ffebld expr,
564 ffelexToken t);
565 static ffelexHandler ffestb_R5372_ (ffelexToken ft, ffebld expr,
566 ffelexToken t);
567 static ffelexHandler ffestb_R5373_ (ffelexToken t);
568 static ffelexHandler ffestb_R5421_ (ffelexToken t);
569 static ffelexHandler ffestb_R5422_ (ffelexToken t);
570 static ffelexHandler ffestb_R5423_ (ffelexToken t);
571 static ffelexHandler ffestb_R5424_ (ffelexToken t);
572 static ffelexHandler ffestb_R5425_ (ffelexToken t);
573 static ffelexHandler ffestb_R5441_ (ffelexToken ft, ffebld expr,
574 ffelexToken t);
575 static ffelexHandler ffestb_R5442_ (ffelexToken ft, ffebld expr,
576 ffelexToken t);
577 static ffelexHandler ffestb_R5443_ (ffelexToken t);
578 static ffelexHandler ffestb_R5444_ (ffelexToken t);
579 static ffelexHandler ffestb_R8341_ (ffelexToken t);
580 static ffelexHandler ffestb_R8351_ (ffelexToken t);
581 static ffelexHandler ffestb_R8381_ (ffelexToken t);
582 static ffelexHandler ffestb_R8382_ (ffelexToken t);
583 static ffelexHandler ffestb_R8383_ (ffelexToken ft, ffebld expr,
584 ffelexToken t);
585 static ffelexHandler ffestb_R8401_ (ffelexToken ft, ffebld expr,
586 ffelexToken t);
587 static ffelexHandler ffestb_R8402_ (ffelexToken t);
588 static ffelexHandler ffestb_R8403_ (ffelexToken t);
589 static ffelexHandler ffestb_R8404_ (ffelexToken t);
590 static ffelexHandler ffestb_R8405_ (ffelexToken t);
591 static ffelexHandler ffestb_R8406_ (ffelexToken t);
592 static ffelexHandler ffestb_R8407_ (ffelexToken t);
593 static ffelexHandler ffestb_R11021_ (ffelexToken t);
594 static ffelexHandler ffestb_R1111_1_ (ffelexToken t);
595 static ffelexHandler ffestb_R1111_2_ (ffelexToken t);
596 static ffelexHandler ffestb_R12121_ (ffelexToken ft, ffebld expr,
597 ffelexToken t);
598 static ffelexHandler ffestb_R12271_ (ffelexToken ft, ffebld expr,
599 ffelexToken t);
600 static ffelexHandler ffestb_construct1_ (ffelexToken t);
601 static ffelexHandler ffestb_construct2_ (ffelexToken t);
602 #if FFESTR_F90
603 static ffelexHandler ffestb_heap1_ (ffelexToken ft, ffebld expr,
604 ffelexToken t);
605 static ffelexHandler ffestb_heap2_ (ffelexToken t);
606 static ffelexHandler ffestb_heap3_ (ffelexToken t);
607 static ffelexHandler ffestb_heap4_ (ffelexToken ft, ffebld expr,
608 ffelexToken t);
609 static ffelexHandler ffestb_heap5_ (ffelexToken t);
610 #endif
611 #if FFESTR_F90
612 static ffelexHandler ffestb_module1_ (ffelexToken t);
613 static ffelexHandler ffestb_module2_ (ffelexToken t);
614 static ffelexHandler ffestb_module3_ (ffelexToken t);
615 #endif
616 static ffelexHandler ffestb_R8091_ (ffelexToken t);
617 static ffelexHandler ffestb_R8092_ (ffelexToken ft, ffebld expr,
618 ffelexToken t);
619 static ffelexHandler ffestb_R8093_ (ffelexToken t);
620 static ffelexHandler ffestb_R8101_ (ffelexToken t);
621 static ffelexHandler ffestb_R8102_ (ffelexToken t);
622 static ffelexHandler ffestb_R8103_ (ffelexToken ft, ffebld expr,
623 ffelexToken t);
624 static ffelexHandler ffestb_R8104_ (ffelexToken ft, ffebld expr,
625 ffelexToken t);
626 static ffelexHandler ffestb_R10011_ (ffelexToken t);
627 static ffelexHandler ffestb_R10012_ (ffelexToken t);
628 static ffelexHandler ffestb_R10013_ (ffelexToken t);
629 static ffelexHandler ffestb_R10014_ (ffelexToken t);
630 static ffelexHandler ffestb_R10015_ (ffelexToken t);
631 static ffelexHandler ffestb_R10016_ (ffelexToken t);
632 static ffelexHandler ffestb_R10017_ (ffelexToken t);
633 static ffelexHandler ffestb_R10018_ (ffelexToken t);
634 static ffelexHandler ffestb_R10019_ (ffelexToken t);
635 static ffelexHandler ffestb_R100110_ (ffelexToken t);
636 static ffelexHandler ffestb_R100111_ (ffelexToken t);
637 static ffelexHandler ffestb_R100112_ (ffelexToken t);
638 static ffelexHandler ffestb_R100113_ (ffelexToken t);
639 static ffelexHandler ffestb_R100114_ (ffelexToken t);
640 static ffelexHandler ffestb_R100115_ (ffelexToken ft, ffebld expr,
641 ffelexToken t);
642 static ffelexHandler ffestb_R100116_ (ffelexToken ft, ffebld expr,
643 ffelexToken t);
644 static ffelexHandler ffestb_R100117_ (ffelexToken ft, ffebld expr,
645 ffelexToken t);
646 static ffelexHandler ffestb_R100118_ (ffelexToken ft, ffebld expr,
647 ffelexToken t);
648 #if FFESTR_F90
649 static ffelexHandler ffestb_R11071_ (ffelexToken t);
650 static ffelexHandler ffestb_R11072_ (ffelexToken t);
651 static ffelexHandler ffestb_R11073_ (ffelexToken t);
652 static ffelexHandler ffestb_R11074_ (ffelexToken t);
653 static ffelexHandler ffestb_R11075_ (ffelexToken t);
654 static ffelexHandler ffestb_R11076_ (ffelexToken t);
655 static ffelexHandler ffestb_R11077_ (ffelexToken t);
656 static ffelexHandler ffestb_R11078_ (ffelexToken t);
657 static ffelexHandler ffestb_R11079_ (ffelexToken t);
658 static ffelexHandler ffestb_R110710_ (ffelexToken t);
659 static ffelexHandler ffestb_R110711_ (ffelexToken t);
660 static ffelexHandler ffestb_R110712_ (ffelexToken t);
661 #endif
662 #if FFESTR_F90
663 static ffelexHandler ffestb_R12021_ (ffelexToken t);
664 static ffelexHandler ffestb_R12022_ (ffelexToken t);
665 static ffelexHandler ffestb_R12023_ (ffelexToken t);
666 static ffelexHandler ffestb_R12024_ (ffelexToken t);
667 static ffelexHandler ffestb_R12025_ (ffelexToken t);
668 static ffelexHandler ffestb_R12026_ (ffelexToken t);
669 #endif
670 static ffelexHandler ffestb_S3P41_ (ffelexToken ft, ffebld expr,
671 ffelexToken t);
672 static ffelexHandler ffestb_V0141_ (ffelexToken t);
673 static ffelexHandler ffestb_V0142_ (ffelexToken t);
674 static ffelexHandler ffestb_V0143_ (ffelexToken t);
675 static ffelexHandler ffestb_V0144_ (ffelexToken t);
676 #if FFESTR_VXT
677 static ffelexHandler ffestb_V0251_ (ffelexToken t);
678 static ffelexHandler ffestb_V0252_ (ffelexToken ft, ffebld expr,
679 ffelexToken t);
680 static ffelexHandler ffestb_V0253_ (ffelexToken ft, ffebld expr,
681 ffelexToken t);
682 static ffelexHandler ffestb_V0254_ (ffelexToken ft, ffebld expr,
683 ffelexToken t);
684 static ffelexHandler ffestb_V0255_ (ffelexToken t);
685 static ffelexHandler ffestb_V0256_ (ffelexToken t);
686 static ffelexHandler ffestb_V0257_ (ffelexToken ft, ffebld expr,
687 ffelexToken t);
688 static ffelexHandler ffestb_V0258_ (ffelexToken t);
689 #endif
690 #if FFESTB_KILL_EASY_
691 static void ffestb_subr_kill_easy_ (ffestpInquireIx max);
692 #else
693 static void ffestb_subr_kill_accept_ (void);
694 static void ffestb_subr_kill_beru_ (void);
695 static void ffestb_subr_kill_close_ (void);
696 static void ffestb_subr_kill_delete_ (void);
697 static void ffestb_subr_kill_find_ (void); /* Not written yet. */
698 static void ffestb_subr_kill_inquire_ (void);
699 static void ffestb_subr_kill_open_ (void);
700 static void ffestb_subr_kill_print_ (void);
701 static void ffestb_subr_kill_read_ (void);
702 static void ffestb_subr_kill_rewrite_ (void);
703 static void ffestb_subr_kill_type_ (void);
704 static void ffestb_subr_kill_vxtcode_ (void); /* Not written yet. */
705 static void ffestb_subr_kill_write_ (void);
706 #endif
707 static ffelexHandler ffestb_beru1_ (ffelexToken ft, ffebld expr,
708 ffelexToken t);
709 static ffelexHandler ffestb_beru2_ (ffelexToken t);
710 static ffelexHandler ffestb_beru3_ (ffelexToken t);
711 static ffelexHandler ffestb_beru4_ (ffelexToken ft, ffebld expr,
712 ffelexToken t);
713 static ffelexHandler ffestb_beru5_ (ffelexToken t);
714 static ffelexHandler ffestb_beru6_ (ffelexToken t);
715 static ffelexHandler ffestb_beru7_ (ffelexToken ft, ffebld expr,
716 ffelexToken t);
717 static ffelexHandler ffestb_beru8_ (ffelexToken t);
718 static ffelexHandler ffestb_beru9_ (ffelexToken t);
719 static ffelexHandler ffestb_beru10_ (ffelexToken t);
720 #if FFESTR_VXT
721 static ffelexHandler ffestb_vxtcode1_ (ffelexToken ft, ffebld expr,
722 ffelexToken t);
723 static ffelexHandler ffestb_vxtcode2_ (ffelexToken ft, ffebld expr,
724 ffelexToken t);
725 static ffelexHandler ffestb_vxtcode3_ (ffelexToken ft, ffebld expr,
726 ffelexToken t);
727 static ffelexHandler ffestb_vxtcode4_ (ffelexToken t);
728 static ffelexHandler ffestb_vxtcode5_ (ffelexToken t);
729 static ffelexHandler ffestb_vxtcode6_ (ffelexToken ft, ffebld expr,
730 ffelexToken t);
731 static ffelexHandler ffestb_vxtcode7_ (ffelexToken t);
732 static ffelexHandler ffestb_vxtcode8_ (ffelexToken t);
733 static ffelexHandler ffestb_vxtcode9_ (ffelexToken t);
734 static ffelexHandler ffestb_vxtcode10_ (ffelexToken ft, ffebld expr,
735 ffelexToken t);
736 #endif
737 static ffelexHandler ffestb_R9041_ (ffelexToken t);
738 static ffelexHandler ffestb_R9042_ (ffelexToken t);
739 static ffelexHandler ffestb_R9043_ (ffelexToken ft, ffebld expr,
740 ffelexToken t);
741 static ffelexHandler ffestb_R9044_ (ffelexToken t);
742 static ffelexHandler ffestb_R9045_ (ffelexToken t);
743 static ffelexHandler ffestb_R9046_ (ffelexToken ft, ffebld expr,
744 ffelexToken t);
745 static ffelexHandler ffestb_R9047_ (ffelexToken t);
746 static ffelexHandler ffestb_R9048_ (ffelexToken t);
747 static ffelexHandler ffestb_R9049_ (ffelexToken t);
748 static ffelexHandler ffestb_R9071_ (ffelexToken t);
749 static ffelexHandler ffestb_R9072_ (ffelexToken t);
750 static ffelexHandler ffestb_R9073_ (ffelexToken ft, ffebld expr,
751 ffelexToken t);
752 static ffelexHandler ffestb_R9074_ (ffelexToken t);
753 static ffelexHandler ffestb_R9075_ (ffelexToken t);
754 static ffelexHandler ffestb_R9076_ (ffelexToken ft, ffebld expr,
755 ffelexToken t);
756 static ffelexHandler ffestb_R9077_ (ffelexToken t);
757 static ffelexHandler ffestb_R9078_ (ffelexToken t);
758 static ffelexHandler ffestb_R9079_ (ffelexToken t);
759 static ffelexHandler ffestb_R9091_ (ffelexToken ft, ffebld expr,
760 ffelexToken t);
761 static ffelexHandler ffestb_R9092_ (ffelexToken t);
762 static ffelexHandler ffestb_R9093_ (ffelexToken t);
763 static ffelexHandler ffestb_R9094_ (ffelexToken ft, ffebld expr,
764 ffelexToken t);
765 static ffelexHandler ffestb_R9095_ (ffelexToken t);
766 static ffelexHandler ffestb_R9096_ (ffelexToken t);
767 static ffelexHandler ffestb_R9097_ (ffelexToken ft, ffebld expr,
768 ffelexToken t);
769 static ffelexHandler ffestb_R9098_ (ffelexToken t);
770 static ffelexHandler ffestb_R9099_ (ffelexToken t);
771 static ffelexHandler ffestb_R90910_ (ffelexToken ft, ffebld expr,
772 ffelexToken t);
773 static ffelexHandler ffestb_R90911_ (ffelexToken t);
774 static ffelexHandler ffestb_R90912_ (ffelexToken t);
775 static ffelexHandler ffestb_R90913_ (ffelexToken t);
776 static ffelexHandler ffestb_R90914_ (ffelexToken ft, ffebld expr,
777 ffelexToken t);
778 static ffelexHandler ffestb_R90915_ (ffelexToken ft, ffebld expr,
779 ffelexToken t);
780 static ffelexHandler ffestb_R9101_ (ffelexToken t);
781 static ffelexHandler ffestb_R9102_ (ffelexToken t);
782 static ffelexHandler ffestb_R9103_ (ffelexToken ft, ffebld expr,
783 ffelexToken t);
784 static ffelexHandler ffestb_R9104_ (ffelexToken t);
785 static ffelexHandler ffestb_R9105_ (ffelexToken t);
786 static ffelexHandler ffestb_R9106_ (ffelexToken ft, ffebld expr,
787 ffelexToken t);
788 static ffelexHandler ffestb_R9107_ (ffelexToken t);
789 static ffelexHandler ffestb_R9108_ (ffelexToken t);
790 static ffelexHandler ffestb_R9109_ (ffelexToken ft, ffebld expr,
791 ffelexToken t);
792 static ffelexHandler ffestb_R91010_ (ffelexToken t);
793 static ffelexHandler ffestb_R91011_ (ffelexToken t);
794 static ffelexHandler ffestb_R91012_ (ffelexToken t);
795 static ffelexHandler ffestb_R91013_ (ffelexToken ft, ffebld expr,
796 ffelexToken t);
797 static ffelexHandler ffestb_R91014_ (ffelexToken ft, ffebld expr,
798 ffelexToken t);
799 static ffelexHandler ffestb_R9111_ (ffelexToken ft, ffebld expr,
800 ffelexToken t);
801 static ffelexHandler ffestb_R9112_ (ffelexToken ft, ffebld expr,
802 ffelexToken t);
803 static ffelexHandler ffestb_R9231_ (ffelexToken t);
804 static ffelexHandler ffestb_R9232_ (ffelexToken t);
805 static ffelexHandler ffestb_R9233_ (ffelexToken ft, ffebld expr,
806 ffelexToken t);
807 static ffelexHandler ffestb_R9234_ (ffelexToken t);
808 static ffelexHandler ffestb_R9235_ (ffelexToken t);
809 static ffelexHandler ffestb_R9236_ (ffelexToken ft, ffebld expr,
810 ffelexToken t);
811 static ffelexHandler ffestb_R9237_ (ffelexToken t);
812 static ffelexHandler ffestb_R9238_ (ffelexToken t);
813 static ffelexHandler ffestb_R9239_ (ffelexToken t);
814 static ffelexHandler ffestb_R92310_ (ffelexToken t);
815 static ffelexHandler ffestb_R92311_ (ffelexToken ft, ffebld expr,
816 ffelexToken t);
817 #if FFESTR_VXT
818 static ffelexHandler ffestb_V0181_ (ffelexToken t);
819 static ffelexHandler ffestb_V0182_ (ffelexToken t);
820 static ffelexHandler ffestb_V0183_ (ffelexToken ft, ffebld expr,
821 ffelexToken t);
822 static ffelexHandler ffestb_V0184_ (ffelexToken t);
823 static ffelexHandler ffestb_V0185_ (ffelexToken t);
824 static ffelexHandler ffestb_V0186_ (ffelexToken ft, ffebld expr,
825 ffelexToken t);
826 static ffelexHandler ffestb_V0187_ (ffelexToken t);
827 static ffelexHandler ffestb_V0188_ (ffelexToken t);
828 static ffelexHandler ffestb_V0189_ (ffelexToken ft, ffebld expr,
829 ffelexToken t);
830 static ffelexHandler ffestb_V01810_ (ffelexToken t);
831 static ffelexHandler ffestb_V01811_ (ffelexToken t);
832 static ffelexHandler ffestb_V01812_ (ffelexToken t);
833 static ffelexHandler ffestb_V01813_ (ffelexToken ft, ffebld expr,
834 ffelexToken t);
835 static ffelexHandler ffestb_V0191_ (ffelexToken ft, ffebld expr,
836 ffelexToken t);
837 static ffelexHandler ffestb_V0192_ (ffelexToken ft, ffebld expr,
838 ffelexToken t);
839 #endif
840 static ffelexHandler ffestb_V0201_ (ffelexToken ft, ffebld expr,
841 ffelexToken t);
842 static ffelexHandler ffestb_V0202_ (ffelexToken ft, ffebld expr,
843 ffelexToken t);
844 #if FFESTR_VXT
845 static ffelexHandler ffestb_V0211_ (ffelexToken t);
846 static ffelexHandler ffestb_V0212_ (ffelexToken t);
847 static ffelexHandler ffestb_V0213_ (ffelexToken ft, ffebld expr,
848 ffelexToken t);
849 static ffelexHandler ffestb_V0214_ (ffelexToken t);
850 static ffelexHandler ffestb_V0215_ (ffelexToken t);
851 static ffelexHandler ffestb_V0216_ (ffelexToken ft, ffebld expr,
852 ffelexToken t);
853 static ffelexHandler ffestb_V0217_ (ffelexToken t);
854 static ffelexHandler ffestb_V0218_ (ffelexToken t);
855 static ffelexHandler ffestb_V0219_ (ffelexToken t);
856 static ffelexHandler ffestb_V0261_ (ffelexToken t);
857 static ffelexHandler ffestb_V0262_ (ffelexToken t);
858 static ffelexHandler ffestb_V0263_ (ffelexToken ft, ffebld expr,
859 ffelexToken t);
860 static ffelexHandler ffestb_V0264_ (ffelexToken t);
861 static ffelexHandler ffestb_V0265_ (ffelexToken t);
862 static ffelexHandler ffestb_V0266_ (ffelexToken ft, ffebld expr,
863 ffelexToken t);
864 static ffelexHandler ffestb_V0267_ (ffelexToken t);
865 static ffelexHandler ffestb_V0268_ (ffelexToken t);
866 static ffelexHandler ffestb_V0269_ (ffelexToken t);
867 #endif
868 #if FFESTR_F90
869 static ffelexHandler ffestb_dimlist1_ (ffelexToken t);
870 static ffelexHandler ffestb_dimlist2_ (ffelexToken t);
871 static ffelexHandler ffestb_dimlist3_ (ffelexToken t);
872 static ffelexHandler ffestb_dimlist4_ (ffelexToken t);
873 #endif
874 static ffelexHandler ffestb_dummy1_ (ffelexToken t);
875 static ffelexHandler ffestb_dummy2_ (ffelexToken t);
876 static ffelexHandler ffestb_R5241_ (ffelexToken t);
877 static ffelexHandler ffestb_R5242_ (ffelexToken t);
878 static ffelexHandler ffestb_R5243_ (ffelexToken t);
879 static ffelexHandler ffestb_R5244_ (ffelexToken t);
880 static ffelexHandler ffestb_R5471_ (ffelexToken t);
881 static ffelexHandler ffestb_R5472_ (ffelexToken t);
882 static ffelexHandler ffestb_R5473_ (ffelexToken t);
883 static ffelexHandler ffestb_R5474_ (ffelexToken t);
884 static ffelexHandler ffestb_R5475_ (ffelexToken t);
885 static ffelexHandler ffestb_R5476_ (ffelexToken t);
886 static ffelexHandler ffestb_R5477_ (ffelexToken t);
887 #if FFESTR_F90
888 static ffelexHandler ffestb_R6241_ (ffelexToken ft, ffebld expr,
889 ffelexToken t);
890 static ffelexHandler ffestb_R6242_ (ffelexToken t);
891 #endif
892 static ffelexHandler ffestb_R12291_ (ffelexToken t);
893 static ffelexHandler ffestb_R12292_ (ffelexToken ft, ffebld expr,
894 ffelexToken t);
895 static ffelexHandler ffestb_decl_chartype1_ (ffelexToken t);
896 #if FFESTR_F90
897 static ffelexHandler ffestb_decl_recursive1_ (ffelexToken t);
898 static ffelexHandler ffestb_decl_recursive2_ (ffelexToken t);
899 static ffelexHandler ffestb_decl_recursive3_ (ffelexToken t);
900 static ffelexHandler ffestb_decl_recursive4_ (ffelexToken t);
901 #endif
902 static ffelexHandler ffestb_decl_attrs_ (ffelexToken t);
903 static ffelexHandler ffestb_decl_attrs_1_ (ffelexToken t);
904 static ffelexHandler ffestb_decl_attrs_2_ (ffelexToken t);
905 #if FFESTR_F90
906 static ffelexHandler ffestb_decl_attrs_3_ (ffelexToken t);
907 static ffelexHandler ffestb_decl_attrs_4_ (ffelexToken t);
908 static ffelexHandler ffestb_decl_attrs_5_ (ffelexToken t);
909 static ffelexHandler ffestb_decl_attrs_6_ (ffelexToken t);
910 #endif
911 static ffelexHandler ffestb_decl_attrs_7_ (ffelexToken t);
912 static ffelexHandler ffestb_decl_attrsp_ (ffelexToken t);
913 static ffelexHandler ffestb_decl_ents_ (ffelexToken t);
914 static ffelexHandler ffestb_decl_ents_1_ (ffelexToken t);
915 static ffelexHandler ffestb_decl_ents_2_ (ffelexToken t);
916 static ffelexHandler ffestb_decl_ents_3_ (ffelexToken t);
917 static ffelexHandler ffestb_decl_ents_4_ (ffelexToken t);
918 static ffelexHandler ffestb_decl_ents_5_ (ffelexToken t);
919 static ffelexHandler ffestb_decl_ents_6_ (ffelexToken ft, ffebld expr,
920 ffelexToken t);
921 static ffelexHandler ffestb_decl_ents_7_ (ffelexToken t);
922 static ffelexHandler ffestb_decl_ents_8_ (ffelexToken ft, ffebld expr,
923 ffelexToken t);
924 static ffelexHandler ffestb_decl_ents_9_ (ffelexToken ft, ffebld expr,
925 ffelexToken t);
926 static ffelexHandler ffestb_decl_ents_10_ (ffelexToken ft, ffebld expr,
927 ffelexToken t);
928 static ffelexHandler ffestb_decl_ents_11_ (ffelexToken t);
929 static ffelexHandler ffestb_decl_entsp_ (ffelexToken t);
930 static ffelexHandler ffestb_decl_entsp_1_ (ffelexToken t);
931 static ffelexHandler ffestb_decl_entsp_2_ (ffelexToken t);
932 static ffelexHandler ffestb_decl_entsp_3_ (ffelexToken t);
933 static ffelexHandler ffestb_decl_entsp_4_ (ffelexToken ft, ffebld expr,
934 ffelexToken t);
935 static ffelexHandler ffestb_decl_entsp_5_ (ffelexToken t);
936 static ffelexHandler ffestb_decl_entsp_6_ (ffelexToken t);
937 static ffelexHandler ffestb_decl_entsp_7_ (ffelexToken t);
938 static ffelexHandler ffestb_decl_entsp_8_ (ffelexToken t);
939 #if FFESTR_F90
940 static ffelexHandler ffestb_decl_func_ (ffelexToken t);
941 #endif
942 static ffelexHandler ffestb_decl_funcname_ (ffelexToken t);
943 static ffelexHandler ffestb_decl_funcname_1_ (ffelexToken t);
944 static ffelexHandler ffestb_decl_funcname_2_ (ffelexToken t);
945 static ffelexHandler ffestb_decl_funcname_3_ (ffelexToken ft, ffebld expr,
946 ffelexToken t);
947 static ffelexHandler ffestb_decl_funcname_4_ (ffelexToken t);
948 static ffelexHandler ffestb_decl_funcname_5_ (ffelexToken t);
949 static ffelexHandler ffestb_decl_funcname_6_ (ffelexToken t);
950 static ffelexHandler ffestb_decl_funcname_7_ (ffelexToken t);
951 static ffelexHandler ffestb_decl_funcname_8_ (ffelexToken t);
952 static ffelexHandler ffestb_decl_funcname_9_ (ffelexToken t);
953 #if FFESTR_VXT
954 static ffelexHandler ffestb_V0031_ (ffelexToken t);
955 static ffelexHandler ffestb_V0032_ (ffelexToken t);
956 static ffelexHandler ffestb_V0033_ (ffelexToken t);
957 static ffelexHandler ffestb_V0034_ (ffelexToken t);
958 static ffelexHandler ffestb_V0035_ (ffelexToken t);
959 static ffelexHandler ffestb_V0036_ (ffelexToken t);
960 static ffelexHandler ffestb_V0161_ (ffelexToken t);
961 static ffelexHandler ffestb_V0162_ (ffelexToken t);
962 static ffelexHandler ffestb_V0163_ (ffelexToken t);
963 static ffelexHandler ffestb_V0164_ (ffelexToken t);
964 static ffelexHandler ffestb_V0165_ (ffelexToken t);
965 static ffelexHandler ffestb_V0166_ (ffelexToken t);
966 #endif
967 static ffelexHandler ffestb_V0271_ (ffelexToken t);
968 static ffelexHandler ffestb_V0272_ (ffelexToken ft, ffebld expr,
969 ffelexToken t);
970 static ffelexHandler ffestb_V0273_ (ffelexToken t);
971 static ffelexHandler ffestb_decl_R5391_ (ffelexToken t);
972 static ffelexHandler ffestb_decl_R5392_ (ffelexToken t);
973 #if FFESTR_F90
974 static ffelexHandler ffestb_decl_R5393_ (ffelexToken t);
975 #endif
976 static ffelexHandler ffestb_decl_R5394_ (ffelexToken t);
977 static ffelexHandler ffestb_decl_R5395_ (ffelexToken t);
978 static ffelexHandler ffestb_decl_R539letters_ (ffelexToken t);
979 static ffelexHandler ffestb_decl_R539letters_1_ (ffelexToken t);
980 static ffelexHandler ffestb_decl_R539letters_2_ (ffelexToken t);
981 static ffelexHandler ffestb_decl_R539letters_3_ (ffelexToken t);
982 static ffelexHandler ffestb_decl_R539letters_4_ (ffelexToken t);
983 static ffelexHandler ffestb_decl_R539letters_5_ (ffelexToken t);
984 static ffelexHandler ffestb_decl_R539maybe_ (ffelexToken t);
985 static ffelexHandler ffestb_decl_R539maybe_1_ (ffelexToken t);
986 static ffelexHandler ffestb_decl_R539maybe_2_ (ffelexToken t);
987 static ffelexHandler ffestb_decl_R539maybe_3_ (ffelexToken t);
988 static ffelexHandler ffestb_decl_R539maybe_4_ (ffelexToken t);
989 static ffelexHandler ffestb_decl_R539maybe_5_ (ffelexToken t);
990
991 /* Internal macros. */
992
993 #if FFESTB_KILL_EASY_
994 #define ffestb_subr_kill_accept_() \
995 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_acceptix)
996 #define ffestb_subr_kill_beru_() \
997 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_beruix)
998 #define ffestb_subr_kill_close_() \
999 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_closeix)
1000 #define ffestb_subr_kill_delete_() \
1001 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_deleteix)
1002 #define ffestb_subr_kill_find_() \
1003 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_findix)
1004 #define ffestb_subr_kill_inquire_() \
1005 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_inquireix)
1006 #define ffestb_subr_kill_open_() \
1007 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_openix)
1008 #define ffestb_subr_kill_print_() \
1009 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_printix)
1010 #define ffestb_subr_kill_read_() \
1011 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_readix)
1012 #define ffestb_subr_kill_rewrite_() \
1013 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_rewriteix)
1014 #define ffestb_subr_kill_type_() \
1015 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_typeix)
1016 #define ffestb_subr_kill_vxtcode_() \
1017 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_vxtcodeix)
1018 #define ffestb_subr_kill_write_() \
1019 ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_writeix)
1020 #endif
1021 \f
1022 /* ffestb_subr_ambig_nope_ -- Cleans up and aborts ambig w/o confirming
1023
1024 ffestb_subr_ambig_nope_();
1025
1026 Switch from ambiguity handling in _entsp_ functions to handling entities
1027 in _ents_ (perform housekeeping tasks). */
1028
1029 static ffelexHandler
1030 ffestb_subr_ambig_nope_ (ffelexToken t)
1031 {
1032 if (ffestb_local_.decl.recursive != NULL)
1033 ffelex_token_kill (ffestb_local_.decl.recursive);
1034 if (ffestb_local_.decl.kindt != NULL)
1035 ffelex_token_kill (ffestb_local_.decl.kindt);
1036 if (ffestb_local_.decl.lent != NULL)
1037 ffelex_token_kill (ffestb_local_.decl.lent);
1038 ffelex_token_kill (ffesta_tokens[1]);
1039 ffelex_token_kill (ffesta_tokens[2]);
1040 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
1041 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
1042 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1043 }
1044
1045 /* ffestb_subr_ambig_to_ents_ -- Switches from ambiguity to entity decl
1046
1047 ffestb_subr_ambig_to_ents_();
1048
1049 Switch from ambiguity handling in _entsp_ functions to handling entities
1050 in _ents_ (perform housekeeping tasks). */
1051
1052 static void
1053 ffestb_subr_ambig_to_ents_ ()
1054 {
1055 ffelexToken nt;
1056
1057 nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
1058 ffelex_token_kill (ffesta_tokens[1]);
1059 ffelex_token_kill (ffesta_tokens[2]);
1060 ffesta_tokens[1] = nt;
1061 if (ffestb_local_.decl.recursive != NULL)
1062 ffelex_token_kill (ffestb_local_.decl.recursive);
1063 if (!ffestb_local_.decl.aster_after)
1064 {
1065 if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
1066 {
1067 if (!ffesta_is_inhibited ())
1068 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1069 ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
1070 ffestb_local_.decl.len, ffestb_local_.decl.lent);
1071 if (ffestb_local_.decl.kindt != NULL)
1072 {
1073 ffelex_token_kill (ffestb_local_.decl.kindt);
1074 ffestb_local_.decl.kind = NULL;
1075 ffestb_local_.decl.kindt = NULL;
1076 }
1077 if (ffestb_local_.decl.lent != NULL)
1078 {
1079 ffelex_token_kill (ffestb_local_.decl.lent);
1080 ffestb_local_.decl.len = NULL;
1081 ffestb_local_.decl.lent = NULL;
1082 }
1083 }
1084 else
1085 {
1086 if (!ffesta_is_inhibited ())
1087 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1088 ffestb_local_.decl.kind, ffestb_local_.decl.kindt, NULL,
1089 NULL);
1090 if (ffestb_local_.decl.kindt != NULL)
1091 {
1092 ffelex_token_kill (ffestb_local_.decl.kindt);
1093 ffestb_local_.decl.kind = NULL;
1094 ffestb_local_.decl.kindt = NULL;
1095 }
1096 }
1097 return;
1098 }
1099 if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
1100 {
1101 if (!ffesta_is_inhibited ())
1102 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1103 ffestb_local_.decl.kind, ffestb_local_.decl.kindt, NULL, NULL);
1104 if (ffestb_local_.decl.kindt != NULL)
1105 {
1106 ffelex_token_kill (ffestb_local_.decl.kindt);
1107 ffestb_local_.decl.kind = NULL;
1108 ffestb_local_.decl.kindt = NULL;
1109 }
1110 }
1111 else if (!ffesta_is_inhibited ())
1112 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1113 NULL, NULL, NULL, NULL);
1114 /* NAME/NAMES token already in ffesta_tokens[1]. */
1115 }
1116
1117 /* ffestb_subr_dimlist_ -- OPEN_PAREN expr
1118
1119 (ffestb_subr_dimlist_) // to expression handler
1120
1121 Deal with a dimension list.
1122
1123 19-Dec-90 JCB 1.1
1124 Detect too many dimensions if backend wants it. */
1125
1126 static ffelexHandler
1127 ffestb_subr_dimlist_ (ffelexToken ft, ffebld expr, ffelexToken t)
1128 {
1129 switch (ffelex_token_type (t))
1130 {
1131 case FFELEX_typeCLOSE_PAREN:
1132 if (expr == NULL)
1133 break;
1134 #ifdef FFECOM_dimensionsMAX
1135 if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
1136 {
1137 ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
1138 ffestb_subrargs_.dim_list.ok = TRUE; /* Not a parse error, really. */
1139 return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1140 }
1141 #endif
1142 ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, NULL, expr,
1143 ffelex_token_use (t));
1144 ffestb_subrargs_.dim_list.ok = TRUE;
1145 return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1146
1147 case FFELEX_typeCOMMA:
1148 if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1149 break;
1150 #ifdef FFECOM_dimensionsMAX
1151 if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
1152 {
1153 ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
1154 return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1155 ffestb_subrargs_.dim_list.ctx,
1156 (ffeexprCallback) ffestb_subr_dimlist_2_);
1157 }
1158 #endif
1159 ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, NULL, expr,
1160 ffelex_token_use (t));
1161 return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1162 ffestb_subrargs_.dim_list.ctx,
1163 (ffeexprCallback) ffestb_subr_dimlist_);
1164
1165 case FFELEX_typeCOLON:
1166 if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1167 break;
1168 #ifdef FFECOM_dimensionsMAX
1169 if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
1170 {
1171 ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
1172 return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1173 ffestb_subrargs_.dim_list.ctx,
1174 (ffeexprCallback) ffestb_subr_dimlist_2_);
1175 }
1176 #endif
1177 ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, expr, NULL,
1178 ffelex_token_use (t)); /* NULL second expr for
1179 now, just plug in. */
1180 return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1181 ffestb_subrargs_.dim_list.ctx,
1182 (ffeexprCallback) ffestb_subr_dimlist_1_);
1183
1184 default:
1185 break;
1186 }
1187
1188 ffestb_subrargs_.dim_list.ok = FALSE;
1189 return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
1190 }
1191
1192 /* ffestb_subr_dimlist_1_ -- OPEN_PAREN expr COLON expr
1193
1194 (ffestb_subr_dimlist_1_) // to expression handler
1195
1196 Get the upper bound. */
1197
1198 static ffelexHandler
1199 ffestb_subr_dimlist_1_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
1200 {
1201 switch (ffelex_token_type (t))
1202 {
1203 case FFELEX_typeCLOSE_PAREN:
1204 ffestb_subrargs_.dim_list.dims->previous->upper = expr;
1205 ffestb_subrargs_.dim_list.ok = TRUE;
1206 return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1207
1208 case FFELEX_typeCOMMA:
1209 if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1210 break;
1211 ffestb_subrargs_.dim_list.dims->previous->upper = expr;
1212 return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1213 ffestb_subrargs_.dim_list.ctx, (ffeexprCallback) ffestb_subr_dimlist_);
1214
1215 default:
1216 break;
1217 }
1218
1219 ffestb_subrargs_.dim_list.ok = FALSE;
1220 return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
1221 }
1222
1223 /* ffestb_subr_dimlist_2_ -- OPEN_PAREN too-many-dim-exprs
1224
1225 (ffestb_subr_dimlist_2_) // to expression handler
1226
1227 Get the upper bound. */
1228
1229 static ffelexHandler
1230 ffestb_subr_dimlist_2_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
1231 {
1232 switch (ffelex_token_type (t))
1233 {
1234 case FFELEX_typeCLOSE_PAREN:
1235 ffestb_subrargs_.dim_list.ok = TRUE; /* Not a parse error, really. */
1236 return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1237
1238 case FFELEX_typeCOMMA:
1239 case FFELEX_typeCOLON:
1240 if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1241 break;
1242 return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1243 ffestb_subrargs_.dim_list.ctx,
1244 (ffeexprCallback) ffestb_subr_dimlist_2_);
1245
1246 default:
1247 break;
1248 }
1249
1250 ffestb_subrargs_.dim_list.ok = FALSE;
1251 return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
1252 }
1253
1254 /* ffestb_subr_name_list_ -- Collect a list of name args and close-paren
1255
1256 return ffestb_subr_name_list_; // to lexer after seeing OPEN_PAREN
1257
1258 This implements R1224 in the Fortran 90 spec. The arg list may be
1259 empty, or be a comma-separated list (an optional trailing comma currently
1260 results in a warning but no other effect) of arguments. For functions,
1261 however, "*" is invalid (we implement dummy-arg-name, rather than R1224
1262 dummy-arg, which itself is either dummy-arg-name or "*"). */
1263
1264 static ffelexHandler
1265 ffestb_subr_name_list_ (ffelexToken t)
1266 {
1267 switch (ffelex_token_type (t))
1268 {
1269 case FFELEX_typeCLOSE_PAREN:
1270 if (ffestt_tokenlist_count (ffestb_subrargs_.name_list.args) != 0)
1271 { /* Trailing comma, warn. */
1272 ffebad_start (FFEBAD_TRAILING_COMMA);
1273 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
1274 ffebad_finish ();
1275 }
1276 ffestb_subrargs_.name_list.ok = TRUE;
1277 ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1278 if (ffestb_subrargs_.name_list.names)
1279 ffelex_set_names (TRUE);
1280 return (ffelexHandler) ffestb_subrargs_.name_list.handler;
1281
1282 case FFELEX_typeASTERISK:
1283 if (!ffestb_subrargs_.name_list.is_subr)
1284 break;
1285
1286 case FFELEX_typeNAME:
1287 ffestt_tokenlist_append (ffestb_subrargs_.name_list.args,
1288 ffelex_token_use (t));
1289 return (ffelexHandler) ffestb_subr_name_list_1_;
1290
1291 default:
1292 break;
1293 }
1294
1295 ffestb_subrargs_.name_list.ok = FALSE;
1296 ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1297 if (ffestb_subrargs_.name_list.names)
1298 ffelex_set_names (TRUE);
1299 return (ffelexHandler) (*ffestb_subrargs_.name_list.handler) (t);
1300 }
1301
1302 /* ffestb_subr_name_list_1_ -- NAME or ASTERISK
1303
1304 return ffestb_subr_name_list_1_; // to lexer
1305
1306 The next token must be COMMA or CLOSE_PAREN, either way go to original
1307 state, but only after adding the appropriate name list item. */
1308
1309 static ffelexHandler
1310 ffestb_subr_name_list_1_ (ffelexToken t)
1311 {
1312 switch (ffelex_token_type (t))
1313 {
1314 case FFELEX_typeCOMMA:
1315 return (ffelexHandler) ffestb_subr_name_list_;
1316
1317 case FFELEX_typeCLOSE_PAREN:
1318 ffestb_subrargs_.name_list.ok = TRUE;
1319 ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1320 if (ffestb_subrargs_.name_list.names)
1321 ffelex_set_names (TRUE);
1322 return (ffelexHandler) ffestb_subrargs_.name_list.handler;
1323
1324 default:
1325 ffestb_subrargs_.name_list.ok = FALSE;
1326 ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1327 if (ffestb_subrargs_.name_list.names)
1328 ffelex_set_names (TRUE);
1329 return (ffelexHandler) (*ffestb_subrargs_.name_list.handler) (t);
1330 }
1331 }
1332
1333 static void
1334 ffestb_subr_R1001_append_p_ (void)
1335 {
1336 ffesttFormatList f;
1337
1338 if (!ffestb_local_.format.pre.present)
1339 {
1340 ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_P_SPEC, ffestb_local_.format.t);
1341 ffelex_token_kill (ffestb_local_.format.t);
1342 return;
1343 }
1344
1345 f = ffestt_formatlist_append (ffestb_local_.format.f);
1346 f->type = FFESTP_formattypeP;
1347 f->t = ffestb_local_.format.t;
1348 f->u.R1010.val = ffestb_local_.format.pre;
1349 }
1350
1351 /* ffestb_decl_kindparam_ -- "type" OPEN_PAREN
1352
1353 return ffestb_decl_kindparam_; // to lexer
1354
1355 Handle "[KIND=]expr)". */
1356
1357 static ffelexHandler
1358 ffestb_decl_kindparam_ (ffelexToken t)
1359 {
1360 switch (ffelex_token_type (t))
1361 {
1362 case FFELEX_typeNAME:
1363 ffesta_tokens[1] = ffelex_token_use (t);
1364 return (ffelexHandler) ffestb_decl_kindparam_1_;
1365
1366 default:
1367 return (ffelexHandler) (*((ffelexHandler)
1368 ffeexpr_rhs (ffesta_output_pool,
1369 FFEEXPR_contextKINDTYPE,
1370 (ffeexprCallback) ffestb_decl_kindparam_2_)))
1371 (t);
1372 }
1373 }
1374
1375 /* ffestb_decl_kindparam_1_ -- "type" OPEN_PAREN NAME
1376
1377 return ffestb_decl_kindparam_1_; // to lexer
1378
1379 Handle "[KIND=]expr)". */
1380
1381 static ffelexHandler
1382 ffestb_decl_kindparam_1_ (ffelexToken t)
1383 {
1384 ffelexHandler next;
1385 ffelexToken nt;
1386
1387 switch (ffelex_token_type (t))
1388 {
1389 case FFELEX_typeEQUALS:
1390 ffesta_confirmed ();
1391 if (ffestr_other (ffesta_tokens[1]) != FFESTR_otherKIND)
1392 break;
1393 ffelex_token_kill (ffesta_tokens[1]);
1394 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1395 FFEEXPR_contextKINDTYPE, (ffeexprCallback) ffestb_decl_kindparam_2_);
1396
1397 default:
1398 nt = ffesta_tokens[1];
1399 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1400 FFEEXPR_contextKINDTYPE, (ffeexprCallback) ffestb_decl_kindparam_2_)))
1401 (nt);
1402 ffelex_token_kill (nt);
1403 return (ffelexHandler) (*next) (t);
1404 }
1405
1406 if (ffestb_local_.decl.recursive != NULL)
1407 ffelex_token_kill (ffestb_local_.decl.recursive);
1408 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1409 ffestb_local_.decl.badname,
1410 ffesta_tokens[1]);
1411 ffelex_token_kill (ffesta_tokens[1]);
1412 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1413 }
1414
1415 /* ffestb_decl_kindparam_2_ -- "type" OPEN_PAREN ["KIND="] expr
1416
1417 (ffestb_decl_kindparam_2_) // to expression handler
1418
1419 Handle "[KIND=]expr)". */
1420
1421 static ffelexHandler
1422 ffestb_decl_kindparam_2_ (ffelexToken ft, ffebld expr, ffelexToken t)
1423 {
1424 switch (ffelex_token_type (t))
1425 {
1426 case FFELEX_typeCLOSE_PAREN:
1427 ffestb_local_.decl.kind = expr;
1428 ffestb_local_.decl.kindt = ffelex_token_use (ft);
1429 ffestb_local_.decl.len = NULL;
1430 ffestb_local_.decl.lent = NULL;
1431 ffelex_set_names (TRUE);
1432 return (ffelexHandler) ffestb_local_.decl.handler;
1433
1434 default:
1435 break;
1436 }
1437
1438 if (ffestb_local_.decl.recursive != NULL)
1439 ffelex_token_kill (ffestb_local_.decl.recursive);
1440 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1441 ffestb_local_.decl.badname,
1442 t);
1443 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1444 }
1445
1446 /* ffestb_decl_starkind_ -- "type" ASTERISK
1447
1448 return ffestb_decl_starkind_; // to lexer
1449
1450 Handle NUMBER. */
1451
1452 static ffelexHandler
1453 ffestb_decl_starkind_ (ffelexToken t)
1454 {
1455 switch (ffelex_token_type (t))
1456 {
1457 case FFELEX_typeNUMBER:
1458 ffestb_local_.decl.kindt = ffelex_token_use (t);
1459 ffestb_local_.decl.kind = NULL;
1460 ffestb_local_.decl.len = NULL;
1461 ffestb_local_.decl.lent = NULL;
1462 ffelex_set_names (TRUE);
1463 return (ffelexHandler) ffestb_local_.decl.handler;
1464
1465 default:
1466 break;
1467 }
1468
1469 if (ffestb_local_.decl.recursive != NULL)
1470 ffelex_token_kill (ffestb_local_.decl.recursive);
1471 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1472 ffestb_local_.decl.badname,
1473 t);
1474 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1475 }
1476
1477 /* ffestb_decl_starlen_ -- "CHARACTER" ASTERISK
1478
1479 return ffestb_decl_starlen_; // to lexer
1480
1481 Handle NUMBER. */
1482
1483 static ffelexHandler
1484 ffestb_decl_starlen_ (ffelexToken t)
1485 {
1486 switch (ffelex_token_type (t))
1487 {
1488 case FFELEX_typeNUMBER:
1489 ffestb_local_.decl.kind = NULL;
1490 ffestb_local_.decl.kindt = NULL;
1491 ffestb_local_.decl.len = NULL;
1492 ffestb_local_.decl.lent = ffelex_token_use (t);
1493 ffelex_set_names (TRUE);
1494 return (ffelexHandler) ffestb_local_.decl.handler;
1495
1496 case FFELEX_typeOPEN_PAREN:
1497 ffestb_local_.decl.kind = NULL;
1498 ffestb_local_.decl.kindt = NULL;
1499 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1500 FFEEXPR_contextCHARACTERSIZE,
1501 (ffeexprCallback) ffestb_decl_starlen_1_);
1502
1503 default:
1504 break;
1505 }
1506
1507 if (ffestb_local_.decl.recursive != NULL)
1508 ffelex_token_kill (ffestb_local_.decl.recursive);
1509 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1510 ffestb_local_.decl.badname,
1511 t);
1512 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1513 }
1514
1515 /* ffestb_decl_starlen_1_ -- "CHARACTER" ASTERISK OPEN_PAREN expr
1516
1517 (ffestb_decl_starlen_1_) // to expression handler
1518
1519 Handle CLOSE_PAREN. */
1520
1521 static ffelexHandler
1522 ffestb_decl_starlen_1_ (ffelexToken ft, ffebld expr, ffelexToken t)
1523 {
1524 switch (ffelex_token_type (t))
1525 {
1526 case FFELEX_typeCLOSE_PAREN:
1527 if (expr == NULL)
1528 break;
1529 ffestb_local_.decl.len = expr;
1530 ffestb_local_.decl.lent = ffelex_token_use (ft);
1531 ffelex_set_names (TRUE);
1532 return (ffelexHandler) ffestb_local_.decl.handler;
1533
1534 default:
1535 break;
1536 }
1537
1538 if (ffestb_local_.decl.recursive != NULL)
1539 ffelex_token_kill (ffestb_local_.decl.recursive);
1540 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1541 ffestb_local_.decl.badname,
1542 t);
1543 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1544 }
1545
1546 /* ffestb_decl_typeparams_ -- "CHARACTER" OPEN_PAREN
1547
1548 return ffestb_decl_typeparams_; // to lexer
1549
1550 Handle "[KIND=]expr)". */
1551
1552 static ffelexHandler
1553 ffestb_decl_typeparams_ (ffelexToken t)
1554 {
1555 switch (ffelex_token_type (t))
1556 {
1557 case FFELEX_typeNAME:
1558 ffesta_tokens[1] = ffelex_token_use (t);
1559 return (ffelexHandler) ffestb_decl_typeparams_1_;
1560
1561 default:
1562 if (ffestb_local_.decl.lent == NULL)
1563 return (ffelexHandler) (*((ffelexHandler)
1564 ffeexpr_rhs (ffesta_output_pool,
1565 FFEEXPR_contextCHARACTERSIZE,
1566 (ffeexprCallback) ffestb_decl_typeparams_2_)))
1567 (t);
1568 if (ffestb_local_.decl.kindt != NULL)
1569 break;
1570 return (ffelexHandler) (*((ffelexHandler)
1571 ffeexpr_rhs (ffesta_output_pool,
1572 FFEEXPR_contextKINDTYPE,
1573 (ffeexprCallback) ffestb_decl_typeparams_3_)))
1574 (t);
1575 }
1576
1577 if (ffestb_local_.decl.recursive != NULL)
1578 ffelex_token_kill (ffestb_local_.decl.recursive);
1579 if (ffestb_local_.decl.kindt != NULL)
1580 ffelex_token_kill (ffestb_local_.decl.kindt);
1581 if (ffestb_local_.decl.lent != NULL)
1582 ffelex_token_kill (ffestb_local_.decl.lent);
1583 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1584 ffestb_local_.decl.badname,
1585 t);
1586 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1587 }
1588
1589 /* ffestb_decl_typeparams_1_ -- "CHARACTER" OPEN_PAREN NAME
1590
1591 return ffestb_decl_typeparams_1_; // to lexer
1592
1593 Handle "[KIND=]expr)". */
1594
1595 static ffelexHandler
1596 ffestb_decl_typeparams_1_ (ffelexToken t)
1597 {
1598 ffelexHandler next;
1599 ffelexToken nt;
1600
1601 switch (ffelex_token_type (t))
1602 {
1603 case FFELEX_typeEQUALS:
1604 ffesta_confirmed ();
1605 switch (ffestr_other (ffesta_tokens[1]))
1606 {
1607 case FFESTR_otherLEN:
1608 if (ffestb_local_.decl.lent != NULL)
1609 break;
1610 ffelex_token_kill (ffesta_tokens[1]);
1611 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1612 FFEEXPR_contextCHARACTERSIZE,
1613 (ffeexprCallback) ffestb_decl_typeparams_2_);
1614
1615 case FFESTR_otherKIND:
1616 if (ffestb_local_.decl.kindt != NULL)
1617 break;
1618 ffelex_token_kill (ffesta_tokens[1]);
1619 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1620 FFEEXPR_contextKINDTYPE,
1621 (ffeexprCallback) ffestb_decl_typeparams_3_);
1622
1623 default:
1624 break;
1625 }
1626 break;
1627
1628 default:
1629 nt = ffesta_tokens[1];
1630 if (ffestb_local_.decl.lent == NULL)
1631 next = (ffelexHandler) (*((ffelexHandler)
1632 ffeexpr_rhs (ffesta_output_pool,
1633 FFEEXPR_contextCHARACTERSIZE,
1634 (ffeexprCallback) ffestb_decl_typeparams_2_)))
1635 (nt);
1636 else if (ffestb_local_.decl.kindt == NULL)
1637 next = (ffelexHandler) (*((ffelexHandler)
1638 ffeexpr_rhs (ffesta_output_pool,
1639 FFEEXPR_contextKINDTYPE,
1640 (ffeexprCallback) ffestb_decl_typeparams_3_)))
1641 (nt);
1642 else
1643 {
1644 ffesta_tokens[1] = nt;
1645 break;
1646 }
1647 ffelex_token_kill (nt);
1648 return (ffelexHandler) (*next) (t);
1649 }
1650
1651 if (ffestb_local_.decl.recursive != NULL)
1652 ffelex_token_kill (ffestb_local_.decl.recursive);
1653 if (ffestb_local_.decl.kindt != NULL)
1654 ffelex_token_kill (ffestb_local_.decl.kindt);
1655 if (ffestb_local_.decl.lent != NULL)
1656 ffelex_token_kill (ffestb_local_.decl.lent);
1657 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1658 ffestb_local_.decl.badname,
1659 ffesta_tokens[1]);
1660 ffelex_token_kill (ffesta_tokens[1]);
1661 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1662 }
1663
1664 /* ffestb_decl_typeparams_2_ -- "CHARACTER" OPEN_PAREN ["LEN="] expr
1665
1666 (ffestb_decl_typeparams_2_) // to expression handler
1667
1668 Handle "[LEN=]expr)". */
1669
1670 static ffelexHandler
1671 ffestb_decl_typeparams_2_ (ffelexToken ft, ffebld expr, ffelexToken t)
1672 {
1673 switch (ffelex_token_type (t))
1674 {
1675 case FFELEX_typeCLOSE_PAREN:
1676 ffestb_local_.decl.len = expr;
1677 ffestb_local_.decl.lent = ffelex_token_use (ft);
1678 ffelex_set_names (TRUE);
1679 return (ffelexHandler) ffestb_local_.decl.handler;
1680
1681 case FFELEX_typeCOMMA:
1682 ffestb_local_.decl.len = expr;
1683 ffestb_local_.decl.lent = ffelex_token_use (ft);
1684 return (ffelexHandler) ffestb_decl_typeparams_;
1685
1686 default:
1687 break;
1688 }
1689
1690 if (ffestb_local_.decl.recursive != NULL)
1691 ffelex_token_kill (ffestb_local_.decl.recursive);
1692 if (ffestb_local_.decl.kindt != NULL)
1693 ffelex_token_kill (ffestb_local_.decl.kindt);
1694 if (ffestb_local_.decl.lent != NULL)
1695 ffelex_token_kill (ffestb_local_.decl.lent);
1696 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1697 ffestb_local_.decl.badname,
1698 t);
1699 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1700 }
1701
1702 /* ffestb_decl_typeparams_3_ -- "CHARACTER" OPEN_PAREN ["KIND="] expr
1703
1704 (ffestb_decl_typeparams_3_) // to expression handler
1705
1706 Handle "[KIND=]expr)". */
1707
1708 static ffelexHandler
1709 ffestb_decl_typeparams_3_ (ffelexToken ft, ffebld expr, ffelexToken t)
1710 {
1711 switch (ffelex_token_type (t))
1712 {
1713 case FFELEX_typeCLOSE_PAREN:
1714 ffestb_local_.decl.kind = expr;
1715 ffestb_local_.decl.kindt = ffelex_token_use (ft);
1716 ffelex_set_names (TRUE);
1717 return (ffelexHandler) ffestb_local_.decl.handler;
1718
1719 case FFELEX_typeCOMMA:
1720 ffestb_local_.decl.kind = expr;
1721 ffestb_local_.decl.kindt = ffelex_token_use (ft);
1722 return (ffelexHandler) ffestb_decl_typeparams_;
1723
1724 default:
1725 break;
1726 }
1727
1728 if (ffestb_local_.decl.recursive != NULL)
1729 ffelex_token_kill (ffestb_local_.decl.recursive);
1730 if (ffestb_local_.decl.kindt != NULL)
1731 ffelex_token_kill (ffestb_local_.decl.kindt);
1732 if (ffestb_local_.decl.lent != NULL)
1733 ffelex_token_kill (ffestb_local_.decl.lent);
1734 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1735 ffestb_local_.decl.badname,
1736 t);
1737 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1738 }
1739
1740 /* ffestb_decl_typetype1_ -- "TYPE" OPEN_PAREN
1741
1742 return ffestb_decl_typetype1_; // to lexer
1743
1744 Handle NAME. */
1745
1746 #if FFESTR_F90
1747 static ffelexHandler
1748 ffestb_decl_typetype1_ (ffelexToken t)
1749 {
1750 switch (ffelex_token_type (t))
1751 {
1752 case FFELEX_typeNAME:
1753 ffestb_local_.decl.kindt = ffelex_token_use (t);
1754 return (ffelexHandler) ffestb_decl_typetype2_;
1755
1756 default:
1757 break;
1758 }
1759
1760 if (ffestb_local_.decl.recursive != NULL)
1761 ffelex_token_kill (ffestb_local_.decl.recursive);
1762 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1763 ffestb_local_.decl.badname,
1764 t);
1765 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1766 }
1767
1768 /* ffestb_decl_typetype2_ -- "TYPE" OPEN_PAREN NAME
1769
1770 return ffestb_decl_typetype2_; // to lexer
1771
1772 Handle CLOSE_PAREN. */
1773
1774 static ffelexHandler
1775 ffestb_decl_typetype2_ (ffelexToken t)
1776 {
1777 switch (ffelex_token_type (t))
1778 {
1779 case FFELEX_typeCLOSE_PAREN:
1780 ffestb_local_.decl.type = FFESTP_typeTYPE;
1781 ffestb_local_.decl.kind = NULL;
1782 ffestb_local_.decl.len = NULL;
1783 ffestb_local_.decl.lent = NULL;
1784 ffelex_set_names (TRUE);
1785 return (ffelexHandler) ffestb_local_.decl.handler;
1786
1787 default:
1788 break;
1789 }
1790
1791 if (ffestb_local_.decl.recursive != NULL)
1792 ffelex_token_kill (ffestb_local_.decl.recursive);
1793 ffelex_token_kill (ffestb_local_.decl.kindt);
1794 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1795 ffestb_local_.decl.badname,
1796 t);
1797 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1798 }
1799
1800 #endif
1801 /* ffestb_subr_label_list_ -- Collect a tokenlist of labels and close-paren
1802
1803 return ffestb_subr_label_list_; // to lexer after seeing OPEN_PAREN
1804
1805 First token must be a NUMBER. Must be followed by zero or more COMMA
1806 NUMBER pairs. Must then be followed by a CLOSE_PAREN. If all ok, put
1807 the NUMBER tokens in a token list and return via the handler for the
1808 token after CLOSE_PAREN. Else return via
1809 same handler, but with the ok return value set FALSE. */
1810
1811 static ffelexHandler
1812 ffestb_subr_label_list_ (ffelexToken t)
1813 {
1814 if (ffelex_token_type (t) == FFELEX_typeNUMBER)
1815 {
1816 ffestt_tokenlist_append (ffestb_subrargs_.label_list.labels,
1817 ffelex_token_use (t));
1818 return (ffelexHandler) ffestb_subr_label_list_1_;
1819 }
1820
1821 ffestb_subrargs_.label_list.ok = FALSE;
1822 return (ffelexHandler) (*ffestb_subrargs_.label_list.handler) (t);
1823 }
1824
1825 /* ffestb_subr_label_list_1_ -- NUMBER
1826
1827 return ffestb_subr_label_list_1_; // to lexer after seeing NUMBER
1828
1829 The next token must be COMMA, in which case go back to
1830 ffestb_subr_label_list_, or CLOSE_PAREN, in which case set ok to TRUE
1831 and go to the handler. */
1832
1833 static ffelexHandler
1834 ffestb_subr_label_list_1_ (ffelexToken t)
1835 {
1836 switch (ffelex_token_type (t))
1837 {
1838 case FFELEX_typeCOMMA:
1839 return (ffelexHandler) ffestb_subr_label_list_;
1840
1841 case FFELEX_typeCLOSE_PAREN:
1842 ffestb_subrargs_.label_list.ok = TRUE;
1843 return (ffelexHandler) ffestb_subrargs_.label_list.handler;
1844
1845 default:
1846 ffestb_subrargs_.label_list.ok = FALSE;
1847 return (ffelexHandler) (*ffestb_subrargs_.label_list.handler) (t);
1848 }
1849 }
1850
1851 /* ffestb_do -- Parse the DO statement
1852
1853 return ffestb_do; // to lexer
1854
1855 Make sure the statement has a valid form for the DO statement. If it
1856 does, implement the statement. */
1857
1858 ffelexHandler
1859 ffestb_do (ffelexToken t)
1860 {
1861 ffeTokenLength i;
1862 unsigned const char *p;
1863 ffelexHandler next;
1864 ffelexToken nt;
1865 ffestrSecond kw;
1866
1867 switch (ffelex_token_type (ffesta_tokens[0]))
1868 {
1869 case FFELEX_typeNAME:
1870 if (ffesta_first_kw != FFESTR_firstDO)
1871 goto bad_0; /* :::::::::::::::::::: */
1872 switch (ffelex_token_type (t))
1873 {
1874 case FFELEX_typeNUMBER:
1875 ffesta_confirmed ();
1876 ffesta_tokens[1] = ffelex_token_use (t);
1877 return (ffelexHandler) ffestb_do1_;
1878
1879 case FFELEX_typeCOMMA:
1880 ffesta_confirmed ();
1881 ffesta_tokens[1] = NULL;
1882 return (ffelexHandler) ffestb_do2_;
1883
1884 case FFELEX_typeNAME:
1885 ffesta_confirmed ();
1886 ffesta_tokens[1] = NULL;
1887 ffesta_tokens[2] = ffelex_token_use (t);
1888 return (ffelexHandler) ffestb_do3_;
1889
1890 case FFELEX_typeEOS:
1891 case FFELEX_typeSEMICOLON:
1892 ffesta_confirmed ();
1893 ffesta_tokens[1] = NULL;
1894 return (ffelexHandler) ffestb_do1_ (t);
1895
1896 case FFELEX_typeCOLONCOLON:
1897 ffesta_confirmed (); /* Error, but clearly intended. */
1898 goto bad_1; /* :::::::::::::::::::: */
1899
1900 default:
1901 goto bad_1; /* :::::::::::::::::::: */
1902 }
1903
1904 case FFELEX_typeNAMES:
1905 if (ffesta_first_kw != FFESTR_firstDO)
1906 goto bad_0; /* :::::::::::::::::::: */
1907 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDO);
1908 switch (ffelex_token_type (t))
1909 {
1910 case FFELEX_typeCOLONCOLON:
1911 ffesta_confirmed (); /* Error, but clearly intended. */
1912 goto bad_1; /* :::::::::::::::::::: */
1913
1914 default:
1915 goto bad_1; /* :::::::::::::::::::: */
1916
1917 case FFELEX_typeOPEN_PAREN: /* Must be "DO" label "WHILE". */
1918 if (! ISDIGIT (*p))
1919 goto bad_i; /* :::::::::::::::::::: */
1920 ffesta_tokens[1] = ffelex_token_number_from_names (ffesta_tokens[0],
1921 i);
1922 p += ffelex_token_length (ffesta_tokens[1]);
1923 i += ffelex_token_length (ffesta_tokens[1]);
1924 if (((*p) != 'W') && ((*p) != 'w'))
1925 goto bad_i1; /* :::::::::::::::::::: */
1926 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
1927 kw = ffestr_second (nt);
1928 ffelex_token_kill (nt);
1929 if (kw != FFESTR_secondWHILE)
1930 goto bad_i1; /* :::::::::::::::::::: */
1931 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1932 FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
1933
1934 case FFELEX_typeCOMMA:
1935 ffesta_confirmed ();
1936 if (*p == '\0')
1937 {
1938 ffesta_tokens[1] = NULL;
1939 return (ffelexHandler) ffestb_do2_;
1940 }
1941 if (! ISDIGIT (*p))
1942 goto bad_i; /* :::::::::::::::::::: */
1943 ffesta_tokens[1] = ffelex_token_number_from_names (ffesta_tokens[0],
1944 i);
1945 p += ffelex_token_length (ffesta_tokens[1]);
1946 i += ffelex_token_length (ffesta_tokens[1]);
1947 if (*p != '\0')
1948 goto bad_i1; /* :::::::::::::::::::: */
1949 return (ffelexHandler) ffestb_do2_;
1950
1951 case FFELEX_typeEQUALS:
1952 if (ISDIGIT (*p))
1953 {
1954 ffesta_tokens[1]
1955 = ffelex_token_number_from_names (ffesta_tokens[0], i);
1956 p += ffelex_token_length (ffesta_tokens[1]);
1957 i += ffelex_token_length (ffesta_tokens[1]);
1958 }
1959 else
1960 ffesta_tokens[1] = NULL;
1961 if (!ffesrc_is_name_init (*p))
1962 goto bad_i1; /* :::::::::::::::::::: */
1963 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
1964 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_lhs
1965 (ffesta_output_pool, FFEEXPR_contextDO,
1966 (ffeexprCallback) ffestb_do6_)))
1967 (nt);
1968 ffelex_token_kill (nt); /* Will get it back in _6_... */
1969 return (ffelexHandler) (*next) (t);
1970
1971 case FFELEX_typeEOS:
1972 case FFELEX_typeSEMICOLON:
1973 ffesta_confirmed ();
1974 if (ISDIGIT (*p))
1975 {
1976 ffesta_tokens[1]
1977 = ffelex_token_number_from_names (ffesta_tokens[0], i);
1978 p += ffelex_token_length (ffesta_tokens[1]);
1979 i += ffelex_token_length (ffesta_tokens[1]);
1980 }
1981 else
1982 ffesta_tokens[1] = NULL;
1983 if (*p != '\0')
1984 goto bad_i1; /* :::::::::::::::::::: */
1985 return (ffelexHandler) ffestb_do1_ (t);
1986 }
1987
1988 default:
1989 goto bad_0; /* :::::::::::::::::::: */
1990 }
1991
1992 bad_0: /* :::::::::::::::::::: */
1993 if (ffesta_construct_name != NULL)
1994 {
1995 ffelex_token_kill (ffesta_construct_name);
1996 ffesta_construct_name = NULL;
1997 }
1998 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0]);
1999 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2000
2001 bad_1: /* :::::::::::::::::::: */
2002 if (ffesta_construct_name != NULL)
2003 {
2004 ffelex_token_kill (ffesta_construct_name);
2005 ffesta_construct_name = NULL;
2006 }
2007 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2008 return (ffelexHandler) ffelex_swallow_tokens (t,
2009 (ffelexHandler) ffesta_zero); /* Invalid second token. */
2010
2011 bad_i1: /* :::::::::::::::::::: */
2012 if (ffesta_tokens[1])
2013 ffelex_token_kill (ffesta_tokens[1]);
2014
2015 bad_i: /* :::::::::::::::::::: */
2016 if (ffesta_construct_name != NULL)
2017 {
2018 ffelex_token_kill (ffesta_construct_name);
2019 ffesta_construct_name = NULL;
2020 }
2021 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0], i, t);
2022 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2023 }
2024
2025 /* ffestb_dowhile -- Parse the DOWHILE statement
2026
2027 return ffestb_dowhile; // to lexer
2028
2029 Make sure the statement has a valid form for the DOWHILE statement. If it
2030 does, implement the statement. */
2031
2032 ffelexHandler
2033 ffestb_dowhile (ffelexToken t)
2034 {
2035 ffeTokenLength i;
2036 const char *p;
2037 ffelexHandler next;
2038 ffelexToken nt;
2039
2040 switch (ffelex_token_type (ffesta_tokens[0]))
2041 {
2042 case FFELEX_typeNAMES:
2043 if (ffesta_first_kw != FFESTR_firstDOWHILE)
2044 goto bad_0; /* :::::::::::::::::::: */
2045 switch (ffelex_token_type (t))
2046 {
2047 case FFELEX_typeEOS:
2048 case FFELEX_typeSEMICOLON:
2049 case FFELEX_typeCOMMA:
2050 case FFELEX_typeCOLONCOLON:
2051 ffesta_confirmed (); /* Error, but clearly intended. */
2052 goto bad_1; /* :::::::::::::::::::: */
2053
2054 default:
2055 goto bad_1; /* :::::::::::::::::::: */
2056
2057 case FFELEX_typeOPEN_PAREN:
2058 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDOWHILE);
2059 if (*p != '\0')
2060 goto bad_i; /* :::::::::::::::::::: */
2061 ffesta_tokens[1] = NULL;
2062 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2063 FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
2064
2065 case FFELEX_typeEQUALS:/* Not really DOWHILE, but DOWHILExyz=.... */
2066 ffesta_tokens[1] = NULL;
2067 nt = ffelex_token_name_from_names (ffesta_tokens[0], FFESTR_firstlDO,
2068 0);
2069 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_lhs
2070 (ffesta_output_pool, FFEEXPR_contextDO,
2071 (ffeexprCallback) ffestb_do6_)))
2072 (nt);
2073 ffelex_token_kill (nt); /* Will get it back in _6_... */
2074 return (ffelexHandler) (*next) (t);
2075 }
2076
2077 default:
2078 goto bad_0; /* :::::::::::::::::::: */
2079 }
2080
2081 bad_0: /* :::::::::::::::::::: */
2082 if (ffesta_construct_name != NULL)
2083 {
2084 ffelex_token_kill (ffesta_construct_name);
2085 ffesta_construct_name = NULL;
2086 }
2087 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0]);
2088 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2089
2090 bad_1: /* :::::::::::::::::::: */
2091 if (ffesta_construct_name != NULL)
2092 {
2093 ffelex_token_kill (ffesta_construct_name);
2094 ffesta_construct_name = NULL;
2095 }
2096 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2097 return (ffelexHandler) ffelex_swallow_tokens (t,
2098 (ffelexHandler) ffesta_zero); /* Invalid second token. */
2099
2100 bad_i: /* :::::::::::::::::::: */
2101 if (ffesta_construct_name != NULL)
2102 {
2103 ffelex_token_kill (ffesta_construct_name);
2104 ffesta_construct_name = NULL;
2105 }
2106 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0], i, t);
2107 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2108 }
2109
2110 /* ffestb_do1_ -- "DO" [label]
2111
2112 return ffestb_do1_; // to lexer
2113
2114 Make sure the statement has a valid form for the DO statement. If it
2115 does, implement the statement. */
2116
2117 static ffelexHandler
2118 ffestb_do1_ (ffelexToken t)
2119 {
2120 switch (ffelex_token_type (t))
2121 {
2122 case FFELEX_typeCOMMA:
2123 ffesta_confirmed ();
2124 return (ffelexHandler) ffestb_do2_;
2125
2126 case FFELEX_typeEOS:
2127 case FFELEX_typeSEMICOLON:
2128 ffesta_confirmed ();
2129 if (!ffesta_is_inhibited ())
2130 {
2131 if (ffesta_tokens[1] != NULL)
2132 ffestc_R819B (ffesta_construct_name, ffesta_tokens[1], NULL,
2133 NULL);
2134 else
2135 ffestc_R820B (ffesta_construct_name, NULL, NULL);
2136 }
2137 if (ffesta_tokens[1] != NULL)
2138 ffelex_token_kill (ffesta_tokens[1]);
2139 if (ffesta_construct_name != NULL)
2140 {
2141 ffelex_token_kill (ffesta_construct_name);
2142 ffesta_construct_name = NULL;
2143 }
2144 return (ffelexHandler) ffesta_zero (t);
2145
2146 case FFELEX_typeNAME:
2147 return (ffelexHandler) ffestb_do2_ (t);
2148
2149 default:
2150 break;
2151 }
2152
2153 if (ffesta_tokens[1] != NULL)
2154 ffelex_token_kill (ffesta_tokens[1]);
2155 if (ffesta_construct_name != NULL)
2156 {
2157 ffelex_token_kill (ffesta_construct_name);
2158 ffesta_construct_name = NULL;
2159 }
2160 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2161 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2162 }
2163
2164 /* ffestb_do2_ -- "DO" [label] [,]
2165
2166 return ffestb_do2_; // to lexer
2167
2168 Make sure the statement has a valid form for the DO statement. If it
2169 does, implement the statement. */
2170
2171 static ffelexHandler
2172 ffestb_do2_ (ffelexToken t)
2173 {
2174 switch (ffelex_token_type (t))
2175 {
2176 case FFELEX_typeNAME:
2177 ffesta_tokens[2] = ffelex_token_use (t);
2178 return (ffelexHandler) ffestb_do3_;
2179
2180 default:
2181 break;
2182 }
2183
2184 if (ffesta_tokens[1] != NULL)
2185 ffelex_token_kill (ffesta_tokens[1]);
2186 if (ffesta_construct_name != NULL)
2187 {
2188 ffelex_token_kill (ffesta_construct_name);
2189 ffesta_construct_name = NULL;
2190 }
2191 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2192 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2193 }
2194
2195 /* ffestb_do3_ -- "DO" [label] [,] NAME
2196
2197 return ffestb_do3_; // to lexer
2198
2199 Make sure the statement has a valid form for the DO statement. If it
2200 does, implement the statement. */
2201
2202 static ffelexHandler
2203 ffestb_do3_ (ffelexToken t)
2204 {
2205 ffelexHandler next;
2206
2207 switch (ffelex_token_type (t))
2208 {
2209 case FFELEX_typeEQUALS:
2210 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
2211 FFEEXPR_contextDO, (ffeexprCallback) ffestb_do6_)))
2212 (ffesta_tokens[2]);
2213 ffelex_token_kill (ffesta_tokens[2]); /* Will get it back in _6_... */
2214 return (ffelexHandler) (*next) (t);
2215
2216 case FFELEX_typeOPEN_PAREN:
2217 if (ffestr_second (ffesta_tokens[2]) != FFESTR_secondWHILE)
2218 {
2219 if (ffesta_tokens[1] != NULL)
2220 ffelex_token_kill (ffesta_tokens[1]);
2221 if (ffesta_construct_name != NULL)
2222 {
2223 ffelex_token_kill (ffesta_construct_name);
2224 ffesta_construct_name = NULL;
2225 }
2226 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[2]);
2227 ffelex_token_kill (ffesta_tokens[2]);
2228 return (ffelexHandler) ffelex_swallow_tokens (t,
2229 (ffelexHandler) ffesta_zero); /* Invalid token. */
2230 }
2231 ffelex_token_kill (ffesta_tokens[2]);
2232 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2233 FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
2234
2235 default:
2236 break;
2237 }
2238
2239 ffelex_token_kill (ffesta_tokens[2]);
2240 if (ffesta_tokens[1] != NULL)
2241 ffelex_token_kill (ffesta_tokens[1]);
2242 if (ffesta_construct_name != NULL)
2243 {
2244 ffelex_token_kill (ffesta_construct_name);
2245 ffesta_construct_name = NULL;
2246 }
2247 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2248 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2249 }
2250
2251 /* ffestb_do4_ -- "DO" [label] [,] "WHILE" OPEN_PAREN expr
2252
2253 (ffestb_do4_) // to expression handler
2254
2255 Make sure the statement has a valid form for the DO statement. If it
2256 does, implement the statement. */
2257
2258 static ffelexHandler
2259 ffestb_do4_ (ffelexToken ft, ffebld expr, ffelexToken t)
2260 {
2261 switch (ffelex_token_type (t))
2262 {
2263 case FFELEX_typeCLOSE_PAREN:
2264 if (expr == NULL)
2265 break;
2266 ffesta_tokens[2] = ffelex_token_use (ft);
2267 ffestb_local_.dowhile.expr = expr;
2268 return (ffelexHandler) ffestb_do5_;
2269
2270 default:
2271 break;
2272 }
2273
2274 if (ffesta_tokens[1] != NULL)
2275 ffelex_token_kill (ffesta_tokens[1]);
2276 if (ffesta_construct_name != NULL)
2277 {
2278 ffelex_token_kill (ffesta_construct_name);
2279 ffesta_construct_name = NULL;
2280 }
2281 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2282 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2283 }
2284
2285 /* ffestb_do5_ -- "DO" [label] [,] "WHILE" OPEN_PAREN expr CLOSE_PAREN
2286
2287 return ffestb_do5_; // to lexer
2288
2289 Make sure the statement has a valid form for the DO statement. If it
2290 does, implement the statement. */
2291
2292 static ffelexHandler
2293 ffestb_do5_ (ffelexToken t)
2294 {
2295 switch (ffelex_token_type (t))
2296 {
2297 case FFELEX_typeEOS:
2298 case FFELEX_typeSEMICOLON:
2299 ffesta_confirmed ();
2300 if (!ffesta_is_inhibited ())
2301 {
2302 if (ffesta_tokens[1] != NULL)
2303 ffestc_R819B (ffesta_construct_name, ffesta_tokens[1],
2304 ffestb_local_.dowhile.expr, ffesta_tokens[2]);
2305 else
2306 ffestc_R820B (ffesta_construct_name, ffestb_local_.dowhile.expr,
2307 ffesta_tokens[2]);
2308 }
2309 ffelex_token_kill (ffesta_tokens[2]);
2310 if (ffesta_tokens[1] != NULL)
2311 ffelex_token_kill (ffesta_tokens[1]);
2312 if (ffesta_construct_name != NULL)
2313 {
2314 ffelex_token_kill (ffesta_construct_name);
2315 ffesta_construct_name = NULL;
2316 }
2317 return (ffelexHandler) ffesta_zero (t);
2318
2319 default:
2320 break;
2321 }
2322
2323 ffelex_token_kill (ffesta_tokens[2]);
2324 if (ffesta_tokens[1] != NULL)
2325 ffelex_token_kill (ffesta_tokens[1]);
2326 if (ffesta_construct_name != NULL)
2327 {
2328 ffelex_token_kill (ffesta_construct_name);
2329 ffesta_construct_name = NULL;
2330 }
2331 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2332 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2333 }
2334
2335 /* ffestb_do6_ -- "DO" [label] [,] var-expr
2336
2337 (ffestb_do6_) // to expression handler
2338
2339 Make sure the statement has a valid form for the DO statement. If it
2340 does, implement the statement. */
2341
2342 static ffelexHandler
2343 ffestb_do6_ (ffelexToken ft, ffebld expr, ffelexToken t)
2344 {
2345 /* _3_ already ensured that this would be an EQUALS token. If not, it is a
2346 bug in the FFE. */
2347
2348 assert (ffelex_token_type (t) == FFELEX_typeEQUALS);
2349
2350 ffesta_tokens[2] = ffelex_token_use (ft);
2351 ffestb_local_.do_stmt.var = expr;
2352 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2353 FFEEXPR_contextDO, (ffeexprCallback) ffestb_do7_);
2354 }
2355
2356 /* ffestb_do7_ -- "DO" [label] [,] var-expr EQUALS expr
2357
2358 (ffestb_do7_) // to expression handler
2359
2360 Make sure the statement has a valid form for the DO statement. If it
2361 does, implement the statement. */
2362
2363 static ffelexHandler
2364 ffestb_do7_ (ffelexToken ft, ffebld expr, ffelexToken t)
2365 {
2366 switch (ffelex_token_type (t))
2367 {
2368 case FFELEX_typeCOMMA:
2369 ffesta_confirmed ();
2370 if (expr == NULL)
2371 break;
2372 ffesta_tokens[3] = ffelex_token_use (ft);
2373 ffestb_local_.do_stmt.start = expr;
2374 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2375 FFEEXPR_contextDO, (ffeexprCallback) ffestb_do8_);
2376
2377 default:
2378 break;
2379 }
2380
2381 ffelex_token_kill (ffesta_tokens[2]);
2382 if (ffesta_tokens[1] != NULL)
2383 ffelex_token_kill (ffesta_tokens[1]);
2384 if (ffesta_construct_name != NULL)
2385 {
2386 ffelex_token_kill (ffesta_construct_name);
2387 ffesta_construct_name = NULL;
2388 }
2389 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2390 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2391 }
2392
2393 /* ffestb_do8_ -- "DO" [label] [,] var-expr EQUALS expr COMMA expr
2394
2395 (ffestb_do8_) // to expression handler
2396
2397 Make sure the statement has a valid form for the DO statement. If it
2398 does, implement the statement. */
2399
2400 static ffelexHandler
2401 ffestb_do8_ (ffelexToken ft, ffebld expr, ffelexToken t)
2402 {
2403 switch (ffelex_token_type (t))
2404 {
2405 case FFELEX_typeCOMMA:
2406 if (expr == NULL)
2407 break;
2408 ffesta_tokens[4] = ffelex_token_use (ft);
2409 ffestb_local_.do_stmt.end = expr;
2410 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2411 FFEEXPR_contextDO, (ffeexprCallback) ffestb_do9_);
2412
2413 case FFELEX_typeEOS:
2414 case FFELEX_typeSEMICOLON:
2415 if (expr == NULL)
2416 break;
2417 ffesta_tokens[4] = ffelex_token_use (ft);
2418 ffestb_local_.do_stmt.end = expr;
2419 return (ffelexHandler) ffestb_do9_ (NULL, NULL, t);
2420
2421 default:
2422 break;
2423 }
2424
2425 ffelex_token_kill (ffesta_tokens[3]);
2426 ffelex_token_kill (ffesta_tokens[2]);
2427 if (ffesta_tokens[1] != NULL)
2428 ffelex_token_kill (ffesta_tokens[1]);
2429 if (ffesta_construct_name != NULL)
2430 {
2431 ffelex_token_kill (ffesta_construct_name);
2432 ffesta_construct_name = NULL;
2433 }
2434 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2435 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2436 }
2437
2438 /* ffestb_do9_ -- "DO" [label] [,] var-expr EQUALS expr COMMA expr
2439 [COMMA expr]
2440
2441 (ffestb_do9_) // to expression handler
2442
2443 Make sure the statement has a valid form for the DO statement. If it
2444 does, implement the statement. */
2445
2446 static ffelexHandler
2447 ffestb_do9_ (ffelexToken ft, ffebld expr, ffelexToken t)
2448 {
2449 switch (ffelex_token_type (t))
2450 {
2451 case FFELEX_typeEOS:
2452 case FFELEX_typeSEMICOLON:
2453 if ((expr == NULL) && (ft != NULL))
2454 break;
2455 if (!ffesta_is_inhibited ())
2456 {
2457 if (ffesta_tokens[1] != NULL)
2458 ffestc_R819A (ffesta_construct_name, ffesta_tokens[1],
2459 ffestb_local_.do_stmt.var, ffesta_tokens[2],
2460 ffestb_local_.do_stmt.start, ffesta_tokens[3],
2461 ffestb_local_.do_stmt.end, ffesta_tokens[4], expr, ft);
2462 else
2463 ffestc_R820A (ffesta_construct_name, ffestb_local_.do_stmt.var,
2464 ffesta_tokens[2], ffestb_local_.do_stmt.start,
2465 ffesta_tokens[3], ffestb_local_.do_stmt.end,
2466 ffesta_tokens[4], expr, ft);
2467 }
2468 ffelex_token_kill (ffesta_tokens[4]);
2469 ffelex_token_kill (ffesta_tokens[3]);
2470 ffelex_token_kill (ffesta_tokens[2]);
2471 if (ffesta_tokens[1] != NULL)
2472 ffelex_token_kill (ffesta_tokens[1]);
2473 if (ffesta_construct_name != NULL)
2474 {
2475 ffelex_token_kill (ffesta_construct_name);
2476 ffesta_construct_name = NULL;
2477 }
2478
2479 return (ffelexHandler) ffesta_zero (t);
2480
2481 default:
2482 break;
2483 }
2484
2485 ffelex_token_kill (ffesta_tokens[4]);
2486 ffelex_token_kill (ffesta_tokens[3]);
2487 ffelex_token_kill (ffesta_tokens[2]);
2488 if (ffesta_tokens[1] != NULL)
2489 ffelex_token_kill (ffesta_tokens[1]);
2490 if (ffesta_construct_name != NULL)
2491 {
2492 ffelex_token_kill (ffesta_construct_name);
2493 ffesta_construct_name = NULL;
2494 }
2495 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2496 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2497 }
2498
2499 /* ffestb_else -- Parse the ELSE statement
2500
2501 return ffestb_else; // to lexer
2502
2503 Make sure the statement has a valid form for the ELSE statement. If it
2504 does, implement the statement. */
2505
2506 ffelexHandler
2507 ffestb_else (ffelexToken t)
2508 {
2509 ffeTokenLength i;
2510 unsigned const char *p;
2511
2512 switch (ffelex_token_type (ffesta_tokens[0]))
2513 {
2514 case FFELEX_typeNAME:
2515 if (ffesta_first_kw != FFESTR_firstELSE)
2516 goto bad_0; /* :::::::::::::::::::: */
2517 switch (ffelex_token_type (t))
2518 {
2519 case FFELEX_typeEOS:
2520 case FFELEX_typeSEMICOLON:
2521 ffesta_confirmed ();
2522 ffesta_tokens[1] = NULL;
2523 ffestb_args.elsexyz.second = FFESTR_secondNone;
2524 return (ffelexHandler) ffestb_else1_ (t);
2525
2526 case FFELEX_typeCOMMA:
2527 case FFELEX_typeCOLONCOLON:
2528 ffesta_confirmed (); /* Error, but clearly intended. */
2529 goto bad_1; /* :::::::::::::::::::: */
2530
2531 default:
2532 goto bad_1; /* :::::::::::::::::::: */
2533
2534 case FFELEX_typeNAME:
2535 break;
2536 }
2537
2538 ffesta_confirmed ();
2539 ffestb_args.elsexyz.second = ffesta_second_kw;
2540 ffesta_tokens[1] = ffelex_token_use (t);
2541 return (ffelexHandler) ffestb_else1_;
2542
2543 case FFELEX_typeNAMES:
2544 if (ffesta_first_kw != FFESTR_firstELSE)
2545 goto bad_0; /* :::::::::::::::::::: */
2546 switch (ffelex_token_type (t))
2547 {
2548 case FFELEX_typeCOMMA:
2549 case FFELEX_typeCOLONCOLON:
2550 ffesta_confirmed (); /* Error, but clearly intended. */
2551 goto bad_1; /* :::::::::::::::::::: */
2552
2553 default:
2554 goto bad_1; /* :::::::::::::::::::: */
2555
2556 case FFELEX_typeEOS:
2557 case FFELEX_typeSEMICOLON:
2558 break;
2559 }
2560 ffesta_confirmed ();
2561 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlELSE)
2562 {
2563 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlELSE);
2564 if (!ffesrc_is_name_init (*p))
2565 goto bad_i; /* :::::::::::::::::::: */
2566 ffesta_tokens[1]
2567 = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
2568 }
2569 else
2570 ffesta_tokens[1] = NULL;
2571 ffestb_args.elsexyz.second = FFESTR_secondNone;
2572 return (ffelexHandler) ffestb_else1_ (t);
2573
2574 default:
2575 goto bad_0; /* :::::::::::::::::::: */
2576 }
2577
2578 bad_0: /* :::::::::::::::::::: */
2579 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0]);
2580 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2581
2582 bad_1: /* :::::::::::::::::::: */
2583 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
2584 return (ffelexHandler) ffelex_swallow_tokens (t,
2585 (ffelexHandler) ffesta_zero); /* Invalid second token. */
2586
2587 bad_i: /* :::::::::::::::::::: */
2588 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0], i, t);
2589 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2590 }
2591
2592 /* ffestb_elsexyz -- Parse an ELSEIF/ELSEWHERE statement
2593
2594 return ffestb_elsexyz; // to lexer
2595
2596 Expects len and second to be set in ffestb_args.elsexyz to the length
2597 of the ELSExyz keyword involved and the corresponding ffestrSecond value. */
2598
2599 ffelexHandler
2600 ffestb_elsexyz (ffelexToken t)
2601 {
2602 ffeTokenLength i;
2603 const char *p;
2604
2605 switch (ffelex_token_type (ffesta_tokens[0]))
2606 {
2607 case FFELEX_typeNAME:
2608 switch (ffelex_token_type (t))
2609 {
2610 case FFELEX_typeEOS:
2611 case FFELEX_typeSEMICOLON:
2612 if (ffesta_first_kw == FFESTR_firstELSEIF)
2613 goto bad_0; /* :::::::::::::::::::: */
2614 ffesta_confirmed ();
2615 ffesta_tokens[1] = NULL;
2616 return (ffelexHandler) ffestb_else1_ (t);
2617
2618 case FFELEX_typeNAME:
2619 ffesta_confirmed ();
2620 goto bad_1; /* :::::::::::::::::::: */
2621
2622 case FFELEX_typeOPEN_PAREN:
2623 if (ffesta_first_kw != FFESTR_firstELSEIF)
2624 goto bad_0; /* :::::::::::::::::::: */
2625 ffesta_tokens[1] = NULL;
2626 return (ffelexHandler) ffestb_else1_ (t);
2627
2628 case FFELEX_typeCOMMA:
2629 case FFELEX_typeCOLONCOLON:
2630 ffesta_confirmed (); /* Error, but clearly intended. */
2631 goto bad_1; /* :::::::::::::::::::: */
2632
2633 default:
2634 goto bad_1; /* :::::::::::::::::::: */
2635 }
2636
2637 case FFELEX_typeNAMES:
2638 switch (ffelex_token_type (t))
2639 {
2640 case FFELEX_typeCOMMA:
2641 case FFELEX_typeCOLONCOLON:
2642 ffesta_confirmed (); /* Error, but clearly intended. */
2643 goto bad_1; /* :::::::::::::::::::: */
2644
2645 default:
2646 goto bad_1; /* :::::::::::::::::::: */
2647
2648 case FFELEX_typeOPEN_PAREN:
2649 if (ffesta_first_kw != FFESTR_firstELSEIF)
2650 goto bad_1; /* :::::::::::::::::::: */
2651 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlELSEIF)
2652 {
2653 i = FFESTR_firstlELSEIF;
2654 goto bad_i; /* :::::::::::::::::::: */
2655 }
2656 ffesta_tokens[1] = NULL;
2657 return (ffelexHandler) ffestb_else1_ (t);
2658
2659 case FFELEX_typeEOS:
2660 case FFELEX_typeSEMICOLON:
2661 break;
2662 }
2663 ffesta_confirmed ();
2664 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlELSE);
2665 ffesta_tokens[1]
2666 = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
2667 #if FFESTR_F90
2668 if ((ffestb_args.elsexyz.second == FFESTR_secondWHERE)
2669 && (ffelex_token_length (ffesta_tokens[1]) != FFESTR_secondlWHERE))
2670 ffestb_args.elsexyz.second = FFESTR_secondNone;
2671 #endif
2672 return (ffelexHandler) ffestb_else1_ (t);
2673
2674 default:
2675 goto bad_0; /* :::::::::::::::::::: */
2676 }
2677
2678 bad_0: /* :::::::::::::::::::: */
2679 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0]);
2680 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2681
2682 bad_1: /* :::::::::::::::::::: */
2683 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
2684 return (ffelexHandler) ffelex_swallow_tokens (t,
2685 (ffelexHandler) ffesta_zero); /* Invalid second token. */
2686
2687 bad_i: /* :::::::::::::::::::: */
2688 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE IF", ffesta_tokens[0], i, t);
2689 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2690 }
2691
2692 /* ffestb_else1_ -- "ELSE" (NAME)
2693
2694 return ffestb_else1_; // to lexer
2695
2696 If EOS/SEMICOLON, implement the appropriate statement (keep in mind that
2697 "ELSE WHERE" is ambiguous at the syntactic level). If OPEN_PAREN, start
2698 expression analysis with callback at _2_. */
2699
2700 static ffelexHandler
2701 ffestb_else1_ (ffelexToken t)
2702 {
2703 switch (ffelex_token_type (t))
2704 {
2705 case FFELEX_typeOPEN_PAREN:
2706 if (ffestb_args.elsexyz.second == FFESTR_secondIF)
2707 {
2708 if (ffesta_tokens[1] != NULL)
2709 ffelex_token_kill (ffesta_tokens[1]);
2710 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2711 FFEEXPR_contextIF, (ffeexprCallback) ffestb_else2_);
2712 }
2713 /* Fall through. */
2714 default:
2715 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
2716 if (ffesta_tokens[1] != NULL)
2717 ffelex_token_kill (ffesta_tokens[1]);
2718 return (ffelexHandler) ffelex_swallow_tokens (t,
2719 (ffelexHandler) ffesta_zero);
2720
2721 case FFELEX_typeEOS:
2722 case FFELEX_typeSEMICOLON:
2723 ffesta_confirmed ();
2724 break;
2725
2726 }
2727
2728 switch (ffestb_args.elsexyz.second)
2729 {
2730 #if FFESTR_F90
2731 case FFESTR_secondWHERE:
2732 if (!ffesta_is_inhibited ())
2733 if ((ffesta_first_kw == FFESTR_firstELSEWHERE)
2734 && (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME))
2735 ffestc_R744 ();
2736 else
2737 ffestc_elsewhere (ffesta_tokens[1]); /* R744 or R805. */
2738 break;
2739 #endif
2740
2741 default:
2742 if (!ffesta_is_inhibited ())
2743 ffestc_R805 (ffesta_tokens[1]);
2744 break;
2745 }
2746
2747 if (ffesta_tokens[1] != NULL)
2748 ffelex_token_kill (ffesta_tokens[1]);
2749 return (ffelexHandler) ffesta_zero (t);
2750 }
2751
2752 /* ffestb_else2_ -- "ELSE" "IF" OPEN_PAREN expr
2753
2754 (ffestb_else2_) // to expression handler
2755
2756 Make sure the next token is CLOSE_PAREN. */
2757
2758 static ffelexHandler
2759 ffestb_else2_ (ffelexToken ft, ffebld expr, ffelexToken t)
2760 {
2761 ffestb_local_.else_stmt.expr = expr;
2762
2763 switch (ffelex_token_type (t))
2764 {
2765 case FFELEX_typeCLOSE_PAREN:
2766 if (expr == NULL)
2767 break;
2768 ffesta_tokens[1] = ffelex_token_use (ft);
2769 ffelex_set_names (TRUE);
2770 return (ffelexHandler) ffestb_else3_;
2771
2772 default:
2773 break;
2774 }
2775
2776 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2777 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2778 }
2779
2780 /* ffestb_else3_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN
2781
2782 return ffestb_else3_; // to lexer
2783
2784 Make sure the next token is "THEN". */
2785
2786 static ffelexHandler
2787 ffestb_else3_ (ffelexToken t)
2788 {
2789 ffeTokenLength i;
2790 unsigned const char *p;
2791
2792 ffelex_set_names (FALSE);
2793
2794 switch (ffelex_token_type (t))
2795 {
2796 case FFELEX_typeNAME:
2797 ffesta_confirmed ();
2798 if (ffestr_first (t) == FFESTR_firstTHEN)
2799 return (ffelexHandler) ffestb_else4_;
2800 break;
2801
2802 case FFELEX_typeNAMES:
2803 ffesta_confirmed ();
2804 if (ffestr_first (t) != FFESTR_firstTHEN)
2805 break;
2806 if (ffelex_token_length (t) == FFESTR_firstlTHEN)
2807 return (ffelexHandler) ffestb_else4_;
2808 p = ffelex_token_text (t) + (i = FFESTR_firstlTHEN);
2809 if (!ffesrc_is_name_init (*p))
2810 goto bad_i; /* :::::::::::::::::::: */
2811 ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
2812 return (ffelexHandler) ffestb_else5_;
2813
2814 default:
2815 break;
2816 }
2817
2818 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2819 ffelex_token_kill (ffesta_tokens[1]);
2820 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2821
2822 bad_i: /* :::::::::::::::::::: */
2823 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t, i, NULL);
2824 ffelex_token_kill (ffesta_tokens[1]);
2825 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2826 }
2827
2828 /* ffestb_else4_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN "THEN"
2829
2830 return ffestb_else4_; // to lexer
2831
2832 Handle a NAME or EOS/SEMICOLON, then go to state _5_. */
2833
2834 static ffelexHandler
2835 ffestb_else4_ (ffelexToken t)
2836 {
2837 ffelex_set_names (FALSE);
2838
2839 switch (ffelex_token_type (t))
2840 {
2841 case FFELEX_typeEOS:
2842 case FFELEX_typeSEMICOLON:
2843 ffesta_tokens[2] = NULL;
2844 return (ffelexHandler) ffestb_else5_ (t);
2845
2846 case FFELEX_typeNAME:
2847 ffesta_tokens[2] = ffelex_token_use (t);
2848 return (ffelexHandler) ffestb_else5_;
2849
2850 default:
2851 break;
2852 }
2853
2854 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2855 ffelex_token_kill (ffesta_tokens[1]);
2856 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2857 }
2858
2859 /* ffestb_else5_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN "THEN"
2860
2861 return ffestb_else5_; // to lexer
2862
2863 Make sure the next token is EOS or SEMICOLON; implement R804. */
2864
2865 static ffelexHandler
2866 ffestb_else5_ (ffelexToken t)
2867 {
2868 switch (ffelex_token_type (t))
2869 {
2870 case FFELEX_typeEOS:
2871 case FFELEX_typeSEMICOLON:
2872 if (!ffesta_is_inhibited ())
2873 ffestc_R804 (ffestb_local_.else_stmt.expr, ffesta_tokens[1],
2874 ffesta_tokens[2]);
2875 ffelex_token_kill (ffesta_tokens[1]);
2876 if (ffesta_tokens[2] != NULL)
2877 ffelex_token_kill (ffesta_tokens[2]);
2878 return (ffelexHandler) ffesta_zero (t);
2879
2880 default:
2881 break;
2882 }
2883
2884 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2885 ffelex_token_kill (ffesta_tokens[1]);
2886 if (ffesta_tokens[2] != NULL)
2887 ffelex_token_kill (ffesta_tokens[2]);
2888 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2889 }
2890
2891 /* ffestb_end -- Parse the END statement
2892
2893 return ffestb_end; // to lexer
2894
2895 Make sure the statement has a valid form for the END statement. If it
2896 does, implement the statement. */
2897
2898 ffelexHandler
2899 ffestb_end (ffelexToken t)
2900 {
2901 ffeTokenLength i;
2902
2903 switch (ffelex_token_type (ffesta_tokens[0]))
2904 {
2905 case FFELEX_typeNAME:
2906 if (ffesta_first_kw != FFESTR_firstEND)
2907 goto bad_0; /* :::::::::::::::::::: */
2908 switch (ffelex_token_type (t))
2909 {
2910 case FFELEX_typeEOS:
2911 case FFELEX_typeSEMICOLON:
2912 ffesta_tokens[1] = NULL;
2913 ffestb_args.endxyz.second = FFESTR_secondNone;
2914 return (ffelexHandler) ffestb_end3_ (t);
2915
2916 case FFELEX_typeCOMMA:
2917 case FFELEX_typeCOLONCOLON:
2918 ffesta_confirmed (); /* Error, but clearly intended. */
2919 goto bad_1; /* :::::::::::::::::::: */
2920
2921 default:
2922 goto bad_1; /* :::::::::::::::::::: */
2923
2924 case FFELEX_typeNAME:
2925 break;
2926 }
2927
2928 ffesta_confirmed ();
2929 ffestb_args.endxyz.second = ffesta_second_kw;
2930 switch (ffesta_second_kw)
2931 {
2932 case FFESTR_secondFILE:
2933 ffestb_args.beru.badname = "ENDFILE";
2934 return (ffelexHandler) ffestb_beru;
2935
2936 case FFESTR_secondBLOCK:
2937 return (ffelexHandler) ffestb_end1_;
2938
2939 #if FFESTR_F90
2940 case FFESTR_secondINTERFACE:
2941 #endif
2942 #if FFESTR_VXT
2943 case FFESTR_secondMAP:
2944 case FFESTR_secondSTRUCTURE:
2945 case FFESTR_secondUNION:
2946 #endif
2947 #if FFESTR_F90
2948 case FFESTR_secondWHERE:
2949 ffesta_tokens[1] = NULL;
2950 return (ffelexHandler) ffestb_end3_;
2951 #endif
2952
2953 case FFESTR_secondNone:
2954 goto bad_1; /* :::::::::::::::::::: */
2955
2956 default:
2957 return (ffelexHandler) ffestb_end2_;
2958 }
2959
2960 case FFELEX_typeNAMES:
2961 if (ffesta_first_kw != FFESTR_firstEND)
2962 goto bad_0; /* :::::::::::::::::::: */
2963 switch (ffelex_token_type (t))
2964 {
2965 case FFELEX_typeCOMMA:
2966 case FFELEX_typeCOLONCOLON:
2967 ffesta_confirmed (); /* Error, but clearly intended. */
2968 goto bad_1; /* :::::::::::::::::::: */
2969
2970 default:
2971 goto bad_1; /* :::::::::::::::::::: */
2972
2973 case FFELEX_typeEOS:
2974 case FFELEX_typeSEMICOLON:
2975 break;
2976 }
2977 ffesta_confirmed ();
2978 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlEND)
2979 {
2980 i = FFESTR_firstlEND;
2981 goto bad_i; /* :::::::::::::::::::: */
2982 }
2983 ffesta_tokens[1] = NULL;
2984 ffestb_args.endxyz.second = FFESTR_secondNone;
2985 return (ffelexHandler) ffestb_end3_ (t);
2986
2987 default:
2988 goto bad_0; /* :::::::::::::::::::: */
2989 }
2990
2991 bad_0: /* :::::::::::::::::::: */
2992 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
2993 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2994
2995 bad_1: /* :::::::::::::::::::: */
2996 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
2997 return (ffelexHandler) ffelex_swallow_tokens (t,
2998 (ffelexHandler) ffesta_zero); /* Invalid second token. */
2999
3000 bad_i: /* :::::::::::::::::::: */
3001 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0], i, t);
3002 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3003 }
3004
3005 /* ffestb_endxyz -- Parse an ENDxyz statement
3006
3007 return ffestb_endxyz; // to lexer
3008
3009 Expects len and second to be set in ffestb_args.endxyz to the length
3010 of the ENDxyz keyword involved and the corresponding ffestrSecond value. */
3011
3012 ffelexHandler
3013 ffestb_endxyz (ffelexToken t)
3014 {
3015 ffeTokenLength i;
3016 unsigned const char *p;
3017
3018 switch (ffelex_token_type (ffesta_tokens[0]))
3019 {
3020 case FFELEX_typeNAME:
3021 switch (ffelex_token_type (t))
3022 {
3023 case FFELEX_typeEOS:
3024 case FFELEX_typeSEMICOLON:
3025 ffesta_confirmed ();
3026 ffesta_tokens[1] = NULL;
3027 return (ffelexHandler) ffestb_end3_ (t);
3028
3029 case FFELEX_typeNAME:
3030 ffesta_confirmed ();
3031 switch (ffestb_args.endxyz.second)
3032 {
3033 #if FFESTR_F90
3034 case FFESTR_secondINTERFACE:
3035 #endif
3036 #if FFESTR_VXT
3037 case FFESTR_secondMAP:
3038 case FFESTR_secondSTRUCTURE:
3039 case FFESTR_secondUNION:
3040 #endif
3041 #if FFESTR_F90
3042 case FFESTR_secondWHERE:
3043 goto bad_1; /* :::::::::::::::::::: */
3044 #endif
3045
3046 case FFESTR_secondBLOCK:
3047 if (ffesta_second_kw != FFESTR_secondDATA)
3048 goto bad_1; /* :::::::::::::::::::: */
3049 return (ffelexHandler) ffestb_end2_;
3050
3051 default:
3052 return (ffelexHandler) ffestb_end2_ (t);
3053 }
3054
3055 case FFELEX_typeCOMMA:
3056 case FFELEX_typeCOLONCOLON:
3057 ffesta_confirmed (); /* Error, but clearly intended. */
3058 goto bad_1; /* :::::::::::::::::::: */
3059
3060 default:
3061 goto bad_1; /* :::::::::::::::::::: */
3062 }
3063
3064 case FFELEX_typeNAMES:
3065 switch (ffelex_token_type (t))
3066 {
3067 case FFELEX_typeCOMMA:
3068 case FFELEX_typeCOLONCOLON:
3069 ffesta_confirmed (); /* Error, but clearly intended. */
3070 goto bad_1; /* :::::::::::::::::::: */
3071
3072 default:
3073 goto bad_1; /* :::::::::::::::::::: */
3074
3075 case FFELEX_typeEOS:
3076 case FFELEX_typeSEMICOLON:
3077 break;
3078 }
3079 ffesta_confirmed ();
3080 if (ffestb_args.endxyz.second == FFESTR_secondBLOCK)
3081 {
3082 i = FFESTR_firstlEND;
3083 goto bad_i; /* :::::::::::::::::::: */
3084 }
3085 if (ffelex_token_length (ffesta_tokens[0]) != ffestb_args.endxyz.len)
3086 {
3087 p = ffelex_token_text (ffesta_tokens[0])
3088 + (i = ffestb_args.endxyz.len);
3089 switch (ffestb_args.endxyz.second)
3090 {
3091 #if FFESTR_F90
3092 case FFESTR_secondINTERFACE:
3093 #endif
3094 #if FFESTR_VXT
3095 case FFESTR_secondMAP:
3096 case FFESTR_secondSTRUCTURE:
3097 case FFESTR_secondUNION:
3098 #endif
3099 #if FFESTR_F90
3100 case FFESTR_secondWHERE:
3101 goto bad_i; /* :::::::::::::::::::: */
3102 #endif
3103
3104 default:
3105 break;
3106 }
3107 if (!ffesrc_is_name_init (*p))
3108 goto bad_i; /* :::::::::::::::::::: */
3109 ffesta_tokens[1]
3110 = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
3111 return (ffelexHandler) ffestb_end3_ (t);
3112 }
3113 ffesta_tokens[1] = NULL;
3114 return (ffelexHandler) ffestb_end3_ (t);
3115
3116 default:
3117 goto bad_0; /* :::::::::::::::::::: */
3118 }
3119
3120 bad_0: /* :::::::::::::::::::: */
3121 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
3122 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3123
3124 bad_1: /* :::::::::::::::::::: */
3125 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3126 return (ffelexHandler) ffelex_swallow_tokens (t,
3127 (ffelexHandler) ffesta_zero); /* Invalid second token. */
3128
3129 bad_i: /* :::::::::::::::::::: */
3130 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0], i, t);
3131 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3132 }
3133
3134 /* ffestb_end1_ -- "END" "BLOCK"
3135
3136 return ffestb_end1_; // to lexer
3137
3138 Make sure the next token is "DATA". */
3139
3140 static ffelexHandler
3141 ffestb_end1_ (ffelexToken t)
3142 {
3143 if ((ffelex_token_type (t) == FFELEX_typeNAME)
3144 && (ffesrc_strcmp_2c (ffe_case_match (), ffelex_token_text (t), "DATA",
3145 "data", "Data")
3146 == 0))
3147 {
3148 return (ffelexHandler) ffestb_end2_;
3149 }
3150
3151 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3152 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3153 }
3154
3155 /* ffestb_end2_ -- "END" <unit-kind>
3156
3157 return ffestb_end2_; // to lexer
3158
3159 Make sure the next token is a NAME or EOS. */
3160
3161 static ffelexHandler
3162 ffestb_end2_ (ffelexToken t)
3163 {
3164 switch (ffelex_token_type (t))
3165 {
3166 case FFELEX_typeNAME:
3167 ffesta_tokens[1] = ffelex_token_use (t);
3168 return (ffelexHandler) ffestb_end3_;
3169
3170 case FFELEX_typeEOS:
3171 case FFELEX_typeSEMICOLON:
3172 ffesta_tokens[1] = NULL;
3173 return (ffelexHandler) ffestb_end3_ (t);
3174
3175 default:
3176 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3177 return (ffelexHandler) ffelex_swallow_tokens (t,
3178 (ffelexHandler) ffesta_zero);
3179 }
3180 }
3181
3182 /* ffestb_end3_ -- "END" <unit-kind> (NAME)
3183
3184 return ffestb_end3_; // to lexer
3185
3186 Make sure the next token is an EOS, then implement the statement. */
3187
3188 static ffelexHandler
3189 ffestb_end3_ (ffelexToken t)
3190 {
3191 switch (ffelex_token_type (t))
3192 {
3193 default:
3194 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3195 if (ffesta_tokens[1] != NULL)
3196 ffelex_token_kill (ffesta_tokens[1]);
3197 return (ffelexHandler) ffelex_swallow_tokens (t,
3198 (ffelexHandler) ffesta_zero);
3199
3200 case FFELEX_typeEOS:
3201 case FFELEX_typeSEMICOLON:
3202 ffesta_confirmed ();
3203 if (ffestb_args.endxyz.second == FFESTR_secondNone)
3204 {
3205 if (!ffesta_is_inhibited ())
3206 ffestc_end ();
3207 return (ffelexHandler) ffesta_zero (t);
3208 }
3209 break;
3210 }
3211
3212 switch (ffestb_args.endxyz.second)
3213 {
3214 #if FFESTR_F90
3215 case FFESTR_secondTYPE:
3216 if (!ffesta_is_inhibited ())
3217 ffestc_R425 (ffesta_tokens[1]);
3218 break;
3219 #endif
3220
3221 #if FFESTR_F90
3222 case FFESTR_secondWHERE:
3223 if (!ffesta_is_inhibited ())
3224 ffestc_R745 ();
3225 break;
3226 #endif
3227
3228 case FFESTR_secondIF:
3229 if (!ffesta_is_inhibited ())
3230 ffestc_R806 (ffesta_tokens[1]);
3231 break;
3232
3233 case FFESTR_secondSELECT:
3234 if (!ffesta_is_inhibited ())
3235 ffestc_R811 (ffesta_tokens[1]);
3236 break;
3237
3238 case FFESTR_secondDO:
3239 if (!ffesta_is_inhibited ())
3240 ffestc_R825 (ffesta_tokens[1]);
3241 break;
3242
3243 case FFESTR_secondPROGRAM:
3244 if (!ffesta_is_inhibited ())
3245 ffestc_R1103 (ffesta_tokens[1]);
3246 break;
3247
3248 #if FFESTR_F90
3249 case FFESTR_secondMODULE:
3250 if (!ffesta_is_inhibited ())
3251 ffestc_R1106 (ffesta_tokens[1]);
3252 break;
3253 #endif
3254 case FFESTR_secondBLOCK:
3255 case FFESTR_secondBLOCKDATA:
3256 if (!ffesta_is_inhibited ())
3257 ffestc_R1112 (ffesta_tokens[1]);
3258 break;
3259
3260 #if FFESTR_F90
3261 case FFESTR_secondINTERFACE:
3262 if (!ffesta_is_inhibited ())
3263 ffestc_R1203 ();
3264 break;
3265 #endif
3266
3267 case FFESTR_secondFUNCTION:
3268 if (!ffesta_is_inhibited ())
3269 ffestc_R1221 (ffesta_tokens[1]);
3270 break;
3271
3272 case FFESTR_secondSUBROUTINE:
3273 if (!ffesta_is_inhibited ())
3274 ffestc_R1225 (ffesta_tokens[1]);
3275 break;
3276
3277 #if FFESTR_VXT
3278 case FFESTR_secondSTRUCTURE:
3279 if (!ffesta_is_inhibited ())
3280 ffestc_V004 ();
3281 break;
3282 #endif
3283
3284 #if FFESTR_VXT
3285 case FFESTR_secondUNION:
3286 if (!ffesta_is_inhibited ())
3287 ffestc_V010 ();
3288 break;
3289 #endif
3290
3291 #if FFESTR_VXT
3292 case FFESTR_secondMAP:
3293 if (!ffesta_is_inhibited ())
3294 ffestc_V013 ();
3295 break;
3296 #endif
3297
3298 default:
3299 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
3300 if (ffesta_tokens[1] != NULL)
3301 ffelex_token_kill (ffesta_tokens[1]);
3302 return (ffelexHandler) ffelex_swallow_tokens (t,
3303 (ffelexHandler) ffesta_zero);
3304 }
3305
3306 if (ffesta_tokens[1] != NULL)
3307 ffelex_token_kill (ffesta_tokens[1]);
3308 return (ffelexHandler) ffesta_zero (t);
3309 }
3310
3311 /* ffestb_goto -- Parse the GOTO statement
3312
3313 return ffestb_goto; // to lexer
3314
3315 Make sure the statement has a valid form for the GOTO statement. If it
3316 does, implement the statement. */
3317
3318 ffelexHandler
3319 ffestb_goto (ffelexToken t)
3320 {
3321 ffeTokenLength i;
3322 unsigned const char *p;
3323 ffelexHandler next;
3324 ffelexToken nt;
3325
3326 switch (ffelex_token_type (ffesta_tokens[0]))
3327 {
3328 case FFELEX_typeNAME:
3329 switch (ffesta_first_kw)
3330 {
3331 case FFESTR_firstGO:
3332 if ((ffelex_token_type (t) != FFELEX_typeNAME)
3333 || (ffesta_second_kw != FFESTR_secondTO))
3334 goto bad_1; /* :::::::::::::::::::: */
3335 ffesta_confirmed ();
3336 return (ffelexHandler) ffestb_goto1_;
3337
3338 case FFESTR_firstGOTO:
3339 return (ffelexHandler) ffestb_goto1_ (t);
3340
3341 default:
3342 goto bad_0; /* :::::::::::::::::::: */
3343 }
3344
3345 case FFELEX_typeNAMES:
3346 if (ffesta_first_kw != FFESTR_firstGOTO)
3347 goto bad_0; /* :::::::::::::::::::: */
3348 switch (ffelex_token_type (t))
3349 {
3350 case FFELEX_typeCOLONCOLON:
3351 ffesta_confirmed (); /* Error, but clearly intended. */
3352 goto bad_1; /* :::::::::::::::::::: */
3353
3354 default:
3355 goto bad_1; /* :::::::::::::::::::: */
3356
3357 case FFELEX_typeOPEN_PAREN:
3358 case FFELEX_typePERCENT: /* Since GOTO I%J is apparently valid
3359 in '90. */
3360 case FFELEX_typeCOMMA:
3361 break;
3362
3363 case FFELEX_typeEOS:
3364 case FFELEX_typeSEMICOLON:
3365 ffesta_confirmed ();
3366 break;
3367 }
3368 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlGOTO)
3369 {
3370 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlGOTO);
3371 if (ISDIGIT (*p))
3372 {
3373 nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
3374 p += ffelex_token_length (nt);
3375 i += ffelex_token_length (nt);
3376 if (*p != '\0')
3377 {
3378 ffelex_token_kill (nt);
3379 goto bad_i; /* :::::::::::::::::::: */
3380 }
3381 }
3382 else if (ffesrc_is_name_init (*p))
3383 {
3384 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
3385 }
3386 else
3387 goto bad_i; /* :::::::::::::::::::: */
3388 next = (ffelexHandler) ffestb_goto1_ (nt);
3389 ffelex_token_kill (nt);
3390 return (ffelexHandler) (*next) (t);
3391 }
3392 return (ffelexHandler) ffestb_goto1_ (t);
3393
3394 default:
3395 goto bad_0; /* :::::::::::::::::::: */
3396 }
3397
3398 bad_0: /* :::::::::::::::::::: */
3399 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", ffesta_tokens[0]);
3400 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3401
3402 bad_1: /* :::::::::::::::::::: */
3403 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
3404 return (ffelexHandler) ffelex_swallow_tokens (t,
3405 (ffelexHandler) ffesta_zero); /* Invalid second token. */
3406
3407 bad_i: /* :::::::::::::::::::: */
3408 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "GO TO", ffesta_tokens[0], i, t);
3409 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3410 }
3411
3412 /* ffestb_goto1_ -- "GOTO" or "GO" "TO"
3413
3414 return ffestb_goto1_; // to lexer
3415
3416 Make sure the statement has a valid form for the GOTO statement. If it
3417 does, implement the statement. */
3418
3419 static ffelexHandler
3420 ffestb_goto1_ (ffelexToken t)
3421 {
3422 switch (ffelex_token_type (t))
3423 {
3424 case FFELEX_typeNUMBER:
3425 if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
3426 ffesta_confirmed ();
3427 ffesta_tokens[1] = ffelex_token_use (t);
3428 return (ffelexHandler) ffestb_goto2_;
3429
3430 case FFELEX_typeOPEN_PAREN:
3431 ffesta_tokens[1] = ffelex_token_use (t);
3432 ffestb_subrargs_.label_list.labels = ffestt_tokenlist_create ();
3433 ffestb_subrargs_.label_list.handler = (ffelexHandler) ffestb_goto3_;
3434 return (ffelexHandler) ffestb_subr_label_list_;
3435
3436 case FFELEX_typeNAME:
3437 if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
3438 ffesta_confirmed ();
3439 return (ffelexHandler) (*((ffelexHandler)
3440 ffeexpr_lhs (ffesta_output_pool,
3441 FFEEXPR_contextAGOTO,
3442 (ffeexprCallback) ffestb_goto4_)))
3443 (t);
3444
3445 case FFELEX_typeEOS:
3446 case FFELEX_typeSEMICOLON:
3447 case FFELEX_typeCOMMA:
3448 case FFELEX_typeCOLONCOLON:
3449 ffesta_confirmed (); /* Error, but clearly intended. */
3450 break;
3451
3452 default:
3453 break;
3454 }
3455
3456 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
3457 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3458 }
3459
3460 /* ffestb_goto2_ -- "GO/TO" NUMBER
3461
3462 return ffestb_goto2_; // to lexer
3463
3464 Make sure the statement has a valid form for the GOTO statement. If it
3465 does, implement the statement. */
3466
3467 static ffelexHandler
3468 ffestb_goto2_ (ffelexToken t)
3469 {
3470 switch (ffelex_token_type (t))
3471 {
3472 case FFELEX_typeEOS:
3473 case FFELEX_typeSEMICOLON:
3474 ffesta_confirmed ();
3475 if (!ffesta_is_inhibited ())
3476 ffestc_R836 (ffesta_tokens[1]);
3477 ffelex_token_kill (ffesta_tokens[1]);
3478 return (ffelexHandler) ffesta_zero (t);
3479
3480 default:
3481 break;
3482 }
3483
3484 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
3485 ffelex_token_kill (ffesta_tokens[1]);
3486 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3487 }
3488
3489 /* ffestb_goto3_ -- "GO/TO" OPEN_PAREN label-list CLOSE_PAREN
3490
3491 return ffestb_goto3_; // to lexer
3492
3493 Make sure the statement has a valid form for the GOTO statement. If it
3494 does, implement the statement. */
3495
3496 static ffelexHandler
3497 ffestb_goto3_ (ffelexToken t)
3498 {
3499 if (!ffestb_subrargs_.label_list.ok)
3500 goto bad; /* :::::::::::::::::::: */
3501
3502 switch (ffelex_token_type (t))
3503 {
3504 case FFELEX_typeCOMMA:
3505 ffesta_confirmed ();
3506 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextCGOTO,
3507 (ffeexprCallback) ffestb_goto5_);
3508
3509 case FFELEX_typeEQUALS:
3510 case FFELEX_typePOINTS:
3511 case FFELEX_typeEOS:
3512 case FFELEX_typeSEMICOLON:
3513 break;
3514
3515 default:
3516 ffesta_confirmed ();
3517 /* Fall through. */
3518 case FFELEX_typeOPEN_PAREN: /* Could still be assignment!! */
3519 return (ffelexHandler) (*((ffelexHandler)
3520 ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextCGOTO,
3521 (ffeexprCallback) ffestb_goto5_)))
3522 (t);
3523 }
3524
3525 bad: /* :::::::::::::::::::: */
3526 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "computed-GOTO", t);
3527 ffelex_token_kill (ffesta_tokens[1]);
3528 ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3529 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3530 }
3531
3532 /* ffestb_goto4_ -- "GO/TO" expr
3533
3534 (ffestb_goto4_) // to expression handler
3535
3536 Make sure the statement has a valid form for the GOTO statement. If it
3537 does, implement the statement. */
3538
3539 static ffelexHandler
3540 ffestb_goto4_ (ffelexToken ft, ffebld expr, ffelexToken t)
3541 {
3542 switch (ffelex_token_type (t))
3543 {
3544 case FFELEX_typeCOMMA:
3545 ffesta_confirmed ();
3546 if (expr == NULL)
3547 break;
3548 ffesta_tokens[1] = ffelex_token_use (ft);
3549 ffestb_local_.go_to.expr = expr;
3550 return (ffelexHandler) ffestb_goto6_;
3551
3552 case FFELEX_typeOPEN_PAREN:
3553 if (expr == NULL)
3554 break;
3555 ffesta_tokens[1] = ffelex_token_use (ft);
3556 ffestb_local_.go_to.expr = expr;
3557 return (ffelexHandler) ffestb_goto6_ (t);
3558
3559 case FFELEX_typeEOS:
3560 case FFELEX_typeSEMICOLON:
3561 ffesta_confirmed ();
3562 if (expr == NULL)
3563 break;
3564 if (!ffesta_is_inhibited ())
3565 ffestc_R839 (expr, ft, NULL);
3566 return (ffelexHandler) ffesta_zero (t);
3567
3568 default:
3569 break;
3570 }
3571
3572 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
3573 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3574 }
3575
3576 /* ffestb_goto5_ -- "GO/TO" OPEN_PAREN label-list CLOSE_PAREN (COMMA) expr
3577
3578 (ffestb_goto5_) // to expression handler
3579
3580 Make sure the statement has a valid form for the GOTO statement. If it
3581 does, implement the statement. */
3582
3583 static ffelexHandler
3584 ffestb_goto5_ (ffelexToken ft, ffebld expr, ffelexToken t)
3585 {
3586 switch (ffelex_token_type (t))
3587 {
3588 case FFELEX_typeEOS:
3589 case FFELEX_typeSEMICOLON:
3590 if (expr == NULL)
3591 break;
3592 ffesta_confirmed ();
3593 if (!ffesta_is_inhibited ())
3594 ffestc_R837 (ffestb_subrargs_.label_list.labels, expr, ft);
3595 ffelex_token_kill (ffesta_tokens[1]);
3596 ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3597 return (ffelexHandler) ffesta_zero (t);
3598
3599 default:
3600 break;
3601 }
3602
3603 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "computed-GOTO", t);
3604 ffelex_token_kill (ffesta_tokens[1]);
3605 ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3606 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3607 }
3608
3609 /* ffestb_goto6_ -- "GO/TO" expr (COMMA)
3610
3611 return ffestb_goto6_; // to lexer
3612
3613 Make sure the statement has a valid form for the GOTO statement. If it
3614 does, implement the statement. */
3615
3616 static ffelexHandler
3617 ffestb_goto6_ (ffelexToken t)
3618 {
3619 switch (ffelex_token_type (t))
3620 {
3621 case FFELEX_typeOPEN_PAREN:
3622 ffesta_tokens[2] = ffelex_token_use (t);
3623 ffestb_subrargs_.label_list.labels = ffestt_tokenlist_create ();
3624 ffestb_subrargs_.label_list.handler = (ffelexHandler) ffestb_goto7_;
3625 return (ffelexHandler) ffestb_subr_label_list_;
3626
3627 default:
3628 break;
3629 }
3630
3631 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
3632 ffelex_token_kill (ffesta_tokens[1]);
3633 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3634 }
3635
3636 /* ffestb_goto7_ -- "GO/TO" expr (COMMA) OPEN_PAREN label-list CLOSE_PAREN
3637
3638 return ffestb_goto7_; // to lexer
3639
3640 Make sure the statement has a valid form for the GOTO statement. If it
3641 does, implement the statement. */
3642
3643 static ffelexHandler
3644 ffestb_goto7_ (ffelexToken t)
3645 {
3646 if (!ffestb_subrargs_.label_list.ok)
3647 goto bad; /* :::::::::::::::::::: */
3648
3649 switch (ffelex_token_type (t))
3650 {
3651 case FFELEX_typeEOS:
3652 case FFELEX_typeSEMICOLON:
3653 ffesta_confirmed ();
3654 if (!ffesta_is_inhibited ())
3655 ffestc_R839 (ffestb_local_.go_to.expr, ffesta_tokens[1],
3656 ffestb_subrargs_.label_list.labels);
3657 ffelex_token_kill (ffesta_tokens[1]);
3658 ffelex_token_kill (ffesta_tokens[2]);
3659 ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3660 return (ffelexHandler) ffesta_zero (t);
3661
3662 default:
3663 break;
3664 }
3665
3666 bad: /* :::::::::::::::::::: */
3667 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
3668 ffelex_token_kill (ffesta_tokens[1]);
3669 ffelex_token_kill (ffesta_tokens[2]);
3670 ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3671 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3672 }
3673
3674 /* ffestb_halt -- Parse the STOP/PAUSE statement
3675
3676 return ffestb_halt; // to lexer
3677
3678 Make sure the statement has a valid form for the STOP/PAUSE statement. If
3679 it does, implement the statement. */
3680
3681 ffelexHandler
3682 ffestb_halt (ffelexToken t)
3683 {
3684 ffelexHandler next;
3685
3686 switch (ffelex_token_type (ffesta_tokens[0]))
3687 {
3688 case FFELEX_typeNAME:
3689 switch (ffelex_token_type (t))
3690 {
3691 case FFELEX_typeCOMMA:
3692 case FFELEX_typeCOLONCOLON:
3693 ffesta_confirmed (); /* Error, but clearly intended. */
3694 goto bad_1; /* :::::::::::::::::::: */
3695
3696 default:
3697 goto bad_1; /* :::::::::::::::::::: */
3698
3699 case FFELEX_typeEOS:
3700 case FFELEX_typeSEMICOLON:
3701 case FFELEX_typeNAME:
3702 case FFELEX_typeNUMBER:
3703 case FFELEX_typeAPOSTROPHE:
3704 case FFELEX_typeQUOTE:
3705 ffesta_confirmed ();
3706 break;
3707 }
3708
3709 return (ffelexHandler) (*((ffelexHandler)
3710 ffeexpr_rhs (ffesta_output_pool,
3711 FFEEXPR_contextSTOP,
3712 (ffeexprCallback) ffestb_halt1_)))
3713 (t);
3714
3715 case FFELEX_typeNAMES:
3716 switch (ffelex_token_type (t))
3717 {
3718 default:
3719 goto bad_1; /* :::::::::::::::::::: */
3720
3721 case FFELEX_typeEOS:
3722 case FFELEX_typeSEMICOLON:
3723 case FFELEX_typeNAME:
3724 case FFELEX_typeNUMBER:
3725 case FFELEX_typeAPOSTROPHE:
3726 case FFELEX_typeQUOTE:
3727 ffesta_confirmed ();
3728 break;
3729 }
3730 next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
3731 FFEEXPR_contextSTOP,
3732 (ffeexprCallback) ffestb_halt1_);
3733 next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
3734 ffestb_args.halt.len);
3735 if (next == NULL)
3736 return (ffelexHandler) ffelex_swallow_tokens (t,
3737 (ffelexHandler) ffesta_zero);
3738 return (ffelexHandler) (*next) (t);
3739
3740 default:
3741 goto bad_0; /* :::::::::::::::::::: */
3742 }
3743
3744 bad_0: /* :::::::::::::::::::: */
3745 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
3746 (ffesta_first_kw == FFESTR_firstSTOP)
3747 ? "STOP" : "PAUSE",
3748 ffesta_tokens[0]);
3749 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3750
3751 bad_1: /* :::::::::::::::::::: */
3752 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
3753 (ffesta_first_kw == FFESTR_firstSTOP)
3754 ? "STOP" : "PAUSE",
3755 t);
3756 return (ffelexHandler) ffelex_swallow_tokens (t,
3757 (ffelexHandler) ffesta_zero); /* Invalid second token. */
3758 }
3759
3760 /* ffestb_halt1_ -- "STOP/PAUSE" expr
3761
3762 (ffestb_halt1_) // to expression handler
3763
3764 Make sure the next token is an EOS or SEMICOLON. */
3765
3766 static ffelexHandler
3767 ffestb_halt1_ (ffelexToken ft, ffebld expr, ffelexToken t)
3768 {
3769 switch (ffelex_token_type (t))
3770 {
3771 case FFELEX_typeEOS:
3772 case FFELEX_typeSEMICOLON:
3773 ffesta_confirmed ();
3774 if (!ffesta_is_inhibited ())
3775 {
3776 if (ffesta_first_kw == FFESTR_firstSTOP)
3777 ffestc_R842 (expr, ft);
3778 else
3779 ffestc_R843 (expr, ft);
3780 }
3781 return (ffelexHandler) ffesta_zero (t);
3782
3783 default:
3784 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
3785 (ffesta_first_kw == FFESTR_firstSTOP)
3786 ? "STOP" : "PAUSE",
3787 t);
3788 break;
3789 }
3790
3791 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3792 }
3793
3794 /* ffestb_if -- Parse an IF statement
3795
3796 return ffestb_if; // to lexer
3797
3798 Make sure the statement has a valid form for an IF statement.
3799 If it does, implement the statement. */
3800
3801 ffelexHandler
3802 ffestb_if (ffelexToken t)
3803 {
3804 switch (ffelex_token_type (ffesta_tokens[0]))
3805 {
3806 case FFELEX_typeNAME:
3807 if (ffesta_first_kw != FFESTR_firstIF)
3808 goto bad_0; /* :::::::::::::::::::: */
3809 break;
3810
3811 case FFELEX_typeNAMES:
3812 if (ffesta_first_kw != FFESTR_firstIF)
3813 goto bad_0; /* :::::::::::::::::::: */
3814 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlIF)
3815 goto bad_0; /* :::::::::::::::::::: */
3816 break;
3817
3818 default:
3819 goto bad_0; /* :::::::::::::::::::: */
3820 }
3821
3822 switch (ffelex_token_type (t))
3823 {
3824 case FFELEX_typeOPEN_PAREN:
3825 break;
3826
3827 case FFELEX_typeEOS:
3828 case FFELEX_typeSEMICOLON:
3829 case FFELEX_typeCOMMA:
3830 case FFELEX_typeCOLONCOLON:
3831 ffesta_confirmed (); /* Error, but clearly intended. */
3832 goto bad_1; /* :::::::::::::::::::: */
3833
3834 default:
3835 goto bad_1; /* :::::::::::::::::::: */
3836 }
3837
3838 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextIF,
3839 (ffeexprCallback) ffestb_if1_);
3840
3841 bad_0: /* :::::::::::::::::::: */
3842 if (ffesta_construct_name != NULL)
3843 {
3844 ffelex_token_kill (ffesta_construct_name);
3845 ffesta_construct_name = NULL;
3846 }
3847 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", ffesta_tokens[0]);
3848 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3849
3850 bad_1: /* :::::::::::::::::::: */
3851 if (ffesta_construct_name != NULL)
3852 {
3853 ffelex_token_kill (ffesta_construct_name);
3854 ffesta_construct_name = NULL;
3855 }
3856 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
3857 return (ffelexHandler) ffelex_swallow_tokens (t,
3858 (ffelexHandler) ffesta_zero); /* Invalid second token. */
3859 }
3860
3861 /* ffestb_if1_ -- "IF" OPEN_PAREN expr
3862
3863 (ffestb_if1_) // to expression handler
3864
3865 Make sure the next token is CLOSE_PAREN. */
3866
3867 static ffelexHandler
3868 ffestb_if1_ (ffelexToken ft, ffebld expr, ffelexToken t)
3869 {
3870 ffestb_local_.if_stmt.expr = expr;
3871
3872 switch (ffelex_token_type (t))
3873 {
3874 case FFELEX_typeCLOSE_PAREN:
3875 if (expr == NULL)
3876 break;
3877 ffesta_tokens[1] = ffelex_token_use (ft);
3878 ffelex_set_names (TRUE);
3879 return (ffelexHandler) ffestb_if2_;
3880
3881 default:
3882 break;
3883 }
3884
3885 if (ffesta_construct_name != NULL)
3886 {
3887 ffelex_token_kill (ffesta_construct_name);
3888 ffesta_construct_name = NULL;
3889 }
3890 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
3891 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3892 }
3893
3894 /* ffestb_if2_ -- "IF" OPEN_PAREN expr CLOSE_PAREN
3895
3896 return ffestb_if2_; // to lexer
3897
3898 Make sure the next token is NAME. */
3899
3900 static ffelexHandler
3901 ffestb_if2_ (ffelexToken t)
3902 {
3903 ffelex_set_names (FALSE);
3904
3905 switch (ffelex_token_type (t))
3906 {
3907 case FFELEX_typeNAME:
3908 case FFELEX_typeNAMES:
3909 ffesta_confirmed ();
3910 ffesta_tokens[2] = ffelex_token_use (t);
3911 return (ffelexHandler) ffestb_if3_;
3912
3913 default:
3914 break;
3915 }
3916
3917 ffelex_token_kill (ffesta_tokens[1]);
3918 if ((ffesta_construct_name == NULL)
3919 || (ffelex_token_type (t) != FFELEX_typeNUMBER))
3920 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
3921 else
3922 ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
3923 ffesta_construct_name, t);
3924 if (ffesta_construct_name != NULL)
3925 {
3926 ffelex_token_kill (ffesta_construct_name);
3927 ffesta_construct_name = NULL;
3928 }
3929 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3930 }
3931
3932 /* ffestb_if3_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NAME
3933
3934 return ffestb_if3_; // to lexer
3935
3936 If the next token is EOS or SEMICOLON and the preceding NAME was "THEN",
3937 implement R803. Else, implement R807 and send the preceding NAME followed
3938 by the current token. */
3939
3940 static ffelexHandler
3941 ffestb_if3_ (ffelexToken t)
3942 {
3943 ffelexHandler next;
3944
3945 switch (ffelex_token_type (t))
3946 {
3947 case FFELEX_typeEOS:
3948 case FFELEX_typeSEMICOLON:
3949 if (ffestr_first (ffesta_tokens[2]) == FFESTR_firstTHEN)
3950 {
3951 if (!ffesta_is_inhibited ())
3952 ffestc_R803 (ffesta_construct_name, ffestb_local_.if_stmt.expr,
3953 ffesta_tokens[1]);
3954 ffelex_token_kill (ffesta_tokens[1]);
3955 ffelex_token_kill (ffesta_tokens[2]);
3956 if (ffesta_construct_name != NULL)
3957 {
3958 ffelex_token_kill (ffesta_construct_name);
3959 ffesta_construct_name = NULL;
3960 }
3961 return (ffelexHandler) ffesta_zero (t);
3962 }
3963 break;
3964
3965 default:
3966 break;
3967 }
3968
3969 if (ffesta_construct_name != NULL)
3970 {
3971 if (!ffesta_is_inhibited ())
3972 ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
3973 ffesta_construct_name, ffesta_tokens[2]);
3974 ffelex_token_kill (ffesta_construct_name);
3975 ffesta_construct_name = NULL;
3976 ffelex_token_kill (ffesta_tokens[1]);
3977 ffelex_token_kill (ffesta_tokens[2]);
3978 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3979 }
3980
3981 if (!ffesta_is_inhibited ())
3982 ffestc_R807 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
3983 ffelex_token_kill (ffesta_tokens[1]);
3984 {
3985 ffelexToken my_2 = ffesta_tokens[2];
3986
3987 next = (ffelexHandler) ffesta_two (my_2, t);
3988 ffelex_token_kill (my_2);
3989 }
3990 return (ffelexHandler) next;
3991 }
3992
3993 /* ffestb_where -- Parse a WHERE statement
3994
3995 return ffestb_where; // to lexer
3996
3997 Make sure the statement has a valid form for a WHERE statement.
3998 If it does, implement the statement. */
3999
4000 #if FFESTR_F90
4001 ffelexHandler
4002 ffestb_where (ffelexToken t)
4003 {
4004 switch (ffelex_token_type (ffesta_tokens[0]))
4005 {
4006 case FFELEX_typeNAME:
4007 if (ffesta_first_kw != FFESTR_firstWHERE)
4008 goto bad_0; /* :::::::::::::::::::: */
4009 break;
4010
4011 case FFELEX_typeNAMES:
4012 if (ffesta_first_kw != FFESTR_firstWHERE)
4013 goto bad_0; /* :::::::::::::::::::: */
4014 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlWHERE)
4015 goto bad_0; /* :::::::::::::::::::: */
4016 break;
4017
4018 default:
4019 goto bad_0; /* :::::::::::::::::::: */
4020 }
4021
4022 switch (ffelex_token_type (t))
4023 {
4024 case FFELEX_typeOPEN_PAREN:
4025 break;
4026
4027 case FFELEX_typeEOS:
4028 case FFELEX_typeSEMICOLON:
4029 case FFELEX_typeCOMMA:
4030 case FFELEX_typeCOLONCOLON:
4031 ffesta_confirmed (); /* Error, but clearly intended. */
4032 goto bad_1; /* :::::::::::::::::::: */
4033
4034 default:
4035 goto bad_1; /* :::::::::::::::::::: */
4036 }
4037
4038 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextWHERE,
4039 (ffeexprCallback) ffestb_where1_);
4040
4041 bad_0: /* :::::::::::::::::::: */
4042 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", ffesta_tokens[0]);
4043 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4044
4045 bad_1: /* :::::::::::::::::::: */
4046 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
4047 return (ffelexHandler) ffelex_swallow_tokens (t,
4048 (ffelexHandler) ffesta_zero); /* Invalid second token. */
4049 }
4050
4051 #endif
4052 /* ffestb_where1_ -- "WHERE" OPEN_PAREN expr
4053
4054 (ffestb_where1_) // to expression handler
4055
4056 Make sure the next token is CLOSE_PAREN. */
4057
4058 #if FFESTR_F90
4059 static ffelexHandler
4060 ffestb_where1_ (ffelexToken ft, ffebld expr, ffelexToken t)
4061 {
4062 ffestb_local_.if_stmt.expr = expr;
4063
4064 switch (ffelex_token_type (t))
4065 {
4066 case FFELEX_typeCLOSE_PAREN:
4067 if (expr == NULL)
4068 break;
4069 ffesta_tokens[1] = ffelex_token_use (ft);
4070 ffelex_set_names (TRUE);
4071 return (ffelexHandler) ffestb_where2_;
4072
4073 default:
4074 break;
4075 }
4076
4077 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
4078 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4079 }
4080
4081 #endif
4082 /* ffestb_where2_ -- "WHERE" OPEN_PAREN expr CLOSE_PAREN
4083
4084 return ffestb_where2_; // to lexer
4085
4086 Make sure the next token is NAME. */
4087
4088 #if FFESTR_F90
4089 static ffelexHandler
4090 ffestb_where2_ (ffelexToken t)
4091 {
4092 ffelex_set_names (FALSE);
4093
4094 switch (ffelex_token_type (t))
4095 {
4096 case FFELEX_typeNAME:
4097 case FFELEX_typeNAMES:
4098 ffesta_confirmed ();
4099 ffesta_tokens[2] = ffelex_token_use (t);
4100 return (ffelexHandler) ffestb_where3_;
4101
4102 case FFELEX_typeEOS:
4103 case FFELEX_typeSEMICOLON:
4104 ffesta_confirmed ();
4105 if (!ffesta_is_inhibited ())
4106 ffestc_R742 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
4107 ffelex_token_kill (ffesta_tokens[1]);
4108 return (ffelexHandler) ffesta_zero (t);
4109
4110 default:
4111 break;
4112 }
4113
4114 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
4115 ffelex_token_kill (ffesta_tokens[1]);
4116 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4117 }
4118
4119 #endif
4120 /* ffestb_where3_ -- "WHERE" OPEN_PAREN expr CLOSE_PAREN NAME
4121
4122 return ffestb_where3_; // to lexer
4123
4124 Implement R742. */
4125
4126 #if FFESTR_F90
4127 static ffelexHandler
4128 ffestb_where3_ (ffelexToken t)
4129 {
4130 ffelexHandler next;
4131 ffelexToken my_2 = ffesta_tokens[2];
4132
4133 if (!ffesta_is_inhibited ())
4134 ffestc_R740 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
4135 ffelex_token_kill (ffesta_tokens[1]);
4136 next = (ffelexHandler) ffesta_two (my_2, t);
4137 ffelex_token_kill (my_2);
4138 return (ffelexHandler) next;
4139 }
4140
4141 #endif
4142 /* ffestb_let -- Parse an assignment statement
4143
4144 return ffestb_let; // to lexer
4145
4146 Make sure the statement has a valid form for an assignment statement. If
4147 it does, implement the statement. */
4148
4149 ffelexHandler
4150 ffestb_let (ffelexToken t)
4151 {
4152 ffelexHandler next;
4153 bool vxtparam; /* TRUE if it might really be a VXT PARAMETER
4154 stmt. */
4155 unsigned const char *p;
4156
4157 switch (ffelex_token_type (ffesta_tokens[0]))
4158 {
4159 case FFELEX_typeNAME:
4160 vxtparam = FALSE;
4161 break;
4162
4163 case FFELEX_typeNAMES:
4164 vxtparam = TRUE;
4165 break;
4166
4167 default:
4168 goto bad_0; /* :::::::::::::::::::: */
4169 }
4170
4171 switch (ffelex_token_type (t))
4172 {
4173 case FFELEX_typeOPEN_PAREN:
4174 case FFELEX_typePERCENT:
4175 case FFELEX_typePOINTS:
4176 ffestb_local_.let.vxtparam = FALSE;
4177 break;
4178
4179 case FFELEX_typeEQUALS:
4180 if (!vxtparam || (ffesta_first_kw != FFESTR_firstPARAMETER))
4181 {
4182 ffestb_local_.let.vxtparam = FALSE;
4183 break;
4184 }
4185 p = ffelex_token_text (ffesta_tokens[0]) + FFESTR_firstlPARAMETER;
4186 ffestb_local_.let.vxtparam = ffesrc_is_name_init (*p);
4187 break;
4188
4189 default:
4190 goto bad_1; /* :::::::::::::::::::: */
4191 }
4192
4193 next = (ffelexHandler) (*((ffelexHandler)
4194 ffeexpr_lhs (ffesta_output_pool,
4195 FFEEXPR_contextLET,
4196 (ffeexprCallback) ffestb_let1_)))
4197 (ffesta_tokens[0]);
4198 return (ffelexHandler) (*next) (t);
4199
4200 bad_0: /* :::::::::::::::::::: */
4201 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", ffesta_tokens[0]);
4202 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4203
4204 bad_1: /* :::::::::::::::::::: */
4205 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", t);
4206 return (ffelexHandler) ffelex_swallow_tokens (t,
4207 (ffelexHandler) ffesta_zero); /* Invalid second token. */
4208 }
4209
4210 /* ffestb_let1_ -- expr
4211
4212 (ffestb_let1_) // to expression handler
4213
4214 Make sure the next token is EQUALS or POINTS. */
4215
4216 static ffelexHandler
4217 ffestb_let1_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
4218 {
4219 ffestb_local_.let.dest = expr;
4220
4221 switch (ffelex_token_type (t))
4222 {
4223 #if FFESTR_F90
4224 case FFELEX_typePOINTS:
4225 #endif
4226 case FFELEX_typeEQUALS:
4227 if (expr == NULL)
4228 break;
4229 ffesta_tokens[1] = ffelex_token_use (t);
4230 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
4231 FFEEXPR_contextLET, (ffeexprCallback) ffestb_let2_);
4232
4233 default:
4234 break;
4235 }
4236
4237 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", t);
4238 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4239 }
4240
4241 /* ffestb_let2_ -- expr EQUALS/POINTS expr
4242
4243 (ffestb_end2_) // to expression handler
4244
4245 Make sure the next token is EOS or SEMICOLON; implement the statement. */
4246
4247 static ffelexHandler
4248 ffestb_let2_ (ffelexToken ft, ffebld expr, ffelexToken t)
4249 {
4250 switch (ffelex_token_type (t))
4251 {
4252 case FFELEX_typeEOS:
4253 case FFELEX_typeSEMICOLON:
4254 if (expr == NULL)
4255 break;
4256 if (ffestb_local_.let.vxtparam && !ffestc_is_let_not_V027 ())
4257 break;
4258 ffesta_confirmed ();
4259 if (!ffesta_is_inhibited ())
4260 #if FFESTR_F90
4261 if (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeEQUALS)
4262 #endif
4263 ffestc_let (ffestb_local_.let.dest, expr, ft);
4264 #if FFESTR_F90
4265 else
4266 ffestc_R738 (ffestb_local_.let.dest, expr, ft);
4267 #endif
4268 ffelex_token_kill (ffesta_tokens[1]);
4269 return (ffelexHandler) ffesta_zero (t);
4270
4271 default:
4272 break;
4273 }
4274
4275 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
4276 (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeEQUALS)
4277 ? "assignment" : "pointer-assignment",
4278 t);
4279 ffelex_token_kill (ffesta_tokens[1]);
4280 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4281 }
4282
4283 /* ffestb_type -- Parse the TYPE statement
4284
4285 return ffestb_type; // to lexer
4286
4287 Make sure the statement has a valid form for the TYPE statement. If
4288 it does, implement the statement. */
4289
4290 #if FFESTR_F90
4291 ffelexHandler
4292 ffestb_type (ffelexToken t)
4293 {
4294 ffeTokenLength i;
4295 const char *p;
4296
4297 switch (ffelex_token_type (ffesta_tokens[0]))
4298 {
4299 case FFELEX_typeNAME:
4300 if (ffesta_first_kw != FFESTR_firstTYPE)
4301 goto bad_0; /* :::::::::::::::::::: */
4302 switch (ffelex_token_type (t))
4303 {
4304 case FFELEX_typeEOS:
4305 case FFELEX_typeSEMICOLON:
4306 case FFELEX_typeCOLONCOLON:
4307 ffesta_confirmed (); /* Error, but clearly intended. */
4308 goto bad_1; /* :::::::::::::::::::: */
4309
4310 default:
4311 goto bad_1; /* :::::::::::::::::::: */
4312
4313 case FFELEX_typeCOMMA:
4314 ffesta_confirmed ();
4315 return (ffelexHandler) ffestb_type1_;
4316
4317 case FFELEX_typeNAME: /* No confirm here, because ambig w/V020 VXT
4318 TYPE. */
4319 ffesta_tokens[1] = NULL;
4320 ffesta_tokens[2] = ffelex_token_use (t);
4321 return (ffelexHandler) ffestb_type4_;
4322 }
4323
4324 case FFELEX_typeNAMES:
4325 if (ffesta_first_kw != FFESTR_firstTYPE)
4326 goto bad_0; /* :::::::::::::::::::: */
4327 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlTYPE);
4328 switch (ffelex_token_type (t))
4329 {
4330 default:
4331 goto bad_1; /* :::::::::::::::::::: */
4332
4333 case FFELEX_typeCOMMA:
4334 if (*p != '\0')
4335 goto bad_i; /* :::::::::::::::::::: */
4336 ffesta_confirmed ();
4337 ffelex_set_names (TRUE);
4338 return (ffelexHandler) ffestb_type1_;
4339
4340 case FFELEX_typeEOS:
4341 case FFELEX_typeSEMICOLON:
4342 break;
4343 }
4344 if (!ffesrc_is_name_init (*p))
4345 goto bad_i; /* :::::::::::::::::::: */
4346 ffesta_tokens[1] = NULL;
4347 ffesta_tokens[2]
4348 = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
4349 return (ffelexHandler) ffestb_type4_ (t);
4350
4351 default:
4352 goto bad_0; /* :::::::::::::::::::: */
4353 }
4354
4355 bad_0: /* :::::::::::::::::::: */
4356 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", ffesta_tokens[0]);
4357 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4358
4359 bad_1: /* :::::::::::::::::::: */
4360 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4361 return (ffelexHandler) ffelex_swallow_tokens (t,
4362 (ffelexHandler) ffesta_zero); /* Invalid second token. */
4363
4364 bad_i: /* :::::::::::::::::::: */
4365 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "TYPE", ffesta_tokens[0], i, t);
4366 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4367 }
4368
4369 /* ffestb_type1_ -- "TYPE" COMMA
4370
4371 return ffestb_type1_; // to lexer
4372
4373 Make sure the next token is a NAME. */
4374
4375 static ffelexHandler
4376 ffestb_type1_ (ffelexToken t)
4377 {
4378 ffeTokenLength i;
4379 const char *p;
4380
4381 ffelex_set_names (FALSE);
4382
4383 switch (ffelex_token_type (t))
4384 {
4385 case FFELEX_typeNAME:
4386 ffesta_tokens[1] = ffelex_token_use (t);
4387 ffestb_local_.type.kw = ffestr_other (t);
4388 switch (ffestb_local_.varlist.kw)
4389 {
4390 case FFESTR_otherPUBLIC:
4391 case FFESTR_otherPRIVATE:
4392 return (ffelexHandler) ffestb_type2_;
4393
4394 default:
4395 ffelex_token_kill (ffesta_tokens[1]);
4396 break;
4397 }
4398 break;
4399
4400 case FFELEX_typeNAMES:
4401 ffesta_tokens[1] = ffelex_token_use (t);
4402 ffestb_local_.type.kw = ffestr_other (t);
4403 switch (ffestb_local_.varlist.kw)
4404 {
4405 case FFESTR_otherPUBLIC:
4406 p = ffelex_token_text (t) + (i = FFESTR_otherlPUBLIC);
4407 if (*p == '\0')
4408 return (ffelexHandler) ffestb_type2_;
4409 if (!ffesrc_is_name_init (*p))
4410 goto bad_i1; /* :::::::::::::::::::: */
4411 ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
4412 return (ffelexHandler) ffestb_type4_;
4413
4414 case FFESTR_otherPRIVATE:
4415 p = ffelex_token_text (t) + (i = FFESTR_otherlPRIVATE);
4416 if (*p == '\0')
4417 return (ffelexHandler) ffestb_type2_;
4418 if (!ffesrc_is_name_init (*p))
4419 goto bad_i1; /* :::::::::::::::::::: */
4420 ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
4421 return (ffelexHandler) ffestb_type4_;
4422
4423 default:
4424 ffelex_token_kill (ffesta_tokens[1]);
4425 break;
4426 }
4427 break;
4428
4429 default:
4430 break;
4431 }
4432
4433 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4434 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4435
4436 bad_i1: /* :::::::::::::::::::: */
4437 ffelex_token_kill (ffesta_tokens[1]);
4438 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "TYPE", t, i, NULL);
4439 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4440 }
4441
4442 /* ffestb_type2_ -- "TYPE" COMMA NAME
4443
4444 return ffestb_type2_; // to lexer
4445
4446 Handle COLONCOLON or NAME. */
4447
4448 static ffelexHandler
4449 ffestb_type2_ (ffelexToken t)
4450 {
4451 switch (ffelex_token_type (t))
4452 {
4453 case FFELEX_typeCOLONCOLON:
4454 return (ffelexHandler) ffestb_type3_;
4455
4456 case FFELEX_typeNAME:
4457 return (ffelexHandler) ffestb_type3_ (t);
4458
4459 default:
4460 break;
4461 }
4462
4463 if (ffesta_tokens[1] != NULL)
4464 ffelex_token_kill (ffesta_tokens[1]);
4465 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4466 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4467 }
4468
4469 /* ffestb_type3_ -- "TYPE" [COMMA NAME [COLONCOLON]]
4470
4471 return ffestb_type3_; // to lexer
4472
4473 Make sure the next token is a NAME. */
4474
4475 static ffelexHandler
4476 ffestb_type3_ (ffelexToken t)
4477 {
4478 switch (ffelex_token_type (t))
4479 {
4480 case FFELEX_typeNAME:
4481 ffesta_tokens[2] = ffelex_token_use (t);
4482 return (ffelexHandler) ffestb_type4_;
4483
4484 default:
4485 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4486 break;
4487 }
4488
4489 if (ffesta_tokens[1] != NULL)
4490 ffelex_token_kill (ffesta_tokens[1]);
4491 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4492 }
4493
4494 /* ffestb_type4_ -- "TYPE" [COMMA NAME [COLONCOLON]] NAME
4495
4496 return ffestb_type4_; // to lexer
4497
4498 Make sure the next token is an EOS or SEMICOLON. */
4499
4500 static ffelexHandler
4501 ffestb_type4_ (ffelexToken t)
4502 {
4503 switch (ffelex_token_type (t))
4504 {
4505 case FFELEX_typeEOS:
4506 case FFELEX_typeSEMICOLON:
4507 ffesta_confirmed ();
4508 if (!ffesta_is_inhibited ())
4509 ffestc_R424 (ffesta_tokens[1], ffestb_local_.type.kw,
4510 ffesta_tokens[2]);
4511 if (ffesta_tokens[1] != NULL)
4512 ffelex_token_kill (ffesta_tokens[1]);
4513 ffelex_token_kill (ffesta_tokens[2]);
4514 return (ffelexHandler) ffesta_zero (t);
4515
4516 default:
4517 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4518 break;
4519 }
4520
4521 if (ffesta_tokens[1] != NULL)
4522 ffelex_token_kill (ffesta_tokens[1]);
4523 ffelex_token_kill (ffesta_tokens[2]);
4524 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4525 }
4526
4527 #endif
4528 /* ffestb_varlist -- Parse EXTERNAL/INTENT/INTRINSIC/OPTIONAL/PUBLIC/PRIVATE
4529 statement
4530
4531 return ffestb_varlist; // to lexer
4532
4533 Make sure the statement has a valid form. If it
4534 does, implement the statement. */
4535
4536 ffelexHandler
4537 ffestb_varlist (ffelexToken t)
4538 {
4539 ffeTokenLength i;
4540 unsigned const char *p;
4541 ffelexToken nt;
4542 ffelexHandler next;
4543
4544 switch (ffelex_token_type (ffesta_tokens[0]))
4545 {
4546 case FFELEX_typeNAME:
4547 switch (ffelex_token_type (t))
4548 {
4549 case FFELEX_typeEOS:
4550 case FFELEX_typeSEMICOLON:
4551 ffesta_confirmed ();
4552 switch (ffesta_first_kw)
4553 {
4554 #if FFESTR_F90
4555 case FFESTR_firstPUBLIC:
4556 if (!ffesta_is_inhibited ())
4557 ffestc_R521A ();
4558 return (ffelexHandler) ffesta_zero (t);
4559
4560 case FFESTR_firstPRIVATE:
4561 if (!ffesta_is_inhibited ())
4562 ffestc_private (); /* Either R523A or R521B. */
4563 return (ffelexHandler) ffesta_zero (t);
4564 #endif
4565
4566 default:
4567 goto bad_1; /* :::::::::::::::::::: */
4568 }
4569
4570 case FFELEX_typeCOMMA:
4571 ffesta_confirmed (); /* Error, but clearly intended. */
4572 goto bad_1; /* :::::::::::::::::::: */
4573
4574 case FFELEX_typeCOLONCOLON:
4575 ffesta_confirmed ();
4576 switch (ffesta_first_kw)
4577 {
4578 #if FFESTR_F90
4579 case FFESTR_firstOPTIONAL:
4580 if (!ffesta_is_inhibited ())
4581 ffestc_R520_start ();
4582 break;
4583
4584 case FFESTR_firstPUBLIC:
4585 if (!ffesta_is_inhibited ())
4586 ffestc_R521Astart ();
4587 break;
4588
4589 case FFESTR_firstPRIVATE:
4590 if (!ffesta_is_inhibited ())
4591 ffestc_R521Bstart ();
4592 break;
4593 #endif
4594
4595 default:
4596 ffesta_confirmed (); /* Error, but clearly intended. */
4597 goto bad_1; /* :::::::::::::::::::: */
4598 }
4599 return (ffelexHandler) ffestb_varlist5_;
4600
4601 default:
4602 goto bad_1; /* :::::::::::::::::::: */
4603
4604 case FFELEX_typeOPEN_PAREN:
4605 switch (ffesta_first_kw)
4606 {
4607 #if FFESTR_F90
4608 case FFESTR_firstINTENT:
4609 return (ffelexHandler) ffestb_varlist1_;
4610 #endif
4611
4612 default:
4613 goto bad_1; /* :::::::::::::::::::: */
4614 }
4615
4616 case FFELEX_typeNAME:
4617 ffesta_confirmed ();
4618 switch (ffesta_first_kw)
4619 {
4620 case FFESTR_firstEXTERNAL:
4621 if (!ffesta_is_inhibited ())
4622 ffestc_R1207_start ();
4623 break;
4624
4625 #if FFESTR_F90
4626 case FFESTR_firstINTENT:
4627 goto bad_1; /* :::::::::::::::::::: */
4628 #endif
4629
4630 case FFESTR_firstINTRINSIC:
4631 if (!ffesta_is_inhibited ())
4632 ffestc_R1208_start ();
4633 break;
4634
4635 #if FFESTR_F90
4636 case FFESTR_firstOPTIONAL:
4637 if (!ffesta_is_inhibited ())
4638 ffestc_R520_start ();
4639 break;
4640 #endif
4641
4642 #if FFESTR_F90
4643 case FFESTR_firstPUBLIC:
4644 if (!ffesta_is_inhibited ())
4645 ffestc_R521Astart ();
4646 break;
4647
4648 case FFESTR_firstPRIVATE:
4649 if (!ffesta_is_inhibited ())
4650 ffestc_R521Bstart ();
4651 break;
4652 #endif
4653
4654 default:
4655 break;
4656 }
4657 return (ffelexHandler) ffestb_varlist5_ (t);
4658 }
4659
4660 case FFELEX_typeNAMES:
4661 p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.varlist.len);
4662 switch (ffelex_token_type (t))
4663 {
4664 case FFELEX_typeEOS:
4665 case FFELEX_typeSEMICOLON:
4666 ffesta_confirmed ();
4667 switch (ffesta_first_kw)
4668 {
4669 #if FFESTR_F90
4670 case FFESTR_firstINTENT:
4671 goto bad_1; /* :::::::::::::::::::: */
4672 #endif
4673
4674 default:
4675 break;
4676 }
4677 if (*p != '\0')
4678 break;
4679 switch (ffesta_first_kw)
4680 {
4681 #if FFESTR_F90
4682 case FFESTR_firstPUBLIC:
4683 if (!ffesta_is_inhibited ())
4684 ffestc_R521A ();
4685 return (ffelexHandler) ffesta_zero (t);
4686
4687 case FFESTR_firstPRIVATE:
4688 if (!ffesta_is_inhibited ())
4689 ffestc_private (); /* Either R423A or R521B. */
4690 return (ffelexHandler) ffesta_zero (t);
4691 #endif
4692
4693 default:
4694 goto bad_1; /* :::::::::::::::::::: */
4695 }
4696
4697 case FFELEX_typeCOMMA:
4698 ffesta_confirmed (); /* Error, but clearly intended. */
4699 switch (ffesta_first_kw)
4700 {
4701 #if FFESTR_F90
4702 case FFESTR_firstINTENT:
4703 goto bad_1; /* :::::::::::::::::::: */
4704 #endif
4705
4706 default:
4707 break;
4708 }
4709 if (*p != '\0')
4710 break;
4711 goto bad_1; /* :::::::::::::::::::: */
4712
4713 case FFELEX_typeCOLONCOLON:
4714 ffesta_confirmed ();
4715 switch (ffesta_first_kw)
4716 {
4717 #if FFESTR_F90
4718 case FFESTR_firstOPTIONAL:
4719 if (!ffesta_is_inhibited ())
4720 ffestc_R520_start ();
4721 break;
4722 #endif
4723
4724 #if FFESTR_F90
4725 case FFESTR_firstPUBLIC:
4726 if (!ffesta_is_inhibited ())
4727 ffestc_R521Astart ();
4728 break;
4729
4730 case FFESTR_firstPRIVATE:
4731 if (!ffesta_is_inhibited ())
4732 ffestc_R521Bstart ();
4733 break;
4734 #endif
4735
4736 default:
4737 goto bad_1; /* :::::::::::::::::::: */
4738 }
4739 return (ffelexHandler) ffestb_varlist5_;
4740
4741 case FFELEX_typeOPEN_PAREN:
4742 switch (ffesta_first_kw)
4743 {
4744 #if FFESTR_F90
4745 case FFESTR_firstINTENT:
4746 if (*p != '\0')
4747 goto bad_1; /* :::::::::::::::::::: */
4748 return (ffelexHandler) ffestb_varlist1_;
4749 #endif
4750
4751 default:
4752 goto bad_1; /* :::::::::::::::::::: */
4753 }
4754
4755 case FFELEX_typeNAME:
4756 ffesta_confirmed ();
4757 switch (ffesta_first_kw)
4758 {
4759 case FFESTR_firstEXTERNAL:
4760 if (!ffesta_is_inhibited ())
4761 ffestc_R1207_start ();
4762 break;
4763
4764 #if FFESTR_F90
4765 case FFESTR_firstINTENT:
4766 goto bad_1; /* :::::::::::::::::::: */
4767 #endif
4768
4769 case FFESTR_firstINTRINSIC:
4770 if (!ffesta_is_inhibited ())
4771 ffestc_R1208_start ();
4772 break;
4773
4774 #if FFESTR_F90
4775 case FFESTR_firstOPTIONAL:
4776 if (!ffesta_is_inhibited ())
4777 ffestc_R520_start ();
4778 break;
4779 #endif
4780
4781 #if FFESTR_F90
4782 case FFESTR_firstPUBLIC:
4783 if (!ffesta_is_inhibited ())
4784 ffestc_R521Astart ();
4785 break;
4786
4787 case FFESTR_firstPRIVATE:
4788 if (!ffesta_is_inhibited ())
4789 ffestc_R521Bstart ();
4790 break;
4791 #endif
4792
4793 default:
4794 break;
4795 }
4796 return (ffelexHandler) ffestb_varlist5_ (t);
4797
4798 default:
4799 goto bad_1; /* :::::::::::::::::::: */
4800 }
4801
4802 /* Here, we have at least one char after the first keyword and t is
4803 COMMA or EOS/SEMICOLON. Also we know that this form is valid for
4804 only the statements reaching here (specifically, INTENT won't reach
4805 here). */
4806
4807 if (!ffesrc_is_name_init (*p))
4808 goto bad_i; /* :::::::::::::::::::: */
4809 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
4810 if (!ffesta_is_inhibited ())
4811 {
4812 switch (ffesta_first_kw)
4813 {
4814 case FFESTR_firstEXTERNAL:
4815 ffestc_R1207_start ();
4816 break;
4817
4818 case FFESTR_firstINTRINSIC:
4819 ffestc_R1208_start ();
4820 break;
4821
4822 #if FFESTR_F90
4823 case FFESTR_firstOPTIONAL:
4824 ffestc_R520_start ();
4825 break;
4826 #endif
4827
4828 #if FFESTR_F90
4829 case FFESTR_firstPUBLIC:
4830 ffestc_R521Astart ();
4831 break;
4832
4833 case FFESTR_firstPRIVATE:
4834 ffestc_R521Bstart ();
4835 break;
4836 #endif
4837
4838 default:
4839 assert (FALSE);
4840 }
4841 }
4842 next = (ffelexHandler) ffestb_varlist5_ (nt);
4843 ffelex_token_kill (nt);
4844 return (ffelexHandler) (*next) (t);
4845
4846 default:
4847 goto bad_0; /* :::::::::::::::::::: */
4848 }
4849
4850 bad_0: /* :::::::::::::::::::: */
4851 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, ffesta_tokens[0]);
4852 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4853
4854 bad_1: /* :::::::::::::::::::: */
4855 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4856 return (ffelexHandler) ffelex_swallow_tokens (t,
4857 (ffelexHandler) ffesta_zero); /* Invalid second token. */
4858
4859 bad_i: /* :::::::::::::::::::: */
4860 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, ffesta_tokens[0], i, t);
4861 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4862 }
4863
4864 /* ffestb_varlist1_ -- "INTENT" OPEN_PAREN
4865
4866 return ffestb_varlist1_; // to lexer
4867
4868 Handle NAME. */
4869
4870 #if FFESTR_F90
4871 static ffelexHandler
4872 ffestb_varlist1_ (ffelexToken t)
4873 {
4874 switch (ffelex_token_type (t))
4875 {
4876 case FFELEX_typeNAME:
4877 ffesta_tokens[1] = ffelex_token_use (t);
4878 ffestb_local_.varlist.kw = ffestr_other (t);
4879 switch (ffestb_local_.varlist.kw)
4880 {
4881 case FFESTR_otherIN:
4882 return (ffelexHandler) ffestb_varlist2_;
4883
4884 case FFESTR_otherINOUT:
4885 return (ffelexHandler) ffestb_varlist3_;
4886
4887 case FFESTR_otherOUT:
4888 return (ffelexHandler) ffestb_varlist3_;
4889
4890 default:
4891 ffelex_token_kill (ffesta_tokens[1]);
4892 break;
4893 }
4894 break;
4895
4896 default:
4897 break;
4898 }
4899
4900 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4901 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4902 }
4903
4904 /* ffestb_varlist2_ -- "INTENT" OPEN_PAREN "IN"
4905
4906 return ffestb_varlist2_; // to lexer
4907
4908 Handle NAME. */
4909
4910 static ffelexHandler
4911 ffestb_varlist2_ (ffelexToken t)
4912 {
4913 switch (ffelex_token_type (t))
4914 {
4915 case FFELEX_typeNAME:
4916 switch (ffestr_other (t))
4917 {
4918 case FFESTR_otherOUT:
4919 ffestb_local_.varlist.kw = FFESTR_otherINOUT;
4920 return (ffelexHandler) ffestb_varlist3_;
4921
4922 default:
4923 break;
4924 }
4925 break;
4926
4927 case FFELEX_typeCLOSE_PAREN:
4928 return (ffelexHandler) ffestb_varlist4_;
4929
4930 default:
4931 break;
4932 }
4933
4934 ffelex_token_kill (ffesta_tokens[1]);
4935 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4936 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4937 }
4938
4939 /* ffestb_varlist3_ -- "INTENT" OPEN_PAREN NAME ["OUT"]
4940
4941 return ffestb_varlist3_; // to lexer
4942
4943 Handle CLOSE_PAREN. */
4944
4945 static ffelexHandler
4946 ffestb_varlist3_ (ffelexToken t)
4947 {
4948 switch (ffelex_token_type (t))
4949 {
4950 case FFELEX_typeCLOSE_PAREN:
4951 return (ffelexHandler) ffestb_varlist4_;
4952
4953 default:
4954 break;
4955 }
4956
4957 ffelex_token_kill (ffesta_tokens[1]);
4958 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4959 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4960 }
4961
4962 /* ffestb_varlist4_ -- "INTENT" OPEN_PAREN NAME ["OUT"] CLOSE_PAREN
4963
4964 return ffestb_varlist4_; // to lexer
4965
4966 Handle COLONCOLON or NAME. */
4967
4968 static ffelexHandler
4969 ffestb_varlist4_ (ffelexToken t)
4970 {
4971 switch (ffelex_token_type (t))
4972 {
4973 case FFELEX_typeCOLONCOLON:
4974 ffesta_confirmed ();
4975 if (!ffesta_is_inhibited ())
4976 ffestc_R519_start (ffesta_tokens[1], ffestb_local_.varlist.kw);
4977 ffelex_token_kill (ffesta_tokens[1]);
4978 return (ffelexHandler) ffestb_varlist5_;
4979
4980 case FFELEX_typeNAME:
4981 ffesta_confirmed ();
4982 if (!ffesta_is_inhibited ())
4983 ffestc_R519_start (ffesta_tokens[1], ffestb_local_.varlist.kw);
4984 ffelex_token_kill (ffesta_tokens[1]);
4985 return (ffelexHandler) ffestb_varlist5_ (t);
4986
4987 default:
4988 break;
4989 }
4990
4991 ffelex_token_kill (ffesta_tokens[1]);
4992 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4993 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4994 }
4995
4996 #endif
4997 /* ffestb_varlist5_ -- Handles the list of variable names
4998
4999 return ffestb_varlist5_; // to lexer
5000
5001 Handle NAME. */
5002
5003 static ffelexHandler
5004 ffestb_varlist5_ (ffelexToken t)
5005 {
5006 switch (ffelex_token_type (t))
5007 {
5008 case FFELEX_typeNAME:
5009 ffesta_tokens[1] = ffelex_token_use (t);
5010 return (ffelexHandler) ffestb_varlist6_;
5011
5012 default:
5013 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
5014 break;
5015 }
5016
5017 if (!ffesta_is_inhibited ())
5018 {
5019 switch (ffesta_first_kw)
5020 {
5021 case FFESTR_firstEXTERNAL:
5022 ffestc_R1207_finish ();
5023 break;
5024
5025 #if FFESTR_F90
5026 case FFESTR_firstINTENT:
5027 ffestc_R519_finish ();
5028 break;
5029 #endif
5030
5031 case FFESTR_firstINTRINSIC:
5032 ffestc_R1208_finish ();
5033 break;
5034
5035 #if FFESTR_F90
5036 case FFESTR_firstOPTIONAL:
5037 ffestc_R520_finish ();
5038 break;
5039 #endif
5040
5041 #if FFESTR_F90
5042 case FFESTR_firstPUBLIC:
5043 ffestc_R521Afinish ();
5044 break;
5045
5046 case FFESTR_firstPRIVATE:
5047 ffestc_R521Bfinish ();
5048 break;
5049 #endif
5050
5051 default:
5052 assert (FALSE);
5053 }
5054 }
5055 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5056 }
5057
5058 /* ffestb_varlist6_ -- (whatever) NAME
5059
5060 return ffestb_varlist6_; // to lexer
5061
5062 Handle COMMA or EOS/SEMICOLON. */
5063
5064 static ffelexHandler
5065 ffestb_varlist6_ (ffelexToken t)
5066 {
5067 switch (ffelex_token_type (t))
5068 {
5069 case FFELEX_typeCOMMA:
5070 if (!ffesta_is_inhibited ())
5071 {
5072 switch (ffesta_first_kw)
5073 {
5074 case FFESTR_firstEXTERNAL:
5075 ffestc_R1207_item (ffesta_tokens[1]);
5076 break;
5077
5078 #if FFESTR_F90
5079 case FFESTR_firstINTENT:
5080 ffestc_R519_item (ffesta_tokens[1]);
5081 break;
5082 #endif
5083
5084 case FFESTR_firstINTRINSIC:
5085 ffestc_R1208_item (ffesta_tokens[1]);
5086 break;
5087
5088 #if FFESTR_F90
5089 case FFESTR_firstOPTIONAL:
5090 ffestc_R520_item (ffesta_tokens[1]);
5091 break;
5092 #endif
5093
5094 #if FFESTR_F90
5095 case FFESTR_firstPUBLIC:
5096 ffestc_R521Aitem (ffesta_tokens[1]);
5097 break;
5098
5099 case FFESTR_firstPRIVATE:
5100 ffestc_R521Bitem (ffesta_tokens[1]);
5101 break;
5102 #endif
5103
5104 default:
5105 assert (FALSE);
5106 }
5107 }
5108 ffelex_token_kill (ffesta_tokens[1]);
5109 return (ffelexHandler) ffestb_varlist5_;
5110
5111 case FFELEX_typeEOS:
5112 case FFELEX_typeSEMICOLON:
5113 if (!ffesta_is_inhibited ())
5114 {
5115 switch (ffesta_first_kw)
5116 {
5117 case FFESTR_firstEXTERNAL:
5118 ffestc_R1207_item (ffesta_tokens[1]);
5119 ffestc_R1207_finish ();
5120 break;
5121
5122 #if FFESTR_F90
5123 case FFESTR_firstINTENT:
5124 ffestc_R519_item (ffesta_tokens[1]);
5125 ffestc_R519_finish ();
5126 break;
5127 #endif
5128
5129 case FFESTR_firstINTRINSIC:
5130 ffestc_R1208_item (ffesta_tokens[1]);
5131 ffestc_R1208_finish ();
5132 break;
5133
5134 #if FFESTR_F90
5135 case FFESTR_firstOPTIONAL:
5136 ffestc_R520_item (ffesta_tokens[1]);
5137 ffestc_R520_finish ();
5138 break;
5139 #endif
5140
5141 #if FFESTR_F90
5142 case FFESTR_firstPUBLIC:
5143 ffestc_R521Aitem (ffesta_tokens[1]);
5144 ffestc_R521Afinish ();
5145 break;
5146
5147 case FFESTR_firstPRIVATE:
5148 ffestc_R521Bitem (ffesta_tokens[1]);
5149 ffestc_R521Bfinish ();
5150 break;
5151 #endif
5152
5153 default:
5154 assert (FALSE);
5155 }
5156 }
5157 ffelex_token_kill (ffesta_tokens[1]);
5158 return (ffelexHandler) ffesta_zero (t);
5159
5160 default:
5161 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
5162 break;
5163 }
5164
5165 if (!ffesta_is_inhibited ())
5166 {
5167 switch (ffesta_first_kw)
5168 {
5169 case FFESTR_firstEXTERNAL:
5170 ffestc_R1207_finish ();
5171 break;
5172
5173 #if FFESTR_F90
5174 case FFESTR_firstINTENT:
5175 ffestc_R519_finish ();
5176 break;
5177 #endif
5178
5179 case FFESTR_firstINTRINSIC:
5180 ffestc_R1208_finish ();
5181 break;
5182
5183 #if FFESTR_F90
5184 case FFESTR_firstOPTIONAL:
5185 ffestc_R520_finish ();
5186 break;
5187 #endif
5188
5189 #if FFESTR_F90
5190 case FFESTR_firstPUBLIC:
5191 ffestc_R521Afinish ();
5192 break;
5193
5194 case FFESTR_firstPRIVATE:
5195 ffestc_R521Bfinish ();
5196 break;
5197 #endif
5198
5199 default:
5200 assert (FALSE);
5201 }
5202 }
5203 ffelex_token_kill (ffesta_tokens[1]);
5204 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5205 }
5206
5207 /* ffestb_R423B -- Parse the SEQUENCE statement
5208
5209 return ffestb_R423B; // to lexer
5210
5211 Make sure the statement has a valid form for the SEQUENCE statement. If
5212 it does, implement the statement. */
5213
5214 #if FFESTR_F90
5215 ffelexHandler
5216 ffestb_R423B (ffelexToken t)
5217 {
5218 const char *p;
5219 ffeTokenLength i;
5220
5221 switch (ffelex_token_type (ffesta_tokens[0]))
5222 {
5223 case FFELEX_typeNAME:
5224 if (ffesta_first_kw != FFESTR_firstSEQUENCE)
5225 goto bad_0; /* :::::::::::::::::::: */
5226 break;
5227
5228 case FFELEX_typeNAMES:
5229 if (ffesta_first_kw != FFESTR_firstSEQUENCE)
5230 goto bad_0; /* :::::::::::::::::::: */
5231 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlSEQUENCE)
5232 {
5233 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSEQUENCE);
5234 goto bad_i; /* :::::::::::::::::::: */
5235 }
5236 break;
5237
5238 default:
5239 goto bad_0; /* :::::::::::::::::::: */
5240 }
5241
5242 switch (ffelex_token_type (t))
5243 {
5244 case FFELEX_typeEOS:
5245 case FFELEX_typeSEMICOLON:
5246 ffesta_confirmed ();
5247 if (!ffesta_is_inhibited ())
5248 ffestc_R423B ();
5249 return (ffelexHandler) ffesta_zero (t);
5250
5251 case FFELEX_typeCOMMA:
5252 case FFELEX_typeCOLONCOLON:
5253 ffesta_confirmed (); /* Error, but clearly intended. */
5254 goto bad_1; /* :::::::::::::::::::: */
5255
5256 default:
5257 goto bad_1; /* :::::::::::::::::::: */
5258 }
5259
5260 bad_0: /* :::::::::::::::::::: */
5261 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", ffesta_tokens[0]);
5262 return (ffelexHandler) ffelex_swallow_tokens (t,
5263 (ffelexHandler) ffesta_zero); /* Invalid first token. */
5264
5265 bad_1: /* :::::::::::::::::::: */
5266 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", t);
5267 return (ffelexHandler) ffelex_swallow_tokens (t,
5268 (ffelexHandler) ffesta_zero); /* Invalid second token. */
5269
5270 bad_i: /* :::::::::::::::::::: */
5271 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", ffesta_tokens[0], i, t);
5272 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5273 }
5274
5275 #endif
5276 /* ffestb_R522 -- Parse the SAVE statement
5277
5278 return ffestb_R522; // to lexer
5279
5280 Make sure the statement has a valid form for the SAVE statement. If it
5281 does, implement the statement. */
5282
5283 ffelexHandler
5284 ffestb_R522 (ffelexToken t)
5285 {
5286 ffeTokenLength i;
5287 unsigned const char *p;
5288 ffelexToken nt;
5289 ffelexHandler next;
5290
5291 switch (ffelex_token_type (ffesta_tokens[0]))
5292 {
5293 case FFELEX_typeNAME:
5294 if (ffesta_first_kw != FFESTR_firstSAVE)
5295 goto bad_0; /* :::::::::::::::::::: */
5296 switch (ffelex_token_type (t))
5297 {
5298 case FFELEX_typeCOMMA:
5299 ffesta_confirmed (); /* Error, but clearly intended. */
5300 goto bad_1; /* :::::::::::::::::::: */
5301
5302 default:
5303 goto bad_1; /* :::::::::::::::::::: */
5304
5305 case FFELEX_typeEOS:
5306 case FFELEX_typeSEMICOLON:
5307 ffesta_confirmed ();
5308 if (!ffesta_is_inhibited ())
5309 ffestc_R522 ();
5310 return (ffelexHandler) ffesta_zero (t);
5311
5312 case FFELEX_typeNAME:
5313 case FFELEX_typeSLASH:
5314 ffesta_confirmed ();
5315 if (!ffesta_is_inhibited ())
5316 ffestc_R522start ();
5317 return (ffelexHandler) ffestb_R5221_ (t);
5318
5319 case FFELEX_typeCOLONCOLON:
5320 ffesta_confirmed ();
5321 if (!ffesta_is_inhibited ())
5322 ffestc_R522start ();
5323 return (ffelexHandler) ffestb_R5221_;
5324 }
5325
5326 case FFELEX_typeNAMES:
5327 if (ffesta_first_kw != FFESTR_firstSAVE)
5328 goto bad_0; /* :::::::::::::::::::: */
5329 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSAVE);
5330 switch (ffelex_token_type (t))
5331 {
5332 default:
5333 goto bad_1; /* :::::::::::::::::::: */
5334
5335 case FFELEX_typeCOMMA:
5336 ffesta_confirmed ();
5337 break;
5338
5339 case FFELEX_typeEOS:
5340 case FFELEX_typeSEMICOLON:
5341 ffesta_confirmed ();
5342 if (*p != '\0')
5343 break;
5344 if (!ffesta_is_inhibited ())
5345 ffestc_R522 ();
5346 return (ffelexHandler) ffesta_zero (t);
5347
5348 case FFELEX_typeSLASH:
5349 ffesta_confirmed ();
5350 if (*p != '\0')
5351 goto bad_i; /* :::::::::::::::::::: */
5352 if (!ffesta_is_inhibited ())
5353 ffestc_R522start ();
5354 return (ffelexHandler) ffestb_R5221_ (t);
5355
5356 case FFELEX_typeCOLONCOLON:
5357 ffesta_confirmed ();
5358 if (*p != '\0')
5359 goto bad_i; /* :::::::::::::::::::: */
5360 if (!ffesta_is_inhibited ())
5361 ffestc_R522start ();
5362 return (ffelexHandler) ffestb_R5221_;
5363 }
5364
5365 /* Here, we have at least one char after "SAVE" and t is COMMA or
5366 EOS/SEMICOLON. */
5367
5368 if (!ffesrc_is_name_init (*p))
5369 goto bad_i; /* :::::::::::::::::::: */
5370 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
5371 if (!ffesta_is_inhibited ())
5372 ffestc_R522start ();
5373 next = (ffelexHandler) ffestb_R5221_ (nt);
5374 ffelex_token_kill (nt);
5375 return (ffelexHandler) (*next) (t);
5376
5377 default:
5378 goto bad_0; /* :::::::::::::::::::: */
5379 }
5380
5381 bad_0: /* :::::::::::::::::::: */
5382 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", ffesta_tokens[0]);
5383 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5384
5385 bad_1: /* :::::::::::::::::::: */
5386 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5387 return (ffelexHandler) ffelex_swallow_tokens (t,
5388 (ffelexHandler) ffesta_zero); /* Invalid second token. */
5389
5390 bad_i: /* :::::::::::::::::::: */
5391 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SAVE", ffesta_tokens[0], i, t);
5392 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5393 }
5394
5395 /* ffestb_R5221_ -- "SAVE" [COLONCOLON]
5396
5397 return ffestb_R5221_; // to lexer
5398
5399 Handle NAME or SLASH. */
5400
5401 static ffelexHandler
5402 ffestb_R5221_ (ffelexToken t)
5403 {
5404 switch (ffelex_token_type (t))
5405 {
5406 case FFELEX_typeNAME:
5407 ffestb_local_.R522.is_cblock = FALSE;
5408 ffesta_tokens[1] = ffelex_token_use (t);
5409 return (ffelexHandler) ffestb_R5224_;
5410
5411 case FFELEX_typeSLASH:
5412 ffestb_local_.R522.is_cblock = TRUE;
5413 return (ffelexHandler) ffestb_R5222_;
5414
5415 default:
5416 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5417 break;
5418 }
5419
5420 if (!ffesta_is_inhibited ())
5421 ffestc_R522finish ();
5422 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5423 }
5424
5425 /* ffestb_R5222_ -- "SAVE" [COLONCOLON] SLASH
5426
5427 return ffestb_R5222_; // to lexer
5428
5429 Handle NAME. */
5430
5431 static ffelexHandler
5432 ffestb_R5222_ (ffelexToken t)
5433 {
5434 switch (ffelex_token_type (t))
5435 {
5436 case FFELEX_typeNAME:
5437 ffesta_tokens[1] = ffelex_token_use (t);
5438 return (ffelexHandler) ffestb_R5223_;
5439
5440 default:
5441 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5442 break;
5443 }
5444
5445 if (!ffesta_is_inhibited ())
5446 ffestc_R522finish ();
5447 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5448 }
5449
5450 /* ffestb_R5223_ -- "SAVE" [COLONCOLON] SLASH NAME
5451
5452 return ffestb_R5223_; // to lexer
5453
5454 Handle SLASH. */
5455
5456 static ffelexHandler
5457 ffestb_R5223_ (ffelexToken t)
5458 {
5459 switch (ffelex_token_type (t))
5460 {
5461 case FFELEX_typeSLASH:
5462 return (ffelexHandler) ffestb_R5224_;
5463
5464 default:
5465 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5466 break;
5467 }
5468
5469 if (!ffesta_is_inhibited ())
5470 ffestc_R522finish ();
5471 ffelex_token_kill (ffesta_tokens[1]);
5472 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5473 }
5474
5475 /* ffestb_R5224_ -- "SAVE" [COLONCOLON] R523
5476
5477 return ffestb_R5224_; // to lexer
5478
5479 Handle COMMA or EOS/SEMICOLON. */
5480
5481 static ffelexHandler
5482 ffestb_R5224_ (ffelexToken t)
5483 {
5484 switch (ffelex_token_type (t))
5485 {
5486 case FFELEX_typeCOMMA:
5487 if (!ffesta_is_inhibited ())
5488 {
5489 if (ffestb_local_.R522.is_cblock)
5490 ffestc_R522item_cblock (ffesta_tokens[1]);
5491 else
5492 ffestc_R522item_object (ffesta_tokens[1]);
5493 }
5494 ffelex_token_kill (ffesta_tokens[1]);
5495 return (ffelexHandler) ffestb_R5221_;
5496
5497 case FFELEX_typeEOS:
5498 case FFELEX_typeSEMICOLON:
5499 if (!ffesta_is_inhibited ())
5500 {
5501 if (ffestb_local_.R522.is_cblock)
5502 ffestc_R522item_cblock (ffesta_tokens[1]);
5503 else
5504 ffestc_R522item_object (ffesta_tokens[1]);
5505 ffestc_R522finish ();
5506 }
5507 ffelex_token_kill (ffesta_tokens[1]);
5508 return (ffelexHandler) ffesta_zero (t);
5509
5510 default:
5511 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5512 break;
5513 }
5514
5515 if (!ffesta_is_inhibited ())
5516 ffestc_R522finish ();
5517 ffelex_token_kill (ffesta_tokens[1]);
5518 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5519 }
5520
5521 /* ffestb_R528 -- Parse the DATA statement
5522
5523 return ffestb_R528; // to lexer
5524
5525 Make sure the statement has a valid form for the DATA statement. If it
5526 does, implement the statement. */
5527
5528 ffelexHandler
5529 ffestb_R528 (ffelexToken t)
5530 {
5531 unsigned const char *p;
5532 ffeTokenLength i;
5533 ffelexToken nt;
5534 ffelexHandler next;
5535
5536 switch (ffelex_token_type (ffesta_tokens[0]))
5537 {
5538 case FFELEX_typeNAME:
5539 if (ffesta_first_kw != FFESTR_firstDATA)
5540 goto bad_0; /* :::::::::::::::::::: */
5541 switch (ffelex_token_type (t))
5542 {
5543 case FFELEX_typeCOMMA:
5544 case FFELEX_typeEOS:
5545 case FFELEX_typeSEMICOLON:
5546 case FFELEX_typeSLASH:
5547 case FFELEX_typeCOLONCOLON:
5548 ffesta_confirmed (); /* Error, but clearly intended. */
5549 goto bad_1; /* :::::::::::::::::::: */
5550
5551 default:
5552 goto bad_1; /* :::::::::::::::::::: */
5553
5554 case FFELEX_typeNAME:
5555 ffesta_confirmed ();
5556 break;
5557
5558 case FFELEX_typeOPEN_PAREN:
5559 break;
5560 }
5561 ffestb_local_.data.started = FALSE;
5562 return (ffelexHandler) (*((ffelexHandler)
5563 ffeexpr_lhs (ffesta_output_pool,
5564 FFEEXPR_contextDATA,
5565 (ffeexprCallback) ffestb_R5281_)))
5566 (t);
5567
5568 case FFELEX_typeNAMES:
5569 if (ffesta_first_kw != FFESTR_firstDATA)
5570 goto bad_0; /* :::::::::::::::::::: */
5571 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDATA);
5572 switch (ffelex_token_type (t))
5573 {
5574 case FFELEX_typeEOS:
5575 case FFELEX_typeSEMICOLON:
5576 case FFELEX_typeCOLONCOLON:
5577 ffesta_confirmed (); /* Error, but clearly intended. */
5578 goto bad_1; /* :::::::::::::::::::: */
5579
5580 default:
5581 goto bad_1; /* :::::::::::::::::::: */
5582
5583 case FFELEX_typeOPEN_PAREN:
5584 if (*p == '\0')
5585 {
5586 ffestb_local_.data.started = FALSE;
5587 return (ffelexHandler) (*((ffelexHandler)
5588 ffeexpr_lhs (ffesta_output_pool,
5589 FFEEXPR_contextDATA,
5590 (ffeexprCallback)
5591 ffestb_R5281_)))
5592 (t);
5593 }
5594 break;
5595
5596 case FFELEX_typeCOMMA:
5597 case FFELEX_typeSLASH:
5598 ffesta_confirmed ();
5599 break;
5600 }
5601 if (!ffesrc_is_name_init (*p))
5602 goto bad_i; /* :::::::::::::::::::: */
5603 ffestb_local_.data.started = FALSE;
5604 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
5605 next = (ffelexHandler) (*((ffelexHandler)
5606 ffeexpr_lhs (ffesta_output_pool,
5607 FFEEXPR_contextDATA,
5608 (ffeexprCallback) ffestb_R5281_)))
5609 (nt);
5610 ffelex_token_kill (nt);
5611 return (ffelexHandler) (*next) (t);
5612
5613 default:
5614 goto bad_0; /* :::::::::::::::::::: */
5615 }
5616
5617 bad_0: /* :::::::::::::::::::: */
5618 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", ffesta_tokens[0]);
5619 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5620
5621 bad_1: /* :::::::::::::::::::: */
5622 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5623 return (ffelexHandler) ffelex_swallow_tokens (t,
5624 (ffelexHandler) ffesta_zero); /* Invalid second token. */
5625
5626 bad_i: /* :::::::::::::::::::: */
5627 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DATA", ffesta_tokens[0], i, t);
5628 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5629 }
5630
5631 /* ffestb_R5281_ -- "DATA" expr-list
5632
5633 (ffestb_R5281_) // to expression handler
5634
5635 Handle COMMA or SLASH. */
5636
5637 static ffelexHandler
5638 ffestb_R5281_ (ffelexToken ft, ffebld expr, ffelexToken t)
5639 {
5640 switch (ffelex_token_type (t))
5641 {
5642 case FFELEX_typeCOMMA:
5643 ffesta_confirmed ();
5644 if (expr == NULL)
5645 break;
5646 if (!ffesta_is_inhibited ())
5647 {
5648 if (!ffestb_local_.data.started)
5649 {
5650 ffestc_R528_start ();
5651 ffestb_local_.data.started = TRUE;
5652 }
5653 ffestc_R528_item_object (expr, ft);
5654 }
5655 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5656 FFEEXPR_contextDATA,
5657 (ffeexprCallback) ffestb_R5281_);
5658
5659 case FFELEX_typeSLASH:
5660 ffesta_confirmed ();
5661 if (expr == NULL)
5662 break;
5663 if (!ffesta_is_inhibited ())
5664 {
5665 if (!ffestb_local_.data.started)
5666 {
5667 ffestc_R528_start ();
5668 ffestb_local_.data.started = TRUE;
5669 }
5670 ffestc_R528_item_object (expr, ft);
5671 ffestc_R528_item_startvals ();
5672 }
5673 return (ffelexHandler) ffeexpr_rhs
5674 (ffesta_output_pool, FFEEXPR_contextDATA,
5675 (ffeexprCallback) ffestb_R5282_);
5676
5677 default:
5678 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5679 break;
5680 }
5681
5682 if (ffestb_local_.data.started && !ffesta_is_inhibited ())
5683 ffestc_R528_finish ();
5684 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5685 }
5686
5687 /* ffestb_R5282_ -- "DATA" expr-list SLASH expr-list
5688
5689 (ffestb_R5282_) // to expression handler
5690
5691 Handle ASTERISK, COMMA, or SLASH. */
5692
5693 static ffelexHandler
5694 ffestb_R5282_ (ffelexToken ft, ffebld expr, ffelexToken t)
5695 {
5696 switch (ffelex_token_type (t))
5697 {
5698 case FFELEX_typeCOMMA:
5699 if (expr == NULL)
5700 break;
5701 if (!ffesta_is_inhibited ())
5702 ffestc_R528_item_value (NULL, NULL, expr, ft);
5703 return (ffelexHandler) ffeexpr_rhs
5704 (ffesta_output_pool, FFEEXPR_contextDATA,
5705 (ffeexprCallback) ffestb_R5282_);
5706
5707 case FFELEX_typeASTERISK:
5708 if (expr == NULL)
5709 break;
5710 ffestb_local_.data.expr = ffeexpr_convert (expr, ft, t,
5711 FFEINFO_basictypeINTEGER,
5712 FFEINFO_kindtypeINTEGER1,
5713 0,
5714 FFETARGET_charactersizeNONE,
5715 FFEEXPR_contextLET);
5716 ffesta_tokens[1] = ffelex_token_use (ft);
5717 return (ffelexHandler) ffeexpr_rhs
5718 (ffesta_output_pool, FFEEXPR_contextDATA,
5719 (ffeexprCallback) ffestb_R5283_);
5720
5721 case FFELEX_typeSLASH:
5722 if (expr == NULL)
5723 break;
5724 if (!ffesta_is_inhibited ())
5725 {
5726 ffestc_R528_item_value (NULL, NULL, expr, ft);
5727 ffestc_R528_item_endvals (t);
5728 }
5729 return (ffelexHandler) ffestb_R5284_;
5730
5731 default:
5732 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5733 break;
5734 }
5735
5736 if (!ffesta_is_inhibited ())
5737 {
5738 ffestc_R528_item_endvals (t);
5739 ffestc_R528_finish ();
5740 }
5741 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5742 }
5743
5744 /* ffestb_R5283_ -- "DATA" expr-list SLASH expr ASTERISK expr
5745
5746 (ffestb_R5283_) // to expression handler
5747
5748 Handle COMMA or SLASH. */
5749
5750 static ffelexHandler
5751 ffestb_R5283_ (ffelexToken ft, ffebld expr, ffelexToken t)
5752 {
5753 switch (ffelex_token_type (t))
5754 {
5755 case FFELEX_typeCOMMA:
5756 if (expr == NULL)
5757 break;
5758 if (!ffesta_is_inhibited ())
5759 ffestc_R528_item_value (ffestb_local_.data.expr, ffesta_tokens[1],
5760 expr, ft);
5761 ffelex_token_kill (ffesta_tokens[1]);
5762 return (ffelexHandler) ffeexpr_rhs
5763 (ffesta_output_pool, FFEEXPR_contextDATA,
5764 (ffeexprCallback) ffestb_R5282_);
5765
5766 case FFELEX_typeSLASH:
5767 if (expr == NULL)
5768 break;
5769 if (!ffesta_is_inhibited ())
5770 {
5771 ffestc_R528_item_value (ffestb_local_.data.expr, ffesta_tokens[1],
5772 expr, ft);
5773 ffestc_R528_item_endvals (t);
5774 }
5775 ffelex_token_kill (ffesta_tokens[1]);
5776 return (ffelexHandler) ffestb_R5284_;
5777
5778 default:
5779 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5780 break;
5781 }
5782
5783 if (!ffesta_is_inhibited ())
5784 {
5785 ffestc_R528_item_endvals (t);
5786 ffestc_R528_finish ();
5787 }
5788 ffelex_token_kill (ffesta_tokens[1]);
5789 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5790 }
5791
5792 /* ffestb_R5284_ -- "DATA" expr-list SLASH expr-list SLASH
5793
5794 return ffestb_R5284_; // to lexer
5795
5796 Handle [COMMA] NAME or EOS/SEMICOLON. */
5797
5798 static ffelexHandler
5799 ffestb_R5284_ (ffelexToken t)
5800 {
5801 switch (ffelex_token_type (t))
5802 {
5803 case FFELEX_typeCOMMA:
5804 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5805 FFEEXPR_contextDATA,
5806 (ffeexprCallback) ffestb_R5281_);
5807
5808 case FFELEX_typeNAME:
5809 case FFELEX_typeOPEN_PAREN:
5810 return (ffelexHandler) (*((ffelexHandler)
5811 ffeexpr_lhs (ffesta_output_pool,
5812 FFEEXPR_contextDATA,
5813 (ffeexprCallback) ffestb_R5281_)))
5814 (t);
5815
5816 case FFELEX_typeEOS:
5817 case FFELEX_typeSEMICOLON:
5818 if (!ffesta_is_inhibited ())
5819 ffestc_R528_finish ();
5820 return (ffelexHandler) ffesta_zero (t);
5821
5822 default:
5823 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5824 break;
5825 }
5826
5827 if (!ffesta_is_inhibited ())
5828 ffestc_R528_finish ();
5829 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5830 }
5831
5832 /* ffestb_R537 -- Parse a PARAMETER statement
5833
5834 return ffestb_R537; // to lexer
5835
5836 Make sure the statement has a valid form for an PARAMETER statement.
5837 If it does, implement the statement. */
5838
5839 ffelexHandler
5840 ffestb_R537 (ffelexToken t)
5841 {
5842 switch (ffelex_token_type (ffesta_tokens[0]))
5843 {
5844 case FFELEX_typeNAME:
5845 if (ffesta_first_kw != FFESTR_firstPARAMETER)
5846 goto bad_0; /* :::::::::::::::::::: */
5847 break;
5848
5849 case FFELEX_typeNAMES:
5850 if (ffesta_first_kw != FFESTR_firstPARAMETER)
5851 goto bad_0; /* :::::::::::::::::::: */
5852 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlPARAMETER)
5853 goto bad_0; /* :::::::::::::::::::: */
5854 break;
5855
5856 default:
5857 goto bad_0; /* :::::::::::::::::::: */
5858 }
5859
5860 switch (ffelex_token_type (t))
5861 {
5862 case FFELEX_typeOPEN_PAREN:
5863 break;
5864
5865 case FFELEX_typeEOS:
5866 case FFELEX_typeSEMICOLON:
5867 case FFELEX_typeCOMMA:
5868 case FFELEX_typeCOLONCOLON:
5869 ffesta_confirmed (); /* Error, but clearly intended. */
5870 goto bad_1; /* :::::::::::::::::::: */
5871
5872 default:
5873 goto bad_1; /* :::::::::::::::::::: */
5874 }
5875
5876 ffestb_local_.parameter.started = FALSE;
5877 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5878 FFEEXPR_contextPARAMETER,
5879 (ffeexprCallback) ffestb_R5371_);
5880
5881 bad_0: /* :::::::::::::::::::: */
5882 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0]);
5883 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5884
5885 bad_1: /* :::::::::::::::::::: */
5886 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
5887 return (ffelexHandler) ffelex_swallow_tokens (t,
5888 (ffelexHandler) ffesta_zero); /* Invalid second token. */
5889 }
5890
5891 /* ffestb_R5371_ -- "PARAMETER" OPEN_PAREN expr
5892
5893 (ffestb_R5371_) // to expression handler
5894
5895 Make sure the next token is EQUALS. */
5896
5897 static ffelexHandler
5898 ffestb_R5371_ (ffelexToken ft, ffebld expr, ffelexToken t)
5899 {
5900 ffestb_local_.parameter.expr = expr;
5901
5902 switch (ffelex_token_type (t))
5903 {
5904 case FFELEX_typeEQUALS:
5905 ffesta_confirmed ();
5906 if (expr == NULL)
5907 break;
5908 ffesta_tokens[1] = ffelex_token_use (ft);
5909 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
5910 FFEEXPR_contextPARAMETER, (ffeexprCallback) ffestb_R5372_);
5911
5912 default:
5913 break;
5914 }
5915
5916 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
5917 if (ffestb_local_.parameter.started)
5918 ffestc_R537_finish ();
5919 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5920 }
5921
5922 /* ffestb_R5372_ -- "PARAMETER" OPEN_PAREN expr EQUALS expr
5923
5924 (ffestb_R5372_) // to expression handler
5925
5926 Make sure the next token is COMMA or CLOSE_PAREN. */
5927
5928 static ffelexHandler
5929 ffestb_R5372_ (ffelexToken ft, ffebld expr, ffelexToken t)
5930 {
5931 switch (ffelex_token_type (t))
5932 {
5933 case FFELEX_typeCOMMA:
5934 if (expr == NULL)
5935 break;
5936 if (!ffesta_is_inhibited ())
5937 {
5938 if (!ffestb_local_.parameter.started)
5939 {
5940 ffestc_R537_start ();
5941 ffestb_local_.parameter.started = TRUE;
5942 }
5943 ffestc_R537_item (ffestb_local_.parameter.expr, ffesta_tokens[1],
5944 expr, ft);
5945 }
5946 ffelex_token_kill (ffesta_tokens[1]);
5947 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5948 FFEEXPR_contextPARAMETER,
5949 (ffeexprCallback) ffestb_R5371_);
5950
5951 case FFELEX_typeCLOSE_PAREN:
5952 if (expr == NULL)
5953 break;
5954 if (!ffesta_is_inhibited ())
5955 {
5956 if (!ffestb_local_.parameter.started)
5957 {
5958 ffestc_R537_start ();
5959 ffestb_local_.parameter.started = TRUE;
5960 }
5961 ffestc_R537_item (ffestb_local_.parameter.expr, ffesta_tokens[1],
5962 expr, ft);
5963 ffestc_R537_finish ();
5964 }
5965 ffelex_token_kill (ffesta_tokens[1]);
5966 return (ffelexHandler) ffestb_R5373_;
5967
5968 default:
5969 break;
5970 }
5971
5972 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
5973 if (ffestb_local_.parameter.started)
5974 ffestc_R537_finish ();
5975 ffelex_token_kill (ffesta_tokens[1]);
5976 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5977 }
5978
5979 /* ffestb_R5373_ -- "PARAMETER" OPEN_PAREN expr EQUALS expr CLOSE_PAREN
5980
5981 return ffestb_R5373_; // to lexer
5982
5983 Make sure the next token is EOS or SEMICOLON, or generate an error. All
5984 cleanup has already been done, by the way. */
5985
5986 static ffelexHandler
5987 ffestb_R5373_ (ffelexToken t)
5988 {
5989 switch (ffelex_token_type (t))
5990 {
5991 case FFELEX_typeEOS:
5992 case FFELEX_typeSEMICOLON:
5993 return (ffelexHandler) ffesta_zero (t);
5994
5995 default:
5996 break;
5997 }
5998
5999 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
6000 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6001 }
6002
6003 /* ffestb_R542 -- Parse the NAMELIST statement
6004
6005 return ffestb_R542; // to lexer
6006
6007 Make sure the statement has a valid form for the NAMELIST statement. If it
6008 does, implement the statement. */
6009
6010 ffelexHandler
6011 ffestb_R542 (ffelexToken t)
6012 {
6013 const char *p;
6014 ffeTokenLength i;
6015
6016 switch (ffelex_token_type (ffesta_tokens[0]))
6017 {
6018 case FFELEX_typeNAME:
6019 if (ffesta_first_kw != FFESTR_firstNAMELIST)
6020 goto bad_0; /* :::::::::::::::::::: */
6021 break;
6022
6023 case FFELEX_typeNAMES:
6024 if (ffesta_first_kw != FFESTR_firstNAMELIST)
6025 goto bad_0; /* :::::::::::::::::::: */
6026 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlNAMELIST);
6027 if (*p != '\0')
6028 goto bad_i; /* :::::::::::::::::::: */
6029 break;
6030
6031 default:
6032 goto bad_0; /* :::::::::::::::::::: */
6033 }
6034
6035 switch (ffelex_token_type (t))
6036 {
6037 case FFELEX_typeCOMMA:
6038 case FFELEX_typeEOS:
6039 case FFELEX_typeSEMICOLON:
6040 case FFELEX_typeCOLONCOLON:
6041 ffesta_confirmed (); /* Error, but clearly intended. */
6042 goto bad_1; /* :::::::::::::::::::: */
6043
6044 default:
6045 goto bad_1; /* :::::::::::::::::::: */
6046
6047 case FFELEX_typeSLASH:
6048 break;
6049 }
6050
6051 ffesta_confirmed ();
6052 if (!ffesta_is_inhibited ())
6053 ffestc_R542_start ();
6054 return (ffelexHandler) ffestb_R5421_;
6055
6056 bad_0: /* :::::::::::::::::::: */
6057 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", ffesta_tokens[0]);
6058 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6059
6060 bad_1: /* :::::::::::::::::::: */
6061 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6062 return (ffelexHandler) ffelex_swallow_tokens (t,
6063 (ffelexHandler) ffesta_zero); /* Invalid second token. */
6064
6065 bad_i: /* :::::::::::::::::::: */
6066 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "NAMELIST", ffesta_tokens[0], i, t);
6067 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6068 }
6069
6070 /* ffestb_R5421_ -- "NAMELIST" SLASH
6071
6072 return ffestb_R5421_; // to lexer
6073
6074 Handle NAME. */
6075
6076 static ffelexHandler
6077 ffestb_R5421_ (ffelexToken t)
6078 {
6079 switch (ffelex_token_type (t))
6080 {
6081 case FFELEX_typeNAME:
6082 if (!ffesta_is_inhibited ())
6083 ffestc_R542_item_nlist (t);
6084 return (ffelexHandler) ffestb_R5422_;
6085
6086 default:
6087 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6088 break;
6089 }
6090
6091 if (!ffesta_is_inhibited ())
6092 ffestc_R542_finish ();
6093 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6094 }
6095
6096 /* ffestb_R5422_ -- "NAMELIST" SLASH NAME
6097
6098 return ffestb_R5422_; // to lexer
6099
6100 Handle SLASH. */
6101
6102 static ffelexHandler
6103 ffestb_R5422_ (ffelexToken t)
6104 {
6105 switch (ffelex_token_type (t))
6106 {
6107 case FFELEX_typeSLASH:
6108 return (ffelexHandler) ffestb_R5423_;
6109
6110 default:
6111 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6112 break;
6113 }
6114
6115 if (!ffesta_is_inhibited ())
6116 ffestc_R542_finish ();
6117 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6118 }
6119
6120 /* ffestb_R5423_ -- "NAMELIST" SLASH NAME SLASH
6121
6122 return ffestb_R5423_; // to lexer
6123
6124 Handle NAME. */
6125
6126 static ffelexHandler
6127 ffestb_R5423_ (ffelexToken t)
6128 {
6129 switch (ffelex_token_type (t))
6130 {
6131 case FFELEX_typeNAME:
6132 if (!ffesta_is_inhibited ())
6133 ffestc_R542_item_nitem (t);
6134 return (ffelexHandler) ffestb_R5424_;
6135
6136 default:
6137 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6138 break;
6139 }
6140
6141 if (!ffesta_is_inhibited ())
6142 ffestc_R542_finish ();
6143 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6144 }
6145
6146 /* ffestb_R5424_ -- "NAMELIST" SLASH NAME SLASH NAME
6147
6148 return ffestb_R5424_; // to lexer
6149
6150 Handle COMMA, EOS/SEMICOLON, or SLASH. */
6151
6152 static ffelexHandler
6153 ffestb_R5424_ (ffelexToken t)
6154 {
6155 switch (ffelex_token_type (t))
6156 {
6157 case FFELEX_typeCOMMA:
6158 return (ffelexHandler) ffestb_R5425_;
6159
6160 case FFELEX_typeEOS:
6161 case FFELEX_typeSEMICOLON:
6162 if (!ffesta_is_inhibited ())
6163 ffestc_R542_finish ();
6164 return (ffelexHandler) ffesta_zero (t);
6165
6166 case FFELEX_typeSLASH:
6167 return (ffelexHandler) ffestb_R5421_;
6168
6169 default:
6170 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6171 break;
6172 }
6173
6174 if (!ffesta_is_inhibited ())
6175 ffestc_R542_finish ();
6176 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6177 }
6178
6179 /* ffestb_R5425_ -- "NAMELIST" SLASH NAME SLASH NAME COMMA
6180
6181 return ffestb_R5425_; // to lexer
6182
6183 Handle NAME or SLASH. */
6184
6185 static ffelexHandler
6186 ffestb_R5425_ (ffelexToken t)
6187 {
6188 switch (ffelex_token_type (t))
6189 {
6190 case FFELEX_typeNAME:
6191 if (!ffesta_is_inhibited ())
6192 ffestc_R542_item_nitem (t);
6193 return (ffelexHandler) ffestb_R5424_;
6194
6195 case FFELEX_typeSLASH:
6196 return (ffelexHandler) ffestb_R5421_;
6197
6198 default:
6199 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6200 break;
6201 }
6202
6203 if (!ffesta_is_inhibited ())
6204 ffestc_R542_finish ();
6205 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6206 }
6207
6208 /* ffestb_R544 -- Parse an EQUIVALENCE statement
6209
6210 return ffestb_R544; // to lexer
6211
6212 Make sure the statement has a valid form for an EQUIVALENCE statement.
6213 If it does, implement the statement. */
6214
6215 ffelexHandler
6216 ffestb_R544 (ffelexToken t)
6217 {
6218 switch (ffelex_token_type (ffesta_tokens[0]))
6219 {
6220 case FFELEX_typeNAME:
6221 if (ffesta_first_kw != FFESTR_firstEQUIVALENCE)
6222 goto bad_0; /* :::::::::::::::::::: */
6223 break;
6224
6225 case FFELEX_typeNAMES:
6226 if (ffesta_first_kw != FFESTR_firstEQUIVALENCE)
6227 goto bad_0; /* :::::::::::::::::::: */
6228 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlEQUIVALENCE)
6229 goto bad_0; /* :::::::::::::::::::: */
6230 break;
6231
6232 default:
6233 goto bad_0; /* :::::::::::::::::::: */
6234 }
6235
6236 switch (ffelex_token_type (t))
6237 {
6238 case FFELEX_typeOPEN_PAREN:
6239 break;
6240
6241 case FFELEX_typeEOS:
6242 case FFELEX_typeSEMICOLON:
6243 case FFELEX_typeCOMMA:
6244 case FFELEX_typeCOLONCOLON:
6245 ffesta_confirmed (); /* Error, but clearly intended. */
6246 goto bad_1; /* :::::::::::::::::::: */
6247
6248 default:
6249 goto bad_1; /* :::::::::::::::::::: */
6250 }
6251
6252 ffestb_local_.equivalence.started = FALSE;
6253 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6254 FFEEXPR_contextEQUIVALENCE,
6255 (ffeexprCallback) ffestb_R5441_);
6256
6257 bad_0: /* :::::::::::::::::::: */
6258 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", ffesta_tokens[0]);
6259 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6260
6261 bad_1: /* :::::::::::::::::::: */
6262 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6263 return (ffelexHandler) ffelex_swallow_tokens (t,
6264 (ffelexHandler) ffesta_zero); /* Invalid second token. */
6265 }
6266
6267 /* ffestb_R5441_ -- "EQUIVALENCE" OPEN_PAREN expr
6268
6269 (ffestb_R5441_) // to expression handler
6270
6271 Make sure the next token is COMMA. */
6272
6273 static ffelexHandler
6274 ffestb_R5441_ (ffelexToken ft, ffebld expr, ffelexToken t)
6275 {
6276 switch (ffelex_token_type (t))
6277 {
6278 case FFELEX_typeCOMMA:
6279 if (expr == NULL)
6280 break;
6281 ffestb_local_.equivalence.exprs = ffestt_exprlist_create ();
6282 ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
6283 ffelex_token_use (ft));
6284 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6285 FFEEXPR_contextEQUIVALENCE,
6286 (ffeexprCallback) ffestb_R5442_);
6287
6288 default:
6289 break;
6290 }
6291
6292 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6293 if (ffestb_local_.equivalence.started)
6294 ffestc_R544_finish ();
6295 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6296 }
6297
6298 /* ffestb_R5442_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr
6299
6300 (ffestb_R5442_) // to expression handler
6301
6302 Make sure the next token is COMMA or CLOSE_PAREN. For COMMA, we just
6303 append the expression to our list and continue; for CLOSE_PAREN, we
6304 append the expression and move to _3_. */
6305
6306 static ffelexHandler
6307 ffestb_R5442_ (ffelexToken ft, ffebld expr, ffelexToken t)
6308 {
6309 switch (ffelex_token_type (t))
6310 {
6311 case FFELEX_typeCOMMA:
6312 if (expr == NULL)
6313 break;
6314 ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
6315 ffelex_token_use (ft));
6316 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6317 FFEEXPR_contextEQUIVALENCE,
6318 (ffeexprCallback) ffestb_R5442_);
6319
6320 case FFELEX_typeCLOSE_PAREN:
6321 if (expr == NULL)
6322 break;
6323 ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
6324 ffelex_token_use (ft));
6325 return (ffelexHandler) ffestb_R5443_;
6326
6327 default:
6328 break;
6329 }
6330
6331 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6332 if (ffestb_local_.equivalence.started)
6333 ffestc_R544_finish ();
6334 ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6335 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6336 }
6337
6338 /* ffestb_R5443_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr CLOSE_PAREN
6339
6340 return ffestb_R5443_; // to lexer
6341
6342 Make sure the next token is COMMA or EOS/SEMICOLON. */
6343
6344 static ffelexHandler
6345 ffestb_R5443_ (ffelexToken t)
6346 {
6347 switch (ffelex_token_type (t))
6348 {
6349 case FFELEX_typeCOMMA:
6350 ffesta_confirmed ();
6351 if (!ffesta_is_inhibited ())
6352 {
6353 if (!ffestb_local_.equivalence.started)
6354 {
6355 ffestc_R544_start ();
6356 ffestb_local_.equivalence.started = TRUE;
6357 }
6358 ffestc_R544_item (ffestb_local_.equivalence.exprs);
6359 }
6360 ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6361 return (ffelexHandler) ffestb_R5444_;
6362
6363 case FFELEX_typeEOS:
6364 case FFELEX_typeSEMICOLON:
6365 ffesta_confirmed ();
6366 if (!ffesta_is_inhibited ())
6367 {
6368 if (!ffestb_local_.equivalence.started)
6369 {
6370 ffestc_R544_start ();
6371 ffestb_local_.equivalence.started = TRUE;
6372 }
6373 ffestc_R544_item (ffestb_local_.equivalence.exprs);
6374 ffestc_R544_finish ();
6375 }
6376 ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6377 return (ffelexHandler) ffesta_zero (t);
6378
6379 default:
6380 break;
6381 }
6382
6383 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6384 if (ffestb_local_.equivalence.started)
6385 ffestc_R544_finish ();
6386 ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6387 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6388 }
6389
6390 /* ffestb_R5444_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr CLOSE_PAREN COMMA
6391
6392 return ffestb_R5444_; // to lexer
6393
6394 Make sure the next token is OPEN_PAREN, or generate an error. */
6395
6396 static ffelexHandler
6397 ffestb_R5444_ (ffelexToken t)
6398 {
6399 switch (ffelex_token_type (t))
6400 {
6401 case FFELEX_typeOPEN_PAREN:
6402 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6403 FFEEXPR_contextEQUIVALENCE,
6404 (ffeexprCallback) ffestb_R5441_);
6405
6406 default:
6407 break;
6408 }
6409
6410 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6411 if (ffestb_local_.equivalence.started)
6412 ffestc_R544_finish ();
6413 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6414 }
6415
6416 /* ffestb_R834 -- Parse the CYCLE statement
6417
6418 return ffestb_R834; // to lexer
6419
6420 Make sure the statement has a valid form for the CYCLE statement. If
6421 it does, implement the statement. */
6422
6423 ffelexHandler
6424 ffestb_R834 (ffelexToken t)
6425 {
6426 ffeTokenLength i;
6427 unsigned const char *p;
6428
6429 switch (ffelex_token_type (ffesta_tokens[0]))
6430 {
6431 case FFELEX_typeNAME:
6432 if (ffesta_first_kw != FFESTR_firstCYCLE)
6433 goto bad_0; /* :::::::::::::::::::: */
6434 switch (ffelex_token_type (t))
6435 {
6436 case FFELEX_typeCOMMA:
6437 case FFELEX_typeCOLONCOLON:
6438 ffesta_confirmed (); /* Error, but clearly intended. */
6439 goto bad_1; /* :::::::::::::::::::: */
6440
6441 default:
6442 goto bad_1; /* :::::::::::::::::::: */
6443
6444 case FFELEX_typeNAME:
6445 ffesta_confirmed ();
6446 ffesta_tokens[1] = ffelex_token_use (t);
6447 return (ffelexHandler) ffestb_R8341_;
6448
6449 case FFELEX_typeEOS:
6450 case FFELEX_typeSEMICOLON:
6451 ffesta_confirmed ();
6452 ffesta_tokens[1] = NULL;
6453 return (ffelexHandler) ffestb_R8341_ (t);
6454 }
6455
6456 case FFELEX_typeNAMES:
6457 if (ffesta_first_kw != FFESTR_firstCYCLE)
6458 goto bad_0; /* :::::::::::::::::::: */
6459 switch (ffelex_token_type (t))
6460 {
6461 default:
6462 goto bad_1; /* :::::::::::::::::::: */
6463
6464 case FFELEX_typeEOS:
6465 case FFELEX_typeSEMICOLON:
6466 break;
6467 }
6468 ffesta_confirmed ();
6469 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCYCLE);
6470 if (*p == '\0')
6471 {
6472 ffesta_tokens[1] = NULL;
6473 }
6474 else
6475 {
6476 if (!ffesrc_is_name_init (*p))
6477 goto bad_i; /* :::::::::::::::::::: */
6478 ffesta_tokens[1]
6479 = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
6480 }
6481 return (ffelexHandler) ffestb_R8341_ (t);
6482
6483 default:
6484 goto bad_0; /* :::::::::::::::::::: */
6485 }
6486
6487 bad_0: /* :::::::::::::::::::: */
6488 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", ffesta_tokens[0]);
6489 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6490
6491 bad_1: /* :::::::::::::::::::: */
6492 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", t);
6493 return (ffelexHandler) ffelex_swallow_tokens (t,
6494 (ffelexHandler) ffesta_zero); /* Invalid second token. */
6495
6496 bad_i: /* :::::::::::::::::::: */
6497 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CYCLE", ffesta_tokens[0], i, t);
6498 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6499 }
6500
6501 /* ffestb_R8341_ -- "CYCLE" [NAME]
6502
6503 return ffestb_R8341_; // to lexer
6504
6505 Make sure the next token is an EOS or SEMICOLON. */
6506
6507 static ffelexHandler
6508 ffestb_R8341_ (ffelexToken t)
6509 {
6510 switch (ffelex_token_type (t))
6511 {
6512 case FFELEX_typeEOS:
6513 case FFELEX_typeSEMICOLON:
6514 ffesta_confirmed ();
6515 if (!ffesta_is_inhibited ())
6516 ffestc_R834 (ffesta_tokens[1]);
6517 if (ffesta_tokens[1] != NULL)
6518 ffelex_token_kill (ffesta_tokens[1]);
6519 return (ffelexHandler) ffesta_zero (t);
6520
6521 default:
6522 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", t);
6523 break;
6524 }
6525
6526 if (ffesta_tokens[1] != NULL)
6527 ffelex_token_kill (ffesta_tokens[1]);
6528 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6529 }
6530
6531 /* ffestb_R835 -- Parse the EXIT statement
6532
6533 return ffestb_R835; // to lexer
6534
6535 Make sure the statement has a valid form for the EXIT statement. If
6536 it does, implement the statement. */
6537
6538 ffelexHandler
6539 ffestb_R835 (ffelexToken t)
6540 {
6541 ffeTokenLength i;
6542 unsigned const char *p;
6543
6544 switch (ffelex_token_type (ffesta_tokens[0]))
6545 {
6546 case FFELEX_typeNAME:
6547 if (ffesta_first_kw != FFESTR_firstEXIT)
6548 goto bad_0; /* :::::::::::::::::::: */
6549 switch (ffelex_token_type (t))
6550 {
6551 case FFELEX_typeCOMMA:
6552 case FFELEX_typeCOLONCOLON:
6553 ffesta_confirmed (); /* Error, but clearly intended. */
6554 goto bad_1; /* :::::::::::::::::::: */
6555
6556 default:
6557 goto bad_1; /* :::::::::::::::::::: */
6558
6559 case FFELEX_typeNAME:
6560 ffesta_confirmed ();
6561 ffesta_tokens[1] = ffelex_token_use (t);
6562 return (ffelexHandler) ffestb_R8351_;
6563
6564 case FFELEX_typeEOS:
6565 case FFELEX_typeSEMICOLON:
6566 ffesta_confirmed ();
6567 ffesta_tokens[1] = NULL;
6568 return (ffelexHandler) ffestb_R8351_ (t);
6569 }
6570
6571 case FFELEX_typeNAMES:
6572 if (ffesta_first_kw != FFESTR_firstEXIT)
6573 goto bad_0; /* :::::::::::::::::::: */
6574 switch (ffelex_token_type (t))
6575 {
6576 default:
6577 goto bad_1; /* :::::::::::::::::::: */
6578
6579 case FFELEX_typeEOS:
6580 case FFELEX_typeSEMICOLON:
6581 break;
6582 }
6583 ffesta_confirmed ();
6584 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlEXIT);
6585 if (*p == '\0')
6586 {
6587 ffesta_tokens[1] = NULL;
6588 }
6589 else
6590 {
6591 if (!ffesrc_is_name_init (*p))
6592 goto bad_i; /* :::::::::::::::::::: */
6593 ffesta_tokens[1]
6594 = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
6595 }
6596 return (ffelexHandler) ffestb_R8351_ (t);
6597
6598 default:
6599 goto bad_0; /* :::::::::::::::::::: */
6600 }
6601
6602 bad_0: /* :::::::::::::::::::: */
6603 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", ffesta_tokens[0]);
6604 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6605
6606 bad_1: /* :::::::::::::::::::: */
6607 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", t);
6608 return (ffelexHandler) ffelex_swallow_tokens (t,
6609 (ffelexHandler) ffesta_zero); /* Invalid second token. */
6610
6611 bad_i: /* :::::::::::::::::::: */
6612 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "EXIT", ffesta_tokens[0], i, t);
6613 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6614 }
6615
6616 /* ffestb_R8351_ -- "EXIT" [NAME]
6617
6618 return ffestb_R8351_; // to lexer
6619
6620 Make sure the next token is an EOS or SEMICOLON. */
6621
6622 static ffelexHandler
6623 ffestb_R8351_ (ffelexToken t)
6624 {
6625 switch (ffelex_token_type (t))
6626 {
6627 case FFELEX_typeEOS:
6628 case FFELEX_typeSEMICOLON:
6629 ffesta_confirmed ();
6630 if (!ffesta_is_inhibited ())
6631 ffestc_R835 (ffesta_tokens[1]);
6632 if (ffesta_tokens[1] != NULL)
6633 ffelex_token_kill (ffesta_tokens[1]);
6634 return (ffelexHandler) ffesta_zero (t);
6635
6636 default:
6637 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", t);
6638 break;
6639 }
6640
6641 if (ffesta_tokens[1] != NULL)
6642 ffelex_token_kill (ffesta_tokens[1]);
6643 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6644 }
6645
6646 /* ffestb_R838 -- Parse the ASSIGN statement
6647
6648 return ffestb_R838; // to lexer
6649
6650 Make sure the statement has a valid form for the ASSIGN statement. If it
6651 does, implement the statement. */
6652
6653 ffelexHandler
6654 ffestb_R838 (ffelexToken t)
6655 {
6656 unsigned const char *p;
6657 ffeTokenLength i;
6658 ffelexHandler next;
6659 ffelexToken et; /* First token in target. */
6660
6661 switch (ffelex_token_type (ffesta_tokens[0]))
6662 {
6663 case FFELEX_typeNAME:
6664 if (ffesta_first_kw != FFESTR_firstASSIGN)
6665 goto bad_0; /* :::::::::::::::::::: */
6666 switch (ffelex_token_type (t))
6667 {
6668 case FFELEX_typeEOS:
6669 case FFELEX_typeSEMICOLON:
6670 case FFELEX_typeCOMMA:
6671 case FFELEX_typeCOLONCOLON:
6672 ffesta_confirmed (); /* Error, but clearly intended. */
6673 goto bad_1; /* :::::::::::::::::::: */
6674
6675 default:
6676 goto bad_1; /* :::::::::::::::::::: */
6677
6678 case FFELEX_typeNUMBER:
6679 break;
6680 }
6681 ffesta_tokens[1] = ffelex_token_use (t);
6682 ffesta_confirmed ();
6683 return (ffelexHandler) ffestb_R8381_;
6684
6685 case FFELEX_typeNAMES:
6686 if (ffesta_first_kw != FFESTR_firstASSIGN)
6687 goto bad_0; /* :::::::::::::::::::: */
6688
6689 switch (ffelex_token_type (t))
6690 {
6691 case FFELEX_typeEOS:
6692 case FFELEX_typeSEMICOLON:
6693 ffesta_confirmed ();
6694 /* Fall through. */
6695 case FFELEX_typePERCENT:
6696 case FFELEX_typeOPEN_PAREN:
6697 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlASSIGN);
6698 if (! ISDIGIT (*p))
6699 goto bad_i; /* :::::::::::::::::::: */
6700 ffesta_tokens[1]
6701 = ffelex_token_number_from_names (ffesta_tokens[0], i);
6702 p += ffelex_token_length (ffesta_tokens[1]); /* Skip to "TO". */
6703 i += ffelex_token_length (ffesta_tokens[1]);
6704 if (!ffesrc_char_match_init (*p, 'T', 't') /* "TO". */
6705 || (++i, !ffesrc_char_match_noninit (*++p, 'O', 'o')))
6706 {
6707 bad_i_1: /* :::::::::::::::::::: */
6708 ffelex_token_kill (ffesta_tokens[1]);
6709 goto bad_i; /* :::::::::::::::::::: */
6710 }
6711 ++p, ++i;
6712 if (!ffesrc_is_name_init (*p))
6713 goto bad_i_1; /* :::::::::::::::::::: */
6714 et = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
6715 next = (ffelexHandler)
6716 (*((ffelexHandler)
6717 ffeexpr_lhs (ffesta_output_pool,
6718 FFEEXPR_contextASSIGN,
6719 (ffeexprCallback)
6720 ffestb_R8383_)))
6721 (et);
6722 ffelex_token_kill (et);
6723 return (ffelexHandler) (*next) (t);
6724
6725 case FFELEX_typeCOMMA:
6726 case FFELEX_typeCOLONCOLON:
6727 ffesta_confirmed (); /* Error, but clearly intended. */
6728 goto bad_1; /* :::::::::::::::::::: */
6729
6730 default:
6731 goto bad_1; /* :::::::::::::::::::: */
6732 }
6733
6734 default:
6735 goto bad_0; /* :::::::::::::::::::: */
6736 }
6737
6738 bad_0: /* :::::::::::::::::::: */
6739 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", ffesta_tokens[0]);
6740 return (ffelexHandler) ffelex_swallow_tokens (t,
6741 (ffelexHandler) ffesta_zero); /* Invalid first token. */
6742
6743 bad_1: /* :::::::::::::::::::: */
6744 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6745 return (ffelexHandler) ffelex_swallow_tokens (t,
6746 (ffelexHandler) ffesta_zero); /* Invalid second token. */
6747
6748 bad_i: /* :::::::::::::::::::: */
6749 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ASSIGN", ffesta_tokens[0], i, t);
6750 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6751 }
6752
6753 /* ffestb_R8381_ -- "ASSIGN" NUMBER
6754
6755 return ffestb_R8381_; // to lexer
6756
6757 Make sure the next token is "TO". */
6758
6759 static ffelexHandler
6760 ffestb_R8381_ (ffelexToken t)
6761 {
6762 if ((ffelex_token_type (t) == FFELEX_typeNAME)
6763 && (ffesrc_strcmp_2c (ffe_case_match (), ffelex_token_text (t), "TO", "to",
6764 "To") == 0))
6765 {
6766 return (ffelexHandler) ffestb_R8382_;
6767 }
6768
6769 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6770 if (ffelex_token_type (t) == FFELEX_typeNAME)
6771 return (ffelexHandler) ffestb_R8382_ (t); /* Maybe user forgot "TO". */
6772
6773 ffelex_token_kill (ffesta_tokens[1]);
6774 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6775 }
6776
6777 /* ffestb_R8382_ -- "ASSIGN" NUMBER ("TO")
6778
6779 return ffestb_R8382_; // to lexer
6780
6781 Make sure the next token is a name, then pass it along to the expression
6782 evaluator as an LHS expression. The callback function is _3_. */
6783
6784 static ffelexHandler
6785 ffestb_R8382_ (ffelexToken t)
6786 {
6787 if (ffelex_token_type (t) == FFELEX_typeNAME)
6788 {
6789 return (ffelexHandler)
6790 (*((ffelexHandler)
6791 ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextASSIGN,
6792 (ffeexprCallback) ffestb_R8383_)))
6793 (t);
6794 }
6795
6796 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6797 ffelex_token_kill (ffesta_tokens[1]);
6798 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6799 }
6800
6801 /* ffestb_R8383_ -- "ASSIGN" NUMBER ("TO") expression
6802
6803 (ffestb_R8383_) // to expression handler
6804
6805 Make sure the next token is an EOS or SEMICOLON. */
6806
6807 static ffelexHandler
6808 ffestb_R8383_ (ffelexToken ft, ffebld expr, ffelexToken t)
6809 {
6810 switch (ffelex_token_type (t))
6811 {
6812 case FFELEX_typeEOS:
6813 case FFELEX_typeSEMICOLON:
6814 ffesta_confirmed ();
6815 if (expr == NULL)
6816 break;
6817 if (!ffesta_is_inhibited ())
6818 ffestc_R838 (ffesta_tokens[1], expr, ft);
6819 ffelex_token_kill (ffesta_tokens[1]);
6820 return (ffelexHandler) ffesta_zero (t);
6821
6822 default:
6823 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6824 break;
6825 }
6826
6827 ffelex_token_kill (ffesta_tokens[1]);
6828 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6829 }
6830
6831 /* ffestb_R840 -- Parse an arithmetic-IF statement
6832
6833 return ffestb_R840; // to lexer
6834
6835 Make sure the statement has a valid form for an arithmetic-IF statement.
6836 If it does, implement the statement. */
6837
6838 ffelexHandler
6839 ffestb_R840 (ffelexToken t)
6840 {
6841 switch (ffelex_token_type (ffesta_tokens[0]))
6842 {
6843 case FFELEX_typeNAME:
6844 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlIF)
6845 goto bad_0; /* :::::::::::::::::::: */
6846 if (ffesta_first_kw != FFESTR_firstIF)
6847 goto bad_0; /* :::::::::::::::::::: */
6848 break;
6849
6850 case FFELEX_typeNAMES:
6851 if (ffesta_first_kw != FFESTR_firstIF)
6852 goto bad_0; /* :::::::::::::::::::: */
6853 break;
6854
6855 default:
6856 goto bad_0; /* :::::::::::::::::::: */
6857 }
6858
6859 switch (ffelex_token_type (t))
6860 {
6861 case FFELEX_typeOPEN_PAREN:
6862 break;
6863
6864 default:
6865 goto bad_1; /* :::::::::::::::::::: */
6866 }
6867
6868 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextARITHIF,
6869 (ffeexprCallback) ffestb_R8401_);
6870
6871 bad_0: /* :::::::::::::::::::: */
6872 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", ffesta_tokens[0]);
6873 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6874
6875 bad_1: /* :::::::::::::::::::: */
6876 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6877 return (ffelexHandler) ffelex_swallow_tokens (t,
6878 (ffelexHandler) ffesta_zero); /* Invalid second token. */
6879 }
6880
6881 /* ffestb_R8401_ -- "IF" OPEN_PAREN expr
6882
6883 (ffestb_R8401_) // to expression handler
6884
6885 Make sure the next token is CLOSE_PAREN. */
6886
6887 static ffelexHandler
6888 ffestb_R8401_ (ffelexToken ft, ffebld expr, ffelexToken t)
6889 {
6890 ffestb_local_.if_stmt.expr = expr;
6891
6892 switch (ffelex_token_type (t))
6893 {
6894 case FFELEX_typeCLOSE_PAREN:
6895 if (expr == NULL)
6896 break;
6897 ffesta_tokens[1] = ffelex_token_use (ft);
6898 ffelex_set_names (TRUE); /* In case it's a logical IF instead. */
6899 return (ffelexHandler) ffestb_R8402_;
6900
6901 default:
6902 break;
6903 }
6904
6905 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6906 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6907 }
6908
6909 /* ffestb_R8402_ -- "IF" OPEN_PAREN expr CLOSE_PAREN
6910
6911 return ffestb_R8402_; // to lexer
6912
6913 Make sure the next token is NUMBER. */
6914
6915 static ffelexHandler
6916 ffestb_R8402_ (ffelexToken t)
6917 {
6918 ffelex_set_names (FALSE);
6919
6920 switch (ffelex_token_type (t))
6921 {
6922 case FFELEX_typeNUMBER:
6923 ffesta_confirmed ();
6924 ffesta_tokens[2] = ffelex_token_use (t);
6925 return (ffelexHandler) ffestb_R8403_;
6926
6927 default:
6928 break;
6929 }
6930
6931 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6932 ffelex_token_kill (ffesta_tokens[1]);
6933 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6934 }
6935
6936 /* ffestb_R8403_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER
6937
6938 return ffestb_R8403_; // to lexer
6939
6940 Make sure the next token is COMMA. */
6941
6942 static ffelexHandler
6943 ffestb_R8403_ (ffelexToken t)
6944 {
6945 switch (ffelex_token_type (t))
6946 {
6947 case FFELEX_typeCOMMA:
6948 return (ffelexHandler) ffestb_R8404_;
6949
6950 default:
6951 break;
6952 }
6953
6954 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6955 ffelex_token_kill (ffesta_tokens[1]);
6956 ffelex_token_kill (ffesta_tokens[2]);
6957 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6958 }
6959
6960 /* ffestb_R8404_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA
6961
6962 return ffestb_R8404_; // to lexer
6963
6964 Make sure the next token is NUMBER. */
6965
6966 static ffelexHandler
6967 ffestb_R8404_ (ffelexToken t)
6968 {
6969 switch (ffelex_token_type (t))
6970 {
6971 case FFELEX_typeNUMBER:
6972 ffesta_tokens[3] = ffelex_token_use (t);
6973 return (ffelexHandler) ffestb_R8405_;
6974
6975 default:
6976 break;
6977 }
6978
6979 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6980 ffelex_token_kill (ffesta_tokens[1]);
6981 ffelex_token_kill (ffesta_tokens[2]);
6982 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6983 }
6984
6985 /* ffestb_R8405_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER
6986
6987 return ffestb_R8405_; // to lexer
6988
6989 Make sure the next token is COMMA. */
6990
6991 static ffelexHandler
6992 ffestb_R8405_ (ffelexToken t)
6993 {
6994 switch (ffelex_token_type (t))
6995 {
6996 case FFELEX_typeCOMMA:
6997 return (ffelexHandler) ffestb_R8406_;
6998
6999 default:
7000 break;
7001 }
7002
7003 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
7004 ffelex_token_kill (ffesta_tokens[1]);
7005 ffelex_token_kill (ffesta_tokens[2]);
7006 ffelex_token_kill (ffesta_tokens[3]);
7007 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7008 }
7009
7010 /* ffestb_R8406_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER COMMA
7011
7012 return ffestb_R8406_; // to lexer
7013
7014 Make sure the next token is NUMBER. */
7015
7016 static ffelexHandler
7017 ffestb_R8406_ (ffelexToken t)
7018 {
7019 switch (ffelex_token_type (t))
7020 {
7021 case FFELEX_typeNUMBER:
7022 ffesta_tokens[4] = ffelex_token_use (t);
7023 return (ffelexHandler) ffestb_R8407_;
7024
7025 default:
7026 break;
7027 }
7028
7029 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
7030 ffelex_token_kill (ffesta_tokens[1]);
7031 ffelex_token_kill (ffesta_tokens[2]);
7032 ffelex_token_kill (ffesta_tokens[3]);
7033 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7034 }
7035
7036 /* ffestb_R8407_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER COMMA
7037 NUMBER
7038
7039 return ffestb_R8407_; // to lexer
7040
7041 Make sure the next token is EOS or SEMICOLON. */
7042
7043 static ffelexHandler
7044 ffestb_R8407_ (ffelexToken t)
7045 {
7046 switch (ffelex_token_type (t))
7047 {
7048 case FFELEX_typeEOS:
7049 case FFELEX_typeSEMICOLON:
7050 if (!ffesta_is_inhibited ())
7051 ffestc_R840 (ffestb_local_.if_stmt.expr, ffesta_tokens[1],
7052 ffesta_tokens[2], ffesta_tokens[3], ffesta_tokens[4]);
7053 ffelex_token_kill (ffesta_tokens[1]);
7054 ffelex_token_kill (ffesta_tokens[2]);
7055 ffelex_token_kill (ffesta_tokens[3]);
7056 ffelex_token_kill (ffesta_tokens[4]);
7057 return (ffelexHandler) ffesta_zero (t);
7058
7059 default:
7060 break;
7061 }
7062
7063 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
7064 ffelex_token_kill (ffesta_tokens[1]);
7065 ffelex_token_kill (ffesta_tokens[2]);
7066 ffelex_token_kill (ffesta_tokens[3]);
7067 ffelex_token_kill (ffesta_tokens[4]);
7068 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7069 }
7070
7071 /* ffestb_R841 -- Parse the CONTINUE statement
7072
7073 return ffestb_R841; // to lexer
7074
7075 Make sure the statement has a valid form for the CONTINUE statement. If
7076 it does, implement the statement. */
7077
7078 ffelexHandler
7079 ffestb_R841 (ffelexToken t)
7080 {
7081 const char *p;
7082 ffeTokenLength i;
7083
7084 switch (ffelex_token_type (ffesta_tokens[0]))
7085 {
7086 case FFELEX_typeNAME:
7087 if (ffesta_first_kw != FFESTR_firstCONTINUE)
7088 goto bad_0; /* :::::::::::::::::::: */
7089 break;
7090
7091 case FFELEX_typeNAMES:
7092 if (ffesta_first_kw != FFESTR_firstCONTINUE)
7093 goto bad_0; /* :::::::::::::::::::: */
7094 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCONTINUE)
7095 {
7096 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCONTINUE);
7097 goto bad_i; /* :::::::::::::::::::: */
7098 }
7099 break;
7100
7101 default:
7102 goto bad_0; /* :::::::::::::::::::: */
7103 }
7104
7105 switch (ffelex_token_type (t))
7106 {
7107 case FFELEX_typeEOS:
7108 case FFELEX_typeSEMICOLON:
7109 ffesta_confirmed ();
7110 if (!ffesta_is_inhibited ())
7111 ffestc_R841 ();
7112 return (ffelexHandler) ffesta_zero (t);
7113
7114 case FFELEX_typeCOMMA:
7115 case FFELEX_typeCOLONCOLON:
7116 ffesta_confirmed (); /* Error, but clearly intended. */
7117 goto bad_1; /* :::::::::::::::::::: */
7118
7119 default:
7120 goto bad_1; /* :::::::::::::::::::: */
7121 }
7122
7123 bad_0: /* :::::::::::::::::::: */
7124 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTINUE", ffesta_tokens[0]);
7125 return (ffelexHandler) ffelex_swallow_tokens (t,
7126 (ffelexHandler) ffesta_zero); /* Invalid first token. */
7127
7128 bad_1: /* :::::::::::::::::::: */
7129 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTINUE", t);
7130 return (ffelexHandler) ffelex_swallow_tokens (t,
7131 (ffelexHandler) ffesta_zero); /* Invalid second token. */
7132
7133 bad_i: /* :::::::::::::::::::: */
7134 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CONTINUE", ffesta_tokens[0], i, t);
7135 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7136 }
7137
7138 /* ffestb_R1102 -- Parse the PROGRAM statement
7139
7140 return ffestb_R1102; // to lexer
7141
7142 Make sure the statement has a valid form for the PROGRAM statement. If it
7143 does, implement the statement. */
7144
7145 ffelexHandler
7146 ffestb_R1102 (ffelexToken t)
7147 {
7148 ffeTokenLength i;
7149 unsigned const char *p;
7150
7151 switch (ffelex_token_type (ffesta_tokens[0]))
7152 {
7153 case FFELEX_typeNAME:
7154 if (ffesta_first_kw != FFESTR_firstPROGRAM)
7155 goto bad_0; /* :::::::::::::::::::: */
7156 switch (ffelex_token_type (t))
7157 {
7158 case FFELEX_typeEOS:
7159 case FFELEX_typeSEMICOLON:
7160 case FFELEX_typeCOMMA:
7161 case FFELEX_typeCOLONCOLON:
7162 ffesta_confirmed (); /* Error, but clearly intended. */
7163 goto bad_1; /* :::::::::::::::::::: */
7164
7165 default:
7166 goto bad_1; /* :::::::::::::::::::: */
7167
7168 case FFELEX_typeNAME:
7169 break;
7170 }
7171
7172 ffesta_confirmed ();
7173 ffesta_tokens[1] = ffelex_token_use (t);
7174 return (ffelexHandler) ffestb_R11021_;
7175
7176 case FFELEX_typeNAMES:
7177 if (ffesta_first_kw != FFESTR_firstPROGRAM)
7178 goto bad_0; /* :::::::::::::::::::: */
7179 switch (ffelex_token_type (t))
7180 {
7181 case FFELEX_typeCOMMA:
7182 case FFELEX_typeCOLONCOLON:
7183 ffesta_confirmed (); /* Error, but clearly intended. */
7184 goto bad_1; /* :::::::::::::::::::: */
7185
7186 default:
7187 goto bad_1; /* :::::::::::::::::::: */
7188
7189 case FFELEX_typeEOS:
7190 case FFELEX_typeSEMICOLON:
7191 break;
7192 }
7193 ffesta_confirmed ();
7194 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlPROGRAM);
7195 if (!ffesrc_is_name_init (*p))
7196 goto bad_i; /* :::::::::::::::::::: */
7197 ffesta_tokens[1]
7198 = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
7199 return (ffelexHandler) ffestb_R11021_ (t);
7200
7201 default:
7202 goto bad_0; /* :::::::::::::::::::: */
7203 }
7204
7205 bad_0: /* :::::::::::::::::::: */
7206 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", ffesta_tokens[0]);
7207 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7208
7209 bad_1: /* :::::::::::::::::::: */
7210 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", t);
7211 return (ffelexHandler) ffelex_swallow_tokens (t,
7212 (ffelexHandler) ffesta_zero); /* Invalid second token. */
7213
7214 bad_i: /* :::::::::::::::::::: */
7215 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "PROGRAM", ffesta_tokens[0], i, t);
7216 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7217 }
7218
7219 /* ffestb_R11021_ -- "PROGRAM" NAME
7220
7221 return ffestb_R11021_; // to lexer
7222
7223 Make sure the next token is an EOS or SEMICOLON. */
7224
7225 static ffelexHandler
7226 ffestb_R11021_ (ffelexToken t)
7227 {
7228 switch (ffelex_token_type (t))
7229 {
7230 case FFELEX_typeEOS:
7231 case FFELEX_typeSEMICOLON:
7232 ffesta_confirmed ();
7233 if (!ffesta_is_inhibited ())
7234 ffestc_R1102 (ffesta_tokens[1]);
7235 ffelex_token_kill (ffesta_tokens[1]);
7236 return (ffelexHandler) ffesta_zero (t);
7237
7238 default:
7239 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", t);
7240 break;
7241 }
7242
7243 ffelex_token_kill (ffesta_tokens[1]);
7244 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7245 }
7246
7247 /* ffestb_block -- Parse the BLOCK DATA statement
7248
7249 return ffestb_block; // to lexer
7250
7251 Make sure the statement has a valid form for the BLOCK DATA statement. If
7252 it does, implement the statement. */
7253
7254 ffelexHandler
7255 ffestb_block (ffelexToken t)
7256 {
7257 switch (ffelex_token_type (ffesta_tokens[0]))
7258 {
7259 case FFELEX_typeNAME:
7260 if (ffesta_first_kw != FFESTR_firstBLOCK)
7261 goto bad_0; /* :::::::::::::::::::: */
7262 switch (ffelex_token_type (t))
7263 {
7264 default:
7265 goto bad_1; /* :::::::::::::::::::: */
7266
7267 case FFELEX_typeNAME:
7268 if (ffesta_second_kw != FFESTR_secondDATA)
7269 goto bad_1; /* :::::::::::::::::::: */
7270 break;
7271 }
7272
7273 ffesta_confirmed ();
7274 return (ffelexHandler) ffestb_R1111_1_;
7275
7276 default:
7277 goto bad_0; /* :::::::::::::::::::: */
7278 }
7279
7280 bad_0: /* :::::::::::::::::::: */
7281 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0]);
7282 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7283
7284 bad_1: /* :::::::::::::::::::: */
7285 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7286 return (ffelexHandler) ffelex_swallow_tokens (t,
7287 (ffelexHandler) ffesta_zero); /* Invalid second token. */
7288 }
7289
7290 /* ffestb_blockdata -- Parse the BLOCKDATA statement
7291
7292 return ffestb_blockdata; // to lexer
7293
7294 Make sure the statement has a valid form for the BLOCKDATA statement. If
7295 it does, implement the statement. */
7296
7297 ffelexHandler
7298 ffestb_blockdata (ffelexToken t)
7299 {
7300 ffeTokenLength i;
7301 unsigned const char *p;
7302
7303 switch (ffelex_token_type (ffesta_tokens[0]))
7304 {
7305 case FFELEX_typeNAME:
7306 if (ffesta_first_kw != FFESTR_firstBLOCKDATA)
7307 goto bad_0; /* :::::::::::::::::::: */
7308 switch (ffelex_token_type (t))
7309 {
7310 case FFELEX_typeCOMMA:
7311 case FFELEX_typeCOLONCOLON:
7312 ffesta_confirmed (); /* Error, but clearly intended. */
7313 goto bad_1; /* :::::::::::::::::::: */
7314
7315 default:
7316 goto bad_1; /* :::::::::::::::::::: */
7317
7318 case FFELEX_typeNAME:
7319 ffesta_confirmed ();
7320 ffesta_tokens[1] = ffelex_token_use (t);
7321 return (ffelexHandler) ffestb_R1111_2_;
7322
7323 case FFELEX_typeEOS:
7324 case FFELEX_typeSEMICOLON:
7325 ffesta_confirmed ();
7326 ffesta_tokens[1] = NULL;
7327 return (ffelexHandler) ffestb_R1111_2_ (t);
7328 }
7329
7330 case FFELEX_typeNAMES:
7331 if (ffesta_first_kw != FFESTR_firstBLOCKDATA)
7332 goto bad_0; /* :::::::::::::::::::: */
7333 switch (ffelex_token_type (t))
7334 {
7335 default:
7336 goto bad_1; /* :::::::::::::::::::: */
7337
7338 case FFELEX_typeEOS:
7339 case FFELEX_typeSEMICOLON:
7340 break;
7341 }
7342 ffesta_confirmed ();
7343 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlBLOCKDATA);
7344 if (*p == '\0')
7345 {
7346 ffesta_tokens[1] = NULL;
7347 }
7348 else
7349 {
7350 if (!ffesrc_is_name_init (*p))
7351 goto bad_i; /* :::::::::::::::::::: */
7352 ffesta_tokens[1]
7353 = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
7354 }
7355 return (ffelexHandler) ffestb_R1111_2_ (t);
7356
7357 default:
7358 goto bad_0; /* :::::::::::::::::::: */
7359 }
7360
7361 bad_0: /* :::::::::::::::::::: */
7362 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0]);
7363 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7364
7365 bad_1: /* :::::::::::::::::::: */
7366 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7367 return (ffelexHandler) ffelex_swallow_tokens (t,
7368 (ffelexHandler) ffesta_zero); /* Invalid second token. */
7369
7370 bad_i: /* :::::::::::::::::::: */
7371 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0], i, t);
7372 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7373 }
7374
7375 /* ffestb_R1111_1_ -- "BLOCK" "DATA"
7376
7377 return ffestb_R1111_1_; // to lexer
7378
7379 Make sure the next token is a NAME, EOS, or SEMICOLON token. */
7380
7381 static ffelexHandler
7382 ffestb_R1111_1_ (ffelexToken t)
7383 {
7384 switch (ffelex_token_type (t))
7385 {
7386 case FFELEX_typeNAME:
7387 ffesta_tokens[1] = ffelex_token_use (t);
7388 return (ffelexHandler) ffestb_R1111_2_;
7389
7390 case FFELEX_typeEOS:
7391 case FFELEX_typeSEMICOLON:
7392 ffesta_tokens[1] = NULL;
7393 return (ffelexHandler) ffestb_R1111_2_ (t);
7394
7395 default:
7396 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7397 break;
7398 }
7399
7400 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7401 }
7402
7403 /* ffestb_R1111_2_ -- "BLOCK/DATA" NAME
7404
7405 return ffestb_R1111_2_; // to lexer
7406
7407 Make sure the next token is an EOS or SEMICOLON. */
7408
7409 static ffelexHandler
7410 ffestb_R1111_2_ (ffelexToken t)
7411 {
7412 switch (ffelex_token_type (t))
7413 {
7414 case FFELEX_typeEOS:
7415 case FFELEX_typeSEMICOLON:
7416 ffesta_confirmed ();
7417 if (!ffesta_is_inhibited ())
7418 ffestc_R1111 (ffesta_tokens[1]);
7419 if (ffesta_tokens[1] != NULL)
7420 ffelex_token_kill (ffesta_tokens[1]);
7421 return (ffelexHandler) ffesta_zero (t);
7422
7423 default:
7424 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7425 break;
7426 }
7427
7428 if (ffesta_tokens[1] != NULL)
7429 ffelex_token_kill (ffesta_tokens[1]);
7430 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7431 }
7432
7433 /* ffestb_R1212 -- Parse the CALL statement
7434
7435 return ffestb_R1212; // to lexer
7436
7437 Make sure the statement has a valid form for the CALL statement. If it
7438 does, implement the statement. */
7439
7440 ffelexHandler
7441 ffestb_R1212 (ffelexToken t)
7442 {
7443 ffeTokenLength i;
7444 unsigned const char *p;
7445 ffelexHandler next;
7446 ffelexToken nt;
7447
7448 switch (ffelex_token_type (ffesta_tokens[0]))
7449 {
7450 case FFELEX_typeNAME:
7451 if (ffesta_first_kw != FFESTR_firstCALL)
7452 goto bad_0; /* :::::::::::::::::::: */
7453 switch (ffelex_token_type (t))
7454 {
7455 case FFELEX_typeEOS:
7456 case FFELEX_typeSEMICOLON:
7457 case FFELEX_typeCOMMA:
7458 case FFELEX_typeCOLONCOLON:
7459 ffesta_confirmed (); /* Error, but clearly intended. */
7460 goto bad_1; /* :::::::::::::::::::: */
7461
7462 default:
7463 goto bad_1; /* :::::::::::::::::::: */
7464
7465 case FFELEX_typeNAME:
7466 break;
7467 }
7468 ffesta_confirmed ();
7469 return (ffelexHandler)
7470 (*((ffelexHandler)
7471 ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextSUBROUTINEREF,
7472 (ffeexprCallback) ffestb_R12121_)))
7473 (t);
7474
7475 case FFELEX_typeNAMES:
7476 if (ffesta_first_kw != FFESTR_firstCALL)
7477 goto bad_0; /* :::::::::::::::::::: */
7478 switch (ffelex_token_type (t))
7479 {
7480 case FFELEX_typeCOLONCOLON:
7481 case FFELEX_typeCOMMA:
7482 ffesta_confirmed (); /* Error, but clearly intended. */
7483 goto bad_1; /* :::::::::::::::::::: */
7484
7485 default:
7486 goto bad_1; /* :::::::::::::::::::: */
7487
7488 case FFELEX_typeOPEN_PAREN:
7489 break;
7490
7491 case FFELEX_typeEOS:
7492 case FFELEX_typeSEMICOLON:
7493 ffesta_confirmed ();
7494 break;
7495 }
7496 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCALL);
7497 if (!ffesrc_is_name_init (*p))
7498 goto bad_i; /* :::::::::::::::::::: */
7499 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
7500 next = (ffelexHandler)
7501 (*((ffelexHandler)
7502 ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextSUBROUTINEREF,
7503 (ffeexprCallback) ffestb_R12121_)))
7504 (nt);
7505 ffelex_token_kill (nt);
7506 return (ffelexHandler) (*next) (t);
7507
7508 default:
7509 goto bad_0; /* :::::::::::::::::::: */
7510 }
7511
7512 bad_0: /* :::::::::::::::::::: */
7513 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", ffesta_tokens[0]);
7514 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7515
7516 bad_1: /* :::::::::::::::::::: */
7517 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", t);
7518 return (ffelexHandler) ffelex_swallow_tokens (t,
7519 (ffelexHandler) ffesta_zero); /* Invalid second token. */
7520
7521 bad_i: /* :::::::::::::::::::: */
7522 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CALL", ffesta_tokens[0], i, t);
7523 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7524 }
7525
7526 /* ffestb_R12121_ -- "CALL" expr
7527
7528 (ffestb_R12121_) // to expression handler
7529
7530 Make sure the statement has a valid form for the CALL statement. If it
7531 does, implement the statement. */
7532
7533 static ffelexHandler
7534 ffestb_R12121_ (ffelexToken ft, ffebld expr, ffelexToken t)
7535 {
7536 switch (ffelex_token_type (t))
7537 {
7538 case FFELEX_typeEOS:
7539 case FFELEX_typeSEMICOLON:
7540 ffesta_confirmed ();
7541 if (expr == NULL)
7542 break;
7543 if (!ffesta_is_inhibited ())
7544 ffestc_R1212 (expr, ft);
7545 return (ffelexHandler) ffesta_zero (t);
7546
7547 default:
7548 break;
7549 }
7550
7551 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", t);
7552 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7553 }
7554
7555 /* ffestb_R1227 -- Parse the RETURN statement
7556
7557 return ffestb_R1227; // to lexer
7558
7559 Make sure the statement has a valid form for the RETURN statement. If it
7560 does, implement the statement. */
7561
7562 ffelexHandler
7563 ffestb_R1227 (ffelexToken t)
7564 {
7565 ffelexHandler next;
7566
7567 switch (ffelex_token_type (ffesta_tokens[0]))
7568 {
7569 case FFELEX_typeNAME:
7570 if (ffesta_first_kw != FFESTR_firstRETURN)
7571 goto bad_0; /* :::::::::::::::::::: */
7572 switch (ffelex_token_type (t))
7573 {
7574 case FFELEX_typeCOMMA:
7575 case FFELEX_typeCOLONCOLON:
7576 ffesta_confirmed (); /* Error, but clearly intended. */
7577 goto bad_1; /* :::::::::::::::::::: */
7578
7579 case FFELEX_typeEQUALS:
7580 case FFELEX_typePOINTS:
7581 case FFELEX_typeCOLON:
7582 goto bad_1; /* :::::::::::::::::::: */
7583
7584 case FFELEX_typeEOS:
7585 case FFELEX_typeSEMICOLON:
7586 case FFELEX_typeNAME:
7587 case FFELEX_typeNUMBER:
7588 ffesta_confirmed ();
7589 break;
7590
7591 default:
7592 break;
7593 }
7594
7595 return (ffelexHandler) (*((ffelexHandler)
7596 ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextRETURN,
7597 (ffeexprCallback) ffestb_R12271_)))
7598 (t);
7599
7600 case FFELEX_typeNAMES:
7601 if (ffesta_first_kw != FFESTR_firstRETURN)
7602 goto bad_0; /* :::::::::::::::::::: */
7603 switch (ffelex_token_type (t))
7604 {
7605 case FFELEX_typeCOMMA:
7606 case FFELEX_typeCOLONCOLON:
7607 ffesta_confirmed (); /* Error, but clearly intended. */
7608 goto bad_1; /* :::::::::::::::::::: */
7609
7610 case FFELEX_typeEQUALS:
7611 case FFELEX_typePOINTS:
7612 case FFELEX_typeCOLON:
7613 goto bad_1; /* :::::::::::::::::::: */
7614
7615 case FFELEX_typeEOS:
7616 case FFELEX_typeSEMICOLON:
7617 ffesta_confirmed ();
7618 break;
7619
7620 default:
7621 break;
7622 }
7623 next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
7624 FFEEXPR_contextRETURN, (ffeexprCallback) ffestb_R12271_);
7625 next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
7626 FFESTR_firstlRETURN);
7627 if (next == NULL)
7628 return (ffelexHandler) ffelex_swallow_tokens (t,
7629 (ffelexHandler) ffesta_zero);
7630 return (ffelexHandler) (*next) (t);
7631
7632 default:
7633 goto bad_0; /* :::::::::::::::::::: */
7634 }
7635
7636 bad_0: /* :::::::::::::::::::: */
7637 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", ffesta_tokens[0]);
7638 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7639
7640 bad_1: /* :::::::::::::::::::: */
7641 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", t);
7642 return (ffelexHandler) ffelex_swallow_tokens (t,
7643 (ffelexHandler) ffesta_zero); /* Invalid second token. */
7644 }
7645
7646 /* ffestb_R12271_ -- "RETURN" expr
7647
7648 (ffestb_R12271_) // to expression handler
7649
7650 Make sure the next token is an EOS or SEMICOLON. */
7651
7652 static ffelexHandler
7653 ffestb_R12271_ (ffelexToken ft, ffebld expr, ffelexToken t)
7654 {
7655 switch (ffelex_token_type (t))
7656 {
7657 case FFELEX_typeEOS:
7658 case FFELEX_typeSEMICOLON:
7659 ffesta_confirmed ();
7660 if (!ffesta_is_inhibited ())
7661 ffestc_R1227 (expr, ft);
7662 return (ffelexHandler) ffesta_zero (t);
7663
7664 default:
7665 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", t);
7666 break;
7667 }
7668
7669 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7670 }
7671
7672 /* ffestb_R1228 -- Parse the CONTAINS statement
7673
7674 return ffestb_R1228; // to lexer
7675
7676 Make sure the statement has a valid form for the CONTAINS statement. If
7677 it does, implement the statement. */
7678
7679 #if FFESTR_F90
7680 ffelexHandler
7681 ffestb_R1228 (ffelexToken t)
7682 {
7683 const char *p;
7684 ffeTokenLength i;
7685
7686 switch (ffelex_token_type (ffesta_tokens[0]))
7687 {
7688 case FFELEX_typeNAME:
7689 if (ffesta_first_kw != FFESTR_firstCONTAINS)
7690 goto bad_0; /* :::::::::::::::::::: */
7691 break;
7692
7693 case FFELEX_typeNAMES:
7694 if (ffesta_first_kw != FFESTR_firstCONTAINS)
7695 goto bad_0; /* :::::::::::::::::::: */
7696 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCONTAINS)
7697 {
7698 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCONTAINS);
7699 goto bad_i; /* :::::::::::::::::::: */
7700 }
7701 break;
7702
7703 default:
7704 goto bad_0; /* :::::::::::::::::::: */
7705 }
7706
7707 switch (ffelex_token_type (t))
7708 {
7709 case FFELEX_typeEOS:
7710 case FFELEX_typeSEMICOLON:
7711 ffesta_confirmed ();
7712 if (!ffesta_is_inhibited ())
7713 ffestc_R1228 ();
7714 return (ffelexHandler) ffesta_zero (t);
7715
7716 case FFELEX_typeCOMMA:
7717 case FFELEX_typeCOLONCOLON:
7718 ffesta_confirmed (); /* Error, but clearly intended. */
7719 goto bad_1; /* :::::::::::::::::::: */
7720
7721 default:
7722 goto bad_1; /* :::::::::::::::::::: */
7723 }
7724
7725 bad_0: /* :::::::::::::::::::: */
7726 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTAINS", ffesta_tokens[0]);
7727 return (ffelexHandler) ffelex_swallow_tokens (t,
7728 (ffelexHandler) ffesta_zero); /* Invalid first token. */
7729
7730 bad_1: /* :::::::::::::::::::: */
7731 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTAINS", t);
7732 return (ffelexHandler) ffelex_swallow_tokens (t,
7733 (ffelexHandler) ffesta_zero); /* Invalid second token. */
7734
7735 bad_i: /* :::::::::::::::::::: */
7736 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CONTAINS", ffesta_tokens[0], i, t);
7737 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7738 }
7739
7740 #endif
7741 /* ffestb_V009 -- Parse the UNION statement
7742
7743 return ffestb_V009; // to lexer
7744
7745 Make sure the statement has a valid form for the UNION statement. If
7746 it does, implement the statement. */
7747
7748 #if FFESTR_VXT
7749 ffelexHandler
7750 ffestb_V009 (ffelexToken t)
7751 {
7752 const char *p;
7753 ffeTokenLength i;
7754
7755 switch (ffelex_token_type (ffesta_tokens[0]))
7756 {
7757 case FFELEX_typeNAME:
7758 if (ffesta_first_kw != FFESTR_firstUNION)
7759 goto bad_0; /* :::::::::::::::::::: */
7760 break;
7761
7762 case FFELEX_typeNAMES:
7763 if (ffesta_first_kw != FFESTR_firstUNION)
7764 goto bad_0; /* :::::::::::::::::::: */
7765 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlUNION)
7766 {
7767 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlUNION);
7768 goto bad_i; /* :::::::::::::::::::: */
7769 }
7770 break;
7771
7772 default:
7773 goto bad_0; /* :::::::::::::::::::: */
7774 }
7775
7776 switch (ffelex_token_type (t))
7777 {
7778 case FFELEX_typeEOS:
7779 case FFELEX_typeSEMICOLON:
7780 ffesta_confirmed ();
7781 if (!ffesta_is_inhibited ())
7782 ffestc_V009 ();
7783 return (ffelexHandler) ffesta_zero (t);
7784
7785 case FFELEX_typeCOMMA:
7786 case FFELEX_typeCOLONCOLON:
7787 ffesta_confirmed (); /* Error, but clearly intended. */
7788 goto bad_1; /* :::::::::::::::::::: */
7789
7790 default:
7791 goto bad_1; /* :::::::::::::::::::: */
7792 }
7793
7794 bad_0: /* :::::::::::::::::::: */
7795 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "UNION", ffesta_tokens[0]);
7796 return (ffelexHandler) ffelex_swallow_tokens (t,
7797 (ffelexHandler) ffesta_zero); /* Invalid first token. */
7798
7799 bad_1: /* :::::::::::::::::::: */
7800 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "UNION", t);
7801 return (ffelexHandler) ffelex_swallow_tokens (t,
7802 (ffelexHandler) ffesta_zero); /* Invalid second token. */
7803
7804 bad_i: /* :::::::::::::::::::: */
7805 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "UNION", ffesta_tokens[0], i, t);
7806 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7807 }
7808
7809 #endif
7810 /* ffestb_construct -- Parse a construct name
7811
7812 return ffestb_construct; // to lexer
7813
7814 Make sure the statement can have a construct name (if-then-stmt, do-stmt,
7815 select-case-stmt). */
7816
7817 ffelexHandler
7818 ffestb_construct (ffelexToken t UNUSED)
7819 {
7820 /* This handler gets invoked only when token 0 is NAME/NAMES and token 1 is
7821 COLON. */
7822
7823 ffesta_confirmed ();
7824 ffelex_set_names (TRUE);
7825 return (ffelexHandler) ffestb_construct1_;
7826 }
7827
7828 /* ffestb_construct1_ -- NAME COLON
7829
7830 return ffestb_construct1_; // to lexer
7831
7832 Make sure we've got a NAME that is DO, DOWHILE, IF, SELECT, or SELECTCASE. */
7833
7834 static ffelexHandler
7835 ffestb_construct1_ (ffelexToken t)
7836 {
7837 ffelex_set_names (FALSE);
7838
7839 switch (ffelex_token_type (t))
7840 {
7841 case FFELEX_typeNAME:
7842 ffesta_first_kw = ffestr_first (t);
7843 switch (ffesta_first_kw)
7844 {
7845 case FFESTR_firstIF:
7846 ffestb_local_.construct.next = (ffelexHandler) ffestb_if;
7847 break;
7848
7849 case FFESTR_firstDO:
7850 ffestb_local_.construct.next = (ffelexHandler) ffestb_do;
7851 break;
7852
7853 case FFESTR_firstDOWHILE:
7854 ffestb_local_.construct.next = (ffelexHandler) ffestb_dowhile;
7855 break;
7856
7857 case FFESTR_firstSELECT:
7858 case FFESTR_firstSELECTCASE:
7859 ffestb_local_.construct.next = (ffelexHandler) ffestb_R809;
7860 break;
7861
7862 default:
7863 goto bad; /* :::::::::::::::::::: */
7864 }
7865 ffesta_construct_name = ffesta_tokens[0];
7866 ffesta_tokens[0] = ffelex_token_use (t);
7867 return (ffelexHandler) ffestb_construct2_;
7868
7869 case FFELEX_typeNAMES:
7870 ffesta_first_kw = ffestr_first (t);
7871 switch (ffesta_first_kw)
7872 {
7873 case FFESTR_firstIF:
7874 if (ffelex_token_length (t) != FFESTR_firstlIF)
7875 goto bad; /* :::::::::::::::::::: */
7876 ffestb_local_.construct.next = (ffelexHandler) ffestb_if;
7877 break;
7878
7879 case FFESTR_firstDO:
7880 ffestb_local_.construct.next = (ffelexHandler) ffestb_do;
7881 break;
7882
7883 case FFESTR_firstDOWHILE:
7884 if (ffelex_token_length (t) != FFESTR_firstlDOWHILE)
7885 goto bad; /* :::::::::::::::::::: */
7886 ffestb_local_.construct.next = (ffelexHandler) ffestb_dowhile;
7887 break;
7888
7889 case FFESTR_firstSELECTCASE:
7890 if (ffelex_token_length (t) != FFESTR_firstlSELECTCASE)
7891 goto bad; /* :::::::::::::::::::: */
7892 ffestb_local_.construct.next = (ffelexHandler) ffestb_R809;
7893 break;
7894
7895 default:
7896 goto bad; /* :::::::::::::::::::: */
7897 }
7898 ffesta_construct_name = ffesta_tokens[0];
7899 ffesta_tokens[0] = ffelex_token_use (t);
7900 return (ffelexHandler) ffestb_construct2_;
7901
7902 default:
7903 break;
7904 }
7905
7906 bad: /* :::::::::::::::::::: */
7907 ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
7908 ffesta_tokens[0], t);
7909 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7910 }
7911
7912 /* ffestb_construct2_ -- NAME COLON "DO/DOWHILE/IF/SELECT/SELECTCASE"
7913
7914 return ffestb_construct2_; // to lexer
7915
7916 This extra step is needed to set ffesta_second_kw if the second token
7917 (here) is a NAME, so DO and SELECT can continue to expect it. */
7918
7919 static ffelexHandler
7920 ffestb_construct2_ (ffelexToken t)
7921 {
7922 if (ffelex_token_type (t) == FFELEX_typeNAME)
7923 ffesta_second_kw = ffestr_second (t);
7924 return (ffelexHandler) (*ffestb_local_.construct.next) (t);
7925 }
7926
7927 /* ffestb_heap -- Parse an ALLOCATE/DEALLOCATE statement
7928
7929 return ffestb_heap; // to lexer
7930
7931 Make sure the statement has a valid form for an ALLOCATE/DEALLOCATE
7932 statement. If it does, implement the statement. */
7933
7934 #if FFESTR_F90
7935 ffelexHandler
7936 ffestb_heap (ffelexToken t)
7937 {
7938 switch (ffelex_token_type (ffesta_tokens[0]))
7939 {
7940 case FFELEX_typeNAME:
7941 break;
7942
7943 case FFELEX_typeNAMES:
7944 if (ffelex_token_length (ffesta_tokens[0]) != ffestb_args.heap.len)
7945 goto bad_0; /* :::::::::::::::::::: */
7946 break;
7947
7948 default:
7949 goto bad_0; /* :::::::::::::::::::: */
7950 }
7951
7952 switch (ffelex_token_type (t))
7953 {
7954 case FFELEX_typeOPEN_PAREN:
7955 break;
7956
7957 case FFELEX_typeEOS:
7958 case FFELEX_typeSEMICOLON:
7959 case FFELEX_typeCOMMA:
7960 case FFELEX_typeCOLONCOLON:
7961 ffesta_confirmed (); /* Error, but clearly intended. */
7962 goto bad_1; /* :::::::::::::::::::: */
7963
7964 default:
7965 goto bad_1; /* :::::::::::::::::::: */
7966 }
7967
7968 ffestb_local_.heap.exprs = ffestt_exprlist_create ();
7969 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
7970 ffestb_args.heap.ctx,
7971 (ffeexprCallback) ffestb_heap1_);
7972
7973 bad_0: /* :::::::::::::::::::: */
7974 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, ffesta_tokens[0]);
7975 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7976
7977 bad_1: /* :::::::::::::::::::: */
7978 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
7979 return (ffelexHandler) ffelex_swallow_tokens (t,
7980 (ffelexHandler) ffesta_zero); /* Invalid second token. */
7981 }
7982
7983 /* ffestb_heap1_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr
7984
7985 (ffestb_heap1_) // to expression handler
7986
7987 Make sure the next token is COMMA. */
7988
7989 static ffelexHandler
7990 ffestb_heap1_ (ffelexToken ft, ffebld expr, ffelexToken t)
7991 {
7992 switch (ffelex_token_type (t))
7993 {
7994 case FFELEX_typeCOMMA:
7995 if (expr == NULL)
7996 break;
7997 ffestt_exprlist_append (ffestb_local_.heap.exprs, expr,
7998 ffelex_token_use (t));
7999 return (ffelexHandler) ffestb_heap2_;
8000
8001 case FFELEX_typeCLOSE_PAREN:
8002 if (expr == NULL)
8003 break;
8004 ffestt_exprlist_append (ffestb_local_.heap.exprs, expr,
8005 ffelex_token_use (t));
8006 ffesta_tokens[1] = NULL;
8007 ffestb_local_.heap.expr = NULL;
8008 return (ffelexHandler) ffestb_heap5_;
8009
8010 default:
8011 break;
8012 }
8013
8014 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8015 ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8016 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8017 }
8018
8019 /* ffestb_heap2_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr COMMA
8020
8021 return ffestb_heap2_; // to lexer
8022
8023 Make sure the next token is NAME. */
8024
8025 static ffelexHandler
8026 ffestb_heap2_ (ffelexToken t)
8027 {
8028 switch (ffelex_token_type (t))
8029 {
8030 case FFELEX_typeNAME:
8031 ffesta_tokens[1] = ffelex_token_use (t);
8032 return (ffelexHandler) ffestb_heap3_;
8033
8034 default:
8035 break;
8036 }
8037
8038 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8039 ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8040 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8041 }
8042
8043 /* ffestb_heap3_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr COMMA NAME
8044
8045 return ffestb_heap3_; // to lexer
8046
8047 If token is EQUALS, make sure NAME was "STAT" and handle STAT variable;
8048 else pass NAME and token to expression handler. */
8049
8050 static ffelexHandler
8051 ffestb_heap3_ (ffelexToken t)
8052 {
8053 ffelexHandler next;
8054
8055 switch (ffelex_token_type (t))
8056 {
8057 case FFELEX_typeEQUALS:
8058 ffesta_confirmed ();
8059 if (ffestr_other (ffesta_tokens[1]) != FFESTR_otherSTAT)
8060 break;
8061 ffelex_token_kill (ffesta_tokens[1]);
8062 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
8063 FFEEXPR_contextHEAPSTAT,
8064 (ffeexprCallback) ffestb_heap4_);
8065
8066 default:
8067 next = (ffelexHandler)
8068 (*((ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
8069 ffestb_args.heap.ctx,
8070 (ffeexprCallback) ffestb_heap1_)))
8071 (ffesta_tokens[1]);
8072 ffelex_token_kill (ffesta_tokens[1]);
8073 return (ffelexHandler) (*next) (t);
8074 }
8075
8076 ffelex_token_kill (ffesta_tokens[1]);
8077 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8078 ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8079 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8080 }
8081
8082 /* ffestb_heap4_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN ... COMMA "STAT" EQUALS
8083 expr
8084
8085 (ffestb_heap4_) // to expression handler
8086
8087 Make sure the next token is CLOSE_PAREN. */
8088
8089 static ffelexHandler
8090 ffestb_heap4_ (ffelexToken ft, ffebld expr, ffelexToken t)
8091 {
8092 switch (ffelex_token_type (t))
8093 {
8094 case FFELEX_typeCLOSE_PAREN:
8095 if (expr == NULL)
8096 break;
8097 ffesta_tokens[1] = ffelex_token_use (ft);
8098 ffestb_local_.heap.expr = expr;
8099 return (ffelexHandler) ffestb_heap5_;
8100
8101 default:
8102 break;
8103 }
8104
8105 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8106 ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8107 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8108 }
8109
8110 /* ffestb_heap5_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN ... CLOSE_PAREN
8111
8112 return ffestb_heap5_; // to lexer
8113
8114 Make sure the next token is EOS/SEMICOLON. */
8115
8116 static ffelexHandler
8117 ffestb_heap5_ (ffelexToken t)
8118 {
8119 switch (ffelex_token_type (t))
8120 {
8121 case FFELEX_typeEOS:
8122 case FFELEX_typeSEMICOLON:
8123 ffesta_confirmed ();
8124 if (!ffesta_is_inhibited ())
8125 if (ffesta_first_kw == FFESTR_firstALLOCATE)
8126 ffestc_R620 (ffestb_local_.heap.exprs, ffestb_local_.heap.expr,
8127 ffesta_tokens[1]);
8128 else
8129 ffestc_R625 (ffestb_local_.heap.exprs, ffestb_local_.heap.expr,
8130 ffesta_tokens[1]);
8131 ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8132 if (ffesta_tokens[1] != NULL)
8133 ffelex_token_kill (ffesta_tokens[1]);
8134 return (ffelexHandler) ffesta_zero (t);
8135
8136 default:
8137 break;
8138 }
8139
8140 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8141 ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8142 if (ffesta_tokens[1] != NULL)
8143 ffelex_token_kill (ffesta_tokens[1]);
8144 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8145 }
8146
8147 #endif
8148 /* ffestb_module -- Parse the MODULEPROCEDURE statement
8149
8150 return ffestb_module; // to lexer
8151
8152 Make sure the statement has a valid form for the MODULEPROCEDURE statement.
8153 If it does, implement the statement.
8154
8155 31-May-90 JCB 1.1
8156 Confirm NAME==MODULE followed by standard four invalid tokens, so we
8157 get decent message if somebody forgets that MODULE requires a name. */
8158
8159 #if FFESTR_F90
8160 ffelexHandler
8161 ffestb_module (ffelexToken t)
8162 {
8163 ffeTokenLength i;
8164 const char *p;
8165 ffelexToken nt;
8166 ffelexToken mt; /* Name in MODULE PROCEDUREname, i.e.
8167 includes "PROCEDURE". */
8168
8169 switch (ffelex_token_type (ffesta_tokens[0]))
8170 {
8171 case FFELEX_typeNAME:
8172 if (ffesta_first_kw != FFESTR_firstMODULE)
8173 goto bad_0; /* :::::::::::::::::::: */
8174 switch (ffelex_token_type (t))
8175 {
8176 case FFELEX_typeNAME:
8177 break;
8178
8179 case FFELEX_typeCOLONCOLON:
8180 case FFELEX_typeCOMMA:
8181 case FFELEX_typeEOS:
8182 case FFELEX_typeSEMICOLON:
8183 ffesta_confirmed ();
8184 goto bad_1m; /* :::::::::::::::::::: */
8185
8186 default:
8187 goto bad_1m; /* :::::::::::::::::::: */
8188 }
8189
8190 ffesta_confirmed ();
8191 if (ffesta_second_kw != FFESTR_secondPROCEDURE)
8192 {
8193 ffesta_tokens[1] = ffelex_token_use (t);
8194 return (ffelexHandler) ffestb_module3_;
8195 }
8196 ffestb_local_.moduleprocedure.started = FALSE;
8197 ffesta_tokens[1] = ffelex_token_use (t);
8198 return (ffelexHandler) ffestb_module1_;
8199
8200 case FFELEX_typeNAMES:
8201 p = ffelex_token_text (ffesta_tokens[0])
8202 + (i = FFESTR_firstlMODULEPROCEDURE);
8203 if ((ffesta_first_kw == FFESTR_firstMODULE)
8204 || ((ffesta_first_kw == FFESTR_firstMODULEPROCEDURE)
8205 && !ffesrc_is_name_init (*p)))
8206 { /* Definitely not "MODULE PROCEDURE name". */
8207 switch (ffelex_token_type (t))
8208 {
8209 case FFELEX_typeCOMMA:
8210 case FFELEX_typeCOLONCOLON:
8211 ffesta_confirmed (); /* Error, but clearly intended. */
8212 goto bad_1m; /* :::::::::::::::::::: */
8213
8214 default:
8215 goto bad_1m; /* :::::::::::::::::::: */
8216
8217 case FFELEX_typeEOS:
8218 case FFELEX_typeSEMICOLON:
8219 ffesta_confirmed ();
8220 break;
8221 }
8222 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlMODULE);
8223 if (!ffesrc_is_name_init (*p))
8224 goto bad_im; /* :::::::::::::::::::: */
8225 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
8226 if (!ffesta_is_inhibited ())
8227 ffestc_R1105 (nt);
8228 ffelex_token_kill (nt);
8229 return (ffelexHandler) ffesta_zero (t);
8230 }
8231
8232 /* Here we know that we're indeed looking at a MODULEPROCEDURE
8233 statement rather than MODULE and that the character following
8234 MODULEPROCEDURE in the NAMES token is a valid first character for a
8235 NAME. This means that unless the second token is COMMA, we have an
8236 ambiguous statement that can be read either as MODULE PROCEDURE name
8237 or MODULE PROCEDUREname, the former being an R1205, the latter an
8238 R1105. */
8239
8240 if (ffesta_first_kw != FFESTR_firstMODULEPROCEDURE)
8241 goto bad_0; /* :::::::::::::::::::: */
8242 switch (ffelex_token_type (t))
8243 {
8244 case FFELEX_typeCOLONCOLON:
8245 ffesta_confirmed (); /* Error, but clearly intended. */
8246 goto bad_1; /* :::::::::::::::::::: */
8247
8248 default:
8249 goto bad_1; /* :::::::::::::::::::: */
8250
8251 case FFELEX_typeCOMMA: /* Aha, clearly not MODULE PROCEDUREname. */
8252 ffesta_confirmed ();
8253 ffestb_local_.moduleprocedure.started = FALSE;
8254 ffesta_tokens[1]
8255 = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
8256 return (ffelexHandler) ffestb_module2_ (t);
8257
8258 case FFELEX_typeEOS: /* MODULE PROCEDURE name or MODULE
8259 PROCEDUREname. */
8260 case FFELEX_typeSEMICOLON:
8261 ffesta_confirmed ();
8262 break;
8263 }
8264 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
8265 mt = ffelex_token_name_from_names (ffesta_tokens[0], FFESTR_firstlMODULE,
8266 0);
8267 if (!ffesta_is_inhibited ())
8268 ffestc_module (mt, nt); /* Implement ambiguous statement. */
8269 ffelex_token_kill (nt);
8270 ffelex_token_kill (mt);
8271 return (ffelexHandler) ffesta_zero (t);
8272
8273 default:
8274 goto bad_0; /* :::::::::::::::::::: */
8275 }
8276
8277 bad_0: /* :::::::::::::::::::: */
8278 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", ffesta_tokens[0]);
8279 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8280
8281 bad_1: /* :::::::::::::::::::: */
8282 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
8283 return (ffelexHandler) ffelex_swallow_tokens (t,
8284 (ffelexHandler) ffesta_zero); /* Invalid second token. */
8285
8286 bad_1m: /* :::::::::::::::::::: */
8287 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE", t);
8288 return (ffelexHandler) ffelex_swallow_tokens (t,
8289 (ffelexHandler) ffesta_zero); /* Invalid second token. */
8290
8291 bad_im: /* :::::::::::::::::::: */
8292 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "MODULE", ffesta_tokens[0], i, t);
8293 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8294 }
8295
8296 /* ffestb_module1_ -- "MODULEPROCEDURE" or "MODULE" "PROCEDURE"
8297
8298 return ffestb_module1_; // to lexer
8299
8300 Make sure the statement has a valid form for the MODULEPROCEDURE statement. If it
8301 does, implement the statement. */
8302
8303 static ffelexHandler
8304 ffestb_module1_ (ffelexToken t)
8305 {
8306 switch (ffelex_token_type (t))
8307 {
8308 case FFELEX_typeNAME:
8309 if (!ffestb_local_.moduleprocedure.started
8310 && (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME))
8311 {
8312 ffesta_confirmed ();
8313 ffelex_token_kill (ffesta_tokens[1]);
8314 }
8315 ffesta_tokens[1] = ffelex_token_use (t);
8316 return (ffelexHandler) ffestb_module2_;
8317
8318 case FFELEX_typeEOS:
8319 case FFELEX_typeSEMICOLON:
8320 if (ffestb_local_.moduleprocedure.started)
8321 break; /* Error if we've already seen NAME COMMA. */
8322 ffesta_confirmed ();
8323 if (!ffesta_is_inhibited ())
8324 ffestc_R1105 (ffesta_tokens[1]);
8325 ffelex_token_kill (ffesta_tokens[1]);
8326 return (ffelexHandler) ffesta_zero (t);
8327
8328 case FFELEX_typeCOMMA:
8329 case FFELEX_typeCOLONCOLON:
8330 ffesta_confirmed (); /* Error, but clearly intended. */
8331 break;
8332
8333 default:
8334 break;
8335 }
8336
8337 if (ffestb_local_.moduleprocedure.started && !ffesta_is_inhibited ())
8338 ffestc_R1205_finish ();
8339 else if (!ffestb_local_.moduleprocedure.started)
8340 ffelex_token_kill (ffesta_tokens[1]);
8341 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
8342 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8343 }
8344
8345 /* ffestb_module2_ -- "MODULE/PROCEDURE" NAME
8346
8347 return ffestb_module2_; // to lexer
8348
8349 Make sure the statement has a valid form for the MODULEPROCEDURE statement. If it
8350 does, implement the statement. */
8351
8352 static ffelexHandler
8353 ffestb_module2_ (ffelexToken t)
8354 {
8355 switch (ffelex_token_type (t))
8356 {
8357 case FFELEX_typeEOS:
8358 case FFELEX_typeSEMICOLON:
8359 if (!ffestb_local_.moduleprocedure.started)
8360 {
8361 ffesta_confirmed ();
8362 if (!ffesta_is_inhibited ())
8363 ffestc_R1205_start ();
8364 }
8365 if (!ffesta_is_inhibited ())
8366 {
8367 ffestc_R1205_item (ffesta_tokens[1]);
8368 ffestc_R1205_finish ();
8369 }
8370 ffelex_token_kill (ffesta_tokens[1]);
8371 return (ffelexHandler) ffesta_zero (t);
8372
8373 case FFELEX_typeCOMMA:
8374 if (!ffestb_local_.moduleprocedure.started)
8375 {
8376 ffestb_local_.moduleprocedure.started = TRUE;
8377 ffesta_confirmed ();
8378 if (!ffesta_is_inhibited ())
8379 ffestc_R1205_start ();
8380 }
8381 if (!ffesta_is_inhibited ())
8382 ffestc_R1205_item (ffesta_tokens[1]);
8383 ffelex_token_kill (ffesta_tokens[1]);
8384 return (ffelexHandler) ffestb_module1_;
8385
8386 default:
8387 break;
8388 }
8389
8390 if (ffestb_local_.moduleprocedure.started && !ffesta_is_inhibited ())
8391 ffestc_R1205_finish ();
8392 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
8393 ffelex_token_kill (ffesta_tokens[1]);
8394 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8395 }
8396
8397 /* ffestb_module3_ -- "MODULE" NAME
8398
8399 return ffestb_module3_; // to lexer
8400
8401 Make sure the statement has a valid form for the MODULE statement. If it
8402 does, implement the statement. */
8403
8404 static ffelexHandler
8405 ffestb_module3_ (ffelexToken t)
8406 {
8407 switch (ffelex_token_type (t))
8408 {
8409 case FFELEX_typeEOS:
8410 case FFELEX_typeSEMICOLON:
8411 if (!ffesta_is_inhibited ())
8412 ffestc_R1105 (ffesta_tokens[1]);
8413 ffelex_token_kill (ffesta_tokens[1]);
8414 return (ffelexHandler) ffesta_zero (t);
8415
8416 default:
8417 break;
8418 }
8419
8420 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE", t);
8421 ffelex_token_kill (ffesta_tokens[1]);
8422 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8423 }
8424
8425 #endif
8426 /* ffestb_R809 -- Parse the SELECTCASE statement
8427
8428 return ffestb_R809; // to lexer
8429
8430 Make sure the statement has a valid form for the SELECTCASE statement.
8431 If it does, implement the statement. */
8432
8433 ffelexHandler
8434 ffestb_R809 (ffelexToken t)
8435 {
8436 ffeTokenLength i;
8437 const char *p;
8438
8439 switch (ffelex_token_type (ffesta_tokens[0]))
8440 {
8441 case FFELEX_typeNAME:
8442 switch (ffesta_first_kw)
8443 {
8444 case FFESTR_firstSELECT:
8445 if ((ffelex_token_type (t) != FFELEX_typeNAME)
8446 || (ffesta_second_kw != FFESTR_secondCASE))
8447 goto bad_1; /* :::::::::::::::::::: */
8448 ffesta_confirmed ();
8449 return (ffelexHandler) ffestb_R8091_;
8450
8451 case FFESTR_firstSELECTCASE:
8452 return (ffelexHandler) ffestb_R8091_ (t);
8453
8454 default:
8455 goto bad_0; /* :::::::::::::::::::: */
8456 }
8457
8458 case FFELEX_typeNAMES:
8459 if (ffesta_first_kw != FFESTR_firstSELECTCASE)
8460 goto bad_0; /* :::::::::::::::::::: */
8461 switch (ffelex_token_type (t))
8462 {
8463 case FFELEX_typeCOMMA:
8464 case FFELEX_typeEOS:
8465 case FFELEX_typeSEMICOLON:
8466 case FFELEX_typeCOLONCOLON:
8467 ffesta_confirmed (); /* Error, but clearly intended. */
8468 goto bad_1; /* :::::::::::::::::::: */
8469
8470 default:
8471 goto bad_1; /* :::::::::::::::::::: */
8472
8473 case FFELEX_typeOPEN_PAREN:
8474 break;
8475 }
8476 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSELECTCASE);
8477 if (*p != '\0')
8478 goto bad_i; /* :::::::::::::::::::: */
8479 return (ffelexHandler) ffestb_R8091_ (t);
8480
8481 default:
8482 goto bad_0; /* :::::::::::::::::::: */
8483 }
8484
8485 bad_0: /* :::::::::::::::::::: */
8486 if (ffesta_construct_name != NULL)
8487 {
8488 ffelex_token_kill (ffesta_construct_name);
8489 ffesta_construct_name = NULL;
8490 }
8491 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", ffesta_tokens[0]);
8492 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8493
8494 bad_1: /* :::::::::::::::::::: */
8495 if (ffesta_construct_name != NULL)
8496 {
8497 ffelex_token_kill (ffesta_construct_name);
8498 ffesta_construct_name = NULL;
8499 }
8500 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8501 return (ffelexHandler) ffelex_swallow_tokens (t,
8502 (ffelexHandler) ffesta_zero); /* Invalid second token. */
8503
8504 bad_i: /* :::::::::::::::::::: */
8505 if (ffesta_construct_name != NULL)
8506 {
8507 ffelex_token_kill (ffesta_construct_name);
8508 ffesta_construct_name = NULL;
8509 }
8510 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", ffesta_tokens[0], i, t);
8511 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8512 }
8513
8514 /* ffestb_R8091_ -- "SELECTCASE" or "SELECT" "CASE"
8515
8516 return ffestb_R8091_; // to lexer
8517
8518 Make sure the statement has a valid form for the SELECTCASE statement. If it
8519 does, implement the statement. */
8520
8521 static ffelexHandler
8522 ffestb_R8091_ (ffelexToken t)
8523 {
8524 switch (ffelex_token_type (t))
8525 {
8526 case FFELEX_typeOPEN_PAREN:
8527 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8528 FFEEXPR_contextSELECTCASE, (ffeexprCallback) ffestb_R8092_);
8529
8530 case FFELEX_typeEOS:
8531 case FFELEX_typeSEMICOLON:
8532 case FFELEX_typeCOMMA:
8533 case FFELEX_typeCOLONCOLON:
8534 ffesta_confirmed (); /* Error, but clearly intended. */
8535 break;
8536
8537 default:
8538 break;
8539 }
8540
8541 if (ffesta_construct_name != NULL)
8542 {
8543 ffelex_token_kill (ffesta_construct_name);
8544 ffesta_construct_name = NULL;
8545 }
8546 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8547 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8548 }
8549
8550 /* ffestb_R8092_ -- "SELECT/CASE" OPEN_PAREN expr
8551
8552 (ffestb_R8092_) // to expression handler
8553
8554 Make sure the statement has a valid form for the SELECTCASE statement. If it
8555 does, implement the statement. */
8556
8557 static ffelexHandler
8558 ffestb_R8092_ (ffelexToken ft, ffebld expr, ffelexToken t)
8559 {
8560 switch (ffelex_token_type (t))
8561 {
8562 case FFELEX_typeCLOSE_PAREN:
8563 if (expr == NULL)
8564 break;
8565 ffesta_tokens[1] = ffelex_token_use (ft);
8566 ffestb_local_.selectcase.expr = expr;
8567 return (ffelexHandler) ffestb_R8093_;
8568
8569 default:
8570 break;
8571 }
8572
8573 if (ffesta_construct_name != NULL)
8574 {
8575 ffelex_token_kill (ffesta_construct_name);
8576 ffesta_construct_name = NULL;
8577 }
8578 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8579 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8580 }
8581
8582 /* ffestb_R8093_ -- "SELECT/CASE" OPEN_PAREN expr CLOSE_PAREN
8583
8584 return ffestb_R8093_; // to lexer
8585
8586 Make sure the statement has a valid form for the SELECTCASE statement. If it
8587 does, implement the statement. */
8588
8589 static ffelexHandler
8590 ffestb_R8093_ (ffelexToken t)
8591 {
8592 switch (ffelex_token_type (t))
8593 {
8594 case FFELEX_typeEOS:
8595 case FFELEX_typeSEMICOLON:
8596 ffesta_confirmed ();
8597 if (!ffesta_is_inhibited ())
8598 ffestc_R809 (ffesta_construct_name, ffestb_local_.selectcase.expr,
8599 ffesta_tokens[1]);
8600 ffelex_token_kill (ffesta_tokens[1]);
8601 if (ffesta_construct_name != NULL)
8602 {
8603 ffelex_token_kill (ffesta_construct_name);
8604 ffesta_construct_name = NULL;
8605 }
8606 return ffesta_zero (t);
8607
8608 case FFELEX_typeCOMMA:
8609 case FFELEX_typeCOLONCOLON:
8610 ffesta_confirmed (); /* Error, but clearly intended. */
8611 break;
8612
8613 default:
8614 break;
8615 }
8616
8617 ffelex_token_kill (ffesta_tokens[1]);
8618 if (ffesta_construct_name != NULL)
8619 {
8620 ffelex_token_kill (ffesta_construct_name);
8621 ffesta_construct_name = NULL;
8622 }
8623 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8624 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8625 }
8626
8627 /* ffestb_R810 -- Parse the CASE statement
8628
8629 return ffestb_R810; // to lexer
8630
8631 Make sure the statement has a valid form for the CASE statement.
8632 If it does, implement the statement. */
8633
8634 ffelexHandler
8635 ffestb_R810 (ffelexToken t)
8636 {
8637 ffeTokenLength i;
8638 unsigned const char *p;
8639
8640 switch (ffelex_token_type (ffesta_tokens[0]))
8641 {
8642 case FFELEX_typeNAME:
8643 if (ffesta_first_kw != FFESTR_firstCASE)
8644 goto bad_0; /* :::::::::::::::::::: */
8645 switch (ffelex_token_type (t))
8646 {
8647 case FFELEX_typeCOMMA:
8648 case FFELEX_typeEOS:
8649 case FFELEX_typeSEMICOLON:
8650 case FFELEX_typeCOLONCOLON:
8651 ffesta_confirmed (); /* Error, but clearly intended. */
8652 goto bad_1; /* :::::::::::::::::::: */
8653
8654 default:
8655 goto bad_1; /* :::::::::::::::::::: */
8656
8657 case FFELEX_typeNAME:
8658 ffesta_confirmed ();
8659 if (ffesta_second_kw != FFESTR_secondDEFAULT)
8660 goto bad_1; /* :::::::::::::::::::: */
8661 ffestb_local_.case_stmt.cases = NULL;
8662 return (ffelexHandler) ffestb_R8101_;
8663
8664 case FFELEX_typeOPEN_PAREN:
8665 ffestb_local_.case_stmt.cases = ffestt_caselist_create ();
8666 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8667 FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8668 }
8669
8670 case FFELEX_typeNAMES:
8671 switch (ffesta_first_kw)
8672 {
8673 case FFESTR_firstCASEDEFAULT:
8674 switch (ffelex_token_type (t))
8675 {
8676 case FFELEX_typeCOMMA:
8677 case FFELEX_typeCOLONCOLON:
8678 ffesta_confirmed (); /* Error, but clearly intended. */
8679 goto bad_1; /* :::::::::::::::::::: */
8680
8681 default:
8682 goto bad_1; /* :::::::::::::::::::: */
8683
8684 case FFELEX_typeEOS:
8685 case FFELEX_typeSEMICOLON:
8686 ffesta_confirmed ();
8687 break;
8688 }
8689 ffestb_local_.case_stmt.cases = NULL;
8690 p = ffelex_token_text (ffesta_tokens[0])
8691 + (i = FFESTR_firstlCASEDEFAULT);
8692 if (*p == '\0')
8693 return (ffelexHandler) ffestb_R8101_ (t);
8694 if (!ffesrc_is_name_init (*p))
8695 goto bad_i; /* :::::::::::::::::::: */
8696 ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i,
8697 0);
8698 return (ffelexHandler) ffestb_R8102_ (t);
8699
8700 case FFESTR_firstCASE:
8701 break;
8702
8703 default:
8704 goto bad_0; /* :::::::::::::::::::: */
8705 }
8706
8707 switch (ffelex_token_type (t))
8708 {
8709 case FFELEX_typeCOMMA:
8710 case FFELEX_typeEOS:
8711 case FFELEX_typeSEMICOLON:
8712 case FFELEX_typeCOLONCOLON:
8713 ffesta_confirmed (); /* Error, but clearly intended. */
8714 goto bad_1; /* :::::::::::::::::::: */
8715
8716 default:
8717 goto bad_1; /* :::::::::::::::::::: */
8718
8719 case FFELEX_typeOPEN_PAREN:
8720 break;
8721 }
8722 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCASE);
8723 if (*p != '\0')
8724 goto bad_i; /* :::::::::::::::::::: */
8725 ffestb_local_.case_stmt.cases = ffestt_caselist_create ();
8726 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8727 FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8728
8729 default:
8730 goto bad_0; /* :::::::::::::::::::: */
8731 }
8732
8733 bad_0: /* :::::::::::::::::::: */
8734 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", ffesta_tokens[0]);
8735 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8736
8737 bad_1: /* :::::::::::::::::::: */
8738 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8739 return (ffelexHandler) ffelex_swallow_tokens (t,
8740 (ffelexHandler) ffesta_zero); /* Invalid second token. */
8741
8742 bad_i: /* :::::::::::::::::::: */
8743 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CASE", ffesta_tokens[0], i, t);
8744 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8745 }
8746
8747 /* ffestb_R8101_ -- "CASE" case-selector
8748
8749 return ffestb_R8101_; // to lexer
8750
8751 Make sure the statement has a valid form for the CASE statement. If it
8752 does, implement the statement. */
8753
8754 static ffelexHandler
8755 ffestb_R8101_ (ffelexToken t)
8756 {
8757 switch (ffelex_token_type (t))
8758 {
8759 case FFELEX_typeNAME:
8760 ffesta_tokens[1] = ffelex_token_use (t);
8761 return (ffelexHandler) ffestb_R8102_;
8762
8763 case FFELEX_typeEOS:
8764 case FFELEX_typeSEMICOLON:
8765 ffesta_tokens[1] = NULL;
8766 return (ffelexHandler) ffestb_R8102_ (t);
8767
8768 case FFELEX_typeCOMMA:
8769 case FFELEX_typeCOLONCOLON:
8770 ffesta_confirmed (); /* Error, but clearly intended. */
8771 break;
8772
8773 default:
8774 break;
8775 }
8776
8777 if (ffestb_local_.case_stmt.cases != NULL)
8778 ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8779 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8780 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8781 }
8782
8783 /* ffestb_R8102_ -- "CASE" case-selector [NAME]
8784
8785 return ffestb_R8102_; // to lexer
8786
8787 Make sure the statement has a valid form for the CASE statement. If it
8788 does, implement the statement. */
8789
8790 static ffelexHandler
8791 ffestb_R8102_ (ffelexToken t)
8792 {
8793 switch (ffelex_token_type (t))
8794 {
8795 case FFELEX_typeEOS:
8796 case FFELEX_typeSEMICOLON:
8797 ffesta_confirmed ();
8798 if (!ffesta_is_inhibited ())
8799 ffestc_R810 (ffestb_local_.case_stmt.cases, ffesta_tokens[1]);
8800 if (ffestb_local_.case_stmt.cases != NULL)
8801 ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8802 if (ffesta_tokens[1] != NULL)
8803 ffelex_token_kill (ffesta_tokens[1]);
8804 return (ffelexHandler) ffesta_zero (t);
8805
8806 case FFELEX_typeCOMMA:
8807 case FFELEX_typeCOLONCOLON:
8808 ffesta_confirmed (); /* Error, but clearly intended. */
8809 break;
8810
8811 default:
8812 break;
8813 }
8814
8815 if (ffestb_local_.case_stmt.cases != NULL)
8816 ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8817 if (ffesta_tokens[1] != NULL)
8818 ffelex_token_kill (ffesta_tokens[1]);
8819 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8820 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8821 }
8822
8823 /* ffestb_R8103_ -- "CASE" OPEN_PAREN expr
8824
8825 (ffestb_R8103_) // to expression handler
8826
8827 Make sure the statement has a valid form for the CASE statement. If it
8828 does, implement the statement. */
8829
8830 static ffelexHandler
8831 ffestb_R8103_ (ffelexToken ft, ffebld expr, ffelexToken t)
8832 {
8833 switch (ffelex_token_type (t))
8834 {
8835 case FFELEX_typeCLOSE_PAREN:
8836 ffestt_caselist_append (ffestb_local_.case_stmt.cases, FALSE, expr, NULL,
8837 ffelex_token_use (ft));
8838 return (ffelexHandler) ffestb_R8101_;
8839
8840 case FFELEX_typeCOMMA:
8841 ffestt_caselist_append (ffestb_local_.case_stmt.cases, FALSE, expr, NULL,
8842 ffelex_token_use (ft));
8843 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8844 FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8845
8846 case FFELEX_typeCOLON:
8847 ffestt_caselist_append (ffestb_local_.case_stmt.cases, TRUE, expr, NULL,
8848 ffelex_token_use (ft)); /* NULL second expr for
8849 now, just plug in. */
8850 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8851 FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8104_);
8852
8853 default:
8854 break;
8855 }
8856
8857 ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8858 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8859 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8860 }
8861
8862 /* ffestb_R8104_ -- "CASE" OPEN_PAREN expr COLON expr
8863
8864 (ffestb_R8104_) // to expression handler
8865
8866 Make sure the statement has a valid form for the CASE statement. If it
8867 does, implement the statement. */
8868
8869 static ffelexHandler
8870 ffestb_R8104_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
8871 {
8872 switch (ffelex_token_type (t))
8873 {
8874 case FFELEX_typeCLOSE_PAREN:
8875 ffestb_local_.case_stmt.cases->previous->expr2 = expr;
8876 return (ffelexHandler) ffestb_R8101_;
8877
8878 case FFELEX_typeCOMMA:
8879 ffestb_local_.case_stmt.cases->previous->expr2 = expr;
8880 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8881 FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8882
8883 default:
8884 break;
8885 }
8886
8887 ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8888 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8889 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8890 }
8891
8892 /* ffestb_R1001 -- Parse a FORMAT statement
8893
8894 return ffestb_R1001; // to lexer
8895
8896 Make sure the statement has a valid form for an FORMAT statement.
8897 If it does, implement the statement. */
8898
8899 ffelexHandler
8900 ffestb_R1001 (ffelexToken t)
8901 {
8902 ffesttFormatList f;
8903
8904 switch (ffelex_token_type (ffesta_tokens[0]))
8905 {
8906 case FFELEX_typeNAME:
8907 if (ffesta_first_kw != FFESTR_firstFORMAT)
8908 goto bad_0; /* :::::::::::::::::::: */
8909 break;
8910
8911 case FFELEX_typeNAMES:
8912 if (ffesta_first_kw != FFESTR_firstFORMAT)
8913 goto bad_0; /* :::::::::::::::::::: */
8914 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlFORMAT)
8915 goto bad_0; /* :::::::::::::::::::: */
8916 break;
8917
8918 default:
8919 goto bad_0; /* :::::::::::::::::::: */
8920 }
8921
8922 switch (ffelex_token_type (t))
8923 {
8924 case FFELEX_typeOPEN_PAREN:
8925 ffestb_local_.format.complained = FALSE;
8926 ffestb_local_.format.f = NULL; /* No parent yet. */
8927 ffestb_local_.format.f = ffestt_formatlist_create (NULL,
8928 ffelex_token_use (t));
8929 ffelex_set_names_pure (TRUE); /* Have even free-form lexer give us
8930 NAMES. */
8931 return (ffelexHandler) ffestb_R10011_;
8932
8933 case FFELEX_typeOPEN_ARRAY:/* "(/". */
8934 ffesta_confirmed ();
8935 ffestb_local_.format.complained = FALSE;
8936 ffestb_local_.format.f = ffestt_formatlist_create (NULL,
8937 ffelex_token_use (t));
8938 f = ffestt_formatlist_append (ffestb_local_.format.f);
8939 f->type = FFESTP_formattypeSLASH;
8940 f->t = ffelex_token_use (t);
8941 f->u.R1010.val.present = FALSE;
8942 f->u.R1010.val.rtexpr = FALSE;
8943 f->u.R1010.val.t = NULL;
8944 f->u.R1010.val.u.unsigned_val = 1;
8945 ffelex_set_names_pure (TRUE); /* Have even free-form lexer give us
8946 NAMES. */
8947 return (ffelexHandler) ffestb_R100112_;
8948
8949 case FFELEX_typeEOS:
8950 case FFELEX_typeSEMICOLON:
8951 case FFELEX_typeCOMMA:
8952 case FFELEX_typeCOLONCOLON:
8953 ffesta_confirmed (); /* Error, but clearly intended. */
8954 goto bad_1; /* :::::::::::::::::::: */
8955
8956 default:
8957 goto bad_1; /* :::::::::::::::::::: */
8958 }
8959
8960 bad_0: /* :::::::::::::::::::: */
8961 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", ffesta_tokens[0]);
8962 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8963
8964 bad_1: /* :::::::::::::::::::: */
8965 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
8966 return (ffelexHandler) ffelex_swallow_tokens (t,
8967 (ffelexHandler) ffesta_zero); /* Invalid second token. */
8968 }
8969
8970 /* ffestb_R10011_ -- "FORMAT" OPEN_PAREN expr
8971
8972 return ffestb_R10011_; // to lexer
8973
8974 For CLOSE_PAREN, wrap up the format list and if it is the top-level one,
8975 exit. For anything else, pass it to _2_. */
8976
8977 static ffelexHandler
8978 ffestb_R10011_ (ffelexToken t)
8979 {
8980 ffesttFormatList f;
8981
8982 switch (ffelex_token_type (t))
8983 {
8984 case FFELEX_typeCLOSE_PAREN:
8985 break;
8986
8987 default:
8988 return (ffelexHandler) ffestb_R10012_ (t);
8989 }
8990
8991 /* If we have a format we're working on, continue working on it. */
8992
8993 f = ffestb_local_.format.f->u.root.parent;
8994
8995 if (f != NULL)
8996 {
8997 ffestb_local_.format.f = f->next;
8998 return (ffelexHandler) ffestb_R100111_;
8999 }
9000
9001 return (ffelexHandler) ffestb_R100114_;
9002 }
9003
9004 /* ffestb_R10012_ -- "FORMAT" OPEN_PAREN [format-item-list]
9005
9006 return ffestb_R10012_; // to lexer
9007
9008 The initial state for a format-item. Here, just handle the initial
9009 number, sign for number, or run-time expression. Also handle spurious
9010 comma, close-paren (indicating spurious comma), close-array (like
9011 close-paren but preceded by slash), and quoted strings. */
9012
9013 static ffelexHandler
9014 ffestb_R10012_ (ffelexToken t)
9015 {
9016 unsigned long unsigned_val;
9017 ffesttFormatList f;
9018
9019 switch (ffelex_token_type (t))
9020 {
9021 case FFELEX_typeOPEN_ANGLE:
9022 ffesta_confirmed ();
9023 ffestb_local_.format.pre.t = ffelex_token_use (t);
9024 ffelex_set_names_pure (FALSE);
9025 if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
9026 {
9027 ffestb_local_.format.complained = TRUE;
9028 ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
9029 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9030 ffebad_finish ();
9031 }
9032 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
9033 FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100115_);
9034
9035 case FFELEX_typeNUMBER:
9036 ffestb_local_.format.sign = FALSE; /* No sign present. */
9037 ffestb_local_.format.pre.present = TRUE;
9038 ffestb_local_.format.pre.rtexpr = FALSE;
9039 ffestb_local_.format.pre.t = ffelex_token_use (t);
9040 ffestb_local_.format.pre.u.unsigned_val = unsigned_val
9041 = strtoul (ffelex_token_text (t), NULL, 10);
9042 ffelex_set_expecting_hollerith (unsigned_val, '\0',
9043 ffelex_token_where_line (t),
9044 ffelex_token_where_column (t));
9045 return (ffelexHandler) ffestb_R10014_;
9046
9047 case FFELEX_typePLUS:
9048 ffestb_local_.format.sign = TRUE; /* Positive. */
9049 ffestb_local_.format.pre.t = ffelex_token_use (t);
9050 return (ffelexHandler) ffestb_R10013_;
9051
9052 case FFELEX_typeMINUS:
9053 ffestb_local_.format.sign = FALSE; /* Negative. */
9054 ffestb_local_.format.pre.t = ffelex_token_use (t);
9055 return (ffelexHandler) ffestb_R10013_;
9056
9057 case FFELEX_typeCOLON:
9058 case FFELEX_typeCOLONCOLON:/* "::". */
9059 case FFELEX_typeSLASH:
9060 case FFELEX_typeCONCAT: /* "//". */
9061 case FFELEX_typeNAMES:
9062 case FFELEX_typeDOLLAR:
9063 case FFELEX_typeOPEN_PAREN:
9064 case FFELEX_typeOPEN_ARRAY:/* "(/". */
9065 ffestb_local_.format.sign = FALSE; /* No sign present. */
9066 ffestb_local_.format.pre.present = FALSE;
9067 ffestb_local_.format.pre.rtexpr = FALSE;
9068 ffestb_local_.format.pre.t = NULL;
9069 ffestb_local_.format.pre.u.unsigned_val = 1;
9070 return (ffelexHandler) ffestb_R10014_ (t);
9071
9072 case FFELEX_typeCOMMA:
9073 ffebad_start (FFEBAD_FORMAT_EXTRA_COMMA);
9074 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9075 ffebad_finish ();
9076 return (ffelexHandler) ffestb_R10012_;
9077
9078 case FFELEX_typeCLOSE_PAREN:
9079 ffebad_start (FFEBAD_FORMAT_EXTRA_COMMA);
9080 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9081 ffebad_finish ();
9082 f = ffestb_local_.format.f->u.root.parent;
9083 if (f == NULL)
9084 return (ffelexHandler) ffestb_R100114_;
9085 ffestb_local_.format.f = f->next;
9086 return (ffelexHandler) ffestb_R100111_;
9087
9088 case FFELEX_typeCLOSE_ARRAY: /* "/)". */
9089 f = ffestt_formatlist_append (ffestb_local_.format.f);
9090 f->type = FFESTP_formattypeSLASH;
9091 f->t = ffelex_token_use (t);
9092 f->u.R1010.val.present = FALSE;
9093 f->u.R1010.val.rtexpr = FALSE;
9094 f->u.R1010.val.t = NULL;
9095 f->u.R1010.val.u.unsigned_val = 1;
9096 f = ffestb_local_.format.f->u.root.parent;
9097 if (f == NULL)
9098 return (ffelexHandler) ffestb_R100114_;
9099 ffestb_local_.format.f = f->next;
9100 return (ffelexHandler) ffestb_R100111_;
9101
9102 case FFELEX_typeEOS:
9103 case FFELEX_typeSEMICOLON:
9104 ffesta_confirmed ();
9105 ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
9106 for (f = ffestb_local_.format.f;
9107 f->u.root.parent != NULL;
9108 f = f->u.root.parent->next)
9109 ;
9110 ffestb_local_.format.f = f;
9111 return (ffelexHandler) ffestb_R100114_ (t);
9112
9113 case FFELEX_typeQUOTE:
9114 if (ffe_is_vxt ())
9115 break; /* Error, probably something like FORMAT("17)
9116 = X. */
9117 ffelex_set_expecting_hollerith (-1, '\"',
9118 ffelex_token_where_line (t),
9119 ffelex_token_where_column (t)); /* Don't have to unset
9120 this one. */
9121 return (ffelexHandler) ffestb_R100113_;
9122
9123 case FFELEX_typeAPOSTROPHE:
9124 #if 0 /* No apparent need for this, and not killed
9125 anywhere. */
9126 ffesta_tokens[1] = ffelex_token_use (t);
9127 #endif
9128 ffelex_set_expecting_hollerith (-1, '\'',
9129 ffelex_token_where_line (t),
9130 ffelex_token_where_column (t)); /* Don't have to unset
9131 this one. */
9132 return (ffelexHandler) ffestb_R100113_;
9133
9134 default:
9135 break;
9136 }
9137
9138 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
9139 ffestt_formatlist_kill (ffestb_local_.format.f);
9140 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
9141 }
9142
9143 /* ffestb_R10013_ -- "FORMAT" OPEN_PAREN [format-item-list] PLUS/MINUS
9144
9145 return ffestb_R10013_; // to lexer
9146
9147 Expect a NUMBER or complain about and then ignore the PLUS/MINUS. */
9148
9149 static ffelexHandler
9150 ffestb_R10013_ (ffelexToken t)
9151 {
9152 unsigned long unsigned_val;
9153
9154 switch (ffelex_token_type (t))
9155 {
9156 case FFELEX_typeNUMBER:
9157 ffestb_local_.format.pre.present = TRUE;
9158 ffestb_local_.format.pre.rtexpr = FALSE;
9159 unsigned_val = strtoul (ffelex_token_text (t), NULL, 10);
9160 ffestb_local_.format.pre.u.signed_val = ffestb_local_.format.sign
9161 ? unsigned_val : -unsigned_val;
9162 ffestb_local_.format.sign = TRUE; /* Sign present. */
9163 return (ffelexHandler) ffestb_R10014_;
9164
9165 default:
9166 ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9167 ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9168 ffelex_token_where_column (ffestb_local_.format.pre.t));
9169 ffebad_finish ();
9170 ffelex_token_kill (ffestb_local_.format.pre.t);
9171 return (ffelexHandler) ffestb_R10012_ (t);
9172 }
9173 }
9174
9175 /* ffestb_R10014_ -- "FORMAT" OPEN_PAREN [format-item-list] [[+/-] NUMBER]
9176
9177 return ffestb_R10014_; // to lexer
9178
9179 Here is where we expect to see the actual NAMES, COLON, SLASH, OPEN_PAREN,
9180 OPEN_ARRAY, COLONCOLON, CONCAT, DOLLAR, or HOLLERITH that identifies what
9181 kind of format-item we're dealing with. But if we see a NUMBER instead, it
9182 means free-form spaces number like "5 6 X", so scale the current number
9183 accordingly and reenter this state. (I really wouldn't be surprised if
9184 they change this spacing rule in the F90 spec so that you can't embed
9185 spaces within numbers or within keywords like BN in a free-source-form
9186 program.) */
9187
9188 static ffelexHandler
9189 ffestb_R10014_ (ffelexToken t)
9190 {
9191 ffesttFormatList f;
9192 ffeTokenLength i;
9193 const char *p;
9194 ffestrFormat kw;
9195
9196 ffelex_set_expecting_hollerith (0, '\0',
9197 ffewhere_line_unknown (),
9198 ffewhere_column_unknown ());
9199
9200 switch (ffelex_token_type (t))
9201 {
9202 case FFELEX_typeHOLLERITH:
9203 f = ffestt_formatlist_append (ffestb_local_.format.f);
9204 f->type = FFESTP_formattypeR1016;
9205 f->t = ffelex_token_use (t);
9206 ffelex_token_kill (ffestb_local_.format.pre.t); /* It WAS present! */
9207 return (ffelexHandler) ffestb_R100111_;
9208
9209 case FFELEX_typeNUMBER:
9210 assert (ffestb_local_.format.pre.present);
9211 ffesta_confirmed ();
9212 if (ffestb_local_.format.pre.rtexpr)
9213 {
9214 ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
9215 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9216 ffebad_finish ();
9217 return (ffelexHandler) ffestb_R10014_;
9218 }
9219 if (ffestb_local_.format.sign)
9220 {
9221 for (i = ffelex_token_length (t) + 1; i > 0; --i)
9222 ffestb_local_.format.pre.u.signed_val *= 10;
9223 ffestb_local_.format.pre.u.signed_val += strtoul (ffelex_token_text (t),
9224 NULL, 10);
9225 }
9226 else
9227 {
9228 for (i = ffelex_token_length (t) + 1; i > 0; --i)
9229 ffestb_local_.format.pre.u.unsigned_val *= 10;
9230 ffestb_local_.format.pre.u.unsigned_val += strtoul (ffelex_token_text (t),
9231 NULL, 10);
9232 ffelex_set_expecting_hollerith (ffestb_local_.format.pre.u.unsigned_val,
9233 '\0',
9234 ffelex_token_where_line (t),
9235 ffelex_token_where_column (t));
9236 }
9237 return (ffelexHandler) ffestb_R10014_;
9238
9239 case FFELEX_typeCOLONCOLON: /* "::". */
9240 if (ffestb_local_.format.pre.present)
9241 {
9242 ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_COLON_SPEC,
9243 ffestb_local_.format.pre.t);
9244 ffelex_token_kill (ffestb_local_.format.pre.t);
9245 ffestb_local_.format.pre.present = FALSE;
9246 }
9247 else
9248 {
9249 f = ffestt_formatlist_append (ffestb_local_.format.f);
9250 f->type = FFESTP_formattypeCOLON;
9251 f->t = ffelex_token_use (t);
9252 f->u.R1010.val.present = FALSE;
9253 f->u.R1010.val.rtexpr = FALSE;
9254 f->u.R1010.val.t = NULL;
9255 f->u.R1010.val.u.unsigned_val = 1;
9256 }
9257 f = ffestt_formatlist_append (ffestb_local_.format.f);
9258 f->type = FFESTP_formattypeCOLON;
9259 f->t = ffelex_token_use (t);
9260 f->u.R1010.val.present = FALSE;
9261 f->u.R1010.val.rtexpr = FALSE;
9262 f->u.R1010.val.t = NULL;
9263 f->u.R1010.val.u.unsigned_val = 1;
9264 return (ffelexHandler) ffestb_R100112_;
9265
9266 case FFELEX_typeCOLON:
9267 if (ffestb_local_.format.pre.present)
9268 {
9269 ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_COLON_SPEC,
9270 ffestb_local_.format.pre.t);
9271 ffelex_token_kill (ffestb_local_.format.pre.t);
9272 return (ffelexHandler) ffestb_R100112_;
9273 }
9274 f = ffestt_formatlist_append (ffestb_local_.format.f);
9275 f->type = FFESTP_formattypeCOLON;
9276 f->t = ffelex_token_use (t);
9277 f->u.R1010.val.present = FALSE;
9278 f->u.R1010.val.rtexpr = FALSE;
9279 f->u.R1010.val.t = NULL;
9280 f->u.R1010.val.u.unsigned_val = 1;
9281 return (ffelexHandler) ffestb_R100112_;
9282
9283 case FFELEX_typeCONCAT: /* "//". */
9284 if (ffestb_local_.format.sign)
9285 {
9286 ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9287 ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9288 ffelex_token_where_column (ffestb_local_.format.pre.t));
9289 ffebad_finish ();
9290 ffestb_local_.format.pre.u.unsigned_val
9291 = (ffestb_local_.format.pre.u.signed_val < 0)
9292 ? -ffestb_local_.format.pre.u.signed_val
9293 : ffestb_local_.format.pre.u.signed_val;
9294 }
9295 f = ffestt_formatlist_append (ffestb_local_.format.f);
9296 f->type = FFESTP_formattypeSLASH;
9297 f->t = ffelex_token_use (t);
9298 f->u.R1010.val = ffestb_local_.format.pre;
9299 ffestb_local_.format.pre.present = FALSE;
9300 ffestb_local_.format.pre.rtexpr = FALSE;
9301 ffestb_local_.format.pre.t = NULL;
9302 ffestb_local_.format.pre.u.unsigned_val = 1;
9303 f = ffestt_formatlist_append (ffestb_local_.format.f);
9304 f->type = FFESTP_formattypeSLASH;
9305 f->t = ffelex_token_use (t);
9306 f->u.R1010.val = ffestb_local_.format.pre;
9307 return (ffelexHandler) ffestb_R100112_;
9308
9309 case FFELEX_typeSLASH:
9310 if (ffestb_local_.format.sign)
9311 {
9312 ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9313 ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9314 ffelex_token_where_column (ffestb_local_.format.pre.t));
9315 ffebad_finish ();
9316 ffestb_local_.format.pre.u.unsigned_val
9317 = (ffestb_local_.format.pre.u.signed_val < 0)
9318 ? -ffestb_local_.format.pre.u.signed_val
9319 : ffestb_local_.format.pre.u.signed_val;
9320 }
9321 f = ffestt_formatlist_append (ffestb_local_.format.f);
9322 f->type = FFESTP_formattypeSLASH;
9323 f->t = ffelex_token_use (t);
9324 f->u.R1010.val = ffestb_local_.format.pre;
9325 return (ffelexHandler) ffestb_R100112_;
9326
9327 case FFELEX_typeOPEN_PAREN:
9328 if (ffestb_local_.format.sign)
9329 {
9330 ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9331 ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9332 ffelex_token_where_column (ffestb_local_.format.pre.t));
9333 ffebad_finish ();
9334 ffestb_local_.format.pre.u.unsigned_val
9335 = (ffestb_local_.format.pre.u.signed_val < 0)
9336 ? -ffestb_local_.format.pre.u.signed_val
9337 : ffestb_local_.format.pre.u.signed_val;
9338 }
9339 f = ffestt_formatlist_append (ffestb_local_.format.f);
9340 f->type = FFESTP_formattypeFORMAT;
9341 f->t = ffelex_token_use (t);
9342 f->u.R1003D.R1004 = ffestb_local_.format.pre;
9343 f->u.R1003D.format = ffestb_local_.format.f
9344 = ffestt_formatlist_create (f, ffelex_token_use (t));
9345 return (ffelexHandler) ffestb_R10011_;
9346
9347 case FFELEX_typeOPEN_ARRAY:/* "(/". */
9348 if (ffestb_local_.format.sign)
9349 {
9350 ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9351 ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9352 ffelex_token_where_column (ffestb_local_.format.pre.t));
9353 ffebad_finish ();
9354 ffestb_local_.format.pre.u.unsigned_val
9355 = (ffestb_local_.format.pre.u.signed_val < 0)
9356 ? -ffestb_local_.format.pre.u.signed_val
9357 : ffestb_local_.format.pre.u.signed_val;
9358 }
9359 f = ffestt_formatlist_append (ffestb_local_.format.f);
9360 f->type = FFESTP_formattypeFORMAT;
9361 f->t = ffelex_token_use (t);
9362 f->u.R1003D.R1004 = ffestb_local_.format.pre;
9363 f->u.R1003D.format = ffestb_local_.format.f
9364 = ffestt_formatlist_create (f, ffelex_token_use (t));
9365 f = ffestt_formatlist_append (ffestb_local_.format.f);
9366 f->type = FFESTP_formattypeSLASH;
9367 f->t = ffelex_token_use (t);
9368 f->u.R1010.val.present = FALSE;
9369 f->u.R1010.val.rtexpr = FALSE;
9370 f->u.R1010.val.t = NULL;
9371 f->u.R1010.val.u.unsigned_val = 1;
9372 return (ffelexHandler) ffestb_R100112_;
9373
9374 case FFELEX_typeCLOSE_ARRAY: /* "/)". */
9375 f = ffestt_formatlist_append (ffestb_local_.format.f);
9376 f->type = FFESTP_formattypeSLASH;
9377 f->t = ffelex_token_use (t);
9378 f->u.R1010.val = ffestb_local_.format.pre;
9379 f = ffestb_local_.format.f->u.root.parent;
9380 if (f == NULL)
9381 return (ffelexHandler) ffestb_R100114_;
9382 ffestb_local_.format.f = f->next;
9383 return (ffelexHandler) ffestb_R100111_;
9384
9385 case FFELEX_typeQUOTE:
9386 if (ffe_is_vxt ())
9387 break; /* A totally bad character in a VXT FORMAT. */
9388 ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
9389 ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9390 ffelex_token_where_column (ffestb_local_.format.pre.t));
9391 ffebad_finish ();
9392 ffelex_token_kill (ffestb_local_.format.pre.t);
9393 ffesta_confirmed ();
9394 #if 0 /* No apparent need for this, and not killed
9395 anywhere. */
9396 ffesta_tokens[1] = ffelex_token_use (t);
9397 #endif
9398 ffelex_set_expecting_hollerith (-1, '\"',
9399 ffelex_token_where_line (t),
9400 ffelex_token_where_column (t)); /* Don't have to unset
9401 this one. */
9402 return (ffelexHandler) ffestb_R100113_;
9403
9404 case FFELEX_typeAPOSTROPHE:
9405 ffesta_confirmed ();
9406 ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
9407 ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9408 ffelex_token_where_column (ffestb_local_.format.pre.t));
9409 ffebad_finish ();
9410 ffelex_token_kill (ffestb_local_.format.pre.t);
9411 #if 0 /* No apparent need for this, and not killed
9412 anywhere. */
9413 ffesta_tokens[1] = ffelex_token_use (t);
9414 #endif
9415 ffelex_set_expecting_hollerith (-1, '\'', ffelex_token_where_line (t),
9416 ffelex_token_where_column (t)); /* Don't have to unset
9417 this one. */
9418 return (ffelexHandler) ffestb_R100113_;
9419
9420 case FFELEX_typeEOS:
9421 case FFELEX_typeSEMICOLON:
9422 ffesta_confirmed ();
9423 ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
9424 for (f = ffestb_local_.format.f;
9425 f->u.root.parent != NULL;
9426 f = f->u.root.parent->next)
9427 ;
9428 ffestb_local_.format.f = f;
9429 ffelex_token_kill (ffestb_local_.format.pre.t);
9430 return (ffelexHandler) ffestb_R100114_ (t);
9431
9432 case FFELEX_typeDOLLAR:
9433 ffestb_local_.format.t = ffelex_token_use (t);
9434 if (ffestb_local_.format.pre.present)
9435 ffesta_confirmed (); /* Number preceding this invalid elsewhere. */
9436 ffestb_local_.format.current = FFESTP_formattypeDOLLAR;
9437 return (ffelexHandler) ffestb_R10015_;
9438
9439 case FFELEX_typeNAMES:
9440 kw = ffestr_format (t);
9441 ffestb_local_.format.t = ffelex_token_use (t);
9442 switch (kw)
9443 {
9444 case FFESTR_formatI:
9445 if (ffestb_local_.format.pre.present)
9446 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9447 ffestb_local_.format.current = FFESTP_formattypeI;
9448 i = FFESTR_formatlI;
9449 break;
9450
9451 case FFESTR_formatB:
9452 if (ffestb_local_.format.pre.present)
9453 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9454 ffestb_local_.format.current = FFESTP_formattypeB;
9455 i = FFESTR_formatlB;
9456 break;
9457
9458 case FFESTR_formatO:
9459 if (ffestb_local_.format.pre.present)
9460 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9461 ffestb_local_.format.current = FFESTP_formattypeO;
9462 i = FFESTR_formatlO;
9463 break;
9464
9465 case FFESTR_formatZ:
9466 if (ffestb_local_.format.pre.present)
9467 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9468 ffestb_local_.format.current = FFESTP_formattypeZ;
9469 i = FFESTR_formatlZ;
9470 break;
9471
9472 case FFESTR_formatF:
9473 if (ffestb_local_.format.pre.present)
9474 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9475 ffestb_local_.format.current = FFESTP_formattypeF;
9476 i = FFESTR_formatlF;
9477 break;
9478
9479 case FFESTR_formatE:
9480 ffestb_local_.format.current = FFESTP_formattypeE;
9481 i = FFESTR_formatlE;
9482 break;
9483
9484 case FFESTR_formatEN:
9485 if (ffestb_local_.format.pre.present)
9486 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9487 ffestb_local_.format.current = FFESTP_formattypeEN;
9488 i = FFESTR_formatlEN;
9489 break;
9490
9491 case FFESTR_formatG:
9492 if (ffestb_local_.format.pre.present)
9493 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9494 ffestb_local_.format.current = FFESTP_formattypeG;
9495 i = FFESTR_formatlG;
9496 break;
9497
9498 case FFESTR_formatL:
9499 if (ffestb_local_.format.pre.present)
9500 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9501 ffestb_local_.format.current = FFESTP_formattypeL;
9502 i = FFESTR_formatlL;
9503 break;
9504
9505 case FFESTR_formatA:
9506 if (ffestb_local_.format.pre.present)
9507 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9508 ffestb_local_.format.current = FFESTP_formattypeA;
9509 i = FFESTR_formatlA;
9510 break;
9511
9512 case FFESTR_formatD:
9513 ffestb_local_.format.current = FFESTP_formattypeD;
9514 i = FFESTR_formatlD;
9515 break;
9516
9517 case FFESTR_formatQ:
9518 ffestb_local_.format.current = FFESTP_formattypeQ;
9519 i = FFESTR_formatlQ;
9520 break;
9521
9522 case FFESTR_formatDOLLAR:
9523 if (ffestb_local_.format.pre.present)
9524 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9525 ffestb_local_.format.current = FFESTP_formattypeDOLLAR;
9526 i = FFESTR_formatlDOLLAR;
9527 break;
9528
9529 case FFESTR_formatP:
9530 if (ffestb_local_.format.pre.present)
9531 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9532 ffestb_local_.format.current = FFESTP_formattypeP;
9533 i = FFESTR_formatlP;
9534 break;
9535
9536 case FFESTR_formatT:
9537 if (ffestb_local_.format.pre.present)
9538 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9539 ffestb_local_.format.current = FFESTP_formattypeT;
9540 i = FFESTR_formatlT;
9541 break;
9542
9543 case FFESTR_formatTL:
9544 if (ffestb_local_.format.pre.present)
9545 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9546 ffestb_local_.format.current = FFESTP_formattypeTL;
9547 i = FFESTR_formatlTL;
9548 break;
9549
9550 case FFESTR_formatTR:
9551 if (ffestb_local_.format.pre.present)
9552 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9553 ffestb_local_.format.current = FFESTP_formattypeTR;
9554 i = FFESTR_formatlTR;
9555 break;
9556
9557 case FFESTR_formatX:
9558 if (ffestb_local_.format.pre.present)
9559 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9560 ffestb_local_.format.current = FFESTP_formattypeX;
9561 i = FFESTR_formatlX;
9562 break;
9563
9564 case FFESTR_formatS:
9565 if (ffestb_local_.format.pre.present)
9566 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9567 ffestb_local_.format.current = FFESTP_formattypeS;
9568 i = FFESTR_formatlS;
9569 break;
9570
9571 case FFESTR_formatSP:
9572 if (ffestb_local_.format.pre.present)
9573 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9574 ffestb_local_.format.current = FFESTP_formattypeSP;
9575 i = FFESTR_formatlSP;
9576 break;
9577
9578 case FFESTR_formatSS:
9579 if (ffestb_local_.format.pre.present)
9580 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9581 ffestb_local_.format.current = FFESTP_formattypeSS;
9582 i = FFESTR_formatlSS;
9583 break;
9584
9585 case FFESTR_formatBN:
9586 if (ffestb_local_.format.pre.present)
9587 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9588 ffestb_local_.format.current = FFESTP_formattypeBN;
9589 i = FFESTR_formatlBN;
9590 break;
9591
9592 case FFESTR_formatBZ:
9593 if (ffestb_local_.format.pre.present)
9594 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9595 ffestb_local_.format.current = FFESTP_formattypeBZ;
9596 i = FFESTR_formatlBZ;
9597 break;
9598
9599 case FFESTR_formatH: /* Error, either "H" or "<expr>H". */
9600 if (ffestb_local_.format.pre.present)
9601 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9602 ffestb_local_.format.current = FFESTP_formattypeH;
9603 i = FFESTR_formatlH;
9604 break;
9605
9606 case FFESTR_formatPD:
9607 if (ffestb_local_.format.pre.present)
9608 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9609 ffestb_subr_R1001_append_p_ ();
9610 ffestb_local_.format.t = ffelex_token_name_from_names (t,
9611 FFESTR_formatlP, 1);
9612 ffestb_local_.format.sign = FALSE;
9613 ffestb_local_.format.pre.present = FALSE;
9614 ffestb_local_.format.pre.rtexpr = FALSE;
9615 ffestb_local_.format.pre.t = NULL;
9616 ffestb_local_.format.pre.u.unsigned_val = 1;
9617 ffestb_local_.format.current = FFESTP_formattypeD;
9618 i = FFESTR_formatlPD;
9619 break;
9620
9621 case FFESTR_formatPE:
9622 if (ffestb_local_.format.pre.present)
9623 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9624 ffestb_subr_R1001_append_p_ ();
9625 ffestb_local_.format.t = ffelex_token_name_from_names (t,
9626 FFESTR_formatlP, 1);
9627 ffestb_local_.format.sign = FALSE;
9628 ffestb_local_.format.pre.present = FALSE;
9629 ffestb_local_.format.pre.rtexpr = FALSE;
9630 ffestb_local_.format.pre.t = NULL;
9631 ffestb_local_.format.pre.u.unsigned_val = 1;
9632 ffestb_local_.format.current = FFESTP_formattypeE;
9633 i = FFESTR_formatlPE;
9634 break;
9635
9636 case FFESTR_formatPEN:
9637 if (ffestb_local_.format.pre.present)
9638 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9639 ffestb_subr_R1001_append_p_ ();
9640 ffestb_local_.format.t = ffelex_token_name_from_names (t,
9641 FFESTR_formatlP, 1);
9642 ffestb_local_.format.sign = FALSE;
9643 ffestb_local_.format.pre.present = FALSE;
9644 ffestb_local_.format.pre.rtexpr = FALSE;
9645 ffestb_local_.format.pre.t = NULL;
9646 ffestb_local_.format.pre.u.unsigned_val = 1;
9647 ffestb_local_.format.current = FFESTP_formattypeEN;
9648 i = FFESTR_formatlPEN;
9649 break;
9650
9651 case FFESTR_formatPF:
9652 if (ffestb_local_.format.pre.present)
9653 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9654 ffestb_subr_R1001_append_p_ ();
9655 ffestb_local_.format.t = ffelex_token_name_from_names (t,
9656 FFESTR_formatlP, 1);
9657 ffestb_local_.format.sign = FALSE;
9658 ffestb_local_.format.pre.present = FALSE;
9659 ffestb_local_.format.pre.rtexpr = FALSE;
9660 ffestb_local_.format.pre.t = NULL;
9661 ffestb_local_.format.pre.u.unsigned_val = 1;
9662 ffestb_local_.format.current = FFESTP_formattypeF;
9663 i = FFESTR_formatlPF;
9664 break;
9665
9666 case FFESTR_formatPG:
9667 if (ffestb_local_.format.pre.present)
9668 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9669 ffestb_subr_R1001_append_p_ ();
9670 ffestb_local_.format.t = ffelex_token_name_from_names (t,
9671 FFESTR_formatlP, 1);
9672 ffestb_local_.format.sign = FALSE;
9673 ffestb_local_.format.pre.present = FALSE;
9674 ffestb_local_.format.pre.rtexpr = FALSE;
9675 ffestb_local_.format.pre.t = NULL;
9676 ffestb_local_.format.pre.u.unsigned_val = 1;
9677 ffestb_local_.format.current = FFESTP_formattypeG;
9678 i = FFESTR_formatlPG;
9679 break;
9680
9681 default:
9682 if (ffestb_local_.format.pre.present)
9683 ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9684 ffestb_local_.format.current = FFESTP_formattypeNone;
9685 p = strpbrk (ffelex_token_text (t), "0123456789");
9686 if (p == NULL)
9687 i = ffelex_token_length (t);
9688 else
9689 i = p - ffelex_token_text (t);
9690 break;
9691 }
9692 p = ffelex_token_text (t) + i;
9693 if (*p == '\0')
9694 return (ffelexHandler) ffestb_R10015_;
9695 if (! ISDIGIT (*p))
9696 {
9697 if (ffestb_local_.format.current == FFESTP_formattypeH)
9698 p = strpbrk (p, "0123456789");
9699 else
9700 {
9701 p = NULL;
9702 ffestb_local_.format.current = FFESTP_formattypeNone;
9703 }
9704 if (p == NULL)
9705 return (ffelexHandler) ffestb_R10015_;
9706 i = p - ffelex_token_text (t); /* Collect digits. */
9707 }
9708 ffestb_local_.format.post.present = TRUE;
9709 ffestb_local_.format.post.rtexpr = FALSE;
9710 ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
9711 ffestb_local_.format.post.u.unsigned_val
9712 = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
9713 p += ffelex_token_length (ffestb_local_.format.post.t);
9714 i += ffelex_token_length (ffestb_local_.format.post.t);
9715 if (*p == '\0')
9716 return (ffelexHandler) ffestb_R10016_;
9717 if ((kw != FFESTR_formatP) ||
9718 !ffelex_is_firstnamechar ((unsigned char)*p))
9719 {
9720 if (ffestb_local_.format.current != FFESTP_formattypeH)
9721 ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
9722 return (ffelexHandler) ffestb_R10016_;
9723 }
9724
9725 /* Here we have [number]P[number][text]. Treat as
9726 [number]P,[number][text]. */
9727
9728 ffestb_subr_R1001_append_p_ ();
9729 t = ffestb_local_.format.t = ffelex_token_names_from_names (t, i, 0);
9730 ffestb_local_.format.sign = FALSE;
9731 ffestb_local_.format.pre = ffestb_local_.format.post;
9732 kw = ffestr_format (t);
9733 switch (kw)
9734 { /* Only a few possibilities here. */
9735 case FFESTR_formatD:
9736 ffestb_local_.format.current = FFESTP_formattypeD;
9737 i = FFESTR_formatlD;
9738 break;
9739
9740 case FFESTR_formatE:
9741 ffestb_local_.format.current = FFESTP_formattypeE;
9742 i = FFESTR_formatlE;
9743 break;
9744
9745 case FFESTR_formatEN:
9746 ffestb_local_.format.current = FFESTP_formattypeEN;
9747 i = FFESTR_formatlEN;
9748 break;
9749
9750 case FFESTR_formatF:
9751 ffestb_local_.format.current = FFESTP_formattypeF;
9752 i = FFESTR_formatlF;
9753 break;
9754
9755 case FFESTR_formatG:
9756 ffestb_local_.format.current = FFESTP_formattypeG;
9757 i = FFESTR_formatlG;
9758 break;
9759
9760 default:
9761 ffebad_start (FFEBAD_FORMAT_P_NOCOMMA);
9762 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9763 ffebad_finish ();
9764 ffestb_local_.format.current = FFESTP_formattypeNone;
9765 p = strpbrk (ffelex_token_text (t), "0123456789");
9766 if (p == NULL)
9767 i = ffelex_token_length (t);
9768 else
9769 i = p - ffelex_token_text (t);
9770 }
9771 p = ffelex_token_text (t) + i;
9772 if (*p == '\0')
9773 return (ffelexHandler) ffestb_R10015_;
9774 if (! ISDIGIT (*p))
9775 {
9776 ffestb_local_.format.current = FFESTP_formattypeNone;
9777 p = strpbrk (p, "0123456789");
9778 if (p == NULL)
9779 return (ffelexHandler) ffestb_R10015_;
9780 i = p - ffelex_token_text (t); /* Collect digits anyway. */
9781 }
9782 ffestb_local_.format.post.present = TRUE;
9783 ffestb_local_.format.post.rtexpr = FALSE;
9784 ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
9785 ffestb_local_.format.post.u.unsigned_val
9786 = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
9787 p += ffelex_token_length (ffestb_local_.format.post.t);
9788 i += ffelex_token_length (ffestb_local_.format.post.t);
9789 if (*p == '\0')
9790 return (ffelexHandler) ffestb_R10016_;
9791 ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
9792 return (ffelexHandler) ffestb_R10016_;
9793
9794 default:
9795 break;
9796 }
9797
9798 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
9799 if (ffestb_local_.format.pre.present)
9800 ffelex_token_kill (ffestb_local_.format.pre.t);
9801 ffestt_formatlist_kill (ffestb_local_.format.f);
9802 return (ffelexHandler) ffelex_swallow_tokens (t,
9803 (ffelexHandler) ffesta_zero);
9804 }
9805
9806 /* ffestb_R10015_ -- [[+/-] NUMBER] NAMES
9807
9808 return ffestb_R10015_; // to lexer
9809
9810 Here we've gotten at least the initial mnemonic for the edit descriptor.
9811 We expect either a NUMBER, for the post-mnemonic value, a NAMES, for
9812 further clarification (in free-form only, sigh) of the mnemonic, or
9813 anything else. In all cases we go to _6_, with the difference that for
9814 NUMBER and NAMES we send the next token rather than the current token. */
9815
9816 static ffelexHandler
9817 ffestb_R10015_ (ffelexToken t)
9818 {
9819 bool split_pea; /* New NAMES requires splitting kP from new
9820 edit desc. */
9821 ffestrFormat kw;
9822 const char *p;
9823 ffeTokenLength i;
9824
9825 switch (ffelex_token_type (t))
9826 {
9827 case FFELEX_typeOPEN_ANGLE:
9828 ffesta_confirmed ();
9829 ffestb_local_.format.post.t = ffelex_token_use (t);
9830 ffelex_set_names_pure (FALSE);
9831 if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
9832 {
9833 ffestb_local_.format.complained = TRUE;
9834 ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
9835 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9836 ffebad_finish ();
9837 }
9838 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
9839 FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100116_);
9840
9841 case FFELEX_typeNUMBER:
9842 ffestb_local_.format.post.present = TRUE;
9843 ffestb_local_.format.post.rtexpr = FALSE;
9844 ffestb_local_.format.post.t = ffelex_token_use (t);
9845 ffestb_local_.format.post.u.unsigned_val
9846 = strtoul (ffelex_token_text (t), NULL, 10);
9847 return (ffelexHandler) ffestb_R10016_;
9848
9849 case FFELEX_typeNAMES:
9850 ffesta_confirmed (); /* NAMES " " NAMES invalid elsewhere in
9851 free-form. */
9852 kw = ffestr_format (t);
9853 switch (ffestb_local_.format.current)
9854 {
9855 case FFESTP_formattypeP:
9856 split_pea = TRUE;
9857 break;
9858
9859 case FFESTP_formattypeH: /* An error, maintain this indicator. */
9860 kw = FFESTR_formatNone;
9861 split_pea = FALSE;
9862 break;
9863
9864 default:
9865 split_pea = FALSE;
9866 break;
9867 }
9868
9869 switch (kw)
9870 {
9871 case FFESTR_formatF:
9872 switch (ffestb_local_.format.current)
9873 {
9874 case FFESTP_formattypeP:
9875 ffestb_local_.format.current = FFESTP_formattypeF;
9876 break;
9877
9878 default:
9879 ffestb_local_.format.current = FFESTP_formattypeNone;
9880 break;
9881 }
9882 i = FFESTR_formatlF;
9883 break;
9884
9885 case FFESTR_formatE:
9886 switch (ffestb_local_.format.current)
9887 {
9888 case FFESTP_formattypeP:
9889 ffestb_local_.format.current = FFESTP_formattypeE;
9890 break;
9891
9892 default:
9893 ffestb_local_.format.current = FFESTP_formattypeNone;
9894 break;
9895 }
9896 i = FFESTR_formatlE;
9897 break;
9898
9899 case FFESTR_formatEN:
9900 switch (ffestb_local_.format.current)
9901 {
9902 case FFESTP_formattypeP:
9903 ffestb_local_.format.current = FFESTP_formattypeEN;
9904 break;
9905
9906 default:
9907 ffestb_local_.format.current = FFESTP_formattypeNone;
9908 break;
9909 }
9910 i = FFESTR_formatlEN;
9911 break;
9912
9913 case FFESTR_formatG:
9914 switch (ffestb_local_.format.current)
9915 {
9916 case FFESTP_formattypeP:
9917 ffestb_local_.format.current = FFESTP_formattypeG;
9918 break;
9919
9920 default:
9921 ffestb_local_.format.current = FFESTP_formattypeNone;
9922 break;
9923 }
9924 i = FFESTR_formatlG;
9925 break;
9926
9927 case FFESTR_formatL:
9928 switch (ffestb_local_.format.current)
9929 {
9930 case FFESTP_formattypeT:
9931 ffestb_local_.format.current = FFESTP_formattypeTL;
9932 break;
9933
9934 default:
9935 ffestb_local_.format.current = FFESTP_formattypeNone;
9936 break;
9937 }
9938 i = FFESTR_formatlL;
9939 break;
9940
9941 case FFESTR_formatD:
9942 switch (ffestb_local_.format.current)
9943 {
9944 case FFESTP_formattypeP:
9945 ffestb_local_.format.current = FFESTP_formattypeD;
9946 break;
9947
9948 default:
9949 ffestb_local_.format.current = FFESTP_formattypeNone;
9950 break;
9951 }
9952 i = FFESTR_formatlD;
9953 break;
9954
9955 case FFESTR_formatS:
9956 switch (ffestb_local_.format.current)
9957 {
9958 case FFESTP_formattypeS:
9959 ffestb_local_.format.current = FFESTP_formattypeSS;
9960 break;
9961
9962 default:
9963 ffestb_local_.format.current = FFESTP_formattypeNone;
9964 break;
9965 }
9966 i = FFESTR_formatlS;
9967 break;
9968
9969 case FFESTR_formatP:
9970 switch (ffestb_local_.format.current)
9971 {
9972 case FFESTP_formattypeS:
9973 ffestb_local_.format.current = FFESTP_formattypeSP;
9974 break;
9975
9976 default:
9977 ffestb_local_.format.current = FFESTP_formattypeNone;
9978 break;
9979 }
9980 i = FFESTR_formatlP;
9981 break;
9982
9983 case FFESTR_formatR:
9984 switch (ffestb_local_.format.current)
9985 {
9986 case FFESTP_formattypeT:
9987 ffestb_local_.format.current = FFESTP_formattypeTR;
9988 break;
9989
9990 default:
9991 ffestb_local_.format.current = FFESTP_formattypeNone;
9992 break;
9993 }
9994 i = FFESTR_formatlR;
9995 break;
9996
9997 case FFESTR_formatZ:
9998 switch (ffestb_local_.format.current)
9999 {
10000 case FFESTP_formattypeB:
10001 ffestb_local_.format.current = FFESTP_formattypeBZ;
10002 break;
10003
10004 default:
10005 ffestb_local_.format.current = FFESTP_formattypeNone;
10006 break;
10007 }
10008 i = FFESTR_formatlZ;
10009 break;
10010
10011 case FFESTR_formatN:
10012 switch (ffestb_local_.format.current)
10013 {
10014 case FFESTP_formattypeE:
10015 ffestb_local_.format.current = FFESTP_formattypeEN;
10016 break;
10017
10018 case FFESTP_formattypeB:
10019 ffestb_local_.format.current = FFESTP_formattypeBN;
10020 break;
10021
10022 default:
10023 ffestb_local_.format.current = FFESTP_formattypeNone;
10024 break;
10025 }
10026 i = FFESTR_formatlN;
10027 break;
10028
10029 default:
10030 if (ffestb_local_.format.current != FFESTP_formattypeH)
10031 ffestb_local_.format.current = FFESTP_formattypeNone;
10032 split_pea = FALSE; /* Go ahead and let the P be in the party. */
10033 p = strpbrk (ffelex_token_text (t), "0123456789");
10034 if (p == NULL)
10035 i = ffelex_token_length (t);
10036 else
10037 i = p - ffelex_token_text (t);
10038 }
10039
10040 if (split_pea)
10041 {
10042 ffestb_subr_R1001_append_p_ ();
10043 ffestb_local_.format.t = ffelex_token_use (t);
10044 ffestb_local_.format.sign = FALSE;
10045 ffestb_local_.format.pre.present = FALSE;
10046 ffestb_local_.format.pre.rtexpr = FALSE;
10047 ffestb_local_.format.pre.t = NULL;
10048 ffestb_local_.format.pre.u.unsigned_val = 1;
10049 }
10050
10051 p = ffelex_token_text (t) + i;
10052 if (*p == '\0')
10053 return (ffelexHandler) ffestb_R10015_;
10054 if (! ISDIGIT (*p))
10055 {
10056 ffestb_local_.format.current = FFESTP_formattypeNone;
10057 p = strpbrk (p, "0123456789");
10058 if (p == NULL)
10059 return (ffelexHandler) ffestb_R10015_;
10060 i = p - ffelex_token_text (t); /* Collect digits anyway. */
10061 }
10062 ffestb_local_.format.post.present = TRUE;
10063 ffestb_local_.format.post.rtexpr = FALSE;
10064 ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
10065 ffestb_local_.format.post.u.unsigned_val
10066 = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
10067 p += ffelex_token_length (ffestb_local_.format.post.t);
10068 i += ffelex_token_length (ffestb_local_.format.post.t);
10069 if (*p == '\0')
10070 return (ffelexHandler) ffestb_R10016_;
10071 ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
10072 return (ffelexHandler) ffestb_R10016_;
10073
10074 default:
10075 ffestb_local_.format.post.present = FALSE;
10076 ffestb_local_.format.post.rtexpr = FALSE;
10077 ffestb_local_.format.post.t = NULL;
10078 ffestb_local_.format.post.u.unsigned_val = 1;
10079 return (ffelexHandler) ffestb_R10016_ (t);
10080 }
10081 }
10082
10083 /* ffestb_R10016_ -- [[+/-] NUMBER] NAMES NUMBER
10084
10085 return ffestb_R10016_; // to lexer
10086
10087 Expect a PERIOD here. Maybe find a NUMBER to append to the current
10088 number, in which case return to this state. Maybe find a NAMES to switch
10089 from a kP descriptor to a new descriptor (else the NAMES is spurious),
10090 in which case generator the P item and go to state _4_. Anything
10091 else, pass token on to state _8_. */
10092
10093 static ffelexHandler
10094 ffestb_R10016_ (ffelexToken t)
10095 {
10096 ffeTokenLength i;
10097
10098 switch (ffelex_token_type (t))
10099 {
10100 case FFELEX_typePERIOD:
10101 return (ffelexHandler) ffestb_R10017_;
10102
10103 case FFELEX_typeNUMBER:
10104 assert (ffestb_local_.format.post.present);
10105 ffesta_confirmed ();
10106 if (ffestb_local_.format.post.rtexpr)
10107 {
10108 ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
10109 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10110 ffebad_finish ();
10111 return (ffelexHandler) ffestb_R10016_;
10112 }
10113 for (i = ffelex_token_length (t) + 1; i > 0; --i)
10114 ffestb_local_.format.post.u.unsigned_val *= 10;
10115 ffestb_local_.format.post.u.unsigned_val += strtoul (ffelex_token_text (t),
10116 NULL, 10);
10117 return (ffelexHandler) ffestb_R10016_;
10118
10119 case FFELEX_typeNAMES:
10120 ffesta_confirmed (); /* NUMBER " " NAMES invalid elsewhere. */
10121 if (ffestb_local_.format.current != FFESTP_formattypeP)
10122 {
10123 ffesta_ffebad_1t (FFEBAD_FORMAT_TEXT_IN_NUMBER, t);
10124 return (ffelexHandler) ffestb_R10016_;
10125 }
10126 ffestb_subr_R1001_append_p_ ();
10127 ffestb_local_.format.sign = FALSE;
10128 ffestb_local_.format.pre = ffestb_local_.format.post;
10129 return (ffelexHandler) ffestb_R10014_ (t);
10130
10131 default:
10132 ffestb_local_.format.dot.present = FALSE;
10133 ffestb_local_.format.dot.rtexpr = FALSE;
10134 ffestb_local_.format.dot.t = NULL;
10135 ffestb_local_.format.dot.u.unsigned_val = 1;
10136 return (ffelexHandler) ffestb_R10018_ (t);
10137 }
10138 }
10139
10140 /* ffestb_R10017_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD
10141
10142 return ffestb_R10017_; // to lexer
10143
10144 Here we've gotten the period following the edit descriptor.
10145 We expect either a NUMBER, for the dot value, or something else, which
10146 probably means we're not even close to being in a real FORMAT statement. */
10147
10148 static ffelexHandler
10149 ffestb_R10017_ (ffelexToken t)
10150 {
10151 switch (ffelex_token_type (t))
10152 {
10153 case FFELEX_typeOPEN_ANGLE:
10154 ffestb_local_.format.dot.t = ffelex_token_use (t);
10155 ffelex_set_names_pure (FALSE);
10156 if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
10157 {
10158 ffestb_local_.format.complained = TRUE;
10159 ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
10160 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10161 ffebad_finish ();
10162 }
10163 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
10164 FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100117_);
10165
10166 case FFELEX_typeNUMBER:
10167 ffestb_local_.format.dot.present = TRUE;
10168 ffestb_local_.format.dot.rtexpr = FALSE;
10169 ffestb_local_.format.dot.t = ffelex_token_use (t);
10170 ffestb_local_.format.dot.u.unsigned_val
10171 = strtoul (ffelex_token_text (t), NULL, 10);
10172 return (ffelexHandler) ffestb_R10018_;
10173
10174 default:
10175 ffelex_token_kill (ffestb_local_.format.t);
10176 if (ffestb_local_.format.pre.present)
10177 ffelex_token_kill (ffestb_local_.format.pre.t);
10178 if (ffestb_local_.format.post.present)
10179 ffelex_token_kill (ffestb_local_.format.post.t);
10180 ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_DOT, t);
10181 ffestt_formatlist_kill (ffestb_local_.format.f);
10182 return (ffelexHandler) ffelex_swallow_tokens (t,
10183 (ffelexHandler) ffesta_zero);
10184 }
10185 }
10186
10187 /* ffestb_R10018_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD NUMBER
10188
10189 return ffestb_R10018_; // to lexer
10190
10191 Expect a NAMES here, which must begin with "E" to be valid. Maybe find a
10192 NUMBER to append to the current number, in which case return to this state.
10193 Anything else, pass token on to state _10_. */
10194
10195 static ffelexHandler
10196 ffestb_R10018_ (ffelexToken t)
10197 {
10198 ffeTokenLength i;
10199 const char *p;
10200
10201 switch (ffelex_token_type (t))
10202 {
10203 case FFELEX_typeNUMBER:
10204 assert (ffestb_local_.format.dot.present);
10205 ffesta_confirmed ();
10206 if (ffestb_local_.format.dot.rtexpr)
10207 {
10208 ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
10209 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10210 ffebad_finish ();
10211 return (ffelexHandler) ffestb_R10018_;
10212 }
10213 for (i = ffelex_token_length (t) + 1; i > 0; --i)
10214 ffestb_local_.format.dot.u.unsigned_val *= 10;
10215 ffestb_local_.format.dot.u.unsigned_val += strtoul (ffelex_token_text (t),
10216 NULL, 10);
10217 return (ffelexHandler) ffestb_R10018_;
10218
10219 case FFELEX_typeNAMES:
10220 if (!ffesrc_char_match_init (*(p = ffelex_token_text (t)), 'E', 'e'))
10221 {
10222 ffesta_ffebad_1t (FFEBAD_FORMAT_TEXT_IN_NUMBER, t);
10223 return (ffelexHandler) ffestb_R10018_;
10224 }
10225 if (*++p == '\0')
10226 return (ffelexHandler) ffestb_R10019_; /* Go get NUMBER. */
10227 i = 1;
10228 if (! ISDIGIT (*p))
10229 {
10230 ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, 1, NULL);
10231 return (ffelexHandler) ffestb_R10018_;
10232 }
10233 ffestb_local_.format.exp.present = TRUE;
10234 ffestb_local_.format.exp.rtexpr = FALSE;
10235 ffestb_local_.format.exp.t = ffelex_token_number_from_names (t, i);
10236 ffestb_local_.format.exp.u.unsigned_val
10237 = strtoul (ffelex_token_text (ffestb_local_.format.exp.t), NULL, 10);
10238 p += ffelex_token_length (ffestb_local_.format.exp.t);
10239 i += ffelex_token_length (ffestb_local_.format.exp.t);
10240 if (*p == '\0')
10241 return (ffelexHandler) ffestb_R100110_;
10242 ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
10243 return (ffelexHandler) ffestb_R100110_;
10244
10245 default:
10246 ffestb_local_.format.exp.present = FALSE;
10247 ffestb_local_.format.exp.rtexpr = FALSE;
10248 ffestb_local_.format.exp.t = NULL;
10249 ffestb_local_.format.exp.u.unsigned_val = 1;
10250 return (ffelexHandler) ffestb_R100110_ (t);
10251 }
10252 }
10253
10254 /* ffestb_R10019_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD NUMBER "E"
10255
10256 return ffestb_R10019_; // to lexer
10257
10258 Here we've gotten the "E" following the edit descriptor.
10259 We expect either a NUMBER, for the exponent value, or something else. */
10260
10261 static ffelexHandler
10262 ffestb_R10019_ (ffelexToken t)
10263 {
10264 switch (ffelex_token_type (t))
10265 {
10266 case FFELEX_typeOPEN_ANGLE:
10267 ffestb_local_.format.exp.t = ffelex_token_use (t);
10268 ffelex_set_names_pure (FALSE);
10269 if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
10270 {
10271 ffestb_local_.format.complained = TRUE;
10272 ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
10273 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10274 ffebad_finish ();
10275 }
10276 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
10277 FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100118_);
10278
10279 case FFELEX_typeNUMBER:
10280 ffestb_local_.format.exp.present = TRUE;
10281 ffestb_local_.format.exp.rtexpr = FALSE;
10282 ffestb_local_.format.exp.t = ffelex_token_use (t);
10283 ffestb_local_.format.exp.u.unsigned_val
10284 = strtoul (ffelex_token_text (t), NULL, 10);
10285 return (ffelexHandler) ffestb_R100110_;
10286
10287 default:
10288 ffelex_token_kill (ffestb_local_.format.t);
10289 if (ffestb_local_.format.pre.present)
10290 ffelex_token_kill (ffestb_local_.format.pre.t);
10291 if (ffestb_local_.format.post.present)
10292 ffelex_token_kill (ffestb_local_.format.post.t);
10293 if (ffestb_local_.format.dot.present)
10294 ffelex_token_kill (ffestb_local_.format.dot.t);
10295 ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_EXP, t);
10296 ffestt_formatlist_kill (ffestb_local_.format.f);
10297 return (ffelexHandler) ffelex_swallow_tokens (t,
10298 (ffelexHandler) ffesta_zero);
10299 }
10300 }
10301
10302 /* ffestb_R100110_ -- [[+/-] NUMBER] NAMES NUMBER [PERIOD NUMBER ["E" NUMBER]]
10303
10304 return ffestb_R100110_; // to lexer
10305
10306 Maybe find a NUMBER to append to the current number, in which case return
10307 to this state. Anything else, handle current descriptor, then pass token
10308 on to state _10_. */
10309
10310 static ffelexHandler
10311 ffestb_R100110_ (ffelexToken t)
10312 {
10313 ffeTokenLength i;
10314 enum expect
10315 {
10316 required,
10317 optional,
10318 disallowed
10319 };
10320 ffebad err;
10321 enum expect pre;
10322 enum expect post;
10323 enum expect dot;
10324 enum expect exp;
10325 bool R1005;
10326 ffesttFormatList f;
10327
10328 switch (ffelex_token_type (t))
10329 {
10330 case FFELEX_typeNUMBER:
10331 assert (ffestb_local_.format.exp.present);
10332 ffesta_confirmed ();
10333 if (ffestb_local_.format.exp.rtexpr)
10334 {
10335 ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
10336 ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10337 ffebad_finish ();
10338 return (ffelexHandler) ffestb_R100110_;
10339 }
10340 for (i = ffelex_token_length (t) + 1; i > 0; --i)
10341 ffestb_local_.format.exp.u.unsigned_val *= 10;
10342 ffestb_local_.format.exp.u.unsigned_val += strtoul (ffelex_token_text (t),
10343 NULL, 10);
10344 return (ffelexHandler) ffestb_R100110_;
10345
10346 default:
10347 if (ffestb_local_.format.sign
10348 && (ffestb_local_.format.current != FFESTP_formattypeP)
10349 && (ffestb_local_.format.current != FFESTP_formattypeH))
10350 {
10351 ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
10352 ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
10353 ffelex_token_where_column (ffestb_local_.format.pre.t));
10354 ffebad_finish ();
10355 ffestb_local_.format.pre.u.unsigned_val
10356 = (ffestb_local_.format.pre.u.signed_val < 0)
10357 ? -ffestb_local_.format.pre.u.signed_val
10358 : ffestb_local_.format.pre.u.signed_val;
10359 }
10360 switch (ffestb_local_.format.current)
10361 {
10362 case FFESTP_formattypeI:
10363 err = FFEBAD_FORMAT_BAD_I_SPEC;
10364 pre = optional;
10365 post = required;
10366 dot = optional;
10367 exp = disallowed;
10368 R1005 = TRUE;
10369 break;
10370
10371 case FFESTP_formattypeB:
10372 err = FFEBAD_FORMAT_BAD_B_SPEC;
10373 pre = optional;
10374 post = required;
10375 dot = optional;
10376 exp = disallowed;
10377 R1005 = TRUE;
10378 break;
10379
10380 case FFESTP_formattypeO:
10381 err = FFEBAD_FORMAT_BAD_O_SPEC;
10382 pre = optional;
10383 post = required;
10384 dot = optional;
10385 exp = disallowed;
10386 R1005 = TRUE;
10387 break;
10388
10389 case FFESTP_formattypeZ:
10390 err = FFEBAD_FORMAT_BAD_Z_SPEC;
10391 pre = optional;
10392 post = required;
10393 dot = optional;
10394 exp = disallowed;
10395 R1005 = TRUE;
10396 break;
10397
10398 case FFESTP_formattypeF:
10399 err = FFEBAD_FORMAT_BAD_F_SPEC;
10400 pre = optional;
10401 post = required;
10402 dot = required;
10403 exp = disallowed;
10404 R1005 = TRUE;
10405 break;
10406
10407 case FFESTP_formattypeE:
10408 err = FFEBAD_FORMAT_BAD_E_SPEC;
10409 pre = optional;
10410 post = required;
10411 dot = required;
10412 exp = optional;
10413 R1005 = TRUE;
10414 break;
10415
10416 case FFESTP_formattypeEN:
10417 err = FFEBAD_FORMAT_BAD_EN_SPEC;
10418 pre = optional;
10419 post = required;
10420 dot = required;
10421 exp = optional;
10422 R1005 = TRUE;
10423 break;
10424
10425 case FFESTP_formattypeG:
10426 err = FFEBAD_FORMAT_BAD_G_SPEC;
10427 pre = optional;
10428 post = required;
10429 dot = required;
10430 exp = optional;
10431 R1005 = TRUE;
10432 break;
10433
10434 case FFESTP_formattypeL:
10435 err = FFEBAD_FORMAT_BAD_L_SPEC;
10436 pre = optional;
10437 post = required;
10438 dot = disallowed;
10439 exp = disallowed;
10440 R1005 = TRUE;
10441 break;
10442
10443 case FFESTP_formattypeA:
10444 err = FFEBAD_FORMAT_BAD_A_SPEC;
10445 pre = optional;
10446 post = optional;
10447 dot = disallowed;
10448 exp = disallowed;
10449 R1005 = TRUE;
10450 break;
10451
10452 case FFESTP_formattypeD:
10453 err = FFEBAD_FORMAT_BAD_D_SPEC;
10454 pre = optional;
10455 post = required;
10456 dot = required;
10457 exp = disallowed;
10458 R1005 = TRUE;
10459 break;
10460
10461 case FFESTP_formattypeQ:
10462 err = FFEBAD_FORMAT_BAD_Q_SPEC;
10463 pre = disallowed;
10464 post = disallowed;
10465 dot = disallowed;
10466 exp = disallowed;
10467 R1005 = FALSE;
10468 break;
10469
10470 case FFESTP_formattypeDOLLAR:
10471 err = FFEBAD_FORMAT_BAD_DOLLAR_SPEC;
10472 pre = disallowed;
10473 post = disallowed;
10474 dot = disallowed;
10475 exp = disallowed;
10476 R1005 = FALSE;
10477 break;
10478
10479 case FFESTP_formattypeP:
10480 err = FFEBAD_FORMAT_BAD_P_SPEC;
10481 pre = required;
10482 post = disallowed;
10483 dot = disallowed;
10484 exp = disallowed;
10485 R1005 = FALSE;
10486 break;
10487
10488 case FFESTP_formattypeT:
10489 err = FFEBAD_FORMAT_BAD_T_SPEC;
10490 pre = disallowed;
10491 post = required;
10492 dot = disallowed;
10493 exp = disallowed;
10494 R1005 = FALSE;
10495 break;
10496
10497 case FFESTP_formattypeTL:
10498 err = FFEBAD_FORMAT_BAD_TL_SPEC;
10499 pre = disallowed;
10500 post = required;
10501 dot = disallowed;
10502 exp = disallowed;
10503 R1005 = FALSE;
10504 break;
10505
10506 case FFESTP_formattypeTR:
10507 err = FFEBAD_FORMAT_BAD_TR_SPEC;
10508 pre = disallowed;
10509 post = required;
10510 dot = disallowed;
10511 exp = disallowed;
10512 R1005 = FALSE;
10513 break;
10514
10515 case FFESTP_formattypeX:
10516 err = FFEBAD_FORMAT_BAD_X_SPEC;
10517 pre = required;
10518 post = disallowed;
10519 dot = disallowed;
10520 exp = disallowed;
10521 R1005 = FALSE;
10522 break;
10523
10524 case FFESTP_formattypeS:
10525 err = FFEBAD_FORMAT_BAD_S_SPEC;
10526 pre = disallowed;
10527 post = disallowed;
10528 dot = disallowed;
10529 exp = disallowed;
10530 R1005 = FALSE;
10531 break;
10532
10533 case FFESTP_formattypeSP:
10534 err = FFEBAD_FORMAT_BAD_SP_SPEC;
10535 pre = disallowed;
10536 post = disallowed;
10537 dot = disallowed;
10538 exp = disallowed;
10539 R1005 = FALSE;
10540 break;
10541
10542 case FFESTP_formattypeSS:
10543 err = FFEBAD_FORMAT_BAD_SS_SPEC;
10544 pre = disallowed;
10545 post = disallowed;
10546 dot = disallowed;
10547 exp = disallowed;
10548 R1005 = FALSE;
10549 break;
10550
10551 case FFESTP_formattypeBN:
10552 err = FFEBAD_FORMAT_BAD_BN_SPEC;
10553 pre = disallowed;
10554 post = disallowed;
10555 dot = disallowed;
10556 exp = disallowed;
10557 R1005 = FALSE;
10558 break;
10559
10560 case FFESTP_formattypeBZ:
10561 err = FFEBAD_FORMAT_BAD_BZ_SPEC;
10562 pre = disallowed;
10563 post = disallowed;
10564 dot = disallowed;
10565 exp = disallowed;
10566 R1005 = FALSE;
10567 break;
10568
10569 case FFESTP_formattypeH: /* Definitely an error, make sure of
10570 it. */
10571 err = FFEBAD_FORMAT_BAD_H_SPEC;
10572 pre = ffestb_local_.format.pre.present ? disallowed : required;
10573 post = disallowed;
10574 dot = disallowed;
10575 exp = disallowed;
10576 R1005 = FALSE;
10577 break;
10578
10579 case FFESTP_formattypeNone:
10580 ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_SPEC,
10581 ffestb_local_.format.t);
10582
10583 clean_up_to_11_: /* :::::::::::::::::::: */
10584
10585 ffelex_token_kill (ffestb_local_.format.t);
10586 if (ffestb_local_.format.pre.present)
10587 ffelex_token_kill (ffestb_local_.format.pre.t);
10588 if (ffestb_local_.format.post.present)
10589 ffelex_token_kill (ffestb_local_.format.post.t);
10590 if (ffestb_local_.format.dot.present)
10591 ffelex_token_kill (ffestb_local_.format.dot.t);
10592 if (ffestb_local_.format.exp.present)
10593 ffelex_token_kill (ffestb_local_.format.exp.t);
10594 return (ffelexHandler) ffestb_R100111_ (t);
10595
10596 default:
10597 assert ("bad format item" == NULL);
10598 err = FFEBAD_FORMAT_BAD_H_SPEC;
10599 pre = disallowed;
10600 post = disallowed;
10601 dot = disallowed;
10602 exp = disallowed;
10603 R1005 = FALSE;
10604 break;
10605 }
10606 if (((pre == disallowed) && ffestb_local_.format.pre.present)
10607 || ((pre == required) && !ffestb_local_.format.pre.present))
10608 {
10609 ffesta_ffebad_1t (err, (pre == required)
10610 ? ffestb_local_.format.t : ffestb_local_.format.pre.t);
10611 goto clean_up_to_11_; /* :::::::::::::::::::: */
10612 }
10613 if (((post == disallowed) && ffestb_local_.format.post.present)
10614 || ((post == required) && !ffestb_local_.format.post.present))
10615 {
10616 ffesta_ffebad_1t (err, (post == required)
10617 ? ffestb_local_.format.t : ffestb_local_.format.post.t);
10618 goto clean_up_to_11_; /* :::::::::::::::::::: */
10619 }
10620 if (((dot == disallowed) && ffestb_local_.format.dot.present)
10621 || ((dot == required) && !ffestb_local_.format.dot.present))
10622 {
10623 ffesta_ffebad_1t (err, (dot == required)
10624 ? ffestb_local_.format.t : ffestb_local_.format.dot.t);
10625 goto clean_up_to_11_; /* :::::::::::::::::::: */
10626 }
10627 if (((exp == disallowed) && ffestb_local_.format.exp.present)
10628 || ((exp == required) && !ffestb_local_.format.exp.present))
10629 {
10630 ffesta_ffebad_1t (err, (exp == required)
10631 ? ffestb_local_.format.t : ffestb_local_.format.exp.t);
10632 goto clean_up_to_11_; /* :::::::::::::::::::: */
10633 }
10634 f = ffestt_formatlist_append (ffestb_local_.format.f);
10635 f->type = ffestb_local_.format.current;
10636 f->t = ffestb_local_.format.t;
10637 if (R1005)
10638 {
10639 f->u.R1005.R1004 = ffestb_local_.format.pre;
10640 f->u.R1005.R1006 = ffestb_local_.format.post;
10641 f->u.R1005.R1007_or_R1008 = ffestb_local_.format.dot;
10642 f->u.R1005.R1009 = ffestb_local_.format.exp;
10643 }
10644 else
10645 /* Must be R1010. */
10646 {
10647 if (pre == disallowed)
10648 f->u.R1010.val = ffestb_local_.format.post;
10649 else
10650 f->u.R1010.val = ffestb_local_.format.pre;
10651 }
10652 return (ffelexHandler) ffestb_R100111_ (t);
10653 }
10654 }
10655
10656 /* ffestb_R100111_ -- edit-descriptor
10657
10658 return ffestb_R100111_; // to lexer
10659
10660 Expect a COMMA, CLOSE_PAREN, CLOSE_ARRAY, COLON, COLONCOLON, SLASH, or
10661 CONCAT, or complain about missing comma. */
10662
10663 static ffelexHandler
10664 ffestb_R100111_ (ffelexToken t)
10665 {
10666 ffesttFormatList f;
10667
10668 switch (ffelex_token_type (t))
10669 {
10670 case FFELEX_typeCOMMA:
10671 return (ffelexHandler) ffestb_R10012_;
10672
10673 case FFELEX_typeCOLON:
10674 case FFELEX_typeCOLONCOLON:
10675 case FFELEX_typeSLASH:
10676 case FFELEX_typeCONCAT:
10677 return (ffelexHandler) ffestb_R10012_ (t);
10678
10679 case FFELEX_typeCLOSE_PAREN:
10680 f = ffestb_local_.format.f->u.root.parent;
10681 if (f == NULL)
10682 return (ffelexHandler) ffestb_R100114_;
10683 ffestb_local_.format.f = f->next;
10684 return (ffelexHandler) ffestb_R100111_;
10685
10686 case FFELEX_typeCLOSE_ARRAY: /* "/)". */
10687 f = ffestt_formatlist_append (ffestb_local_.format.f);
10688 f->type = FFESTP_formattypeSLASH;
10689 f->t = ffelex_token_use (t);
10690 f->u.R1010.val.present = FALSE;
10691 f->u.R1010.val.rtexpr = FALSE;
10692 f->u.R1010.val.t = NULL;
10693 f->u.R1010.val.u.unsigned_val = 1;
10694 f = ffestb_local_.format.f->u.root.parent;
10695 if (f == NULL)
10696 return (ffelexHandler) ffestb_R100114_;
10697 ffestb_local_.format.f = f->next;
10698 return (ffelexHandler) ffestb_R100111_;
10699
10700 case FFELEX_typeOPEN_ANGLE:
10701 case FFELEX_typeDOLLAR:
10702 case FFELEX_typeNUMBER:
10703 case FFELEX_typeOPEN_PAREN:
10704 case FFELEX_typeOPEN_ARRAY:
10705 case FFELEX_typeQUOTE:
10706 case FFELEX_typeAPOSTROPHE:
10707 case FFELEX_typeNAMES:
10708 ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_COMMA, t);
10709 return (ffelexHandler) ffestb_R10012_ (t);
10710
10711 case FFELEX_typeEOS:
10712 case FFELEX_typeSEMICOLON:
10713 ffesta_confirmed ();
10714 ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
10715 for (f = ffestb_local_.format.f;
10716 f->u.root.parent != NULL;
10717 f = f->u.root.parent->next)
10718 ;
10719 ffestb_local_.format.f = f;
10720 return (ffelexHandler) ffestb_R100114_ (t);
10721
10722 default:
10723 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10724 ffestt_formatlist_kill (ffestb_local_.format.f);
10725 return (ffelexHandler) ffelex_swallow_tokens (t,
10726 (ffelexHandler) ffesta_zero);
10727 }
10728 }
10729
10730 /* ffestb_R100112_ -- COLON, COLONCOLON, SLASH, OPEN_ARRAY, or CONCAT
10731
10732 return ffestb_R100112_; // to lexer
10733
10734 Like _11_ except the COMMA is optional. */
10735
10736 static ffelexHandler
10737 ffestb_R100112_ (ffelexToken t)
10738 {
10739 ffesttFormatList f;
10740
10741 switch (ffelex_token_type (t))
10742 {
10743 case FFELEX_typeCOMMA:
10744 return (ffelexHandler) ffestb_R10012_;
10745
10746 case FFELEX_typeCOLON:
10747 case FFELEX_typeCOLONCOLON:
10748 case FFELEX_typeSLASH:
10749 case FFELEX_typeCONCAT:
10750 case FFELEX_typeOPEN_ANGLE:
10751 case FFELEX_typeNAMES:
10752 case FFELEX_typeDOLLAR:
10753 case FFELEX_typeNUMBER:
10754 case FFELEX_typeOPEN_PAREN:
10755 case FFELEX_typeOPEN_ARRAY:
10756 case FFELEX_typeQUOTE:
10757 case FFELEX_typeAPOSTROPHE:
10758 case FFELEX_typePLUS:
10759 case FFELEX_typeMINUS:
10760 return (ffelexHandler) ffestb_R10012_ (t);
10761
10762 case FFELEX_typeCLOSE_PAREN:
10763 f = ffestb_local_.format.f->u.root.parent;
10764 if (f == NULL)
10765 return (ffelexHandler) ffestb_R100114_;
10766 ffestb_local_.format.f = f->next;
10767 return (ffelexHandler) ffestb_R100111_;
10768
10769 case FFELEX_typeCLOSE_ARRAY: /* "/)". */
10770 f = ffestt_formatlist_append (ffestb_local_.format.f);
10771 f->type = FFESTP_formattypeSLASH;
10772 f->t = ffelex_token_use (t);
10773 f->u.R1010.val.present = FALSE;
10774 f->u.R1010.val.rtexpr = FALSE;
10775 f->u.R1010.val.t = NULL;
10776 f->u.R1010.val.u.unsigned_val = 1;
10777 f = ffestb_local_.format.f->u.root.parent;
10778 if (f == NULL)
10779 return (ffelexHandler) ffestb_R100114_;
10780 ffestb_local_.format.f = f->next;
10781 return (ffelexHandler) ffestb_R100111_;
10782
10783 case FFELEX_typeEOS:
10784 case FFELEX_typeSEMICOLON:
10785 ffesta_confirmed ();
10786 ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
10787 for (f = ffestb_local_.format.f;
10788 f->u.root.parent != NULL;
10789 f = f->u.root.parent->next)
10790 ;
10791 ffestb_local_.format.f = f;
10792 return (ffelexHandler) ffestb_R100114_ (t);
10793
10794 default:
10795 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10796 ffestt_formatlist_kill (ffestb_local_.format.f);
10797 return (ffelexHandler) ffelex_swallow_tokens (t,
10798 (ffelexHandler) ffesta_zero);
10799 }
10800 }
10801
10802 /* ffestb_R100113_ -- Handle CHARACTER token.
10803
10804 return ffestb_R100113_; // to lexer
10805
10806 Append the format item to the list, go to _11_. */
10807
10808 static ffelexHandler
10809 ffestb_R100113_ (ffelexToken t)
10810 {
10811 ffesttFormatList f;
10812
10813 assert (ffelex_token_type (t) == FFELEX_typeCHARACTER);
10814
10815 if (ffe_is_pedantic_not_90 () && (ffelex_token_length (t) == 0))
10816 {
10817 ffebad_start (FFEBAD_NULL_CHAR_CONST);
10818 ffebad_here (0, ffelex_token_where_line (t),
10819 ffelex_token_where_column (t));
10820 ffebad_finish ();
10821 }
10822
10823 f = ffestt_formatlist_append (ffestb_local_.format.f);
10824 f->type = FFESTP_formattypeR1016;
10825 f->t = ffelex_token_use (t);
10826 return (ffelexHandler) ffestb_R100111_;
10827 }
10828
10829 /* ffestb_R100114_ -- "FORMAT" OPEN_PAREN format-item-list CLOSE_PAREN
10830
10831 return ffestb_R100114_; // to lexer
10832
10833 Handle EOS/SEMICOLON or something else. */
10834
10835 static ffelexHandler
10836 ffestb_R100114_ (ffelexToken t)
10837 {
10838 ffelex_set_names_pure (FALSE);
10839
10840 switch (ffelex_token_type (t))
10841 {
10842 case FFELEX_typeEOS:
10843 case FFELEX_typeSEMICOLON:
10844 ffesta_confirmed ();
10845 if (!ffesta_is_inhibited () && !ffestb_local_.format.complained)
10846 ffestc_R1001 (ffestb_local_.format.f);
10847 ffestt_formatlist_kill (ffestb_local_.format.f);
10848 return (ffelexHandler) ffesta_zero (t);
10849
10850 default:
10851 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10852 ffestt_formatlist_kill (ffestb_local_.format.f);
10853 return (ffelexHandler) ffelex_swallow_tokens (t,
10854 (ffelexHandler) ffesta_zero);
10855 }
10856 }
10857
10858 /* ffestb_R100115_ -- OPEN_ANGLE expr
10859
10860 (ffestb_R100115_) // to expression handler
10861
10862 Handle expression prior to the edit descriptor. */
10863
10864 static ffelexHandler
10865 ffestb_R100115_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10866 {
10867 switch (ffelex_token_type (t))
10868 {
10869 case FFELEX_typeCLOSE_ANGLE:
10870 ffestb_local_.format.pre.present = TRUE;
10871 ffestb_local_.format.pre.rtexpr = TRUE;
10872 ffestb_local_.format.pre.u.expr = expr;
10873 ffelex_set_names_pure (TRUE);
10874 return (ffelexHandler) ffestb_R10014_;
10875
10876 default:
10877 ffelex_token_kill (ffestb_local_.format.pre.t);
10878 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10879 ffestt_formatlist_kill (ffestb_local_.format.f);
10880 return (ffelexHandler) ffelex_swallow_tokens (t,
10881 (ffelexHandler) ffesta_zero);
10882 }
10883 }
10884
10885 /* ffestb_R100116_ -- "[n]X" OPEN_ANGLE expr
10886
10887 (ffestb_R100116_) // to expression handler
10888
10889 Handle expression after the edit descriptor. */
10890
10891 static ffelexHandler
10892 ffestb_R100116_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10893 {
10894 switch (ffelex_token_type (t))
10895 {
10896 case FFELEX_typeCLOSE_ANGLE:
10897 ffestb_local_.format.post.present = TRUE;
10898 ffestb_local_.format.post.rtexpr = TRUE;
10899 ffestb_local_.format.post.u.expr = expr;
10900 ffelex_set_names_pure (TRUE);
10901 return (ffelexHandler) ffestb_R10016_;
10902
10903 default:
10904 ffelex_token_kill (ffestb_local_.format.t);
10905 ffelex_token_kill (ffestb_local_.format.post.t);
10906 if (ffestb_local_.format.pre.present)
10907 ffelex_token_kill (ffestb_local_.format.pre.t);
10908 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10909 ffestt_formatlist_kill (ffestb_local_.format.f);
10910 return (ffelexHandler) ffelex_swallow_tokens (t,
10911 (ffelexHandler) ffesta_zero);
10912 }
10913 }
10914
10915 /* ffestb_R100117_ -- "[n]X[n]." OPEN_ANGLE expr
10916
10917 (ffestb_R100117_) // to expression handler
10918
10919 Handle expression after the PERIOD. */
10920
10921 static ffelexHandler
10922 ffestb_R100117_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10923 {
10924 switch (ffelex_token_type (t))
10925 {
10926 case FFELEX_typeCLOSE_ANGLE:
10927 ffestb_local_.format.dot.present = TRUE;
10928 ffestb_local_.format.dot.rtexpr = TRUE;
10929 ffestb_local_.format.dot.u.expr = expr;
10930 ffelex_set_names_pure (TRUE);
10931 return (ffelexHandler) ffestb_R10018_;
10932
10933 default:
10934 ffelex_token_kill (ffestb_local_.format.t);
10935 ffelex_token_kill (ffestb_local_.format.dot.t);
10936 if (ffestb_local_.format.pre.present)
10937 ffelex_token_kill (ffestb_local_.format.pre.t);
10938 if (ffestb_local_.format.post.present)
10939 ffelex_token_kill (ffestb_local_.format.post.t);
10940 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10941 ffestt_formatlist_kill (ffestb_local_.format.f);
10942 return (ffelexHandler) ffelex_swallow_tokens (t,
10943 (ffelexHandler) ffesta_zero);
10944 }
10945 }
10946
10947 /* ffestb_R100118_ -- "[n]X[n].[n]E" OPEN_ANGLE expr
10948
10949 (ffestb_R100118_) // to expression handler
10950
10951 Handle expression after the "E". */
10952
10953 static ffelexHandler
10954 ffestb_R100118_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10955 {
10956 switch (ffelex_token_type (t))
10957 {
10958 case FFELEX_typeCLOSE_ANGLE:
10959 ffestb_local_.format.exp.present = TRUE;
10960 ffestb_local_.format.exp.rtexpr = TRUE;
10961 ffestb_local_.format.exp.u.expr = expr;
10962 ffelex_set_names_pure (TRUE);
10963 return (ffelexHandler) ffestb_R100110_;
10964
10965 default:
10966 ffelex_token_kill (ffestb_local_.format.t);
10967 ffelex_token_kill (ffestb_local_.format.exp.t);
10968 if (ffestb_local_.format.pre.present)
10969 ffelex_token_kill (ffestb_local_.format.pre.t);
10970 if (ffestb_local_.format.post.present)
10971 ffelex_token_kill (ffestb_local_.format.post.t);
10972 if (ffestb_local_.format.dot.present)
10973 ffelex_token_kill (ffestb_local_.format.dot.t);
10974 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10975 ffestt_formatlist_kill (ffestb_local_.format.f);
10976 return (ffelexHandler) ffelex_swallow_tokens (t,
10977 (ffelexHandler) ffesta_zero);
10978 }
10979 }
10980
10981 /* ffestb_R1107 -- Parse the USE statement
10982
10983 return ffestb_R1107; // to lexer
10984
10985 Make sure the statement has a valid form for the USE statement.
10986 If it does, implement the statement. */
10987
10988 #if FFESTR_F90
10989 ffelexHandler
10990 ffestb_R1107 (ffelexToken t)
10991 {
10992 ffeTokenLength i;
10993 const char *p;
10994
10995 switch (ffelex_token_type (ffesta_tokens[0]))
10996 {
10997 case FFELEX_typeNAME:
10998 if (ffesta_first_kw != FFESTR_firstUSE)
10999 goto bad_0; /* :::::::::::::::::::: */
11000 switch (ffelex_token_type (t))
11001 {
11002 case FFELEX_typeNAME:
11003 break;
11004
11005 case FFELEX_typeEOS:
11006 case FFELEX_typeSEMICOLON:
11007 case FFELEX_typeCOMMA:
11008 case FFELEX_typeCOLONCOLON:
11009 ffesta_confirmed (); /* Error, but clearly intended. */
11010 goto bad_1; /* :::::::::::::::::::: */
11011
11012 default:
11013 goto bad_0; /* :::::::::::::::::::: */
11014 }
11015 ffesta_confirmed ();
11016 ffesta_tokens[1] = ffelex_token_use (t);
11017 return (ffelexHandler) ffestb_R11071_;
11018
11019 case FFELEX_typeNAMES:
11020 if (ffesta_first_kw != FFESTR_firstUSE)
11021 goto bad_0; /* :::::::::::::::::::: */
11022 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlUSE);
11023 if (!ffesrc_is_name_init (*p))
11024 goto bad_i; /* :::::::::::::::::::: */
11025 switch (ffelex_token_type (t))
11026 {
11027 case FFELEX_typeCOLONCOLON:
11028 ffesta_confirmed (); /* Error, but clearly intended. */
11029 goto bad_1; /* :::::::::::::::::::: */
11030
11031 default:
11032 goto bad_1; /* :::::::::::::::::::: */
11033
11034 case FFELEX_typeCOMMA:
11035 case FFELEX_typeEOS:
11036 case FFELEX_typeSEMICOLON:
11037 break;
11038 }
11039 ffesta_confirmed ();
11040 ffesta_tokens[1]
11041 = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
11042 return (ffelexHandler) ffestb_R11071_ (t);
11043
11044 default:
11045 goto bad_0; /* :::::::::::::::::::: */
11046 }
11047
11048 bad_0: /* :::::::::::::::::::: */
11049 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", ffesta_tokens[0]);
11050 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11051
11052 bad_1: /* :::::::::::::::::::: */
11053 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11054 return (ffelexHandler) ffelex_swallow_tokens (t,
11055 (ffelexHandler) ffesta_zero); /* Invalid second token. */
11056
11057 bad_i: /* :::::::::::::::::::: */
11058 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "USE", ffesta_tokens[0], i, t);
11059 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11060 }
11061
11062 /* ffestb_R11071_ -- "USE" NAME
11063
11064 return ffestb_R11071_; // to lexer
11065
11066 Make sure the statement has a valid form for the USE statement. If it
11067 does, implement the statement. */
11068
11069 static ffelexHandler
11070 ffestb_R11071_ (ffelexToken t)
11071 {
11072 switch (ffelex_token_type (t))
11073 {
11074 case FFELEX_typeEOS:
11075 case FFELEX_typeSEMICOLON:
11076 if (!ffesta_is_inhibited ())
11077 {
11078 ffestc_R1107_start (ffesta_tokens[1], FALSE);
11079 ffestc_R1107_finish ();
11080 }
11081 ffelex_token_kill (ffesta_tokens[1]);
11082 return (ffelexHandler) ffesta_zero (t);
11083
11084 case FFELEX_typeCOMMA:
11085 return (ffelexHandler) ffestb_R11072_;
11086
11087 default:
11088 break;
11089 }
11090
11091 ffelex_token_kill (ffesta_tokens[1]);
11092 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11093 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11094 }
11095
11096 /* ffestb_R11072_ -- "USE" NAME COMMA
11097
11098 return ffestb_R11072_; // to lexer
11099
11100 Make sure the statement has a valid form for the USE statement. If it
11101 does, implement the statement. */
11102
11103 static ffelexHandler
11104 ffestb_R11072_ (ffelexToken t)
11105 {
11106 switch (ffelex_token_type (t))
11107 {
11108 case FFELEX_typeNAME:
11109 ffesta_tokens[2] = ffelex_token_use (t);
11110 return (ffelexHandler) ffestb_R11073_;
11111
11112 default:
11113 break;
11114 }
11115
11116 ffelex_token_kill (ffesta_tokens[1]);
11117 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11118 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11119 }
11120
11121 /* ffestb_R11073_ -- "USE" NAME COMMA NAME
11122
11123 return ffestb_R11073_; // to lexer
11124
11125 Make sure the statement has a valid form for the USE statement. If it
11126 does, implement the statement. */
11127
11128 static ffelexHandler
11129 ffestb_R11073_ (ffelexToken t)
11130 {
11131 switch (ffelex_token_type (t))
11132 {
11133 case FFELEX_typeCOLON:
11134 if (ffestr_other (ffesta_tokens[2]) != FFESTR_otherONLY)
11135 break;
11136 if (!ffesta_is_inhibited ())
11137 ffestc_R1107_start (ffesta_tokens[1], TRUE);
11138 ffelex_token_kill (ffesta_tokens[1]);
11139 ffelex_token_kill (ffesta_tokens[2]);
11140 return (ffelexHandler) ffestb_R11074_;
11141
11142 case FFELEX_typePOINTS:
11143 if (!ffesta_is_inhibited ())
11144 ffestc_R1107_start (ffesta_tokens[1], FALSE);
11145 ffelex_token_kill (ffesta_tokens[1]);
11146 ffesta_tokens[1] = ffesta_tokens[2];
11147 return (ffelexHandler) ffestb_R110711_;
11148
11149 default:
11150 break;
11151 }
11152
11153 ffelex_token_kill (ffesta_tokens[1]);
11154 ffelex_token_kill (ffesta_tokens[2]);
11155 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11156 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11157 }
11158
11159 /* ffestb_R11074_ -- "USE" NAME COMMA "ONLY" COLON
11160
11161 return ffestb_R11074_; // to lexer
11162
11163 Make sure the statement has a valid form for the USE statement. If it
11164 does, implement the statement. */
11165
11166 static ffelexHandler
11167 ffestb_R11074_ (ffelexToken t)
11168 {
11169 switch (ffelex_token_type (t))
11170 {
11171 case FFELEX_typeNAME:
11172 ffesta_tokens[1] = ffelex_token_use (t);
11173 return (ffelexHandler) ffestb_R11075_;
11174
11175 case FFELEX_typeEOS:
11176 case FFELEX_typeSEMICOLON:
11177 if (!ffesta_is_inhibited ())
11178 ffestc_R1107_finish ();
11179 return (ffelexHandler) ffesta_zero (t);
11180
11181 default:
11182 break;
11183 }
11184
11185 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11186 ffestc_R1107_finish ();
11187 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11188 }
11189
11190 /* ffestb_R11075_ -- "USE" NAME COMMA "ONLY" COLON NAME
11191
11192 return ffestb_R11075_; // to lexer
11193
11194 Make sure the statement has a valid form for the USE statement. If it
11195 does, implement the statement. */
11196
11197 static ffelexHandler
11198 ffestb_R11075_ (ffelexToken t)
11199 {
11200 switch (ffelex_token_type (t))
11201 {
11202 case FFELEX_typeEOS:
11203 case FFELEX_typeSEMICOLON:
11204 if (!ffesta_is_inhibited ())
11205 {
11206 ffestc_R1107_item (NULL, ffesta_tokens[1]);
11207 ffestc_R1107_finish ();
11208 }
11209 ffelex_token_kill (ffesta_tokens[1]);
11210 return (ffelexHandler) ffesta_zero (t);
11211
11212 case FFELEX_typeCOMMA:
11213 if (!ffesta_is_inhibited ())
11214 ffestc_R1107_item (NULL, ffesta_tokens[1]);
11215 ffelex_token_kill (ffesta_tokens[1]);
11216 return (ffelexHandler) ffestb_R11078_;
11217
11218 case FFELEX_typePOINTS:
11219 return (ffelexHandler) ffestb_R11076_;
11220
11221 default:
11222 break;
11223 }
11224
11225 ffelex_token_kill (ffesta_tokens[1]);
11226 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11227 ffestc_R1107_finish ();
11228 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11229 }
11230
11231 /* ffestb_R11076_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS
11232
11233 return ffestb_R11076_; // to lexer
11234
11235 Make sure the statement has a valid form for the USE statement. If it
11236 does, implement the statement. */
11237
11238 static ffelexHandler
11239 ffestb_R11076_ (ffelexToken t)
11240 {
11241 switch (ffelex_token_type (t))
11242 {
11243 case FFELEX_typeNAME:
11244 if (!ffesta_is_inhibited ())
11245 ffestc_R1107_item (ffesta_tokens[1], t);
11246 ffelex_token_kill (ffesta_tokens[1]);
11247 return (ffelexHandler) ffestb_R11077_;
11248
11249 default:
11250 break;
11251 }
11252
11253 ffelex_token_kill (ffesta_tokens[1]);
11254 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11255 ffestc_R1107_finish ();
11256 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11257 }
11258
11259 /* ffestb_R11077_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS NAME
11260
11261 return ffestb_R11077_; // to lexer
11262
11263 Make sure the statement has a valid form for the USE statement. If it
11264 does, implement the statement. */
11265
11266 static ffelexHandler
11267 ffestb_R11077_ (ffelexToken t)
11268 {
11269 switch (ffelex_token_type (t))
11270 {
11271 case FFELEX_typeEOS:
11272 case FFELEX_typeSEMICOLON:
11273 if (!ffesta_is_inhibited ())
11274 ffestc_R1107_finish ();
11275 return (ffelexHandler) ffesta_zero (t);
11276
11277 case FFELEX_typeCOMMA:
11278 return (ffelexHandler) ffestb_R11078_;
11279
11280 default:
11281 break;
11282 }
11283
11284 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11285 ffestc_R1107_finish ();
11286 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11287 }
11288
11289 /* ffestb_R11078_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS NAME COMMA
11290
11291 return ffestb_R11078_; // to lexer
11292
11293 Make sure the statement has a valid form for the USE statement. If it
11294 does, implement the statement. */
11295
11296 static ffelexHandler
11297 ffestb_R11078_ (ffelexToken t)
11298 {
11299 switch (ffelex_token_type (t))
11300 {
11301 case FFELEX_typeNAME:
11302 ffesta_tokens[1] = ffelex_token_use (t);
11303 return (ffelexHandler) ffestb_R11075_;
11304
11305 default:
11306 break;
11307 }
11308
11309 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11310 ffestc_R1107_finish ();
11311 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11312 }
11313
11314 /* ffestb_R11079_ -- "USE" NAME COMMA
11315
11316 return ffestb_R11079_; // to lexer
11317
11318 Make sure the statement has a valid form for the USE statement. If it
11319 does, implement the statement. */
11320
11321 static ffelexHandler
11322 ffestb_R11079_ (ffelexToken t)
11323 {
11324 switch (ffelex_token_type (t))
11325 {
11326 case FFELEX_typeNAME:
11327 ffesta_tokens[1] = ffelex_token_use (t);
11328 return (ffelexHandler) ffestb_R110710_;
11329
11330 default:
11331 break;
11332 }
11333
11334 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11335 ffestc_R1107_finish ();
11336 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11337 }
11338
11339 /* ffestb_R110710_ -- "USE" NAME COMMA NAME
11340
11341 return ffestb_R110710_; // to lexer
11342
11343 Make sure the statement has a valid form for the USE statement. If it
11344 does, implement the statement. */
11345
11346 static ffelexHandler
11347 ffestb_R110710_ (ffelexToken t)
11348 {
11349 switch (ffelex_token_type (t))
11350 {
11351 case FFELEX_typePOINTS:
11352 return (ffelexHandler) ffestb_R110711_;
11353
11354 default:
11355 break;
11356 }
11357
11358 ffelex_token_kill (ffesta_tokens[1]);
11359 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11360 ffestc_R1107_finish ();
11361 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11362 }
11363
11364 /* ffestb_R110711_ -- "USE" NAME COMMA NAME POINTS
11365
11366 return ffestb_R110711_; // to lexer
11367
11368 Make sure the statement has a valid form for the USE statement. If it
11369 does, implement the statement. */
11370
11371 static ffelexHandler
11372 ffestb_R110711_ (ffelexToken t)
11373 {
11374 switch (ffelex_token_type (t))
11375 {
11376 case FFELEX_typeNAME:
11377 if (!ffesta_is_inhibited ())
11378 ffestc_R1107_item (ffesta_tokens[1], t);
11379 ffelex_token_kill (ffesta_tokens[1]);
11380 return (ffelexHandler) ffestb_R110712_;
11381
11382 default:
11383 break;
11384 }
11385
11386 ffelex_token_kill (ffesta_tokens[1]);
11387 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11388 ffestc_R1107_finish ();
11389 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11390 }
11391
11392 /* ffestb_R110712_ -- "USE" NAME COMMA NAME POINTS NAME
11393
11394 return ffestb_R110712_; // to lexer
11395
11396 Make sure the statement has a valid form for the USE statement. If it
11397 does, implement the statement. */
11398
11399 static ffelexHandler
11400 ffestb_R110712_ (ffelexToken t)
11401 {
11402 switch (ffelex_token_type (t))
11403 {
11404 case FFELEX_typeEOS:
11405 case FFELEX_typeSEMICOLON:
11406 if (!ffesta_is_inhibited ())
11407 ffestc_R1107_finish ();
11408 return (ffelexHandler) ffesta_zero (t);
11409
11410 case FFELEX_typeCOMMA:
11411 return (ffelexHandler) ffestb_R11079_;
11412
11413 default:
11414 break;
11415 }
11416
11417 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11418 ffestc_R1107_finish ();
11419 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11420 }
11421
11422 #endif
11423 /* ffestb_R1202 -- Parse the INTERFACE statement
11424
11425 return ffestb_R1202; // to lexer
11426
11427 Make sure the statement has a valid form for the INTERFACE statement.
11428 If it does, implement the statement.
11429
11430 15-May-90 JCB 1.1
11431 Allow INTERFACE by itself; missed this
11432 valid form when originally doing syntactic analysis code. */
11433
11434 #if FFESTR_F90
11435 ffelexHandler
11436 ffestb_R1202 (ffelexToken t)
11437 {
11438 ffeTokenLength i;
11439 const char *p;
11440
11441 switch (ffelex_token_type (ffesta_tokens[0]))
11442 {
11443 case FFELEX_typeNAME:
11444 if (ffesta_first_kw != FFESTR_firstINTERFACE)
11445 goto bad_0; /* :::::::::::::::::::: */
11446 switch (ffelex_token_type (t))
11447 {
11448 case FFELEX_typeNAME:
11449 break;
11450
11451 case FFELEX_typeEOS:
11452 case FFELEX_typeSEMICOLON:
11453 ffesta_confirmed ();
11454 if (!ffesta_is_inhibited ())
11455 ffestc_R1202 (FFESTP_definedoperatorNone, NULL);
11456 return (ffelexHandler) ffesta_zero (t);
11457
11458 case FFELEX_typeCOMMA:
11459 case FFELEX_typeCOLONCOLON:
11460 ffesta_confirmed (); /* Error, but clearly intended. */
11461 goto bad_1; /* :::::::::::::::::::: */
11462
11463 default:
11464 goto bad_1; /* :::::::::::::::::::: */
11465 }
11466
11467 ffesta_confirmed ();
11468 switch (ffesta_second_kw)
11469 {
11470 case FFESTR_secondOPERATOR:
11471 ffestb_local_.interface.operator = FFESTP_definedoperatorOPERATOR;
11472 break;
11473
11474 case FFESTR_secondASSIGNMENT:
11475 ffestb_local_.interface.operator = FFESTP_definedoperatorASSIGNMENT;
11476 break;
11477
11478 default:
11479 ffestb_local_.interface.operator = FFESTP_definedoperatorNone;
11480 break;
11481 }
11482 ffesta_tokens[1] = ffelex_token_use (t);
11483 return (ffelexHandler) ffestb_R12021_;
11484
11485 case FFELEX_typeNAMES:
11486 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlINTERFACE);
11487 switch (ffesta_first_kw)
11488 {
11489 case FFESTR_firstINTERFACEOPERATOR:
11490 if (*(ffelex_token_text (ffesta_tokens[0])
11491 + FFESTR_firstlINTERFACEOPERATOR) == '\0')
11492 ffestb_local_.interface.operator
11493 = FFESTP_definedoperatorOPERATOR;
11494 break;
11495
11496 case FFESTR_firstINTERFACEASSGNMNT:
11497 if (*(ffelex_token_text (ffesta_tokens[0])
11498 + FFESTR_firstlINTERFACEASSGNMNT) == '\0')
11499 ffestb_local_.interface.operator
11500 = FFESTP_definedoperatorASSIGNMENT;
11501 break;
11502
11503 case FFESTR_firstINTERFACE:
11504 ffestb_local_.interface.operator = FFESTP_definedoperatorNone;
11505 break;
11506
11507 default:
11508 goto bad_0; /* :::::::::::::::::::: */
11509 }
11510 switch (ffelex_token_type (t))
11511 {
11512 case FFELEX_typeCOMMA:
11513 case FFELEX_typeCOLONCOLON:
11514 ffesta_confirmed (); /* Error, but clearly intended. */
11515 goto bad_1; /* :::::::::::::::::::: */
11516
11517 default:
11518 goto bad_1; /* :::::::::::::::::::: */
11519
11520 case FFELEX_typeOPEN_PAREN:
11521 case FFELEX_typeOPEN_ARRAY: /* Sigh. */
11522 break;
11523
11524 case FFELEX_typeEOS:
11525 case FFELEX_typeSEMICOLON:
11526 ffesta_confirmed ();
11527 if (*p == '\0')
11528 {
11529 if (!ffesta_is_inhibited ())
11530 ffestc_R1202 (FFESTP_definedoperatorNone, NULL);
11531 return (ffelexHandler) ffesta_zero (t);
11532 }
11533 break;
11534 }
11535 if (!ffesrc_is_name_init (*p))
11536 goto bad_i; /* :::::::::::::::::::: */
11537 ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
11538 return (ffelexHandler) ffestb_R12021_ (t);
11539
11540 default:
11541 goto bad_0; /* :::::::::::::::::::: */
11542 }
11543
11544 bad_0: /* :::::::::::::::::::: */
11545 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", ffesta_tokens[0]);
11546 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11547
11548 bad_1: /* :::::::::::::::::::: */
11549 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11550 return (ffelexHandler) ffelex_swallow_tokens (t,
11551 (ffelexHandler) ffesta_zero); /* Invalid second token. */
11552
11553 bad_i: /* :::::::::::::::::::: */
11554 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "INTERFACE", ffesta_tokens[0], i, t);
11555 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11556 }
11557
11558 /* ffestb_R12021_ -- "INTERFACE" NAME
11559
11560 return ffestb_R12021_; // to lexer
11561
11562 Make sure the statement has a valid form for the INTERFACE statement. If
11563 it does, implement the statement. */
11564
11565 static ffelexHandler
11566 ffestb_R12021_ (ffelexToken t)
11567 {
11568 ffestb_local_.interface.slash = TRUE; /* Slash follows open paren. */
11569
11570 switch (ffelex_token_type (t))
11571 {
11572 case FFELEX_typeEOS:
11573 case FFELEX_typeSEMICOLON:
11574 if (!ffesta_is_inhibited ())
11575 ffestc_R1202 (FFESTP_definedoperatorNone, ffesta_tokens[1]);
11576 ffelex_token_kill (ffesta_tokens[1]);
11577 return (ffelexHandler) ffesta_zero (t);
11578
11579 case FFELEX_typeOPEN_PAREN:
11580 ffestb_local_.interface.slash = FALSE; /* Slash doesn't follow. */
11581 /* Fall through. */
11582 case FFELEX_typeOPEN_ARRAY:
11583 switch (ffestb_local_.interface.operator)
11584 {
11585 case FFESTP_definedoperatorNone:
11586 break;
11587
11588 case FFESTP_definedoperatorOPERATOR:
11589 ffestb_local_.interface.assignment = FALSE;
11590 return (ffelexHandler) ffestb_R12022_;
11591
11592 case FFESTP_definedoperatorASSIGNMENT:
11593 ffestb_local_.interface.assignment = TRUE;
11594 return (ffelexHandler) ffestb_R12022_;
11595
11596 default:
11597 assert (FALSE);
11598 }
11599 break;
11600
11601 case FFELEX_typeCOMMA:
11602 case FFELEX_typeCOLONCOLON:
11603 ffesta_confirmed (); /* Error, but clearly intended. */
11604 break;
11605
11606 default:
11607 break;
11608 }
11609
11610 ffelex_token_kill (ffesta_tokens[1]);
11611 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11612 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11613 }
11614
11615 /* ffestb_R12022_ -- "INTERFACE" "OPERATOR/ASSIGNMENT" OPEN_PAREN
11616
11617 return ffestb_R12022_; // to lexer
11618
11619 Make sure the statement has a valid form for the INTERFACE statement. If
11620 it does, implement the statement. */
11621
11622 static ffelexHandler
11623 ffestb_R12022_ (ffelexToken t)
11624 {
11625 ffesta_tokens[2] = ffelex_token_use (t);
11626
11627 switch (ffelex_token_type (t))
11628 {
11629 case FFELEX_typePERIOD:
11630 if (ffestb_local_.interface.slash)
11631 break;
11632 return (ffelexHandler) ffestb_R12023_;
11633
11634 case FFELEX_typePOWER:
11635 if (ffestb_local_.interface.slash)
11636 break;
11637 ffestb_local_.interface.operator = FFESTP_definedoperatorPOWER;
11638 return (ffelexHandler) ffestb_R12025_;
11639
11640 case FFELEX_typeASTERISK:
11641 if (ffestb_local_.interface.slash)
11642 break;
11643 ffestb_local_.interface.operator = FFESTP_definedoperatorMULT;
11644 return (ffelexHandler) ffestb_R12025_;
11645
11646 case FFELEX_typePLUS:
11647 if (ffestb_local_.interface.slash)
11648 break;
11649 ffestb_local_.interface.operator = FFESTP_definedoperatorADD;
11650 return (ffelexHandler) ffestb_R12025_;
11651
11652 case FFELEX_typeCONCAT:
11653 if (ffestb_local_.interface.slash)
11654 break;
11655 ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
11656 return (ffelexHandler) ffestb_R12025_;
11657
11658 case FFELEX_typeSLASH:
11659 if (ffestb_local_.interface.slash)
11660 {
11661 ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
11662 return (ffelexHandler) ffestb_R12025_;
11663 }
11664 ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
11665 return (ffelexHandler) ffestb_R12025_;
11666
11667 case FFELEX_typeMINUS:
11668 if (ffestb_local_.interface.slash)
11669 break;
11670 ffestb_local_.interface.operator = FFESTP_definedoperatorSUBTRACT;
11671 return (ffelexHandler) ffestb_R12025_;
11672
11673 case FFELEX_typeREL_EQ:
11674 if (ffestb_local_.interface.slash)
11675 break;
11676 ffestb_local_.interface.operator = FFESTP_definedoperatorEQ;
11677 return (ffelexHandler) ffestb_R12025_;
11678
11679 case FFELEX_typeREL_NE:
11680 if (ffestb_local_.interface.slash)
11681 break;
11682 ffestb_local_.interface.operator = FFESTP_definedoperatorNE;
11683 return (ffelexHandler) ffestb_R12025_;
11684
11685 case FFELEX_typeOPEN_ANGLE:
11686 if (ffestb_local_.interface.slash)
11687 break;
11688 ffestb_local_.interface.operator = FFESTP_definedoperatorLT;
11689 return (ffelexHandler) ffestb_R12025_;
11690
11691 case FFELEX_typeREL_LE:
11692 if (ffestb_local_.interface.slash)
11693 break;
11694 ffestb_local_.interface.operator = FFESTP_definedoperatorLE;
11695 return (ffelexHandler) ffestb_R12025_;
11696
11697 case FFELEX_typeCLOSE_ANGLE:
11698 if (ffestb_local_.interface.slash)
11699 break;
11700 ffestb_local_.interface.operator = FFESTP_definedoperatorGT;
11701 return (ffelexHandler) ffestb_R12025_;
11702
11703 case FFELEX_typeREL_GE:
11704 if (ffestb_local_.interface.slash)
11705 break;
11706 ffestb_local_.interface.operator = FFESTP_definedoperatorGE;
11707 return (ffelexHandler) ffestb_R12025_;
11708
11709 case FFELEX_typeEQUALS:
11710 if (ffestb_local_.interface.slash)
11711 {
11712 ffestb_local_.interface.operator = FFESTP_definedoperatorNE;
11713 return (ffelexHandler) ffestb_R12025_;
11714 }
11715 ffestb_local_.interface.operator = FFESTP_definedoperatorASSIGNMENT;
11716 return (ffelexHandler) ffestb_R12025_;
11717
11718 case FFELEX_typeCLOSE_ARRAY:
11719 if (!ffestb_local_.interface.slash)
11720 {
11721 ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
11722 return (ffelexHandler) ffestb_R12026_;
11723 }
11724 ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
11725 return (ffelexHandler) ffestb_R12026_;
11726
11727 case FFELEX_typeCLOSE_PAREN:
11728 if (!ffestb_local_.interface.slash)
11729 break;
11730 ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
11731 return (ffelexHandler) ffestb_R12026_;
11732
11733 default:
11734 break;
11735 }
11736
11737 ffelex_token_kill (ffesta_tokens[1]);
11738 ffelex_token_kill (ffesta_tokens[2]);
11739 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11740 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11741 }
11742
11743 /* ffestb_R12023_ -- "INTERFACE" NAME OPEN_PAREN PERIOD
11744
11745 return ffestb_R12023_; // to lexer
11746
11747 Make sure the statement has a valid form for the INTERFACE statement. If
11748 it does, implement the statement. */
11749
11750 static ffelexHandler
11751 ffestb_R12023_ (ffelexToken t)
11752 {
11753 switch (ffelex_token_type (t))
11754 {
11755 case FFELEX_typeNAME:
11756 ffelex_token_kill (ffesta_tokens[2]);
11757 ffesta_tokens[2] = ffelex_token_use (t);
11758 return (ffelexHandler) ffestb_R12024_;
11759
11760 default:
11761 break;
11762 }
11763
11764 ffelex_token_kill (ffesta_tokens[1]);
11765 ffelex_token_kill (ffesta_tokens[2]);
11766 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11767 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11768 }
11769
11770 /* ffestb_R12024_ -- "INTERFACE" NAME OPEN_PAREN PERIOD NAME
11771
11772 return ffestb_R12024_; // to lexer
11773
11774 Make sure the statement has a valid form for the INTERFACE statement. If
11775 it does, implement the statement. */
11776
11777 static ffelexHandler
11778 ffestb_R12024_ (ffelexToken t)
11779 {
11780 switch (ffelex_token_type (t))
11781 {
11782 case FFELEX_typePERIOD:
11783 return (ffelexHandler) ffestb_R12025_;
11784
11785 default:
11786 break;
11787 }
11788
11789 ffelex_token_kill (ffesta_tokens[1]);
11790 ffelex_token_kill (ffesta_tokens[2]);
11791 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11792 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11793 }
11794
11795 /* ffestb_R12025_ -- "INTERFACE" NAME OPEN_PAREN operator
11796
11797 return ffestb_R12025_; // to lexer
11798
11799 Make sure the statement has a valid form for the INTERFACE statement. If
11800 it does, implement the statement. */
11801
11802 static ffelexHandler
11803 ffestb_R12025_ (ffelexToken t)
11804 {
11805 switch (ffelex_token_type (t))
11806 {
11807 case FFELEX_typeCLOSE_PAREN:
11808 return (ffelexHandler) ffestb_R12026_;
11809
11810 default:
11811 break;
11812 }
11813
11814 ffelex_token_kill (ffesta_tokens[1]);
11815 ffelex_token_kill (ffesta_tokens[2]);
11816 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11817 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11818 }
11819
11820 /* ffestb_R12026_ -- "INTERFACE" NAME OPEN_PAREN operator CLOSE_PAREN
11821
11822 return ffestb_R12026_; // to lexer
11823
11824 Make sure the statement has a valid form for the INTERFACE statement. If
11825 it does, implement the statement. */
11826
11827 static ffelexHandler
11828 ffestb_R12026_ (ffelexToken t)
11829 {
11830 const char *p;
11831
11832 switch (ffelex_token_type (t))
11833 {
11834 case FFELEX_typeEOS:
11835 case FFELEX_typeSEMICOLON:
11836 ffesta_confirmed ();
11837 if (ffestb_local_.interface.assignment
11838 && (ffestb_local_.interface.operator
11839 != FFESTP_definedoperatorASSIGNMENT))
11840 {
11841 ffebad_start (FFEBAD_INTERFACE_ASSIGNMENT);
11842 ffebad_here (0, ffelex_token_where_line (ffesta_tokens[1]),
11843 ffelex_token_where_column (ffesta_tokens[1]));
11844 ffebad_here (1, ffelex_token_where_line (ffesta_tokens[2]),
11845 ffelex_token_where_column (ffesta_tokens[2]));
11846 ffebad_finish ();
11847 }
11848 switch (ffelex_token_type (ffesta_tokens[2]))
11849 {
11850 case FFELEX_typeNAME:
11851 switch (ffestr_other (ffesta_tokens[2]))
11852 {
11853 case FFESTR_otherNOT:
11854 if (!ffesta_is_inhibited ())
11855 ffestc_R1202 (FFESTP_definedoperatorNOT, NULL);
11856 break;
11857
11858 case FFESTR_otherAND:
11859 if (!ffesta_is_inhibited ())
11860 ffestc_R1202 (FFESTP_definedoperatorAND, NULL);
11861 break;
11862
11863 case FFESTR_otherOR:
11864 if (!ffesta_is_inhibited ())
11865 ffestc_R1202 (FFESTP_definedoperatorOR, NULL);
11866 break;
11867
11868 case FFESTR_otherEQV:
11869 if (!ffesta_is_inhibited ())
11870 ffestc_R1202 (FFESTP_definedoperatorEQV, NULL);
11871 break;
11872
11873 case FFESTR_otherNEQV:
11874 if (!ffesta_is_inhibited ())
11875 ffestc_R1202 (FFESTP_definedoperatorNEQV, NULL);
11876 break;
11877
11878 case FFESTR_otherEQ:
11879 if (!ffesta_is_inhibited ())
11880 ffestc_R1202 (FFESTP_definedoperatorEQ, NULL);
11881 break;
11882
11883 case FFESTR_otherNE:
11884 if (!ffesta_is_inhibited ())
11885 ffestc_R1202 (FFESTP_definedoperatorNE, NULL);
11886 break;
11887
11888 case FFESTR_otherLT:
11889 if (!ffesta_is_inhibited ())
11890 ffestc_R1202 (FFESTP_definedoperatorLT, NULL);
11891 break;
11892
11893 case FFESTR_otherLE:
11894 if (!ffesta_is_inhibited ())
11895 ffestc_R1202 (FFESTP_definedoperatorLE, NULL);
11896 break;
11897
11898 case FFESTR_otherGT:
11899 if (!ffesta_is_inhibited ())
11900 ffestc_R1202 (FFESTP_definedoperatorGT, NULL);
11901 break;
11902
11903 case FFESTR_otherGE:
11904 if (!ffesta_is_inhibited ())
11905 ffestc_R1202 (FFESTP_definedoperatorGE, NULL);
11906 break;
11907
11908 default:
11909 for (p = ffelex_token_text (ffesta_tokens[2]); *p != '\0'; ++p)
11910 {
11911 if (! ISALPHA (*p))
11912 {
11913 ffelex_token_kill (ffesta_tokens[1]);
11914 ffelex_token_kill (ffesta_tokens[2]);
11915 ffesta_ffebad_1t (FFEBAD_INTERFACE_NONLETTER,
11916 ffesta_tokens[2]);
11917 return (ffelexHandler) ffelex_swallow_tokens (t,
11918 (ffelexHandler) ffesta_zero);
11919 }
11920 }
11921 if (!ffesta_is_inhibited ())
11922 ffestc_R1202 (FFESTP_definedoperatorOPERATOR,
11923 ffesta_tokens[2]);
11924 }
11925 break;
11926
11927 case FFELEX_typeEQUALS:
11928 if (!ffestb_local_.interface.assignment
11929 && (ffestb_local_.interface.operator
11930 == FFESTP_definedoperatorASSIGNMENT))
11931 {
11932 ffebad_start (FFEBAD_INTERFACE_OPERATOR);
11933 ffebad_here (0, ffelex_token_where_line (ffesta_tokens[1]),
11934 ffelex_token_where_column (ffesta_tokens[1]));
11935 ffebad_here (1, ffelex_token_where_line (ffesta_tokens[2]),
11936 ffelex_token_where_column (ffesta_tokens[2]));
11937 ffebad_finish ();
11938 }
11939 if (!ffesta_is_inhibited ())
11940 ffestc_R1202 (ffestb_local_.interface.operator, NULL);
11941 break;
11942
11943 default:
11944 if (!ffesta_is_inhibited ())
11945 ffestc_R1202 (ffestb_local_.interface.operator, NULL);
11946 }
11947 ffelex_token_kill (ffesta_tokens[1]);
11948 ffelex_token_kill (ffesta_tokens[2]);
11949 return (ffelexHandler) ffesta_zero (t);
11950
11951 default:
11952 break;
11953 }
11954
11955 ffelex_token_kill (ffesta_tokens[1]);
11956 ffelex_token_kill (ffesta_tokens[2]);
11957 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11958 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11959 }
11960
11961 #endif
11962 /* ffestb_S3P4 -- Parse the INCLUDE line
11963
11964 return ffestb_S3P4; // to lexer
11965
11966 Make sure the statement has a valid form for the INCLUDE line. If it
11967 does, implement the statement. */
11968
11969 ffelexHandler
11970 ffestb_S3P4 (ffelexToken t)
11971 {
11972 ffeTokenLength i;
11973 const char *p;
11974 ffelexHandler next;
11975 ffelexToken nt;
11976 ffelexToken ut;
11977
11978 switch (ffelex_token_type (ffesta_tokens[0]))
11979 {
11980 case FFELEX_typeNAME:
11981 if (ffesta_first_kw != FFESTR_firstINCLUDE)
11982 goto bad_0; /* :::::::::::::::::::: */
11983 switch (ffelex_token_type (t))
11984 {
11985 case FFELEX_typeNUMBER:
11986 case FFELEX_typeAPOSTROPHE:
11987 case FFELEX_typeQUOTE:
11988 break;
11989
11990 default:
11991 goto bad_1; /* :::::::::::::::::::: */
11992 }
11993 ffesta_confirmed ();
11994 return (ffelexHandler) (*((ffelexHandler)
11995 ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextINCLUDE,
11996 (ffeexprCallback) ffestb_S3P41_)))
11997 (t);
11998
11999 case FFELEX_typeNAMES:
12000 if (ffesta_first_kw != FFESTR_firstINCLUDE)
12001 goto bad_0; /* :::::::::::::::::::: */
12002 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlINCLUDE);
12003 switch (ffelex_token_type (t))
12004 {
12005 default:
12006 goto bad_1; /* :::::::::::::::::::: */
12007
12008 case FFELEX_typeAPOSTROPHE:
12009 case FFELEX_typeQUOTE:
12010 break;
12011 }
12012 ffesta_confirmed ();
12013 if (*p == '\0')
12014 return (ffelexHandler) (*((ffelexHandler)
12015 ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextINCLUDE,
12016 (ffeexprCallback) ffestb_S3P41_)))
12017 (t);
12018 if (! ISDIGIT (*p))
12019 goto bad_i; /* :::::::::::::::::::: */
12020 nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
12021 p += ffelex_token_length (nt);
12022 i += ffelex_token_length (nt);
12023 if ((*p != '_') || (++i, *++p != '\0'))
12024 {
12025 ffelex_token_kill (nt);
12026 goto bad_i; /* :::::::::::::::::::: */
12027 }
12028 ut = ffelex_token_uscore_from_names (ffesta_tokens[0], i - 1);
12029 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs
12030 (ffesta_output_pool, FFEEXPR_contextINCLUDE,
12031 (ffeexprCallback) ffestb_S3P41_)))
12032 (nt);
12033 ffelex_token_kill (nt);
12034 next = (ffelexHandler) (*next) (ut);
12035 ffelex_token_kill (ut);
12036 return (ffelexHandler) (*next) (t);
12037
12038 default:
12039 goto bad_0; /* :::::::::::::::::::: */
12040 }
12041
12042 bad_0: /* :::::::::::::::::::: */
12043 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", ffesta_tokens[0]);
12044 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12045
12046 bad_1: /* :::::::::::::::::::: */
12047 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", t);
12048 return (ffelexHandler) ffelex_swallow_tokens (t,
12049 (ffelexHandler) ffesta_zero); /* Invalid second token. */
12050
12051 bad_i: /* :::::::::::::::::::: */
12052 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "INCLUDE", ffesta_tokens[0], i, t);
12053 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12054 }
12055
12056 /* ffestb_S3P41_ -- "INCLUDE" [NUMBER "_"] expr
12057
12058 (ffestb_S3P41_) // to expression handler
12059
12060 Make sure the next token is an EOS, but not a SEMICOLON. */
12061
12062 static ffelexHandler
12063 ffestb_S3P41_ (ffelexToken ft, ffebld expr, ffelexToken t)
12064 {
12065 switch (ffelex_token_type (t))
12066 {
12067 case FFELEX_typeEOS:
12068 case FFELEX_typeSEMICOLON:
12069 if (expr == NULL)
12070 break;
12071 if (!ffesta_is_inhibited ())
12072 {
12073 if (ffe_is_pedantic ()
12074 && ((ffelex_token_type (t) == FFELEX_typeSEMICOLON)
12075 || ffesta_line_has_semicolons))
12076 {
12077 ffebad_start_msg ("INCLUDE at %0 not the only statement on the source line", FFEBAD_severityWARNING);
12078 ffebad_here (0, ffelex_token_where_line (ffesta_tokens[0]),
12079 ffelex_token_where_column (ffesta_tokens[0]));
12080 ffebad_finish ();
12081 }
12082 ffestc_S3P4 (expr, ft);
12083 }
12084 return (ffelexHandler) ffesta_zero (t);
12085
12086 default:
12087 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", t);
12088 break;
12089 }
12090
12091 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12092 }
12093
12094 /* ffestb_V012 -- Parse the MAP statement
12095
12096 return ffestb_V012; // to lexer
12097
12098 Make sure the statement has a valid form for the MAP statement. If
12099 it does, implement the statement. */
12100
12101 #if FFESTR_VXT
12102 ffelexHandler
12103 ffestb_V012 (ffelexToken t)
12104 {
12105 const char *p;
12106 ffeTokenLength i;
12107
12108 switch (ffelex_token_type (ffesta_tokens[0]))
12109 {
12110 case FFELEX_typeNAME:
12111 if (ffesta_first_kw != FFESTR_firstMAP)
12112 goto bad_0; /* :::::::::::::::::::: */
12113 break;
12114
12115 case FFELEX_typeNAMES:
12116 if (ffesta_first_kw != FFESTR_firstMAP)
12117 goto bad_0; /* :::::::::::::::::::: */
12118 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlMAP)
12119 {
12120 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlMAP);
12121 goto bad_i; /* :::::::::::::::::::: */
12122 }
12123 break;
12124
12125 default:
12126 goto bad_0; /* :::::::::::::::::::: */
12127 }
12128
12129 switch (ffelex_token_type (t))
12130 {
12131 case FFELEX_typeEOS:
12132 case FFELEX_typeSEMICOLON:
12133 ffesta_confirmed ();
12134 if (!ffesta_is_inhibited ())
12135 ffestc_V012 ();
12136 return (ffelexHandler) ffesta_zero (t);
12137
12138 case FFELEX_typeCOMMA:
12139 case FFELEX_typeCOLONCOLON:
12140 ffesta_confirmed (); /* Error, but clearly intended. */
12141 goto bad_1; /* :::::::::::::::::::: */
12142
12143 default:
12144 goto bad_1; /* :::::::::::::::::::: */
12145 }
12146
12147 bad_0: /* :::::::::::::::::::: */
12148 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MAP", ffesta_tokens[0]);
12149 return (ffelexHandler) ffelex_swallow_tokens (t,
12150 (ffelexHandler) ffesta_zero); /* Invalid first token. */
12151
12152 bad_1: /* :::::::::::::::::::: */
12153 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MAP", t);
12154 return (ffelexHandler) ffelex_swallow_tokens (t,
12155 (ffelexHandler) ffesta_zero); /* Invalid second token. */
12156
12157 bad_i: /* :::::::::::::::::::: */
12158 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "MAP", ffesta_tokens[0], i, t);
12159 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12160 }
12161
12162 #endif
12163 /* ffestb_V014 -- Parse the VOLATILE statement
12164
12165 return ffestb_V014; // to lexer
12166
12167 Make sure the statement has a valid form for the VOLATILE statement. If it
12168 does, implement the statement. */
12169
12170 ffelexHandler
12171 ffestb_V014 (ffelexToken t)
12172 {
12173 ffeTokenLength i;
12174 unsigned const char *p;
12175 ffelexToken nt;
12176 ffelexHandler next;
12177
12178 switch (ffelex_token_type (ffesta_tokens[0]))
12179 {
12180 case FFELEX_typeNAME:
12181 if (ffesta_first_kw != FFESTR_firstVOLATILE)
12182 goto bad_0; /* :::::::::::::::::::: */
12183 switch (ffelex_token_type (t))
12184 {
12185 case FFELEX_typeEOS:
12186 case FFELEX_typeSEMICOLON:
12187 case FFELEX_typeCOMMA:
12188 ffesta_confirmed (); /* Error, but clearly intended. */
12189 goto bad_1; /* :::::::::::::::::::: */
12190
12191 default:
12192 goto bad_1; /* :::::::::::::::::::: */
12193
12194 case FFELEX_typeNAME:
12195 case FFELEX_typeSLASH:
12196 ffesta_confirmed ();
12197 if (!ffesta_is_inhibited ())
12198 ffestc_V014_start ();
12199 return (ffelexHandler) ffestb_V0141_ (t);
12200
12201 case FFELEX_typeCOLONCOLON:
12202 ffesta_confirmed ();
12203 if (!ffesta_is_inhibited ())
12204 ffestc_V014_start ();
12205 return (ffelexHandler) ffestb_V0141_;
12206 }
12207
12208 case FFELEX_typeNAMES:
12209 if (ffesta_first_kw != FFESTR_firstVOLATILE)
12210 goto bad_0; /* :::::::::::::::::::: */
12211 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlVOLATILE);
12212 switch (ffelex_token_type (t))
12213 {
12214 default:
12215 goto bad_1; /* :::::::::::::::::::: */
12216
12217 case FFELEX_typeCOMMA:
12218 case FFELEX_typeEOS:
12219 case FFELEX_typeSEMICOLON:
12220 ffesta_confirmed ();
12221 break;
12222
12223 case FFELEX_typeSLASH:
12224 ffesta_confirmed ();
12225 if (*p != '\0')
12226 goto bad_i; /* :::::::::::::::::::: */
12227 if (!ffesta_is_inhibited ())
12228 ffestc_V014_start ();
12229 return (ffelexHandler) ffestb_V0141_ (t);
12230
12231 case FFELEX_typeCOLONCOLON:
12232 ffesta_confirmed ();
12233 if (*p != '\0')
12234 goto bad_i; /* :::::::::::::::::::: */
12235 if (!ffesta_is_inhibited ())
12236 ffestc_V014_start ();
12237 return (ffelexHandler) ffestb_V0141_;
12238 }
12239
12240 /* Here, we have at least one char after "VOLATILE" and t is COMMA or
12241 EOS/SEMICOLON. */
12242
12243 if (!ffesrc_is_name_init (*p))
12244 goto bad_i; /* :::::::::::::::::::: */
12245 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
12246 if (!ffesta_is_inhibited ())
12247 ffestc_V014_start ();
12248 next = (ffelexHandler) ffestb_V0141_ (nt);
12249 ffelex_token_kill (nt);
12250 return (ffelexHandler) (*next) (t);
12251
12252 default:
12253 goto bad_0; /* :::::::::::::::::::: */
12254 }
12255
12256 bad_0: /* :::::::::::::::::::: */
12257 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", ffesta_tokens[0]);
12258 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12259
12260 bad_1: /* :::::::::::::::::::: */
12261 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12262 return (ffelexHandler) ffelex_swallow_tokens (t,
12263 (ffelexHandler) ffesta_zero); /* Invalid second token. */
12264
12265 bad_i: /* :::::::::::::::::::: */
12266 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "VOLATILE", ffesta_tokens[0], i, t);
12267 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12268 }
12269
12270 /* ffestb_V0141_ -- "VOLATILE" [COLONCOLON]
12271
12272 return ffestb_V0141_; // to lexer
12273
12274 Handle NAME or SLASH. */
12275
12276 static ffelexHandler
12277 ffestb_V0141_ (ffelexToken t)
12278 {
12279 switch (ffelex_token_type (t))
12280 {
12281 case FFELEX_typeNAME:
12282 ffestb_local_.V014.is_cblock = FALSE;
12283 ffesta_tokens[1] = ffelex_token_use (t);
12284 return (ffelexHandler) ffestb_V0144_;
12285
12286 case FFELEX_typeSLASH:
12287 ffestb_local_.V014.is_cblock = TRUE;
12288 return (ffelexHandler) ffestb_V0142_;
12289
12290 default:
12291 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12292 break;
12293 }
12294
12295 if (!ffesta_is_inhibited ())
12296 ffestc_V014_finish ();
12297 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12298 }
12299
12300 /* ffestb_V0142_ -- "VOLATILE" [COLONCOLON] SLASH
12301
12302 return ffestb_V0142_; // to lexer
12303
12304 Handle NAME. */
12305
12306 static ffelexHandler
12307 ffestb_V0142_ (ffelexToken t)
12308 {
12309 switch (ffelex_token_type (t))
12310 {
12311 case FFELEX_typeNAME:
12312 ffesta_tokens[1] = ffelex_token_use (t);
12313 return (ffelexHandler) ffestb_V0143_;
12314
12315 default:
12316 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12317 break;
12318 }
12319
12320 if (!ffesta_is_inhibited ())
12321 ffestc_V014_finish ();
12322 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12323 }
12324
12325 /* ffestb_V0143_ -- "VOLATILE" [COLONCOLON] SLASH NAME
12326
12327 return ffestb_V0143_; // to lexer
12328
12329 Handle SLASH. */
12330
12331 static ffelexHandler
12332 ffestb_V0143_ (ffelexToken t)
12333 {
12334 switch (ffelex_token_type (t))
12335 {
12336 case FFELEX_typeSLASH:
12337 return (ffelexHandler) ffestb_V0144_;
12338
12339 default:
12340 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12341 break;
12342 }
12343
12344 if (!ffesta_is_inhibited ())
12345 ffestc_V014_finish ();
12346 ffelex_token_kill (ffesta_tokens[1]);
12347 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12348 }
12349
12350 /* ffestb_V0144_ -- "VOLATILE" [COLONCOLON] R523
12351
12352 return ffestb_V0144_; // to lexer
12353
12354 Handle COMMA or EOS/SEMICOLON. */
12355
12356 static ffelexHandler
12357 ffestb_V0144_ (ffelexToken t)
12358 {
12359 switch (ffelex_token_type (t))
12360 {
12361 case FFELEX_typeCOMMA:
12362 if (!ffesta_is_inhibited ())
12363 {
12364 if (ffestb_local_.V014.is_cblock)
12365 ffestc_V014_item_cblock (ffesta_tokens[1]);
12366 else
12367 ffestc_V014_item_object (ffesta_tokens[1]);
12368 }
12369 ffelex_token_kill (ffesta_tokens[1]);
12370 return (ffelexHandler) ffestb_V0141_;
12371
12372 case FFELEX_typeEOS:
12373 case FFELEX_typeSEMICOLON:
12374 if (!ffesta_is_inhibited ())
12375 {
12376 if (ffestb_local_.V014.is_cblock)
12377 ffestc_V014_item_cblock (ffesta_tokens[1]);
12378 else
12379 ffestc_V014_item_object (ffesta_tokens[1]);
12380 ffestc_V014_finish ();
12381 }
12382 ffelex_token_kill (ffesta_tokens[1]);
12383 return (ffelexHandler) ffesta_zero (t);
12384
12385 default:
12386 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12387 break;
12388 }
12389
12390 if (!ffesta_is_inhibited ())
12391 ffestc_V014_finish ();
12392 ffelex_token_kill (ffesta_tokens[1]);
12393 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12394 }
12395
12396 /* ffestb_V025 -- Parse the DEFINEFILE statement
12397
12398 return ffestb_V025; // to lexer
12399
12400 Make sure the statement has a valid form for the DEFINEFILE statement.
12401 If it does, implement the statement. */
12402
12403 #if FFESTR_VXT
12404 ffelexHandler
12405 ffestb_V025 (ffelexToken t)
12406 {
12407 ffeTokenLength i;
12408 const char *p;
12409 ffelexToken nt;
12410 ffelexHandler next;
12411
12412 ffestb_local_.V025.started = FALSE;
12413 switch (ffelex_token_type (ffesta_tokens[0]))
12414 {
12415 case FFELEX_typeNAME:
12416 switch (ffesta_first_kw)
12417 {
12418 case FFESTR_firstDEFINE:
12419 if ((ffelex_token_type (t) != FFELEX_typeNAME)
12420 || (ffesta_second_kw != FFESTR_secondFILE))
12421 goto bad_1; /* :::::::::::::::::::: */
12422 ffesta_confirmed ();
12423 return (ffelexHandler) ffestb_V0251_;
12424
12425 case FFESTR_firstDEFINEFILE:
12426 return (ffelexHandler) ffestb_V0251_ (t);
12427
12428 default:
12429 goto bad_0; /* :::::::::::::::::::: */
12430 }
12431
12432 case FFELEX_typeNAMES:
12433 if (ffesta_first_kw != FFESTR_firstDEFINEFILE)
12434 goto bad_0; /* :::::::::::::::::::: */
12435 switch (ffelex_token_type (t))
12436 {
12437 case FFELEX_typeCOMMA:
12438 case FFELEX_typeEOS:
12439 case FFELEX_typeSEMICOLON:
12440 case FFELEX_typeCOLONCOLON:
12441 ffesta_confirmed (); /* Error, but clearly intended. */
12442 goto bad_1; /* :::::::::::::::::::: */
12443
12444 default:
12445 goto bad_1; /* :::::::::::::::::::: */
12446
12447 case FFELEX_typeOPEN_PAREN:
12448 break;
12449 }
12450 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDEFINEFILE);
12451 if (ISDIGIT (*p))
12452 nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
12453 else if (ffesrc_is_name_init (*p))
12454 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
12455 else
12456 goto bad_i; /* :::::::::::::::::::: */
12457 next = (ffelexHandler) ffestb_V0251_ (nt);
12458 ffelex_token_kill (nt);
12459 return (ffelexHandler) (*next) (t);
12460
12461 default:
12462 goto bad_0; /* :::::::::::::::::::: */
12463 }
12464
12465 bad_0: /* :::::::::::::::::::: */
12466 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", ffesta_tokens[0]);
12467 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12468
12469 bad_1: /* :::::::::::::::::::: */
12470 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12471 return (ffelexHandler) ffelex_swallow_tokens (t,
12472 (ffelexHandler) ffesta_zero); /* Invalid second token. */
12473
12474 bad_i: /* :::::::::::::::::::: */
12475 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", ffesta_tokens[0], i, t);
12476 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12477 }
12478
12479 /* ffestb_V0251_ -- "DEFINEFILE" or "DEFINE" "FILE"
12480
12481 return ffestb_V0251_; // to lexer
12482
12483 Make sure the statement has a valid form for the DEFINEFILE statement. If it
12484 does, implement the statement. */
12485
12486 static ffelexHandler
12487 ffestb_V0251_ (ffelexToken t)
12488 {
12489 switch (ffelex_token_type (t))
12490 {
12491 case FFELEX_typeNAME:
12492 case FFELEX_typeNUMBER:
12493 if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
12494 ffesta_confirmed ();
12495 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12496 FFEEXPR_contextFILEUNIT_DF, (ffeexprCallback) ffestb_V0252_)))
12497 (t);
12498
12499 case FFELEX_typeEOS:
12500 case FFELEX_typeSEMICOLON:
12501 case FFELEX_typeCOMMA:
12502 case FFELEX_typeCOLONCOLON:
12503 ffesta_confirmed (); /* Error, but clearly intended. */
12504 break;
12505
12506 default:
12507 break;
12508 }
12509
12510 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12511 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12512 }
12513
12514 /* ffestb_V0252_ -- "DEFINEFILE" expr
12515
12516 (ffestb_V0252_) // to expression handler
12517
12518 Make sure the statement has a valid form for the DEFINEFILE statement. If
12519 it does, implement the statement. */
12520
12521 static ffelexHandler
12522 ffestb_V0252_ (ffelexToken ft, ffebld expr, ffelexToken t)
12523 {
12524 switch (ffelex_token_type (t))
12525 {
12526 case FFELEX_typeOPEN_PAREN:
12527 ffestb_local_.V025.u = expr;
12528 ffesta_tokens[1] = ffelex_token_use (ft);
12529 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12530 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0253_);
12531
12532 default:
12533 break;
12534 }
12535
12536 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12537 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12538 }
12539
12540 /* ffestb_V0253_ -- "DEFINEFILE" expr OPEN_PAREN expr
12541
12542 (ffestb_V0253_) // to expression handler
12543
12544 Make sure the statement has a valid form for the DEFINEFILE statement. If
12545 it does, implement the statement. */
12546
12547 static ffelexHandler
12548 ffestb_V0253_ (ffelexToken ft, ffebld expr, ffelexToken t)
12549 {
12550 switch (ffelex_token_type (t))
12551 {
12552 case FFELEX_typeCOMMA:
12553 ffestb_local_.V025.m = expr;
12554 ffesta_tokens[2] = ffelex_token_use (ft);
12555 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12556 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0254_);
12557
12558 default:
12559 break;
12560 }
12561
12562 ffelex_token_kill (ffesta_tokens[1]);
12563 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12564 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12565 }
12566
12567 /* ffestb_V0254_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr
12568
12569 (ffestb_V0254_) // to expression handler
12570
12571 Make sure the statement has a valid form for the DEFINEFILE statement. If
12572 it does, implement the statement. */
12573
12574 static ffelexHandler
12575 ffestb_V0254_ (ffelexToken ft, ffebld expr, ffelexToken t)
12576 {
12577 switch (ffelex_token_type (t))
12578 {
12579 case FFELEX_typeCOMMA:
12580 ffestb_local_.V025.n = expr;
12581 ffesta_tokens[3] = ffelex_token_use (ft);
12582 return (ffelexHandler) ffestb_V0255_;
12583
12584 default:
12585 break;
12586 }
12587
12588 ffelex_token_kill (ffesta_tokens[1]);
12589 ffelex_token_kill (ffesta_tokens[2]);
12590 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12591 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12592 }
12593
12594 /* ffestb_V0255_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA
12595
12596 return ffestb_V0255_; // to lexer
12597
12598 Make sure the statement has a valid form for the DEFINEFILE statement. If
12599 it does, implement the statement. */
12600
12601 static ffelexHandler
12602 ffestb_V0255_ (ffelexToken t)
12603 {
12604 const char *p;
12605
12606 switch (ffelex_token_type (t))
12607 {
12608 case FFELEX_typeNAME:
12609 p = ffelex_token_text (t);
12610 if (!ffesrc_char_match_init (*p, 'U', 'u') || (*++p != '\0'))
12611 break;
12612 return (ffelexHandler) ffestb_V0256_;
12613
12614 default:
12615 break;
12616 }
12617
12618 ffelex_token_kill (ffesta_tokens[1]);
12619 ffelex_token_kill (ffesta_tokens[2]);
12620 ffelex_token_kill (ffesta_tokens[3]);
12621 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12622 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12623 }
12624
12625 /* ffestb_V0256_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
12626
12627 return ffestb_V0256_; // to lexer
12628
12629 Make sure the statement has a valid form for the DEFINEFILE statement. If
12630 it does, implement the statement. */
12631
12632 static ffelexHandler
12633 ffestb_V0256_ (ffelexToken t)
12634 {
12635 switch (ffelex_token_type (t))
12636 {
12637 case FFELEX_typeCOMMA:
12638 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
12639 FFEEXPR_contextFILEASSOC,
12640 (ffeexprCallback) ffestb_V0257_);
12641
12642 default:
12643 break;
12644 }
12645
12646 ffelex_token_kill (ffesta_tokens[1]);
12647 ffelex_token_kill (ffesta_tokens[2]);
12648 ffelex_token_kill (ffesta_tokens[3]);
12649 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12650 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12651 }
12652
12653 /* ffestb_V0257_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
12654 COMMA expr
12655
12656 (ffestb_V0257_) // to expression handler
12657
12658 Make sure the statement has a valid form for the DEFINEFILE statement. If
12659 it does, implement the statement. */
12660
12661 static ffelexHandler
12662 ffestb_V0257_ (ffelexToken ft, ffebld expr, ffelexToken t)
12663 {
12664 switch (ffelex_token_type (t))
12665 {
12666 case FFELEX_typeCLOSE_PAREN:
12667 ffestb_local_.V025.asv = expr;
12668 ffesta_tokens[4] = ffelex_token_use (ft);
12669 return (ffelexHandler) ffestb_V0258_;
12670
12671 default:
12672 break;
12673 }
12674
12675 ffelex_token_kill (ffesta_tokens[1]);
12676 ffelex_token_kill (ffesta_tokens[2]);
12677 ffelex_token_kill (ffesta_tokens[3]);
12678 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12679 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12680 }
12681
12682 /* ffestb_V0258_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
12683 COMMA expr CLOSE_PAREN
12684
12685 return ffestb_V0258_; // to lexer
12686
12687 Make sure the statement has a valid form for the DEFINEFILE statement. If
12688 it does, implement the statement. */
12689
12690 static ffelexHandler
12691 ffestb_V0258_ (ffelexToken t)
12692 {
12693 switch (ffelex_token_type (t))
12694 {
12695 case FFELEX_typeCOMMA:
12696 case FFELEX_typeEOS:
12697 case FFELEX_typeSEMICOLON:
12698 if (!ffestb_local_.V025.started)
12699 {
12700 ffesta_confirmed ();
12701 if (!ffesta_is_inhibited ())
12702 ffestc_V025_start ();
12703 ffestb_local_.V025.started = TRUE;
12704 }
12705 if (!ffesta_is_inhibited ())
12706 ffestc_V025_item (ffestb_local_.V025.u, ffesta_tokens[1],
12707 ffestb_local_.V025.m, ffesta_tokens[2],
12708 ffestb_local_.V025.n, ffesta_tokens[3],
12709 ffestb_local_.V025.asv, ffesta_tokens[4]);
12710 ffelex_token_kill (ffesta_tokens[1]);
12711 ffelex_token_kill (ffesta_tokens[2]);
12712 ffelex_token_kill (ffesta_tokens[3]);
12713 ffelex_token_kill (ffesta_tokens[4]);
12714 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
12715 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12716 FFEEXPR_contextFILEUNIT_DF, (ffeexprCallback) ffestb_V0252_);
12717 if (!ffesta_is_inhibited ())
12718 ffestc_V025_finish ();
12719 return (ffelexHandler) ffesta_zero (t);
12720
12721 default:
12722 break;
12723 }
12724
12725 ffelex_token_kill (ffesta_tokens[1]);
12726 ffelex_token_kill (ffesta_tokens[2]);
12727 ffelex_token_kill (ffesta_tokens[3]);
12728 ffelex_token_kill (ffesta_tokens[4]);
12729 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12730 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12731 }
12732
12733 #endif
12734 /* ffestb_subr_kill_easy_ -- Kill I/O statement data structure
12735
12736 ffestb_subr_kill_easy_();
12737
12738 Kills all tokens in the I/O data structure. Assumes that they are
12739 overlaid with each other (union) in ffest_private.h and the typing
12740 and structure references assume (though not necessarily dangerous if
12741 FALSE) that INQUIRE has the most file elements. */
12742
12743 #if FFESTB_KILL_EASY_
12744 static void
12745 ffestb_subr_kill_easy_ (ffestpInquireIx max)
12746 {
12747 ffestpInquireIx ix;
12748
12749 for (ix = 0; ix < max; ++ix)
12750 {
12751 if (ffestp_file.inquire.inquire_spec[ix].kw_or_val_present)
12752 {
12753 if (ffestp_file.inquire.inquire_spec[ix].kw_present)
12754 ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].kw);
12755 if (ffestp_file.inquire.inquire_spec[ix].value_present)
12756 ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].value);
12757 }
12758 }
12759 }
12760
12761 #endif
12762 /* ffestb_subr_kill_accept_ -- Kill ACCEPT statement data structure
12763
12764 ffestb_subr_kill_accept_();
12765
12766 Kills all tokens in the ACCEPT data structure. */
12767
12768 #if !FFESTB_KILL_EASY_
12769 static void
12770 ffestb_subr_kill_accept_ ()
12771 {
12772 ffestpAcceptIx ix;
12773
12774 for (ix = 0; ix < FFESTP_acceptix; ++ix)
12775 {
12776 if (ffestp_file.accept.accept_spec[ix].kw_or_val_present)
12777 {
12778 if (ffestp_file.accept.accept_spec[ix].kw_present)
12779 ffelex_token_kill (ffestp_file.accept.accept_spec[ix].kw);
12780 if (ffestp_file.accept.accept_spec[ix].value_present)
12781 ffelex_token_kill (ffestp_file.accept.accept_spec[ix].value);
12782 }
12783 }
12784 }
12785
12786 #endif
12787 /* ffestb_subr_kill_beru_ -- Kill BACKSPACE/ENDFILE/REWIND/UNLOCK statement
12788 data structure
12789
12790 ffestb_subr_kill_beru_();
12791
12792 Kills all tokens in the BACKSPACE/ENDFILE/REWIND/UNLOCK data structure. */
12793
12794 #if !FFESTB_KILL_EASY_
12795 static void
12796 ffestb_subr_kill_beru_ ()
12797 {
12798 ffestpBeruIx ix;
12799
12800 for (ix = 0; ix < FFESTP_beruix; ++ix)
12801 {
12802 if (ffestp_file.beru.beru_spec[ix].kw_or_val_present)
12803 {
12804 if (ffestp_file.beru.beru_spec[ix].kw_present)
12805 ffelex_token_kill (ffestp_file.beru.beru_spec[ix].kw);
12806 if (ffestp_file.beru.beru_spec[ix].value_present)
12807 ffelex_token_kill (ffestp_file.beru.beru_spec[ix].value);
12808 }
12809 }
12810 }
12811
12812 #endif
12813 /* ffestb_subr_kill_close_ -- Kill CLOSE statement data structure
12814
12815 ffestb_subr_kill_close_();
12816
12817 Kills all tokens in the CLOSE data structure. */
12818
12819 #if !FFESTB_KILL_EASY_
12820 static void
12821 ffestb_subr_kill_close_ ()
12822 {
12823 ffestpCloseIx ix;
12824
12825 for (ix = 0; ix < FFESTP_closeix; ++ix)
12826 {
12827 if (ffestp_file.close.close_spec[ix].kw_or_val_present)
12828 {
12829 if (ffestp_file.close.close_spec[ix].kw_present)
12830 ffelex_token_kill (ffestp_file.close.close_spec[ix].kw);
12831 if (ffestp_file.close.close_spec[ix].value_present)
12832 ffelex_token_kill (ffestp_file.close.close_spec[ix].value);
12833 }
12834 }
12835 }
12836
12837 #endif
12838 /* ffestb_subr_kill_delete_ -- Kill DELETE statement data structure
12839
12840 ffestb_subr_kill_delete_();
12841
12842 Kills all tokens in the DELETE data structure. */
12843
12844 #if !FFESTB_KILL_EASY_
12845 static void
12846 ffestb_subr_kill_delete_ ()
12847 {
12848 ffestpDeleteIx ix;
12849
12850 for (ix = 0; ix < FFESTP_deleteix; ++ix)
12851 {
12852 if (ffestp_file.delete.delete_spec[ix].kw_or_val_present)
12853 {
12854 if (ffestp_file.delete.delete_spec[ix].kw_present)
12855 ffelex_token_kill (ffestp_file.delete.delete_spec[ix].kw);
12856 if (ffestp_file.delete.delete_spec[ix].value_present)
12857 ffelex_token_kill (ffestp_file.delete.delete_spec[ix].value);
12858 }
12859 }
12860 }
12861
12862 #endif
12863 /* ffestb_subr_kill_inquire_ -- Kill INQUIRE statement data structure
12864
12865 ffestb_subr_kill_inquire_();
12866
12867 Kills all tokens in the INQUIRE data structure. */
12868
12869 #if !FFESTB_KILL_EASY_
12870 static void
12871 ffestb_subr_kill_inquire_ ()
12872 {
12873 ffestpInquireIx ix;
12874
12875 for (ix = 0; ix < FFESTP_inquireix; ++ix)
12876 {
12877 if (ffestp_file.inquire.inquire_spec[ix].kw_or_val_present)
12878 {
12879 if (ffestp_file.inquire.inquire_spec[ix].kw_present)
12880 ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].kw);
12881 if (ffestp_file.inquire.inquire_spec[ix].value_present)
12882 ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].value);
12883 }
12884 }
12885 }
12886
12887 #endif
12888 /* ffestb_subr_kill_open_ -- Kill OPEN statement data structure
12889
12890 ffestb_subr_kill_open_();
12891
12892 Kills all tokens in the OPEN data structure. */
12893
12894 #if !FFESTB_KILL_EASY_
12895 static void
12896 ffestb_subr_kill_open_ ()
12897 {
12898 ffestpOpenIx ix;
12899
12900 for (ix = 0; ix < FFESTP_openix; ++ix)
12901 {
12902 if (ffestp_file.open.open_spec[ix].kw_or_val_present)
12903 {
12904 if (ffestp_file.open.open_spec[ix].kw_present)
12905 ffelex_token_kill (ffestp_file.open.open_spec[ix].kw);
12906 if (ffestp_file.open.open_spec[ix].value_present)
12907 ffelex_token_kill (ffestp_file.open.open_spec[ix].value);
12908 }
12909 }
12910 }
12911
12912 #endif
12913 /* ffestb_subr_kill_print_ -- Kill PRINT statement data structure
12914
12915 ffestb_subr_kill_print_();
12916
12917 Kills all tokens in the PRINT data structure. */
12918
12919 #if !FFESTB_KILL_EASY_
12920 static void
12921 ffestb_subr_kill_print_ ()
12922 {
12923 ffestpPrintIx ix;
12924
12925 for (ix = 0; ix < FFESTP_printix; ++ix)
12926 {
12927 if (ffestp_file.print.print_spec[ix].kw_or_val_present)
12928 {
12929 if (ffestp_file.print.print_spec[ix].kw_present)
12930 ffelex_token_kill (ffestp_file.print.print_spec[ix].kw);
12931 if (ffestp_file.print.print_spec[ix].value_present)
12932 ffelex_token_kill (ffestp_file.print.print_spec[ix].value);
12933 }
12934 }
12935 }
12936
12937 #endif
12938 /* ffestb_subr_kill_read_ -- Kill READ statement data structure
12939
12940 ffestb_subr_kill_read_();
12941
12942 Kills all tokens in the READ data structure. */
12943
12944 #if !FFESTB_KILL_EASY_
12945 static void
12946 ffestb_subr_kill_read_ ()
12947 {
12948 ffestpReadIx ix;
12949
12950 for (ix = 0; ix < FFESTP_readix; ++ix)
12951 {
12952 if (ffestp_file.read.read_spec[ix].kw_or_val_present)
12953 {
12954 if (ffestp_file.read.read_spec[ix].kw_present)
12955 ffelex_token_kill (ffestp_file.read.read_spec[ix].kw);
12956 if (ffestp_file.read.read_spec[ix].value_present)
12957 ffelex_token_kill (ffestp_file.read.read_spec[ix].value);
12958 }
12959 }
12960 }
12961
12962 #endif
12963 /* ffestb_subr_kill_rewrite_ -- Kill REWRITE statement data structure
12964
12965 ffestb_subr_kill_rewrite_();
12966
12967 Kills all tokens in the REWRITE data structure. */
12968
12969 #if !FFESTB_KILL_EASY_
12970 static void
12971 ffestb_subr_kill_rewrite_ ()
12972 {
12973 ffestpRewriteIx ix;
12974
12975 for (ix = 0; ix < FFESTP_rewriteix; ++ix)
12976 {
12977 if (ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present)
12978 {
12979 if (ffestp_file.rewrite.rewrite_spec[ix].kw_present)
12980 ffelex_token_kill (ffestp_file.rewrite.rewrite_spec[ix].kw);
12981 if (ffestp_file.rewrite.rewrite_spec[ix].value_present)
12982 ffelex_token_kill (ffestp_file.rewrite.rewrite_spec[ix].value);
12983 }
12984 }
12985 }
12986
12987 #endif
12988 /* ffestb_subr_kill_type_ -- Kill TYPE statement data structure
12989
12990 ffestb_subr_kill_type_();
12991
12992 Kills all tokens in the TYPE data structure. */
12993
12994 #if !FFESTB_KILL_EASY_
12995 static void
12996 ffestb_subr_kill_type_ ()
12997 {
12998 ffestpTypeIx ix;
12999
13000 for (ix = 0; ix < FFESTP_typeix; ++ix)
13001 {
13002 if (ffestp_file.type.type_spec[ix].kw_or_val_present)
13003 {
13004 if (ffestp_file.type.type_spec[ix].kw_present)
13005 ffelex_token_kill (ffestp_file.type.type_spec[ix].kw);
13006 if (ffestp_file.type.type_spec[ix].value_present)
13007 ffelex_token_kill (ffestp_file.type.type_spec[ix].value);
13008 }
13009 }
13010 }
13011
13012 #endif
13013 /* ffestb_subr_kill_write_ -- Kill WRITE statement data structure
13014
13015 ffestb_subr_kill_write_();
13016
13017 Kills all tokens in the WRITE data structure. */
13018
13019 #if !FFESTB_KILL_EASY_
13020 static void
13021 ffestb_subr_kill_write_ ()
13022 {
13023 ffestpWriteIx ix;
13024
13025 for (ix = 0; ix < FFESTP_writeix; ++ix)
13026 {
13027 if (ffestp_file.write.write_spec[ix].kw_or_val_present)
13028 {
13029 if (ffestp_file.write.write_spec[ix].kw_present)
13030 ffelex_token_kill (ffestp_file.write.write_spec[ix].kw);
13031 if (ffestp_file.write.write_spec[ix].value_present)
13032 ffelex_token_kill (ffestp_file.write.write_spec[ix].value);
13033 }
13034 }
13035 }
13036
13037 #endif
13038 /* ffestb_beru -- Parse the BACKSPACE/ENDFILE/REWIND/UNLOCK statement
13039
13040 return ffestb_beru; // to lexer
13041
13042 Make sure the statement has a valid form for the BACKSPACE/ENDFILE/REWIND/
13043 UNLOCK statement. If it does, implement the statement. */
13044
13045 ffelexHandler
13046 ffestb_beru (ffelexToken t)
13047 {
13048 ffelexHandler next;
13049 ffestpBeruIx ix;
13050
13051 switch (ffelex_token_type (ffesta_tokens[0]))
13052 {
13053 case FFELEX_typeNAME:
13054 switch (ffelex_token_type (t))
13055 {
13056 case FFELEX_typeCOMMA:
13057 case FFELEX_typeCOLONCOLON:
13058 case FFELEX_typeEOS:
13059 case FFELEX_typeSEMICOLON:
13060 ffesta_confirmed (); /* Error, but clearly intended. */
13061 goto bad_1; /* :::::::::::::::::::: */
13062
13063 case FFELEX_typeEQUALS:
13064 case FFELEX_typePOINTS:
13065 case FFELEX_typeCOLON:
13066 goto bad_1; /* :::::::::::::::::::: */
13067
13068 case FFELEX_typeNAME:
13069 case FFELEX_typeNUMBER:
13070 ffesta_confirmed ();
13071 break;
13072
13073 case FFELEX_typeOPEN_PAREN:
13074 for (ix = 0; ix < FFESTP_beruix; ++ix)
13075 ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13076 ffesta_tokens[1] = ffelex_token_use (t);
13077 return (ffelexHandler) ffestb_beru2_;
13078
13079 default:
13080 break;
13081 }
13082
13083 for (ix = 0; ix < FFESTP_beruix; ++ix)
13084 ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13085 return (ffelexHandler) (*((ffelexHandler)
13086 ffeexpr_rhs (ffesta_output_pool,
13087 FFEEXPR_contextFILENUM,
13088 (ffeexprCallback) ffestb_beru1_)))
13089 (t);
13090
13091 case FFELEX_typeNAMES:
13092 switch (ffelex_token_type (t))
13093 {
13094 case FFELEX_typeCOMMA:
13095 case FFELEX_typeCOLONCOLON:
13096 ffesta_confirmed (); /* Error, but clearly intended. */
13097 goto bad_1; /* :::::::::::::::::::: */
13098
13099 case FFELEX_typeEQUALS:
13100 case FFELEX_typePOINTS:
13101 case FFELEX_typeCOLON:
13102 goto bad_1; /* :::::::::::::::::::: */
13103
13104 case FFELEX_typeEOS:
13105 case FFELEX_typeSEMICOLON:
13106 ffesta_confirmed ();
13107 break;
13108
13109 case FFELEX_typeOPEN_PAREN:
13110 if (ffelex_token_length (ffesta_tokens[0])
13111 != ffestb_args.beru.len)
13112 break;
13113
13114 for (ix = 0; ix < FFESTP_beruix; ++ix)
13115 ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13116 ffesta_tokens[1] = ffelex_token_use (t);
13117 return (ffelexHandler) ffestb_beru2_;
13118
13119 default:
13120 break;
13121 }
13122 for (ix = 0; ix < FFESTP_beruix; ++ix)
13123 ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13124 next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13125 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_beru1_);
13126 next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
13127 ffestb_args.beru.len);
13128 if (next == NULL)
13129 return (ffelexHandler) ffelex_swallow_tokens (t,
13130 (ffelexHandler) ffesta_zero);
13131 return (ffelexHandler) (*next) (t);
13132
13133 default:
13134 goto bad_0; /* :::::::::::::::::::: */
13135 }
13136
13137 bad_0: /* :::::::::::::::::::: */
13138 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, ffesta_tokens[0]);
13139 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13140
13141 bad_1: /* :::::::::::::::::::: */
13142 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13143 return (ffelexHandler) ffelex_swallow_tokens (t,
13144 (ffelexHandler) ffesta_zero); /* Invalid second token. */
13145 }
13146
13147 /* ffestb_beru1_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" expr
13148
13149 (ffestb_beru1_) // to expression handler
13150
13151 Make sure the next token is an EOS or SEMICOLON. */
13152
13153 static ffelexHandler
13154 ffestb_beru1_ (ffelexToken ft, ffebld expr, ffelexToken t)
13155 {
13156 switch (ffelex_token_type (t))
13157 {
13158 case FFELEX_typeEOS:
13159 case FFELEX_typeSEMICOLON:
13160 if (expr == NULL)
13161 break;
13162 ffesta_confirmed ();
13163 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_or_val_present
13164 = TRUE;
13165 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_present = FALSE;
13166 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_present = TRUE;
13167 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_is_label
13168 = FALSE;
13169 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value
13170 = ffelex_token_use (ft);
13171 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].u.expr = expr;
13172 if (!ffesta_is_inhibited ())
13173 {
13174 switch (ffesta_first_kw)
13175 {
13176 case FFESTR_firstBACKSPACE:
13177 ffestc_R919 ();
13178 break;
13179
13180 case FFESTR_firstENDFILE:
13181 case FFESTR_firstEND:
13182 ffestc_R920 ();
13183 break;
13184
13185 case FFESTR_firstREWIND:
13186 ffestc_R921 ();
13187 break;
13188
13189 #if FFESTR_VXT
13190 case FFESTR_firstUNLOCK:
13191 ffestc_V022 ();
13192 break;
13193 #endif
13194
13195 default:
13196 assert (FALSE);
13197 }
13198 }
13199 ffestb_subr_kill_beru_ ();
13200 return (ffelexHandler) ffesta_zero (t);
13201
13202 default:
13203 break;
13204 }
13205
13206 ffestb_subr_kill_beru_ ();
13207 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13208 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13209 }
13210
13211 /* ffestb_beru2_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN
13212
13213 return ffestb_beru2_; // to lexer
13214
13215 Handle expr construct (not NAME=expr construct) here. */
13216
13217 static ffelexHandler
13218 ffestb_beru2_ (ffelexToken t)
13219 {
13220 ffelexToken nt;
13221 ffelexHandler next;
13222
13223 switch (ffelex_token_type (t))
13224 {
13225 case FFELEX_typeNAME:
13226 ffesta_tokens[2] = ffelex_token_use (t);
13227 return (ffelexHandler) ffestb_beru3_;
13228
13229 default:
13230 nt = ffesta_tokens[1];
13231 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13232 FFEEXPR_contextFILENUMAMBIG, (ffeexprCallback) ffestb_beru4_)))
13233 (nt);
13234 ffelex_token_kill (nt);
13235 return (ffelexHandler) (*next) (t);
13236 }
13237 }
13238
13239 /* ffestb_beru3_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN NAME
13240
13241 return ffestb_beru3_; // to lexer
13242
13243 If EQUALS here, go to states that handle it. Else, send NAME and this
13244 token thru expression handler. */
13245
13246 static ffelexHandler
13247 ffestb_beru3_ (ffelexToken t)
13248 {
13249 ffelexHandler next;
13250 ffelexToken nt;
13251 ffelexToken ot;
13252
13253 switch (ffelex_token_type (t))
13254 {
13255 case FFELEX_typeEQUALS:
13256 ffelex_token_kill (ffesta_tokens[1]);
13257 nt = ffesta_tokens[2];
13258 next = (ffelexHandler) ffestb_beru5_ (nt);
13259 ffelex_token_kill (nt);
13260 return (ffelexHandler) (*next) (t);
13261
13262 default:
13263 nt = ffesta_tokens[1];
13264 ot = ffesta_tokens[2];
13265 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13266 FFEEXPR_contextFILENUMAMBIG, (ffeexprCallback) ffestb_beru4_)))
13267 (nt);
13268 ffelex_token_kill (nt);
13269 next = (ffelexHandler) (*next) (ot);
13270 ffelex_token_kill (ot);
13271 return (ffelexHandler) (*next) (t);
13272 }
13273 }
13274
13275 /* ffestb_beru4_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN expr [CLOSE_PAREN]
13276
13277 (ffestb_beru4_) // to expression handler
13278
13279 Handle COMMA or EOS/SEMICOLON here.
13280
13281 15-Feb-91 JCB 1.2
13282 Now using new mechanism whereby expr comes back as opITEM if the
13283 expr is considered part (or all) of an I/O control list (and should
13284 be stripped of its outer opITEM node) or not if it is considered
13285 a plain unit number that happens to have been enclosed in parens.
13286 26-Mar-90 JCB 1.1
13287 No longer expecting close-paren here because of constructs like
13288 BACKSPACE (5)+2, so now expecting either COMMA because it was a
13289 construct like BACKSPACE (5+2,... or EOS/SEMICOLON because it is like
13290 the former construct. Ah, the vagaries of Fortran. */
13291
13292 static ffelexHandler
13293 ffestb_beru4_ (ffelexToken ft, ffebld expr, ffelexToken t)
13294 {
13295 bool inlist;
13296
13297 switch (ffelex_token_type (t))
13298 {
13299 case FFELEX_typeCOMMA:
13300 case FFELEX_typeEOS:
13301 case FFELEX_typeSEMICOLON:
13302 case FFELEX_typeCLOSE_PAREN:
13303 if (expr == NULL)
13304 break;
13305 if (ffebld_op (expr) == FFEBLD_opITEM)
13306 {
13307 inlist = TRUE;
13308 expr = ffebld_head (expr);
13309 }
13310 else
13311 inlist = FALSE;
13312 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_or_val_present
13313 = TRUE;
13314 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_present = FALSE;
13315 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_present = TRUE;
13316 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_is_label
13317 = FALSE;
13318 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value
13319 = ffelex_token_use (ft);
13320 ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].u.expr = expr;
13321 if (inlist)
13322 return (ffelexHandler) ffestb_beru9_ (t);
13323 return (ffelexHandler) ffestb_beru10_ (t);
13324
13325 default:
13326 break;
13327 }
13328
13329 ffestb_subr_kill_beru_ ();
13330 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13331 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13332 }
13333
13334 /* ffestb_beru5_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN [external-file-unit
13335 COMMA]
13336
13337 return ffestb_beru5_; // to lexer
13338
13339 Handle expr construct (not NAME=expr construct) here. */
13340
13341 static ffelexHandler
13342 ffestb_beru5_ (ffelexToken t)
13343 {
13344 ffestrGenio kw;
13345
13346 ffestb_local_.beru.label = FALSE;
13347
13348 switch (ffelex_token_type (t))
13349 {
13350 case FFELEX_typeNAME:
13351 kw = ffestr_genio (t);
13352 switch (kw)
13353 {
13354 case FFESTR_genioERR:
13355 ffestb_local_.beru.ix = FFESTP_beruixERR;
13356 ffestb_local_.beru.label = TRUE;
13357 break;
13358
13359 case FFESTR_genioIOSTAT:
13360 ffestb_local_.beru.ix = FFESTP_beruixIOSTAT;
13361 ffestb_local_.beru.left = TRUE;
13362 ffestb_local_.beru.context = FFEEXPR_contextFILEINT;
13363 break;
13364
13365 case FFESTR_genioUNIT:
13366 ffestb_local_.beru.ix = FFESTP_beruixUNIT;
13367 ffestb_local_.beru.left = FALSE;
13368 ffestb_local_.beru.context = FFEEXPR_contextFILENUM;
13369 break;
13370
13371 default:
13372 goto bad; /* :::::::::::::::::::: */
13373 }
13374 if (ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13375 .kw_or_val_present)
13376 break; /* Can't specify a keyword twice! */
13377 ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13378 .kw_or_val_present = TRUE;
13379 ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13380 .kw_present = TRUE;
13381 ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13382 .value_present = FALSE;
13383 ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value_is_label
13384 = ffestb_local_.beru.label;
13385 ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].kw
13386 = ffelex_token_use (t);
13387 return (ffelexHandler) ffestb_beru6_;
13388
13389 default:
13390 break;
13391 }
13392
13393 bad: /* :::::::::::::::::::: */
13394 ffestb_subr_kill_beru_ ();
13395 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13396 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13397 }
13398
13399 /* ffestb_beru6_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN [external-file-unit
13400 COMMA] NAME
13401
13402 return ffestb_beru6_; // to lexer
13403
13404 Make sure EQUALS here, send next token to expression handler. */
13405
13406 static ffelexHandler
13407 ffestb_beru6_ (ffelexToken t)
13408 {
13409
13410 switch (ffelex_token_type (t))
13411 {
13412 case FFELEX_typeEQUALS:
13413 ffesta_confirmed ();
13414 if (ffestb_local_.beru.label)
13415 return (ffelexHandler) ffestb_beru8_;
13416 if (ffestb_local_.beru.left)
13417 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13418 ffestb_local_.beru.context,
13419 (ffeexprCallback) ffestb_beru7_);
13420 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13421 ffestb_local_.beru.context,
13422 (ffeexprCallback) ffestb_beru7_);
13423
13424 default:
13425 break;
13426 }
13427
13428 ffestb_subr_kill_beru_ ();
13429 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13430 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13431 }
13432
13433 /* ffestb_beru7_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS expr
13434
13435 (ffestb_beru7_) // to expression handler
13436
13437 Handle COMMA or CLOSE_PAREN here. */
13438
13439 static ffelexHandler
13440 ffestb_beru7_ (ffelexToken ft, ffebld expr, ffelexToken t)
13441 {
13442 switch (ffelex_token_type (t))
13443 {
13444 case FFELEX_typeCOMMA:
13445 case FFELEX_typeCLOSE_PAREN:
13446 if (expr == NULL)
13447 break;
13448 ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value_present
13449 = TRUE;
13450 ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value
13451 = ffelex_token_use (ft);
13452 ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].u.expr = expr;
13453 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
13454 return (ffelexHandler) ffestb_beru5_;
13455 return (ffelexHandler) ffestb_beru10_;
13456
13457 default:
13458 break;
13459 }
13460
13461 ffestb_subr_kill_beru_ ();
13462 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13463 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13464 }
13465
13466 /* ffestb_beru8_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS
13467
13468 return ffestb_beru8_; // to lexer
13469
13470 Handle NUMBER for label here. */
13471
13472 static ffelexHandler
13473 ffestb_beru8_ (ffelexToken t)
13474 {
13475 switch (ffelex_token_type (t))
13476 {
13477 case FFELEX_typeNUMBER:
13478 ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value_present
13479 = TRUE;
13480 ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value
13481 = ffelex_token_use (t);
13482 return (ffelexHandler) ffestb_beru9_;
13483
13484 default:
13485 break;
13486 }
13487
13488 ffestb_subr_kill_beru_ ();
13489 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13490 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13491 }
13492
13493 /* ffestb_beru9_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS
13494 NUMBER
13495
13496 return ffestb_beru9_; // to lexer
13497
13498 Handle COMMA or CLOSE_PAREN here. */
13499
13500 static ffelexHandler
13501 ffestb_beru9_ (ffelexToken t)
13502 {
13503 switch (ffelex_token_type (t))
13504 {
13505 case FFELEX_typeCOMMA:
13506 return (ffelexHandler) ffestb_beru5_;
13507
13508 case FFELEX_typeCLOSE_PAREN:
13509 return (ffelexHandler) ffestb_beru10_;
13510
13511 default:
13512 break;
13513 }
13514
13515 ffestb_subr_kill_beru_ ();
13516 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13517 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13518 }
13519
13520 /* ffestb_beru10_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... CLOSE_PAREN
13521
13522 return ffestb_beru10_; // to lexer
13523
13524 Handle EOS or SEMICOLON here. */
13525
13526 static ffelexHandler
13527 ffestb_beru10_ (ffelexToken t)
13528 {
13529 switch (ffelex_token_type (t))
13530 {
13531 case FFELEX_typeEOS:
13532 case FFELEX_typeSEMICOLON:
13533 ffesta_confirmed ();
13534 if (!ffesta_is_inhibited ())
13535 {
13536 switch (ffesta_first_kw)
13537 {
13538 case FFESTR_firstBACKSPACE:
13539 ffestc_R919 ();
13540 break;
13541
13542 case FFESTR_firstENDFILE:
13543 case FFESTR_firstEND:
13544 ffestc_R920 ();
13545 break;
13546
13547 case FFESTR_firstREWIND:
13548 ffestc_R921 ();
13549 break;
13550
13551 #if FFESTR_VXT
13552 case FFESTR_firstUNLOCK:
13553 ffestc_V022 ();
13554 break;
13555 #endif
13556
13557 default:
13558 assert (FALSE);
13559 }
13560 }
13561 ffestb_subr_kill_beru_ ();
13562 return (ffelexHandler) ffesta_zero (t);
13563
13564 default:
13565 break;
13566 }
13567
13568 ffestb_subr_kill_beru_ ();
13569 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13570 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13571 }
13572
13573 /* ffestb_vxtcode -- Parse the VXT DECODE/ENCODE statement
13574
13575 return ffestb_vxtcode; // to lexer
13576
13577 Make sure the statement has a valid form for the VXT DECODE/ENCODE
13578 statement. If it does, implement the statement. */
13579
13580 #if FFESTR_VXT
13581 ffelexHandler
13582 ffestb_vxtcode (ffelexToken t)
13583 {
13584 ffestpVxtcodeIx ix;
13585
13586 switch (ffelex_token_type (ffesta_tokens[0]))
13587 {
13588 case FFELEX_typeNAME:
13589 switch (ffelex_token_type (t))
13590 {
13591 case FFELEX_typeCOMMA:
13592 case FFELEX_typeCOLONCOLON:
13593 case FFELEX_typeEOS:
13594 case FFELEX_typeSEMICOLON:
13595 case FFELEX_typeNAME:
13596 case FFELEX_typeNUMBER:
13597 ffesta_confirmed (); /* Error, but clearly intended. */
13598 goto bad_1; /* :::::::::::::::::::: */
13599
13600 default:
13601 goto bad_1; /* :::::::::::::::::::: */
13602
13603 case FFELEX_typeOPEN_PAREN:
13604 for (ix = 0; ix < FFESTP_vxtcodeix; ++ix)
13605 ffestp_file.vxtcode.vxtcode_spec[ix].kw_or_val_present = FALSE;
13606 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13607 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_vxtcode1_);
13608 }
13609
13610 case FFELEX_typeNAMES:
13611 switch (ffelex_token_type (t))
13612 {
13613 case FFELEX_typeEOS:
13614 case FFELEX_typeSEMICOLON:
13615 case FFELEX_typeCOMMA:
13616 case FFELEX_typeCOLONCOLON:
13617 ffesta_confirmed (); /* Error, but clearly intended. */
13618 goto bad_1; /* :::::::::::::::::::: */
13619
13620 default:
13621 goto bad_1; /* :::::::::::::::::::: */
13622
13623 case FFELEX_typeOPEN_PAREN:
13624 if (ffelex_token_length (ffesta_tokens[0])
13625 != ffestb_args.vxtcode.len)
13626 goto bad_0; /* :::::::::::::::::::: */
13627
13628 for (ix = 0; ix < FFESTP_vxtcodeix; ++ix)
13629 ffestp_file.vxtcode.vxtcode_spec[ix].kw_or_val_present = FALSE;
13630 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13631 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_vxtcode1_);
13632 }
13633
13634 default:
13635 goto bad_0; /* :::::::::::::::::::: */
13636 }
13637
13638 bad_0: /* :::::::::::::::::::: */
13639 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, ffesta_tokens[0]);
13640 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13641
13642 bad_1: /* :::::::::::::::::::: */
13643 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13644 return (ffelexHandler) ffelex_swallow_tokens (t,
13645 (ffelexHandler) ffesta_zero); /* Invalid second token. */
13646 }
13647
13648 /* ffestb_vxtcode1_ -- "VXTCODE" OPEN_PAREN expr
13649
13650 (ffestb_vxtcode1_) // to expression handler
13651
13652 Handle COMMA here. */
13653
13654 static ffelexHandler
13655 ffestb_vxtcode1_ (ffelexToken ft, ffebld expr, ffelexToken t)
13656 {
13657 switch (ffelex_token_type (t))
13658 {
13659 case FFELEX_typeCOMMA:
13660 if (expr == NULL)
13661 break;
13662 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].kw_or_val_present
13663 = TRUE;
13664 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].kw_present = FALSE;
13665 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value_present = TRUE;
13666 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value_is_label
13667 = FALSE;
13668 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value
13669 = ffelex_token_use (ft);
13670 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].u.expr = expr;
13671 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13672 FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_vxtcode2_);
13673
13674 default:
13675 break;
13676 }
13677
13678 ffestb_subr_kill_vxtcode_ ();
13679 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13680 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13681 }
13682
13683 /* ffestb_vxtcode2_ -- "VXTCODE" OPEN_PAREN expr COMMA expr
13684
13685 (ffestb_vxtcode2_) // to expression handler
13686
13687 Handle COMMA here. */
13688
13689 static ffelexHandler
13690 ffestb_vxtcode2_ (ffelexToken ft, ffebld expr, ffelexToken t)
13691 {
13692 switch (ffelex_token_type (t))
13693 {
13694 case FFELEX_typeCOMMA:
13695 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].kw_or_val_present
13696 = TRUE;
13697 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].kw_present = FALSE;
13698 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value_present = TRUE;
13699 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value_is_label
13700 = (expr == NULL);
13701 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value
13702 = ffelex_token_use (ft);
13703 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].u.expr = expr;
13704 if (ffesta_first_kw == FFESTR_firstENCODE)
13705 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13706 FFEEXPR_contextFILEVXTCODE,
13707 (ffeexprCallback) ffestb_vxtcode3_);
13708 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13709 FFEEXPR_contextFILEVXTCODE,
13710 (ffeexprCallback) ffestb_vxtcode3_);
13711
13712 default:
13713 break;
13714 }
13715
13716 ffestb_subr_kill_vxtcode_ ();
13717 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13718 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13719 }
13720
13721 /* ffestb_vxtcode3_ -- "VXTCODE" OPEN_PAREN expr COMMA expr COMMA expr
13722
13723 (ffestb_vxtcode3_) // to expression handler
13724
13725 Handle COMMA or CLOSE_PAREN here. */
13726
13727 static ffelexHandler
13728 ffestb_vxtcode3_ (ffelexToken ft, ffebld expr, ffelexToken t)
13729 {
13730 switch (ffelex_token_type (t))
13731 {
13732 case FFELEX_typeCOMMA:
13733 case FFELEX_typeCLOSE_PAREN:
13734 if (expr == NULL)
13735 break;
13736 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].kw_or_val_present
13737 = TRUE;
13738 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].kw_present = FALSE;
13739 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value_present = TRUE;
13740 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value_is_label
13741 = FALSE;
13742 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value
13743 = ffelex_token_use (ft);
13744 ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].u.expr = expr;
13745 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
13746 return (ffelexHandler) ffestb_vxtcode4_;
13747 return (ffelexHandler) ffestb_vxtcode9_;
13748
13749 default:
13750 break;
13751 }
13752
13753 ffestb_subr_kill_vxtcode_ ();
13754 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13755 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13756 }
13757
13758 /* ffestb_vxtcode4_ -- "VXTCODE" OPEN_PAREN ...
13759
13760 return ffestb_vxtcode4_; // to lexer
13761
13762 Handle NAME=expr construct here. */
13763
13764 static ffelexHandler
13765 ffestb_vxtcode4_ (ffelexToken t)
13766 {
13767 ffestrGenio kw;
13768
13769 ffestb_local_.vxtcode.label = FALSE;
13770
13771 switch (ffelex_token_type (t))
13772 {
13773 case FFELEX_typeNAME:
13774 kw = ffestr_genio (t);
13775 switch (kw)
13776 {
13777 case FFESTR_genioERR:
13778 ffestb_local_.vxtcode.ix = FFESTP_vxtcodeixERR;
13779 ffestb_local_.vxtcode.label = TRUE;
13780 break;
13781
13782 case FFESTR_genioIOSTAT:
13783 ffestb_local_.vxtcode.ix = FFESTP_vxtcodeixIOSTAT;
13784 ffestb_local_.vxtcode.left = TRUE;
13785 ffestb_local_.vxtcode.context = FFEEXPR_contextFILEINT;
13786 break;
13787
13788 default:
13789 goto bad; /* :::::::::::::::::::: */
13790 }
13791 if (ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13792 .kw_or_val_present)
13793 break; /* Can't specify a keyword twice! */
13794 ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13795 .kw_or_val_present = TRUE;
13796 ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13797 .kw_present = TRUE;
13798 ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13799 .value_present = FALSE;
13800 ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value_is_label
13801 = ffestb_local_.vxtcode.label;
13802 ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].kw
13803 = ffelex_token_use (t);
13804 return (ffelexHandler) ffestb_vxtcode5_;
13805
13806 default:
13807 break;
13808 }
13809
13810 bad: /* :::::::::::::::::::: */
13811 ffestb_subr_kill_vxtcode_ ();
13812 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13813 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13814 }
13815
13816 /* ffestb_vxtcode5_ -- "VXTCODE" OPEN_PAREN [external-file-unit COMMA [format
13817 COMMA]] NAME
13818
13819 return ffestb_vxtcode5_; // to lexer
13820
13821 Make sure EQUALS here, send next token to expression handler. */
13822
13823 static ffelexHandler
13824 ffestb_vxtcode5_ (ffelexToken t)
13825 {
13826 switch (ffelex_token_type (t))
13827 {
13828 case FFELEX_typeEQUALS:
13829 ffesta_confirmed ();
13830 if (ffestb_local_.vxtcode.label)
13831 return (ffelexHandler) ffestb_vxtcode7_;
13832 if (ffestb_local_.vxtcode.left)
13833 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13834 ffestb_local_.vxtcode.context,
13835 (ffeexprCallback) ffestb_vxtcode6_);
13836 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13837 ffestb_local_.vxtcode.context,
13838 (ffeexprCallback) ffestb_vxtcode6_);
13839
13840 default:
13841 break;
13842 }
13843
13844 ffestb_subr_kill_vxtcode_ ();
13845 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13846 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13847 }
13848
13849 /* ffestb_vxtcode6_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS expr
13850
13851 (ffestb_vxtcode6_) // to expression handler
13852
13853 Handle COMMA or CLOSE_PAREN here. */
13854
13855 static ffelexHandler
13856 ffestb_vxtcode6_ (ffelexToken ft, ffebld expr, ffelexToken t)
13857 {
13858 switch (ffelex_token_type (t))
13859 {
13860 case FFELEX_typeCOMMA:
13861 case FFELEX_typeCLOSE_PAREN:
13862 if (expr == NULL)
13863 break;
13864 ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value_present
13865 = TRUE;
13866 ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value
13867 = ffelex_token_use (ft);
13868 ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].u.expr = expr;
13869 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
13870 return (ffelexHandler) ffestb_vxtcode4_;
13871 return (ffelexHandler) ffestb_vxtcode9_;
13872
13873 default:
13874 break;
13875 }
13876
13877 ffestb_subr_kill_vxtcode_ ();
13878 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13879 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13880 }
13881
13882 /* ffestb_vxtcode7_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS
13883
13884 return ffestb_vxtcode7_; // to lexer
13885
13886 Handle NUMBER for label here. */
13887
13888 static ffelexHandler
13889 ffestb_vxtcode7_ (ffelexToken t)
13890 {
13891 switch (ffelex_token_type (t))
13892 {
13893 case FFELEX_typeNUMBER:
13894 ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value_present
13895 = TRUE;
13896 ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value
13897 = ffelex_token_use (t);
13898 return (ffelexHandler) ffestb_vxtcode8_;
13899
13900 default:
13901 break;
13902 }
13903
13904 ffestb_subr_kill_vxtcode_ ();
13905 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13906 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13907 }
13908
13909 /* ffestb_vxtcode8_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS NUMBER
13910
13911 return ffestb_vxtcode8_; // to lexer
13912
13913 Handle COMMA or CLOSE_PAREN here. */
13914
13915 static ffelexHandler
13916 ffestb_vxtcode8_ (ffelexToken t)
13917 {
13918 switch (ffelex_token_type (t))
13919 {
13920 case FFELEX_typeCOMMA:
13921 return (ffelexHandler) ffestb_vxtcode4_;
13922
13923 case FFELEX_typeCLOSE_PAREN:
13924 return (ffelexHandler) ffestb_vxtcode9_;
13925
13926 default:
13927 break;
13928 }
13929
13930 ffestb_subr_kill_vxtcode_ ();
13931 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13932 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13933 }
13934
13935 /* ffestb_vxtcode9_ -- "VXTCODE" OPEN_PAREN ... CLOSE_PAREN
13936
13937 return ffestb_vxtcode9_; // to lexer
13938
13939 Handle EOS or SEMICOLON here.
13940
13941 07-Jun-90 JCB 1.1
13942 Context for ENCODE/DECODE expressions is now IOLISTDF instead of IOLIST
13943 since they apply to internal files. */
13944
13945 static ffelexHandler
13946 ffestb_vxtcode9_ (ffelexToken t)
13947 {
13948 ffelexHandler next;
13949
13950 switch (ffelex_token_type (t))
13951 {
13952 case FFELEX_typeEOS:
13953 case FFELEX_typeSEMICOLON:
13954 ffesta_confirmed ();
13955 if (!ffesta_is_inhibited ())
13956 {
13957 if (ffesta_first_kw == FFESTR_firstENCODE)
13958 {
13959 ffestc_V023_start ();
13960 ffestc_V023_finish ();
13961 }
13962 else
13963 {
13964 ffestc_V024_start ();
13965 ffestc_V024_finish ();
13966 }
13967 }
13968 ffestb_subr_kill_vxtcode_ ();
13969 return (ffelexHandler) ffesta_zero (t);
13970
13971 case FFELEX_typeNAME:
13972 case FFELEX_typeOPEN_PAREN:
13973 case FFELEX_typeCOMMA:
13974 ffesta_confirmed ();
13975 if (!ffesta_is_inhibited ())
13976 if (ffesta_first_kw == FFESTR_firstENCODE)
13977 ffestc_V023_start ();
13978 else
13979 ffestc_V024_start ();
13980 ffestb_subr_kill_vxtcode_ ();
13981 if (ffesta_first_kw == FFESTR_firstDECODE)
13982 next = (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13983 FFEEXPR_contextIOLISTDF,
13984 (ffeexprCallback) ffestb_vxtcode10_);
13985 else
13986 next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13987 FFEEXPR_contextIOLISTDF,
13988 (ffeexprCallback) ffestb_vxtcode10_);
13989
13990 /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
13991 (f2c provides this extension, as do other compilers, supposedly.) */
13992
13993 if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
13994 return next;
13995
13996 return (ffelexHandler) (*next) (t);
13997
13998 default:
13999 break;
14000 }
14001
14002 ffestb_subr_kill_vxtcode_ ();
14003 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
14004 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14005 }
14006
14007 /* ffestb_vxtcode10_ -- "VXTCODE(...)" expr
14008
14009 (ffestb_vxtcode10_) // to expression handler
14010
14011 Handle COMMA or EOS/SEMICOLON here.
14012
14013 07-Jun-90 JCB 1.1
14014 Context for ENCODE/DECODE expressions is now IOLISTDF instead of IOLIST
14015 since they apply to internal files. */
14016
14017 static ffelexHandler
14018 ffestb_vxtcode10_ (ffelexToken ft, ffebld expr, ffelexToken t)
14019 {
14020 switch (ffelex_token_type (t))
14021 {
14022 case FFELEX_typeCOMMA:
14023 if (expr == NULL)
14024 break;
14025 if (!ffesta_is_inhibited ())
14026 if (ffesta_first_kw == FFESTR_firstENCODE)
14027 ffestc_V023_item (expr, ft);
14028 else
14029 ffestc_V024_item (expr, ft);
14030 if (ffesta_first_kw == FFESTR_firstDECODE)
14031 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
14032 FFEEXPR_contextIOLISTDF,
14033 (ffeexprCallback) ffestb_vxtcode10_);
14034 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14035 FFEEXPR_contextIOLISTDF,
14036 (ffeexprCallback) ffestb_vxtcode10_);
14037
14038 case FFELEX_typeEOS:
14039 case FFELEX_typeSEMICOLON:
14040 if (expr == NULL)
14041 break;
14042 if (!ffesta_is_inhibited ())
14043 {
14044 if (ffesta_first_kw == FFESTR_firstENCODE)
14045 {
14046 ffestc_V023_item (expr, ft);
14047 ffestc_V023_finish ();
14048 }
14049 else
14050 {
14051 ffestc_V024_item (expr, ft);
14052 ffestc_V024_finish ();
14053 }
14054 }
14055 return (ffelexHandler) ffesta_zero (t);
14056
14057 default:
14058 break;
14059 }
14060
14061 if (!ffesta_is_inhibited ())
14062 if (ffesta_first_kw == FFESTR_firstENCODE)
14063 ffestc_V023_finish ();
14064 else
14065 ffestc_V024_finish ();
14066 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
14067 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14068 }
14069
14070 #endif
14071 /* ffestb_R904 -- Parse an OPEN statement
14072
14073 return ffestb_R904; // to lexer
14074
14075 Make sure the statement has a valid form for an OPEN statement.
14076 If it does, implement the statement. */
14077
14078 ffelexHandler
14079 ffestb_R904 (ffelexToken t)
14080 {
14081 ffestpOpenIx ix;
14082
14083 switch (ffelex_token_type (ffesta_tokens[0]))
14084 {
14085 case FFELEX_typeNAME:
14086 if (ffesta_first_kw != FFESTR_firstOPEN)
14087 goto bad_0; /* :::::::::::::::::::: */
14088 break;
14089
14090 case FFELEX_typeNAMES:
14091 if (ffesta_first_kw != FFESTR_firstOPEN)
14092 goto bad_0; /* :::::::::::::::::::: */
14093 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlOPEN)
14094 goto bad_0; /* :::::::::::::::::::: */
14095 break;
14096
14097 default:
14098 goto bad_0; /* :::::::::::::::::::: */
14099 }
14100
14101 switch (ffelex_token_type (t))
14102 {
14103 case FFELEX_typeOPEN_PAREN:
14104 break;
14105
14106 case FFELEX_typeEOS:
14107 case FFELEX_typeSEMICOLON:
14108 case FFELEX_typeCOMMA:
14109 case FFELEX_typeCOLONCOLON:
14110 ffesta_confirmed (); /* Error, but clearly intended. */
14111 goto bad_1; /* :::::::::::::::::::: */
14112
14113 default:
14114 goto bad_1; /* :::::::::::::::::::: */
14115 }
14116
14117 for (ix = 0; ix < FFESTP_openix; ++ix)
14118 ffestp_file.open.open_spec[ix].kw_or_val_present = FALSE;
14119
14120 return (ffelexHandler) ffestb_R9041_;
14121
14122 bad_0: /* :::::::::::::::::::: */
14123 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", ffesta_tokens[0]);
14124 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14125
14126 bad_1: /* :::::::::::::::::::: */
14127 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14128 return (ffelexHandler) ffelex_swallow_tokens (t,
14129 (ffelexHandler) ffesta_zero); /* Invalid second token. */
14130 }
14131
14132 /* ffestb_R9041_ -- "OPEN" OPEN_PAREN
14133
14134 return ffestb_R9041_; // to lexer
14135
14136 Handle expr construct (not NAME=expr construct) here. */
14137
14138 static ffelexHandler
14139 ffestb_R9041_ (ffelexToken t)
14140 {
14141 switch (ffelex_token_type (t))
14142 {
14143 case FFELEX_typeNAME:
14144 ffesta_tokens[1] = ffelex_token_use (t);
14145 return (ffelexHandler) ffestb_R9042_;
14146
14147 default:
14148 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14149 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9043_)))
14150 (t);
14151 }
14152 }
14153
14154 /* ffestb_R9042_ -- "OPEN" OPEN_PAREN NAME
14155
14156 return ffestb_R9042_; // to lexer
14157
14158 If EQUALS here, go to states that handle it. Else, send NAME and this
14159 token thru expression handler. */
14160
14161 static ffelexHandler
14162 ffestb_R9042_ (ffelexToken t)
14163 {
14164 ffelexHandler next;
14165 ffelexToken nt;
14166
14167 switch (ffelex_token_type (t))
14168 {
14169 case FFELEX_typeEQUALS:
14170 nt = ffesta_tokens[1];
14171 next = (ffelexHandler) ffestb_R9044_ (nt);
14172 ffelex_token_kill (nt);
14173 return (ffelexHandler) (*next) (t);
14174
14175 default:
14176 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14177 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9043_)))
14178 (ffesta_tokens[1]);
14179 ffelex_token_kill (ffesta_tokens[1]);
14180 return (ffelexHandler) (*next) (t);
14181 }
14182 }
14183
14184 /* ffestb_R9043_ -- "OPEN" OPEN_PAREN expr
14185
14186 (ffestb_R9043_) // to expression handler
14187
14188 Handle COMMA or CLOSE_PAREN here. */
14189
14190 static ffelexHandler
14191 ffestb_R9043_ (ffelexToken ft, ffebld expr, ffelexToken t)
14192 {
14193 switch (ffelex_token_type (t))
14194 {
14195 case FFELEX_typeCOMMA:
14196 case FFELEX_typeCLOSE_PAREN:
14197 if (expr == NULL)
14198 break;
14199 ffestp_file.open.open_spec[FFESTP_openixUNIT].kw_or_val_present
14200 = TRUE;
14201 ffestp_file.open.open_spec[FFESTP_openixUNIT].kw_present = FALSE;
14202 ffestp_file.open.open_spec[FFESTP_openixUNIT].value_present = TRUE;
14203 ffestp_file.open.open_spec[FFESTP_openixUNIT].value_is_label
14204 = FALSE;
14205 ffestp_file.open.open_spec[FFESTP_openixUNIT].value
14206 = ffelex_token_use (ft);
14207 ffestp_file.open.open_spec[FFESTP_openixUNIT].u.expr = expr;
14208 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14209 return (ffelexHandler) ffestb_R9044_;
14210 return (ffelexHandler) ffestb_R9049_;
14211
14212 default:
14213 break;
14214 }
14215
14216 ffestb_subr_kill_open_ ();
14217 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14218 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14219 }
14220
14221 /* ffestb_R9044_ -- "OPEN" OPEN_PAREN [external-file-unit COMMA]
14222
14223 return ffestb_R9044_; // to lexer
14224
14225 Handle expr construct (not NAME=expr construct) here. */
14226
14227 static ffelexHandler
14228 ffestb_R9044_ (ffelexToken t)
14229 {
14230 ffestrOpen kw;
14231
14232 ffestb_local_.open.label = FALSE;
14233
14234 switch (ffelex_token_type (t))
14235 {
14236 case FFELEX_typeNAME:
14237 kw = ffestr_open (t);
14238 switch (kw)
14239 {
14240 case FFESTR_openACCESS:
14241 ffestb_local_.open.ix = FFESTP_openixACCESS;
14242 ffestb_local_.open.left = FALSE;
14243 ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14244 break;
14245
14246 case FFESTR_openACTION:
14247 ffestb_local_.open.ix = FFESTP_openixACTION;
14248 ffestb_local_.open.left = FALSE;
14249 ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14250 break;
14251
14252 case FFESTR_openASSOCIATEVARIABLE:
14253 ffestb_local_.open.ix = FFESTP_openixASSOCIATEVARIABLE;
14254 ffestb_local_.open.left = TRUE;
14255 ffestb_local_.open.context = FFEEXPR_contextFILEASSOC;
14256 break;
14257
14258 case FFESTR_openBLANK:
14259 ffestb_local_.open.ix = FFESTP_openixBLANK;
14260 ffestb_local_.open.left = FALSE;
14261 ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14262 break;
14263
14264 case FFESTR_openBLOCKSIZE:
14265 ffestb_local_.open.ix = FFESTP_openixBLOCKSIZE;
14266 ffestb_local_.open.left = FALSE;
14267 ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14268 break;
14269
14270 case FFESTR_openBUFFERCOUNT:
14271 ffestb_local_.open.ix = FFESTP_openixBUFFERCOUNT;
14272 ffestb_local_.open.left = FALSE;
14273 ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14274 break;
14275
14276 case FFESTR_openCARRIAGECONTROL:
14277 ffestb_local_.open.ix = FFESTP_openixCARRIAGECONTROL;
14278 ffestb_local_.open.left = FALSE;
14279 ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14280 break;
14281
14282 case FFESTR_openDEFAULTFILE:
14283 ffestb_local_.open.ix = FFESTP_openixDEFAULTFILE;
14284 ffestb_local_.open.left = FALSE;
14285 ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14286 break;
14287
14288 case FFESTR_openDELIM:
14289 ffestb_local_.open.ix = FFESTP_openixDELIM;
14290 ffestb_local_.open.left = FALSE;
14291 ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14292 break;
14293
14294 case FFESTR_openDISP:
14295 case FFESTR_openDISPOSE:
14296 ffestb_local_.open.ix = FFESTP_openixDISPOSE;
14297 ffestb_local_.open.left = FALSE;
14298 ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14299 break;
14300
14301 case FFESTR_openERR:
14302 ffestb_local_.open.ix = FFESTP_openixERR;
14303 ffestb_local_.open.label = TRUE;
14304 break;
14305
14306 case FFESTR_openEXTENDSIZE:
14307 ffestb_local_.open.ix = FFESTP_openixEXTENDSIZE;
14308 ffestb_local_.open.left = FALSE;
14309 ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14310 break;
14311
14312 case FFESTR_openFILE:
14313 case FFESTR_openNAME:
14314 ffestb_local_.open.ix = FFESTP_openixFILE;
14315 ffestb_local_.open.left = FALSE;
14316 ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14317 break;
14318
14319 case FFESTR_openFORM:
14320 ffestb_local_.open.ix = FFESTP_openixFORM;
14321 ffestb_local_.open.left = FALSE;
14322 ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14323 break;
14324
14325 case FFESTR_openINITIALSIZE:
14326 ffestb_local_.open.ix = FFESTP_openixINITIALSIZE;
14327 ffestb_local_.open.left = FALSE;
14328 ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14329 break;
14330
14331 case FFESTR_openIOSTAT:
14332 ffestb_local_.open.ix = FFESTP_openixIOSTAT;
14333 ffestb_local_.open.left = TRUE;
14334 ffestb_local_.open.context = FFEEXPR_contextFILEINT;
14335 break;
14336
14337 #if 0 /* Haven't added support for expression
14338 context yet (though easy). */
14339 case FFESTR_openKEY:
14340 ffestb_local_.open.ix = FFESTP_openixKEY;
14341 ffestb_local_.open.left = FALSE;
14342 ffestb_local_.open.context = FFEEXPR_contextFILEKEY;
14343 break;
14344 #endif
14345
14346 case FFESTR_openMAXREC:
14347 ffestb_local_.open.ix = FFESTP_openixMAXREC;
14348 ffestb_local_.open.left = FALSE;
14349 ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14350 break;
14351
14352 case FFESTR_openNOSPANBLOCKS:
14353 if (ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14354 .kw_or_val_present)
14355 goto bad; /* :::::::::::::::::::: */
14356 ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14357 .kw_or_val_present = TRUE;
14358 ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14359 .kw_present = TRUE;
14360 ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14361 .value_present = FALSE;
14362 ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS].kw
14363 = ffelex_token_use (t);
14364 return (ffelexHandler) ffestb_R9048_;
14365
14366 case FFESTR_openORGANIZATION:
14367 ffestb_local_.open.ix = FFESTP_openixORGANIZATION;
14368 ffestb_local_.open.left = FALSE;
14369 ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14370 break;
14371
14372 case FFESTR_openPAD:
14373 ffestb_local_.open.ix = FFESTP_openixPAD;
14374 ffestb_local_.open.left = FALSE;
14375 ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14376 break;
14377
14378 case FFESTR_openPOSITION:
14379 ffestb_local_.open.ix = FFESTP_openixPOSITION;
14380 ffestb_local_.open.left = FALSE;
14381 ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14382 break;
14383
14384 case FFESTR_openREADONLY:
14385 if (ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14386 .kw_or_val_present)
14387 goto bad; /* :::::::::::::::::::: */
14388 ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14389 .kw_or_val_present = TRUE;
14390 ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14391 .kw_present = TRUE;
14392 ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14393 .value_present = FALSE;
14394 ffestp_file.open.open_spec[FFESTP_openixREADONLY].kw
14395 = ffelex_token_use (t);
14396 return (ffelexHandler) ffestb_R9048_;
14397
14398 case FFESTR_openRECL:
14399 case FFESTR_openRECORDSIZE:
14400 ffestb_local_.open.ix = FFESTP_openixRECL;
14401 ffestb_local_.open.left = FALSE;
14402 ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14403 break;
14404
14405 case FFESTR_openRECORDTYPE:
14406 ffestb_local_.open.ix = FFESTP_openixRECORDTYPE;
14407 ffestb_local_.open.left = FALSE;
14408 ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14409 break;
14410
14411 case FFESTR_openSHARED:
14412 if (ffestp_file.open.open_spec[FFESTP_openixSHARED]
14413 .kw_or_val_present)
14414 goto bad; /* :::::::::::::::::::: */
14415 ffestp_file.open.open_spec[FFESTP_openixSHARED]
14416 .kw_or_val_present = TRUE;
14417 ffestp_file.open.open_spec[FFESTP_openixSHARED]
14418 .kw_present = TRUE;
14419 ffestp_file.open.open_spec[FFESTP_openixSHARED]
14420 .value_present = FALSE;
14421 ffestp_file.open.open_spec[FFESTP_openixSHARED].kw
14422 = ffelex_token_use (t);
14423 return (ffelexHandler) ffestb_R9048_;
14424
14425 case FFESTR_openSTATUS:
14426 case FFESTR_openTYPE:
14427 ffestb_local_.open.ix = FFESTP_openixSTATUS;
14428 ffestb_local_.open.left = FALSE;
14429 ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14430 break;
14431
14432 case FFESTR_openUNIT:
14433 ffestb_local_.open.ix = FFESTP_openixUNIT;
14434 ffestb_local_.open.left = FALSE;
14435 ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14436 break;
14437
14438 case FFESTR_openUSEROPEN:
14439 ffestb_local_.open.ix = FFESTP_openixUSEROPEN;
14440 ffestb_local_.open.left = TRUE;
14441 ffestb_local_.open.context = FFEEXPR_contextFILEEXTFUNC;
14442 break;
14443
14444 default:
14445 goto bad; /* :::::::::::::::::::: */
14446 }
14447 if (ffestp_file.open.open_spec[ffestb_local_.open.ix]
14448 .kw_or_val_present)
14449 break; /* Can't specify a keyword twice! */
14450 ffestp_file.open.open_spec[ffestb_local_.open.ix]
14451 .kw_or_val_present = TRUE;
14452 ffestp_file.open.open_spec[ffestb_local_.open.ix]
14453 .kw_present = TRUE;
14454 ffestp_file.open.open_spec[ffestb_local_.open.ix]
14455 .value_present = FALSE;
14456 ffestp_file.open.open_spec[ffestb_local_.open.ix].value_is_label
14457 = ffestb_local_.open.label;
14458 ffestp_file.open.open_spec[ffestb_local_.open.ix].kw
14459 = ffelex_token_use (t);
14460 return (ffelexHandler) ffestb_R9045_;
14461
14462 default:
14463 break;
14464 }
14465
14466 bad: /* :::::::::::::::::::: */
14467 ffestb_subr_kill_open_ ();
14468 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14469 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14470 }
14471
14472 /* ffestb_R9045_ -- "OPEN" OPEN_PAREN [external-file-unit COMMA] NAME
14473
14474 return ffestb_R9045_; // to lexer
14475
14476 Make sure EQUALS here, send next token to expression handler. */
14477
14478 static ffelexHandler
14479 ffestb_R9045_ (ffelexToken t)
14480 {
14481 switch (ffelex_token_type (t))
14482 {
14483 case FFELEX_typeEQUALS:
14484 ffesta_confirmed ();
14485 if (ffestb_local_.open.label)
14486 return (ffelexHandler) ffestb_R9047_;
14487 if (ffestb_local_.open.left)
14488 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
14489 ffestb_local_.open.context,
14490 (ffeexprCallback) ffestb_R9046_);
14491 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14492 ffestb_local_.open.context,
14493 (ffeexprCallback) ffestb_R9046_);
14494
14495 default:
14496 break;
14497 }
14498
14499 ffestb_subr_kill_open_ ();
14500 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14501 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14502 }
14503
14504 /* ffestb_R9046_ -- "OPEN" OPEN_PAREN ... NAME EQUALS expr
14505
14506 (ffestb_R9046_) // to expression handler
14507
14508 Handle COMMA or CLOSE_PAREN here. */
14509
14510 static ffelexHandler
14511 ffestb_R9046_ (ffelexToken ft, ffebld expr, ffelexToken t)
14512 {
14513 switch (ffelex_token_type (t))
14514 {
14515 case FFELEX_typeCOMMA:
14516 case FFELEX_typeCLOSE_PAREN:
14517 if (expr == NULL)
14518 break;
14519 ffestp_file.open.open_spec[ffestb_local_.open.ix].value_present
14520 = TRUE;
14521 ffestp_file.open.open_spec[ffestb_local_.open.ix].value
14522 = ffelex_token_use (ft);
14523 ffestp_file.open.open_spec[ffestb_local_.open.ix].u.expr = expr;
14524 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14525 return (ffelexHandler) ffestb_R9044_;
14526 return (ffelexHandler) ffestb_R9049_;
14527
14528 default:
14529 break;
14530 }
14531
14532 ffestb_subr_kill_open_ ();
14533 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14534 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14535 }
14536
14537 /* ffestb_R9047_ -- "OPEN" OPEN_PAREN ... NAME EQUALS
14538
14539 return ffestb_R9047_; // to lexer
14540
14541 Handle NUMBER for label here. */
14542
14543 static ffelexHandler
14544 ffestb_R9047_ (ffelexToken t)
14545 {
14546 switch (ffelex_token_type (t))
14547 {
14548 case FFELEX_typeNUMBER:
14549 ffestp_file.open.open_spec[ffestb_local_.open.ix].value_present
14550 = TRUE;
14551 ffestp_file.open.open_spec[ffestb_local_.open.ix].value
14552 = ffelex_token_use (t);
14553 return (ffelexHandler) ffestb_R9048_;
14554
14555 default:
14556 break;
14557 }
14558
14559 ffestb_subr_kill_open_ ();
14560 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14561 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14562 }
14563
14564 /* ffestb_R9048_ -- "OPEN" OPEN_PAREN ... NAME EQUALS NUMBER
14565
14566 return ffestb_R9048_; // to lexer
14567
14568 Handle COMMA or CLOSE_PAREN here. */
14569
14570 static ffelexHandler
14571 ffestb_R9048_ (ffelexToken t)
14572 {
14573 switch (ffelex_token_type (t))
14574 {
14575 case FFELEX_typeCOMMA:
14576 return (ffelexHandler) ffestb_R9044_;
14577
14578 case FFELEX_typeCLOSE_PAREN:
14579 return (ffelexHandler) ffestb_R9049_;
14580
14581 default:
14582 break;
14583 }
14584
14585 ffestb_subr_kill_open_ ();
14586 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14587 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14588 }
14589
14590 /* ffestb_R9049_ -- "OPEN" OPEN_PAREN ... CLOSE_PAREN
14591
14592 return ffestb_R9049_; // to lexer
14593
14594 Handle EOS or SEMICOLON here. */
14595
14596 static ffelexHandler
14597 ffestb_R9049_ (ffelexToken t)
14598 {
14599 switch (ffelex_token_type (t))
14600 {
14601 case FFELEX_typeEOS:
14602 case FFELEX_typeSEMICOLON:
14603 ffesta_confirmed ();
14604 if (!ffesta_is_inhibited ())
14605 ffestc_R904 ();
14606 ffestb_subr_kill_open_ ();
14607 return (ffelexHandler) ffesta_zero (t);
14608
14609 default:
14610 break;
14611 }
14612
14613 ffestb_subr_kill_open_ ();
14614 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14615 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14616 }
14617
14618 /* ffestb_R907 -- Parse a CLOSE statement
14619
14620 return ffestb_R907; // to lexer
14621
14622 Make sure the statement has a valid form for a CLOSE statement.
14623 If it does, implement the statement. */
14624
14625 ffelexHandler
14626 ffestb_R907 (ffelexToken t)
14627 {
14628 ffestpCloseIx ix;
14629
14630 switch (ffelex_token_type (ffesta_tokens[0]))
14631 {
14632 case FFELEX_typeNAME:
14633 if (ffesta_first_kw != FFESTR_firstCLOSE)
14634 goto bad_0; /* :::::::::::::::::::: */
14635 break;
14636
14637 case FFELEX_typeNAMES:
14638 if (ffesta_first_kw != FFESTR_firstCLOSE)
14639 goto bad_0; /* :::::::::::::::::::: */
14640 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCLOSE)
14641 goto bad_0; /* :::::::::::::::::::: */
14642 break;
14643
14644 default:
14645 goto bad_0; /* :::::::::::::::::::: */
14646 }
14647
14648 switch (ffelex_token_type (t))
14649 {
14650 case FFELEX_typeOPEN_PAREN:
14651 break;
14652
14653 case FFELEX_typeEOS:
14654 case FFELEX_typeSEMICOLON:
14655 case FFELEX_typeCOMMA:
14656 case FFELEX_typeCOLONCOLON:
14657 ffesta_confirmed (); /* Error, but clearly intended. */
14658 goto bad_1; /* :::::::::::::::::::: */
14659
14660 default:
14661 goto bad_1; /* :::::::::::::::::::: */
14662 }
14663
14664 for (ix = 0; ix < FFESTP_closeix; ++ix)
14665 ffestp_file.close.close_spec[ix].kw_or_val_present = FALSE;
14666
14667 return (ffelexHandler) ffestb_R9071_;
14668
14669 bad_0: /* :::::::::::::::::::: */
14670 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", ffesta_tokens[0]);
14671 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14672
14673 bad_1: /* :::::::::::::::::::: */
14674 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14675 return (ffelexHandler) ffelex_swallow_tokens (t,
14676 (ffelexHandler) ffesta_zero); /* Invalid second token. */
14677 }
14678
14679 /* ffestb_R9071_ -- "CLOSE" OPEN_PAREN
14680
14681 return ffestb_R9071_; // to lexer
14682
14683 Handle expr construct (not NAME=expr construct) here. */
14684
14685 static ffelexHandler
14686 ffestb_R9071_ (ffelexToken t)
14687 {
14688 switch (ffelex_token_type (t))
14689 {
14690 case FFELEX_typeNAME:
14691 ffesta_tokens[1] = ffelex_token_use (t);
14692 return (ffelexHandler) ffestb_R9072_;
14693
14694 default:
14695 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14696 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9073_)))
14697 (t);
14698 }
14699 }
14700
14701 /* ffestb_R9072_ -- "CLOSE" OPEN_PAREN NAME
14702
14703 return ffestb_R9072_; // to lexer
14704
14705 If EQUALS here, go to states that handle it. Else, send NAME and this
14706 token thru expression handler. */
14707
14708 static ffelexHandler
14709 ffestb_R9072_ (ffelexToken t)
14710 {
14711 ffelexHandler next;
14712 ffelexToken nt;
14713
14714 switch (ffelex_token_type (t))
14715 {
14716 case FFELEX_typeEQUALS:
14717 nt = ffesta_tokens[1];
14718 next = (ffelexHandler) ffestb_R9074_ (nt);
14719 ffelex_token_kill (nt);
14720 return (ffelexHandler) (*next) (t);
14721
14722 default:
14723 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14724 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9073_)))
14725 (ffesta_tokens[1]);
14726 ffelex_token_kill (ffesta_tokens[1]);
14727 return (ffelexHandler) (*next) (t);
14728 }
14729 }
14730
14731 /* ffestb_R9073_ -- "CLOSE" OPEN_PAREN expr
14732
14733 (ffestb_R9073_) // to expression handler
14734
14735 Handle COMMA or CLOSE_PAREN here. */
14736
14737 static ffelexHandler
14738 ffestb_R9073_ (ffelexToken ft, ffebld expr, ffelexToken t)
14739 {
14740 switch (ffelex_token_type (t))
14741 {
14742 case FFELEX_typeCOMMA:
14743 case FFELEX_typeCLOSE_PAREN:
14744 if (expr == NULL)
14745 break;
14746 ffestp_file.close.close_spec[FFESTP_closeixUNIT].kw_or_val_present
14747 = TRUE;
14748 ffestp_file.close.close_spec[FFESTP_closeixUNIT].kw_present = FALSE;
14749 ffestp_file.close.close_spec[FFESTP_closeixUNIT].value_present = TRUE;
14750 ffestp_file.close.close_spec[FFESTP_closeixUNIT].value_is_label
14751 = FALSE;
14752 ffestp_file.close.close_spec[FFESTP_closeixUNIT].value
14753 = ffelex_token_use (ft);
14754 ffestp_file.close.close_spec[FFESTP_closeixUNIT].u.expr = expr;
14755 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14756 return (ffelexHandler) ffestb_R9074_;
14757 return (ffelexHandler) ffestb_R9079_;
14758
14759 default:
14760 break;
14761 }
14762
14763 ffestb_subr_kill_close_ ();
14764 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14765 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14766 }
14767
14768 /* ffestb_R9074_ -- "CLOSE" OPEN_PAREN [external-file-unit COMMA]
14769
14770 return ffestb_R9074_; // to lexer
14771
14772 Handle expr construct (not NAME=expr construct) here. */
14773
14774 static ffelexHandler
14775 ffestb_R9074_ (ffelexToken t)
14776 {
14777 ffestrGenio kw;
14778
14779 ffestb_local_.close.label = FALSE;
14780
14781 switch (ffelex_token_type (t))
14782 {
14783 case FFELEX_typeNAME:
14784 kw = ffestr_genio (t);
14785 switch (kw)
14786 {
14787 case FFESTR_genioERR:
14788 ffestb_local_.close.ix = FFESTP_closeixERR;
14789 ffestb_local_.close.label = TRUE;
14790 break;
14791
14792 case FFESTR_genioIOSTAT:
14793 ffestb_local_.close.ix = FFESTP_closeixIOSTAT;
14794 ffestb_local_.close.left = TRUE;
14795 ffestb_local_.close.context = FFEEXPR_contextFILEINT;
14796 break;
14797
14798 case FFESTR_genioSTATUS:
14799 case FFESTR_genioDISP:
14800 case FFESTR_genioDISPOSE:
14801 ffestb_local_.close.ix = FFESTP_closeixSTATUS;
14802 ffestb_local_.close.left = FALSE;
14803 ffestb_local_.close.context = FFEEXPR_contextFILEDFCHAR;
14804 break;
14805
14806 case FFESTR_genioUNIT:
14807 ffestb_local_.close.ix = FFESTP_closeixUNIT;
14808 ffestb_local_.close.left = FALSE;
14809 ffestb_local_.close.context = FFEEXPR_contextFILENUM;
14810 break;
14811
14812 default:
14813 goto bad; /* :::::::::::::::::::: */
14814 }
14815 if (ffestp_file.close.close_spec[ffestb_local_.close.ix]
14816 .kw_or_val_present)
14817 break; /* Can't specify a keyword twice! */
14818 ffestp_file.close.close_spec[ffestb_local_.close.ix]
14819 .kw_or_val_present = TRUE;
14820 ffestp_file.close.close_spec[ffestb_local_.close.ix]
14821 .kw_present = TRUE;
14822 ffestp_file.close.close_spec[ffestb_local_.close.ix]
14823 .value_present = FALSE;
14824 ffestp_file.close.close_spec[ffestb_local_.close.ix].value_is_label
14825 = ffestb_local_.close.label;
14826 ffestp_file.close.close_spec[ffestb_local_.close.ix].kw
14827 = ffelex_token_use (t);
14828 return (ffelexHandler) ffestb_R9075_;
14829
14830 default:
14831 break;
14832 }
14833
14834 bad: /* :::::::::::::::::::: */
14835 ffestb_subr_kill_close_ ();
14836 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14837 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14838 }
14839
14840 /* ffestb_R9075_ -- "CLOSE" OPEN_PAREN [external-file-unit COMMA] NAME
14841
14842 return ffestb_R9075_; // to lexer
14843
14844 Make sure EQUALS here, send next token to expression handler. */
14845
14846 static ffelexHandler
14847 ffestb_R9075_ (ffelexToken t)
14848 {
14849 switch (ffelex_token_type (t))
14850 {
14851 case FFELEX_typeEQUALS:
14852 ffesta_confirmed ();
14853 if (ffestb_local_.close.label)
14854 return (ffelexHandler) ffestb_R9077_;
14855 if (ffestb_local_.close.left)
14856 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
14857 ffestb_local_.close.context,
14858 (ffeexprCallback) ffestb_R9076_);
14859 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14860 ffestb_local_.close.context,
14861 (ffeexprCallback) ffestb_R9076_);
14862
14863 default:
14864 break;
14865 }
14866
14867 ffestb_subr_kill_close_ ();
14868 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14869 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14870 }
14871
14872 /* ffestb_R9076_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS expr
14873
14874 (ffestb_R9076_) // to expression handler
14875
14876 Handle COMMA or CLOSE_PAREN here. */
14877
14878 static ffelexHandler
14879 ffestb_R9076_ (ffelexToken ft, ffebld expr, ffelexToken t)
14880 {
14881 switch (ffelex_token_type (t))
14882 {
14883 case FFELEX_typeCOMMA:
14884 case FFELEX_typeCLOSE_PAREN:
14885 if (expr == NULL)
14886 break;
14887 ffestp_file.close.close_spec[ffestb_local_.close.ix].value_present
14888 = TRUE;
14889 ffestp_file.close.close_spec[ffestb_local_.close.ix].value
14890 = ffelex_token_use (ft);
14891 ffestp_file.close.close_spec[ffestb_local_.close.ix].u.expr = expr;
14892 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14893 return (ffelexHandler) ffestb_R9074_;
14894 return (ffelexHandler) ffestb_R9079_;
14895
14896 default:
14897 break;
14898 }
14899
14900 ffestb_subr_kill_close_ ();
14901 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14902 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14903 }
14904
14905 /* ffestb_R9077_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS
14906
14907 return ffestb_R9077_; // to lexer
14908
14909 Handle NUMBER for label here. */
14910
14911 static ffelexHandler
14912 ffestb_R9077_ (ffelexToken t)
14913 {
14914 switch (ffelex_token_type (t))
14915 {
14916 case FFELEX_typeNUMBER:
14917 ffestp_file.close.close_spec[ffestb_local_.close.ix].value_present
14918 = TRUE;
14919 ffestp_file.close.close_spec[ffestb_local_.close.ix].value
14920 = ffelex_token_use (t);
14921 return (ffelexHandler) ffestb_R9078_;
14922
14923 default:
14924 break;
14925 }
14926
14927 ffestb_subr_kill_close_ ();
14928 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14929 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14930 }
14931
14932 /* ffestb_R9078_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS NUMBER
14933
14934 return ffestb_R9078_; // to lexer
14935
14936 Handle COMMA or CLOSE_PAREN here. */
14937
14938 static ffelexHandler
14939 ffestb_R9078_ (ffelexToken t)
14940 {
14941 switch (ffelex_token_type (t))
14942 {
14943 case FFELEX_typeCOMMA:
14944 return (ffelexHandler) ffestb_R9074_;
14945
14946 case FFELEX_typeCLOSE_PAREN:
14947 return (ffelexHandler) ffestb_R9079_;
14948
14949 default:
14950 break;
14951 }
14952
14953 ffestb_subr_kill_close_ ();
14954 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14955 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14956 }
14957
14958 /* ffestb_R9079_ -- "CLOSE" OPEN_PAREN ... CLOSE_PAREN
14959
14960 return ffestb_R9079_; // to lexer
14961
14962 Handle EOS or SEMICOLON here. */
14963
14964 static ffelexHandler
14965 ffestb_R9079_ (ffelexToken t)
14966 {
14967 switch (ffelex_token_type (t))
14968 {
14969 case FFELEX_typeEOS:
14970 case FFELEX_typeSEMICOLON:
14971 ffesta_confirmed ();
14972 if (!ffesta_is_inhibited ())
14973 ffestc_R907 ();
14974 ffestb_subr_kill_close_ ();
14975 return (ffelexHandler) ffesta_zero (t);
14976
14977 default:
14978 break;
14979 }
14980
14981 ffestb_subr_kill_close_ ();
14982 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14983 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14984 }
14985
14986 /* ffestb_R909 -- Parse the READ statement
14987
14988 return ffestb_R909; // to lexer
14989
14990 Make sure the statement has a valid form for the READ
14991 statement. If it does, implement the statement. */
14992
14993 ffelexHandler
14994 ffestb_R909 (ffelexToken t)
14995 {
14996 ffelexHandler next;
14997 ffestpReadIx ix;
14998
14999 switch (ffelex_token_type (ffesta_tokens[0]))
15000 {
15001 case FFELEX_typeNAME:
15002 if (ffesta_first_kw != FFESTR_firstREAD)
15003 goto bad_0; /* :::::::::::::::::::: */
15004 switch (ffelex_token_type (t))
15005 {
15006 case FFELEX_typeCOMMA:
15007 case FFELEX_typeCOLONCOLON:
15008 case FFELEX_typeEOS:
15009 case FFELEX_typeSEMICOLON:
15010 ffesta_confirmed (); /* Error, but clearly intended. */
15011 goto bad_1; /* :::::::::::::::::::: */
15012
15013 case FFELEX_typeEQUALS:
15014 case FFELEX_typePOINTS:
15015 case FFELEX_typeCOLON:
15016 goto bad_1; /* :::::::::::::::::::: */
15017
15018 case FFELEX_typeNAME:
15019 case FFELEX_typeNUMBER:
15020 ffesta_confirmed ();
15021 break;
15022
15023 case FFELEX_typeOPEN_PAREN:
15024 for (ix = 0; ix < FFESTP_readix; ++ix)
15025 ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15026 ffesta_tokens[1] = ffelex_token_use (t);
15027 return (ffelexHandler) ffestb_R9092_;
15028
15029 default:
15030 break;
15031 }
15032
15033 for (ix = 0; ix < FFESTP_readix; ++ix)
15034 ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15035 return (ffelexHandler) (*((ffelexHandler)
15036 ffeexpr_rhs (ffesta_output_pool,
15037 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9091_)))
15038 (t);
15039
15040 case FFELEX_typeNAMES:
15041 if (ffesta_first_kw != FFESTR_firstREAD)
15042 goto bad_0; /* :::::::::::::::::::: */
15043 switch (ffelex_token_type (t))
15044 {
15045 case FFELEX_typeEOS:
15046 case FFELEX_typeSEMICOLON:
15047 case FFELEX_typeCOMMA:
15048 ffesta_confirmed ();
15049 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREAD)
15050 break;
15051 goto bad_1; /* :::::::::::::::::::: */
15052
15053 case FFELEX_typeCOLONCOLON:
15054 ffesta_confirmed (); /* Error, but clearly intended. */
15055 goto bad_1; /* :::::::::::::::::::: */
15056
15057 case FFELEX_typeEQUALS:
15058 case FFELEX_typePOINTS:
15059 case FFELEX_typeCOLON:
15060 goto bad_1; /* :::::::::::::::::::: */
15061
15062 case FFELEX_typeOPEN_PAREN:
15063 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREAD)
15064 break;
15065
15066 for (ix = 0; ix < FFESTP_readix; ++ix)
15067 ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15068 ffesta_tokens[1] = ffelex_token_use (t);
15069 return (ffelexHandler) ffestb_R9092_;
15070
15071 default:
15072 break;
15073 }
15074 for (ix = 0; ix < FFESTP_readix; ++ix)
15075 ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15076 next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15077 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9091_);
15078 next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
15079 FFESTR_firstlREAD);
15080 if (next == NULL)
15081 return (ffelexHandler) ffelex_swallow_tokens (t,
15082 (ffelexHandler) ffesta_zero);
15083 return (ffelexHandler) (*next) (t);
15084
15085 default:
15086 goto bad_0; /* :::::::::::::::::::: */
15087 }
15088
15089 bad_0: /* :::::::::::::::::::: */
15090 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", ffesta_tokens[0]);
15091 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15092
15093 bad_1: /* :::::::::::::::::::: */
15094 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15095 return (ffelexHandler) ffelex_swallow_tokens (t,
15096 (ffelexHandler) ffesta_zero); /* Invalid second token. */
15097 }
15098
15099 /* ffestb_R9091_ -- "READ" expr
15100
15101 (ffestb_R9091_) // to expression handler
15102
15103 Make sure the next token is a COMMA or EOS/SEMICOLON. */
15104
15105 static ffelexHandler
15106 ffestb_R9091_ (ffelexToken ft, ffebld expr, ffelexToken t)
15107 {
15108 switch (ffelex_token_type (t))
15109 {
15110 case FFELEX_typeEOS:
15111 case FFELEX_typeSEMICOLON:
15112 case FFELEX_typeCOMMA:
15113 ffesta_confirmed ();
15114 ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
15115 = TRUE;
15116 ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
15117 ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
15118 ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
15119 = (expr == NULL);
15120 ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
15121 = ffelex_token_use (ft);
15122 ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
15123 if (!ffesta_is_inhibited ())
15124 ffestc_R909_start (TRUE);
15125 ffestb_subr_kill_read_ ();
15126 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15127 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
15128 ffestc_context_iolist (),
15129 (ffeexprCallback) ffestb_R90915_);
15130 if (!ffesta_is_inhibited ())
15131 ffestc_R909_finish ();
15132 return (ffelexHandler) ffesta_zero (t);
15133
15134 default:
15135 break;
15136 }
15137
15138 ffestb_subr_kill_read_ ();
15139 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15140 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15141 }
15142
15143 /* ffestb_R9092_ -- "READ" OPEN_PAREN
15144
15145 return ffestb_R9092_; // to lexer
15146
15147 Handle expr construct (not NAME=expr construct) here. */
15148
15149 static ffelexHandler
15150 ffestb_R9092_ (ffelexToken t)
15151 {
15152 ffelexToken nt;
15153 ffelexHandler next;
15154
15155 switch (ffelex_token_type (t))
15156 {
15157 case FFELEX_typeNAME:
15158 ffesta_tokens[2] = ffelex_token_use (t);
15159 return (ffelexHandler) ffestb_R9093_;
15160
15161 default:
15162 nt = ffesta_tokens[1];
15163 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15164 FFEEXPR_contextFILEUNITAMBIG, (ffeexprCallback) ffestb_R9094_)))
15165 (nt);
15166 ffelex_token_kill (nt);
15167 return (ffelexHandler) (*next) (t);
15168 }
15169 }
15170
15171 /* ffestb_R9093_ -- "READ" OPEN_PAREN NAME
15172
15173 return ffestb_R9093_; // to lexer
15174
15175 If EQUALS here, go to states that handle it. Else, send NAME and this
15176 token thru expression handler. */
15177
15178 static ffelexHandler
15179 ffestb_R9093_ (ffelexToken t)
15180 {
15181 ffelexHandler next;
15182 ffelexToken nt;
15183 ffelexToken ot;
15184
15185 switch (ffelex_token_type (t))
15186 {
15187 case FFELEX_typeEQUALS:
15188 ffelex_token_kill (ffesta_tokens[1]);
15189 nt = ffesta_tokens[2];
15190 next = (ffelexHandler) ffestb_R9098_ (nt);
15191 ffelex_token_kill (nt);
15192 return (ffelexHandler) (*next) (t);
15193
15194 default:
15195 nt = ffesta_tokens[1];
15196 ot = ffesta_tokens[2];
15197 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15198 FFEEXPR_contextFILEUNITAMBIG, (ffeexprCallback) ffestb_R9094_)))
15199 (nt);
15200 ffelex_token_kill (nt);
15201 next = (ffelexHandler) (*next) (ot);
15202 ffelex_token_kill (ot);
15203 return (ffelexHandler) (*next) (t);
15204 }
15205 }
15206
15207 /* ffestb_R9094_ -- "READ" OPEN_PAREN expr [CLOSE_PAREN]
15208
15209 (ffestb_R9094_) // to expression handler
15210
15211 Handle COMMA or EOS/SEMICOLON here.
15212
15213 15-Feb-91 JCB 1.1
15214 Use new ffeexpr mechanism whereby the expr is encased in an opITEM if
15215 ffeexpr decided it was an item in a control list (hence a unit
15216 specifier), or a format specifier otherwise. */
15217
15218 static ffelexHandler
15219 ffestb_R9094_ (ffelexToken ft, ffebld expr, ffelexToken t)
15220 {
15221 if (expr == NULL)
15222 goto bad; /* :::::::::::::::::::: */
15223
15224 if (ffebld_op (expr) != FFEBLD_opITEM)
15225 {
15226 switch (ffelex_token_type (t))
15227 {
15228 case FFELEX_typeCOMMA:
15229 case FFELEX_typeEOS:
15230 case FFELEX_typeSEMICOLON:
15231 ffesta_confirmed ();
15232 ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
15233 = TRUE;
15234 ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
15235 ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
15236 ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
15237 = FALSE;
15238 ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
15239 = ffelex_token_use (ft);
15240 ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
15241 if (!ffesta_is_inhibited ())
15242 ffestc_R909_start (TRUE);
15243 ffestb_subr_kill_read_ ();
15244 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15245 return (ffelexHandler)
15246 ffeexpr_lhs (ffesta_output_pool,
15247 ffestc_context_iolist (),
15248 (ffeexprCallback) ffestb_R90915_);
15249 if (!ffesta_is_inhibited ())
15250 ffestc_R909_finish ();
15251 return (ffelexHandler) ffesta_zero (t);
15252
15253 default:
15254 goto bad; /* :::::::::::::::::::: */
15255 }
15256 }
15257
15258 expr = ffebld_head (expr);
15259
15260 if (expr == NULL)
15261 goto bad; /* :::::::::::::::::::: */
15262
15263 switch (ffelex_token_type (t))
15264 {
15265 case FFELEX_typeCOMMA:
15266 case FFELEX_typeCLOSE_PAREN:
15267 ffestp_file.read.read_spec[FFESTP_readixUNIT].kw_or_val_present
15268 = TRUE;
15269 ffestp_file.read.read_spec[FFESTP_readixUNIT].kw_present = FALSE;
15270 ffestp_file.read.read_spec[FFESTP_readixUNIT].value_present = TRUE;
15271 ffestp_file.read.read_spec[FFESTP_readixUNIT].value_is_label
15272 = FALSE;
15273 ffestp_file.read.read_spec[FFESTP_readixUNIT].value
15274 = ffelex_token_use (ft);
15275 ffestp_file.read.read_spec[FFESTP_readixUNIT].u.expr = expr;
15276 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15277 return (ffelexHandler) ffestb_R9095_;
15278 return (ffelexHandler) ffestb_R90913_;
15279
15280 default:
15281 break;
15282 }
15283
15284 bad: /* :::::::::::::::::::: */
15285 ffestb_subr_kill_read_ ();
15286 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15287 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15288 }
15289
15290 /* ffestb_R9095_ -- "READ" OPEN_PAREN expr COMMA
15291
15292 return ffestb_R9095_; // to lexer
15293
15294 Handle expr construct (not NAME=expr construct) here. */
15295
15296 static ffelexHandler
15297 ffestb_R9095_ (ffelexToken t)
15298 {
15299 switch (ffelex_token_type (t))
15300 {
15301 case FFELEX_typeNAME:
15302 ffesta_tokens[1] = ffelex_token_use (t);
15303 return (ffelexHandler) ffestb_R9096_;
15304
15305 default:
15306 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15307 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9097_)))
15308 (t);
15309 }
15310 }
15311
15312 /* ffestb_R9096_ -- "READ" OPEN_PAREN expr COMMA NAME
15313
15314 return ffestb_R9096_; // to lexer
15315
15316 If EQUALS here, go to states that handle it. Else, send NAME and this
15317 token thru expression handler. */
15318
15319 static ffelexHandler
15320 ffestb_R9096_ (ffelexToken t)
15321 {
15322 ffelexHandler next;
15323 ffelexToken nt;
15324
15325 switch (ffelex_token_type (t))
15326 {
15327 case FFELEX_typeEQUALS:
15328 nt = ffesta_tokens[1];
15329 next = (ffelexHandler) ffestb_R9098_ (nt);
15330 ffelex_token_kill (nt);
15331 return (ffelexHandler) (*next) (t);
15332
15333 default:
15334 nt = ffesta_tokens[1];
15335 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15336 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9097_)))
15337 (nt);
15338 ffelex_token_kill (nt);
15339 return (ffelexHandler) (*next) (t);
15340 }
15341 }
15342
15343 /* ffestb_R9097_ -- "READ" OPEN_PAREN expr COMMA expr
15344
15345 (ffestb_R9097_) // to expression handler
15346
15347 Handle COMMA or CLOSE_PAREN here. */
15348
15349 static ffelexHandler
15350 ffestb_R9097_ (ffelexToken ft, ffebld expr, ffelexToken t)
15351 {
15352 switch (ffelex_token_type (t))
15353 {
15354 case FFELEX_typeCOMMA:
15355 case FFELEX_typeCLOSE_PAREN:
15356 ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
15357 = TRUE;
15358 ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
15359 ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
15360 ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
15361 = (expr == NULL);
15362 ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
15363 = ffelex_token_use (ft);
15364 ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
15365 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15366 return (ffelexHandler) ffestb_R9098_;
15367 return (ffelexHandler) ffestb_R90913_;
15368
15369 default:
15370 break;
15371 }
15372
15373 ffestb_subr_kill_read_ ();
15374 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15375 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15376 }
15377
15378 /* ffestb_R9098_ -- "READ" OPEN_PAREN [external-file-unit COMMA [format
15379 COMMA]]
15380
15381 return ffestb_R9098_; // to lexer
15382
15383 Handle expr construct (not NAME=expr construct) here. */
15384
15385 static ffelexHandler
15386 ffestb_R9098_ (ffelexToken t)
15387 {
15388 ffestrGenio kw;
15389
15390 ffestb_local_.read.label = FALSE;
15391
15392 switch (ffelex_token_type (t))
15393 {
15394 case FFELEX_typeNAME:
15395 kw = ffestr_genio (t);
15396 switch (kw)
15397 {
15398 case FFESTR_genioADVANCE:
15399 ffestb_local_.read.ix = FFESTP_readixADVANCE;
15400 ffestb_local_.read.left = FALSE;
15401 ffestb_local_.read.context = FFEEXPR_contextFILEDFCHAR;
15402 break;
15403
15404 case FFESTR_genioEOR:
15405 ffestb_local_.read.ix = FFESTP_readixEOR;
15406 ffestb_local_.read.label = TRUE;
15407 break;
15408
15409 case FFESTR_genioERR:
15410 ffestb_local_.read.ix = FFESTP_readixERR;
15411 ffestb_local_.read.label = TRUE;
15412 break;
15413
15414 case FFESTR_genioEND:
15415 ffestb_local_.read.ix = FFESTP_readixEND;
15416 ffestb_local_.read.label = TRUE;
15417 break;
15418
15419 case FFESTR_genioFMT:
15420 ffestb_local_.read.ix = FFESTP_readixFORMAT;
15421 ffestb_local_.read.left = FALSE;
15422 ffestb_local_.read.context = FFEEXPR_contextFILEFORMAT;
15423 break;
15424
15425 case FFESTR_genioIOSTAT:
15426 ffestb_local_.read.ix = FFESTP_readixIOSTAT;
15427 ffestb_local_.read.left = TRUE;
15428 ffestb_local_.read.context = FFEEXPR_contextFILEINT;
15429 break;
15430
15431 case FFESTR_genioKEY:
15432 case FFESTR_genioKEYEQ:
15433 ffestb_local_.read.ix = FFESTP_readixKEYEQ;
15434 ffestb_local_.read.left = FALSE;
15435 ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
15436 break;
15437
15438 case FFESTR_genioKEYGE:
15439 ffestb_local_.read.ix = FFESTP_readixKEYGE;
15440 ffestb_local_.read.left = FALSE;
15441 ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
15442 break;
15443
15444 case FFESTR_genioKEYGT:
15445 ffestb_local_.read.ix = FFESTP_readixKEYGT;
15446 ffestb_local_.read.left = FALSE;
15447 ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
15448 break;
15449
15450 case FFESTR_genioKEYID:
15451 ffestb_local_.read.ix = FFESTP_readixKEYID;
15452 ffestb_local_.read.left = FALSE;
15453 ffestb_local_.read.context = FFEEXPR_contextFILENUM;
15454 break;
15455
15456 case FFESTR_genioNML:
15457 ffestb_local_.read.ix = FFESTP_readixFORMAT;
15458 ffestb_local_.read.left = TRUE;
15459 ffestb_local_.read.context = FFEEXPR_contextFILENAMELIST;
15460 break;
15461
15462 case FFESTR_genioNULLS:
15463 ffestb_local_.read.ix = FFESTP_readixNULLS;
15464 ffestb_local_.read.left = TRUE;
15465 ffestb_local_.read.context = FFEEXPR_contextFILEINT;
15466 break;
15467
15468 case FFESTR_genioREC:
15469 ffestb_local_.read.ix = FFESTP_readixREC;
15470 ffestb_local_.read.left = FALSE;
15471 ffestb_local_.read.context = FFEEXPR_contextFILENUM;
15472 break;
15473
15474 case FFESTR_genioSIZE:
15475 ffestb_local_.read.ix = FFESTP_readixSIZE;
15476 ffestb_local_.read.left = TRUE;
15477 ffestb_local_.read.context = FFEEXPR_contextFILEINT;
15478 break;
15479
15480 case FFESTR_genioUNIT:
15481 ffestb_local_.read.ix = FFESTP_readixUNIT;
15482 ffestb_local_.read.left = FALSE;
15483 ffestb_local_.read.context = FFEEXPR_contextFILEUNIT;
15484 break;
15485
15486 default:
15487 goto bad; /* :::::::::::::::::::: */
15488 }
15489 if (ffestp_file.read.read_spec[ffestb_local_.read.ix]
15490 .kw_or_val_present)
15491 break; /* Can't specify a keyword twice! */
15492 ffestp_file.read.read_spec[ffestb_local_.read.ix]
15493 .kw_or_val_present = TRUE;
15494 ffestp_file.read.read_spec[ffestb_local_.read.ix]
15495 .kw_present = TRUE;
15496 ffestp_file.read.read_spec[ffestb_local_.read.ix]
15497 .value_present = FALSE;
15498 ffestp_file.read.read_spec[ffestb_local_.read.ix].value_is_label
15499 = ffestb_local_.read.label;
15500 ffestp_file.read.read_spec[ffestb_local_.read.ix].kw
15501 = ffelex_token_use (t);
15502 return (ffelexHandler) ffestb_R9099_;
15503
15504 default:
15505 break;
15506 }
15507
15508 bad: /* :::::::::::::::::::: */
15509 ffestb_subr_kill_read_ ();
15510 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15511 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15512 }
15513
15514 /* ffestb_R9099_ -- "READ" OPEN_PAREN [external-file-unit COMMA [format
15515 COMMA]] NAME
15516
15517 return ffestb_R9099_; // to lexer
15518
15519 Make sure EQUALS here, send next token to expression handler. */
15520
15521 static ffelexHandler
15522 ffestb_R9099_ (ffelexToken t)
15523 {
15524 switch (ffelex_token_type (t))
15525 {
15526 case FFELEX_typeEQUALS:
15527 ffesta_confirmed ();
15528 if (ffestb_local_.read.label)
15529 return (ffelexHandler) ffestb_R90911_;
15530 if (ffestb_local_.read.left)
15531 return (ffelexHandler)
15532 ffeexpr_lhs (ffesta_output_pool,
15533 ffestb_local_.read.context,
15534 (ffeexprCallback) ffestb_R90910_);
15535 return (ffelexHandler)
15536 ffeexpr_rhs (ffesta_output_pool,
15537 ffestb_local_.read.context,
15538 (ffeexprCallback) ffestb_R90910_);
15539
15540 default:
15541 break;
15542 }
15543
15544 ffestb_subr_kill_read_ ();
15545 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15546 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15547 }
15548
15549 /* ffestb_R90910_ -- "READ" OPEN_PAREN ... NAME EQUALS expr
15550
15551 (ffestb_R90910_) // to expression handler
15552
15553 Handle COMMA or CLOSE_PAREN here. */
15554
15555 static ffelexHandler
15556 ffestb_R90910_ (ffelexToken ft, ffebld expr, ffelexToken t)
15557 {
15558 switch (ffelex_token_type (t))
15559 {
15560 case FFELEX_typeCOMMA:
15561 case FFELEX_typeCLOSE_PAREN:
15562 if (expr == NULL)
15563 {
15564 if (ffestb_local_.read.context == FFEEXPR_contextFILEFORMAT)
15565 ffestp_file.read.read_spec[ffestb_local_.read.ix]
15566 .value_is_label = TRUE;
15567 else
15568 break;
15569 }
15570 ffestp_file.read.read_spec[ffestb_local_.read.ix].value_present
15571 = TRUE;
15572 ffestp_file.read.read_spec[ffestb_local_.read.ix].value
15573 = ffelex_token_use (ft);
15574 ffestp_file.read.read_spec[ffestb_local_.read.ix].u.expr = expr;
15575 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15576 return (ffelexHandler) ffestb_R9098_;
15577 return (ffelexHandler) ffestb_R90913_;
15578
15579 default:
15580 break;
15581 }
15582
15583 ffestb_subr_kill_read_ ();
15584 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15585 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15586 }
15587
15588 /* ffestb_R90911_ -- "READ" OPEN_PAREN ... NAME EQUALS
15589
15590 return ffestb_R90911_; // to lexer
15591
15592 Handle NUMBER for label here. */
15593
15594 static ffelexHandler
15595 ffestb_R90911_ (ffelexToken t)
15596 {
15597 switch (ffelex_token_type (t))
15598 {
15599 case FFELEX_typeNUMBER:
15600 ffestp_file.read.read_spec[ffestb_local_.read.ix].value_present
15601 = TRUE;
15602 ffestp_file.read.read_spec[ffestb_local_.read.ix].value
15603 = ffelex_token_use (t);
15604 return (ffelexHandler) ffestb_R90912_;
15605
15606 default:
15607 break;
15608 }
15609
15610 ffestb_subr_kill_read_ ();
15611 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15612 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15613 }
15614
15615 /* ffestb_R90912_ -- "READ" OPEN_PAREN ... NAME EQUALS NUMBER
15616
15617 return ffestb_R90912_; // to lexer
15618
15619 Handle COMMA or CLOSE_PAREN here. */
15620
15621 static ffelexHandler
15622 ffestb_R90912_ (ffelexToken t)
15623 {
15624 switch (ffelex_token_type (t))
15625 {
15626 case FFELEX_typeCOMMA:
15627 return (ffelexHandler) ffestb_R9098_;
15628
15629 case FFELEX_typeCLOSE_PAREN:
15630 return (ffelexHandler) ffestb_R90913_;
15631
15632 default:
15633 break;
15634 }
15635
15636 ffestb_subr_kill_read_ ();
15637 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15638 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15639 }
15640
15641 /* ffestb_R90913_ -- "READ" OPEN_PAREN ... CLOSE_PAREN
15642
15643 return ffestb_R90913_; // to lexer
15644
15645 Handle EOS or SEMICOLON here.
15646
15647 15-Feb-91 JCB 1.1
15648 Fix to allow implied-DO construct here (OPEN_PAREN) -- actually,
15649 don't presume knowledge of what an initial token in an lhs context
15650 is going to be, let ffeexpr_lhs handle that as much as possible. */
15651
15652 static ffelexHandler
15653 ffestb_R90913_ (ffelexToken t)
15654 {
15655 switch (ffelex_token_type (t))
15656 {
15657 case FFELEX_typeEOS:
15658 case FFELEX_typeSEMICOLON:
15659 ffesta_confirmed ();
15660 if (!ffesta_is_inhibited ())
15661 {
15662 ffestc_R909_start (FALSE);
15663 ffestc_R909_finish ();
15664 }
15665 ffestb_subr_kill_read_ ();
15666 return (ffelexHandler) ffesta_zero (t);
15667
15668 default:
15669 ffesta_confirmed ();
15670 /* Fall through. */
15671 case FFELEX_typeOPEN_PAREN: /* Could still be assignment!! */
15672 break;
15673 }
15674
15675 /* If token isn't NAME or OPEN_PAREN, ffeexpr_lhs will ultimately whine
15676 about it, so leave it up to that code. */
15677
15678 /* EXTENSION: Allow an optional preceding COMMA here if not pedantic. (f2c
15679 provides this extension, as do other compilers, supposedly.) */
15680
15681 if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
15682 return (ffelexHandler)
15683 ffeexpr_lhs (ffesta_output_pool,
15684 ffestc_context_iolist (),
15685 (ffeexprCallback) ffestb_R90914_);
15686
15687 return (ffelexHandler) (*((ffelexHandler)
15688 ffeexpr_lhs (ffesta_output_pool,
15689 ffestc_context_iolist (),
15690 (ffeexprCallback) ffestb_R90914_)))
15691 (t);
15692 }
15693
15694 /* ffestb_R90914_ -- "READ(...)" expr
15695
15696 (ffestb_R90914_) // to expression handler
15697
15698 Handle COMMA or EOS/SEMICOLON here. */
15699
15700 static ffelexHandler
15701 ffestb_R90914_ (ffelexToken ft, ffebld expr, ffelexToken t)
15702 {
15703 switch (ffelex_token_type (t))
15704 {
15705 case FFELEX_typeCOMMA:
15706 if (expr == NULL)
15707 break;
15708
15709 ffesta_confirmed ();
15710 if (!ffesta_is_inhibited ())
15711 ffestc_R909_start (FALSE);
15712 ffestb_subr_kill_read_ ();
15713
15714 if (!ffesta_is_inhibited ())
15715 ffestc_R909_item (expr, ft);
15716 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
15717 ffestc_context_iolist (),
15718 (ffeexprCallback) ffestb_R90915_);
15719
15720 case FFELEX_typeEOS:
15721 case FFELEX_typeSEMICOLON:
15722 if (expr == NULL)
15723 break;
15724
15725 ffesta_confirmed ();
15726 if (!ffesta_is_inhibited ())
15727 ffestc_R909_start (FALSE);
15728 ffestb_subr_kill_read_ ();
15729
15730 if (!ffesta_is_inhibited ())
15731 {
15732 ffestc_R909_item (expr, ft);
15733 ffestc_R909_finish ();
15734 }
15735 return (ffelexHandler) ffesta_zero (t);
15736
15737 default:
15738 break;
15739 }
15740
15741 ffestb_subr_kill_read_ ();
15742 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15743 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15744 }
15745
15746 /* ffestb_R90915_ -- "READ(...)" expr COMMA expr
15747
15748 (ffestb_R90915_) // to expression handler
15749
15750 Handle COMMA or EOS/SEMICOLON here. */
15751
15752 static ffelexHandler
15753 ffestb_R90915_ (ffelexToken ft, ffebld expr, ffelexToken t)
15754 {
15755 switch (ffelex_token_type (t))
15756 {
15757 case FFELEX_typeCOMMA:
15758 if (expr == NULL)
15759 break;
15760 if (!ffesta_is_inhibited ())
15761 ffestc_R909_item (expr, ft);
15762 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
15763 ffestc_context_iolist (),
15764 (ffeexprCallback) ffestb_R90915_);
15765
15766 case FFELEX_typeEOS:
15767 case FFELEX_typeSEMICOLON:
15768 if (expr == NULL)
15769 break;
15770 if (!ffesta_is_inhibited ())
15771 {
15772 ffestc_R909_item (expr, ft);
15773 ffestc_R909_finish ();
15774 }
15775 return (ffelexHandler) ffesta_zero (t);
15776
15777 default:
15778 break;
15779 }
15780
15781 if (!ffesta_is_inhibited ())
15782 ffestc_R909_finish ();
15783 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15784 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15785 }
15786
15787 /* ffestb_R910 -- Parse the WRITE statement
15788
15789 return ffestb_R910; // to lexer
15790
15791 Make sure the statement has a valid form for the WRITE
15792 statement. If it does, implement the statement. */
15793
15794 ffelexHandler
15795 ffestb_R910 (ffelexToken t)
15796 {
15797 ffestpWriteIx ix;
15798
15799 switch (ffelex_token_type (ffesta_tokens[0]))
15800 {
15801 case FFELEX_typeNAME:
15802 if (ffesta_first_kw != FFESTR_firstWRITE)
15803 goto bad_0; /* :::::::::::::::::::: */
15804 switch (ffelex_token_type (t))
15805 {
15806 case FFELEX_typeCOMMA:
15807 case FFELEX_typeCOLONCOLON:
15808 case FFELEX_typeEOS:
15809 case FFELEX_typeSEMICOLON:
15810 case FFELEX_typeNAME:
15811 case FFELEX_typeNUMBER:
15812 ffesta_confirmed (); /* Error, but clearly intended. */
15813 goto bad_1; /* :::::::::::::::::::: */
15814
15815 default:
15816 goto bad_1; /* :::::::::::::::::::: */
15817
15818 case FFELEX_typeOPEN_PAREN:
15819 for (ix = 0; ix < FFESTP_writeix; ++ix)
15820 ffestp_file.write.write_spec[ix].kw_or_val_present = FALSE;
15821 return (ffelexHandler) ffestb_R9101_;
15822 }
15823
15824 case FFELEX_typeNAMES:
15825 if (ffesta_first_kw != FFESTR_firstWRITE)
15826 goto bad_0; /* :::::::::::::::::::: */
15827 switch (ffelex_token_type (t))
15828 {
15829 case FFELEX_typeEOS:
15830 case FFELEX_typeSEMICOLON:
15831 case FFELEX_typeCOMMA:
15832 case FFELEX_typeCOLONCOLON:
15833 ffesta_confirmed (); /* Error, but clearly intended. */
15834 goto bad_1; /* :::::::::::::::::::: */
15835
15836 default:
15837 goto bad_1; /* :::::::::::::::::::: */
15838
15839 case FFELEX_typeOPEN_PAREN:
15840 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlWRITE)
15841 goto bad_0; /* :::::::::::::::::::: */
15842
15843 for (ix = 0; ix < FFESTP_writeix; ++ix)
15844 ffestp_file.write.write_spec[ix].kw_or_val_present = FALSE;
15845 return (ffelexHandler) ffestb_R9101_;
15846 }
15847
15848 default:
15849 goto bad_0; /* :::::::::::::::::::: */
15850 }
15851
15852 bad_0: /* :::::::::::::::::::: */
15853 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", ffesta_tokens[0]);
15854 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15855
15856 bad_1: /* :::::::::::::::::::: */
15857 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
15858 return (ffelexHandler) ffelex_swallow_tokens (t,
15859 (ffelexHandler) ffesta_zero); /* Invalid second token. */
15860 }
15861
15862 /* ffestb_R9101_ -- "WRITE" OPEN_PAREN
15863
15864 return ffestb_R9101_; // to lexer
15865
15866 Handle expr construct (not NAME=expr construct) here. */
15867
15868 static ffelexHandler
15869 ffestb_R9101_ (ffelexToken t)
15870 {
15871 switch (ffelex_token_type (t))
15872 {
15873 case FFELEX_typeNAME:
15874 ffesta_tokens[1] = ffelex_token_use (t);
15875 return (ffelexHandler) ffestb_R9102_;
15876
15877 default:
15878 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15879 FFEEXPR_contextFILEUNIT, (ffeexprCallback) ffestb_R9103_)))
15880 (t);
15881 }
15882 }
15883
15884 /* ffestb_R9102_ -- "WRITE" OPEN_PAREN NAME
15885
15886 return ffestb_R9102_; // to lexer
15887
15888 If EQUALS here, go to states that handle it. Else, send NAME and this
15889 token thru expression handler. */
15890
15891 static ffelexHandler
15892 ffestb_R9102_ (ffelexToken t)
15893 {
15894 ffelexHandler next;
15895 ffelexToken nt;
15896
15897 switch (ffelex_token_type (t))
15898 {
15899 case FFELEX_typeEQUALS:
15900 nt = ffesta_tokens[1];
15901 next = (ffelexHandler) ffestb_R9107_ (nt);
15902 ffelex_token_kill (nt);
15903 return (ffelexHandler) (*next) (t);
15904
15905 default:
15906 nt = ffesta_tokens[1];
15907 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15908 FFEEXPR_contextFILEUNIT, (ffeexprCallback) ffestb_R9103_)))
15909 (nt);
15910 ffelex_token_kill (nt);
15911 return (ffelexHandler) (*next) (t);
15912 }
15913 }
15914
15915 /* ffestb_R9103_ -- "WRITE" OPEN_PAREN expr [CLOSE_PAREN]
15916
15917 (ffestb_R9103_) // to expression handler
15918
15919 Handle COMMA or EOS/SEMICOLON here. */
15920
15921 static ffelexHandler
15922 ffestb_R9103_ (ffelexToken ft, ffebld expr, ffelexToken t)
15923 {
15924 switch (ffelex_token_type (t))
15925 {
15926 case FFELEX_typeCOMMA:
15927 case FFELEX_typeCLOSE_PAREN:
15928 if (expr == NULL)
15929 break;
15930 ffestp_file.write.write_spec[FFESTP_writeixUNIT].kw_or_val_present
15931 = TRUE;
15932 ffestp_file.write.write_spec[FFESTP_writeixUNIT].kw_present = FALSE;
15933 ffestp_file.write.write_spec[FFESTP_writeixUNIT].value_present = TRUE;
15934 ffestp_file.write.write_spec[FFESTP_writeixUNIT].value_is_label
15935 = FALSE;
15936 ffestp_file.write.write_spec[FFESTP_writeixUNIT].value
15937 = ffelex_token_use (ft);
15938 ffestp_file.write.write_spec[FFESTP_writeixUNIT].u.expr = expr;
15939 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15940 return (ffelexHandler) ffestb_R9104_;
15941 return (ffelexHandler) ffestb_R91012_;
15942
15943 default:
15944 break;
15945 }
15946
15947 ffestb_subr_kill_write_ ();
15948 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
15949 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15950 }
15951
15952 /* ffestb_R9104_ -- "WRITE" OPEN_PAREN expr COMMA
15953
15954 return ffestb_R9104_; // to lexer
15955
15956 Handle expr construct (not NAME=expr construct) here. */
15957
15958 static ffelexHandler
15959 ffestb_R9104_ (ffelexToken t)
15960 {
15961 switch (ffelex_token_type (t))
15962 {
15963 case FFELEX_typeNAME:
15964 ffesta_tokens[1] = ffelex_token_use (t);
15965 return (ffelexHandler) ffestb_R9105_;
15966
15967 default:
15968 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15969 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9106_)))
15970 (t);
15971 }
15972 }
15973
15974 /* ffestb_R9105_ -- "WRITE" OPEN_PAREN expr COMMA NAME
15975
15976 return ffestb_R9105_; // to lexer
15977
15978 If EQUALS here, go to states that handle it. Else, send NAME and this
15979 token thru expression handler. */
15980
15981 static ffelexHandler
15982 ffestb_R9105_ (ffelexToken t)
15983 {
15984 ffelexHandler next;
15985 ffelexToken nt;
15986
15987 switch (ffelex_token_type (t))
15988 {
15989 case FFELEX_typeEQUALS:
15990 nt = ffesta_tokens[1];
15991 next = (ffelexHandler) ffestb_R9107_ (nt);
15992 ffelex_token_kill (nt);
15993 return (ffelexHandler) (*next) (t);
15994
15995 default:
15996 nt = ffesta_tokens[1];
15997 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15998 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9106_)))
15999 (nt);
16000 ffelex_token_kill (nt);
16001 return (ffelexHandler) (*next) (t);
16002 }
16003 }
16004
16005 /* ffestb_R9106_ -- "WRITE" OPEN_PAREN expr COMMA expr
16006
16007 (ffestb_R9106_) // to expression handler
16008
16009 Handle COMMA or CLOSE_PAREN here. */
16010
16011 static ffelexHandler
16012 ffestb_R9106_ (ffelexToken ft, ffebld expr, ffelexToken t)
16013 {
16014 switch (ffelex_token_type (t))
16015 {
16016 case FFELEX_typeCOMMA:
16017 case FFELEX_typeCLOSE_PAREN:
16018 ffestp_file.write.write_spec[FFESTP_writeixFORMAT].kw_or_val_present
16019 = TRUE;
16020 ffestp_file.write.write_spec[FFESTP_writeixFORMAT].kw_present = FALSE;
16021 ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value_present = TRUE;
16022 ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value_is_label
16023 = (expr == NULL);
16024 ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value
16025 = ffelex_token_use (ft);
16026 ffestp_file.write.write_spec[FFESTP_writeixFORMAT].u.expr = expr;
16027 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16028 return (ffelexHandler) ffestb_R9107_;
16029 return (ffelexHandler) ffestb_R91012_;
16030
16031 default:
16032 break;
16033 }
16034
16035 ffestb_subr_kill_write_ ();
16036 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16037 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16038 }
16039
16040 /* ffestb_R9107_ -- "WRITE" OPEN_PAREN [external-file-unit COMMA [format
16041 COMMA]]
16042
16043 return ffestb_R9107_; // to lexer
16044
16045 Handle expr construct (not NAME=expr construct) here. */
16046
16047 static ffelexHandler
16048 ffestb_R9107_ (ffelexToken t)
16049 {
16050 ffestrGenio kw;
16051
16052 ffestb_local_.write.label = FALSE;
16053
16054 switch (ffelex_token_type (t))
16055 {
16056 case FFELEX_typeNAME:
16057 kw = ffestr_genio (t);
16058 switch (kw)
16059 {
16060 case FFESTR_genioADVANCE:
16061 ffestb_local_.write.ix = FFESTP_writeixADVANCE;
16062 ffestb_local_.write.left = FALSE;
16063 ffestb_local_.write.context = FFEEXPR_contextFILEDFCHAR;
16064 break;
16065
16066 case FFESTR_genioEOR:
16067 ffestb_local_.write.ix = FFESTP_writeixEOR;
16068 ffestb_local_.write.label = TRUE;
16069 break;
16070
16071 case FFESTR_genioERR:
16072 ffestb_local_.write.ix = FFESTP_writeixERR;
16073 ffestb_local_.write.label = TRUE;
16074 break;
16075
16076 case FFESTR_genioFMT:
16077 ffestb_local_.write.ix = FFESTP_writeixFORMAT;
16078 ffestb_local_.write.left = FALSE;
16079 ffestb_local_.write.context = FFEEXPR_contextFILEFORMAT;
16080 break;
16081
16082 case FFESTR_genioIOSTAT:
16083 ffestb_local_.write.ix = FFESTP_writeixIOSTAT;
16084 ffestb_local_.write.left = TRUE;
16085 ffestb_local_.write.context = FFEEXPR_contextFILEINT;
16086 break;
16087
16088 case FFESTR_genioNML:
16089 ffestb_local_.write.ix = FFESTP_writeixFORMAT;
16090 ffestb_local_.write.left = TRUE;
16091 ffestb_local_.write.context = FFEEXPR_contextFILENAMELIST;
16092 break;
16093
16094 case FFESTR_genioREC:
16095 ffestb_local_.write.ix = FFESTP_writeixREC;
16096 ffestb_local_.write.left = FALSE;
16097 ffestb_local_.write.context = FFEEXPR_contextFILENUM;
16098 break;
16099
16100 case FFESTR_genioUNIT:
16101 ffestb_local_.write.ix = FFESTP_writeixUNIT;
16102 ffestb_local_.write.left = FALSE;
16103 ffestb_local_.write.context = FFEEXPR_contextFILEUNIT;
16104 break;
16105
16106 default:
16107 goto bad; /* :::::::::::::::::::: */
16108 }
16109 if (ffestp_file.write.write_spec[ffestb_local_.write.ix]
16110 .kw_or_val_present)
16111 break; /* Can't specify a keyword twice! */
16112 ffestp_file.write.write_spec[ffestb_local_.write.ix]
16113 .kw_or_val_present = TRUE;
16114 ffestp_file.write.write_spec[ffestb_local_.write.ix]
16115 .kw_present = TRUE;
16116 ffestp_file.write.write_spec[ffestb_local_.write.ix]
16117 .value_present = FALSE;
16118 ffestp_file.write.write_spec[ffestb_local_.write.ix].value_is_label
16119 = ffestb_local_.write.label;
16120 ffestp_file.write.write_spec[ffestb_local_.write.ix].kw
16121 = ffelex_token_use (t);
16122 return (ffelexHandler) ffestb_R9108_;
16123
16124 default:
16125 break;
16126 }
16127
16128 bad: /* :::::::::::::::::::: */
16129 ffestb_subr_kill_write_ ();
16130 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16131 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16132 }
16133
16134 /* ffestb_R9108_ -- "WRITE" OPEN_PAREN [external-file-unit COMMA [format
16135 COMMA]] NAME
16136
16137 return ffestb_R9108_; // to lexer
16138
16139 Make sure EQUALS here, send next token to expression handler. */
16140
16141 static ffelexHandler
16142 ffestb_R9108_ (ffelexToken t)
16143 {
16144 switch (ffelex_token_type (t))
16145 {
16146 case FFELEX_typeEQUALS:
16147 ffesta_confirmed ();
16148 if (ffestb_local_.write.label)
16149 return (ffelexHandler) ffestb_R91010_;
16150 if (ffestb_local_.write.left)
16151 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
16152 ffestb_local_.write.context,
16153 (ffeexprCallback) ffestb_R9109_);
16154 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16155 ffestb_local_.write.context,
16156 (ffeexprCallback) ffestb_R9109_);
16157
16158 default:
16159 break;
16160 }
16161
16162 ffestb_subr_kill_write_ ();
16163 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16164 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16165 }
16166
16167 /* ffestb_R9109_ -- "WRITE" OPEN_PAREN ... NAME EQUALS expr
16168
16169 (ffestb_R9109_) // to expression handler
16170
16171 Handle COMMA or CLOSE_PAREN here. */
16172
16173 static ffelexHandler
16174 ffestb_R9109_ (ffelexToken ft, ffebld expr, ffelexToken t)
16175 {
16176 switch (ffelex_token_type (t))
16177 {
16178 case FFELEX_typeCOMMA:
16179 case FFELEX_typeCLOSE_PAREN:
16180 if (expr == NULL)
16181 {
16182 if (ffestb_local_.write.context == FFEEXPR_contextFILEFORMAT)
16183 ffestp_file.write.write_spec[ffestb_local_.write.ix]
16184 .value_is_label = TRUE;
16185 else
16186 break;
16187 }
16188 ffestp_file.write.write_spec[ffestb_local_.write.ix].value_present
16189 = TRUE;
16190 ffestp_file.write.write_spec[ffestb_local_.write.ix].value
16191 = ffelex_token_use (ft);
16192 ffestp_file.write.write_spec[ffestb_local_.write.ix].u.expr = expr;
16193 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16194 return (ffelexHandler) ffestb_R9107_;
16195 return (ffelexHandler) ffestb_R91012_;
16196
16197 default:
16198 break;
16199 }
16200
16201 ffestb_subr_kill_write_ ();
16202 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16203 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16204 }
16205
16206 /* ffestb_R91010_ -- "WRITE" OPEN_PAREN ... NAME EQUALS
16207
16208 return ffestb_R91010_; // to lexer
16209
16210 Handle NUMBER for label here. */
16211
16212 static ffelexHandler
16213 ffestb_R91010_ (ffelexToken t)
16214 {
16215 switch (ffelex_token_type (t))
16216 {
16217 case FFELEX_typeNUMBER:
16218 ffestp_file.write.write_spec[ffestb_local_.write.ix].value_present
16219 = TRUE;
16220 ffestp_file.write.write_spec[ffestb_local_.write.ix].value
16221 = ffelex_token_use (t);
16222 return (ffelexHandler) ffestb_R91011_;
16223
16224 default:
16225 break;
16226 }
16227
16228 ffestb_subr_kill_write_ ();
16229 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16230 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16231 }
16232
16233 /* ffestb_R91011_ -- "WRITE" OPEN_PAREN ... NAME EQUALS NUMBER
16234
16235 return ffestb_R91011_; // to lexer
16236
16237 Handle COMMA or CLOSE_PAREN here. */
16238
16239 static ffelexHandler
16240 ffestb_R91011_ (ffelexToken t)
16241 {
16242 switch (ffelex_token_type (t))
16243 {
16244 case FFELEX_typeCOMMA:
16245 return (ffelexHandler) ffestb_R9107_;
16246
16247 case FFELEX_typeCLOSE_PAREN:
16248 return (ffelexHandler) ffestb_R91012_;
16249
16250 default:
16251 break;
16252 }
16253
16254 ffestb_subr_kill_write_ ();
16255 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16256 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16257 }
16258
16259 /* ffestb_R91012_ -- "WRITE" OPEN_PAREN ... CLOSE_PAREN
16260
16261 return ffestb_R91012_; // to lexer
16262
16263 Handle EOS or SEMICOLON here. */
16264
16265 static ffelexHandler
16266 ffestb_R91012_ (ffelexToken t)
16267 {
16268 switch (ffelex_token_type (t))
16269 {
16270 case FFELEX_typeEOS:
16271 case FFELEX_typeSEMICOLON:
16272 ffesta_confirmed ();
16273 if (!ffesta_is_inhibited ())
16274 {
16275 ffestc_R910_start ();
16276 ffestc_R910_finish ();
16277 }
16278 ffestb_subr_kill_write_ ();
16279 return (ffelexHandler) ffesta_zero (t);
16280
16281 default:
16282 ffesta_confirmed ();
16283 /* Fall through. */
16284 case FFELEX_typeOPEN_PAREN: /* Could still be assignment!! */
16285
16286 /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
16287 (f2c provides this extension, as do other compilers, supposedly.) */
16288
16289 if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
16290 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16291 ffestc_context_iolist (), (ffeexprCallback) ffestb_R91013_);
16292
16293 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16294 ffestc_context_iolist (), (ffeexprCallback) ffestb_R91013_)))
16295 (t);
16296
16297 case FFELEX_typeEQUALS:
16298 case FFELEX_typePOINTS:
16299 break;
16300 }
16301
16302 ffestb_subr_kill_write_ ();
16303 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16304 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16305 }
16306
16307 /* ffestb_R91013_ -- "WRITE(...)" expr
16308
16309 (ffestb_R91013_) // to expression handler
16310
16311 Handle COMMA or EOS/SEMICOLON here. */
16312
16313 static ffelexHandler
16314 ffestb_R91013_ (ffelexToken ft, ffebld expr, ffelexToken t)
16315 {
16316 switch (ffelex_token_type (t))
16317 {
16318 case FFELEX_typeCOMMA:
16319 if (expr == NULL)
16320 break;
16321
16322 ffesta_confirmed ();
16323 if (!ffesta_is_inhibited ())
16324 ffestc_R910_start ();
16325 ffestb_subr_kill_write_ ();
16326
16327 if (!ffesta_is_inhibited ())
16328 ffestc_R910_item (expr, ft);
16329 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16330 ffestc_context_iolist (), (ffeexprCallback) ffestb_R91014_);
16331
16332 case FFELEX_typeEOS:
16333 case FFELEX_typeSEMICOLON:
16334 if (expr == NULL)
16335 break;
16336
16337 ffesta_confirmed ();
16338 if (!ffesta_is_inhibited ())
16339 ffestc_R910_start ();
16340 ffestb_subr_kill_write_ ();
16341
16342 if (!ffesta_is_inhibited ())
16343 {
16344 ffestc_R910_item (expr, ft);
16345 ffestc_R910_finish ();
16346 }
16347 return (ffelexHandler) ffesta_zero (t);
16348
16349 default:
16350 break;
16351 }
16352
16353 ffestb_subr_kill_write_ ();
16354 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16355 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16356 }
16357
16358 /* ffestb_R91014_ -- "WRITE(...)" expr COMMA expr
16359
16360 (ffestb_R91014_) // to expression handler
16361
16362 Handle COMMA or EOS/SEMICOLON here. */
16363
16364 static ffelexHandler
16365 ffestb_R91014_ (ffelexToken ft, ffebld expr, ffelexToken t)
16366 {
16367 switch (ffelex_token_type (t))
16368 {
16369 case FFELEX_typeCOMMA:
16370 if (expr == NULL)
16371 break;
16372 if (!ffesta_is_inhibited ())
16373 ffestc_R910_item (expr, ft);
16374 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16375 ffestc_context_iolist (), (ffeexprCallback) ffestb_R91014_);
16376
16377 case FFELEX_typeEOS:
16378 case FFELEX_typeSEMICOLON:
16379 if (expr == NULL)
16380 break;
16381 if (!ffesta_is_inhibited ())
16382 {
16383 ffestc_R910_item (expr, ft);
16384 ffestc_R910_finish ();
16385 }
16386 return (ffelexHandler) ffesta_zero (t);
16387
16388 default:
16389 break;
16390 }
16391
16392 if (!ffesta_is_inhibited ())
16393 ffestc_R910_finish ();
16394 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16395 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16396 }
16397
16398 /* ffestb_R911 -- Parse the PRINT statement
16399
16400 return ffestb_R911; // to lexer
16401
16402 Make sure the statement has a valid form for the PRINT
16403 statement. If it does, implement the statement. */
16404
16405 ffelexHandler
16406 ffestb_R911 (ffelexToken t)
16407 {
16408 ffelexHandler next;
16409 ffestpPrintIx ix;
16410
16411 switch (ffelex_token_type (ffesta_tokens[0]))
16412 {
16413 case FFELEX_typeNAME:
16414 if (ffesta_first_kw != FFESTR_firstPRINT)
16415 goto bad_0; /* :::::::::::::::::::: */
16416 switch (ffelex_token_type (t))
16417 {
16418 case FFELEX_typeCOMMA:
16419 case FFELEX_typeCOLONCOLON:
16420 case FFELEX_typeEOS:
16421 case FFELEX_typeSEMICOLON:
16422 ffesta_confirmed (); /* Error, but clearly intended. */
16423 goto bad_1; /* :::::::::::::::::::: */
16424
16425 case FFELEX_typeEQUALS:
16426 case FFELEX_typePOINTS:
16427 case FFELEX_typeCOLON:
16428 goto bad_1; /* :::::::::::::::::::: */
16429
16430 case FFELEX_typeNAME:
16431 case FFELEX_typeNUMBER:
16432 ffesta_confirmed ();
16433 break;
16434
16435 default:
16436 break;
16437 }
16438
16439 for (ix = 0; ix < FFESTP_printix; ++ix)
16440 ffestp_file.print.print_spec[ix].kw_or_val_present = FALSE;
16441 return (ffelexHandler) (*((ffelexHandler)
16442 ffeexpr_rhs (ffesta_output_pool,
16443 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9111_)))
16444 (t);
16445
16446 case FFELEX_typeNAMES:
16447 if (ffesta_first_kw != FFESTR_firstPRINT)
16448 goto bad_0; /* :::::::::::::::::::: */
16449 switch (ffelex_token_type (t))
16450 {
16451 case FFELEX_typeEOS:
16452 case FFELEX_typeSEMICOLON:
16453 case FFELEX_typeCOMMA:
16454 ffesta_confirmed ();
16455 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlPRINT)
16456 break;
16457 goto bad_1; /* :::::::::::::::::::: */
16458
16459 case FFELEX_typeCOLONCOLON:
16460 ffesta_confirmed (); /* Error, but clearly intended. */
16461 goto bad_1; /* :::::::::::::::::::: */
16462
16463 case FFELEX_typeEQUALS:
16464 case FFELEX_typePOINTS:
16465 case FFELEX_typeCOLON:
16466 goto bad_1; /* :::::::::::::::::::: */
16467
16468 default:
16469 break;
16470 }
16471 for (ix = 0; ix < FFESTP_printix; ++ix)
16472 ffestp_file.print.print_spec[ix].kw_or_val_present = FALSE;
16473 next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16474 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9111_);
16475 next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
16476 FFESTR_firstlPRINT);
16477 if (next == NULL)
16478 return (ffelexHandler) ffelex_swallow_tokens (t,
16479 (ffelexHandler) ffesta_zero);
16480 return (ffelexHandler) (*next) (t);
16481
16482 default:
16483 goto bad_0; /* :::::::::::::::::::: */
16484 }
16485
16486 bad_0: /* :::::::::::::::::::: */
16487 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", ffesta_tokens[0]);
16488 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16489
16490 bad_1: /* :::::::::::::::::::: */
16491 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
16492 return (ffelexHandler) ffelex_swallow_tokens (t,
16493 (ffelexHandler) ffesta_zero); /* Invalid second token. */
16494 }
16495
16496 /* ffestb_R9111_ -- "PRINT" expr
16497
16498 (ffestb_R9111_) // to expression handler
16499
16500 Make sure the next token is a COMMA or EOS/SEMICOLON. */
16501
16502 static ffelexHandler
16503 ffestb_R9111_ (ffelexToken ft, ffebld expr, ffelexToken t)
16504 {
16505 switch (ffelex_token_type (t))
16506 {
16507 case FFELEX_typeEOS:
16508 case FFELEX_typeSEMICOLON:
16509 case FFELEX_typeCOMMA:
16510 ffesta_confirmed ();
16511 ffestp_file.print.print_spec[FFESTP_printixFORMAT].kw_or_val_present
16512 = TRUE;
16513 ffestp_file.print.print_spec[FFESTP_printixFORMAT].kw_present = FALSE;
16514 ffestp_file.print.print_spec[FFESTP_printixFORMAT].value_present = TRUE;
16515 ffestp_file.print.print_spec[FFESTP_printixFORMAT].value_is_label
16516 = (expr == NULL);
16517 ffestp_file.print.print_spec[FFESTP_printixFORMAT].value
16518 = ffelex_token_use (ft);
16519 ffestp_file.print.print_spec[FFESTP_printixFORMAT].u.expr = expr;
16520 if (!ffesta_is_inhibited ())
16521 ffestc_R911_start ();
16522 ffestb_subr_kill_print_ ();
16523 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16524 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16525 FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R9112_);
16526 if (!ffesta_is_inhibited ())
16527 ffestc_R911_finish ();
16528 return (ffelexHandler) ffesta_zero (t);
16529
16530 default:
16531 break;
16532 }
16533
16534 ffestb_subr_kill_print_ ();
16535 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
16536 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16537 }
16538
16539 /* ffestb_R9112_ -- "PRINT" expr COMMA expr
16540
16541 (ffestb_R9112_) // to expression handler
16542
16543 Handle COMMA or EOS/SEMICOLON here. */
16544
16545 static ffelexHandler
16546 ffestb_R9112_ (ffelexToken ft, ffebld expr, ffelexToken t)
16547 {
16548 switch (ffelex_token_type (t))
16549 {
16550 case FFELEX_typeCOMMA:
16551 if (expr == NULL)
16552 break;
16553 if (!ffesta_is_inhibited ())
16554 ffestc_R911_item (expr, ft);
16555 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16556 FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R9112_);
16557
16558 case FFELEX_typeEOS:
16559 case FFELEX_typeSEMICOLON:
16560 if (expr == NULL)
16561 break;
16562 if (!ffesta_is_inhibited ())
16563 {
16564 ffestc_R911_item (expr, ft);
16565 ffestc_R911_finish ();
16566 }
16567 return (ffelexHandler) ffesta_zero (t);
16568
16569 default:
16570 break;
16571 }
16572
16573 if (!ffesta_is_inhibited ())
16574 ffestc_R911_finish ();
16575 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
16576 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16577 }
16578
16579 /* ffestb_R923 -- Parse an INQUIRE statement
16580
16581 return ffestb_R923; // to lexer
16582
16583 Make sure the statement has a valid form for an INQUIRE statement.
16584 If it does, implement the statement. */
16585
16586 ffelexHandler
16587 ffestb_R923 (ffelexToken t)
16588 {
16589 ffestpInquireIx ix;
16590
16591 switch (ffelex_token_type (ffesta_tokens[0]))
16592 {
16593 case FFELEX_typeNAME:
16594 if (ffesta_first_kw != FFESTR_firstINQUIRE)
16595 goto bad_0; /* :::::::::::::::::::: */
16596 break;
16597
16598 case FFELEX_typeNAMES:
16599 if (ffesta_first_kw != FFESTR_firstINQUIRE)
16600 goto bad_0; /* :::::::::::::::::::: */
16601 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlINQUIRE)
16602 goto bad_0; /* :::::::::::::::::::: */
16603 break;
16604
16605 default:
16606 goto bad_0; /* :::::::::::::::::::: */
16607 }
16608
16609 switch (ffelex_token_type (t))
16610 {
16611 case FFELEX_typeOPEN_PAREN:
16612 break;
16613
16614 case FFELEX_typeEOS:
16615 case FFELEX_typeSEMICOLON:
16616 case FFELEX_typeCOMMA:
16617 case FFELEX_typeCOLONCOLON:
16618 ffesta_confirmed (); /* Error, but clearly intended. */
16619 goto bad_1; /* :::::::::::::::::::: */
16620
16621 default:
16622 goto bad_1; /* :::::::::::::::::::: */
16623 }
16624
16625 for (ix = 0; ix < FFESTP_inquireix; ++ix)
16626 ffestp_file.inquire.inquire_spec[ix].kw_or_val_present = FALSE;
16627
16628 ffestb_local_.inquire.may_be_iolength = TRUE;
16629 return (ffelexHandler) ffestb_R9231_;
16630
16631 bad_0: /* :::::::::::::::::::: */
16632 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", ffesta_tokens[0]);
16633 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16634
16635 bad_1: /* :::::::::::::::::::: */
16636 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16637 return (ffelexHandler) ffelex_swallow_tokens (t,
16638 (ffelexHandler) ffesta_zero); /* Invalid second token. */
16639 }
16640
16641 /* ffestb_R9231_ -- "INQUIRE" OPEN_PAREN
16642
16643 return ffestb_R9231_; // to lexer
16644
16645 Handle expr construct (not NAME=expr construct) here. */
16646
16647 static ffelexHandler
16648 ffestb_R9231_ (ffelexToken t)
16649 {
16650 switch (ffelex_token_type (t))
16651 {
16652 case FFELEX_typeNAME:
16653 ffesta_tokens[1] = ffelex_token_use (t);
16654 return (ffelexHandler) ffestb_R9232_;
16655
16656 default:
16657 ffestb_local_.inquire.may_be_iolength = FALSE;
16658 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16659 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9233_)))
16660 (t);
16661 }
16662 }
16663
16664 /* ffestb_R9232_ -- "INQUIRE" OPEN_PAREN NAME
16665
16666 return ffestb_R9232_; // to lexer
16667
16668 If EQUALS here, go to states that handle it. Else, send NAME and this
16669 token thru expression handler. */
16670
16671 static ffelexHandler
16672 ffestb_R9232_ (ffelexToken t)
16673 {
16674 ffelexHandler next;
16675 ffelexToken nt;
16676
16677 switch (ffelex_token_type (t))
16678 {
16679 case FFELEX_typeEQUALS:
16680 nt = ffesta_tokens[1];
16681 next = (ffelexHandler) ffestb_R9234_ (nt);
16682 ffelex_token_kill (nt);
16683 return (ffelexHandler) (*next) (t);
16684
16685 default:
16686 ffestb_local_.inquire.may_be_iolength = FALSE;
16687 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16688 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9233_)))
16689 (ffesta_tokens[1]);
16690 ffelex_token_kill (ffesta_tokens[1]);
16691 return (ffelexHandler) (*next) (t);
16692 }
16693 }
16694
16695 /* ffestb_R9233_ -- "INQUIRE" OPEN_PAREN expr
16696
16697 (ffestb_R9233_) // to expression handler
16698
16699 Handle COMMA or CLOSE_PAREN here. */
16700
16701 static ffelexHandler
16702 ffestb_R9233_ (ffelexToken ft, ffebld expr, ffelexToken t)
16703 {
16704 switch (ffelex_token_type (t))
16705 {
16706 case FFELEX_typeCOMMA:
16707 case FFELEX_typeCLOSE_PAREN:
16708 if (expr == NULL)
16709 break;
16710 ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].kw_or_val_present
16711 = TRUE;
16712 ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].kw_present = FALSE;
16713 ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value_present = TRUE;
16714 ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value_is_label
16715 = FALSE;
16716 ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value
16717 = ffelex_token_use (ft);
16718 ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].u.expr = expr;
16719 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16720 return (ffelexHandler) ffestb_R9234_;
16721 return (ffelexHandler) ffestb_R9239_;
16722
16723 default:
16724 break;
16725 }
16726
16727 ffestb_subr_kill_inquire_ ();
16728 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16729 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16730 }
16731
16732 /* ffestb_R9234_ -- "INQUIRE" OPEN_PAREN [external-file-unit COMMA]
16733
16734 return ffestb_R9234_; // to lexer
16735
16736 Handle expr construct (not NAME=expr construct) here. */
16737
16738 static ffelexHandler
16739 ffestb_R9234_ (ffelexToken t)
16740 {
16741 ffestrInquire kw;
16742
16743 ffestb_local_.inquire.label = FALSE;
16744
16745 switch (ffelex_token_type (t))
16746 {
16747 case FFELEX_typeNAME:
16748 kw = ffestr_inquire (t);
16749 if (kw != FFESTR_inquireIOLENGTH)
16750 ffestb_local_.inquire.may_be_iolength = FALSE;
16751 switch (kw)
16752 {
16753 case FFESTR_inquireACCESS:
16754 ffestb_local_.inquire.ix = FFESTP_inquireixACCESS;
16755 ffestb_local_.inquire.left = TRUE;
16756 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16757 break;
16758
16759 case FFESTR_inquireACTION:
16760 ffestb_local_.inquire.ix = FFESTP_inquireixACTION;
16761 ffestb_local_.inquire.left = TRUE;
16762 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16763 break;
16764
16765 case FFESTR_inquireBLANK:
16766 ffestb_local_.inquire.ix = FFESTP_inquireixBLANK;
16767 ffestb_local_.inquire.left = TRUE;
16768 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16769 break;
16770
16771 case FFESTR_inquireCARRIAGECONTROL:
16772 ffestb_local_.inquire.ix = FFESTP_inquireixCARRIAGECONTROL;
16773 ffestb_local_.inquire.left = TRUE;
16774 ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16775 break;
16776
16777 case FFESTR_inquireDEFAULTFILE:
16778 ffestb_local_.inquire.ix = FFESTP_inquireixDEFAULTFILE;
16779 ffestb_local_.inquire.left = FALSE;
16780 ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16781 break;
16782
16783 case FFESTR_inquireDELIM:
16784 ffestb_local_.inquire.ix = FFESTP_inquireixDELIM;
16785 ffestb_local_.inquire.left = TRUE;
16786 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16787 break;
16788
16789 case FFESTR_inquireDIRECT:
16790 ffestb_local_.inquire.ix = FFESTP_inquireixDIRECT;
16791 ffestb_local_.inquire.left = TRUE;
16792 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16793 break;
16794
16795 case FFESTR_inquireERR:
16796 ffestb_local_.inquire.ix = FFESTP_inquireixERR;
16797 ffestb_local_.inquire.label = TRUE;
16798 break;
16799
16800 case FFESTR_inquireEXIST:
16801 ffestb_local_.inquire.ix = FFESTP_inquireixEXIST;
16802 ffestb_local_.inquire.left = TRUE;
16803 ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
16804 break;
16805
16806 case FFESTR_inquireFILE:
16807 ffestb_local_.inquire.ix = FFESTP_inquireixFILE;
16808 ffestb_local_.inquire.left = FALSE;
16809 ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16810 break;
16811
16812 case FFESTR_inquireFORM:
16813 ffestb_local_.inquire.ix = FFESTP_inquireixFORM;
16814 ffestb_local_.inquire.left = TRUE;
16815 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16816 break;
16817
16818 case FFESTR_inquireFORMATTED:
16819 ffestb_local_.inquire.ix = FFESTP_inquireixFORMATTED;
16820 ffestb_local_.inquire.left = TRUE;
16821 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16822 break;
16823
16824 case FFESTR_inquireIOLENGTH:
16825 if (!ffestb_local_.inquire.may_be_iolength)
16826 goto bad; /* :::::::::::::::::::: */
16827 ffestb_local_.inquire.ix = FFESTP_inquireixIOLENGTH;
16828 ffestb_local_.inquire.left = TRUE;
16829 ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16830 break;
16831
16832 case FFESTR_inquireIOSTAT:
16833 ffestb_local_.inquire.ix = FFESTP_inquireixIOSTAT;
16834 ffestb_local_.inquire.left = TRUE;
16835 ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16836 break;
16837
16838 case FFESTR_inquireKEYED:
16839 ffestb_local_.inquire.ix = FFESTP_inquireixKEYED;
16840 ffestb_local_.inquire.left = TRUE;
16841 ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16842 break;
16843
16844 case FFESTR_inquireNAME:
16845 ffestb_local_.inquire.ix = FFESTP_inquireixNAME;
16846 ffestb_local_.inquire.left = TRUE;
16847 ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16848 break;
16849
16850 case FFESTR_inquireNAMED:
16851 ffestb_local_.inquire.ix = FFESTP_inquireixNAMED;
16852 ffestb_local_.inquire.left = TRUE;
16853 ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
16854 break;
16855
16856 case FFESTR_inquireNEXTREC:
16857 ffestb_local_.inquire.ix = FFESTP_inquireixNEXTREC;
16858 ffestb_local_.inquire.left = TRUE;
16859 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFINT;
16860 break;
16861
16862 case FFESTR_inquireNUMBER:
16863 ffestb_local_.inquire.ix = FFESTP_inquireixNUMBER;
16864 ffestb_local_.inquire.left = TRUE;
16865 ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16866 break;
16867
16868 case FFESTR_inquireOPENED:
16869 ffestb_local_.inquire.ix = FFESTP_inquireixOPENED;
16870 ffestb_local_.inquire.left = TRUE;
16871 ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
16872 break;
16873
16874 case FFESTR_inquireORGANIZATION:
16875 ffestb_local_.inquire.ix = FFESTP_inquireixORGANIZATION;
16876 ffestb_local_.inquire.left = TRUE;
16877 ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16878 break;
16879
16880 case FFESTR_inquirePAD:
16881 ffestb_local_.inquire.ix = FFESTP_inquireixPAD;
16882 ffestb_local_.inquire.left = TRUE;
16883 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16884 break;
16885
16886 case FFESTR_inquirePOSITION:
16887 ffestb_local_.inquire.ix = FFESTP_inquireixPOSITION;
16888 ffestb_local_.inquire.left = TRUE;
16889 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16890 break;
16891
16892 case FFESTR_inquireREAD:
16893 ffestb_local_.inquire.ix = FFESTP_inquireixREAD;
16894 ffestb_local_.inquire.left = TRUE;
16895 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16896 break;
16897
16898 case FFESTR_inquireREADWRITE:
16899 ffestb_local_.inquire.ix = FFESTP_inquireixREADWRITE;
16900 ffestb_local_.inquire.left = TRUE;
16901 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16902 break;
16903
16904 case FFESTR_inquireRECL:
16905 ffestb_local_.inquire.ix = FFESTP_inquireixRECL;
16906 ffestb_local_.inquire.left = TRUE;
16907 ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16908 break;
16909
16910 case FFESTR_inquireRECORDTYPE:
16911 ffestb_local_.inquire.ix = FFESTP_inquireixRECORDTYPE;
16912 ffestb_local_.inquire.left = TRUE;
16913 ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16914 break;
16915
16916 case FFESTR_inquireSEQUENTIAL:
16917 ffestb_local_.inquire.ix = FFESTP_inquireixSEQUENTIAL;
16918 ffestb_local_.inquire.left = TRUE;
16919 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16920 break;
16921
16922 case FFESTR_inquireUNFORMATTED:
16923 ffestb_local_.inquire.ix = FFESTP_inquireixUNFORMATTED;
16924 ffestb_local_.inquire.left = TRUE;
16925 ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16926 break;
16927
16928 case FFESTR_inquireUNIT:
16929 ffestb_local_.inquire.ix = FFESTP_inquireixUNIT;
16930 ffestb_local_.inquire.left = FALSE;
16931 ffestb_local_.inquire.context = FFEEXPR_contextFILENUM;
16932 break;
16933
16934 default:
16935 goto bad; /* :::::::::::::::::::: */
16936 }
16937 if (ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16938 .kw_or_val_present)
16939 break; /* Can't specify a keyword twice! */
16940 ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16941 .kw_or_val_present = TRUE;
16942 ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16943 .kw_present = TRUE;
16944 ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16945 .value_present = FALSE;
16946 ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_is_label
16947 = ffestb_local_.inquire.label;
16948 ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].kw
16949 = ffelex_token_use (t);
16950 return (ffelexHandler) ffestb_R9235_;
16951
16952 default:
16953 break;
16954 }
16955
16956 bad: /* :::::::::::::::::::: */
16957 ffestb_subr_kill_inquire_ ();
16958 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16959 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16960 }
16961
16962 /* ffestb_R9235_ -- "INQUIRE" OPEN_PAREN [external-file-unit COMMA] NAME
16963
16964 return ffestb_R9235_; // to lexer
16965
16966 Make sure EQUALS here, send next token to expression handler. */
16967
16968 static ffelexHandler
16969 ffestb_R9235_ (ffelexToken t)
16970 {
16971 switch (ffelex_token_type (t))
16972 {
16973 case FFELEX_typeEQUALS:
16974 ffesta_confirmed ();
16975 if (ffestb_local_.inquire.label)
16976 return (ffelexHandler) ffestb_R9237_;
16977 if (ffestb_local_.inquire.left)
16978 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
16979 ffestb_local_.inquire.context,
16980 (ffeexprCallback) ffestb_R9236_);
16981 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16982 ffestb_local_.inquire.context,
16983 (ffeexprCallback) ffestb_R9236_);
16984
16985 default:
16986 break;
16987 }
16988
16989 ffestb_subr_kill_inquire_ ();
16990 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16991 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16992 }
16993
16994 /* ffestb_R9236_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS expr
16995
16996 (ffestb_R9236_) // to expression handler
16997
16998 Handle COMMA or CLOSE_PAREN here. */
16999
17000 static ffelexHandler
17001 ffestb_R9236_ (ffelexToken ft, ffebld expr, ffelexToken t)
17002 {
17003 switch (ffelex_token_type (t))
17004 {
17005 case FFELEX_typeCOMMA:
17006 if (ffestb_local_.inquire.ix == FFESTP_inquireixIOLENGTH)
17007 break; /* IOLENGTH=expr must be followed by
17008 CLOSE_PAREN. */
17009 /* Fall through. */
17010 case FFELEX_typeCLOSE_PAREN:
17011 if (expr == NULL)
17012 break;
17013 ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_present
17014 = TRUE;
17015 ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value
17016 = ffelex_token_use (ft);
17017 ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].u.expr = expr;
17018 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17019 return (ffelexHandler) ffestb_R9234_;
17020 if (ffestb_local_.inquire.ix == FFESTP_inquireixIOLENGTH)
17021 return (ffelexHandler) ffestb_R92310_;
17022 return (ffelexHandler) ffestb_R9239_;
17023
17024 default:
17025 break;
17026 }
17027
17028 ffestb_subr_kill_inquire_ ();
17029 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17030 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17031 }
17032
17033 /* ffestb_R9237_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS
17034
17035 return ffestb_R9237_; // to lexer
17036
17037 Handle NUMBER for label here. */
17038
17039 static ffelexHandler
17040 ffestb_R9237_ (ffelexToken t)
17041 {
17042 switch (ffelex_token_type (t))
17043 {
17044 case FFELEX_typeNUMBER:
17045 ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_present
17046 = TRUE;
17047 ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value
17048 = ffelex_token_use (t);
17049 return (ffelexHandler) ffestb_R9238_;
17050
17051 default:
17052 break;
17053 }
17054
17055 ffestb_subr_kill_inquire_ ();
17056 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17057 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17058 }
17059
17060 /* ffestb_R9238_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS NUMBER
17061
17062 return ffestb_R9238_; // to lexer
17063
17064 Handle COMMA or CLOSE_PAREN here. */
17065
17066 static ffelexHandler
17067 ffestb_R9238_ (ffelexToken t)
17068 {
17069 switch (ffelex_token_type (t))
17070 {
17071 case FFELEX_typeCOMMA:
17072 return (ffelexHandler) ffestb_R9234_;
17073
17074 case FFELEX_typeCLOSE_PAREN:
17075 return (ffelexHandler) ffestb_R9239_;
17076
17077 default:
17078 break;
17079 }
17080
17081 ffestb_subr_kill_inquire_ ();
17082 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17083 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17084 }
17085
17086 /* ffestb_R9239_ -- "INQUIRE" OPEN_PAREN ... CLOSE_PAREN
17087
17088 return ffestb_R9239_; // to lexer
17089
17090 Handle EOS or SEMICOLON here. */
17091
17092 static ffelexHandler
17093 ffestb_R9239_ (ffelexToken t)
17094 {
17095 switch (ffelex_token_type (t))
17096 {
17097 case FFELEX_typeEOS:
17098 case FFELEX_typeSEMICOLON:
17099 ffesta_confirmed ();
17100 if (!ffesta_is_inhibited ())
17101 ffestc_R923A ();
17102 ffestb_subr_kill_inquire_ ();
17103 return (ffelexHandler) ffesta_zero (t);
17104
17105 default:
17106 break;
17107 }
17108
17109 ffestb_subr_kill_inquire_ ();
17110 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17111 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17112 }
17113
17114 /* ffestb_R92310_ -- "INQUIRE(IOLENGTH=expr)"
17115
17116 return ffestb_R92310_; // to lexer
17117
17118 Make sure EOS or SEMICOLON not here; begin R923B processing and expect
17119 output IO list. */
17120
17121 static ffelexHandler
17122 ffestb_R92310_ (ffelexToken t)
17123 {
17124 switch (ffelex_token_type (t))
17125 {
17126 case FFELEX_typeEOS:
17127 case FFELEX_typeSEMICOLON:
17128 break;
17129
17130 default:
17131 ffesta_confirmed ();
17132 if (!ffesta_is_inhibited ())
17133 ffestc_R923B_start ();
17134 ffestb_subr_kill_inquire_ ();
17135 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17136 FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R92311_)))
17137 (t);
17138 }
17139
17140 ffestb_subr_kill_inquire_ ();
17141 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17142 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17143 }
17144
17145 /* ffestb_R92311_ -- "INQUIRE(IOLENGTH=expr)" expr
17146
17147 (ffestb_R92311_) // to expression handler
17148
17149 Handle COMMA or EOS/SEMICOLON here. */
17150
17151 static ffelexHandler
17152 ffestb_R92311_ (ffelexToken ft, ffebld expr, ffelexToken t)
17153 {
17154 switch (ffelex_token_type (t))
17155 {
17156 case FFELEX_typeCOMMA:
17157 if (expr == NULL)
17158 break;
17159 if (!ffesta_is_inhibited ())
17160 ffestc_R923B_item (expr, ft);
17161 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17162 FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R92311_);
17163
17164 case FFELEX_typeEOS:
17165 case FFELEX_typeSEMICOLON:
17166 if (expr == NULL)
17167 break;
17168 if (!ffesta_is_inhibited ())
17169 {
17170 ffestc_R923B_item (expr, ft);
17171 ffestc_R923B_finish ();
17172 }
17173 return (ffelexHandler) ffesta_zero (t);
17174
17175 default:
17176 break;
17177 }
17178
17179 if (!ffesta_is_inhibited ())
17180 ffestc_R923B_finish ();
17181 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17182 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17183 }
17184
17185 /* ffestb_V018 -- Parse the REWRITE statement
17186
17187 return ffestb_V018; // to lexer
17188
17189 Make sure the statement has a valid form for the REWRITE
17190 statement. If it does, implement the statement. */
17191
17192 #if FFESTR_VXT
17193 ffelexHandler
17194 ffestb_V018 (ffelexToken t)
17195 {
17196 ffestpRewriteIx ix;
17197
17198 switch (ffelex_token_type (ffesta_tokens[0]))
17199 {
17200 case FFELEX_typeNAME:
17201 if (ffesta_first_kw != FFESTR_firstREWRITE)
17202 goto bad_0; /* :::::::::::::::::::: */
17203 switch (ffelex_token_type (t))
17204 {
17205 case FFELEX_typeCOMMA:
17206 case FFELEX_typeCOLONCOLON:
17207 case FFELEX_typeEOS:
17208 case FFELEX_typeSEMICOLON:
17209 case FFELEX_typeNAME:
17210 case FFELEX_typeNUMBER:
17211 ffesta_confirmed (); /* Error, but clearly intended. */
17212 goto bad_1; /* :::::::::::::::::::: */
17213
17214 default:
17215 goto bad_1; /* :::::::::::::::::::: */
17216
17217 case FFELEX_typeOPEN_PAREN:
17218 for (ix = 0; ix < FFESTP_rewriteix; ++ix)
17219 ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present = FALSE;
17220 return (ffelexHandler) ffestb_V0181_;
17221 }
17222
17223 case FFELEX_typeNAMES:
17224 if (ffesta_first_kw != FFESTR_firstREWRITE)
17225 goto bad_0; /* :::::::::::::::::::: */
17226 switch (ffelex_token_type (t))
17227 {
17228 case FFELEX_typeEOS:
17229 case FFELEX_typeSEMICOLON:
17230 case FFELEX_typeCOMMA:
17231 case FFELEX_typeCOLONCOLON:
17232 ffesta_confirmed (); /* Error, but clearly intended. */
17233 goto bad_1; /* :::::::::::::::::::: */
17234
17235 default:
17236 goto bad_1; /* :::::::::::::::::::: */
17237
17238 case FFELEX_typeOPEN_PAREN:
17239 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREWRITE)
17240 goto bad_0; /* :::::::::::::::::::: */
17241
17242 for (ix = 0; ix < FFESTP_rewriteix; ++ix)
17243 ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present = FALSE;
17244 return (ffelexHandler) ffestb_V0181_;
17245 }
17246
17247 default:
17248 goto bad_0; /* :::::::::::::::::::: */
17249 }
17250
17251 bad_0: /* :::::::::::::::::::: */
17252 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", ffesta_tokens[0]);
17253 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17254
17255 bad_1: /* :::::::::::::::::::: */
17256 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17257 return (ffelexHandler) ffelex_swallow_tokens (t,
17258 (ffelexHandler) ffesta_zero); /* Invalid second token. */
17259 }
17260
17261 /* ffestb_V0181_ -- "REWRITE" OPEN_PAREN
17262
17263 return ffestb_V0181_; // to lexer
17264
17265 Handle expr construct (not NAME=expr construct) here. */
17266
17267 static ffelexHandler
17268 ffestb_V0181_ (ffelexToken t)
17269 {
17270 switch (ffelex_token_type (t))
17271 {
17272 case FFELEX_typeNAME:
17273 ffesta_tokens[1] = ffelex_token_use (t);
17274 return (ffelexHandler) ffestb_V0182_;
17275
17276 default:
17277 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17278 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0183_)))
17279 (t);
17280 }
17281 }
17282
17283 /* ffestb_V0182_ -- "REWRITE" OPEN_PAREN NAME
17284
17285 return ffestb_V0182_; // to lexer
17286
17287 If EQUALS here, go to states that handle it. Else, send NAME and this
17288 token thru expression handler. */
17289
17290 static ffelexHandler
17291 ffestb_V0182_ (ffelexToken t)
17292 {
17293 ffelexHandler next;
17294 ffelexToken nt;
17295
17296 switch (ffelex_token_type (t))
17297 {
17298 case FFELEX_typeEQUALS:
17299 nt = ffesta_tokens[1];
17300 next = (ffelexHandler) ffestb_V0187_ (nt);
17301 ffelex_token_kill (nt);
17302 return (ffelexHandler) (*next) (t);
17303
17304 default:
17305 nt = ffesta_tokens[1];
17306 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17307 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0183_)))
17308 (nt);
17309 ffelex_token_kill (nt);
17310 return (ffelexHandler) (*next) (t);
17311 }
17312 }
17313
17314 /* ffestb_V0183_ -- "REWRITE" OPEN_PAREN expr [CLOSE_PAREN]
17315
17316 (ffestb_V0183_) // to expression handler
17317
17318 Handle COMMA or EOS/SEMICOLON here. */
17319
17320 static ffelexHandler
17321 ffestb_V0183_ (ffelexToken ft, ffebld expr, ffelexToken t)
17322 {
17323 switch (ffelex_token_type (t))
17324 {
17325 case FFELEX_typeCOMMA:
17326 case FFELEX_typeCLOSE_PAREN:
17327 if (expr == NULL)
17328 break;
17329 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].kw_or_val_present
17330 = TRUE;
17331 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].kw_present = FALSE;
17332 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value_present = TRUE;
17333 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value_is_label
17334 = FALSE;
17335 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value
17336 = ffelex_token_use (ft);
17337 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].u.expr = expr;
17338 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17339 return (ffelexHandler) ffestb_V0184_;
17340 return (ffelexHandler) ffestb_V01812_;
17341
17342 default:
17343 break;
17344 }
17345
17346 ffestb_subr_kill_rewrite_ ();
17347 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17348 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17349 }
17350
17351 /* ffestb_V0184_ -- "REWRITE" OPEN_PAREN expr COMMA
17352
17353 return ffestb_V0184_; // to lexer
17354
17355 Handle expr construct (not NAME=expr construct) here. */
17356
17357 static ffelexHandler
17358 ffestb_V0184_ (ffelexToken t)
17359 {
17360 switch (ffelex_token_type (t))
17361 {
17362 case FFELEX_typeNAME:
17363 ffesta_tokens[1] = ffelex_token_use (t);
17364 return (ffelexHandler) ffestb_V0185_;
17365
17366 default:
17367 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17368 FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_V0186_)))
17369 (t);
17370 }
17371 }
17372
17373 /* ffestb_V0185_ -- "REWRITE" OPEN_PAREN expr COMMA NAME
17374
17375 return ffestb_V0185_; // to lexer
17376
17377 If EQUALS here, go to states that handle it. Else, send NAME and this
17378 token thru expression handler. */
17379
17380 static ffelexHandler
17381 ffestb_V0185_ (ffelexToken t)
17382 {
17383 ffelexHandler next;
17384 ffelexToken nt;
17385
17386 switch (ffelex_token_type (t))
17387 {
17388 case FFELEX_typeEQUALS:
17389 nt = ffesta_tokens[1];
17390 next = (ffelexHandler) ffestb_V0187_ (nt);
17391 ffelex_token_kill (nt);
17392 return (ffelexHandler) (*next) (t);
17393
17394 default:
17395 nt = ffesta_tokens[1];
17396 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17397 FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_V0186_)))
17398 (nt);
17399 ffelex_token_kill (nt);
17400 return (ffelexHandler) (*next) (t);
17401 }
17402 }
17403
17404 /* ffestb_V0186_ -- "REWRITE" OPEN_PAREN expr COMMA expr
17405
17406 (ffestb_V0186_) // to expression handler
17407
17408 Handle COMMA or CLOSE_PAREN here. */
17409
17410 static ffelexHandler
17411 ffestb_V0186_ (ffelexToken ft, ffebld expr, ffelexToken t)
17412 {
17413 switch (ffelex_token_type (t))
17414 {
17415 case FFELEX_typeCOMMA:
17416 case FFELEX_typeCLOSE_PAREN:
17417 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].kw_or_val_present
17418 = TRUE;
17419 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].kw_present = FALSE;
17420 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value_present = TRUE;
17421 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value_is_label
17422 = (expr == NULL);
17423 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value
17424 = ffelex_token_use (ft);
17425 ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].u.expr = expr;
17426 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17427 return (ffelexHandler) ffestb_V0187_;
17428 return (ffelexHandler) ffestb_V01812_;
17429
17430 default:
17431 break;
17432 }
17433
17434 ffestb_subr_kill_rewrite_ ();
17435 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17436 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17437 }
17438
17439 /* ffestb_V0187_ -- "REWRITE" OPEN_PAREN [external-file-unit COMMA [format
17440 COMMA]]
17441
17442 return ffestb_V0187_; // to lexer
17443
17444 Handle expr construct (not NAME=expr construct) here. */
17445
17446 static ffelexHandler
17447 ffestb_V0187_ (ffelexToken t)
17448 {
17449 ffestrGenio kw;
17450
17451 ffestb_local_.rewrite.label = FALSE;
17452
17453 switch (ffelex_token_type (t))
17454 {
17455 case FFELEX_typeNAME:
17456 kw = ffestr_genio (t);
17457 switch (kw)
17458 {
17459 case FFESTR_genioERR:
17460 ffestb_local_.rewrite.ix = FFESTP_rewriteixERR;
17461 ffestb_local_.rewrite.label = TRUE;
17462 break;
17463
17464 case FFESTR_genioFMT:
17465 ffestb_local_.rewrite.ix = FFESTP_rewriteixFMT;
17466 ffestb_local_.rewrite.left = FALSE;
17467 ffestb_local_.rewrite.context = FFEEXPR_contextFILEFORMAT;
17468 break;
17469
17470 case FFESTR_genioIOSTAT:
17471 ffestb_local_.rewrite.ix = FFESTP_rewriteixIOSTAT;
17472 ffestb_local_.rewrite.left = TRUE;
17473 ffestb_local_.rewrite.context = FFEEXPR_contextFILEINT;
17474 break;
17475
17476 case FFESTR_genioUNIT:
17477 ffestb_local_.rewrite.ix = FFESTP_rewriteixUNIT;
17478 ffestb_local_.rewrite.left = FALSE;
17479 ffestb_local_.rewrite.context = FFEEXPR_contextFILENUM;
17480 break;
17481
17482 default:
17483 goto bad; /* :::::::::::::::::::: */
17484 }
17485 if (ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17486 .kw_or_val_present)
17487 break; /* Can't specify a keyword twice! */
17488 ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17489 .kw_or_val_present = TRUE;
17490 ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17491 .kw_present = TRUE;
17492 ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17493 .value_present = FALSE;
17494 ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_is_label
17495 = ffestb_local_.rewrite.label;
17496 ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].kw
17497 = ffelex_token_use (t);
17498 return (ffelexHandler) ffestb_V0188_;
17499
17500 default:
17501 break;
17502 }
17503
17504 bad: /* :::::::::::::::::::: */
17505 ffestb_subr_kill_rewrite_ ();
17506 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17507 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17508 }
17509
17510 /* ffestb_V0188_ -- "REWRITE" OPEN_PAREN [external-file-unit COMMA [format
17511 COMMA]] NAME
17512
17513 return ffestb_V0188_; // to lexer
17514
17515 Make sure EQUALS here, send next token to expression handler. */
17516
17517 static ffelexHandler
17518 ffestb_V0188_ (ffelexToken t)
17519 {
17520 switch (ffelex_token_type (t))
17521 {
17522 case FFELEX_typeEQUALS:
17523 ffesta_confirmed ();
17524 if (ffestb_local_.rewrite.label)
17525 return (ffelexHandler) ffestb_V01810_;
17526 if (ffestb_local_.rewrite.left)
17527 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
17528 ffestb_local_.rewrite.context,
17529 (ffeexprCallback) ffestb_V0189_);
17530 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17531 ffestb_local_.rewrite.context,
17532 (ffeexprCallback) ffestb_V0189_);
17533
17534 default:
17535 break;
17536 }
17537
17538 ffestb_subr_kill_rewrite_ ();
17539 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17540 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17541 }
17542
17543 /* ffestb_V0189_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS expr
17544
17545 (ffestb_V0189_) // to expression handler
17546
17547 Handle COMMA or CLOSE_PAREN here. */
17548
17549 static ffelexHandler
17550 ffestb_V0189_ (ffelexToken ft, ffebld expr, ffelexToken t)
17551 {
17552 switch (ffelex_token_type (t))
17553 {
17554 case FFELEX_typeCOMMA:
17555 case FFELEX_typeCLOSE_PAREN:
17556 if (expr == NULL)
17557 if (ffestb_local_.rewrite.context == FFEEXPR_contextFILEFORMAT)
17558 ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17559 .value_is_label = TRUE;
17560 else
17561 break;
17562 ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_present
17563 = TRUE;
17564 ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value
17565 = ffelex_token_use (ft);
17566 ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].u.expr = expr;
17567 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17568 return (ffelexHandler) ffestb_V0187_;
17569 return (ffelexHandler) ffestb_V01812_;
17570
17571 default:
17572 break;
17573 }
17574
17575 ffestb_subr_kill_rewrite_ ();
17576 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17577 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17578 }
17579
17580 /* ffestb_V01810_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS
17581
17582 return ffestb_V01810_; // to lexer
17583
17584 Handle NUMBER for label here. */
17585
17586 static ffelexHandler
17587 ffestb_V01810_ (ffelexToken t)
17588 {
17589 switch (ffelex_token_type (t))
17590 {
17591 case FFELEX_typeNUMBER:
17592 ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_present
17593 = TRUE;
17594 ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value
17595 = ffelex_token_use (t);
17596 return (ffelexHandler) ffestb_V01811_;
17597
17598 default:
17599 break;
17600 }
17601
17602 ffestb_subr_kill_rewrite_ ();
17603 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17604 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17605 }
17606
17607 /* ffestb_V01811_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS NUMBER
17608
17609 return ffestb_V01811_; // to lexer
17610
17611 Handle COMMA or CLOSE_PAREN here. */
17612
17613 static ffelexHandler
17614 ffestb_V01811_ (ffelexToken t)
17615 {
17616 switch (ffelex_token_type (t))
17617 {
17618 case FFELEX_typeCOMMA:
17619 return (ffelexHandler) ffestb_V0187_;
17620
17621 case FFELEX_typeCLOSE_PAREN:
17622 return (ffelexHandler) ffestb_V01812_;
17623
17624 default:
17625 break;
17626 }
17627
17628 ffestb_subr_kill_rewrite_ ();
17629 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17630 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17631 }
17632
17633 /* ffestb_V01812_ -- "REWRITE" OPEN_PAREN ... CLOSE_PAREN
17634
17635 return ffestb_V01812_; // to lexer
17636
17637 Handle EOS or SEMICOLON here. */
17638
17639 static ffelexHandler
17640 ffestb_V01812_ (ffelexToken t)
17641 {
17642 switch (ffelex_token_type (t))
17643 {
17644 case FFELEX_typeEOS:
17645 case FFELEX_typeSEMICOLON:
17646 ffesta_confirmed ();
17647 if (!ffesta_is_inhibited ())
17648 {
17649 ffestc_V018_start ();
17650 ffestc_V018_finish ();
17651 }
17652 ffestb_subr_kill_rewrite_ ();
17653 return (ffelexHandler) ffesta_zero (t);
17654
17655 case FFELEX_typeNAME:
17656 case FFELEX_typeOPEN_PAREN:
17657 case FFELEX_typeCOMMA:
17658 ffesta_confirmed ();
17659 if (!ffesta_is_inhibited ())
17660 ffestc_V018_start ();
17661 ffestb_subr_kill_rewrite_ ();
17662
17663 /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
17664 (f2c provides this extension, as do other compilers, supposedly.) */
17665
17666 if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
17667 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17668 FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_);
17669
17670 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17671 FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_)))
17672 (t);
17673
17674 default:
17675 break;
17676 }
17677
17678 ffestb_subr_kill_rewrite_ ();
17679 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17680 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17681 }
17682
17683 /* ffestb_V01813_ -- "REWRITE(...)" expr
17684
17685 (ffestb_V01813_) // to expression handler
17686
17687 Handle COMMA or EOS/SEMICOLON here. */
17688
17689 static ffelexHandler
17690 ffestb_V01813_ (ffelexToken ft, ffebld expr, ffelexToken t)
17691 {
17692 switch (ffelex_token_type (t))
17693 {
17694 case FFELEX_typeCOMMA:
17695 if (expr == NULL)
17696 break;
17697 if (!ffesta_is_inhibited ())
17698 ffestc_V018_item (expr, ft);
17699 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17700 FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_);
17701
17702 case FFELEX_typeEOS:
17703 case FFELEX_typeSEMICOLON:
17704 if (expr == NULL)
17705 break;
17706 if (!ffesta_is_inhibited ())
17707 {
17708 ffestc_V018_item (expr, ft);
17709 ffestc_V018_finish ();
17710 }
17711 return (ffelexHandler) ffesta_zero (t);
17712
17713 default:
17714 break;
17715 }
17716
17717 if (!ffesta_is_inhibited ())
17718 ffestc_V018_finish ();
17719 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17720 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17721 }
17722
17723 /* ffestb_V019 -- Parse the ACCEPT statement
17724
17725 return ffestb_V019; // to lexer
17726
17727 Make sure the statement has a valid form for the ACCEPT
17728 statement. If it does, implement the statement. */
17729
17730 ffelexHandler
17731 ffestb_V019 (ffelexToken t)
17732 {
17733 ffelexHandler next;
17734 ffestpAcceptIx ix;
17735
17736 switch (ffelex_token_type (ffesta_tokens[0]))
17737 {
17738 case FFELEX_typeNAME:
17739 if (ffesta_first_kw != FFESTR_firstACCEPT)
17740 goto bad_0; /* :::::::::::::::::::: */
17741 switch (ffelex_token_type (t))
17742 {
17743 case FFELEX_typeCOMMA:
17744 case FFELEX_typeCOLONCOLON:
17745 case FFELEX_typeEOS:
17746 case FFELEX_typeSEMICOLON:
17747 ffesta_confirmed (); /* Error, but clearly intended. */
17748 goto bad_1; /* :::::::::::::::::::: */
17749
17750 case FFELEX_typeEQUALS:
17751 case FFELEX_typePOINTS:
17752 case FFELEX_typeCOLON:
17753 goto bad_1; /* :::::::::::::::::::: */
17754
17755 case FFELEX_typeNAME:
17756 case FFELEX_typeNUMBER:
17757 ffesta_confirmed ();
17758 break;
17759
17760 default:
17761 break;
17762 }
17763
17764 for (ix = 0; ix < FFESTP_acceptix; ++ix)
17765 ffestp_file.accept.accept_spec[ix].kw_or_val_present = FALSE;
17766 return (ffelexHandler) (*((ffelexHandler)
17767 ffeexpr_rhs (ffesta_output_pool,
17768 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0191_)))
17769 (t);
17770
17771 case FFELEX_typeNAMES:
17772 if (ffesta_first_kw != FFESTR_firstACCEPT)
17773 goto bad_0; /* :::::::::::::::::::: */
17774 switch (ffelex_token_type (t))
17775 {
17776 case FFELEX_typeEOS:
17777 case FFELEX_typeSEMICOLON:
17778 case FFELEX_typeCOMMA:
17779 ffesta_confirmed ();
17780 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlACCEPT)
17781 break;
17782 goto bad_1; /* :::::::::::::::::::: */
17783
17784 case FFELEX_typeCOLONCOLON:
17785 ffesta_confirmed (); /* Error, but clearly intended. */
17786 goto bad_1; /* :::::::::::::::::::: */
17787
17788 case FFELEX_typeEQUALS:
17789 case FFELEX_typePOINTS:
17790 case FFELEX_typeCOLON:
17791 goto bad_1; /* :::::::::::::::::::: */
17792
17793 default:
17794 break;
17795 }
17796 for (ix = 0; ix < FFESTP_acceptix; ++ix)
17797 ffestp_file.accept.accept_spec[ix].kw_or_val_present = FALSE;
17798 next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17799 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0191_);
17800 next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
17801 FFESTR_firstlACCEPT);
17802 if (next == NULL)
17803 return (ffelexHandler) ffelex_swallow_tokens (t,
17804 (ffelexHandler) ffesta_zero);
17805 return (ffelexHandler) (*next) (t);
17806
17807 default:
17808 goto bad_0; /* :::::::::::::::::::: */
17809 }
17810
17811 bad_0: /* :::::::::::::::::::: */
17812 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", ffesta_tokens[0]);
17813 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17814
17815 bad_1: /* :::::::::::::::::::: */
17816 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
17817 return (ffelexHandler) ffelex_swallow_tokens (t,
17818 (ffelexHandler) ffesta_zero); /* Invalid second token. */
17819 }
17820
17821 /* ffestb_V0191_ -- "ACCEPT" expr
17822
17823 (ffestb_V0191_) // to expression handler
17824
17825 Make sure the next token is a COMMA or EOS/SEMICOLON. */
17826
17827 static ffelexHandler
17828 ffestb_V0191_ (ffelexToken ft, ffebld expr, ffelexToken t)
17829 {
17830 switch (ffelex_token_type (t))
17831 {
17832 case FFELEX_typeEOS:
17833 case FFELEX_typeSEMICOLON:
17834 case FFELEX_typeCOMMA:
17835 ffesta_confirmed ();
17836 ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].kw_or_val_present
17837 = TRUE;
17838 ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].kw_present = FALSE;
17839 ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value_present = TRUE;
17840 ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value_is_label
17841 = (expr == NULL);
17842 ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value
17843 = ffelex_token_use (ft);
17844 ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].u.expr = expr;
17845 if (!ffesta_is_inhibited ())
17846 ffestc_V019_start ();
17847 ffestb_subr_kill_accept_ ();
17848 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17849 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
17850 FFEEXPR_contextIOLIST,
17851 (ffeexprCallback) ffestb_V0192_);
17852 if (!ffesta_is_inhibited ())
17853 ffestc_V019_finish ();
17854 return (ffelexHandler) ffesta_zero (t);
17855
17856 default:
17857 break;
17858 }
17859
17860 ffestb_subr_kill_accept_ ();
17861 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
17862 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17863 }
17864
17865 /* ffestb_V0192_ -- "ACCEPT" expr COMMA expr
17866
17867 (ffestb_V0192_) // to expression handler
17868
17869 Handle COMMA or EOS/SEMICOLON here. */
17870
17871 static ffelexHandler
17872 ffestb_V0192_ (ffelexToken ft, ffebld expr, ffelexToken t)
17873 {
17874 switch (ffelex_token_type (t))
17875 {
17876 case FFELEX_typeCOMMA:
17877 if (expr == NULL)
17878 break;
17879 if (!ffesta_is_inhibited ())
17880 ffestc_V019_item (expr, ft);
17881 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
17882 FFEEXPR_contextIOLIST,
17883 (ffeexprCallback) ffestb_V0192_);
17884
17885 case FFELEX_typeEOS:
17886 case FFELEX_typeSEMICOLON:
17887 if (expr == NULL)
17888 break;
17889 if (!ffesta_is_inhibited ())
17890 {
17891 ffestc_V019_item (expr, ft);
17892 ffestc_V019_finish ();
17893 }
17894 return (ffelexHandler) ffesta_zero (t);
17895
17896 default:
17897 break;
17898 }
17899
17900 if (!ffesta_is_inhibited ())
17901 ffestc_V019_finish ();
17902 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
17903 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17904 }
17905
17906 #endif
17907 /* ffestb_V020 -- Parse the TYPE statement
17908
17909 return ffestb_V020; // to lexer
17910
17911 Make sure the statement has a valid form for the TYPE
17912 statement. If it does, implement the statement. */
17913
17914 ffelexHandler
17915 ffestb_V020 (ffelexToken t)
17916 {
17917 ffeTokenLength i;
17918 const char *p;
17919 ffelexHandler next;
17920 ffestpTypeIx ix;
17921
17922 switch (ffelex_token_type (ffesta_tokens[0]))
17923 {
17924 case FFELEX_typeNAME:
17925 if (ffesta_first_kw != FFESTR_firstTYPE)
17926 goto bad_0; /* :::::::::::::::::::: */
17927 switch (ffelex_token_type (t))
17928 {
17929 case FFELEX_typeCOLONCOLON:
17930 case FFELEX_typeEOS:
17931 case FFELEX_typeSEMICOLON:
17932 ffesta_confirmed (); /* Error, but clearly intended. */
17933 goto bad_1; /* :::::::::::::::::::: */
17934
17935 case FFELEX_typeEQUALS:
17936 case FFELEX_typePOINTS:
17937 case FFELEX_typeCOLON:
17938 case FFELEX_typeCOMMA: /* Because "TYPE,PUBLIC::A" is ambiguous with
17939 '90. */
17940 goto bad_1; /* :::::::::::::::::::: */
17941
17942 case FFELEX_typeNUMBER:
17943 ffesta_confirmed ();
17944 break;
17945
17946 case FFELEX_typeNAME: /* Because TYPE A is ambiguous with '90. */
17947 default:
17948 break;
17949 }
17950
17951 for (ix = 0; ix < FFESTP_typeix; ++ix)
17952 ffestp_file.type.type_spec[ix].kw_or_val_present = FALSE;
17953 return (ffelexHandler) (*((ffelexHandler)
17954 ffeexpr_rhs (ffesta_output_pool,
17955 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0201_)))
17956 (t);
17957
17958 case FFELEX_typeNAMES:
17959 if (ffesta_first_kw != FFESTR_firstTYPE)
17960 goto bad_0; /* :::::::::::::::::::: */
17961 switch (ffelex_token_type (t))
17962 {
17963 case FFELEX_typeEOS:
17964 case FFELEX_typeSEMICOLON:
17965 case FFELEX_typeCOMMA:
17966 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlTYPE)
17967 break;
17968 goto bad_1; /* :::::::::::::::::::: */
17969
17970 case FFELEX_typeCOLONCOLON:
17971 ffesta_confirmed (); /* Error, but clearly intended. */
17972 goto bad_1; /* :::::::::::::::::::: */
17973
17974 case FFELEX_typeOPEN_PAREN:
17975 if (ffelex_token_length (ffesta_tokens[0]) == FFESTR_firstlTYPE)
17976 break; /* Else might be assignment/stmtfuncdef. */
17977 goto bad_1; /* :::::::::::::::::::: */
17978
17979 case FFELEX_typeEQUALS:
17980 case FFELEX_typePOINTS:
17981 case FFELEX_typeCOLON:
17982 goto bad_1; /* :::::::::::::::::::: */
17983
17984 default:
17985 break;
17986 }
17987 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlTYPE);
17988 if (ISDIGIT (*p))
17989 ffesta_confirmed (); /* Else might be '90 TYPE statement. */
17990 for (ix = 0; ix < FFESTP_typeix; ++ix)
17991 ffestp_file.type.type_spec[ix].kw_or_val_present = FALSE;
17992 next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17993 FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0201_);
17994 next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
17995 FFESTR_firstlTYPE);
17996 if (next == NULL)
17997 return (ffelexHandler) ffelex_swallow_tokens (t,
17998 (ffelexHandler) ffesta_zero);
17999 return (ffelexHandler) (*next) (t);
18000
18001 default:
18002 goto bad_0; /* :::::::::::::::::::: */
18003 }
18004
18005 bad_0: /* :::::::::::::::::::: */
18006 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", ffesta_tokens[0]);
18007 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18008
18009 bad_1: /* :::::::::::::::::::: */
18010 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
18011 return (ffelexHandler) ffelex_swallow_tokens (t,
18012 (ffelexHandler) ffesta_zero); /* Invalid second token. */
18013 }
18014
18015 /* ffestb_V0201_ -- "TYPE" expr
18016
18017 (ffestb_V0201_) // to expression handler
18018
18019 Make sure the next token is a COMMA or EOS/SEMICOLON. */
18020
18021 static ffelexHandler
18022 ffestb_V0201_ (ffelexToken ft, ffebld expr, ffelexToken t)
18023 {
18024 bool comma = TRUE;
18025
18026 switch (ffelex_token_type (t))
18027 {
18028 case FFELEX_typeEOS:
18029 case FFELEX_typeSEMICOLON:
18030 if (!ffe_is_vxt () && (expr != NULL)
18031 && (ffebld_op (expr) == FFEBLD_opSYMTER))
18032 break;
18033 comma = FALSE;
18034 /* Fall through. */
18035 case FFELEX_typeCOMMA:
18036 if (!ffe_is_vxt () && comma && (expr != NULL)
18037 && (ffebld_op (expr) == FFEBLD_opPAREN)
18038 && (ffebld_op (ffebld_left (expr)) == FFEBLD_opSYMTER))
18039 break;
18040 ffesta_confirmed ();
18041 ffestp_file.type.type_spec[FFESTP_typeixFORMAT].kw_or_val_present
18042 = TRUE;
18043 ffestp_file.type.type_spec[FFESTP_typeixFORMAT].kw_present = FALSE;
18044 ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value_present = TRUE;
18045 ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value_is_label
18046 = (expr == NULL);
18047 ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value
18048 = ffelex_token_use (ft);
18049 ffestp_file.type.type_spec[FFESTP_typeixFORMAT].u.expr = expr;
18050 if (!ffesta_is_inhibited ())
18051 ffestc_V020_start ();
18052 ffestb_subr_kill_type_ ();
18053 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18054 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18055 FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V0202_);
18056 if (!ffesta_is_inhibited ())
18057 ffestc_V020_finish ();
18058 return (ffelexHandler) ffesta_zero (t);
18059
18060 default:
18061 break;
18062 }
18063
18064 ffestb_subr_kill_type_ ();
18065 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
18066 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18067 }
18068
18069 /* ffestb_V0202_ -- "TYPE" expr COMMA expr
18070
18071 (ffestb_V0202_) // to expression handler
18072
18073 Handle COMMA or EOS/SEMICOLON here. */
18074
18075 static ffelexHandler
18076 ffestb_V0202_ (ffelexToken ft, ffebld expr, ffelexToken t)
18077 {
18078 switch (ffelex_token_type (t))
18079 {
18080 case FFELEX_typeCOMMA:
18081 if (expr == NULL)
18082 break;
18083 if (!ffesta_is_inhibited ())
18084 ffestc_V020_item (expr, ft);
18085 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18086 FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V0202_);
18087
18088 case FFELEX_typeEOS:
18089 case FFELEX_typeSEMICOLON:
18090 if (expr == NULL)
18091 break;
18092 if (!ffesta_is_inhibited ())
18093 {
18094 ffestc_V020_item (expr, ft);
18095 ffestc_V020_finish ();
18096 }
18097 return (ffelexHandler) ffesta_zero (t);
18098
18099 default:
18100 break;
18101 }
18102
18103 if (!ffesta_is_inhibited ())
18104 ffestc_V020_finish ();
18105 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
18106 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18107 }
18108
18109 /* ffestb_V021 -- Parse a DELETE statement
18110
18111 return ffestb_V021; // to lexer
18112
18113 Make sure the statement has a valid form for a DELETE statement.
18114 If it does, implement the statement. */
18115
18116 #if FFESTR_VXT
18117 ffelexHandler
18118 ffestb_V021 (ffelexToken t)
18119 {
18120 ffestpDeleteIx ix;
18121
18122 switch (ffelex_token_type (ffesta_tokens[0]))
18123 {
18124 case FFELEX_typeNAME:
18125 if (ffesta_first_kw != FFESTR_firstDELETE)
18126 goto bad_0; /* :::::::::::::::::::: */
18127 break;
18128
18129 case FFELEX_typeNAMES:
18130 if (ffesta_first_kw != FFESTR_firstDELETE)
18131 goto bad_0; /* :::::::::::::::::::: */
18132 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlDELETE)
18133 goto bad_0; /* :::::::::::::::::::: */
18134 break;
18135
18136 default:
18137 goto bad_0; /* :::::::::::::::::::: */
18138 }
18139
18140 switch (ffelex_token_type (t))
18141 {
18142 case FFELEX_typeOPEN_PAREN:
18143 break;
18144
18145 case FFELEX_typeEOS:
18146 case FFELEX_typeSEMICOLON:
18147 case FFELEX_typeCOMMA:
18148 case FFELEX_typeCOLONCOLON:
18149 ffesta_confirmed (); /* Error, but clearly intended. */
18150 goto bad_1; /* :::::::::::::::::::: */
18151
18152 default:
18153 goto bad_1; /* :::::::::::::::::::: */
18154 }
18155
18156 for (ix = 0; ix < FFESTP_deleteix; ++ix)
18157 ffestp_file.delete.delete_spec[ix].kw_or_val_present = FALSE;
18158
18159 return (ffelexHandler) ffestb_V0211_;
18160
18161 bad_0: /* :::::::::::::::::::: */
18162 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", ffesta_tokens[0]);
18163 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18164
18165 bad_1: /* :::::::::::::::::::: */
18166 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18167 return (ffelexHandler) ffelex_swallow_tokens (t,
18168 (ffelexHandler) ffesta_zero); /* Invalid second token. */
18169 }
18170
18171 /* ffestb_V0211_ -- "DELETE" OPEN_PAREN
18172
18173 return ffestb_V0211_; // to lexer
18174
18175 Handle expr construct (not NAME=expr construct) here. */
18176
18177 static ffelexHandler
18178 ffestb_V0211_ (ffelexToken t)
18179 {
18180 switch (ffelex_token_type (t))
18181 {
18182 case FFELEX_typeNAME:
18183 ffesta_tokens[1] = ffelex_token_use (t);
18184 return (ffelexHandler) ffestb_V0212_;
18185
18186 default:
18187 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18188 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0213_)))
18189 (t);
18190 }
18191 }
18192
18193 /* ffestb_V0212_ -- "DELETE" OPEN_PAREN NAME
18194
18195 return ffestb_V0212_; // to lexer
18196
18197 If EQUALS here, go to states that handle it. Else, send NAME and this
18198 token thru expression handler. */
18199
18200 static ffelexHandler
18201 ffestb_V0212_ (ffelexToken t)
18202 {
18203 ffelexHandler next;
18204 ffelexToken nt;
18205
18206 switch (ffelex_token_type (t))
18207 {
18208 case FFELEX_typeEQUALS:
18209 nt = ffesta_tokens[1];
18210 next = (ffelexHandler) ffestb_V0214_ (nt);
18211 ffelex_token_kill (nt);
18212 return (ffelexHandler) (*next) (t);
18213
18214 default:
18215 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18216 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0213_)))
18217 (ffesta_tokens[1]);
18218 ffelex_token_kill (ffesta_tokens[1]);
18219 return (ffelexHandler) (*next) (t);
18220 }
18221 }
18222
18223 /* ffestb_V0213_ -- "DELETE" OPEN_PAREN expr
18224
18225 (ffestb_V0213_) // to expression handler
18226
18227 Handle COMMA or DELETE_PAREN here. */
18228
18229 static ffelexHandler
18230 ffestb_V0213_ (ffelexToken ft, ffebld expr, ffelexToken t)
18231 {
18232 switch (ffelex_token_type (t))
18233 {
18234 case FFELEX_typeCOMMA:
18235 case FFELEX_typeCLOSE_PAREN:
18236 if (expr == NULL)
18237 break;
18238 ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].kw_or_val_present
18239 = TRUE;
18240 ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].kw_present = FALSE;
18241 ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value_present = TRUE;
18242 ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value_is_label
18243 = FALSE;
18244 ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value
18245 = ffelex_token_use (ft);
18246 ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].u.expr = expr;
18247 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18248 return (ffelexHandler) ffestb_V0214_;
18249 return (ffelexHandler) ffestb_V0219_;
18250
18251 default:
18252 break;
18253 }
18254
18255 ffestb_subr_kill_delete_ ();
18256 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18257 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18258 }
18259
18260 /* ffestb_V0214_ -- "DELETE" OPEN_PAREN [external-file-unit COMMA]
18261
18262 return ffestb_V0214_; // to lexer
18263
18264 Handle expr construct (not NAME=expr construct) here. */
18265
18266 static ffelexHandler
18267 ffestb_V0214_ (ffelexToken t)
18268 {
18269 ffestrGenio kw;
18270
18271 ffestb_local_.delete.label = FALSE;
18272
18273 switch (ffelex_token_type (t))
18274 {
18275 case FFELEX_typeNAME:
18276 kw = ffestr_genio (t);
18277 switch (kw)
18278 {
18279 case FFESTR_genioERR:
18280 ffestb_local_.delete.ix = FFESTP_deleteixERR;
18281 ffestb_local_.delete.label = TRUE;
18282 break;
18283
18284 case FFESTR_genioIOSTAT:
18285 ffestb_local_.delete.ix = FFESTP_deleteixIOSTAT;
18286 ffestb_local_.delete.left = TRUE;
18287 ffestb_local_.delete.context = FFEEXPR_contextFILEINT;
18288 break;
18289
18290 case FFESTR_genioREC:
18291 ffestb_local_.delete.ix = FFESTP_deleteixREC;
18292 ffestb_local_.delete.left = FALSE;
18293 ffestb_local_.delete.context = FFEEXPR_contextFILENUM;
18294 break;
18295
18296 case FFESTR_genioUNIT:
18297 ffestb_local_.delete.ix = FFESTP_deleteixUNIT;
18298 ffestb_local_.delete.left = FALSE;
18299 ffestb_local_.delete.context = FFEEXPR_contextFILENUM;
18300 break;
18301
18302 default:
18303 goto bad; /* :::::::::::::::::::: */
18304 }
18305 if (ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18306 .kw_or_val_present)
18307 break; /* Can't specify a keyword twice! */
18308 ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18309 .kw_or_val_present = TRUE;
18310 ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18311 .kw_present = TRUE;
18312 ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18313 .value_present = FALSE;
18314 ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_is_label
18315 = ffestb_local_.delete.label;
18316 ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].kw
18317 = ffelex_token_use (t);
18318 return (ffelexHandler) ffestb_V0215_;
18319
18320 default:
18321 break;
18322 }
18323
18324 bad: /* :::::::::::::::::::: */
18325 ffestb_subr_kill_delete_ ();
18326 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18327 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18328 }
18329
18330 /* ffestb_V0215_ -- "DELETE" OPEN_PAREN [external-file-unit COMMA] NAME
18331
18332 return ffestb_V0215_; // to lexer
18333
18334 Make sure EQUALS here, send next token to expression handler. */
18335
18336 static ffelexHandler
18337 ffestb_V0215_ (ffelexToken t)
18338 {
18339 switch (ffelex_token_type (t))
18340 {
18341 case FFELEX_typeEQUALS:
18342 ffesta_confirmed ();
18343 if (ffestb_local_.delete.label)
18344 return (ffelexHandler) ffestb_V0217_;
18345 if (ffestb_local_.delete.left)
18346 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
18347 ffestb_local_.delete.context,
18348 (ffeexprCallback) ffestb_V0216_);
18349 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18350 ffestb_local_.delete.context, (ffeexprCallback) ffestb_V0216_);
18351
18352 default:
18353 break;
18354 }
18355
18356 ffestb_subr_kill_delete_ ();
18357 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18358 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18359 }
18360
18361 /* ffestb_V0216_ -- "DELETE" OPEN_PAREN ... NAME EQUALS expr
18362
18363 (ffestb_V0216_) // to expression handler
18364
18365 Handle COMMA or CLOSE_PAREN here. */
18366
18367 static ffelexHandler
18368 ffestb_V0216_ (ffelexToken ft, ffebld expr, ffelexToken t)
18369 {
18370 switch (ffelex_token_type (t))
18371 {
18372 case FFELEX_typeCOMMA:
18373 case FFELEX_typeCLOSE_PAREN:
18374 if (expr == NULL)
18375 break;
18376 ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_present
18377 = TRUE;
18378 ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value
18379 = ffelex_token_use (ft);
18380 ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].u.expr = expr;
18381 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18382 return (ffelexHandler) ffestb_V0214_;
18383 return (ffelexHandler) ffestb_V0219_;
18384
18385 default:
18386 break;
18387 }
18388
18389 ffestb_subr_kill_delete_ ();
18390 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18391 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18392 }
18393
18394 /* ffestb_V0217_ -- "DELETE" OPEN_PAREN ... NAME EQUALS
18395
18396 return ffestb_V0217_; // to lexer
18397
18398 Handle NUMBER for label here. */
18399
18400 static ffelexHandler
18401 ffestb_V0217_ (ffelexToken t)
18402 {
18403 switch (ffelex_token_type (t))
18404 {
18405 case FFELEX_typeNUMBER:
18406 ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_present
18407 = TRUE;
18408 ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value
18409 = ffelex_token_use (t);
18410 return (ffelexHandler) ffestb_V0218_;
18411
18412 default:
18413 break;
18414 }
18415
18416 ffestb_subr_kill_delete_ ();
18417 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18418 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18419 }
18420
18421 /* ffestb_V0218_ -- "DELETE" OPEN_PAREN ... NAME EQUALS NUMBER
18422
18423 return ffestb_V0218_; // to lexer
18424
18425 Handle COMMA or CLOSE_PAREN here. */
18426
18427 static ffelexHandler
18428 ffestb_V0218_ (ffelexToken t)
18429 {
18430 switch (ffelex_token_type (t))
18431 {
18432 case FFELEX_typeCOMMA:
18433 return (ffelexHandler) ffestb_V0214_;
18434
18435 case FFELEX_typeCLOSE_PAREN:
18436 return (ffelexHandler) ffestb_V0219_;
18437
18438 default:
18439 break;
18440 }
18441
18442 ffestb_subr_kill_delete_ ();
18443 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18444 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18445 }
18446
18447 /* ffestb_V0219_ -- "DELETE" OPEN_PAREN ... CLOSE_PAREN
18448
18449 return ffestb_V0219_; // to lexer
18450
18451 Handle EOS or SEMICOLON here. */
18452
18453 static ffelexHandler
18454 ffestb_V0219_ (ffelexToken t)
18455 {
18456 switch (ffelex_token_type (t))
18457 {
18458 case FFELEX_typeEOS:
18459 case FFELEX_typeSEMICOLON:
18460 ffesta_confirmed ();
18461 if (!ffesta_is_inhibited ())
18462 ffestc_V021 ();
18463 ffestb_subr_kill_delete_ ();
18464 return (ffelexHandler) ffesta_zero (t);
18465
18466 default:
18467 break;
18468 }
18469
18470 ffestb_subr_kill_delete_ ();
18471 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18472 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18473 }
18474
18475 /* ffestb_V026 -- Parse a FIND statement
18476
18477 return ffestb_V026; // to lexer
18478
18479 Make sure the statement has a valid form for a FIND statement.
18480 If it does, implement the statement. */
18481
18482 ffelexHandler
18483 ffestb_V026 (ffelexToken t)
18484 {
18485 ffestpFindIx ix;
18486
18487 switch (ffelex_token_type (ffesta_tokens[0]))
18488 {
18489 case FFELEX_typeNAME:
18490 if (ffesta_first_kw != FFESTR_firstFIND)
18491 goto bad_0; /* :::::::::::::::::::: */
18492 break;
18493
18494 case FFELEX_typeNAMES:
18495 if (ffesta_first_kw != FFESTR_firstFIND)
18496 goto bad_0; /* :::::::::::::::::::: */
18497 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlFIND)
18498 goto bad_0; /* :::::::::::::::::::: */
18499 break;
18500
18501 default:
18502 goto bad_0; /* :::::::::::::::::::: */
18503 }
18504
18505 switch (ffelex_token_type (t))
18506 {
18507 case FFELEX_typeOPEN_PAREN:
18508 break;
18509
18510 case FFELEX_typeEOS:
18511 case FFELEX_typeSEMICOLON:
18512 case FFELEX_typeCOMMA:
18513 case FFELEX_typeCOLONCOLON:
18514 ffesta_confirmed (); /* Error, but clearly intended. */
18515 goto bad_1; /* :::::::::::::::::::: */
18516
18517 default:
18518 goto bad_1; /* :::::::::::::::::::: */
18519 }
18520
18521 for (ix = 0; ix < FFESTP_findix; ++ix)
18522 ffestp_file.find.find_spec[ix].kw_or_val_present = FALSE;
18523
18524 return (ffelexHandler) ffestb_V0261_;
18525
18526 bad_0: /* :::::::::::::::::::: */
18527 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", ffesta_tokens[0]);
18528 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18529
18530 bad_1: /* :::::::::::::::::::: */
18531 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18532 return (ffelexHandler) ffelex_swallow_tokens (t,
18533 (ffelexHandler) ffesta_zero); /* Invalid second token. */
18534 }
18535
18536 /* ffestb_V0261_ -- "FIND" OPEN_PAREN
18537
18538 return ffestb_V0261_; // to lexer
18539
18540 Handle expr construct (not NAME=expr construct) here. */
18541
18542 static ffelexHandler
18543 ffestb_V0261_ (ffelexToken t)
18544 {
18545 switch (ffelex_token_type (t))
18546 {
18547 case FFELEX_typeNAME:
18548 ffesta_tokens[1] = ffelex_token_use (t);
18549 return (ffelexHandler) ffestb_V0262_;
18550
18551 default:
18552 return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18553 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0263_)))
18554 (t);
18555 }
18556 }
18557
18558 /* ffestb_V0262_ -- "FIND" OPEN_PAREN NAME
18559
18560 return ffestb_V0262_; // to lexer
18561
18562 If EQUALS here, go to states that handle it. Else, send NAME and this
18563 token thru expression handler. */
18564
18565 static ffelexHandler
18566 ffestb_V0262_ (ffelexToken t)
18567 {
18568 ffelexHandler next;
18569 ffelexToken nt;
18570
18571 switch (ffelex_token_type (t))
18572 {
18573 case FFELEX_typeEQUALS:
18574 nt = ffesta_tokens[1];
18575 next = (ffelexHandler) ffestb_V0264_ (nt);
18576 ffelex_token_kill (nt);
18577 return (ffelexHandler) (*next) (t);
18578
18579 default:
18580 next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18581 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0263_)))
18582 (ffesta_tokens[1]);
18583 ffelex_token_kill (ffesta_tokens[1]);
18584 return (ffelexHandler) (*next) (t);
18585 }
18586 }
18587
18588 /* ffestb_V0263_ -- "FIND" OPEN_PAREN expr
18589
18590 (ffestb_V0263_) // to expression handler
18591
18592 Handle COMMA or FIND_PAREN here. */
18593
18594 static ffelexHandler
18595 ffestb_V0263_ (ffelexToken ft, ffebld expr, ffelexToken t)
18596 {
18597 switch (ffelex_token_type (t))
18598 {
18599 case FFELEX_typeCOMMA:
18600 case FFELEX_typeCLOSE_PAREN:
18601 if (expr == NULL)
18602 break;
18603 ffestp_file.find.find_spec[FFESTP_findixUNIT].kw_or_val_present
18604 = TRUE;
18605 ffestp_file.find.find_spec[FFESTP_findixUNIT].kw_present = FALSE;
18606 ffestp_file.find.find_spec[FFESTP_findixUNIT].value_present = TRUE;
18607 ffestp_file.find.find_spec[FFESTP_findixUNIT].value_is_label
18608 = FALSE;
18609 ffestp_file.find.find_spec[FFESTP_findixUNIT].value
18610 = ffelex_token_use (ft);
18611 ffestp_file.find.find_spec[FFESTP_findixUNIT].u.expr = expr;
18612 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18613 return (ffelexHandler) ffestb_V0264_;
18614 return (ffelexHandler) ffestb_V0269_;
18615
18616 default:
18617 break;
18618 }
18619
18620 ffestb_subr_kill_find_ ();
18621 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18622 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18623 }
18624
18625 /* ffestb_V0264_ -- "FIND" OPEN_PAREN [external-file-unit COMMA]
18626
18627 return ffestb_V0264_; // to lexer
18628
18629 Handle expr construct (not NAME=expr construct) here. */
18630
18631 static ffelexHandler
18632 ffestb_V0264_ (ffelexToken t)
18633 {
18634 ffestrGenio kw;
18635
18636 ffestb_local_.find.label = FALSE;
18637
18638 switch (ffelex_token_type (t))
18639 {
18640 case FFELEX_typeNAME:
18641 kw = ffestr_genio (t);
18642 switch (kw)
18643 {
18644 case FFESTR_genioERR:
18645 ffestb_local_.find.ix = FFESTP_findixERR;
18646 ffestb_local_.find.label = TRUE;
18647 break;
18648
18649 case FFESTR_genioIOSTAT:
18650 ffestb_local_.find.ix = FFESTP_findixIOSTAT;
18651 ffestb_local_.find.left = TRUE;
18652 ffestb_local_.find.context = FFEEXPR_contextFILEINT;
18653 break;
18654
18655 case FFESTR_genioREC:
18656 ffestb_local_.find.ix = FFESTP_findixREC;
18657 ffestb_local_.find.left = FALSE;
18658 ffestb_local_.find.context = FFEEXPR_contextFILENUM;
18659 break;
18660
18661 case FFESTR_genioUNIT:
18662 ffestb_local_.find.ix = FFESTP_findixUNIT;
18663 ffestb_local_.find.left = FALSE;
18664 ffestb_local_.find.context = FFEEXPR_contextFILENUM;
18665 break;
18666
18667 default:
18668 goto bad; /* :::::::::::::::::::: */
18669 }
18670 if (ffestp_file.find.find_spec[ffestb_local_.find.ix]
18671 .kw_or_val_present)
18672 break; /* Can't specify a keyword twice! */
18673 ffestp_file.find.find_spec[ffestb_local_.find.ix]
18674 .kw_or_val_present = TRUE;
18675 ffestp_file.find.find_spec[ffestb_local_.find.ix]
18676 .kw_present = TRUE;
18677 ffestp_file.find.find_spec[ffestb_local_.find.ix]
18678 .value_present = FALSE;
18679 ffestp_file.find.find_spec[ffestb_local_.find.ix].value_is_label
18680 = ffestb_local_.find.label;
18681 ffestp_file.find.find_spec[ffestb_local_.find.ix].kw
18682 = ffelex_token_use (t);
18683 return (ffelexHandler) ffestb_V0265_;
18684
18685 default:
18686 break;
18687 }
18688
18689 bad: /* :::::::::::::::::::: */
18690 ffestb_subr_kill_find_ ();
18691 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18692 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18693 }
18694
18695 /* ffestb_V0265_ -- "FIND" OPEN_PAREN [external-file-unit COMMA] NAME
18696
18697 return ffestb_V0265_; // to lexer
18698
18699 Make sure EQUALS here, send next token to expression handler. */
18700
18701 static ffelexHandler
18702 ffestb_V0265_ (ffelexToken t)
18703 {
18704 switch (ffelex_token_type (t))
18705 {
18706 case FFELEX_typeEQUALS:
18707 ffesta_confirmed ();
18708 if (ffestb_local_.find.label)
18709 return (ffelexHandler) ffestb_V0267_;
18710 if (ffestb_local_.find.left)
18711 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
18712 ffestb_local_.find.context,
18713 (ffeexprCallback) ffestb_V0266_);
18714 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18715 ffestb_local_.find.context,
18716 (ffeexprCallback) ffestb_V0266_);
18717
18718 default:
18719 break;
18720 }
18721
18722 ffestb_subr_kill_find_ ();
18723 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18724 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18725 }
18726
18727 /* ffestb_V0266_ -- "FIND" OPEN_PAREN ... NAME EQUALS expr
18728
18729 (ffestb_V0266_) // to expression handler
18730
18731 Handle COMMA or CLOSE_PAREN here. */
18732
18733 static ffelexHandler
18734 ffestb_V0266_ (ffelexToken ft, ffebld expr, ffelexToken t)
18735 {
18736 switch (ffelex_token_type (t))
18737 {
18738 case FFELEX_typeCOMMA:
18739 case FFELEX_typeCLOSE_PAREN:
18740 if (expr == NULL)
18741 break;
18742 ffestp_file.find.find_spec[ffestb_local_.find.ix].value_present
18743 = TRUE;
18744 ffestp_file.find.find_spec[ffestb_local_.find.ix].value
18745 = ffelex_token_use (ft);
18746 ffestp_file.find.find_spec[ffestb_local_.find.ix].u.expr = expr;
18747 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18748 return (ffelexHandler) ffestb_V0264_;
18749 return (ffelexHandler) ffestb_V0269_;
18750
18751 default:
18752 break;
18753 }
18754
18755 ffestb_subr_kill_find_ ();
18756 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18757 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18758 }
18759
18760 /* ffestb_V0267_ -- "FIND" OPEN_PAREN ... NAME EQUALS
18761
18762 return ffestb_V0267_; // to lexer
18763
18764 Handle NUMBER for label here. */
18765
18766 static ffelexHandler
18767 ffestb_V0267_ (ffelexToken t)
18768 {
18769 switch (ffelex_token_type (t))
18770 {
18771 case FFELEX_typeNUMBER:
18772 ffestp_file.find.find_spec[ffestb_local_.find.ix].value_present
18773 = TRUE;
18774 ffestp_file.find.find_spec[ffestb_local_.find.ix].value
18775 = ffelex_token_use (t);
18776 return (ffelexHandler) ffestb_V0268_;
18777
18778 default:
18779 break;
18780 }
18781
18782 ffestb_subr_kill_find_ ();
18783 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18784 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18785 }
18786
18787 /* ffestb_V0268_ -- "FIND" OPEN_PAREN ... NAME EQUALS NUMBER
18788
18789 return ffestb_V0268_; // to lexer
18790
18791 Handle COMMA or CLOSE_PAREN here. */
18792
18793 static ffelexHandler
18794 ffestb_V0268_ (ffelexToken t)
18795 {
18796 switch (ffelex_token_type (t))
18797 {
18798 case FFELEX_typeCOMMA:
18799 return (ffelexHandler) ffestb_V0264_;
18800
18801 case FFELEX_typeCLOSE_PAREN:
18802 return (ffelexHandler) ffestb_V0269_;
18803
18804 default:
18805 break;
18806 }
18807
18808 ffestb_subr_kill_find_ ();
18809 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18810 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18811 }
18812
18813 /* ffestb_V0269_ -- "FIND" OPEN_PAREN ... CLOSE_PAREN
18814
18815 return ffestb_V0269_; // to lexer
18816
18817 Handle EOS or SEMICOLON here. */
18818
18819 static ffelexHandler
18820 ffestb_V0269_ (ffelexToken t)
18821 {
18822 switch (ffelex_token_type (t))
18823 {
18824 case FFELEX_typeEOS:
18825 case FFELEX_typeSEMICOLON:
18826 ffesta_confirmed ();
18827 if (!ffesta_is_inhibited ())
18828 ffestc_V026 ();
18829 ffestb_subr_kill_find_ ();
18830 return (ffelexHandler) ffesta_zero (t);
18831
18832 default:
18833 break;
18834 }
18835
18836 ffestb_subr_kill_find_ ();
18837 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18838 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18839 }
18840
18841 #endif
18842 /* ffestb_dimlist -- Parse the ALLOCATABLE/POINTER/TARGET statement
18843
18844 return ffestb_dimlist; // to lexer
18845
18846 Make sure the statement has a valid form for the ALLOCATABLE/POINTER/
18847 TARGET statement. If it does, implement the statement. */
18848
18849 #if FFESTR_F90
18850 ffelexHandler
18851 ffestb_dimlist (ffelexToken t)
18852 {
18853 ffeTokenLength i;
18854 const char *p;
18855 ffelexToken nt;
18856 ffelexHandler next;
18857
18858 switch (ffelex_token_type (ffesta_tokens[0]))
18859 {
18860 case FFELEX_typeNAME:
18861 switch (ffelex_token_type (t))
18862 {
18863 case FFELEX_typeCOMMA:
18864 case FFELEX_typeEOS:
18865 case FFELEX_typeSEMICOLON:
18866 ffesta_confirmed (); /* Error, but clearly intended. */
18867 goto bad_1; /* :::::::::::::::::::: */
18868
18869 default:
18870 goto bad_1; /* :::::::::::::::::::: */
18871
18872 case FFELEX_typeCOLONCOLON:
18873 ffesta_confirmed ();
18874 if (!ffesta_is_inhibited ())
18875 {
18876 switch (ffesta_first_kw)
18877 {
18878 case FFESTR_firstALLOCATABLE:
18879 ffestc_R525_start ();
18880 break;
18881
18882 case FFESTR_firstPOINTER:
18883 ffestc_R526_start ();
18884 break;
18885
18886 case FFESTR_firstTARGET:
18887 ffestc_R527_start ();
18888 break;
18889
18890 default:
18891 assert (FALSE);
18892 }
18893 }
18894 ffestb_local_.dimlist.started = TRUE;
18895 return (ffelexHandler) ffestb_dimlist1_;
18896
18897 case FFELEX_typeNAME:
18898 ffesta_confirmed ();
18899 if (!ffesta_is_inhibited ())
18900 {
18901 switch (ffesta_first_kw)
18902 {
18903 case FFESTR_firstALLOCATABLE:
18904 ffestc_R525_start ();
18905 break;
18906
18907 case FFESTR_firstPOINTER:
18908 ffestc_R526_start ();
18909 break;
18910
18911 case FFESTR_firstTARGET:
18912 ffestc_R527_start ();
18913 break;
18914
18915 default:
18916 assert (FALSE);
18917 }
18918 }
18919 ffestb_local_.dimlist.started = TRUE;
18920 return (ffelexHandler) ffestb_dimlist1_ (t);
18921 }
18922
18923 case FFELEX_typeNAMES:
18924 p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.dimlist.len);
18925 switch (ffelex_token_type (t))
18926 {
18927 default:
18928 goto bad_1; /* :::::::::::::::::::: */
18929
18930 case FFELEX_typeEOS:
18931 case FFELEX_typeSEMICOLON:
18932 case FFELEX_typeCOMMA:
18933 ffesta_confirmed ();
18934 if (!ffesrc_is_name_init (*p))
18935 goto bad_i; /* :::::::::::::::::::: */
18936 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
18937 if (!ffesta_is_inhibited ())
18938 {
18939 switch (ffesta_first_kw)
18940 {
18941 case FFESTR_firstALLOCATABLE:
18942 ffestc_R525_start ();
18943 break;
18944
18945 case FFESTR_firstPOINTER:
18946 ffestc_R526_start ();
18947 break;
18948
18949 case FFESTR_firstTARGET:
18950 ffestc_R527_start ();
18951 break;
18952
18953 default:
18954 assert (FALSE);
18955 }
18956 }
18957 ffestb_local_.dimlist.started = TRUE;
18958 next = (ffelexHandler) ffestb_dimlist1_ (nt);
18959 ffelex_token_kill (nt);
18960 return (ffelexHandler) (*next) (t);
18961
18962 case FFELEX_typeCOLONCOLON:
18963 ffesta_confirmed ();
18964 if (*p != '\0')
18965 goto bad_i; /* :::::::::::::::::::: */
18966 if (!ffesta_is_inhibited ())
18967 {
18968 switch (ffesta_first_kw)
18969 {
18970 case FFESTR_firstALLOCATABLE:
18971 ffestc_R525_start ();
18972 break;
18973
18974 case FFESTR_firstPOINTER:
18975 ffestc_R526_start ();
18976 break;
18977
18978 case FFESTR_firstTARGET:
18979 ffestc_R527_start ();
18980 break;
18981
18982 default:
18983 assert (FALSE);
18984 }
18985 }
18986 ffestb_local_.dimlist.started = TRUE;
18987 return (ffelexHandler) ffestb_dimlist1_;
18988
18989 case FFELEX_typeOPEN_PAREN:
18990 if (!ffesrc_is_name_init (*p))
18991 goto bad_i; /* :::::::::::::::::::: */
18992 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
18993 ffestb_local_.dimlist.started = FALSE;
18994 next = (ffelexHandler) ffestb_dimlist1_ (nt);
18995 ffelex_token_kill (nt);
18996 return (ffelexHandler) (*next) (t);
18997 }
18998
18999 default:
19000 goto bad_0; /* :::::::::::::::::::: */
19001 }
19002
19003 bad_0: /* :::::::::::::::::::: */
19004 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, ffesta_tokens[0]);
19005 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19006
19007 bad_1: /* :::::::::::::::::::: */
19008 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19009 return (ffelexHandler) ffelex_swallow_tokens (t,
19010 (ffelexHandler) ffesta_zero); /* Invalid second token. */
19011
19012 bad_i: /* :::::::::::::::::::: */
19013 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, ffesta_tokens[0], i, t);
19014 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19015 }
19016
19017 /* ffestb_dimlist1_ -- "ALLOCATABLE/POINTER/TARGET" [COLONCOLON]
19018
19019 return ffestb_dimlist1_; // to lexer
19020
19021 Handle NAME. */
19022
19023 static ffelexHandler
19024 ffestb_dimlist1_ (ffelexToken t)
19025 {
19026 switch (ffelex_token_type (t))
19027 {
19028 case FFELEX_typeNAME:
19029 ffesta_tokens[1] = ffelex_token_use (t);
19030 return (ffelexHandler) ffestb_dimlist2_;
19031
19032 default:
19033 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19034 break;
19035 }
19036
19037 if (!ffesta_is_inhibited ())
19038 {
19039 switch (ffesta_first_kw)
19040 {
19041 case FFESTR_firstALLOCATABLE:
19042 ffestc_R525_finish ();
19043 break;
19044
19045 case FFESTR_firstPOINTER:
19046 ffestc_R526_finish ();
19047 break;
19048
19049 case FFESTR_firstTARGET:
19050 ffestc_R527_finish ();
19051 break;
19052
19053 default:
19054 assert (FALSE);
19055 }
19056 }
19057 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19058 }
19059
19060 /* ffestb_dimlist2_ -- "ALLOCATABLE/POINTER/TARGET" ... NAME
19061
19062 return ffestb_dimlist2_; // to lexer
19063
19064 Handle OPEN_PAREN. */
19065
19066 static ffelexHandler
19067 ffestb_dimlist2_ (ffelexToken t)
19068 {
19069 switch (ffelex_token_type (t))
19070 {
19071 case FFELEX_typeOPEN_PAREN:
19072 ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
19073 ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_dimlist3_;
19074 ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
19075 ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLIST;
19076 #ifdef FFECOM_dimensionsMAX
19077 ffestb_subrargs_.dim_list.ndims = 0;
19078 #endif
19079 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
19080 FFEEXPR_contextDIMLIST, (ffeexprCallback) ffestb_subr_dimlist_);
19081
19082 case FFELEX_typeCOMMA:
19083 ffesta_confirmed ();
19084 if (!ffesta_is_inhibited ())
19085 {
19086 if (!ffestb_local_.dimlist.started)
19087 {
19088 switch (ffesta_first_kw)
19089 {
19090 case FFESTR_firstALLOCATABLE:
19091 ffestc_R525_start ();
19092 break;
19093
19094 case FFESTR_firstPOINTER:
19095 ffestc_R526_start ();
19096 break;
19097
19098 case FFESTR_firstTARGET:
19099 ffestc_R527_start ();
19100 break;
19101
19102 default:
19103 assert (FALSE);
19104 }
19105 ffestb_local_.dimlist.started = TRUE;
19106 }
19107 switch (ffesta_first_kw)
19108 {
19109 case FFESTR_firstALLOCATABLE:
19110 ffestc_R525_item (ffesta_tokens[1], NULL);
19111 break;
19112
19113 case FFESTR_firstPOINTER:
19114 ffestc_R526_item (ffesta_tokens[1], NULL);
19115 break;
19116
19117 case FFESTR_firstTARGET:
19118 ffestc_R527_item (ffesta_tokens[1], NULL);
19119 break;
19120
19121 default:
19122 assert (FALSE);
19123 }
19124 }
19125 ffelex_token_kill (ffesta_tokens[1]);
19126 return (ffelexHandler) ffestb_dimlist4_;
19127
19128 case FFELEX_typeEOS:
19129 case FFELEX_typeSEMICOLON:
19130 ffesta_confirmed ();
19131 if (!ffesta_is_inhibited ())
19132 {
19133 if (!ffestb_local_.dimlist.started)
19134 {
19135 switch (ffesta_first_kw)
19136 {
19137 case FFESTR_firstALLOCATABLE:
19138 ffestc_R525_start ();
19139 break;
19140
19141 case FFESTR_firstPOINTER:
19142 ffestc_R526_start ();
19143 break;
19144
19145 case FFESTR_firstTARGET:
19146 ffestc_R527_start ();
19147 break;
19148
19149 default:
19150 assert (FALSE);
19151 }
19152 }
19153 switch (ffesta_first_kw)
19154 {
19155 case FFESTR_firstALLOCATABLE:
19156 ffestc_R525_item (ffesta_tokens[1], NULL);
19157 ffestc_R525_finish ();
19158 break;
19159
19160 case FFESTR_firstPOINTER:
19161 ffestc_R526_item (ffesta_tokens[1], NULL);
19162 ffestc_R526_finish ();
19163 break;
19164
19165 case FFESTR_firstTARGET:
19166 ffestc_R527_item (ffesta_tokens[1], NULL);
19167 ffestc_R527_finish ();
19168 break;
19169
19170 default:
19171 assert (FALSE);
19172 }
19173 }
19174 ffelex_token_kill (ffesta_tokens[1]);
19175 return (ffelexHandler) ffesta_zero (t);
19176
19177 default:
19178 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19179 break;
19180 }
19181
19182 if (!ffesta_is_inhibited ())
19183 {
19184 switch (ffesta_first_kw)
19185 {
19186 case FFESTR_firstALLOCATABLE:
19187 ffestc_R525_finish ();
19188 break;
19189
19190 case FFESTR_firstPOINTER:
19191 ffestc_R526_finish ();
19192 break;
19193
19194 case FFESTR_firstTARGET:
19195 ffestc_R527_finish ();
19196 break;
19197
19198 default:
19199 assert (FALSE);
19200 }
19201 }
19202 ffelex_token_kill (ffesta_tokens[1]);
19203 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19204 }
19205
19206 /* ffestb_dimlist3_ -- "ALLOCATABLE/POINTER/TARGET" ... NAME OPEN_PAREN
19207 dimlist CLOSE_PAREN
19208
19209 return ffestb_dimlist3_; // to lexer
19210
19211 Handle COMMA or EOS/SEMICOLON. */
19212
19213 static ffelexHandler
19214 ffestb_dimlist3_ (ffelexToken t)
19215 {
19216 if (!ffestb_subrargs_.dim_list.ok)
19217 goto bad; /* :::::::::::::::::::: */
19218
19219 switch (ffelex_token_type (t))
19220 {
19221 case FFELEX_typeCOMMA:
19222 ffesta_confirmed ();
19223 if (!ffesta_is_inhibited ())
19224 {
19225 if (!ffestb_local_.dimlist.started)
19226 {
19227 switch (ffesta_first_kw)
19228 {
19229 case FFESTR_firstALLOCATABLE:
19230 ffestc_R525_start ();
19231 break;
19232
19233 case FFESTR_firstPOINTER:
19234 ffestc_R526_start ();
19235 break;
19236
19237 case FFESTR_firstTARGET:
19238 ffestc_R527_start ();
19239 break;
19240
19241 default:
19242 assert (FALSE);
19243 }
19244 ffestb_local_.dimlist.started = TRUE;
19245 }
19246 switch (ffesta_first_kw)
19247 {
19248 case FFESTR_firstALLOCATABLE:
19249 ffestc_R525_item (ffesta_tokens[1],
19250 ffestb_subrargs_.dim_list.dims);
19251 break;
19252
19253 case FFESTR_firstPOINTER:
19254 ffestc_R526_item (ffesta_tokens[1],
19255 ffestb_subrargs_.dim_list.dims);
19256 break;
19257
19258 case FFESTR_firstTARGET:
19259 ffestc_R527_item (ffesta_tokens[1],
19260 ffestb_subrargs_.dim_list.dims);
19261 break;
19262
19263 default:
19264 assert (FALSE);
19265 }
19266 }
19267 ffelex_token_kill (ffesta_tokens[1]);
19268 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19269 return (ffelexHandler) ffestb_dimlist4_;
19270
19271 case FFELEX_typeEOS:
19272 case FFELEX_typeSEMICOLON:
19273 ffesta_confirmed ();
19274 if (!ffesta_is_inhibited ())
19275 {
19276 if (!ffestb_local_.dimlist.started)
19277 {
19278 switch (ffesta_first_kw)
19279 {
19280 case FFESTR_firstALLOCATABLE:
19281 ffestc_R525_start ();
19282 break;
19283
19284 case FFESTR_firstPOINTER:
19285 ffestc_R526_start ();
19286 break;
19287
19288 case FFESTR_firstTARGET:
19289 ffestc_R527_start ();
19290 break;
19291
19292 default:
19293 assert (FALSE);
19294 }
19295 }
19296 switch (ffesta_first_kw)
19297 {
19298 case FFESTR_firstALLOCATABLE:
19299 ffestc_R525_item (ffesta_tokens[1],
19300 ffestb_subrargs_.dim_list.dims);
19301 ffestc_R525_finish ();
19302 break;
19303
19304 case FFESTR_firstPOINTER:
19305 ffestc_R526_item (ffesta_tokens[1],
19306 ffestb_subrargs_.dim_list.dims);
19307 ffestc_R526_finish ();
19308 break;
19309
19310 case FFESTR_firstTARGET:
19311 ffestc_R527_item (ffesta_tokens[1],
19312 ffestb_subrargs_.dim_list.dims);
19313 ffestc_R527_finish ();
19314 break;
19315
19316 default:
19317 assert (FALSE);
19318 }
19319 }
19320 ffelex_token_kill (ffesta_tokens[1]);
19321 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19322 return (ffelexHandler) ffesta_zero (t);
19323
19324 default:
19325 break;
19326 }
19327
19328 bad: /* :::::::::::::::::::: */
19329 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19330 if (ffestb_local_.dimlist.started && !ffesta_is_inhibited ())
19331 {
19332 switch (ffesta_first_kw)
19333 {
19334 case FFESTR_firstALLOCATABLE:
19335 ffestc_R525_finish ();
19336 break;
19337
19338 case FFESTR_firstPOINTER:
19339 ffestc_R526_finish ();
19340 break;
19341
19342 case FFESTR_firstTARGET:
19343 ffestc_R527_finish ();
19344 break;
19345
19346 default:
19347 assert (FALSE);
19348 }
19349 }
19350 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19351 ffelex_token_kill (ffesta_tokens[1]);
19352 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19353 }
19354
19355 /* ffestb_dimlist4_ -- "ALLOCATABLE/POINTER/TARGET" ... COMMA
19356
19357 return ffestb_dimlist4_; // to lexer
19358
19359 Make sure we don't have EOS or SEMICOLON. */
19360
19361 static ffelexHandler
19362 ffestb_dimlist4_ (ffelexToken t)
19363 {
19364 switch (ffelex_token_type (t))
19365 {
19366 case FFELEX_typeEOS:
19367 case FFELEX_typeSEMICOLON:
19368 if (!ffesta_is_inhibited ())
19369 {
19370 switch (ffesta_first_kw)
19371 {
19372 case FFESTR_firstALLOCATABLE:
19373 ffestc_R525_finish ();
19374 break;
19375
19376 case FFESTR_firstPOINTER:
19377 ffestc_R526_finish ();
19378 break;
19379
19380 case FFESTR_firstTARGET:
19381 ffestc_R527_finish ();
19382 break;
19383
19384 default:
19385 assert (FALSE);
19386 }
19387 }
19388 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19389 return (ffelexHandler) ffesta_zero (t);
19390
19391 default:
19392 return (ffelexHandler) ffestb_dimlist1_ (t);
19393 }
19394 }
19395
19396 #endif
19397 /* ffestb_dummy -- Parse an ENTRY/FUNCTION/SUBROUTINE statement
19398
19399 return ffestb_dummy; // to lexer
19400
19401 Make sure the statement has a valid form for an ENTRY/FUNCTION/SUBROUTINE
19402 statement. If it does, implement the statement. */
19403
19404 ffelexHandler
19405 ffestb_dummy (ffelexToken t)
19406 {
19407 ffeTokenLength i;
19408 unsigned const char *p;
19409
19410 switch (ffelex_token_type (ffesta_tokens[0]))
19411 {
19412 case FFELEX_typeNAME:
19413 switch (ffelex_token_type (t))
19414 {
19415 case FFELEX_typeEOS:
19416 case FFELEX_typeSEMICOLON:
19417 case FFELEX_typeCOMMA:
19418 case FFELEX_typeCOLONCOLON:
19419 ffesta_confirmed (); /* Error, but clearly intended. */
19420 goto bad_1; /* :::::::::::::::::::: */
19421
19422 default:
19423 goto bad_1; /* :::::::::::::::::::: */
19424
19425 case FFELEX_typeNAME:
19426 break;
19427 }
19428
19429 ffesta_confirmed ();
19430 ffesta_tokens[1] = ffelex_token_use (t);
19431 ffestb_local_.decl.recursive = NULL;
19432 ffestb_local_.dummy.badname = ffestb_args.dummy.badname;
19433 ffestb_local_.dummy.is_subr = ffestb_args.dummy.is_subr;
19434 ffestb_local_.dummy.first_kw = ffesta_first_kw;
19435 return (ffelexHandler) ffestb_dummy1_;
19436
19437 case FFELEX_typeNAMES:
19438 switch (ffelex_token_type (t))
19439 {
19440 case FFELEX_typeCOMMA:
19441 case FFELEX_typeCOLONCOLON:
19442 ffesta_confirmed (); /* Error, but clearly intended. */
19443 goto bad_1; /* :::::::::::::::::::: */
19444
19445 default:
19446 goto bad_1; /* :::::::::::::::::::: */
19447
19448 case FFELEX_typeEOS:
19449 case FFELEX_typeSEMICOLON:
19450 ffesta_confirmed ();
19451 break;
19452
19453 case FFELEX_typeOPEN_PAREN:
19454 break;
19455 }
19456 p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.dummy.len);
19457 if (!ffesrc_is_name_init (*p))
19458 goto bad_i; /* :::::::::::::::::::: */
19459 ffesta_tokens[1]
19460 = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
19461 ffestb_local_.decl.recursive = NULL;
19462 ffestb_local_.dummy.badname = ffestb_args.dummy.badname;
19463 ffestb_local_.dummy.is_subr = ffestb_args.dummy.is_subr;
19464 ffestb_local_.dummy.first_kw = ffesta_first_kw;
19465 return (ffelexHandler) ffestb_dummy1_ (t);
19466
19467 default:
19468 goto bad_0; /* :::::::::::::::::::: */
19469 }
19470
19471 bad_0: /* :::::::::::::::::::: */
19472 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, ffesta_tokens[0]);
19473 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19474
19475 bad_1: /* :::::::::::::::::::: */
19476 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, t);
19477 return (ffelexHandler) ffelex_swallow_tokens (t,
19478 (ffelexHandler) ffesta_zero); /* Invalid second token. */
19479
19480 bad_i: /* :::::::::::::::::::: */
19481 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, ffesta_tokens[0], i, t);
19482 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19483 }
19484
19485 /* ffestb_dummy1_ -- "ENTRY/FUNCTION/SUBROUTINE" NAME
19486
19487 return ffestb_dummy1_; // to lexer
19488
19489 Make sure the next token is an EOS, SEMICOLON, or OPEN_PAREN. In the
19490 former case, just implement a null arg list, else get the arg list and
19491 then implement. */
19492
19493 static ffelexHandler
19494 ffestb_dummy1_ (ffelexToken t)
19495 {
19496 switch (ffelex_token_type (t))
19497 {
19498 case FFELEX_typeEOS:
19499 case FFELEX_typeSEMICOLON:
19500 if (ffestb_local_.dummy.first_kw == FFESTR_firstFUNCTION)
19501 {
19502 ffesta_confirmed (); /* Later, not if typename w/o RECURSIVE. */
19503 break; /* Produce an error message, need that open
19504 paren. */
19505 }
19506 ffesta_confirmed ();
19507 if (!ffesta_is_inhibited ())
19508 { /* Pretend as though we got a truly NULL
19509 list. */
19510 ffestb_subrargs_.name_list.args = NULL;
19511 ffestb_subrargs_.name_list.ok = TRUE;
19512 ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
19513 return (ffelexHandler) ffestb_dummy2_ (t);
19514 }
19515 if (ffestb_local_.decl.recursive != NULL)
19516 ffelex_token_kill (ffestb_local_.decl.recursive);
19517 ffelex_token_kill (ffesta_tokens[1]);
19518 return (ffelexHandler) ffesta_zero (t);
19519
19520 case FFELEX_typeOPEN_PAREN:
19521 ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
19522 ffestb_subrargs_.name_list.handler = (ffelexHandler) ffestb_dummy2_;
19523 ffestb_subrargs_.name_list.is_subr = ffestb_local_.dummy.is_subr;
19524 ffestb_subrargs_.name_list.names = FALSE;
19525 return (ffelexHandler) ffestb_subr_name_list_;
19526
19527 default:
19528 break;
19529 }
19530
19531 if (ffestb_local_.decl.recursive != NULL)
19532 ffelex_token_kill (ffestb_local_.decl.recursive);
19533 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_local_.dummy.badname, t);
19534 ffelex_token_kill (ffesta_tokens[1]);
19535 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19536 }
19537
19538 /* ffestb_dummy2_ -- <dummy-keyword> NAME OPEN_PAREN arg-list CLOSE_PAREN
19539
19540 return ffestb_dummy2_; // to lexer
19541
19542 Make sure the statement has a valid form for a dummy-def statement. If it
19543 does, implement the statement. */
19544
19545 static ffelexHandler
19546 ffestb_dummy2_ (ffelexToken t)
19547 {
19548 if (!ffestb_subrargs_.name_list.ok)
19549 goto bad; /* :::::::::::::::::::: */
19550
19551 switch (ffelex_token_type (t))
19552 {
19553 case FFELEX_typeEOS:
19554 case FFELEX_typeSEMICOLON:
19555 ffesta_confirmed ();
19556 if (!ffesta_is_inhibited ())
19557 {
19558 switch (ffestb_local_.dummy.first_kw)
19559 {
19560 case FFESTR_firstFUNCTION:
19561 ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
19562 ffestb_subrargs_.name_list.close_paren, FFESTP_typeNone,
19563 NULL, NULL, NULL, NULL, ffestb_local_.decl.recursive, NULL);
19564 break;
19565
19566 case FFESTR_firstSUBROUTINE:
19567 ffestc_R1223 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
19568 ffestb_subrargs_.name_list.close_paren,
19569 ffestb_local_.decl.recursive);
19570 break;
19571
19572 case FFESTR_firstENTRY:
19573 ffestc_R1226 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
19574 ffestb_subrargs_.name_list.close_paren);
19575 break;
19576
19577 default:
19578 assert (FALSE);
19579 }
19580 }
19581 ffelex_token_kill (ffesta_tokens[1]);
19582 if (ffestb_local_.decl.recursive != NULL)
19583 ffelex_token_kill (ffestb_local_.decl.recursive);
19584 ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
19585 if (ffestb_subrargs_.name_list.args != NULL)
19586 ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
19587 return (ffelexHandler) ffesta_zero (t);
19588
19589 case FFELEX_typeNAME:
19590 ffesta_confirmed ();
19591 if ((ffestb_local_.dummy.first_kw != FFESTR_firstFUNCTION)
19592 || (ffestr_other (t) != FFESTR_otherRESULT))
19593 break;
19594 ffestb_local_.decl.type = FFESTP_typeNone;
19595 ffestb_local_.decl.kind = NULL;
19596 ffestb_local_.decl.kindt = NULL;
19597 ffestb_local_.decl.len = NULL;
19598 ffestb_local_.decl.lent = NULL;
19599 return (ffelexHandler) ffestb_decl_funcname_6_;
19600
19601 default:
19602 break;
19603 }
19604
19605 bad: /* :::::::::::::::::::: */
19606 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_local_.dummy.badname, t);
19607 ffelex_token_kill (ffesta_tokens[1]);
19608 if (ffestb_local_.decl.recursive != NULL)
19609 ffelex_token_kill (ffestb_local_.decl.recursive);
19610 ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
19611 if (ffestb_subrargs_.name_list.args != NULL)
19612 ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
19613 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19614 }
19615
19616 /* ffestb_R524 -- Parse the DIMENSION statement
19617
19618 return ffestb_R524; // to lexer
19619
19620 Make sure the statement has a valid form for the DIMENSION statement. If
19621 it does, implement the statement. */
19622
19623 ffelexHandler
19624 ffestb_R524 (ffelexToken t)
19625 {
19626 ffeTokenLength i;
19627 unsigned const char *p;
19628 ffelexToken nt;
19629 ffelexHandler next;
19630
19631 switch (ffelex_token_type (ffesta_tokens[0]))
19632 {
19633 case FFELEX_typeNAME:
19634 switch (ffelex_token_type (t))
19635 {
19636 case FFELEX_typeCOMMA:
19637 case FFELEX_typeCOLONCOLON:
19638 case FFELEX_typeEOS:
19639 case FFELEX_typeSEMICOLON:
19640 ffesta_confirmed (); /* Error, but clearly intended. */
19641 goto bad_1; /* :::::::::::::::::::: */
19642
19643 default:
19644 goto bad_1; /* :::::::::::::::::::: */
19645
19646 case FFELEX_typeNAME:
19647 ffesta_confirmed ();
19648 if (!ffesta_is_inhibited ())
19649 ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
19650 ffestb_local_.dimension.started = TRUE;
19651 return (ffelexHandler) ffestb_R5241_ (t);
19652 }
19653
19654 case FFELEX_typeNAMES:
19655 p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.R524.len);
19656 switch (ffelex_token_type (t))
19657 {
19658 default:
19659 goto bad_1; /* :::::::::::::::::::: */
19660
19661 case FFELEX_typeEOS:
19662 case FFELEX_typeSEMICOLON:
19663 case FFELEX_typeCOMMA:
19664 case FFELEX_typeCOLONCOLON:
19665 ffesta_confirmed ();
19666 goto bad_1; /* :::::::::::::::::::: */
19667
19668 case FFELEX_typeOPEN_PAREN:
19669 break;
19670 }
19671
19672 /* Here, we have at least one char after "DIMENSION" and t is
19673 OPEN_PAREN. */
19674
19675 if (!ffesrc_is_name_init (*p))
19676 goto bad_i; /* :::::::::::::::::::: */
19677 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
19678 ffestb_local_.dimension.started = FALSE;
19679 next = (ffelexHandler) ffestb_R5241_ (nt);
19680 ffelex_token_kill (nt);
19681 return (ffelexHandler) (*next) (t);
19682
19683 default:
19684 goto bad_0; /* :::::::::::::::::::: */
19685 }
19686
19687 bad_0: /* :::::::::::::::::::: */
19688 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, ffesta_tokens[0]);
19689 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19690
19691 bad_1: /* :::::::::::::::::::: */
19692 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19693 return (ffelexHandler) ffelex_swallow_tokens (t,
19694 (ffelexHandler) ffesta_zero); /* Invalid second token. */
19695
19696 bad_i: /* :::::::::::::::::::: */
19697 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, ffesta_tokens[0], i, t);
19698 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19699 }
19700
19701 /* ffestb_R5241_ -- "DIMENSION"
19702
19703 return ffestb_R5241_; // to lexer
19704
19705 Handle NAME. */
19706
19707 static ffelexHandler
19708 ffestb_R5241_ (ffelexToken t)
19709 {
19710 switch (ffelex_token_type (t))
19711 {
19712 case FFELEX_typeNAME:
19713 ffesta_tokens[1] = ffelex_token_use (t);
19714 return (ffelexHandler) ffestb_R5242_;
19715
19716 default:
19717 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19718 break;
19719 }
19720
19721 if (!ffesta_is_inhibited ())
19722 ffestc_R524_finish ();
19723 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19724 }
19725
19726 /* ffestb_R5242_ -- "DIMENSION" ... NAME
19727
19728 return ffestb_R5242_; // to lexer
19729
19730 Handle OPEN_PAREN. */
19731
19732 static ffelexHandler
19733 ffestb_R5242_ (ffelexToken t)
19734 {
19735 switch (ffelex_token_type (t))
19736 {
19737 case FFELEX_typeOPEN_PAREN:
19738 ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
19739 ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_R5243_;
19740 ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
19741 ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
19742 ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
19743 #ifdef FFECOM_dimensionsMAX
19744 ffestb_subrargs_.dim_list.ndims = 0;
19745 #endif
19746 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
19747 ffestb_subrargs_.dim_list.ctx,
19748 (ffeexprCallback) ffestb_subr_dimlist_);
19749
19750 default:
19751 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19752 break;
19753 }
19754
19755 if (!ffesta_is_inhibited ())
19756 ffestc_R524_finish ();
19757 ffelex_token_kill (ffesta_tokens[1]);
19758 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19759 }
19760
19761 /* ffestb_R5243_ -- "DIMENSION" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
19762
19763 return ffestb_R5243_; // to lexer
19764
19765 Handle COMMA or EOS/SEMICOLON. */
19766
19767 static ffelexHandler
19768 ffestb_R5243_ (ffelexToken t)
19769 {
19770 if (!ffestb_subrargs_.dim_list.ok)
19771 goto bad; /* :::::::::::::::::::: */
19772
19773 switch (ffelex_token_type (t))
19774 {
19775 case FFELEX_typeCOMMA:
19776 ffesta_confirmed ();
19777 if (!ffesta_is_inhibited ())
19778 {
19779 if (!ffestb_local_.dimension.started)
19780 {
19781 ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
19782 ffestb_local_.dimension.started = TRUE;
19783 }
19784 ffestc_R524_item (ffesta_tokens[1],
19785 ffestb_subrargs_.dim_list.dims);
19786 }
19787 ffelex_token_kill (ffesta_tokens[1]);
19788 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19789 return (ffelexHandler) ffestb_R5244_;
19790
19791 case FFELEX_typeEOS:
19792 case FFELEX_typeSEMICOLON:
19793 ffesta_confirmed ();
19794 if (!ffesta_is_inhibited ())
19795 {
19796 if (!ffestb_local_.dimension.started)
19797 {
19798 ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
19799 ffestb_local_.dimension.started = TRUE;
19800 }
19801 ffestc_R524_item (ffesta_tokens[1],
19802 ffestb_subrargs_.dim_list.dims);
19803 ffestc_R524_finish ();
19804 }
19805 ffelex_token_kill (ffesta_tokens[1]);
19806 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19807 return (ffelexHandler) ffesta_zero (t);
19808
19809 default:
19810 break;
19811 }
19812
19813 bad: /* :::::::::::::::::::: */
19814 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19815 if (ffestb_local_.dimension.started && !ffesta_is_inhibited ())
19816 ffestc_R524_finish ();
19817 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19818 ffelex_token_kill (ffesta_tokens[1]);
19819 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19820 }
19821
19822 /* ffestb_R5244_ -- "DIMENSION" ... COMMA
19823
19824 return ffestb_R5244_; // to lexer
19825
19826 Make sure we don't have EOS or SEMICOLON. */
19827
19828 static ffelexHandler
19829 ffestb_R5244_ (ffelexToken t)
19830 {
19831 switch (ffelex_token_type (t))
19832 {
19833 case FFELEX_typeEOS:
19834 case FFELEX_typeSEMICOLON:
19835 if (!ffesta_is_inhibited ())
19836 ffestc_R524_finish ();
19837 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19838 return (ffelexHandler) ffesta_zero (t);
19839
19840 default:
19841 return (ffelexHandler) ffestb_R5241_ (t);
19842 }
19843 }
19844
19845 /* ffestb_R547 -- Parse the COMMON statement
19846
19847 return ffestb_R547; // to lexer
19848
19849 Make sure the statement has a valid form for the COMMON statement. If it
19850 does, implement the statement. */
19851
19852 ffelexHandler
19853 ffestb_R547 (ffelexToken t)
19854 {
19855 ffeTokenLength i;
19856 unsigned const char *p;
19857 ffelexToken nt;
19858 ffelexHandler next;
19859
19860 switch (ffelex_token_type (ffesta_tokens[0]))
19861 {
19862 case FFELEX_typeNAME:
19863 if (ffesta_first_kw != FFESTR_firstCOMMON)
19864 goto bad_0; /* :::::::::::::::::::: */
19865 switch (ffelex_token_type (t))
19866 {
19867 case FFELEX_typeCOMMA:
19868 case FFELEX_typeCOLONCOLON:
19869 case FFELEX_typeEOS:
19870 case FFELEX_typeSEMICOLON:
19871 ffesta_confirmed (); /* Error, but clearly intended. */
19872 goto bad_1; /* :::::::::::::::::::: */
19873
19874 default:
19875 goto bad_1; /* :::::::::::::::::::: */
19876
19877 case FFELEX_typeNAME:
19878 case FFELEX_typeSLASH:
19879 case FFELEX_typeCONCAT:
19880 ffesta_confirmed ();
19881 if (!ffesta_is_inhibited ())
19882 ffestc_R547_start ();
19883 ffestb_local_.common.started = TRUE;
19884 return (ffelexHandler) ffestb_R5471_ (t);
19885 }
19886
19887 case FFELEX_typeNAMES:
19888 if (ffesta_first_kw != FFESTR_firstCOMMON)
19889 goto bad_0; /* :::::::::::::::::::: */
19890 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCOMMON);
19891 switch (ffelex_token_type (t))
19892 {
19893 default:
19894 goto bad_1; /* :::::::::::::::::::: */
19895
19896 case FFELEX_typeEOS:
19897 case FFELEX_typeSEMICOLON:
19898 case FFELEX_typeCOMMA:
19899 case FFELEX_typeCOLONCOLON:
19900 ffesta_confirmed ();
19901 break;
19902
19903 case FFELEX_typeSLASH:
19904 case FFELEX_typeCONCAT:
19905 ffesta_confirmed ();
19906 if (*p != '\0')
19907 break;
19908 if (!ffesta_is_inhibited ())
19909 ffestc_R547_start ();
19910 ffestb_local_.common.started = TRUE;
19911 return (ffelexHandler) ffestb_R5471_ (t);
19912
19913 case FFELEX_typeOPEN_PAREN:
19914 break;
19915 }
19916
19917 /* Here, we have at least one char after "COMMON" and t is COMMA,
19918 EOS/SEMICOLON, OPEN_PAREN, SLASH, or CONCAT. */
19919
19920 if (!ffesrc_is_name_init (*p))
19921 goto bad_i; /* :::::::::::::::::::: */
19922 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
19923 if (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN)
19924 ffestb_local_.common.started = FALSE;
19925 else
19926 {
19927 if (!ffesta_is_inhibited ())
19928 ffestc_R547_start ();
19929 ffestb_local_.common.started = TRUE;
19930 }
19931 next = (ffelexHandler) ffestb_R5471_ (nt);
19932 ffelex_token_kill (nt);
19933 return (ffelexHandler) (*next) (t);
19934
19935 default:
19936 goto bad_0; /* :::::::::::::::::::: */
19937 }
19938
19939 bad_0: /* :::::::::::::::::::: */
19940 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", ffesta_tokens[0]);
19941 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19942
19943 bad_1: /* :::::::::::::::::::: */
19944 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
19945 return (ffelexHandler) ffelex_swallow_tokens (t,
19946 (ffelexHandler) ffesta_zero); /* Invalid second token. */
19947
19948 bad_i: /* :::::::::::::::::::: */
19949 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "COMMON", ffesta_tokens[0], i, t);
19950 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19951 }
19952
19953 /* ffestb_R5471_ -- "COMMON"
19954
19955 return ffestb_R5471_; // to lexer
19956
19957 Handle NAME, SLASH, or CONCAT. */
19958
19959 static ffelexHandler
19960 ffestb_R5471_ (ffelexToken t)
19961 {
19962 switch (ffelex_token_type (t))
19963 {
19964 case FFELEX_typeNAME:
19965 return (ffelexHandler) ffestb_R5474_ (t);
19966
19967 case FFELEX_typeSLASH:
19968 return (ffelexHandler) ffestb_R5472_;
19969
19970 case FFELEX_typeCONCAT:
19971 if (!ffesta_is_inhibited ())
19972 ffestc_R547_item_cblock (NULL);
19973 return (ffelexHandler) ffestb_R5474_;
19974
19975 default:
19976 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
19977 break;
19978 }
19979
19980 if (!ffesta_is_inhibited ())
19981 ffestc_R547_finish ();
19982 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19983 }
19984
19985 /* ffestb_R5472_ -- "COMMON" SLASH
19986
19987 return ffestb_R5472_; // to lexer
19988
19989 Handle NAME. */
19990
19991 static ffelexHandler
19992 ffestb_R5472_ (ffelexToken t)
19993 {
19994 switch (ffelex_token_type (t))
19995 {
19996 case FFELEX_typeNAME:
19997 ffesta_tokens[1] = ffelex_token_use (t);
19998 return (ffelexHandler) ffestb_R5473_;
19999
20000 case FFELEX_typeSLASH:
20001 if (!ffesta_is_inhibited ())
20002 ffestc_R547_item_cblock (NULL);
20003 return (ffelexHandler) ffestb_R5474_;
20004
20005 default:
20006 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20007 break;
20008 }
20009
20010 if (!ffesta_is_inhibited ())
20011 ffestc_R547_finish ();
20012 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20013 }
20014
20015 /* ffestb_R5473_ -- "COMMON" SLASH NAME
20016
20017 return ffestb_R5473_; // to lexer
20018
20019 Handle SLASH. */
20020
20021 static ffelexHandler
20022 ffestb_R5473_ (ffelexToken t)
20023 {
20024 switch (ffelex_token_type (t))
20025 {
20026 case FFELEX_typeSLASH:
20027 if (!ffesta_is_inhibited ())
20028 ffestc_R547_item_cblock (ffesta_tokens[1]);
20029 ffelex_token_kill (ffesta_tokens[1]);
20030 return (ffelexHandler) ffestb_R5474_;
20031
20032 default:
20033 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20034 break;
20035 }
20036
20037 if (!ffesta_is_inhibited ())
20038 ffestc_R547_finish ();
20039 ffelex_token_kill (ffesta_tokens[1]);
20040 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20041 }
20042
20043 /* ffestb_R5474_ -- "COMMON" [SLASH NAME SLASH] or "COMMON" CONCAT
20044
20045 return ffestb_R5474_; // to lexer
20046
20047 Handle NAME. */
20048
20049 static ffelexHandler
20050 ffestb_R5474_ (ffelexToken t)
20051 {
20052 switch (ffelex_token_type (t))
20053 {
20054 case FFELEX_typeNAME:
20055 ffesta_tokens[1] = ffelex_token_use (t);
20056 return (ffelexHandler) ffestb_R5475_;
20057
20058 default:
20059 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20060 break;
20061 }
20062
20063 if (!ffesta_is_inhibited ())
20064 ffestc_R547_finish ();
20065 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20066 }
20067
20068 /* ffestb_R5475_ -- "COMMON" ... NAME
20069
20070 return ffestb_R5475_; // to lexer
20071
20072 Handle OPEN_PAREN. */
20073
20074 static ffelexHandler
20075 ffestb_R5475_ (ffelexToken t)
20076 {
20077 switch (ffelex_token_type (t))
20078 {
20079 case FFELEX_typeOPEN_PAREN:
20080 ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
20081 ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_R5476_;
20082 ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
20083 ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
20084 #ifdef FFECOM_dimensionsMAX
20085 ffestb_subrargs_.dim_list.ndims = 0;
20086 #endif
20087 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
20088 FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
20089
20090 case FFELEX_typeCOMMA:
20091 if (!ffesta_is_inhibited ())
20092 ffestc_R547_item_object (ffesta_tokens[1], NULL);
20093 ffelex_token_kill (ffesta_tokens[1]);
20094 return (ffelexHandler) ffestb_R5477_;
20095
20096 case FFELEX_typeSLASH:
20097 case FFELEX_typeCONCAT:
20098 if (!ffesta_is_inhibited ())
20099 ffestc_R547_item_object (ffesta_tokens[1], NULL);
20100 ffelex_token_kill (ffesta_tokens[1]);
20101 return (ffelexHandler) ffestb_R5471_ (t);
20102
20103 case FFELEX_typeEOS:
20104 case FFELEX_typeSEMICOLON:
20105 if (!ffesta_is_inhibited ())
20106 {
20107 ffestc_R547_item_object (ffesta_tokens[1], NULL);
20108 ffestc_R547_finish ();
20109 }
20110 ffelex_token_kill (ffesta_tokens[1]);
20111 return (ffelexHandler) ffesta_zero (t);
20112
20113 default:
20114 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20115 break;
20116 }
20117
20118 if (!ffesta_is_inhibited ())
20119 ffestc_R547_finish ();
20120 ffelex_token_kill (ffesta_tokens[1]);
20121 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20122 }
20123
20124 /* ffestb_R5476_ -- "COMMON" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
20125
20126 return ffestb_R5476_; // to lexer
20127
20128 Handle COMMA, SLASH, CONCAT, EOS/SEMICOLON. */
20129
20130 static ffelexHandler
20131 ffestb_R5476_ (ffelexToken t)
20132 {
20133 if (!ffestb_subrargs_.dim_list.ok)
20134 goto bad; /* :::::::::::::::::::: */
20135
20136 switch (ffelex_token_type (t))
20137 {
20138 case FFELEX_typeCOMMA:
20139 ffesta_confirmed ();
20140 if (!ffesta_is_inhibited ())
20141 {
20142 if (!ffestb_local_.common.started)
20143 {
20144 ffestc_R547_start ();
20145 ffestb_local_.common.started = TRUE;
20146 }
20147 ffestc_R547_item_object (ffesta_tokens[1],
20148 ffestb_subrargs_.dim_list.dims);
20149 }
20150 ffelex_token_kill (ffesta_tokens[1]);
20151 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20152 return (ffelexHandler) ffestb_R5477_;
20153
20154 case FFELEX_typeSLASH:
20155 case FFELEX_typeCONCAT:
20156 ffesta_confirmed ();
20157 if (!ffesta_is_inhibited ())
20158 {
20159 if (!ffestb_local_.common.started)
20160 {
20161 ffestc_R547_start ();
20162 ffestb_local_.common.started = TRUE;
20163 }
20164 ffestc_R547_item_object (ffesta_tokens[1],
20165 ffestb_subrargs_.dim_list.dims);
20166 }
20167 ffelex_token_kill (ffesta_tokens[1]);
20168 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20169 return (ffelexHandler) ffestb_R5471_ (t);
20170
20171 case FFELEX_typeEOS:
20172 case FFELEX_typeSEMICOLON:
20173 ffesta_confirmed ();
20174 if (!ffesta_is_inhibited ())
20175 {
20176 if (!ffestb_local_.common.started)
20177 ffestc_R547_start ();
20178 ffestc_R547_item_object (ffesta_tokens[1],
20179 ffestb_subrargs_.dim_list.dims);
20180 ffestc_R547_finish ();
20181 }
20182 ffelex_token_kill (ffesta_tokens[1]);
20183 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20184 return (ffelexHandler) ffesta_zero (t);
20185
20186 default:
20187 break;
20188 }
20189
20190 bad: /* :::::::::::::::::::: */
20191 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20192 if (ffestb_local_.common.started && !ffesta_is_inhibited ())
20193 ffestc_R547_finish ();
20194 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20195 ffelex_token_kill (ffesta_tokens[1]);
20196 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20197 }
20198
20199 /* ffestb_R5477_ -- "COMMON" ... COMMA
20200
20201 return ffestb_R5477_; // to lexer
20202
20203 Make sure we don't have EOS or SEMICOLON. */
20204
20205 static ffelexHandler
20206 ffestb_R5477_ (ffelexToken t)
20207 {
20208 switch (ffelex_token_type (t))
20209 {
20210 case FFELEX_typeEOS:
20211 case FFELEX_typeSEMICOLON:
20212 if (!ffesta_is_inhibited ())
20213 ffestc_R547_finish ();
20214 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20215 return (ffelexHandler) ffesta_zero (t);
20216
20217 default:
20218 return (ffelexHandler) ffestb_R5471_ (t);
20219 }
20220 }
20221
20222 /* ffestb_R624 -- Parse a NULLIFY statement
20223
20224 return ffestb_R624; // to lexer
20225
20226 Make sure the statement has a valid form for a NULLIFY
20227 statement. If it does, implement the statement.
20228
20229 31-May-90 JCB 2.0
20230 Rewrite to produce a list of expressions rather than just names; this
20231 eases semantic checking, putting it in expression handling where that
20232 kind of thing gets done anyway, and makes it easier to support more
20233 flexible extensions to Fortran 90 like NULLIFY(FOO%BAR). */
20234
20235 #if FFESTR_F90
20236 ffelexHandler
20237 ffestb_R624 (ffelexToken t)
20238 {
20239 switch (ffelex_token_type (ffesta_tokens[0]))
20240 {
20241 case FFELEX_typeNAME:
20242 if (ffesta_first_kw != FFESTR_firstNULLIFY)
20243 goto bad_0; /* :::::::::::::::::::: */
20244 break;
20245
20246 case FFELEX_typeNAMES:
20247 if (ffesta_first_kw != FFESTR_firstNULLIFY)
20248 goto bad_0; /* :::::::::::::::::::: */
20249 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlNULLIFY)
20250 goto bad_0; /* :::::::::::::::::::: */
20251 break;
20252
20253 default:
20254 goto bad_0; /* :::::::::::::::::::: */
20255 }
20256
20257 switch (ffelex_token_type (t))
20258 {
20259 case FFELEX_typeOPEN_PAREN:
20260 break;
20261
20262 case FFELEX_typeEOS:
20263 case FFELEX_typeSEMICOLON:
20264 case FFELEX_typeCOMMA:
20265 case FFELEX_typeCOLONCOLON:
20266 case FFELEX_typeNAME:
20267 ffesta_confirmed (); /* Error, but clearly intended. */
20268 goto bad_1; /* :::::::::::::::::::: */
20269
20270 default:
20271 goto bad_1; /* :::::::::::::::::::: */
20272 }
20273
20274 ffestb_local_.R624.exprs = ffestt_exprlist_create ();
20275 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
20276 FFEEXPR_contextNULLIFY,
20277 (ffeexprCallback) ffestb_R6241_);
20278
20279 bad_0: /* :::::::::::::::::::: */
20280 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", ffesta_tokens[0]);
20281 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20282
20283 bad_1: /* :::::::::::::::::::: */
20284 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
20285 return (ffelexHandler) ffelex_swallow_tokens (t,
20286 (ffelexHandler) ffesta_zero); /* Invalid second token. */
20287 }
20288
20289 /* ffestb_R6241_ -- "NULLIFY" OPEN_PAREN expr
20290
20291 return ffestb_R6241_; // to lexer
20292
20293 Make sure the statement has a valid form for a NULLIFY statement. If it
20294 does, implement the statement.
20295
20296 31-May-90 JCB 2.0
20297 Rewrite to produce a list of expressions rather than just names; this
20298 eases semantic checking, putting it in expression handling where that
20299 kind of thing gets done anyway, and makes it easier to support more
20300 flexible extensions to Fortran 90 like NULLIFY(FOO%BAR). */
20301
20302 static ffelexHandler
20303 ffestb_R6241_ (ffelexToken ft, ffebld expr, ffelexToken t)
20304 {
20305 switch (ffelex_token_type (t))
20306 {
20307 case FFELEX_typeCLOSE_PAREN:
20308 if (expr == NULL)
20309 break;
20310 ffestt_exprlist_append (ffestb_local_.R624.exprs, expr,
20311 ffelex_token_use (t));
20312 return (ffelexHandler) ffestb_R6242_;
20313
20314 case FFELEX_typeCOMMA:
20315 if (expr == NULL)
20316 break;
20317 ffestt_exprlist_append (ffestb_local_.R624.exprs, expr,
20318 ffelex_token_use (t));
20319 return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
20320 FFEEXPR_contextNULLIFY,
20321 (ffeexprCallback) ffestb_R6241_);
20322
20323 default:
20324 break;
20325 }
20326
20327 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
20328 ffestt_exprlist_kill (ffestb_local_.R624.exprs);
20329 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20330 }
20331
20332 /* ffestb_R6242_ -- "NULLIFY" OPEN_PAREN expr-list CLOSE_PAREN
20333
20334 return ffestb_R6242_; // to lexer
20335
20336 Make sure the statement has a valid form for a NULLIFY statement. If it
20337 does, implement the statement. */
20338
20339 static ffelexHandler
20340 ffestb_R6242_ (ffelexToken t)
20341 {
20342 switch (ffelex_token_type (t))
20343 {
20344 case FFELEX_typeEOS:
20345 case FFELEX_typeSEMICOLON:
20346 ffesta_confirmed ();
20347 if (!ffesta_is_inhibited ())
20348 ffestc_R624 (ffestb_local_.R624.exprs);
20349 ffestt_exprlist_kill (ffestb_local_.R624.exprs);
20350 return (ffelexHandler) ffesta_zero (t);
20351
20352 default:
20353 break;
20354 }
20355
20356 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
20357 ffestt_exprlist_kill (ffestb_local_.R624.exprs);
20358 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20359 }
20360
20361 #endif
20362 /* ffestb_R1229 -- Parse a STMTFUNCTION statement
20363
20364 return ffestb_R1229; // to lexer
20365
20366 Make sure the statement has a valid form for a STMTFUNCTION
20367 statement. If it does, implement the statement. */
20368
20369 ffelexHandler
20370 ffestb_R1229 (ffelexToken t)
20371 {
20372 switch (ffelex_token_type (ffesta_tokens[0]))
20373 {
20374 case FFELEX_typeNAME:
20375 case FFELEX_typeNAMES:
20376 break;
20377
20378 default:
20379 goto bad_0; /* :::::::::::::::::::: */
20380 }
20381
20382 switch (ffelex_token_type (t))
20383 {
20384 case FFELEX_typeOPEN_PAREN:
20385 break;
20386
20387 case FFELEX_typeEOS:
20388 case FFELEX_typeSEMICOLON:
20389 case FFELEX_typeCOMMA:
20390 case FFELEX_typeCOLONCOLON:
20391 case FFELEX_typeNAME:
20392 ffesta_confirmed (); /* Error, but clearly intended. */
20393 goto bad_1; /* :::::::::::::::::::: */
20394
20395 default:
20396 goto bad_1; /* :::::::::::::::::::: */
20397 }
20398
20399 ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
20400 ffestb_subrargs_.name_list.handler = (ffelexHandler) ffestb_R12291_;
20401 ffestb_subrargs_.name_list.is_subr = FALSE; /* No "*" items in list! */
20402 ffestb_subrargs_.name_list.names = TRUE; /* In case "IF(FOO)CALL
20403 FOO...". */
20404 return (ffelexHandler) ffestb_subr_name_list_;
20405
20406 bad_0: /* :::::::::::::::::::: */
20407 bad_1: /* :::::::::::::::::::: */
20408 ffesta_ffebad_2t (FFEBAD_UNREC_STMT, ffesta_tokens[0], t);
20409 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20410 }
20411
20412 /* ffestb_R12291_ -- "STMTFUNCTION" OPEN_PAREN dummy-name-list CLOSE_PAREN
20413
20414 return ffestb_R12291_; // to lexer
20415
20416 Make sure the statement has a valid form for a STMTFUNCTION statement. If
20417 it does, implement the statement. */
20418
20419 static ffelexHandler
20420 ffestb_R12291_ (ffelexToken t)
20421 {
20422 ffelex_set_names (FALSE);
20423
20424 if (!ffestb_subrargs_.name_list.ok)
20425 goto bad; /* :::::::::::::::::::: */
20426
20427 switch (ffelex_token_type (t))
20428 {
20429 case FFELEX_typeEQUALS:
20430 ffesta_confirmed ();
20431 if (!ffesta_is_inhibited ())
20432 ffestc_R1229_start (ffesta_tokens[0],
20433 ffestb_subrargs_.name_list.args,
20434 ffestb_subrargs_.name_list.close_paren);
20435 ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
20436 ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
20437 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
20438 FFEEXPR_contextSFUNCDEF, (ffeexprCallback) ffestb_R12292_);
20439
20440 default:
20441 break;
20442 }
20443
20444 bad: /* :::::::::::::::::::: */
20445 ffesta_ffebad_2t (FFEBAD_UNREC_STMT, ffesta_tokens[0], t);
20446 ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
20447 ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
20448 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20449 }
20450
20451 /* ffestb_R12292_ -- "STMTFUNCTION" OPEN_PAREN dummy-name-list CLOSE_PAREN
20452 EQUALS expr
20453
20454 (ffestb_R12292_) // to expression handler
20455
20456 Make sure the statement has a valid form for a STMTFUNCTION statement. If
20457 it does, implement the statement. */
20458
20459 static ffelexHandler
20460 ffestb_R12292_ (ffelexToken ft, ffebld expr, ffelexToken t)
20461 {
20462 if (expr == NULL)
20463 goto bad; /* :::::::::::::::::::: */
20464
20465 switch (ffelex_token_type (t))
20466 {
20467 case FFELEX_typeEOS:
20468 case FFELEX_typeSEMICOLON:
20469 if (!ffesta_is_inhibited ())
20470 ffestc_R1229_finish (expr, ft);
20471 return (ffelexHandler) ffesta_zero (t);
20472
20473 default:
20474 break;
20475 }
20476
20477 bad: /* :::::::::::::::::::: */
20478 ffestc_R1229_finish (NULL, NULL);
20479 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "statement-function-definition", t);
20480 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20481 }
20482
20483 /* ffestb_decl_chartype -- Parse the CHARACTER statement
20484
20485 return ffestb_decl_chartype; // to lexer
20486
20487 Make sure the statement has a valid form for the CHARACTER statement. If
20488 it does, implement the statement. */
20489
20490 ffelexHandler
20491 ffestb_decl_chartype (ffelexToken t)
20492 {
20493 ffeTokenLength i;
20494 unsigned const char *p;
20495
20496 ffestb_local_.decl.type = FFESTP_typeCHARACTER;
20497 ffestb_local_.decl.recursive = NULL;
20498 ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20499 ffestb_local_.decl.coloncolon = FALSE; /* No COLONCOLON seen. */
20500
20501 switch (ffelex_token_type (ffesta_tokens[0]))
20502 {
20503 case FFELEX_typeNAME:
20504 if (ffesta_first_kw != FFESTR_firstCHRCTR)
20505 goto bad_0; /* :::::::::::::::::::: */
20506 switch (ffelex_token_type (t))
20507 {
20508 case FFELEX_typeEOS:
20509 case FFELEX_typeSEMICOLON:
20510 ffesta_confirmed (); /* Error, but clearly intended. */
20511 goto bad_1; /* :::::::::::::::::::: */
20512
20513 default:
20514 goto bad_1; /* :::::::::::::::::::: */
20515
20516 case FFELEX_typeCOMMA:
20517 ffesta_confirmed ();
20518 if (!ffesta_is_inhibited ())
20519 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20520 NULL, NULL, NULL, NULL);
20521 return (ffelexHandler) ffestb_decl_attrs_;
20522
20523 case FFELEX_typeCOLONCOLON:
20524 ffestb_local_.decl.coloncolon = TRUE;
20525 ffesta_confirmed ();
20526 if (!ffesta_is_inhibited ())
20527 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20528 NULL, NULL, NULL, NULL);
20529 return (ffelexHandler) ffestb_decl_ents_;
20530
20531 case FFELEX_typeASTERISK:
20532 ffesta_confirmed ();
20533 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_chartype1_;
20534 ffestb_local_.decl.badname = "TYPEDECL";
20535 return (ffelexHandler) ffestb_decl_starlen_;
20536
20537 case FFELEX_typeOPEN_PAREN:
20538 ffestb_local_.decl.kind = NULL;
20539 ffestb_local_.decl.kindt = NULL;
20540 ffestb_local_.decl.len = NULL;
20541 ffestb_local_.decl.lent = NULL;
20542 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20543 ffestb_local_.decl.badname = "_TYPEDECL";
20544 return (ffelexHandler) ffestb_decl_typeparams_;
20545
20546 case FFELEX_typeNAME:
20547 ffesta_confirmed ();
20548 ffestb_local_.decl.kind = NULL;
20549 ffestb_local_.decl.kindt = NULL;
20550 ffestb_local_.decl.len = NULL;
20551 ffestb_local_.decl.lent = NULL;
20552 return (ffelexHandler) ffestb_decl_entsp_ (t);
20553 }
20554
20555 case FFELEX_typeNAMES:
20556 if (ffesta_first_kw != FFESTR_firstCHRCTR)
20557 goto bad_0; /* :::::::::::::::::::: */
20558 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCHRCTR);
20559 switch (ffelex_token_type (t))
20560 {
20561 default:
20562 goto bad_1; /* :::::::::::::::::::: */
20563
20564 case FFELEX_typeEOS:
20565 case FFELEX_typeSEMICOLON:
20566 ffesta_confirmed ();
20567 break;
20568
20569 case FFELEX_typeCOMMA:
20570 ffesta_confirmed ();
20571 if (*p != '\0')
20572 break;
20573 if (!ffesta_is_inhibited ())
20574 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20575 NULL, NULL, NULL, NULL);
20576 return (ffelexHandler) ffestb_decl_attrs_;
20577
20578 case FFELEX_typeCOLONCOLON:
20579 ffestb_local_.decl.coloncolon = TRUE;
20580 ffesta_confirmed ();
20581 if (*p != '\0')
20582 goto bad_i; /* :::::::::::::::::::: */
20583 if (!ffesta_is_inhibited ())
20584 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20585 NULL, NULL, NULL, NULL);
20586 return (ffelexHandler) ffestb_decl_ents_;
20587
20588 case FFELEX_typeASTERISK:
20589 ffesta_confirmed ();
20590 if (*p != '\0')
20591 break;
20592 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_chartype1_;
20593 ffestb_local_.decl.badname = "TYPEDECL";
20594 return (ffelexHandler) ffestb_decl_starlen_;
20595
20596 case FFELEX_typeSLASH:
20597 ffesta_confirmed ();
20598 if (*p != '\0')
20599 break;
20600 goto bad_1; /* :::::::::::::::::::: */
20601
20602 case FFELEX_typeOPEN_PAREN:
20603 if (*p != '\0')
20604 break;
20605 ffestb_local_.decl.kind = NULL;
20606 ffestb_local_.decl.kindt = NULL;
20607 ffestb_local_.decl.len = NULL;
20608 ffestb_local_.decl.lent = NULL;
20609 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20610 ffestb_local_.decl.badname = "TYPEDECL";
20611 return (ffelexHandler) ffestb_decl_typeparams_;
20612 }
20613 if (!ffesrc_is_name_init (*p))
20614 goto bad_i; /* :::::::::::::::::::: */
20615 ffestb_local_.decl.kind = NULL;
20616 ffestb_local_.decl.kindt = NULL;
20617 ffestb_local_.decl.len = NULL;
20618 ffestb_local_.decl.lent = NULL;
20619 ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
20620 return (ffelexHandler) ffestb_decl_entsp_2_ (t);
20621
20622 default:
20623 goto bad_0; /* :::::::::::::::::::: */
20624 }
20625
20626 bad_0: /* :::::::::::::::::::: */
20627 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20628 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20629
20630 bad_1: /* :::::::::::::::::::: */
20631 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20632 return (ffelexHandler) ffelex_swallow_tokens (t,
20633 (ffelexHandler) ffesta_zero); /* Invalid second token. */
20634
20635 bad_i: /* :::::::::::::::::::: */
20636 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
20637 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20638 }
20639
20640 /* ffestb_decl_chartype1_ -- "CHARACTER" ASTERISK char-length
20641
20642 return ffestb_decl_chartype1_; // to lexer
20643
20644 Handle COMMA, COLONCOLON, or anything else. */
20645
20646 static ffelexHandler
20647 ffestb_decl_chartype1_ (ffelexToken t)
20648 {
20649 ffelex_set_names (FALSE);
20650
20651 switch (ffelex_token_type (t))
20652 {
20653 case FFELEX_typeCOLONCOLON:
20654 ffestb_local_.decl.coloncolon = TRUE;
20655 /* Fall through. */
20656 case FFELEX_typeCOMMA:
20657 ffesta_confirmed ();
20658 if (!ffesta_is_inhibited ())
20659 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20660 NULL, NULL, ffestb_local_.decl.len, ffestb_local_.decl.lent);
20661 if (ffestb_local_.decl.lent != NULL)
20662 ffelex_token_kill (ffestb_local_.decl.lent);
20663 return (ffelexHandler) ffestb_decl_ents_;
20664
20665 default:
20666 return (ffelexHandler) ffestb_decl_entsp_ (t);
20667 }
20668 }
20669
20670 /* ffestb_decl_dbltype -- Parse the DOUBLEPRECISION/DOUBLECOMPLEX statement
20671
20672 return ffestb_decl_dbltype; // to lexer
20673
20674 Make sure the statement has a valid form for the DOUBLEPRECISION/
20675 DOUBLECOMPLEX statement. If it does, implement the statement. */
20676
20677 ffelexHandler
20678 ffestb_decl_dbltype (ffelexToken t)
20679 {
20680 ffeTokenLength i;
20681 unsigned const char *p;
20682
20683 ffestb_local_.decl.type = ffestb_args.decl.type;
20684 ffestb_local_.decl.recursive = NULL;
20685 ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20686 ffestb_local_.decl.coloncolon = FALSE; /* No COLONCOLON seen. */
20687
20688 switch (ffelex_token_type (ffesta_tokens[0]))
20689 {
20690 case FFELEX_typeNAME:
20691 switch (ffelex_token_type (t))
20692 {
20693 case FFELEX_typeEOS:
20694 case FFELEX_typeSEMICOLON:
20695 ffesta_confirmed (); /* Error, but clearly intended. */
20696 goto bad_1; /* :::::::::::::::::::: */
20697
20698 default:
20699 goto bad_1; /* :::::::::::::::::::: */
20700
20701 case FFELEX_typeCOMMA:
20702 ffesta_confirmed ();
20703 if (!ffesta_is_inhibited ())
20704 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20705 NULL, NULL, NULL, NULL);
20706 return (ffelexHandler) ffestb_decl_attrs_;
20707
20708 case FFELEX_typeCOLONCOLON:
20709 ffestb_local_.decl.coloncolon = TRUE;
20710 ffesta_confirmed ();
20711 if (!ffesta_is_inhibited ())
20712 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20713 NULL, NULL, NULL, NULL);
20714 return (ffelexHandler) ffestb_decl_ents_;
20715
20716 case FFELEX_typeNAME:
20717 ffesta_confirmed ();
20718 ffestb_local_.decl.kind = NULL;
20719 ffestb_local_.decl.kindt = NULL;
20720 ffestb_local_.decl.len = NULL;
20721 ffestb_local_.decl.lent = NULL;
20722 return (ffelexHandler) ffestb_decl_entsp_ (t);
20723 }
20724
20725 case FFELEX_typeNAMES:
20726 p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.decl.len);
20727 switch (ffelex_token_type (t))
20728 {
20729 default:
20730 goto bad_1; /* :::::::::::::::::::: */
20731
20732 case FFELEX_typeEOS:
20733 case FFELEX_typeSEMICOLON:
20734 ffesta_confirmed ();
20735 break;
20736
20737 case FFELEX_typeCOMMA:
20738 ffesta_confirmed ();
20739 if (*p != '\0')
20740 break;
20741 if (!ffesta_is_inhibited ())
20742 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20743 NULL, NULL, NULL, NULL);
20744 return (ffelexHandler) ffestb_decl_attrs_;
20745
20746 case FFELEX_typeCOLONCOLON:
20747 ffestb_local_.decl.coloncolon = TRUE;
20748 ffesta_confirmed ();
20749 if (*p != '\0')
20750 goto bad_i; /* :::::::::::::::::::: */
20751 if (!ffesta_is_inhibited ())
20752 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20753 NULL, NULL, NULL, NULL);
20754 return (ffelexHandler) ffestb_decl_ents_;
20755
20756 case FFELEX_typeSLASH:
20757 ffesta_confirmed ();
20758 if (*p != '\0')
20759 break;
20760 goto bad_1; /* :::::::::::::::::::: */
20761
20762 case FFELEX_typeOPEN_PAREN:
20763 if (*p != '\0')
20764 break;
20765 goto bad_1; /* :::::::::::::::::::: */
20766 }
20767 if (!ffesrc_is_name_init (*p))
20768 goto bad_i; /* :::::::::::::::::::: */
20769 ffestb_local_.decl.kind = NULL;
20770 ffestb_local_.decl.kindt = NULL;
20771 ffestb_local_.decl.len = NULL;
20772 ffestb_local_.decl.lent = NULL;
20773 ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
20774 return (ffelexHandler) ffestb_decl_entsp_2_ (t);
20775
20776 default:
20777 goto bad_0; /* :::::::::::::::::::: */
20778 }
20779
20780 bad_0: /* :::::::::::::::::::: */
20781 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20782 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20783
20784 bad_1: /* :::::::::::::::::::: */
20785 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20786 return (ffelexHandler) ffelex_swallow_tokens (t,
20787 (ffelexHandler) ffesta_zero); /* Invalid second token. */
20788
20789 bad_i: /* :::::::::::::::::::: */
20790 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
20791 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20792 }
20793
20794 /* ffestb_decl_double -- Parse the DOUBLE PRECISION/DOUBLE COMPLEX statement
20795
20796 return ffestb_decl_double; // to lexer
20797
20798 Make sure the statement has a valid form for the DOUBLE PRECISION/
20799 DOUBLE COMPLEX statement. If it does, implement the statement. */
20800
20801 ffelexHandler
20802 ffestb_decl_double (ffelexToken t)
20803 {
20804 ffestb_local_.decl.recursive = NULL;
20805 ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20806 ffestb_local_.decl.coloncolon = FALSE; /* No COLONCOLON seen. */
20807
20808 switch (ffelex_token_type (ffesta_tokens[0]))
20809 {
20810 case FFELEX_typeNAME:
20811 if (ffesta_first_kw != FFESTR_firstDBL)
20812 goto bad_0; /* :::::::::::::::::::: */
20813 switch (ffelex_token_type (t))
20814 {
20815 case FFELEX_typeEOS:
20816 case FFELEX_typeSEMICOLON:
20817 case FFELEX_typeCOMMA:
20818 case FFELEX_typeCOLONCOLON:
20819 ffesta_confirmed (); /* Error, but clearly intended. */
20820 goto bad_1; /* :::::::::::::::::::: */
20821
20822 default:
20823 goto bad_1; /* :::::::::::::::::::: */
20824
20825 case FFELEX_typeNAME:
20826 ffesta_confirmed ();
20827 switch (ffestr_second (t))
20828 {
20829 case FFESTR_secondCOMPLEX:
20830 ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
20831 break;
20832
20833 case FFESTR_secondPRECISION:
20834 ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
20835 break;
20836
20837 default:
20838 goto bad_1; /* :::::::::::::::::::: */
20839 }
20840 ffestb_local_.decl.kind = NULL;
20841 ffestb_local_.decl.kindt = NULL;
20842 ffestb_local_.decl.len = NULL;
20843 ffestb_local_.decl.lent = NULL;
20844 return (ffelexHandler) ffestb_decl_attrsp_;
20845 }
20846
20847 default:
20848 goto bad_0; /* :::::::::::::::::::: */
20849 }
20850
20851 bad_0: /* :::::::::::::::::::: */
20852 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20853 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20854
20855 bad_1: /* :::::::::::::::::::: */
20856 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20857 return (ffelexHandler) ffelex_swallow_tokens (t,
20858 (ffelexHandler) ffesta_zero); /* Invalid second token. */
20859 }
20860
20861 /* ffestb_decl_gentype -- Parse the INTEGER/REAL/COMPLEX/LOGICAL statement
20862
20863 return ffestb_decl_gentype; // to lexer
20864
20865 Make sure the statement has a valid form for the INTEGER/REAL/COMPLEX/
20866 LOGICAL statement. If it does, implement the statement. */
20867
20868 ffelexHandler
20869 ffestb_decl_gentype (ffelexToken t)
20870 {
20871 ffeTokenLength i;
20872 unsigned const char *p;
20873
20874 ffestb_local_.decl.type = ffestb_args.decl.type;
20875 ffestb_local_.decl.recursive = NULL;
20876 ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20877 ffestb_local_.decl.coloncolon = FALSE; /* No COLONCOLON seen. */
20878
20879 switch (ffelex_token_type (ffesta_tokens[0]))
20880 {
20881 case FFELEX_typeNAME:
20882 switch (ffelex_token_type (t))
20883 {
20884 case FFELEX_typeEOS:
20885 case FFELEX_typeSEMICOLON:
20886 ffesta_confirmed (); /* Error, but clearly intended. */
20887 goto bad_1; /* :::::::::::::::::::: */
20888
20889 default:
20890 goto bad_1; /* :::::::::::::::::::: */
20891
20892 case FFELEX_typeCOMMA:
20893 ffesta_confirmed ();
20894 if (!ffesta_is_inhibited ())
20895 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20896 NULL, NULL, NULL, NULL);
20897 return (ffelexHandler) ffestb_decl_attrs_;
20898
20899 case FFELEX_typeCOLONCOLON:
20900 ffestb_local_.decl.coloncolon = TRUE;
20901 ffesta_confirmed ();
20902 if (!ffesta_is_inhibited ())
20903 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20904 NULL, NULL, NULL, NULL);
20905 return (ffelexHandler) ffestb_decl_ents_;
20906
20907 case FFELEX_typeASTERISK:
20908 ffesta_confirmed ();
20909 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20910 ffestb_local_.decl.badname = "TYPEDECL";
20911 return (ffelexHandler) ffestb_decl_starkind_;
20912
20913 case FFELEX_typeOPEN_PAREN:
20914 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20915 ffestb_local_.decl.badname = "TYPEDECL";
20916 return (ffelexHandler) ffestb_decl_kindparam_;
20917
20918 case FFELEX_typeNAME:
20919 ffesta_confirmed ();
20920 ffestb_local_.decl.kind = NULL;
20921 ffestb_local_.decl.kindt = NULL;
20922 ffestb_local_.decl.len = NULL;
20923 ffestb_local_.decl.lent = NULL;
20924 return (ffelexHandler) ffestb_decl_entsp_ (t);
20925 }
20926
20927 case FFELEX_typeNAMES:
20928 p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.decl.len);
20929 switch (ffelex_token_type (t))
20930 {
20931 default:
20932 goto bad_1; /* :::::::::::::::::::: */
20933
20934 case FFELEX_typeEOS:
20935 case FFELEX_typeSEMICOLON:
20936 ffesta_confirmed ();
20937 break;
20938
20939 case FFELEX_typeCOMMA:
20940 ffesta_confirmed ();
20941 if (*p != '\0')
20942 break;
20943 if (!ffesta_is_inhibited ())
20944 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20945 NULL, NULL, NULL, NULL);
20946 return (ffelexHandler) ffestb_decl_attrs_;
20947
20948 case FFELEX_typeCOLONCOLON:
20949 ffestb_local_.decl.coloncolon = TRUE;
20950 ffesta_confirmed ();
20951 if (*p != '\0')
20952 goto bad_i; /* :::::::::::::::::::: */
20953 if (!ffesta_is_inhibited ())
20954 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20955 NULL, NULL, NULL, NULL);
20956 return (ffelexHandler) ffestb_decl_ents_;
20957
20958 case FFELEX_typeSLASH:
20959 ffesta_confirmed ();
20960 if (*p != '\0')
20961 break;
20962 goto bad_1; /* :::::::::::::::::::: */
20963
20964 case FFELEX_typeASTERISK:
20965 ffesta_confirmed ();
20966 if (*p != '\0')
20967 break;
20968 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20969 ffestb_local_.decl.badname = "TYPEDECL";
20970 return (ffelexHandler) ffestb_decl_starkind_;
20971
20972 case FFELEX_typeOPEN_PAREN:
20973 if (*p != '\0')
20974 break;
20975 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20976 ffestb_local_.decl.badname = "TYPEDECL";
20977 return (ffelexHandler) ffestb_decl_kindparam_;
20978 }
20979 if (!ffesrc_is_name_init (*p))
20980 goto bad_i; /* :::::::::::::::::::: */
20981 ffestb_local_.decl.kind = NULL;
20982 ffestb_local_.decl.kindt = NULL;
20983 ffestb_local_.decl.len = NULL;
20984 ffestb_local_.decl.lent = NULL;
20985 ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
20986 return (ffelexHandler) ffestb_decl_entsp_2_ (t);
20987
20988 default:
20989 goto bad_0; /* :::::::::::::::::::: */
20990 }
20991
20992 bad_0: /* :::::::::::::::::::: */
20993 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20994 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20995
20996 bad_1: /* :::::::::::::::::::: */
20997 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20998 return (ffelexHandler) ffelex_swallow_tokens (t,
20999 (ffelexHandler) ffesta_zero); /* Invalid second token. */
21000
21001 bad_i: /* :::::::::::::::::::: */
21002 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
21003 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21004 }
21005
21006 /* ffestb_decl_recursive -- Parse the RECURSIVE FUNCTION statement
21007
21008 return ffestb_decl_recursive; // to lexer
21009
21010 Make sure the statement has a valid form for the RECURSIVE FUNCTION
21011 statement. If it does, implement the statement. */
21012
21013 #if FFESTR_F90
21014 ffelexHandler
21015 ffestb_decl_recursive (ffelexToken t)
21016 {
21017 ffeTokenLength i;
21018 const char *p;
21019 ffelexToken nt;
21020 ffelexToken ot;
21021 ffelexHandler next;
21022 bool needfunc;
21023
21024 switch (ffelex_token_type (ffesta_tokens[0]))
21025 {
21026 case FFELEX_typeNAME:
21027 if (ffesta_first_kw != FFESTR_firstRECURSIVE)
21028 goto bad_0; /* :::::::::::::::::::: */
21029 switch (ffelex_token_type (t))
21030 {
21031 case FFELEX_typeEOS:
21032 case FFELEX_typeSEMICOLON:
21033 case FFELEX_typeCOMMA:
21034 case FFELEX_typeCOLONCOLON:
21035 ffesta_confirmed (); /* Error, but clearly intended. */
21036 goto bad_1; /* :::::::::::::::::::: */
21037
21038 default:
21039 goto bad_1; /* :::::::::::::::::::: */
21040
21041 case FFELEX_typeNAME:
21042 break;
21043 }
21044 ffesta_confirmed ();
21045 ffestb_local_.decl.recursive = ffelex_token_use (ffesta_tokens[0]);
21046 switch (ffesta_second_kw)
21047 {
21048 case FFESTR_secondINTEGER:
21049 ffestb_local_.decl.type = FFESTP_typeINTEGER;
21050 return (ffelexHandler) ffestb_decl_recursive1_;
21051
21052 case FFESTR_secondBYTE:
21053 ffestb_local_.decl.type = FFESTP_typeBYTE;
21054 return (ffelexHandler) ffestb_decl_recursive1_;
21055
21056 case FFESTR_secondWORD:
21057 ffestb_local_.decl.type = FFESTP_typeWORD;
21058 return (ffelexHandler) ffestb_decl_recursive1_;
21059
21060 case FFESTR_secondREAL:
21061 ffestb_local_.decl.type = FFESTP_typeREAL;
21062 return (ffelexHandler) ffestb_decl_recursive1_;
21063
21064 case FFESTR_secondCOMPLEX:
21065 ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
21066 return (ffelexHandler) ffestb_decl_recursive1_;
21067
21068 case FFESTR_secondLOGICAL:
21069 ffestb_local_.decl.type = FFESTP_typeLOGICAL;
21070 return (ffelexHandler) ffestb_decl_recursive1_;
21071
21072 case FFESTR_secondCHARACTER:
21073 ffestb_local_.decl.type = FFESTP_typeCHARACTER;
21074 return (ffelexHandler) ffestb_decl_recursive1_;
21075
21076 case FFESTR_secondDOUBLE:
21077 return (ffelexHandler) ffestb_decl_recursive2_;
21078
21079 case FFESTR_secondDOUBLEPRECISION:
21080 ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
21081 ffestb_local_.decl.kind = NULL;
21082 ffestb_local_.decl.kindt = NULL;
21083 ffestb_local_.decl.len = NULL;
21084 ffestb_local_.decl.lent = NULL;
21085 return (ffelexHandler) ffestb_decl_func_;
21086
21087 case FFESTR_secondDOUBLECOMPLEX:
21088 ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
21089 ffestb_local_.decl.kind = NULL;
21090 ffestb_local_.decl.kindt = NULL;
21091 ffestb_local_.decl.len = NULL;
21092 ffestb_local_.decl.lent = NULL;
21093 return (ffelexHandler) ffestb_decl_func_;
21094
21095 case FFESTR_secondTYPE:
21096 ffestb_local_.decl.type = FFESTP_typeTYPE;
21097 return (ffelexHandler) ffestb_decl_recursive3_;
21098
21099 case FFESTR_secondFUNCTION:
21100 ffestb_local_.dummy.first_kw = FFESTR_firstFUNCTION;
21101 ffestb_local_.dummy.badname = "FUNCTION";
21102 ffestb_local_.dummy.is_subr = FALSE;
21103 return (ffelexHandler) ffestb_decl_recursive4_;
21104
21105 case FFESTR_secondSUBROUTINE:
21106 ffestb_local_.dummy.first_kw = FFESTR_firstSUBROUTINE;
21107 ffestb_local_.dummy.badname = "SUBROUTINE";
21108 ffestb_local_.dummy.is_subr = TRUE;
21109 return (ffelexHandler) ffestb_decl_recursive4_;
21110
21111 default:
21112 ffelex_token_kill (ffestb_local_.decl.recursive);
21113 goto bad_1; /* :::::::::::::::::::: */
21114 }
21115
21116 case FFELEX_typeNAMES:
21117 if (ffesta_first_kw != FFESTR_firstRECURSIVE)
21118 goto bad_0; /* :::::::::::::::::::: */
21119 switch (ffelex_token_type (t))
21120 {
21121 case FFELEX_typeCOMMA:
21122 case FFELEX_typeCOLONCOLON:
21123 case FFELEX_typeASTERISK:
21124 case FFELEX_typeSEMICOLON:
21125 case FFELEX_typeEOS:
21126 ffesta_confirmed ();
21127 break;
21128
21129 default:
21130 break;
21131 }
21132 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlRECURSIVE);
21133 if (!ffesrc_is_name_init (*p))
21134 goto bad_0; /* :::::::::::::::::::: */
21135 ffestb_local_.decl.recursive
21136 = ffelex_token_name_from_names (ffesta_tokens[0], 0,
21137 FFESTR_firstlRECURSIVE);
21138 nt = ffelex_token_names_from_names (ffesta_tokens[0],
21139 FFESTR_firstlRECURSIVE, 0);
21140 switch (ffestr_first (nt))
21141 {
21142 case FFESTR_firstINTGR:
21143 p = ffelex_token_text (nt) + (i = FFESTR_firstlINTGR);
21144 ffestb_local_.decl.type = FFESTP_typeINTEGER;
21145 needfunc = FALSE;
21146 goto typefunc; /* :::::::::::::::::::: */
21147
21148 case FFESTR_firstBYTE:
21149 p = ffelex_token_text (nt) + (i = FFESTR_firstlBYTE);
21150 ffestb_local_.decl.type = FFESTP_typeBYTE;
21151 needfunc = FALSE;
21152 goto typefunc; /* :::::::::::::::::::: */
21153
21154 case FFESTR_firstWORD:
21155 p = ffelex_token_text (nt) + (i = FFESTR_firstlWORD);
21156 ffestb_local_.decl.type = FFESTP_typeWORD;
21157 needfunc = FALSE;
21158 goto typefunc; /* :::::::::::::::::::: */
21159
21160 case FFESTR_firstREAL:
21161 p = ffelex_token_text (nt) + (i = FFESTR_firstlREAL);
21162 ffestb_local_.decl.type = FFESTP_typeREAL;
21163 needfunc = FALSE;
21164 goto typefunc; /* :::::::::::::::::::: */
21165
21166 case FFESTR_firstCMPLX:
21167 p = ffelex_token_text (nt) + (i = FFESTR_firstlCMPLX);
21168 ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
21169 needfunc = FALSE;
21170 goto typefunc; /* :::::::::::::::::::: */
21171
21172 case FFESTR_firstLGCL:
21173 p = ffelex_token_text (nt) + (i = FFESTR_firstlLGCL);
21174 ffestb_local_.decl.type = FFESTP_typeLOGICAL;
21175 needfunc = FALSE;
21176 goto typefunc; /* :::::::::::::::::::: */
21177
21178 case FFESTR_firstCHRCTR:
21179 p = ffelex_token_text (nt) + (i = FFESTR_firstlCHRCTR);
21180 ffestb_local_.decl.type = FFESTP_typeCHARACTER;
21181 needfunc = FALSE;
21182 goto typefunc; /* :::::::::::::::::::: */
21183
21184 case FFESTR_firstDBLPRCSN:
21185 p = ffelex_token_text (nt) + (i = FFESTR_firstlDBLPRCSN);
21186 ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
21187 needfunc = TRUE;
21188 goto typefunc; /* :::::::::::::::::::: */
21189
21190 case FFESTR_firstDBLCMPLX:
21191 p = ffelex_token_text (nt) + (i = FFESTR_firstlDBLCMPLX);
21192 ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
21193 needfunc = TRUE;
21194 goto typefunc; /* :::::::::::::::::::: */
21195
21196 case FFESTR_firstTYPE:
21197 p = ffelex_token_text (nt) + (i = FFESTR_firstlTYPE);
21198 ffestb_local_.decl.type = FFESTP_typeTYPE;
21199 next = (ffelexHandler) ffestb_decl_recursive3_;
21200 break;
21201
21202 case FFESTR_firstFUNCTION:
21203 p = ffelex_token_text (nt) + (i = FFESTR_firstlFUNCTION);
21204 ffestb_local_.dummy.first_kw = FFESTR_firstFUNCTION;
21205 ffestb_local_.dummy.badname = "FUNCTION";
21206 ffestb_local_.dummy.is_subr = FALSE;
21207 next = (ffelexHandler) ffestb_decl_recursive4_;
21208 break;
21209
21210 case FFESTR_firstSUBROUTINE:
21211 p = ffelex_token_text (nt) + (i = FFESTR_firstlSUBROUTINE);
21212 ffestb_local_.dummy.first_kw = FFESTR_firstSUBROUTINE;
21213 ffestb_local_.dummy.badname = "SUBROUTINE";
21214 ffestb_local_.dummy.is_subr = TRUE;
21215 next = (ffelexHandler) ffestb_decl_recursive4_;
21216 break;
21217
21218 default:
21219 ffelex_token_kill (ffestb_local_.decl.recursive);
21220 ffelex_token_kill (nt);
21221 goto bad_1; /* :::::::::::::::::::: */
21222 }
21223 if (*p == '\0')
21224 {
21225 ffelex_token_kill (nt);
21226 return (ffelexHandler) (*next) (t);
21227 }
21228 if (!ffesrc_is_name_init (*p))
21229 goto bad_i; /* :::::::::::::::::::: */
21230 ot = ffelex_token_name_from_names (nt, i, 0);
21231 ffelex_token_kill (nt);
21232 next = (ffelexHandler) (*next) (ot);
21233 ffelex_token_kill (ot);
21234 return (ffelexHandler) (*next) (t);
21235
21236 default:
21237 goto bad_0; /* :::::::::::::::::::: */
21238 }
21239
21240 typefunc: /* :::::::::::::::::::: */
21241 if (*p == '\0')
21242 {
21243 ffelex_token_kill (nt);
21244 if (needfunc) /* DOUBLE PRECISION or DOUBLE COMPLEX? */
21245 {
21246 ffelex_token_kill (ffestb_local_.decl.recursive);
21247 goto bad_1; /* :::::::::::::::::::: */
21248 }
21249 return (ffelexHandler) ffestb_decl_recursive1_ (t);
21250 }
21251 if (!ffesrc_is_name_init (*p))
21252 goto bad_i; /* :::::::::::::::::::: */
21253 ot = ffelex_token_names_from_names (nt, i, 0);
21254 ffelex_token_kill (nt);
21255 if (ffestr_first (ot) != FFESTR_firstFUNCTION)
21256 goto bad_o; /* :::::::::::::::::::: */
21257 p = ffelex_token_text (ot) + (i = FFESTR_firstlFUNCTION);
21258 if (!ffesrc_is_name_init (*p))
21259 goto bad_i; /* :::::::::::::::::::: */
21260 ffesta_tokens[1] = ffelex_token_name_from_names (ot, i, 0);
21261 ffelex_token_kill (ot);
21262 ffestb_local_.decl.kind = NULL;
21263 ffestb_local_.decl.kindt = NULL;
21264 ffestb_local_.decl.len = NULL;
21265 ffestb_local_.decl.lent = NULL;
21266 return (ffelexHandler) ffestb_decl_funcname_1_ (t);
21267
21268 bad_0: /* :::::::::::::::::::: */
21269 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ffesta_tokens[0]);
21270 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21271
21272 bad_1: /* :::::::::::::::::::: */
21273 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21274 return (ffelexHandler) ffelex_swallow_tokens (t,
21275 (ffelexHandler) ffesta_zero); /* Invalid second token. */
21276
21277 bad_i: /* :::::::::::::::::::: */
21278 ffelex_token_kill (ffestb_local_.decl.recursive);
21279 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", nt, i, t);
21280 ffelex_token_kill (nt);
21281 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21282
21283 bad_o: /* :::::::::::::::::::: */
21284 ffelex_token_kill (ffestb_local_.decl.recursive);
21285 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ot);
21286 ffelex_token_kill (ot);
21287 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21288 }
21289
21290 /* ffestb_decl_recursive1_ -- "RECURSIVE" generic-type
21291
21292 return ffestb_decl_recursive1_; // to lexer
21293
21294 Handle ASTERISK, OPEN_PAREN, or NAME. */
21295
21296 static ffelexHandler
21297 ffestb_decl_recursive1_ (ffelexToken t)
21298 {
21299 switch (ffelex_token_type (t))
21300 {
21301 case FFELEX_typeASTERISK:
21302 ffesta_confirmed ();
21303 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
21304 ffestb_local_.decl.badname = "TYPEFUNC";
21305 if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
21306 return (ffelexHandler) ffestb_decl_starlen_;
21307 return (ffelexHandler) ffestb_decl_starkind_;
21308
21309 case FFELEX_typeOPEN_PAREN:
21310 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
21311 ffestb_local_.decl.badname = "TYPEFUNC";
21312 if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
21313 {
21314 ffestb_local_.decl.kind = NULL;
21315 ffestb_local_.decl.kindt = NULL;
21316 ffestb_local_.decl.len = NULL;
21317 ffestb_local_.decl.lent = NULL;
21318 return (ffelexHandler) ffestb_decl_typeparams_;
21319 }
21320 return (ffelexHandler) ffestb_decl_kindparam_;
21321
21322 case FFELEX_typeNAME:
21323 ffestb_local_.decl.kind = NULL;
21324 ffestb_local_.decl.kindt = NULL;
21325 ffestb_local_.decl.len = NULL;
21326 ffestb_local_.decl.lent = NULL;
21327 return (ffelexHandler) ffestb_decl_func_ (t);
21328
21329 default:
21330 break;
21331 }
21332
21333 if (ffestb_local_.decl.recursive != NULL)
21334 ffelex_token_kill (ffestb_local_.decl.recursive);
21335 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21336 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21337 }
21338
21339 /* ffestb_decl_recursive2_ -- "RECURSIVE" "DOUBLE"
21340
21341 return ffestb_decl_recursive2_; // to lexer
21342
21343 Handle NAME. */
21344
21345 static ffelexHandler
21346 ffestb_decl_recursive2_ (ffelexToken t)
21347 {
21348 switch (ffelex_token_type (t))
21349 {
21350 case FFELEX_typeNAME:
21351 switch (ffestr_second (t))
21352 {
21353 case FFESTR_secondPRECISION:
21354 ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
21355 break;
21356
21357 case FFESTR_secondCOMPLEX:
21358 ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
21359 break;
21360
21361 default:
21362 goto bad; /* :::::::::::::::::::: */
21363 }
21364 ffestb_local_.decl.kind = NULL;
21365 ffestb_local_.decl.kindt = NULL;
21366 ffestb_local_.decl.len = NULL;
21367 ffestb_local_.decl.lent = NULL;
21368 return (ffelexHandler) ffestb_decl_func_;
21369
21370 default:
21371 break;
21372 }
21373
21374 bad: /* :::::::::::::::::::: */
21375 if (ffestb_local_.decl.recursive != NULL)
21376 ffelex_token_kill (ffestb_local_.decl.recursive);
21377 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21378 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21379 }
21380
21381 /* ffestb_decl_recursive3_ -- "RECURSIVE" "TYPE"
21382
21383 return ffestb_decl_recursive3_; // to lexer
21384
21385 Handle OPEN_PAREN. */
21386
21387 static ffelexHandler
21388 ffestb_decl_recursive3_ (ffelexToken t)
21389 {
21390 switch (ffelex_token_type (t))
21391 {
21392 case FFELEX_typeOPEN_PAREN:
21393 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
21394 ffestb_local_.decl.badname = "TYPEFUNC";
21395 return (ffelexHandler) ffestb_decl_typetype1_;
21396
21397 default:
21398 break;
21399 }
21400
21401 if (ffestb_local_.decl.recursive != NULL)
21402 ffelex_token_kill (ffestb_local_.decl.recursive);
21403 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21404 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21405 }
21406
21407 /* ffestb_decl_recursive4_ -- "RECURSIVE" "FUNCTION/SUBROUTINE"
21408
21409 return ffestb_decl_recursive4_; // to lexer
21410
21411 Handle OPEN_PAREN. */
21412
21413 static ffelexHandler
21414 ffestb_decl_recursive4_ (ffelexToken t)
21415 {
21416 switch (ffelex_token_type (t))
21417 {
21418 case FFELEX_typeNAME:
21419 ffesta_tokens[1] = ffelex_token_use (t);
21420 return (ffelexHandler) ffestb_dummy1_;
21421
21422 default:
21423 break;
21424 }
21425
21426 if (ffestb_local_.decl.recursive != NULL)
21427 ffelex_token_kill (ffestb_local_.decl.recursive);
21428 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21429 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21430 }
21431
21432 #endif
21433 /* ffestb_decl_typetype -- Parse the R426/R501/R1219 TYPE statement
21434
21435 return ffestb_decl_typetype; // to lexer
21436
21437 Make sure the statement has a valid form for the TYPE statement. If it
21438 does, implement the statement. */
21439
21440 #if FFESTR_F90
21441 ffelexHandler
21442 ffestb_decl_typetype (ffelexToken t)
21443 {
21444 switch (ffelex_token_type (ffesta_tokens[0]))
21445 {
21446 case FFELEX_typeNAME:
21447 if (ffesta_first_kw != FFESTR_firstTYPE)
21448 goto bad_0; /* :::::::::::::::::::: */
21449 break;
21450
21451 case FFELEX_typeNAMES:
21452 if (ffesta_first_kw != FFESTR_firstTYPE)
21453 goto bad_0; /* :::::::::::::::::::: */
21454 if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlTYPE)
21455 goto bad_0; /* :::::::::::::::::::: */
21456 break;
21457
21458 default:
21459 goto bad_0; /* :::::::::::::::::::: */
21460 }
21461
21462 switch (ffelex_token_type (t))
21463 {
21464 case FFELEX_typeOPEN_PAREN:
21465 break;
21466
21467 case FFELEX_typeEOS:
21468 case FFELEX_typeSEMICOLON:
21469 case FFELEX_typeCOLONCOLON:/* Not COMMA: R424 "TYPE,PUBLIC::A". */
21470 ffesta_confirmed (); /* Error, but clearly intended. */
21471 goto bad_1; /* :::::::::::::::::::: */
21472
21473 default:
21474 goto bad_1; /* :::::::::::::::::::: */
21475 }
21476
21477 ffestb_local_.decl.recursive = NULL;
21478 ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
21479 ffestb_local_.decl.coloncolon = FALSE; /* No COLONCOLON seen. */
21480
21481 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
21482 ffestb_local_.decl.badname = "type-declaration";
21483 return (ffelexHandler) ffestb_decl_typetype1_;
21484
21485 bad_0: /* :::::::::::::::::::: */
21486 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
21487 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21488
21489 bad_1: /* :::::::::::::::::::: */
21490 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21491 return (ffelexHandler) ffelex_swallow_tokens (t,
21492 (ffelexHandler) ffesta_zero); /* Invalid second token. */
21493 }
21494
21495 #endif
21496 /* ffestb_decl_attrs_ -- "type" [type parameters] COMMA
21497
21498 return ffestb_decl_attrs_; // to lexer
21499
21500 Handle NAME of an attribute. */
21501
21502 static ffelexHandler
21503 ffestb_decl_attrs_ (ffelexToken t)
21504 {
21505 switch (ffelex_token_type (t))
21506 {
21507 case FFELEX_typeNAME:
21508 switch (ffestr_first (t))
21509 {
21510 #if FFESTR_F90
21511 case FFESTR_firstALLOCATABLE:
21512 if (!ffesta_is_inhibited ())
21513 ffestc_decl_attrib (FFESTP_attribALLOCATABLE, t,
21514 FFESTR_otherNone, NULL);
21515 return (ffelexHandler) ffestb_decl_attrs_7_;
21516 #endif
21517
21518 case FFESTR_firstDIMENSION:
21519 ffesta_tokens[1] = ffelex_token_use (t);
21520 return (ffelexHandler) ffestb_decl_attrs_1_;
21521
21522 case FFESTR_firstEXTERNAL:
21523 if (!ffesta_is_inhibited ())
21524 ffestc_decl_attrib (FFESTP_attribEXTERNAL, t,
21525 FFESTR_otherNone, NULL);
21526 return (ffelexHandler) ffestb_decl_attrs_7_;
21527
21528 #if FFESTR_F90
21529 case FFESTR_firstINTENT:
21530 ffesta_tokens[1] = ffelex_token_use (t);
21531 return (ffelexHandler) ffestb_decl_attrs_3_;
21532 #endif
21533
21534 case FFESTR_firstINTRINSIC:
21535 if (!ffesta_is_inhibited ())
21536 ffestc_decl_attrib (FFESTP_attribINTRINSIC, t,
21537 FFESTR_otherNone, NULL);
21538 return (ffelexHandler) ffestb_decl_attrs_7_;
21539
21540 #if FFESTR_F90
21541 case FFESTR_firstOPTIONAL:
21542 if (!ffesta_is_inhibited ())
21543 ffestc_decl_attrib (FFESTP_attribOPTIONAL, t,
21544 FFESTR_otherNone, NULL);
21545 return (ffelexHandler) ffestb_decl_attrs_7_;
21546 #endif
21547
21548 case FFESTR_firstPARAMETER:
21549 ffestb_local_.decl.parameter = TRUE;
21550 if (!ffesta_is_inhibited ())
21551 ffestc_decl_attrib (FFESTP_attribPARAMETER, t,
21552 FFESTR_otherNone, NULL);
21553 return (ffelexHandler) ffestb_decl_attrs_7_;
21554
21555 #if FFESTR_F90
21556 case FFESTR_firstPOINTER:
21557 if (!ffesta_is_inhibited ())
21558 ffestc_decl_attrib (FFESTP_attribPOINTER, t,
21559 FFESTR_otherNone, NULL);
21560 return (ffelexHandler) ffestb_decl_attrs_7_;
21561 #endif
21562
21563 #if FFESTR_F90
21564 case FFESTR_firstPRIVATE:
21565 if (!ffesta_is_inhibited ())
21566 ffestc_decl_attrib (FFESTP_attribPRIVATE, t,
21567 FFESTR_otherNone, NULL);
21568 return (ffelexHandler) ffestb_decl_attrs_7_;
21569
21570 case FFESTR_firstPUBLIC:
21571 if (!ffesta_is_inhibited ())
21572 ffestc_decl_attrib (FFESTP_attribPUBLIC, t,
21573 FFESTR_otherNone, NULL);
21574 return (ffelexHandler) ffestb_decl_attrs_7_;
21575 #endif
21576
21577 case FFESTR_firstSAVE:
21578 if (!ffesta_is_inhibited ())
21579 ffestc_decl_attrib (FFESTP_attribSAVE, t,
21580 FFESTR_otherNone, NULL);
21581 return (ffelexHandler) ffestb_decl_attrs_7_;
21582
21583 #if FFESTR_F90
21584 case FFESTR_firstTARGET:
21585 if (!ffesta_is_inhibited ())
21586 ffestc_decl_attrib (FFESTP_attribTARGET, t,
21587 FFESTR_otherNone, NULL);
21588 return (ffelexHandler) ffestb_decl_attrs_7_;
21589 #endif
21590
21591 default:
21592 ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21593 return (ffelexHandler) ffestb_decl_attrs_7_;
21594 }
21595 break;
21596
21597 default:
21598 break;
21599 }
21600
21601 if (!ffesta_is_inhibited ())
21602 ffestc_decl_finish ();
21603 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21604 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21605 }
21606
21607 /* ffestb_decl_attrs_1_ -- "type" [type parameters] ",DIMENSION"
21608
21609 return ffestb_decl_attrs_1_; // to lexer
21610
21611 Handle OPEN_PAREN. */
21612
21613 static ffelexHandler
21614 ffestb_decl_attrs_1_ (ffelexToken t)
21615 {
21616 switch (ffelex_token_type (t))
21617 {
21618 case FFELEX_typeOPEN_PAREN:
21619 ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
21620 ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_decl_attrs_2_;
21621 ffestb_subrargs_.dim_list.pool = ffesta_scratch_pool;
21622 ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
21623 ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
21624 #ifdef FFECOM_dimensionsMAX
21625 ffestb_subrargs_.dim_list.ndims = 0;
21626 #endif
21627 return (ffelexHandler) ffeexpr_rhs (ffesta_scratch_pool,
21628 ffestb_subrargs_.dim_list.ctx,
21629 (ffeexprCallback) ffestb_subr_dimlist_);
21630
21631 case FFELEX_typeCOMMA:
21632 case FFELEX_typeCOLONCOLON:
21633 ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, ffesta_tokens[1]);
21634 ffelex_token_kill (ffesta_tokens[1]);
21635 return (ffelexHandler) ffestb_decl_attrs_7_ (t);
21636
21637 default:
21638 break;
21639 }
21640
21641 if (!ffesta_is_inhibited ())
21642 ffestc_decl_finish ();
21643 ffelex_token_kill (ffesta_tokens[1]);
21644 ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21645 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21646 }
21647
21648 /* ffestb_decl_attrs_2_ -- "type" [type parameters] ",DIMENSION" OPEN_PAREN
21649 dimlist CLOSE_PAREN
21650
21651 return ffestb_decl_attrs_2_; // to lexer
21652
21653 Handle COMMA or COLONCOLON. */
21654
21655 static ffelexHandler
21656 ffestb_decl_attrs_2_ (ffelexToken t)
21657 {
21658 if (!ffestb_subrargs_.dim_list.ok)
21659 goto bad; /* :::::::::::::::::::: */
21660
21661 switch (ffelex_token_type (t))
21662 {
21663 case FFELEX_typeCOMMA:
21664 case FFELEX_typeCOLONCOLON:
21665 if (!ffesta_is_inhibited ())
21666 ffestc_decl_attrib (FFESTP_attribDIMENSION, ffesta_tokens[1],
21667 FFESTR_otherNone, ffestb_subrargs_.dim_list.dims);
21668 ffelex_token_kill (ffesta_tokens[1]);
21669 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
21670 return (ffelexHandler) ffestb_decl_attrs_7_ (t);
21671
21672 default:
21673 break;
21674 }
21675
21676 bad: /* :::::::::::::::::::: */
21677 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21678 if (!ffesta_is_inhibited ())
21679 ffestc_decl_finish ();
21680 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
21681 ffelex_token_kill (ffesta_tokens[1]);
21682 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21683 }
21684
21685 /* ffestb_decl_attrs_3_ -- "type" [type parameters] ",INTENT"
21686
21687 return ffestb_decl_attrs_3_; // to lexer
21688
21689 Handle OPEN_PAREN. */
21690
21691 #if FFESTR_F90
21692 static ffelexHandler
21693 ffestb_decl_attrs_3_ (ffelexToken t)
21694 {
21695 switch (ffelex_token_type (t))
21696 {
21697 case FFELEX_typeOPEN_PAREN:
21698 return (ffelexHandler) ffestb_decl_attrs_4_;
21699
21700 case FFELEX_typeCOMMA:
21701 case FFELEX_typeCOLONCOLON:
21702 ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, ffesta_tokens[1]);
21703 ffelex_token_kill (ffesta_tokens[1]);
21704 return (ffelexHandler) ffestb_decl_attrs_7_ (t);
21705
21706 default:
21707 break;
21708 }
21709
21710 if (!ffesta_is_inhibited ())
21711 ffestc_decl_finish ();
21712 ffelex_token_kill (ffesta_tokens[1]);
21713 ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21714 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21715 }
21716
21717 /* ffestb_decl_attrs_4_ -- "type" [type parameters] ",INTENT" OPEN_PAREN
21718
21719 return ffestb_decl_attrs_4_; // to lexer
21720
21721 Handle NAME. */
21722
21723 static ffelexHandler
21724 ffestb_decl_attrs_4_ (ffelexToken t)
21725 {
21726 switch (ffelex_token_type (t))
21727 {
21728 case FFELEX_typeNAME:
21729 ffestb_local_.decl.kw = ffestr_other (t);
21730 switch (ffestb_local_.decl.kw)
21731 {
21732 case FFESTR_otherIN:
21733 return (ffelexHandler) ffestb_decl_attrs_5_;
21734
21735 case FFESTR_otherINOUT:
21736 return (ffelexHandler) ffestb_decl_attrs_6_;
21737
21738 case FFESTR_otherOUT:
21739 return (ffelexHandler) ffestb_decl_attrs_6_;
21740
21741 default:
21742 ffestb_local_.decl.kw = FFESTR_otherNone;
21743 ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21744 return (ffelexHandler) ffestb_decl_attrs_5_;
21745 }
21746 break;
21747
21748 default:
21749 break;
21750 }
21751
21752 if (!ffesta_is_inhibited ())
21753 ffestc_decl_finish ();
21754 ffelex_token_kill (ffesta_tokens[1]);
21755 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21756 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21757 }
21758
21759 /* ffestb_decl_attrs_5_ -- "type" [type parameters] ",INTENT" OPEN_PAREN "IN"
21760
21761 return ffestb_decl_attrs_5_; // to lexer
21762
21763 Handle NAME or CLOSE_PAREN. */
21764
21765 static ffelexHandler
21766 ffestb_decl_attrs_5_ (ffelexToken t)
21767 {
21768 switch (ffelex_token_type (t))
21769 {
21770 case FFELEX_typeNAME:
21771 switch (ffestr_other (t))
21772 {
21773 case FFESTR_otherOUT:
21774 if (ffestb_local_.decl.kw != FFESTR_otherNone)
21775 ffestb_local_.decl.kw = FFESTR_otherINOUT;
21776 return (ffelexHandler) ffestb_decl_attrs_6_;
21777
21778 default:
21779 if (ffestb_local_.decl.kw != FFESTR_otherNone)
21780 {
21781 ffestb_local_.decl.kw = FFESTR_otherNone;
21782 ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21783 }
21784 return (ffelexHandler) ffestb_decl_attrs_5_;
21785 }
21786 break;
21787
21788 case FFELEX_typeCLOSE_PAREN:
21789 return (ffelexHandler) ffestb_decl_attrs_6_ (t);
21790
21791 default:
21792 break;
21793 }
21794
21795 if (!ffesta_is_inhibited ())
21796 ffestc_decl_finish ();
21797 ffelex_token_kill (ffesta_tokens[1]);
21798 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21799 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21800 }
21801
21802 /* ffestb_decl_attrs_6_ -- "type" [type parameters] ",INTENT" OPEN_PAREN "IN"
21803 ["OUT"]
21804
21805 return ffestb_decl_attrs_6_; // to lexer
21806
21807 Handle CLOSE_PAREN. */
21808
21809 static ffelexHandler
21810 ffestb_decl_attrs_6_ (ffelexToken t)
21811 {
21812 switch (ffelex_token_type (t))
21813 {
21814 case FFELEX_typeCLOSE_PAREN:
21815 if ((ffestb_local_.decl.kw != FFESTR_otherNone)
21816 && !ffesta_is_inhibited ())
21817 ffestc_decl_attrib (FFESTP_attribINTENT, ffesta_tokens[1],
21818 ffestb_local_.decl.kw, NULL);
21819 ffelex_token_kill (ffesta_tokens[1]);
21820 return (ffelexHandler) ffestb_decl_attrs_7_;
21821
21822 default:
21823 break;
21824 }
21825
21826 if (!ffesta_is_inhibited ())
21827 ffestc_decl_finish ();
21828 ffelex_token_kill (ffesta_tokens[1]);
21829 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21830 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21831 }
21832
21833 #endif
21834 /* ffestb_decl_attrs_7_ -- "type" [type parameters] attribute
21835
21836 return ffestb_decl_attrs_7_; // to lexer
21837
21838 Handle COMMA (another attribute) or COLONCOLON (entities). */
21839
21840 static ffelexHandler
21841 ffestb_decl_attrs_7_ (ffelexToken t)
21842 {
21843 switch (ffelex_token_type (t))
21844 {
21845 case FFELEX_typeCOMMA:
21846 return (ffelexHandler) ffestb_decl_attrs_;
21847
21848 case FFELEX_typeCOLONCOLON:
21849 ffestb_local_.decl.coloncolon = TRUE;
21850 return (ffelexHandler) ffestb_decl_ents_;
21851
21852 default:
21853 break;
21854 }
21855
21856 if (!ffesta_is_inhibited ())
21857 ffestc_decl_finish ();
21858 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21859 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21860 }
21861
21862 /* ffestb_decl_attrsp_ -- "type" [type parameters]
21863
21864 return ffestb_decl_attrsp_; // to lexer
21865
21866 Handle COMMA (meaning we have attributes), COLONCOLON (meaning we have
21867 no attributes but entities), or go to entsp to see about functions or
21868 entities. */
21869
21870 static ffelexHandler
21871 ffestb_decl_attrsp_ (ffelexToken t)
21872 {
21873 ffelex_set_names (FALSE);
21874
21875 switch (ffelex_token_type (t))
21876 {
21877 case FFELEX_typeCOMMA:
21878 ffesta_confirmed ();
21879 if (!ffesta_is_inhibited ())
21880 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
21881 ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
21882 ffestb_local_.decl.len, ffestb_local_.decl.lent);
21883 if (ffestb_local_.decl.kindt != NULL)
21884 ffelex_token_kill (ffestb_local_.decl.kindt);
21885 if (ffestb_local_.decl.lent != NULL)
21886 ffelex_token_kill (ffestb_local_.decl.lent);
21887 return (ffelexHandler) ffestb_decl_attrs_;
21888
21889 case FFELEX_typeCOLONCOLON:
21890 ffestb_local_.decl.coloncolon = TRUE;
21891 ffesta_confirmed ();
21892 if (!ffesta_is_inhibited ())
21893 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
21894 ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
21895 ffestb_local_.decl.len, ffestb_local_.decl.lent);
21896 if (ffestb_local_.decl.kindt != NULL)
21897 ffelex_token_kill (ffestb_local_.decl.kindt);
21898 if (ffestb_local_.decl.lent != NULL)
21899 ffelex_token_kill (ffestb_local_.decl.lent);
21900 return (ffelexHandler) ffestb_decl_ents_;
21901
21902 default:
21903 return (ffelexHandler) ffestb_decl_entsp_ (t);
21904 }
21905 }
21906
21907 /* ffestb_decl_ents_ -- "type" [type parameters] [attributes "::"]
21908
21909 return ffestb_decl_ents_; // to lexer
21910
21911 Handle NAME of an entity. */
21912
21913 static ffelexHandler
21914 ffestb_decl_ents_ (ffelexToken t)
21915 {
21916 switch (ffelex_token_type (t))
21917 {
21918 case FFELEX_typeNAME:
21919 ffesta_tokens[1] = ffelex_token_use (t);
21920 return (ffelexHandler) ffestb_decl_ents_1_;
21921
21922 default:
21923 break;
21924 }
21925
21926 if (!ffesta_is_inhibited ())
21927 ffestc_decl_finish ();
21928 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21929 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21930 }
21931
21932 /* ffestb_decl_ents_1_ -- "type" [type parameters] [attributes "::"] NAME
21933
21934 return ffestb_decl_ents_1_; // to lexer
21935
21936 Handle ASTERISK, OPEN_PAREN, EQUALS, SLASH, COMMA, or EOS/SEMICOLON. */
21937
21938 static ffelexHandler
21939 ffestb_decl_ents_1_ (ffelexToken t)
21940 {
21941 switch (ffelex_token_type (t))
21942 {
21943 case FFELEX_typeCOMMA:
21944 if (!ffesta_is_inhibited ())
21945 ffestc_decl_item (ffesta_tokens[1], NULL, NULL, NULL, NULL, NULL, NULL,
21946 NULL, FALSE);
21947 ffelex_token_kill (ffesta_tokens[1]);
21948 return (ffelexHandler) ffestb_decl_ents_;
21949
21950 case FFELEX_typeEOS:
21951 case FFELEX_typeSEMICOLON:
21952 if (!ffesta_is_inhibited ())
21953 {
21954 ffestc_decl_item (ffesta_tokens[1], NULL, NULL, NULL, NULL, NULL, NULL,
21955 NULL, FALSE);
21956 ffestc_decl_finish ();
21957 }
21958 ffelex_token_kill (ffesta_tokens[1]);
21959 return (ffelexHandler) ffesta_zero (t);
21960
21961 case FFELEX_typeASTERISK:
21962 ffestb_local_.decl.len = NULL;
21963 ffestb_local_.decl.lent = NULL;
21964 return (ffelexHandler) ffestb_decl_ents_2_;
21965
21966 case FFELEX_typeOPEN_PAREN:
21967 ffestb_local_.decl.kind = NULL;
21968 ffestb_local_.decl.kindt = NULL;
21969 ffestb_local_.decl.len = NULL;
21970 ffestb_local_.decl.lent = NULL;
21971 return (ffelexHandler) ffestb_decl_ents_3_ (t);
21972
21973 case FFELEX_typeEQUALS:
21974 case FFELEX_typeSLASH:
21975 ffestb_local_.decl.kind = NULL;
21976 ffestb_local_.decl.kindt = NULL;
21977 ffestb_subrargs_.dim_list.dims = NULL;
21978 ffestb_local_.decl.len = NULL;
21979 ffestb_local_.decl.lent = NULL;
21980 return (ffelexHandler) ffestb_decl_ents_7_ (t);
21981
21982 default:
21983 break;
21984 }
21985
21986 if (!ffesta_is_inhibited ())
21987 ffestc_decl_finish ();
21988 ffelex_token_kill (ffesta_tokens[1]);
21989 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21990 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21991 }
21992
21993 /* ffestb_decl_ents_2_ -- "type" [type parameters] [attributes "::"] NAME
21994 ASTERISK
21995
21996 return ffestb_decl_ents_2_; // to lexer
21997
21998 Handle NUMBER or OPEN_PAREN. */
21999
22000 static ffelexHandler
22001 ffestb_decl_ents_2_ (ffelexToken t)
22002 {
22003 switch (ffelex_token_type (t))
22004 {
22005 case FFELEX_typeNUMBER:
22006 if (ffestb_local_.decl.type != FFESTP_typeCHARACTER)
22007 {
22008 ffestb_local_.decl.kind = NULL;
22009 ffestb_local_.decl.kindt = ffelex_token_use (t);
22010 return (ffelexHandler) ffestb_decl_ents_3_;
22011 }
22012 /* Fall through. *//* (CHARACTER's *n is always a len spec. */
22013 case FFELEX_typeOPEN_PAREN:/* "*(" is after the (omitted)
22014 "(array-spec)". */
22015 ffestb_local_.decl.kind = NULL;
22016 ffestb_local_.decl.kindt = NULL;
22017 ffestb_subrargs_.dim_list.dims = NULL;
22018 return (ffelexHandler) ffestb_decl_ents_5_ (t);
22019
22020 default:
22021 break;
22022 }
22023
22024 if (!ffesta_is_inhibited ())
22025 ffestc_decl_finish ();
22026 ffelex_token_kill (ffesta_tokens[1]);
22027 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22028 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22029 }
22030
22031 /* ffestb_decl_ents_3_ -- "type" [type parameters] [attributes "::"] NAME
22032 [ASTERISK NUMBER]
22033
22034 return ffestb_decl_ents_3_; // to lexer
22035
22036 Handle ASTERISK, OPEN_PAREN, EQUALS, SLASH, COMMA, or EOS/SEMICOLON. */
22037
22038 static ffelexHandler
22039 ffestb_decl_ents_3_ (ffelexToken t)
22040 {
22041 switch (ffelex_token_type (t))
22042 {
22043 case FFELEX_typeCOMMA:
22044 if (!ffesta_is_inhibited ())
22045 ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22046 ffestb_local_.decl.kindt, NULL, NULL, NULL, NULL, NULL, FALSE);
22047 ffelex_token_kill (ffesta_tokens[1]);
22048 if (ffestb_local_.decl.kindt != NULL)
22049 ffelex_token_kill (ffestb_local_.decl.kindt);
22050 return (ffelexHandler) ffestb_decl_ents_;
22051
22052 case FFELEX_typeEOS:
22053 case FFELEX_typeSEMICOLON:
22054 if (!ffesta_is_inhibited ())
22055 {
22056 ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22057 ffestb_local_.decl.kindt, NULL, NULL, NULL, NULL, NULL, FALSE);
22058 ffestc_decl_finish ();
22059 }
22060 ffelex_token_kill (ffesta_tokens[1]);
22061 if (ffestb_local_.decl.kindt != NULL)
22062 ffelex_token_kill (ffestb_local_.decl.kindt);
22063 return (ffelexHandler) ffesta_zero (t);
22064
22065 case FFELEX_typeASTERISK:
22066 ffestb_subrargs_.dim_list.dims = NULL;
22067 return (ffelexHandler) ffestb_decl_ents_5_;
22068
22069 case FFELEX_typeOPEN_PAREN:
22070 ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
22071 ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_decl_ents_4_;
22072 ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
22073 ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
22074 ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
22075 #ifdef FFECOM_dimensionsMAX
22076 ffestb_subrargs_.dim_list.ndims = 0;
22077 #endif
22078 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22079 ffestb_subrargs_.dim_list.ctx,
22080 (ffeexprCallback) ffestb_subr_dimlist_);
22081
22082 case FFELEX_typeEQUALS:
22083 case FFELEX_typeSLASH:
22084 ffestb_local_.decl.kind = NULL;
22085 ffestb_local_.decl.kindt = NULL;
22086 ffestb_subrargs_.dim_list.dims = NULL;
22087 ffestb_local_.decl.len = NULL;
22088 ffestb_local_.decl.lent = NULL;
22089 return (ffelexHandler) ffestb_decl_ents_7_ (t);
22090
22091 default:
22092 break;
22093 }
22094
22095 if (!ffesta_is_inhibited ())
22096 ffestc_decl_finish ();
22097 ffelex_token_kill (ffesta_tokens[1]);
22098 if (ffestb_local_.decl.kindt != NULL)
22099 ffelex_token_kill (ffestb_local_.decl.kindt);
22100 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22101 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22102 }
22103
22104 /* ffestb_decl_ents_4_ -- "type" [type parameters] [attributes "::"] NAME
22105 [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22106
22107 return ffestb_decl_ents_4_; // to lexer
22108
22109 Handle ASTERISK, EQUALS, SLASH, COMMA, or EOS/SEMICOLON. */
22110
22111 static ffelexHandler
22112 ffestb_decl_ents_4_ (ffelexToken t)
22113 {
22114 ffelexToken nt;
22115
22116 if (!ffestb_subrargs_.dim_list.ok)
22117 goto bad; /* :::::::::::::::::::: */
22118
22119 if (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeNAMES)
22120 {
22121 switch (ffelex_token_type (t))
22122 {
22123 case FFELEX_typeCOMMA:
22124 case FFELEX_typeEOS:
22125 case FFELEX_typeSEMICOLON:
22126 case FFELEX_typeASTERISK:
22127 case FFELEX_typeSLASH: /* But NOT FFELEX_typeEQUALS. */
22128 case FFELEX_typeCOLONCOLON: /* Actually an error. */
22129 break; /* Confirm and handle. */
22130
22131 default: /* Perhaps EQUALS, as in
22132 INTEGERFUNCTIONX(A)=B. */
22133 goto bad; /* :::::::::::::::::::: */
22134 }
22135 ffesta_confirmed ();
22136 if (!ffesta_is_inhibited ())
22137 {
22138 nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
22139 ffelex_token_kill (ffesta_tokens[1]);
22140 ffesta_tokens[1] = nt;
22141 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
22142 NULL, NULL, NULL, NULL);
22143 }
22144 }
22145
22146 switch (ffelex_token_type (t))
22147 {
22148 case FFELEX_typeCOMMA:
22149 if (!ffesta_is_inhibited ())
22150 ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22151 ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22152 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22153 FALSE);
22154 ffelex_token_kill (ffesta_tokens[1]);
22155 if (ffestb_local_.decl.kindt != NULL)
22156 ffelex_token_kill (ffestb_local_.decl.kindt);
22157 if (ffestb_local_.decl.lent != NULL)
22158 ffelex_token_kill (ffestb_local_.decl.lent);
22159 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22160 return (ffelexHandler) ffestb_decl_ents_;
22161
22162 case FFELEX_typeEOS:
22163 case FFELEX_typeSEMICOLON:
22164 if (!ffesta_is_inhibited ())
22165 {
22166 ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22167 ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22168 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22169 FALSE);
22170 ffestc_decl_finish ();
22171 }
22172 ffelex_token_kill (ffesta_tokens[1]);
22173 if (ffestb_local_.decl.kindt != NULL)
22174 ffelex_token_kill (ffestb_local_.decl.kindt);
22175 if (ffestb_local_.decl.lent != NULL)
22176 ffelex_token_kill (ffestb_local_.decl.lent);
22177 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22178 return (ffelexHandler) ffesta_zero (t);
22179
22180 case FFELEX_typeASTERISK:
22181 if (ffestb_local_.decl.lent != NULL)
22182 break; /* Can't specify "*length" twice. */
22183 return (ffelexHandler) ffestb_decl_ents_5_;
22184
22185 case FFELEX_typeEQUALS:
22186 case FFELEX_typeSLASH:
22187 return (ffelexHandler) ffestb_decl_ents_7_ (t);
22188
22189 default:
22190 break;
22191 }
22192
22193 bad: /* :::::::::::::::::::: */
22194 if ((ffelex_token_type (ffesta_tokens[1]) != FFELEX_typeNAMES)
22195 && !ffesta_is_inhibited ())
22196 ffestc_decl_finish ();
22197 ffelex_token_kill (ffesta_tokens[1]);
22198 if (ffestb_local_.decl.kindt != NULL)
22199 ffelex_token_kill (ffestb_local_.decl.kindt);
22200 if (ffestb_local_.decl.lent != NULL)
22201 ffelex_token_kill (ffestb_local_.decl.lent);
22202 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22203 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22204 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22205 }
22206
22207 /* ffestb_decl_ents_5_ -- "type" [type parameters] [attributes "::"] NAME
22208 [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22209 ASTERISK
22210
22211 return ffestb_decl_ents_5_; // to lexer
22212
22213 Handle NUMBER or OPEN_PAREN. */
22214
22215 static ffelexHandler
22216 ffestb_decl_ents_5_ (ffelexToken t)
22217 {
22218 switch (ffelex_token_type (t))
22219 {
22220 case FFELEX_typeNUMBER:
22221 ffestb_local_.decl.len = NULL;
22222 ffestb_local_.decl.lent = ffelex_token_use (t);
22223 return (ffelexHandler) ffestb_decl_ents_7_;
22224
22225 case FFELEX_typeOPEN_PAREN:
22226 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22227 FFEEXPR_contextCHARACTERSIZE, (ffeexprCallback) ffestb_decl_ents_6_);
22228
22229 default:
22230 break;
22231 }
22232
22233 if (!ffesta_is_inhibited ())
22234 ffestc_decl_finish ();
22235 ffelex_token_kill (ffesta_tokens[1]);
22236 if (ffestb_local_.decl.kindt != NULL)
22237 ffelex_token_kill (ffestb_local_.decl.kindt);
22238 if (ffestb_subrargs_.dim_list.dims != NULL)
22239 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22240 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22241 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22242 }
22243
22244 /* ffestb_decl_ents_6_ -- "type" [type parameters] [attributes "::"] NAME
22245 [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22246 ASTERISK OPEN_PAREN expr
22247
22248 (ffestb_decl_ents_6_) // to expression handler
22249
22250 Handle CLOSE_PAREN. */
22251
22252 static ffelexHandler
22253 ffestb_decl_ents_6_ (ffelexToken ft, ffebld expr, ffelexToken t)
22254 {
22255 switch (ffelex_token_type (t))
22256 {
22257 case FFELEX_typeCLOSE_PAREN:
22258 if (expr == NULL)
22259 break;
22260 ffestb_local_.decl.len = expr;
22261 ffestb_local_.decl.lent = ffelex_token_use (ft);
22262 return (ffelexHandler) ffestb_decl_ents_7_;
22263
22264 default:
22265 break;
22266 }
22267
22268 if (!ffesta_is_inhibited ())
22269 ffestc_decl_finish ();
22270 ffelex_token_kill (ffesta_tokens[1]);
22271 if (ffestb_local_.decl.kindt != NULL)
22272 ffelex_token_kill (ffestb_local_.decl.kindt);
22273 if (ffestb_subrargs_.dim_list.dims != NULL)
22274 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22275 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22276 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22277 }
22278
22279 /* ffestb_decl_ents_7_ -- "type" [type parameters] [attributes "::"] NAME
22280 [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22281 [ASTERISK charlength]
22282
22283 return ffestb_decl_ents_7_; // to lexer
22284
22285 Handle EQUALS, SLASH, COMMA, or EOS/SEMICOLON. */
22286
22287 static ffelexHandler
22288 ffestb_decl_ents_7_ (ffelexToken t)
22289 {
22290 switch (ffelex_token_type (t))
22291 {
22292 case FFELEX_typeCOMMA:
22293 if (!ffesta_is_inhibited ())
22294 ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22295 ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22296 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22297 FALSE);
22298 ffelex_token_kill (ffesta_tokens[1]);
22299 if (ffestb_local_.decl.kindt != NULL)
22300 ffelex_token_kill (ffestb_local_.decl.kindt);
22301 if (ffestb_subrargs_.dim_list.dims != NULL)
22302 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22303 if (ffestb_local_.decl.lent != NULL)
22304 ffelex_token_kill (ffestb_local_.decl.lent);
22305 return (ffelexHandler) ffestb_decl_ents_;
22306
22307 case FFELEX_typeEOS:
22308 case FFELEX_typeSEMICOLON:
22309 if (!ffesta_is_inhibited ())
22310 {
22311 ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22312 ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22313 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22314 FALSE);
22315 ffestc_decl_finish ();
22316 }
22317 ffelex_token_kill (ffesta_tokens[1]);
22318 if (ffestb_local_.decl.kindt != NULL)
22319 ffelex_token_kill (ffestb_local_.decl.kindt);
22320 if (ffestb_subrargs_.dim_list.dims != NULL)
22321 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22322 if (ffestb_local_.decl.lent != NULL)
22323 ffelex_token_kill (ffestb_local_.decl.lent);
22324 return (ffelexHandler) ffesta_zero (t);
22325
22326 case FFELEX_typeEQUALS:
22327 if (!ffestb_local_.decl.coloncolon)
22328 ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_INIT, t);
22329 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22330 ffestb_local_.decl.parameter ? FFEEXPR_contextPARAMETER
22331 : FFEEXPR_contextINITVAL, (ffeexprCallback) ffestb_decl_ents_8_);
22332
22333 case FFELEX_typeSLASH:
22334 if (!ffesta_is_inhibited ())
22335 {
22336 ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22337 ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22338 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22339 TRUE);
22340 ffestc_decl_itemstartvals ();
22341 }
22342 ffelex_token_kill (ffesta_tokens[1]);
22343 if (ffestb_local_.decl.kindt != NULL)
22344 ffelex_token_kill (ffestb_local_.decl.kindt);
22345 if (ffestb_subrargs_.dim_list.dims != NULL)
22346 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22347 if (ffestb_local_.decl.lent != NULL)
22348 ffelex_token_kill (ffestb_local_.decl.lent);
22349 return (ffelexHandler) ffeexpr_rhs
22350 (ffesta_output_pool, FFEEXPR_contextDATA,
22351 (ffeexprCallback) ffestb_decl_ents_9_);
22352
22353 default:
22354 break;
22355 }
22356
22357 if (!ffesta_is_inhibited ())
22358 ffestc_decl_finish ();
22359 ffelex_token_kill (ffesta_tokens[1]);
22360 if (ffestb_local_.decl.kindt != NULL)
22361 ffelex_token_kill (ffestb_local_.decl.kindt);
22362 if (ffestb_subrargs_.dim_list.dims != NULL)
22363 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22364 if (ffestb_local_.decl.lent != NULL)
22365 ffelex_token_kill (ffestb_local_.decl.lent);
22366 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22367 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22368 }
22369
22370 /* ffestb_decl_ents_8_ -- "type" [type parameters] [attributes "::"] NAME
22371 [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22372 [ASTERISK charlength] EQUALS expr
22373
22374 (ffestb_decl_ents_8_) // to expression handler
22375
22376 Handle COMMA or EOS/SEMICOLON. */
22377
22378 static ffelexHandler
22379 ffestb_decl_ents_8_ (ffelexToken ft, ffebld expr, ffelexToken t)
22380 {
22381 switch (ffelex_token_type (t))
22382 {
22383 case FFELEX_typeCOMMA:
22384 if (expr == NULL)
22385 break;
22386 if (!ffesta_is_inhibited ())
22387 ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22388 ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22389 ffestb_local_.decl.len, ffestb_local_.decl.lent, expr, ft,
22390 FALSE);
22391 ffelex_token_kill (ffesta_tokens[1]);
22392 if (ffestb_local_.decl.kindt != NULL)
22393 ffelex_token_kill (ffestb_local_.decl.kindt);
22394 if (ffestb_subrargs_.dim_list.dims != NULL)
22395 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22396 if (ffestb_local_.decl.lent != NULL)
22397 ffelex_token_kill (ffestb_local_.decl.lent);
22398 return (ffelexHandler) ffestb_decl_ents_;
22399
22400 case FFELEX_typeEOS:
22401 case FFELEX_typeSEMICOLON:
22402 if (!ffesta_is_inhibited ())
22403 {
22404 ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22405 ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22406 ffestb_local_.decl.len, ffestb_local_.decl.lent, expr, ft,
22407 FALSE);
22408 ffestc_decl_finish ();
22409 }
22410 ffelex_token_kill (ffesta_tokens[1]);
22411 if (ffestb_local_.decl.kindt != NULL)
22412 ffelex_token_kill (ffestb_local_.decl.kindt);
22413 if (ffestb_subrargs_.dim_list.dims != NULL)
22414 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22415 if (ffestb_local_.decl.lent != NULL)
22416 ffelex_token_kill (ffestb_local_.decl.lent);
22417 return (ffelexHandler) ffesta_zero (t);
22418
22419 default:
22420 break;
22421 }
22422
22423 if (!ffesta_is_inhibited ())
22424 ffestc_decl_finish ();
22425 ffelex_token_kill (ffesta_tokens[1]);
22426 if (ffestb_local_.decl.kindt != NULL)
22427 ffelex_token_kill (ffestb_local_.decl.kindt);
22428 if (ffestb_subrargs_.dim_list.dims != NULL)
22429 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22430 if (ffestb_local_.decl.lent != NULL)
22431 ffelex_token_kill (ffestb_local_.decl.lent);
22432 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22433 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22434 }
22435
22436 /* ffestb_decl_ents_9_ -- "type" ... SLASH expr
22437
22438 (ffestb_decl_ents_9_) // to expression handler
22439
22440 Handle ASTERISK, COMMA, or SLASH. */
22441
22442 static ffelexHandler
22443 ffestb_decl_ents_9_ (ffelexToken ft, ffebld expr, ffelexToken t)
22444 {
22445 switch (ffelex_token_type (t))
22446 {
22447 case FFELEX_typeCOMMA:
22448 if (expr == NULL)
22449 break;
22450 if (!ffesta_is_inhibited ())
22451 ffestc_decl_itemvalue (NULL, NULL, expr, ft);
22452 return (ffelexHandler) ffeexpr_rhs
22453 (ffesta_output_pool, FFEEXPR_contextDATA,
22454 (ffeexprCallback) ffestb_decl_ents_9_);
22455
22456 case FFELEX_typeASTERISK:
22457 if (expr == NULL)
22458 break;
22459 ffestb_local_.decl.expr = expr;
22460 ffesta_tokens[1] = ffelex_token_use (ft);
22461 return (ffelexHandler) ffeexpr_rhs
22462 (ffesta_output_pool, FFEEXPR_contextDATA,
22463 (ffeexprCallback) ffestb_decl_ents_10_);
22464
22465 case FFELEX_typeSLASH:
22466 if (expr == NULL)
22467 break;
22468 if (!ffesta_is_inhibited ())
22469 {
22470 ffestc_decl_itemvalue (NULL, NULL, expr, ft);
22471 ffestc_decl_itemendvals (t);
22472 }
22473 return (ffelexHandler) ffestb_decl_ents_11_;
22474
22475 default:
22476 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22477 break;
22478 }
22479
22480 if (!ffesta_is_inhibited ())
22481 {
22482 ffestc_decl_itemendvals (t);
22483 ffestc_decl_finish ();
22484 }
22485 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22486 }
22487
22488 /* ffestb_decl_ents_10_ -- "type" ... SLASH expr ASTERISK expr
22489
22490 (ffestb_decl_ents_10_) // to expression handler
22491
22492 Handle COMMA or SLASH. */
22493
22494 static ffelexHandler
22495 ffestb_decl_ents_10_ (ffelexToken ft, ffebld expr, ffelexToken t)
22496 {
22497 switch (ffelex_token_type (t))
22498 {
22499 case FFELEX_typeCOMMA:
22500 if (expr == NULL)
22501 break;
22502 if (!ffesta_is_inhibited ())
22503 ffestc_decl_itemvalue (ffestb_local_.decl.expr, ffesta_tokens[1],
22504 expr, ft);
22505 ffelex_token_kill (ffesta_tokens[1]);
22506 return (ffelexHandler) ffeexpr_rhs
22507 (ffesta_output_pool, FFEEXPR_contextDATA,
22508 (ffeexprCallback) ffestb_decl_ents_9_);
22509
22510 case FFELEX_typeSLASH:
22511 if (expr == NULL)
22512 break;
22513 if (!ffesta_is_inhibited ())
22514 {
22515 ffestc_decl_itemvalue (ffestb_local_.decl.expr, ffesta_tokens[1],
22516 expr, ft);
22517 ffestc_decl_itemendvals (t);
22518 }
22519 ffelex_token_kill (ffesta_tokens[1]);
22520 return (ffelexHandler) ffestb_decl_ents_11_;
22521
22522 default:
22523 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22524 break;
22525 }
22526
22527 if (!ffesta_is_inhibited ())
22528 {
22529 ffestc_decl_itemendvals (t);
22530 ffestc_decl_finish ();
22531 }
22532 ffelex_token_kill (ffesta_tokens[1]);
22533 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22534 }
22535
22536 /* ffestb_decl_ents_11_ -- "type" [type parameters] [attributes "::"] NAME
22537 [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22538 [ASTERISK charlength] SLASH initvals SLASH
22539
22540 return ffestb_decl_ents_11_; // to lexer
22541
22542 Handle COMMA or EOS/SEMICOLON. */
22543
22544 static ffelexHandler
22545 ffestb_decl_ents_11_ (ffelexToken t)
22546 {
22547 switch (ffelex_token_type (t))
22548 {
22549 case FFELEX_typeCOMMA:
22550 return (ffelexHandler) ffestb_decl_ents_;
22551
22552 case FFELEX_typeEOS:
22553 case FFELEX_typeSEMICOLON:
22554 if (!ffesta_is_inhibited ())
22555 ffestc_decl_finish ();
22556 return (ffelexHandler) ffesta_zero (t);
22557
22558 default:
22559 break;
22560 }
22561
22562 if (!ffesta_is_inhibited ())
22563 ffestc_decl_finish ();
22564 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22565 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22566 }
22567
22568 /* ffestb_decl_entsp_ -- "type" [type parameters]
22569
22570 return ffestb_decl_entsp_; // to lexer
22571
22572 Handle NAME or NAMES beginning either an entity (object) declaration or
22573 a function definition.. */
22574
22575 static ffelexHandler
22576 ffestb_decl_entsp_ (ffelexToken t)
22577 {
22578 switch (ffelex_token_type (t))
22579 {
22580 case FFELEX_typeNAME:
22581 ffesta_confirmed ();
22582 ffesta_tokens[1] = ffelex_token_use (t);
22583 return (ffelexHandler) ffestb_decl_entsp_1_;
22584
22585 case FFELEX_typeNAMES:
22586 ffesta_confirmed ();
22587 ffesta_tokens[1] = ffelex_token_use (t);
22588 return (ffelexHandler) ffestb_decl_entsp_2_;
22589
22590 default:
22591 break;
22592 }
22593
22594 if (ffestb_local_.decl.kindt != NULL)
22595 ffelex_token_kill (ffestb_local_.decl.kindt);
22596 if (ffestb_local_.decl.lent != NULL)
22597 ffelex_token_kill (ffestb_local_.decl.lent);
22598 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22599 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22600 }
22601
22602 /* ffestb_decl_entsp_1_ -- "type" [type parameters] NAME
22603
22604 return ffestb_decl_entsp_1_; // to lexer
22605
22606 If we get another NAME token here, then the previous one must be
22607 "RECURSIVE" or "FUNCTION" and we handle it accordingly. Otherwise,
22608 we send the previous and current token through to _ents_. */
22609
22610 static ffelexHandler
22611 ffestb_decl_entsp_1_ (ffelexToken t)
22612 {
22613 switch (ffelex_token_type (t))
22614 {
22615 case FFELEX_typeNAME:
22616 switch (ffestr_first (ffesta_tokens[1]))
22617 {
22618 #if FFESTR_F90
22619 case FFESTR_firstRECURSIVE:
22620 if (ffestr_first (t) != FFESTR_firstFUNCTION)
22621 {
22622 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22623 break;
22624 }
22625 ffestb_local_.decl.recursive = ffesta_tokens[1];
22626 return (ffelexHandler) ffestb_decl_funcname_;
22627 #endif
22628
22629 case FFESTR_firstFUNCTION:
22630 ffelex_token_kill (ffesta_tokens[1]);
22631 return (ffelexHandler) ffestb_decl_funcname_ (t);
22632
22633 default:
22634 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ffesta_tokens[1]);
22635 break;
22636 }
22637 break;
22638
22639 default:
22640 if ((ffelex_token_type (ffesta_tokens[1]) != FFELEX_typeNAMES)
22641 && !ffesta_is_inhibited ())
22642 ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
22643 ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
22644 ffestb_local_.decl.len, ffestb_local_.decl.lent);
22645 if (ffestb_local_.decl.kindt != NULL)
22646 ffelex_token_kill (ffestb_local_.decl.kindt);
22647 if (ffestb_local_.decl.lent != NULL)
22648 ffelex_token_kill (ffestb_local_.decl.lent);
22649 /* NAME/NAMES token already in ffesta_tokens[1]. */
22650 return (ffelexHandler) ffestb_decl_ents_1_ (t);
22651 }
22652
22653 if (ffestb_local_.decl.kindt != NULL)
22654 ffelex_token_kill (ffestb_local_.decl.kindt);
22655 if (ffestb_local_.decl.lent != NULL)
22656 ffelex_token_kill (ffestb_local_.decl.lent);
22657 ffelex_token_kill (ffesta_tokens[1]);
22658 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22659 }
22660
22661 /* ffestb_decl_entsp_2_ -- "type" [type parameters] NAMES
22662
22663 return ffestb_decl_entsp_2_; // to lexer
22664
22665 If we get an ASTERISK or OPEN_PAREN here, then if the previous NAMES
22666 begins with "FUNCTION" or "RECURSIVEFUNCTION" and is followed by a
22667 first-name-char, we have a possible syntactically ambiguous situation.
22668 Otherwise, we have a straightforward situation just as if we went
22669 through _entsp_1_ instead of here. */
22670
22671 static ffelexHandler
22672 ffestb_decl_entsp_2_ (ffelexToken t)
22673 {
22674 ffelexToken nt;
22675 bool asterisk_ok;
22676 unsigned const char *p;
22677 ffeTokenLength i;
22678
22679 switch (ffelex_token_type (t))
22680 {
22681 case FFELEX_typeASTERISK:
22682 ffesta_confirmed ();
22683 switch (ffestb_local_.decl.type)
22684 {
22685 case FFESTP_typeINTEGER:
22686 case FFESTP_typeREAL:
22687 case FFESTP_typeCOMPLEX:
22688 case FFESTP_typeLOGICAL:
22689 asterisk_ok = (ffestb_local_.decl.kindt == NULL);
22690 break;
22691
22692 case FFESTP_typeCHARACTER:
22693 asterisk_ok = (ffestb_local_.decl.lent == NULL);
22694 break;
22695
22696 case FFESTP_typeBYTE:
22697 case FFESTP_typeWORD:
22698 default:
22699 asterisk_ok = FALSE;
22700 break;
22701 }
22702 switch (ffestr_first (ffesta_tokens[1]))
22703 {
22704 #if FFESTR_F90
22705 case FFESTR_firstRECURSIVEFNCTN:
22706 if (!asterisk_ok)
22707 break; /* For our own convenience, treat as non-FN
22708 stmt. */
22709 p = ffelex_token_text (ffesta_tokens[1])
22710 + (i = FFESTR_firstlRECURSIVEFNCTN);
22711 if (!ffesrc_is_name_init (*p))
22712 break;
22713 ffestb_local_.decl.recursive
22714 = ffelex_token_name_from_names (ffesta_tokens[1], 0,
22715 FFESTR_firstlRECURSIVEFNCTN);
22716 ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22717 FFESTR_firstlRECURSIVEFNCTN, 0);
22718 return (ffelexHandler) ffestb_decl_entsp_3_;
22719 #endif
22720
22721 case FFESTR_firstFUNCTION:
22722 if (!asterisk_ok)
22723 break; /* For our own convenience, treat as non-FN
22724 stmt. */
22725 p = ffelex_token_text (ffesta_tokens[1])
22726 + (i = FFESTR_firstlFUNCTION);
22727 if (!ffesrc_is_name_init (*p))
22728 break;
22729 ffestb_local_.decl.recursive = NULL;
22730 ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22731 FFESTR_firstlFUNCTION, 0);
22732 return (ffelexHandler) ffestb_decl_entsp_3_;
22733
22734 default:
22735 break;
22736 }
22737 break;
22738
22739 case FFELEX_typeOPEN_PAREN:
22740 ffestb_local_.decl.aster_after = FALSE;
22741 switch (ffestr_first (ffesta_tokens[1]))
22742 {
22743 #if FFESTR_F90
22744 case FFESTR_firstRECURSIVEFNCTN:
22745 p = ffelex_token_text (ffesta_tokens[1])
22746 + (i = FFESTR_firstlRECURSIVEFNCTN);
22747 if (!ffesrc_is_name_init (*p))
22748 break;
22749 ffestb_local_.decl.recursive
22750 = ffelex_token_name_from_names (ffesta_tokens[1], 0,
22751 FFESTR_firstlRECURSIVEFNCTN);
22752 ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22753 FFESTR_firstlRECURSIVEFNCTN, 0);
22754 return (ffelexHandler) ffestb_decl_entsp_5_ (t);
22755 #endif
22756
22757 case FFESTR_firstFUNCTION:
22758 p = ffelex_token_text (ffesta_tokens[1])
22759 + (i = FFESTR_firstlFUNCTION);
22760 if (!ffesrc_is_name_init (*p))
22761 break;
22762 ffestb_local_.decl.recursive = NULL;
22763 ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22764 FFESTR_firstlFUNCTION, 0);
22765 return (ffelexHandler) ffestb_decl_entsp_5_ (t);
22766
22767 default:
22768 break;
22769 }
22770 if ((ffestb_local_.decl.kindt != NULL)
22771 || (ffestb_local_.decl.lent != NULL))
22772 break; /* Have kind/len type param, definitely not
22773 assignment stmt. */
22774 return (ffelexHandler) ffestb_decl_entsp_1_ (t);
22775
22776 default:
22777 break;
22778 }
22779
22780 nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
22781 ffelex_token_kill (ffesta_tokens[1]);
22782 ffesta_tokens[1] = nt; /* Change NAMES to NAME. */
22783 return (ffelexHandler) ffestb_decl_entsp_1_ (t);
22784 }
22785
22786 /* ffestb_decl_entsp_3_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22787 NAME ASTERISK
22788
22789 return ffestb_decl_entsp_3_; // to lexer
22790
22791 Handle NUMBER or OPEN_PAREN. */
22792
22793 static ffelexHandler
22794 ffestb_decl_entsp_3_ (ffelexToken t)
22795 {
22796 ffestb_local_.decl.aster_after = TRUE;
22797
22798 switch (ffelex_token_type (t))
22799 {
22800 case FFELEX_typeNUMBER:
22801 switch (ffestb_local_.decl.type)
22802 {
22803 case FFESTP_typeINTEGER:
22804 case FFESTP_typeREAL:
22805 case FFESTP_typeCOMPLEX:
22806 case FFESTP_typeLOGICAL:
22807 ffestb_local_.decl.kindt = ffelex_token_use (t);
22808 break;
22809
22810 case FFESTP_typeCHARACTER:
22811 ffestb_local_.decl.lent = ffelex_token_use (t);
22812 break;
22813
22814 case FFESTP_typeBYTE:
22815 case FFESTP_typeWORD:
22816 default:
22817 assert (FALSE);
22818 }
22819 return (ffelexHandler) ffestb_decl_entsp_5_;
22820
22821 case FFELEX_typeOPEN_PAREN:
22822 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22823 FFEEXPR_contextCHARACTERSIZE,
22824 (ffeexprCallback) ffestb_decl_entsp_4_);
22825
22826 default:
22827 break;
22828 }
22829
22830 if (ffestb_local_.decl.recursive != NULL)
22831 ffelex_token_kill (ffestb_local_.decl.recursive);
22832 if (ffestb_local_.decl.kindt != NULL)
22833 ffelex_token_kill (ffestb_local_.decl.kindt);
22834 if (ffestb_local_.decl.lent != NULL)
22835 ffelex_token_kill (ffestb_local_.decl.lent);
22836 ffelex_token_kill (ffesta_tokens[1]);
22837 ffelex_token_kill (ffesta_tokens[2]);
22838 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22839 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22840 }
22841
22842 /* ffestb_decl_entsp_4_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22843 NAME ASTERISK OPEN_PAREN expr
22844
22845 (ffestb_decl_entsp_4_) // to expression handler
22846
22847 Allow only CLOSE_PAREN; and deal with character-length expression. */
22848
22849 static ffelexHandler
22850 ffestb_decl_entsp_4_ (ffelexToken ft, ffebld expr, ffelexToken t)
22851 {
22852 switch (ffelex_token_type (t))
22853 {
22854 case FFELEX_typeCLOSE_PAREN:
22855 if (expr == NULL)
22856 break;
22857 switch (ffestb_local_.decl.type)
22858 {
22859 case FFESTP_typeCHARACTER:
22860 ffestb_local_.decl.len = expr;
22861 ffestb_local_.decl.lent = ffelex_token_use (ft);
22862 break;
22863
22864 default:
22865 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22866 break;
22867 }
22868 return (ffelexHandler) ffestb_decl_entsp_5_;
22869
22870 default:
22871 break;
22872 }
22873
22874 if (ffestb_local_.decl.recursive != NULL)
22875 ffelex_token_kill (ffestb_local_.decl.recursive);
22876 if (ffestb_local_.decl.kindt != NULL)
22877 ffelex_token_kill (ffestb_local_.decl.kindt);
22878 if (ffestb_local_.decl.lent != NULL)
22879 ffelex_token_kill (ffestb_local_.decl.lent);
22880 ffelex_token_kill (ffesta_tokens[1]);
22881 ffelex_token_kill (ffesta_tokens[2]);
22882 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22883 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22884 }
22885
22886 /* ffestb_decl_entsp_5_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22887 NAME [type parameter]
22888
22889 return ffestb_decl_entsp_5_; // to lexer
22890
22891 Make sure the next token is an OPEN_PAREN. Get the arg list or dimension
22892 list. If it can't be an arg list, or if the CLOSE_PAREN is followed by
22893 something other than EOS/SEMICOLON or NAME, then treat as dimension list
22894 and handle statement as an R426/R501. If it can't be a dimension list, or
22895 if the CLOSE_PAREN is followed by NAME, treat as an arg list and handle
22896 statement as an R1219. If it can be either an arg list or a dimension
22897 list and if the CLOSE_PAREN is followed by EOS/SEMICOLON, ask FFESTC
22898 whether to treat the statement as an R426/R501 or an R1219 and act
22899 accordingly. */
22900
22901 static ffelexHandler
22902 ffestb_decl_entsp_5_ (ffelexToken t)
22903 {
22904 switch (ffelex_token_type (t))
22905 {
22906 case FFELEX_typeOPEN_PAREN:
22907 if (ffestb_local_.decl.aster_after && (ffestb_local_.decl.len != NULL))
22908 { /* "CHARACTER[RECURSIVE]FUNCTIONxyz*(len-expr)
22909 (..." must be a function-stmt, since the
22910 (len-expr) cannot precede (array-spec) in
22911 an object declaration but can precede
22912 (name-list) in a function stmt. */
22913 ffelex_token_kill (ffesta_tokens[1]);
22914 ffesta_tokens[1] = ffesta_tokens[2];
22915 return (ffelexHandler) ffestb_decl_funcname_4_ (t);
22916 }
22917 ffestb_local_.decl.toklist = ffestt_tokenlist_create ();
22918 ffestb_local_.decl.empty = TRUE;
22919 ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
22920 return (ffelexHandler) ffestb_decl_entsp_6_;
22921
22922 default:
22923 break;
22924 }
22925
22926 assert (ffestb_local_.decl.aster_after);
22927 ffesta_confirmed (); /* We've seen an ASTERISK, so even EQUALS
22928 confirmed. */
22929 ffestb_subr_ambig_to_ents_ ();
22930 ffestb_subrargs_.dim_list.dims = NULL;
22931 return (ffelexHandler) ffestb_decl_ents_7_ (t);
22932 }
22933
22934 /* ffestb_decl_entsp_6_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22935 NAME [type parameter] OPEN_PAREN
22936
22937 return ffestb_decl_entsp_6_; // to lexer
22938
22939 If CLOSE_PAREN, we definitely have an R1219 function-stmt, since
22940 the notation "name()" is invalid for a declaration. */
22941
22942 static ffelexHandler
22943 ffestb_decl_entsp_6_ (ffelexToken t)
22944 {
22945 ffelexHandler next;
22946
22947 switch (ffelex_token_type (t))
22948 {
22949 case FFELEX_typeCLOSE_PAREN:
22950 if (!ffestb_local_.decl.empty)
22951 { /* Trailing comma, just a warning for
22952 stmt func def, so allow ambiguity. */
22953 ffestt_tokenlist_append (ffestb_local_.decl.toklist,
22954 ffelex_token_use (t));
22955 return (ffelexHandler) ffestb_decl_entsp_8_;
22956 }
22957 ffelex_token_kill (ffesta_tokens[1]);
22958 ffesta_tokens[1] = ffesta_tokens[2];
22959 next = (ffelexHandler) ffestt_tokenlist_handle
22960 (ffestb_local_.decl.toklist, (ffelexHandler) ffestb_decl_funcname_4_);
22961 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
22962 return (ffelexHandler) (*next) (t);
22963
22964 case FFELEX_typeNAME:
22965 ffestb_local_.decl.empty = FALSE;
22966 ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
22967 return (ffelexHandler) ffestb_decl_entsp_7_;
22968
22969 case FFELEX_typeEQUALS:
22970 case FFELEX_typePOINTS:
22971 case FFELEX_typePERCENT:
22972 case FFELEX_typePERIOD:
22973 case FFELEX_typeOPEN_PAREN:
22974 if ((ffestb_local_.decl.kindt != NULL)
22975 || (ffestb_local_.decl.lent != NULL))
22976 break; /* type(params)name or type*val name, either
22977 way confirmed. */
22978 return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
22979
22980 default:
22981 break;
22982 }
22983
22984 ffesta_confirmed ();
22985 ffestb_subr_ambig_to_ents_ ();
22986 next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
22987 (ffelexHandler) ffestb_decl_ents_3_);
22988 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
22989 return (ffelexHandler) (*next) (t);
22990 }
22991
22992 /* ffestb_decl_entsp_7_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22993 NAME [type parameter] OPEN_PAREN NAME
22994
22995 return ffestb_decl_entsp_7_; // to lexer
22996
22997 Expect COMMA or CLOSE_PAREN to remain ambiguous, else not an R1219
22998 function-stmt. */
22999
23000 static ffelexHandler
23001 ffestb_decl_entsp_7_ (ffelexToken t)
23002 {
23003 ffelexHandler next;
23004
23005 switch (ffelex_token_type (t))
23006 {
23007 case FFELEX_typeCLOSE_PAREN:
23008 ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
23009 return (ffelexHandler) ffestb_decl_entsp_8_;
23010
23011 case FFELEX_typeCOMMA:
23012 ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
23013 return (ffelexHandler) ffestb_decl_entsp_6_;
23014
23015 case FFELEX_typeEQUALS:
23016 case FFELEX_typePOINTS:
23017 case FFELEX_typePERCENT:
23018 case FFELEX_typePERIOD:
23019 case FFELEX_typeOPEN_PAREN:
23020 if ((ffestb_local_.decl.kindt != NULL)
23021 || (ffestb_local_.decl.lent != NULL))
23022 break; /* type(params)name or type*val name, either
23023 way confirmed. */
23024 return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
23025
23026 default:
23027 break;
23028 }
23029
23030 ffesta_confirmed ();
23031 ffestb_subr_ambig_to_ents_ ();
23032 next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
23033 (ffelexHandler) ffestb_decl_ents_3_);
23034 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
23035 return (ffelexHandler) (*next) (t);
23036 }
23037
23038 /* ffestb_decl_entsp_8_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23039 NAME [type parameter] OPEN_PAREN name-list
23040 CLOSE_PAREN
23041
23042 return ffestb_decl_entsp_8_; // to lexer
23043
23044 If EOS/SEMICOLON, situation remains ambiguous, ask FFESTC to resolve
23045 it. If NAME (must be "RESULT", but that is checked later on),
23046 definitely an R1219 function-stmt. Anything else, handle as entity decl. */
23047
23048 static ffelexHandler
23049 ffestb_decl_entsp_8_ (ffelexToken t)
23050 {
23051 ffelexHandler next;
23052
23053 switch (ffelex_token_type (t))
23054 {
23055 case FFELEX_typeEOS:
23056 case FFELEX_typeSEMICOLON:
23057 ffesta_confirmed ();
23058 if (ffestc_is_decl_not_R1219 ())
23059 break;
23060 /* Fall through. */
23061 case FFELEX_typeNAME:
23062 ffesta_confirmed ();
23063 ffelex_token_kill (ffesta_tokens[1]);
23064 ffesta_tokens[1] = ffesta_tokens[2];
23065 next = (ffelexHandler) ffestt_tokenlist_handle
23066 (ffestb_local_.decl.toklist, (ffelexHandler) ffestb_decl_funcname_4_);
23067 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
23068 return (ffelexHandler) (*next) (t);
23069
23070 case FFELEX_typeEQUALS:
23071 case FFELEX_typePOINTS:
23072 case FFELEX_typePERCENT:
23073 case FFELEX_typePERIOD:
23074 case FFELEX_typeOPEN_PAREN:
23075 if ((ffestb_local_.decl.kindt != NULL)
23076 || (ffestb_local_.decl.lent != NULL))
23077 break; /* type(params)name or type*val name, either
23078 way confirmed. */
23079 return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
23080
23081 default:
23082 break;
23083 }
23084
23085 ffesta_confirmed ();
23086 ffestb_subr_ambig_to_ents_ ();
23087 next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
23088 (ffelexHandler) ffestb_decl_ents_3_);
23089 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
23090 return (ffelexHandler) (*next) (t);
23091 }
23092
23093 /* ffestb_decl_func_ -- ["type" [type parameters]] RECURSIVE
23094
23095 return ffestb_decl_func_; // to lexer
23096
23097 Handle "FUNCTION". */
23098
23099 #if FFESTR_F90
23100 static ffelexHandler
23101 ffestb_decl_func_ (ffelexToken t)
23102 {
23103 const char *p;
23104 ffeTokenLength i;
23105
23106 ffelex_set_names (FALSE);
23107
23108 switch (ffelex_token_type (t))
23109 {
23110 case FFELEX_typeNAME:
23111 if (ffestr_first (t) != FFESTR_firstFUNCTION)
23112 break;
23113 return (ffelexHandler) ffestb_decl_funcname_;
23114
23115 case FFELEX_typeNAMES:
23116 ffesta_confirmed ();
23117 if (ffestr_first (t) != FFESTR_firstFUNCTION)
23118 break;
23119 p = ffelex_token_text (t) + (i = FFESTR_firstlFUNCTION);
23120 if (*p == '\0')
23121 break;
23122 if (!ffesrc_is_name_init (*p))
23123 goto bad_i; /* :::::::::::::::::::: */
23124 ffesta_tokens[1] = ffelex_token_name_from_names (t, i, 0);
23125 return (ffelexHandler) ffestb_decl_funcname_1_;
23126
23127 default:
23128 break;
23129 }
23130
23131 if (ffestb_local_.decl.recursive != NULL)
23132 ffelex_token_kill (ffestb_local_.decl.recursive);
23133 if (ffestb_local_.decl.kindt != NULL)
23134 ffelex_token_kill (ffestb_local_.decl.kindt);
23135 if (ffestb_local_.decl.lent != NULL)
23136 ffelex_token_kill (ffestb_local_.decl.lent);
23137 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23138 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23139
23140 bad_i: /* :::::::::::::::::::: */
23141 if (ffestb_local_.decl.recursive != NULL)
23142 ffelex_token_kill (ffestb_local_.decl.recursive);
23143 if (ffestb_local_.decl.kindt != NULL)
23144 ffelex_token_kill (ffestb_local_.decl.kindt);
23145 if (ffestb_local_.decl.lent != NULL)
23146 ffelex_token_kill (ffestb_local_.decl.lent);
23147 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t, i, NULL);
23148 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23149 }
23150
23151 #endif
23152 /* ffestb_decl_funcname_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23153
23154 return ffestb_decl_funcname_; // to lexer
23155
23156 Handle NAME of a function. */
23157
23158 static ffelexHandler
23159 ffestb_decl_funcname_ (ffelexToken t)
23160 {
23161 switch (ffelex_token_type (t))
23162 {
23163 case FFELEX_typeNAME:
23164 ffesta_tokens[1] = ffelex_token_use (t);
23165 return (ffelexHandler) ffestb_decl_funcname_1_;
23166
23167 default:
23168 break;
23169 }
23170
23171 if (ffestb_local_.decl.recursive != NULL)
23172 ffelex_token_kill (ffestb_local_.decl.recursive);
23173 if (ffestb_local_.decl.kindt != NULL)
23174 ffelex_token_kill (ffestb_local_.decl.kindt);
23175 if (ffestb_local_.decl.lent != NULL)
23176 ffelex_token_kill (ffestb_local_.decl.lent);
23177 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23178 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23179 }
23180
23181 /* ffestb_decl_funcname_1_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23182 NAME
23183
23184 return ffestb_decl_funcname_1_; // to lexer
23185
23186 Handle ASTERISK or OPEN_PAREN. */
23187
23188 static ffelexHandler
23189 ffestb_decl_funcname_1_ (ffelexToken t)
23190 {
23191 switch (ffelex_token_type (t))
23192 {
23193 case FFELEX_typeASTERISK:
23194 return (ffelexHandler) ffestb_decl_funcname_2_;
23195
23196 case FFELEX_typeOPEN_PAREN:
23197 return (ffelexHandler) ffestb_decl_funcname_4_ (t);
23198
23199 default:
23200 break;
23201 }
23202
23203 if (ffestb_local_.decl.recursive != NULL)
23204 ffelex_token_kill (ffestb_local_.decl.recursive);
23205 if (ffestb_local_.decl.kindt != NULL)
23206 ffelex_token_kill (ffestb_local_.decl.kindt);
23207 if (ffestb_local_.decl.lent != NULL)
23208 ffelex_token_kill (ffestb_local_.decl.lent);
23209 ffelex_token_kill (ffesta_tokens[1]);
23210 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23211 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23212 }
23213
23214 /* ffestb_decl_funcname_2_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23215 NAME ASTERISK
23216
23217 return ffestb_decl_funcname_2_; // to lexer
23218
23219 Handle NUMBER or OPEN_PAREN. */
23220
23221 static ffelexHandler
23222 ffestb_decl_funcname_2_ (ffelexToken t)
23223 {
23224 switch (ffelex_token_type (t))
23225 {
23226 case FFELEX_typeNUMBER:
23227 switch (ffestb_local_.decl.type)
23228 {
23229 case FFESTP_typeINTEGER:
23230 case FFESTP_typeREAL:
23231 case FFESTP_typeCOMPLEX:
23232 case FFESTP_typeLOGICAL:
23233 if (ffestb_local_.decl.kindt == NULL)
23234 ffestb_local_.decl.kindt = ffelex_token_use (t);
23235 else
23236 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23237 break;
23238
23239 case FFESTP_typeCHARACTER:
23240 if (ffestb_local_.decl.lent == NULL)
23241 ffestb_local_.decl.lent = ffelex_token_use (t);
23242 else
23243 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23244 break;
23245
23246 case FFESTP_typeBYTE:
23247 case FFESTP_typeWORD:
23248 default:
23249 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23250 break;
23251 }
23252 return (ffelexHandler) ffestb_decl_funcname_4_;
23253
23254 case FFELEX_typeOPEN_PAREN:
23255 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
23256 FFEEXPR_contextCHARACTERSIZE,
23257 (ffeexprCallback) ffestb_decl_funcname_3_);
23258
23259 default:
23260 break;
23261 }
23262
23263 if (ffestb_local_.decl.recursive != NULL)
23264 ffelex_token_kill (ffestb_local_.decl.recursive);
23265 if (ffestb_local_.decl.kindt != NULL)
23266 ffelex_token_kill (ffestb_local_.decl.kindt);
23267 if (ffestb_local_.decl.lent != NULL)
23268 ffelex_token_kill (ffestb_local_.decl.lent);
23269 ffelex_token_kill (ffesta_tokens[1]);
23270 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23271 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23272 }
23273
23274 /* ffestb_decl_funcname_3_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23275 NAME ASTERISK OPEN_PAREN expr
23276
23277 (ffestb_decl_funcname_3_) // to expression handler
23278
23279 Allow only CLOSE_PAREN; and deal with character-length expression. */
23280
23281 static ffelexHandler
23282 ffestb_decl_funcname_3_ (ffelexToken ft, ffebld expr, ffelexToken t)
23283 {
23284 switch (ffelex_token_type (t))
23285 {
23286 case FFELEX_typeCLOSE_PAREN:
23287 if (expr == NULL)
23288 break;
23289 switch (ffestb_local_.decl.type)
23290 {
23291 case FFESTP_typeCHARACTER:
23292 if (ffestb_local_.decl.lent == NULL)
23293 {
23294 ffestb_local_.decl.len = expr;
23295 ffestb_local_.decl.lent = ffelex_token_use (ft);
23296 }
23297 else
23298 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23299 break;
23300
23301 default:
23302 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23303 break;
23304 }
23305 return (ffelexHandler) ffestb_decl_funcname_4_;
23306
23307 default:
23308 break;
23309 }
23310
23311 if (ffestb_local_.decl.recursive != NULL)
23312 ffelex_token_kill (ffestb_local_.decl.recursive);
23313 if (ffestb_local_.decl.kindt != NULL)
23314 ffelex_token_kill (ffestb_local_.decl.kindt);
23315 if (ffestb_local_.decl.lent != NULL)
23316 ffelex_token_kill (ffestb_local_.decl.lent);
23317 ffelex_token_kill (ffesta_tokens[1]);
23318 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23319 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23320 }
23321
23322 /* ffestb_decl_funcname_4_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23323 NAME [type parameter]
23324
23325 return ffestb_decl_funcname_4_; // to lexer
23326
23327 Make sure the next token is an OPEN_PAREN. Get the arg list and
23328 then implement. */
23329
23330 static ffelexHandler
23331 ffestb_decl_funcname_4_ (ffelexToken t)
23332 {
23333 switch (ffelex_token_type (t))
23334 {
23335 case FFELEX_typeOPEN_PAREN:
23336 ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
23337 ffestb_subrargs_.name_list.handler
23338 = (ffelexHandler) ffestb_decl_funcname_5_;
23339 ffestb_subrargs_.name_list.is_subr = FALSE;
23340 ffestb_subrargs_.name_list.names = FALSE;
23341 return (ffelexHandler) ffestb_subr_name_list_;
23342
23343 default:
23344 break;
23345 }
23346
23347 if (ffestb_local_.decl.recursive != NULL)
23348 ffelex_token_kill (ffestb_local_.decl.recursive);
23349 if (ffestb_local_.decl.kindt != NULL)
23350 ffelex_token_kill (ffestb_local_.decl.kindt);
23351 if (ffestb_local_.decl.lent != NULL)
23352 ffelex_token_kill (ffestb_local_.decl.lent);
23353 ffelex_token_kill (ffesta_tokens[1]);
23354 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23355 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23356 }
23357
23358 /* ffestb_decl_funcname_5_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23359 NAME [type parameter] OPEN_PAREN arg-list
23360 CLOSE_PAREN
23361
23362 return ffestb_decl_funcname_5_; // to lexer
23363
23364 Must have EOS/SEMICOLON or "RESULT" here. */
23365
23366 static ffelexHandler
23367 ffestb_decl_funcname_5_ (ffelexToken t)
23368 {
23369 if (!ffestb_subrargs_.name_list.ok)
23370 goto bad; /* :::::::::::::::::::: */
23371
23372 switch (ffelex_token_type (t))
23373 {
23374 case FFELEX_typeEOS:
23375 case FFELEX_typeSEMICOLON:
23376 ffesta_confirmed ();
23377 if (!ffesta_is_inhibited ())
23378 ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
23379 ffestb_subrargs_.name_list.close_paren, ffestb_local_.decl.type,
23380 ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
23381 ffestb_local_.decl.len, ffestb_local_.decl.lent,
23382 ffestb_local_.decl.recursive, NULL);
23383 if (ffestb_local_.decl.recursive != NULL)
23384 ffelex_token_kill (ffestb_local_.decl.recursive);
23385 if (ffestb_local_.decl.kindt != NULL)
23386 ffelex_token_kill (ffestb_local_.decl.kindt);
23387 if (ffestb_local_.decl.lent != NULL)
23388 ffelex_token_kill (ffestb_local_.decl.lent);
23389 ffelex_token_kill (ffesta_tokens[1]);
23390 ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23391 ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23392 return (ffelexHandler) ffesta_zero (t);
23393
23394 case FFELEX_typeNAME:
23395 if (ffestr_other (t) != FFESTR_otherRESULT)
23396 break;
23397 return (ffelexHandler) ffestb_decl_funcname_6_;
23398
23399 default:
23400 break;
23401 }
23402
23403 bad: /* :::::::::::::::::::: */
23404 if (ffestb_local_.decl.recursive != NULL)
23405 ffelex_token_kill (ffestb_local_.decl.recursive);
23406 if (ffestb_local_.decl.kindt != NULL)
23407 ffelex_token_kill (ffestb_local_.decl.kindt);
23408 if (ffestb_local_.decl.lent != NULL)
23409 ffelex_token_kill (ffestb_local_.decl.lent);
23410 ffelex_token_kill (ffesta_tokens[1]);
23411 ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23412 ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23413 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23414 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23415 }
23416
23417 /* ffestb_decl_funcname_6_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23418 NAME [type parameter] OPEN_PAREN arglist
23419 CLOSE_PAREN "RESULT"
23420
23421 return ffestb_decl_funcname_6_; // to lexer
23422
23423 Make sure the next token is an OPEN_PAREN. */
23424
23425 static ffelexHandler
23426 ffestb_decl_funcname_6_ (ffelexToken t)
23427 {
23428 switch (ffelex_token_type (t))
23429 {
23430 case FFELEX_typeOPEN_PAREN:
23431 return (ffelexHandler) ffestb_decl_funcname_7_;
23432
23433 default:
23434 break;
23435 }
23436
23437 if (ffestb_local_.decl.recursive != NULL)
23438 ffelex_token_kill (ffestb_local_.decl.recursive);
23439 if (ffestb_local_.decl.kindt != NULL)
23440 ffelex_token_kill (ffestb_local_.decl.kindt);
23441 if (ffestb_local_.decl.lent != NULL)
23442 ffelex_token_kill (ffestb_local_.decl.lent);
23443 ffelex_token_kill (ffesta_tokens[1]);
23444 ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23445 ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23446 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23447 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23448 }
23449
23450 /* ffestb_decl_funcname_7_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23451 NAME [type parameter] OPEN_PAREN arglist
23452 CLOSE_PAREN "RESULT" OPEN_PAREN
23453
23454 return ffestb_decl_funcname_7_; // to lexer
23455
23456 Make sure the next token is a NAME. */
23457
23458 static ffelexHandler
23459 ffestb_decl_funcname_7_ (ffelexToken t)
23460 {
23461 switch (ffelex_token_type (t))
23462 {
23463 case FFELEX_typeNAME:
23464 ffesta_tokens[2] = ffelex_token_use (t);
23465 return (ffelexHandler) ffestb_decl_funcname_8_;
23466
23467 default:
23468 break;
23469 }
23470
23471 if (ffestb_local_.decl.recursive != NULL)
23472 ffelex_token_kill (ffestb_local_.decl.recursive);
23473 if (ffestb_local_.decl.kindt != NULL)
23474 ffelex_token_kill (ffestb_local_.decl.kindt);
23475 if (ffestb_local_.decl.lent != NULL)
23476 ffelex_token_kill (ffestb_local_.decl.lent);
23477 ffelex_token_kill (ffesta_tokens[1]);
23478 ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23479 ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23480 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23481 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23482 }
23483
23484 /* ffestb_decl_funcname_8_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23485 NAME [type parameter] OPEN_PAREN arglist
23486 CLOSE_PAREN "RESULT" OPEN_PAREN NAME
23487
23488 return ffestb_decl_funcname_8_; // to lexer
23489
23490 Make sure the next token is a CLOSE_PAREN. */
23491
23492 static ffelexHandler
23493 ffestb_decl_funcname_8_ (ffelexToken t)
23494 {
23495 switch (ffelex_token_type (t))
23496 {
23497 case FFELEX_typeCLOSE_PAREN:
23498 return (ffelexHandler) ffestb_decl_funcname_9_;
23499
23500 default:
23501 break;
23502 }
23503
23504 if (ffestb_local_.decl.recursive != NULL)
23505 ffelex_token_kill (ffestb_local_.decl.recursive);
23506 if (ffestb_local_.decl.kindt != NULL)
23507 ffelex_token_kill (ffestb_local_.decl.kindt);
23508 if (ffestb_local_.decl.lent != NULL)
23509 ffelex_token_kill (ffestb_local_.decl.lent);
23510 ffelex_token_kill (ffesta_tokens[1]);
23511 ffelex_token_kill (ffesta_tokens[2]);
23512 ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23513 ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23514 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23515 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23516 }
23517
23518 /* ffestb_decl_funcname_9_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23519 NAME [type parameter] OPEN_PAREN arg-list
23520 CLOSE_PAREN "RESULT" OPEN_PAREN NAME CLOSE_PAREN
23521
23522 return ffestb_decl_funcname_9_; // to lexer
23523
23524 Must have EOS/SEMICOLON here. */
23525
23526 static ffelexHandler
23527 ffestb_decl_funcname_9_ (ffelexToken t)
23528 {
23529 switch (ffelex_token_type (t))
23530 {
23531 case FFELEX_typeEOS:
23532 case FFELEX_typeSEMICOLON:
23533 if (!ffesta_is_inhibited ())
23534 ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
23535 ffestb_subrargs_.name_list.close_paren, ffestb_local_.decl.type,
23536 ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
23537 ffestb_local_.decl.len, ffestb_local_.decl.lent,
23538 ffestb_local_.decl.recursive, ffesta_tokens[2]);
23539 if (ffestb_local_.decl.recursive != NULL)
23540 ffelex_token_kill (ffestb_local_.decl.recursive);
23541 if (ffestb_local_.decl.kindt != NULL)
23542 ffelex_token_kill (ffestb_local_.decl.kindt);
23543 if (ffestb_local_.decl.lent != NULL)
23544 ffelex_token_kill (ffestb_local_.decl.lent);
23545 ffelex_token_kill (ffesta_tokens[1]);
23546 ffelex_token_kill (ffesta_tokens[2]);
23547 ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23548 ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23549 return (ffelexHandler) ffesta_zero (t);
23550
23551 default:
23552 break;
23553 }
23554
23555 if (ffestb_local_.decl.recursive != NULL)
23556 ffelex_token_kill (ffestb_local_.decl.recursive);
23557 if (ffestb_local_.decl.kindt != NULL)
23558 ffelex_token_kill (ffestb_local_.decl.kindt);
23559 if (ffestb_local_.decl.lent != NULL)
23560 ffelex_token_kill (ffestb_local_.decl.lent);
23561 ffelex_token_kill (ffesta_tokens[1]);
23562 ffelex_token_kill (ffesta_tokens[2]);
23563 ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23564 ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23565 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23566 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23567 }
23568
23569 /* ffestb_V003 -- Parse the STRUCTURE statement
23570
23571 return ffestb_V003; // to lexer
23572
23573 Make sure the statement has a valid form for the STRUCTURE statement.
23574 If it does, implement the statement. */
23575
23576 #if FFESTR_VXT
23577 ffelexHandler
23578 ffestb_V003 (ffelexToken t)
23579 {
23580 ffeTokenLength i;
23581 const char *p;
23582 ffelexToken nt;
23583 ffelexHandler next;
23584
23585 switch (ffelex_token_type (ffesta_tokens[0]))
23586 {
23587 case FFELEX_typeNAME:
23588 if (ffesta_first_kw != FFESTR_firstSTRUCTURE)
23589 goto bad_0; /* :::::::::::::::::::: */
23590 switch (ffelex_token_type (t))
23591 {
23592 case FFELEX_typeCOMMA:
23593 case FFELEX_typeCOLONCOLON:
23594 case FFELEX_typeEOS:
23595 case FFELEX_typeSEMICOLON:
23596 ffesta_confirmed (); /* Error, but clearly intended. */
23597 goto bad_1; /* :::::::::::::::::::: */
23598
23599 default:
23600 goto bad_1; /* :::::::::::::::::::: */
23601
23602 case FFELEX_typeNAME:
23603 ffesta_confirmed ();
23604 if (!ffesta_is_inhibited ())
23605 ffestc_V003_start (NULL);
23606 ffestb_local_.structure.started = TRUE;
23607 return (ffelexHandler) ffestb_V0034_ (t);
23608
23609 case FFELEX_typeSLASH:
23610 ffesta_confirmed ();
23611 return (ffelexHandler) ffestb_V0031_;
23612 }
23613
23614 case FFELEX_typeNAMES:
23615 if (ffesta_first_kw != FFESTR_firstSTRUCTURE)
23616 goto bad_0; /* :::::::::::::::::::: */
23617 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSTRUCTURE);
23618 switch (ffelex_token_type (t))
23619 {
23620 default:
23621 goto bad_1; /* :::::::::::::::::::: */
23622
23623 case FFELEX_typeEOS:
23624 case FFELEX_typeSEMICOLON:
23625 case FFELEX_typeCOMMA:
23626 case FFELEX_typeCOLONCOLON:
23627 ffesta_confirmed ();
23628 break;
23629
23630 case FFELEX_typeSLASH:
23631 ffesta_confirmed ();
23632 if (*p != '\0')
23633 goto bad_1; /* :::::::::::::::::::: */
23634 return (ffelexHandler) ffestb_V0031_;
23635
23636 case FFELEX_typeOPEN_PAREN:
23637 break;
23638 }
23639
23640 /* Here, we have at least one char after "STRUCTURE" and t is COMMA,
23641 EOS/SEMICOLON, or OPEN_PAREN. */
23642
23643 if (!ffesrc_is_name_init (*p))
23644 goto bad_i; /* :::::::::::::::::::: */
23645 nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
23646 if (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN)
23647 ffestb_local_.structure.started = FALSE;
23648 else
23649 {
23650 if (!ffesta_is_inhibited ())
23651 ffestc_V003_start (NULL);
23652 ffestb_local_.structure.started = TRUE;
23653 }
23654 next = (ffelexHandler) ffestb_V0034_ (nt);
23655 ffelex_token_kill (nt);
23656 return (ffelexHandler) (*next) (t);
23657
23658 default:
23659 goto bad_0; /* :::::::::::::::::::: */
23660 }
23661
23662 bad_0: /* :::::::::::::::::::: */
23663 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", ffesta_tokens[0]);
23664 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23665
23666 bad_1: /* :::::::::::::::::::: */
23667 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23668 return (ffelexHandler) ffelex_swallow_tokens (t,
23669 (ffelexHandler) ffesta_zero); /* Invalid second token. */
23670
23671 bad_i: /* :::::::::::::::::::: */
23672 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", ffesta_tokens[0], i, t);
23673 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23674 }
23675
23676 /* ffestb_V0031_ -- "STRUCTURE" SLASH
23677
23678 return ffestb_V0031_; // to lexer
23679
23680 Handle NAME. */
23681
23682 static ffelexHandler
23683 ffestb_V0031_ (ffelexToken t)
23684 {
23685 switch (ffelex_token_type (t))
23686 {
23687 case FFELEX_typeNAME:
23688 ffesta_tokens[1] = ffelex_token_use (t);
23689 return (ffelexHandler) ffestb_V0032_;
23690
23691 default:
23692 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23693 break;
23694 }
23695
23696 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23697 }
23698
23699 /* ffestb_V0032_ -- "STRUCTURE" SLASH NAME
23700
23701 return ffestb_V0032_; // to lexer
23702
23703 Handle SLASH. */
23704
23705 static ffelexHandler
23706 ffestb_V0032_ (ffelexToken t)
23707 {
23708 switch (ffelex_token_type (t))
23709 {
23710 case FFELEX_typeSLASH:
23711 if (!ffesta_is_inhibited ())
23712 ffestc_V003_start (ffesta_tokens[1]);
23713 ffestb_local_.structure.started = TRUE;
23714 ffelex_token_kill (ffesta_tokens[1]);
23715 return (ffelexHandler) ffestb_V0033_;
23716
23717 default:
23718 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23719 break;
23720 }
23721
23722 ffelex_token_kill (ffesta_tokens[1]);
23723 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23724 }
23725
23726 /* ffestb_V0033_ -- "STRUCTURE" SLASH NAME SLASH
23727
23728 return ffestb_V0033_; // to lexer
23729
23730 Handle NAME or EOS/SEMICOLON. */
23731
23732 static ffelexHandler
23733 ffestb_V0033_ (ffelexToken t)
23734 {
23735 switch (ffelex_token_type (t))
23736 {
23737 case FFELEX_typeNAME:
23738 return (ffelexHandler) ffestb_V0034_ (t);
23739
23740 case FFELEX_typeEOS:
23741 case FFELEX_typeSEMICOLON:
23742 if (!ffesta_is_inhibited ())
23743 ffestc_V003_finish ();
23744 return (ffelexHandler) ffesta_zero (t);
23745
23746 default:
23747 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23748 break;
23749 }
23750
23751 ffelex_token_kill (ffesta_tokens[1]);
23752 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23753 }
23754
23755 /* ffestb_V0034_ -- "STRUCTURE" [SLASH NAME SLASH]
23756
23757 return ffestb_V0034_; // to lexer
23758
23759 Handle NAME. */
23760
23761 static ffelexHandler
23762 ffestb_V0034_ (ffelexToken t)
23763 {
23764 switch (ffelex_token_type (t))
23765 {
23766 case FFELEX_typeNAME:
23767 ffesta_tokens[1] = ffelex_token_use (t);
23768 return (ffelexHandler) ffestb_V0035_;
23769
23770 default:
23771 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23772 break;
23773 }
23774
23775 if (!ffesta_is_inhibited ())
23776 ffestc_V003_finish ();
23777 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23778 }
23779
23780 /* ffestb_V0035_ -- "STRUCTURE" ... NAME
23781
23782 return ffestb_V0035_; // to lexer
23783
23784 Handle OPEN_PAREN. */
23785
23786 static ffelexHandler
23787 ffestb_V0035_ (ffelexToken t)
23788 {
23789 switch (ffelex_token_type (t))
23790 {
23791 case FFELEX_typeOPEN_PAREN:
23792 ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
23793 ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_V0036_;
23794 ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
23795 ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
23796 #ifdef FFECOM_dimensionsMAX
23797 ffestb_subrargs_.dim_list.ndims = 0;
23798 #endif
23799 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
23800 FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
23801
23802 case FFELEX_typeCOMMA:
23803 if (!ffesta_is_inhibited ())
23804 ffestc_V003_item (ffesta_tokens[1], NULL);
23805 ffelex_token_kill (ffesta_tokens[1]);
23806 return (ffelexHandler) ffestb_V0034_;
23807
23808 case FFELEX_typeEOS:
23809 case FFELEX_typeSEMICOLON:
23810 if (!ffesta_is_inhibited ())
23811 {
23812 ffestc_V003_item (ffesta_tokens[1], NULL);
23813 ffestc_V003_finish ();
23814 }
23815 ffelex_token_kill (ffesta_tokens[1]);
23816 return (ffelexHandler) ffesta_zero (t);
23817
23818 default:
23819 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23820 break;
23821 }
23822
23823 if (!ffesta_is_inhibited ())
23824 ffestc_V003_finish ();
23825 ffelex_token_kill (ffesta_tokens[1]);
23826 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23827 }
23828
23829 /* ffestb_V0036_ -- "STRUCTURE" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
23830
23831 return ffestb_V0036_; // to lexer
23832
23833 Handle COMMA or EOS/SEMICOLON. */
23834
23835 static ffelexHandler
23836 ffestb_V0036_ (ffelexToken t)
23837 {
23838 if (!ffestb_subrargs_.dim_list.ok)
23839 goto bad; /* :::::::::::::::::::: */
23840
23841 switch (ffelex_token_type (t))
23842 {
23843 case FFELEX_typeCOMMA:
23844 ffesta_confirmed ();
23845 if (!ffesta_is_inhibited ())
23846 {
23847 if (!ffestb_local_.structure.started)
23848 {
23849 ffestc_V003_start (NULL);
23850 ffestb_local_.structure.started = TRUE;
23851 }
23852 ffestc_V003_item (ffesta_tokens[1],
23853 ffestb_subrargs_.dim_list.dims);
23854 }
23855 ffelex_token_kill (ffesta_tokens[1]);
23856 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
23857 return (ffelexHandler) ffestb_V0034_;
23858
23859 case FFELEX_typeEOS:
23860 case FFELEX_typeSEMICOLON:
23861 ffesta_confirmed ();
23862 if (!ffesta_is_inhibited ())
23863 {
23864 if (!ffestb_local_.structure.started)
23865 ffestc_V003_start (NULL);
23866 ffestc_V003_item (ffesta_tokens[1],
23867 ffestb_subrargs_.dim_list.dims);
23868 ffestc_V003_finish ();
23869 }
23870 ffelex_token_kill (ffesta_tokens[1]);
23871 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
23872 return (ffelexHandler) ffesta_zero (t);
23873
23874 default:
23875 break;
23876 }
23877
23878 bad: /* :::::::::::::::::::: */
23879 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23880 if (ffestb_local_.structure.started && !ffesta_is_inhibited ())
23881 ffestc_V003_finish ();
23882 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
23883 ffelex_token_kill (ffesta_tokens[1]);
23884 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23885 }
23886
23887 /* ffestb_V016 -- Parse the RECORD statement
23888
23889 return ffestb_V016; // to lexer
23890
23891 Make sure the statement has a valid form for the RECORD statement. If it
23892 does, implement the statement. */
23893
23894 ffelexHandler
23895 ffestb_V016 (ffelexToken t)
23896 {
23897 const char *p;
23898 ffeTokenLength i;
23899
23900 switch (ffelex_token_type (ffesta_tokens[0]))
23901 {
23902 case FFELEX_typeNAME:
23903 if (ffesta_first_kw != FFESTR_firstRECORD)
23904 goto bad_0; /* :::::::::::::::::::: */
23905 break;
23906
23907 case FFELEX_typeNAMES:
23908 if (ffesta_first_kw != FFESTR_firstRECORD)
23909 goto bad_0; /* :::::::::::::::::::: */
23910 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlRECORD);
23911 if (*p != '\0')
23912 goto bad_i; /* :::::::::::::::::::: */
23913 break;
23914
23915 default:
23916 goto bad_0; /* :::::::::::::::::::: */
23917 }
23918
23919 switch (ffelex_token_type (t))
23920 {
23921 case FFELEX_typeCOMMA:
23922 case FFELEX_typeEOS:
23923 case FFELEX_typeSEMICOLON:
23924 case FFELEX_typeCOLONCOLON:
23925 ffesta_confirmed (); /* Error, but clearly intended. */
23926 goto bad_1; /* :::::::::::::::::::: */
23927
23928 default:
23929 goto bad_1; /* :::::::::::::::::::: */
23930
23931 case FFELEX_typeSLASH:
23932 break;
23933 }
23934
23935 ffesta_confirmed ();
23936 if (!ffesta_is_inhibited ())
23937 ffestc_V016_start ();
23938 return (ffelexHandler) ffestb_V0161_;
23939
23940 bad_0: /* :::::::::::::::::::: */
23941 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", ffesta_tokens[0]);
23942 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23943
23944 bad_1: /* :::::::::::::::::::: */
23945 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
23946 return (ffelexHandler) ffelex_swallow_tokens (t,
23947 (ffelexHandler) ffesta_zero); /* Invalid second token. */
23948
23949 bad_i: /* :::::::::::::::::::: */
23950 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "RECORD", ffesta_tokens[0], i, t);
23951 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23952 }
23953
23954 /* ffestb_V0161_ -- "RECORD" SLASH
23955
23956 return ffestb_V0161_; // to lexer
23957
23958 Handle NAME. */
23959
23960 static ffelexHandler
23961 ffestb_V0161_ (ffelexToken t)
23962 {
23963 switch (ffelex_token_type (t))
23964 {
23965 case FFELEX_typeNAME:
23966 if (!ffesta_is_inhibited ())
23967 ffestc_V016_item_structure (t);
23968 return (ffelexHandler) ffestb_V0162_;
23969
23970 default:
23971 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
23972 break;
23973 }
23974
23975 if (!ffesta_is_inhibited ())
23976 ffestc_V016_finish ();
23977 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23978 }
23979
23980 /* ffestb_V0162_ -- "RECORD" SLASH NAME
23981
23982 return ffestb_V0162_; // to lexer
23983
23984 Handle SLASH. */
23985
23986 static ffelexHandler
23987 ffestb_V0162_ (ffelexToken t)
23988 {
23989 switch (ffelex_token_type (t))
23990 {
23991 case FFELEX_typeSLASH:
23992 return (ffelexHandler) ffestb_V0163_;
23993
23994 default:
23995 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
23996 break;
23997 }
23998
23999 if (!ffesta_is_inhibited ())
24000 ffestc_V016_finish ();
24001 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24002 }
24003
24004 /* ffestb_V0163_ -- "RECORD" SLASH NAME SLASH
24005
24006 return ffestb_V0163_; // to lexer
24007
24008 Handle NAME. */
24009
24010 static ffelexHandler
24011 ffestb_V0163_ (ffelexToken t)
24012 {
24013 switch (ffelex_token_type (t))
24014 {
24015 case FFELEX_typeNAME:
24016 ffesta_tokens[1] = ffelex_token_use (t);
24017 return (ffelexHandler) ffestb_V0164_;
24018
24019 default:
24020 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24021 break;
24022 }
24023
24024 if (!ffesta_is_inhibited ())
24025 ffestc_V016_finish ();
24026 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24027 }
24028
24029 /* ffestb_V0164_ -- "RECORD" ... NAME
24030
24031 return ffestb_V0164_; // to lexer
24032
24033 Handle OPEN_PAREN. */
24034
24035 static ffelexHandler
24036 ffestb_V0164_ (ffelexToken t)
24037 {
24038 switch (ffelex_token_type (t))
24039 {
24040 case FFELEX_typeOPEN_PAREN:
24041 ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
24042 ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_V0165_;
24043 ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
24044 ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
24045 #ifdef FFECOM_dimensionsMAX
24046 ffestb_subrargs_.dim_list.ndims = 0;
24047 #endif
24048 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
24049 FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
24050
24051 case FFELEX_typeCOMMA:
24052 if (!ffesta_is_inhibited ())
24053 ffestc_V016_item_object (ffesta_tokens[1], NULL);
24054 ffelex_token_kill (ffesta_tokens[1]);
24055 return (ffelexHandler) ffestb_V0166_;
24056
24057 case FFELEX_typeEOS:
24058 case FFELEX_typeSEMICOLON:
24059 if (!ffesta_is_inhibited ())
24060 {
24061 ffestc_V016_item_object (ffesta_tokens[1], NULL);
24062 ffestc_V016_finish ();
24063 }
24064 ffelex_token_kill (ffesta_tokens[1]);
24065 return (ffelexHandler) ffesta_zero (t);
24066
24067 default:
24068 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24069 break;
24070 }
24071
24072 if (!ffesta_is_inhibited ())
24073 ffestc_V016_finish ();
24074 ffelex_token_kill (ffesta_tokens[1]);
24075 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24076 }
24077
24078 /* ffestb_V0165_ -- "RECORD" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
24079
24080 return ffestb_V0165_; // to lexer
24081
24082 Handle COMMA or EOS/SEMICOLON. */
24083
24084 static ffelexHandler
24085 ffestb_V0165_ (ffelexToken t)
24086 {
24087 if (!ffestb_subrargs_.dim_list.ok)
24088 goto bad; /* :::::::::::::::::::: */
24089
24090 switch (ffelex_token_type (t))
24091 {
24092 case FFELEX_typeCOMMA:
24093 if (!ffesta_is_inhibited ())
24094 ffestc_V016_item_object (ffesta_tokens[1],
24095 ffestb_subrargs_.dim_list.dims);
24096 ffelex_token_kill (ffesta_tokens[1]);
24097 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
24098 return (ffelexHandler) ffestb_V0166_;
24099
24100 case FFELEX_typeEOS:
24101 case FFELEX_typeSEMICOLON:
24102 if (!ffesta_is_inhibited ())
24103 {
24104 ffestc_V016_item_object (ffesta_tokens[1],
24105 ffestb_subrargs_.dim_list.dims);
24106 ffestc_V016_finish ();
24107 }
24108 ffelex_token_kill (ffesta_tokens[1]);
24109 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
24110 return (ffelexHandler) ffesta_zero (t);
24111
24112 default:
24113 break;
24114 }
24115
24116 bad: /* :::::::::::::::::::: */
24117 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24118 if (ffestb_local_.structure.started && !ffesta_is_inhibited ())
24119 ffestc_V016_finish ();
24120 ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
24121 ffelex_token_kill (ffesta_tokens[1]);
24122 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24123 }
24124
24125 /* ffestb_V0166_ -- "RECORD" SLASH NAME SLASH NAME [OPEN_PAREN dimlist
24126 CLOSE_PAREN] COMMA
24127
24128 return ffestb_V0166_; // to lexer
24129
24130 Handle NAME or SLASH. */
24131
24132 static ffelexHandler
24133 ffestb_V0166_ (ffelexToken t)
24134 {
24135 switch (ffelex_token_type (t))
24136 {
24137 case FFELEX_typeNAME:
24138 ffesta_tokens[1] = ffelex_token_use (t);
24139 return (ffelexHandler) ffestb_V0164_;
24140
24141 case FFELEX_typeSLASH:
24142 return (ffelexHandler) ffestb_V0161_;
24143
24144 default:
24145 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24146 break;
24147 }
24148
24149 if (!ffesta_is_inhibited ())
24150 ffestc_V016_finish ();
24151 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24152 }
24153
24154 #endif
24155 /* ffestb_V027 -- Parse the VXT PARAMETER statement
24156
24157 return ffestb_V027; // to lexer
24158
24159 Make sure the statement has a valid form for the VXT PARAMETER statement.
24160 If it does, implement the statement. */
24161
24162 ffelexHandler
24163 ffestb_V027 (ffelexToken t)
24164 {
24165 unsigned const char *p;
24166 ffeTokenLength i;
24167
24168 switch (ffelex_token_type (ffesta_tokens[0]))
24169 {
24170 case FFELEX_typeNAME:
24171 if (ffesta_first_kw != FFESTR_firstPARAMETER)
24172 goto bad_0; /* :::::::::::::::::::: */
24173 switch (ffelex_token_type (t))
24174 {
24175 case FFELEX_typeNAME:
24176 break;
24177
24178 default:
24179 goto bad_1; /* :::::::::::::::::::: */
24180 }
24181 ffesta_confirmed ();
24182 ffestb_local_.vxtparam.started = TRUE;
24183 if (!ffesta_is_inhibited ())
24184 ffestc_V027_start ();
24185 ffesta_tokens[1] = ffelex_token_use (t);
24186 return (ffelexHandler) ffestb_V0271_;
24187
24188 case FFELEX_typeNAMES:
24189 if (ffesta_first_kw != FFESTR_firstPARAMETER)
24190 goto bad_0; /* :::::::::::::::::::: */
24191 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlPARAMETER);
24192 switch (ffelex_token_type (t))
24193 {
24194 case FFELEX_typeEQUALS:
24195 break;
24196
24197 default:
24198 goto bad_1; /* :::::::::::::::::::: */
24199 }
24200 if (!ffesrc_is_name_init (*p))
24201 goto bad_i; /* :::::::::::::::::::: */
24202 ffestb_local_.vxtparam.started = FALSE;
24203 ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i,
24204 0);
24205 return (ffelexHandler) ffestb_V0271_ (t);
24206
24207 default:
24208 goto bad_0; /* :::::::::::::::::::: */
24209 }
24210
24211 bad_0: /* :::::::::::::::::::: */
24212 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0]);
24213 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24214
24215 bad_1: /* :::::::::::::::::::: */
24216 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24217 return (ffelexHandler) ffelex_swallow_tokens (t,
24218 (ffelexHandler) ffesta_zero); /* Invalid second token. */
24219
24220 bad_i: /* :::::::::::::::::::: */
24221 ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0], i, t);
24222 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24223 }
24224
24225 /* ffestb_V0271_ -- "PARAMETER" NAME
24226
24227 return ffestb_V0271_; // to lexer
24228
24229 Handle EQUALS. */
24230
24231 static ffelexHandler
24232 ffestb_V0271_ (ffelexToken t)
24233 {
24234 switch (ffelex_token_type (t))
24235 {
24236 case FFELEX_typeEQUALS:
24237 return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
24238 FFEEXPR_contextPARAMETER, (ffeexprCallback) ffestb_V0272_);
24239
24240 default:
24241 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24242 break;
24243 }
24244
24245 ffelex_token_kill (ffesta_tokens[1]);
24246 if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
24247 ffestc_V027_finish ();
24248 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24249 }
24250
24251 /* ffestb_V0272_ -- "PARAMETER" NAME EQUALS expr
24252
24253 (ffestb_V0272_) // to expression handler
24254
24255 Handle COMMA or EOS/SEMICOLON. */
24256
24257 static ffelexHandler
24258 ffestb_V0272_ (ffelexToken ft, ffebld expr, ffelexToken t)
24259 {
24260 switch (ffelex_token_type (t))
24261 {
24262 case FFELEX_typeEOS:
24263 case FFELEX_typeSEMICOLON:
24264 if (!ffestb_local_.vxtparam.started)
24265 {
24266 if (ffestc_is_let_not_V027 ())
24267 break; /* Not a valid VXTPARAMETER stmt. */
24268 ffesta_confirmed ();
24269 if (!ffesta_is_inhibited ())
24270 ffestc_V027_start ();
24271 ffestb_local_.vxtparam.started = TRUE;
24272 }
24273 if (expr == NULL)
24274 break;
24275 if (!ffesta_is_inhibited ())
24276 {
24277 ffestc_V027_item (ffesta_tokens[1], expr, ft);
24278 ffestc_V027_finish ();
24279 }
24280 ffelex_token_kill (ffesta_tokens[1]);
24281 return (ffelexHandler) ffesta_zero (t);
24282
24283 case FFELEX_typeCOMMA:
24284 ffesta_confirmed ();
24285 if (!ffestb_local_.vxtparam.started)
24286 {
24287 if (!ffesta_is_inhibited ())
24288 ffestc_V027_start ();
24289 ffestb_local_.vxtparam.started = TRUE;
24290 }
24291 if (expr == NULL)
24292 break;
24293 if (!ffesta_is_inhibited ())
24294 ffestc_V027_item (ffesta_tokens[1], expr, ft);
24295 ffelex_token_kill (ffesta_tokens[1]);
24296 return (ffelexHandler) ffestb_V0273_;
24297
24298 default:
24299 break;
24300 }
24301
24302 ffelex_token_kill (ffesta_tokens[1]);
24303 if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
24304 ffestc_V027_finish ();
24305 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24306 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24307 }
24308
24309 /* ffestb_V0273_ -- "PARAMETER" NAME EQUALS expr COMMA
24310
24311 return ffestb_V0273_; // to lexer
24312
24313 Handle NAME. */
24314
24315 static ffelexHandler
24316 ffestb_V0273_ (ffelexToken t)
24317 {
24318 switch (ffelex_token_type (t))
24319 {
24320 case FFELEX_typeNAME:
24321 ffesta_tokens[1] = ffelex_token_use (t);
24322 return (ffelexHandler) ffestb_V0271_;
24323
24324 default:
24325 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24326 break;
24327 }
24328
24329 if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
24330 ffestc_V027_finish ();
24331 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24332 }
24333
24334 /* ffestb_decl_R539 -- Parse the IMPLICIT FUNCTION statement
24335
24336 return ffestb_decl_R539; // to lexer
24337
24338 Make sure the statement has a valid form for the IMPLICIT
24339 statement. If it does, implement the statement. */
24340
24341 ffelexHandler
24342 ffestb_decl_R539 (ffelexToken t)
24343 {
24344 ffeTokenLength i;
24345 unsigned const char *p;
24346 ffelexToken nt;
24347 ffestrSecond kw;
24348
24349 ffestb_local_.decl.recursive = NULL;
24350
24351 switch (ffelex_token_type (ffesta_tokens[0]))
24352 {
24353 case FFELEX_typeNAME:
24354 if (ffesta_first_kw != FFESTR_firstIMPLICIT)
24355 goto bad_0; /* :::::::::::::::::::: */
24356 switch (ffelex_token_type (t))
24357 {
24358 case FFELEX_typeEOS:
24359 case FFELEX_typeSEMICOLON:
24360 case FFELEX_typeCOMMA:
24361 case FFELEX_typeCOLONCOLON:
24362 ffesta_confirmed (); /* Error, but clearly intended. */
24363 goto bad_1; /* :::::::::::::::::::: */
24364
24365 default:
24366 goto bad_1; /* :::::::::::::::::::: */
24367
24368 case FFELEX_typeNAME:
24369 break;
24370 }
24371 ffesta_confirmed ();
24372 ffestb_local_.decl.imp_started = FALSE;
24373 switch (ffesta_second_kw)
24374 {
24375 case FFESTR_secondINTEGER:
24376 ffestb_local_.decl.type = FFESTP_typeINTEGER;
24377 return (ffelexHandler) ffestb_decl_R5391_;
24378
24379 case FFESTR_secondBYTE:
24380 ffestb_local_.decl.type = FFESTP_typeBYTE;
24381 return (ffelexHandler) ffestb_decl_R5391_;
24382
24383 case FFESTR_secondWORD:
24384 ffestb_local_.decl.type = FFESTP_typeWORD;
24385 return (ffelexHandler) ffestb_decl_R5391_;
24386
24387 case FFESTR_secondREAL:
24388 ffestb_local_.decl.type = FFESTP_typeREAL;
24389 return (ffelexHandler) ffestb_decl_R5391_;
24390
24391 case FFESTR_secondCOMPLEX:
24392 ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
24393 return (ffelexHandler) ffestb_decl_R5391_;
24394
24395 case FFESTR_secondLOGICAL:
24396 ffestb_local_.decl.type = FFESTP_typeLOGICAL;
24397 return (ffelexHandler) ffestb_decl_R5391_;
24398
24399 case FFESTR_secondCHARACTER:
24400 ffestb_local_.decl.type = FFESTP_typeCHARACTER;
24401 return (ffelexHandler) ffestb_decl_R5391_;
24402
24403 case FFESTR_secondDOUBLE:
24404 return (ffelexHandler) ffestb_decl_R5392_;
24405
24406 case FFESTR_secondDOUBLEPRECISION:
24407 ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24408 ffestb_local_.decl.kind = NULL;
24409 ffestb_local_.decl.kindt = NULL;
24410 ffestb_local_.decl.len = NULL;
24411 ffestb_local_.decl.lent = NULL;
24412 return (ffelexHandler) ffestb_decl_R539letters_;
24413
24414 case FFESTR_secondDOUBLECOMPLEX:
24415 ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24416 ffestb_local_.decl.kind = NULL;
24417 ffestb_local_.decl.kindt = NULL;
24418 ffestb_local_.decl.len = NULL;
24419 ffestb_local_.decl.lent = NULL;
24420 return (ffelexHandler) ffestb_decl_R539letters_;
24421
24422 case FFESTR_secondNONE:
24423 return (ffelexHandler) ffestb_decl_R5394_;
24424
24425 #if FFESTR_F90
24426 case FFESTR_secondTYPE:
24427 ffestb_local_.decl.type = FFESTP_typeTYPE;
24428 return (ffelexHandler) ffestb_decl_R5393_;
24429 #endif
24430
24431 default:
24432 goto bad_1; /* :::::::::::::::::::: */
24433 }
24434
24435 case FFELEX_typeNAMES:
24436 if (ffesta_first_kw != FFESTR_firstIMPLICIT)
24437 goto bad_0; /* :::::::::::::::::::: */
24438 switch (ffelex_token_type (t))
24439 {
24440 case FFELEX_typeCOMMA:
24441 case FFELEX_typeCOLONCOLON:
24442 case FFELEX_typeASTERISK:
24443 case FFELEX_typeSEMICOLON:
24444 case FFELEX_typeEOS:
24445 ffesta_confirmed ();
24446 break;
24447
24448 case FFELEX_typeOPEN_PAREN:
24449 break;
24450
24451 default:
24452 goto bad_1; /* :::::::::::::::::::: */
24453 }
24454 p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlIMPLICIT);
24455 if (!ffesrc_is_name_init (*p))
24456 goto bad_0; /* :::::::::::::::::::: */
24457 ffestb_local_.decl.imp_started = FALSE;
24458 nt = ffelex_token_name_from_names (ffesta_tokens[0],
24459 FFESTR_firstlIMPLICIT, 0);
24460 kw = ffestr_second (nt);
24461 ffelex_token_kill (nt);
24462 switch (kw)
24463 {
24464 case FFESTR_secondINTEGER:
24465 ffestb_local_.decl.type = FFESTP_typeINTEGER;
24466 return (ffelexHandler) ffestb_decl_R5391_ (t);
24467
24468 case FFESTR_secondBYTE:
24469 ffestb_local_.decl.type = FFESTP_typeBYTE;
24470 return (ffelexHandler) ffestb_decl_R5391_ (t);
24471
24472 case FFESTR_secondWORD:
24473 ffestb_local_.decl.type = FFESTP_typeWORD;
24474 return (ffelexHandler) ffestb_decl_R5391_ (t);
24475
24476 case FFESTR_secondREAL:
24477 ffestb_local_.decl.type = FFESTP_typeREAL;
24478 return (ffelexHandler) ffestb_decl_R5391_ (t);
24479
24480 case FFESTR_secondCOMPLEX:
24481 ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
24482 return (ffelexHandler) ffestb_decl_R5391_ (t);
24483
24484 case FFESTR_secondLOGICAL:
24485 ffestb_local_.decl.type = FFESTP_typeLOGICAL;
24486 return (ffelexHandler) ffestb_decl_R5391_ (t);
24487
24488 case FFESTR_secondCHARACTER:
24489 ffestb_local_.decl.type = FFESTP_typeCHARACTER;
24490 return (ffelexHandler) ffestb_decl_R5391_ (t);
24491
24492 case FFESTR_secondDOUBLEPRECISION:
24493 ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24494 ffestb_local_.decl.kind = NULL;
24495 ffestb_local_.decl.kindt = NULL;
24496 ffestb_local_.decl.len = NULL;
24497 ffestb_local_.decl.lent = NULL;
24498 return (ffelexHandler) ffestb_decl_R539letters_ (t);
24499
24500 case FFESTR_secondDOUBLECOMPLEX:
24501 ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24502 ffestb_local_.decl.kind = NULL;
24503 ffestb_local_.decl.kindt = NULL;
24504 ffestb_local_.decl.len = NULL;
24505 ffestb_local_.decl.lent = NULL;
24506 return (ffelexHandler) ffestb_decl_R539letters_ (t);
24507
24508 case FFESTR_secondNONE:
24509 return (ffelexHandler) ffestb_decl_R5394_ (t);
24510
24511 #if FFESTR_F90
24512 case FFESTR_secondTYPE:
24513 ffestb_local_.decl.type = FFESTP_typeTYPE;
24514 return (ffelexHandler) ffestb_decl_R5393_ (t);
24515 #endif
24516
24517 default:
24518 goto bad_1; /* :::::::::::::::::::: */
24519 }
24520
24521 default:
24522 goto bad_0; /* :::::::::::::::::::: */
24523 }
24524
24525 bad_0: /* :::::::::::::::::::: */
24526 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", ffesta_tokens[0]);
24527 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24528
24529 bad_1: /* :::::::::::::::::::: */
24530 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24531 return (ffelexHandler) ffelex_swallow_tokens (t,
24532 (ffelexHandler) ffesta_zero); /* Invalid second token. */
24533 }
24534
24535 /* ffestb_decl_R5391_ -- "IMPLICIT" generic-type
24536
24537 return ffestb_decl_R5391_; // to lexer
24538
24539 Handle ASTERISK or OPEN_PAREN. */
24540
24541 static ffelexHandler
24542 ffestb_decl_R5391_ (ffelexToken t)
24543 {
24544 switch (ffelex_token_type (t))
24545 {
24546 case FFELEX_typeASTERISK:
24547 ffesta_confirmed ();
24548 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
24549 ffestb_local_.decl.badname = "IMPLICIT";
24550 if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
24551 return (ffelexHandler) ffestb_decl_starlen_;
24552 return (ffelexHandler) ffestb_decl_starkind_;
24553
24554 case FFELEX_typeOPEN_PAREN:
24555 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
24556 ffestb_local_.decl.badname = "IMPLICIT";
24557 ffestb_local_.decl.kind = NULL;
24558 ffestb_local_.decl.kindt = NULL;
24559 ffestb_local_.decl.len = NULL;
24560 ffestb_local_.decl.lent = NULL;
24561 if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
24562 ffestb_local_.decl.imp_handler
24563 = (ffelexHandler) ffestb_decl_typeparams_;
24564 else
24565 ffestb_local_.decl.imp_handler
24566 = (ffelexHandler) ffestb_decl_kindparam_;
24567 return (ffelexHandler) ffestb_decl_R539maybe_ (t);
24568
24569 default:
24570 break;
24571 }
24572
24573 if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24574 ffestc_R539finish ();
24575 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24576 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24577 }
24578
24579 /* ffestb_decl_R5392_ -- "IMPLICIT" "DOUBLE"
24580
24581 return ffestb_decl_R5392_; // to lexer
24582
24583 Handle NAME. */
24584
24585 static ffelexHandler
24586 ffestb_decl_R5392_ (ffelexToken t)
24587 {
24588 switch (ffelex_token_type (t))
24589 {
24590 case FFELEX_typeNAME:
24591 switch (ffestr_second (t))
24592 {
24593 case FFESTR_secondPRECISION:
24594 ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24595 break;
24596
24597 case FFESTR_secondCOMPLEX:
24598 ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24599 break;
24600
24601 default:
24602 goto bad; /* :::::::::::::::::::: */
24603 }
24604 ffestb_local_.decl.kind = NULL;
24605 ffestb_local_.decl.kindt = NULL;
24606 ffestb_local_.decl.len = NULL;
24607 ffestb_local_.decl.lent = NULL;
24608 return (ffelexHandler) ffestb_decl_R539letters_;
24609
24610 default:
24611 break;
24612 }
24613
24614 bad: /* :::::::::::::::::::: */
24615 if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24616 ffestc_R539finish ();
24617 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24618 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24619 }
24620
24621 /* ffestb_decl_R5393_ -- "IMPLICIT" "TYPE"
24622
24623 return ffestb_decl_R5393_; // to lexer
24624
24625 Handle OPEN_PAREN. */
24626
24627 #if FFESTR_F90
24628 static ffelexHandler
24629 ffestb_decl_R5393_ (ffelexToken t)
24630 {
24631 switch (ffelex_token_type (t))
24632 {
24633 case FFELEX_typeOPEN_PAREN:
24634 ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
24635 ffestb_local_.decl.badname = "IMPLICIT";
24636 return (ffelexHandler) ffestb_decl_typetype1_;
24637
24638 default:
24639 break;
24640 }
24641
24642 if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24643 ffestc_R539finish ();
24644 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24645 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24646 }
24647
24648 #endif
24649 /* ffestb_decl_R5394_ -- "IMPLICIT" "NONE"
24650
24651 return ffestb_decl_R5394_; // to lexer
24652
24653 Handle EOS/SEMICOLON. */
24654
24655 static ffelexHandler
24656 ffestb_decl_R5394_ (ffelexToken t)
24657 {
24658 switch (ffelex_token_type (t))
24659 {
24660 case FFELEX_typeEOS:
24661 case FFELEX_typeSEMICOLON:
24662 ffesta_confirmed ();
24663 if (!ffesta_is_inhibited ())
24664 ffestc_R539 (); /* IMPLICIT NONE. */
24665 return (ffelexHandler) ffesta_zero (t);
24666
24667 default:
24668 break;
24669 }
24670
24671 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24672 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24673 }
24674
24675 /* ffestb_decl_R5395_ -- "IMPLICIT" implicit-spec-list COMMA
24676
24677 return ffestb_decl_R5395_; // to lexer
24678
24679 Handle NAME for next type-spec. */
24680
24681 static ffelexHandler
24682 ffestb_decl_R5395_ (ffelexToken t)
24683 {
24684 switch (ffelex_token_type (t))
24685 {
24686 case FFELEX_typeNAME:
24687 switch (ffestr_second (t))
24688 {
24689 case FFESTR_secondINTEGER:
24690 ffestb_local_.decl.type = FFESTP_typeINTEGER;
24691 return (ffelexHandler) ffestb_decl_R5391_;
24692
24693 case FFESTR_secondBYTE:
24694 ffestb_local_.decl.type = FFESTP_typeBYTE;
24695 return (ffelexHandler) ffestb_decl_R5391_;
24696
24697 case FFESTR_secondWORD:
24698 ffestb_local_.decl.type = FFESTP_typeWORD;
24699 return (ffelexHandler) ffestb_decl_R5391_;
24700
24701 case FFESTR_secondREAL:
24702 ffestb_local_.decl.type = FFESTP_typeREAL;
24703 return (ffelexHandler) ffestb_decl_R5391_;
24704
24705 case FFESTR_secondCOMPLEX:
24706 ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
24707 return (ffelexHandler) ffestb_decl_R5391_;
24708
24709 case FFESTR_secondLOGICAL:
24710 ffestb_local_.decl.type = FFESTP_typeLOGICAL;
24711 return (ffelexHandler) ffestb_decl_R5391_;
24712
24713 case FFESTR_secondCHARACTER:
24714 ffestb_local_.decl.type = FFESTP_typeCHARACTER;
24715 return (ffelexHandler) ffestb_decl_R5391_;
24716
24717 case FFESTR_secondDOUBLE:
24718 return (ffelexHandler) ffestb_decl_R5392_;
24719
24720 case FFESTR_secondDOUBLEPRECISION:
24721 ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24722 ffestb_local_.decl.kind = NULL;
24723 ffestb_local_.decl.kindt = NULL;
24724 ffestb_local_.decl.len = NULL;
24725 ffestb_local_.decl.lent = NULL;
24726 return (ffelexHandler) ffestb_decl_R539letters_;
24727
24728 case FFESTR_secondDOUBLECOMPLEX:
24729 ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24730 ffestb_local_.decl.kind = NULL;
24731 ffestb_local_.decl.kindt = NULL;
24732 ffestb_local_.decl.len = NULL;
24733 ffestb_local_.decl.lent = NULL;
24734 return (ffelexHandler) ffestb_decl_R539letters_;
24735
24736 #if FFESTR_F90
24737 case FFESTR_secondTYPE:
24738 ffestb_local_.decl.type = FFESTP_typeTYPE;
24739 return (ffelexHandler) ffestb_decl_R5393_;
24740 #endif
24741
24742 default:
24743 break;
24744 }
24745 break;
24746
24747 default:
24748 break;
24749 }
24750
24751 if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24752 ffestc_R539finish ();
24753 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24754 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24755 }
24756
24757 /* ffestb_decl_R539letters_ -- "IMPLICIT" type-spec
24758
24759 return ffestb_decl_R539letters_; // to lexer
24760
24761 Handle OPEN_PAREN. */
24762
24763 static ffelexHandler
24764 ffestb_decl_R539letters_ (ffelexToken t)
24765 {
24766 ffelex_set_names (FALSE);
24767
24768 switch (ffelex_token_type (t))
24769 {
24770 case FFELEX_typeOPEN_PAREN:
24771 ffestb_local_.decl.imps = ffestt_implist_create ();
24772 return (ffelexHandler) ffestb_decl_R539letters_1_;
24773
24774 default:
24775 break;
24776 }
24777
24778 if (ffestb_local_.decl.kindt != NULL)
24779 ffelex_token_kill (ffestb_local_.decl.kindt);
24780 if (ffestb_local_.decl.lent != NULL)
24781 ffelex_token_kill (ffestb_local_.decl.lent);
24782 if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24783 ffestc_R539finish ();
24784 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24785 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24786 }
24787
24788 /* ffestb_decl_R539letters_1_ -- "IMPLICIT" type-spec OPEN_PAREN
24789
24790 return ffestb_decl_R539letters_1_; // to lexer
24791
24792 Handle NAME. */
24793
24794 static ffelexHandler
24795 ffestb_decl_R539letters_1_ (ffelexToken t)
24796 {
24797 switch (ffelex_token_type (t))
24798 {
24799 case FFELEX_typeNAME:
24800 if (ffelex_token_length (t) != 1)
24801 break;
24802 ffesta_tokens[1] = ffelex_token_use (t);
24803 return (ffelexHandler) ffestb_decl_R539letters_2_;
24804
24805 default:
24806 break;
24807 }
24808
24809 ffestt_implist_kill (ffestb_local_.decl.imps);
24810 if (ffestb_local_.decl.kindt != NULL)
24811 ffelex_token_kill (ffestb_local_.decl.kindt);
24812 if (ffestb_local_.decl.lent != NULL)
24813 ffelex_token_kill (ffestb_local_.decl.lent);
24814 if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24815 ffestc_R539finish ();
24816 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24817 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24818 }
24819
24820 /* ffestb_decl_R539letters_2_ -- "IMPLICIT" type-spec OPEN_PAREN NAME
24821
24822 return ffestb_decl_R539letters_2_; // to lexer
24823
24824 Handle COMMA or MINUS. */
24825
24826 static ffelexHandler
24827 ffestb_decl_R539letters_2_ (ffelexToken t)
24828 {
24829 switch (ffelex_token_type (t))
24830 {
24831 case FFELEX_typeCOMMA:
24832 ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
24833 return (ffelexHandler) ffestb_decl_R539letters_1_;
24834
24835 case FFELEX_typeCLOSE_PAREN:
24836 ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
24837 return (ffelexHandler) ffestb_decl_R539letters_5_;
24838
24839 case FFELEX_typeMINUS:
24840 return (ffelexHandler) ffestb_decl_R539letters_3_;
24841
24842 default:
24843 break;
24844 }
24845
24846 ffelex_token_kill (ffesta_tokens[1]);
24847 ffestt_implist_kill (ffestb_local_.decl.imps);
24848 if (ffestb_local_.decl.kindt != NULL)
24849 ffelex_token_kill (ffestb_local_.decl.kindt);
24850 if (ffestb_local_.decl.lent != NULL)
24851 ffelex_token_kill (ffestb_local_.decl.lent);
24852 if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24853 ffestc_R539finish ();
24854 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24855 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24856 }
24857
24858 /* ffestb_decl_R539letters_3_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
24859
24860 return ffestb_decl_R539letters_3_; // to lexer
24861
24862 Handle NAME. */
24863
24864 static ffelexHandler
24865 ffestb_decl_R539letters_3_ (ffelexToken t)
24866 {
24867 switch (ffelex_token_type (t))
24868 {
24869 case FFELEX_typeNAME:
24870 if (ffelex_token_length (t) != 1)
24871 break;
24872 ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1],
24873 ffelex_token_use (t));
24874 return (ffelexHandler) ffestb_decl_R539letters_4_;
24875
24876 default:
24877 break;
24878 }
24879
24880 ffelex_token_kill (ffesta_tokens[1]);
24881 ffestt_implist_kill (ffestb_local_.decl.imps);
24882 if (ffestb_local_.decl.kindt != NULL)
24883 ffelex_token_kill (ffestb_local_.decl.kindt);
24884 if (ffestb_local_.decl.lent != NULL)
24885 ffelex_token_kill (ffestb_local_.decl.lent);
24886 if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24887 ffestc_R539finish ();
24888 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24889 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24890 }
24891
24892 /* ffestb_decl_R539letters_4_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
24893 NAME
24894
24895 return ffestb_decl_R539letters_4_; // to lexer
24896
24897 Handle COMMA or CLOSE_PAREN. */
24898
24899 static ffelexHandler
24900 ffestb_decl_R539letters_4_ (ffelexToken t)
24901 {
24902 switch (ffelex_token_type (t))
24903 {
24904 case FFELEX_typeCOMMA:
24905 return (ffelexHandler) ffestb_decl_R539letters_1_;
24906
24907 case FFELEX_typeCLOSE_PAREN:
24908 return (ffelexHandler) ffestb_decl_R539letters_5_;
24909
24910 default:
24911 break;
24912 }
24913
24914 ffestt_implist_kill (ffestb_local_.decl.imps);
24915 if (ffestb_local_.decl.kindt != NULL)
24916 ffelex_token_kill (ffestb_local_.decl.kindt);
24917 if (ffestb_local_.decl.lent != NULL)
24918 ffelex_token_kill (ffestb_local_.decl.lent);
24919 if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24920 ffestc_R539finish ();
24921 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24922 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24923 }
24924
24925 /* ffestb_decl_R539letters_5_ -- "IMPLICIT" type-spec OPEN_PAREN
24926 letter-spec-list CLOSE_PAREN
24927
24928 return ffestb_decl_R539letters_5_; // to lexer
24929
24930 Handle COMMA or EOS/SEMICOLON. */
24931
24932 static ffelexHandler
24933 ffestb_decl_R539letters_5_ (ffelexToken t)
24934 {
24935 switch (ffelex_token_type (t))
24936 {
24937 case FFELEX_typeCOMMA:
24938 case FFELEX_typeEOS:
24939 case FFELEX_typeSEMICOLON:
24940 if (!ffestb_local_.decl.imp_started)
24941 {
24942 ffestb_local_.decl.imp_started = TRUE;
24943 ffesta_confirmed ();
24944 if (!ffesta_is_inhibited ())
24945 ffestc_R539start ();
24946 }
24947 if (!ffesta_is_inhibited ())
24948 ffestc_R539item (ffestb_local_.decl.type, ffestb_local_.decl.kind,
24949 ffestb_local_.decl.kindt, ffestb_local_.decl.len,
24950 ffestb_local_.decl.lent, ffestb_local_.decl.imps);
24951 if (ffestb_local_.decl.kindt != NULL)
24952 ffelex_token_kill (ffestb_local_.decl.kindt);
24953 if (ffestb_local_.decl.lent != NULL)
24954 ffelex_token_kill (ffestb_local_.decl.lent);
24955 ffestt_implist_kill (ffestb_local_.decl.imps);
24956 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
24957 return (ffelexHandler) ffestb_decl_R5395_;
24958 if (!ffesta_is_inhibited ())
24959 ffestc_R539finish ();
24960 return (ffelexHandler) ffesta_zero (t);
24961
24962 default:
24963 break;
24964 }
24965
24966 ffestt_implist_kill (ffestb_local_.decl.imps);
24967 if (ffestb_local_.decl.kindt != NULL)
24968 ffelex_token_kill (ffestb_local_.decl.kindt);
24969 if (ffestb_local_.decl.lent != NULL)
24970 ffelex_token_kill (ffestb_local_.decl.lent);
24971 if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24972 ffestc_R539finish ();
24973 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24974 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24975 }
24976
24977 /* ffestb_decl_R539maybe_ -- "IMPLICIT" generic-type-spec
24978
24979 return ffestb_decl_R539maybe_; // to lexer
24980
24981 Handle OPEN_PAREN. */
24982
24983 static ffelexHandler
24984 ffestb_decl_R539maybe_ (ffelexToken t)
24985 {
24986 assert (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN);
24987 ffestb_local_.decl.imps = ffestt_implist_create ();
24988 ffestb_local_.decl.toklist = ffestt_tokenlist_create ();
24989 ffestb_local_.decl.imp_seen_comma
24990 = (ffestb_local_.decl.type != FFESTP_typeCHARACTER);
24991 return (ffelexHandler) ffestb_decl_R539maybe_1_;
24992 }
24993
24994 /* ffestb_decl_R539maybe_1_ -- "IMPLICIT" generic-type-spec OPEN_PAREN
24995
24996 return ffestb_decl_R539maybe_1_; // to lexer
24997
24998 Handle NAME. */
24999
25000 static ffelexHandler
25001 ffestb_decl_R539maybe_1_ (ffelexToken t)
25002 {
25003 ffelexHandler next;
25004
25005 switch (ffelex_token_type (t))
25006 {
25007 case FFELEX_typeNAME:
25008 if (ffelex_token_length (t) != 1)
25009 break;
25010 ffesta_tokens[1] = ffelex_token_use (t);
25011 ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25012 return (ffelexHandler) ffestb_decl_R539maybe_2_;
25013
25014 default:
25015 break;
25016 }
25017
25018 ffestt_implist_kill (ffestb_local_.decl.imps);
25019 next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25020 (ffelexHandler) ffestb_local_.decl.imp_handler);
25021 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25022 return (ffelexHandler) (*next) (t);
25023 }
25024
25025 /* ffestb_decl_R539maybe_2_ -- "IMPLICIT" generic-type-spec OPEN_PAREN NAME
25026
25027 return ffestb_decl_R539maybe_2_; // to lexer
25028
25029 Handle COMMA or MINUS. */
25030
25031 static ffelexHandler
25032 ffestb_decl_R539maybe_2_ (ffelexToken t)
25033 {
25034 ffelexHandler next;
25035
25036 switch (ffelex_token_type (t))
25037 {
25038 case FFELEX_typeCOMMA:
25039 ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
25040 if (ffestb_local_.decl.imp_seen_comma)
25041 {
25042 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25043 return (ffelexHandler) ffestb_decl_R539letters_1_;
25044 }
25045 ffestb_local_.decl.imp_seen_comma = TRUE;
25046 ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25047 return (ffelexHandler) ffestb_decl_R539maybe_1_;
25048
25049 case FFELEX_typeCLOSE_PAREN:
25050 ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
25051 ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25052 return (ffelexHandler) ffestb_decl_R539maybe_5_;
25053
25054 case FFELEX_typeMINUS:
25055 ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25056 return (ffelexHandler) ffestb_decl_R539maybe_3_;
25057
25058 default:
25059 break;
25060 }
25061
25062 ffelex_token_kill (ffesta_tokens[1]);
25063 ffestt_implist_kill (ffestb_local_.decl.imps);
25064 next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25065 (ffelexHandler) ffestb_local_.decl.imp_handler);
25066 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25067 return (ffelexHandler) (*next) (t);
25068 }
25069
25070 /* ffestb_decl_R539maybe_3_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
25071
25072 return ffestb_decl_R539maybe_3_; // to lexer
25073
25074 Handle NAME. */
25075
25076 static ffelexHandler
25077 ffestb_decl_R539maybe_3_ (ffelexToken t)
25078 {
25079 ffelexHandler next;
25080
25081 switch (ffelex_token_type (t))
25082 {
25083 case FFELEX_typeNAME:
25084 if (ffelex_token_length (t) != 1)
25085 break;
25086 ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1],
25087 ffelex_token_use (t));
25088 ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25089 return (ffelexHandler) ffestb_decl_R539maybe_4_;
25090
25091 default:
25092 break;
25093 }
25094
25095 ffelex_token_kill (ffesta_tokens[1]);
25096 ffestt_implist_kill (ffestb_local_.decl.imps);
25097 next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25098 (ffelexHandler) ffestb_local_.decl.imp_handler);
25099 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25100 return (ffelexHandler) (*next) (t);
25101 }
25102
25103 /* ffestb_decl_R539maybe_4_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
25104 NAME
25105
25106 return ffestb_decl_R539maybe_4_; // to lexer
25107
25108 Handle COMMA or CLOSE_PAREN. */
25109
25110 static ffelexHandler
25111 ffestb_decl_R539maybe_4_ (ffelexToken t)
25112 {
25113 ffelexHandler next;
25114
25115 switch (ffelex_token_type (t))
25116 {
25117 case FFELEX_typeCOMMA:
25118 if (ffestb_local_.decl.imp_seen_comma)
25119 {
25120 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25121 return (ffelexHandler) ffestb_decl_R539letters_1_;
25122 }
25123 ffestb_local_.decl.imp_seen_comma = TRUE;
25124 ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25125 return (ffelexHandler) ffestb_decl_R539maybe_1_;
25126
25127 case FFELEX_typeCLOSE_PAREN:
25128 ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25129 return (ffelexHandler) ffestb_decl_R539maybe_5_;
25130
25131 default:
25132 break;
25133 }
25134
25135 ffestt_implist_kill (ffestb_local_.decl.imps);
25136 next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25137 (ffelexHandler) ffestb_local_.decl.imp_handler);
25138 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25139 return (ffelexHandler) (*next) (t);
25140 }
25141
25142 /* ffestb_decl_R539maybe_5_ -- "IMPLICIT" type-spec OPEN_PAREN
25143 letter-spec-list CLOSE_PAREN
25144
25145 return ffestb_decl_R539maybe_5_; // to lexer
25146
25147 Handle COMMA or EOS/SEMICOLON. */
25148
25149 static ffelexHandler
25150 ffestb_decl_R539maybe_5_ (ffelexToken t)
25151 {
25152 ffelexHandler next;
25153
25154 switch (ffelex_token_type (t))
25155 {
25156 case FFELEX_typeCOMMA:
25157 case FFELEX_typeEOS:
25158 case FFELEX_typeSEMICOLON:
25159 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25160 if (!ffestb_local_.decl.imp_started)
25161 {
25162 ffestb_local_.decl.imp_started = TRUE;
25163 ffesta_confirmed ();
25164 if (!ffesta_is_inhibited ())
25165 ffestc_R539start ();
25166 }
25167 if (!ffesta_is_inhibited ())
25168 ffestc_R539item (ffestb_local_.decl.type, ffestb_local_.decl.kind,
25169 ffestb_local_.decl.kindt, ffestb_local_.decl.len,
25170 ffestb_local_.decl.lent, ffestb_local_.decl.imps);
25171 if (ffestb_local_.decl.kindt != NULL)
25172 ffelex_token_kill (ffestb_local_.decl.kindt);
25173 if (ffestb_local_.decl.lent != NULL)
25174 ffelex_token_kill (ffestb_local_.decl.lent);
25175 ffestt_implist_kill (ffestb_local_.decl.imps);
25176 if (ffelex_token_type (t) == FFELEX_typeCOMMA)
25177 return (ffelexHandler) ffestb_decl_R5395_;
25178 if (!ffesta_is_inhibited ())
25179 ffestc_R539finish ();
25180 return (ffelexHandler) ffesta_zero (t);
25181
25182 case FFELEX_typeOPEN_PAREN:
25183 ffesta_confirmed ();
25184 ffestt_implist_kill (ffestb_local_.decl.imps);
25185 next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25186 (ffelexHandler) ffestb_local_.decl.imp_handler);
25187 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25188 return (ffelexHandler) (*next) (t);
25189
25190 default:
25191 break;
25192 }
25193
25194 ffestt_implist_kill (ffestb_local_.decl.imps);
25195 ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25196 if (ffestb_local_.decl.kindt != NULL)
25197 ffelex_token_kill (ffestb_local_.decl.kindt);
25198 if (ffestb_local_.decl.lent != NULL)
25199 ffelex_token_kill (ffestb_local_.decl.lent);
25200 if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
25201 ffestc_R539finish ();
25202 ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
25203 return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
25204 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org