gcc/f/stb.c

   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 (burley@gnu.ai.mit.edu).
   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 <ctype.h>
  92 #include "stb.h"
  93 #include "bad.h"
  94 #include "expr.h"
  95 #include "lex.h"
  96 #include "malloc.h"
  97 #include "src.h"
  98 #include "sta.h"
  99 #include "stc.h"
 100 #include "stp.h"
 101 #include "str.h"
 102
 103 /* Externals defined here. */
 104
 105 struct _ffestb_args_ ffestb_args;
 106
 107 /* Simple definitions and enumerations. */
 108
 109 #define FFESTB_KILL_EASY_ 1     /* 1 for only one _subr_kill_xyz_ fn. */
 110
 111 /* Internal typedefs. */
 112
 113 union ffestb_subrargs_u_
 114   {
 115     struct
 116       {
 117         ffesttTokenList labels; /* Input arg, must not be NULL. */
 118         ffelexHandler handler;  /* Input arg, call me when done. */
 119         bool ok;                /* Output arg, TRUE if list ended in
 120                                    CLOSE_PAREN. */
 121       }
 122     label_list;
 123     struct
 124       {
 125         ffesttDimList dims;     /* Input arg, must not be NULL. */
 126         ffelexHandler handler;  /* Input arg, call me when done. */
 127         mallocPool pool;        /* Pool to allocate into. */
 128         bool ok;                /* Output arg, TRUE if list ended in
 129                                    CLOSE_PAREN. */
 130         ffeexprContext ctx;     /* DIMLIST or DIMLISTCOMMON. */
 131 #ifdef FFECOM_dimensionsMAX
 132         int ndims;              /* For backends that really can't have
 133                                    infinite dims. */
 134 #endif
 135       }
 136     dim_list;
 137     struct
 138       {
 139         ffesttTokenList args;   /* Input arg, must not be NULL. */
 140         ffelexHandler handler;  /* Input arg, call me when done. */
 141         ffelexToken close_paren;/* Output arg if ok, CLOSE_PAREN token. */
 142         bool is_subr;           /* Input arg, TRUE if list in subr-def
 143                                    context. */
 144         bool ok;                /* Output arg, TRUE if list ended in
 145                                    CLOSE_PAREN. */
 146         bool names;             /* Do ffelex_set_names(TRUE) before return. */
 147       }
 148     name_list;
 149   };
 150
 151 union ffestb_local_u_
 152   {
 153     struct
 154       {
 155         ffebld expr;
 156       }
 157     call_stmt;
 158     struct
 159       {
 160         ffebld expr;
 161       }
 162     go_to;
 163     struct
 164       {
 165         ffebld dest;
 166         bool vxtparam;          /* If assignment might really be VXT
 167                                    PARAMETER stmt. */
 168       }
 169     let;
 170     struct
 171       {
 172         ffebld expr;
 173       }
 174     if_stmt;
 175     struct
 176       {
 177         ffebld expr;
 178       }
 179     else_stmt;
 180     struct
 181       {
 182         ffebld expr;
 183       }
 184     dowhile;
 185     struct
 186       {
 187         ffebld var;
 188         ffebld start;
 189         ffebld end;
 190       }
 191     do_stmt;
 192     struct
 193       {
 194         bool is_cblock;
 195       }
 196     R522;
 197     struct
 198       {
 199         ffebld expr;
 200         bool started;
 201       }
 202     parameter;
 203     struct
 204       {
 205         ffesttExprList exprs;
 206         bool started;
 207       }
 208     equivalence;
 209     struct
 210       {
 211         ffebld expr;
 212         bool started;
 213       }
 214     data;
 215     struct
 216       {
 217         ffestrOther kw;
 218       }
 219     varlist;
 220 #if FFESTR_F90
 221     struct
 222       {
 223         ffestrOther kw;
 224       }
 225     type;
 226 #endif
 227     struct
 228       {
 229         ffelexHandler next;
 230       }
 231     construct;
 232     struct
 233       {
 234         ffesttFormatList f;
 235         ffestpFormatType current;       /* What we're currently working on. */
 236         ffelexToken t;          /* Token of what we're currently working on. */
 237         ffesttFormatValue pre;
 238         ffesttFormatValue post;
 239         ffesttFormatValue dot;
 240         ffesttFormatValue exp;
 241         bool sign;              /* _3_, pos/neg; elsewhere, signed/unsigned. */
 242         bool complained;        /* If run-time expr seen in nonexec context. */
 243       }
 244     format;
 245 #if FFESTR_F90
 246     struct
 247       {
 248         bool started;
 249       }
 250     moduleprocedure;
 251 #endif
 252     struct
 253       {
 254         ffebld expr;
 255       }
 256     selectcase;
 257     struct
 258       {
 259         ffesttCaseList cases;
 260       }
 261     case_stmt;
 262 #if FFESTR_F90
 263     struct
 264       {
 265         ffesttExprList exprs;
 266         ffebld expr;
 267       }
 268     heap;
 269 #endif
 270 #if FFESTR_F90
 271     struct
 272       {
 273         ffesttExprList exprs;
 274       }
 275     R624;
 276 #endif
 277 #if FFESTR_F90
 278     struct
 279       {
 280         ffestpDefinedOperator operator;
 281         bool assignment;        /* TRUE for INTERFACE ASSIGNMENT, FALSE for
 282                                    ...OPERATOR. */
 283         bool slash;             /* TRUE if OPEN_ARRAY, FALSE if OPEN_PAREN. */
 284       }
 285     interface;
 286 #endif
 287     struct
 288       {
 289         bool is_cblock;
 290       }
 291     V014;
 292 #if FFESTR_VXT
 293     struct
 294       {
 295         bool started;
 296         ffebld u;
 297         ffebld m;
 298         ffebld n;
 299         ffebld asv;
 300       }
 301     V025;
 302 #endif
 303     struct
 304       {
 305         ffestpBeruIx ix;
 306         bool label;
 307         bool left;
 308         ffeexprContext context;
 309       }
 310     beru;
 311     struct
 312       {
 313         ffestpCloseIx ix;
 314         bool label;
 315         bool left;
 316         ffeexprContext context;
 317       }
 318     close;
 319     struct
 320       {
 321         ffestpDeleteIx ix;
 322         bool label;
 323         bool left;
 324         ffeexprContext context;
 325       }
 326     delete;
 327     struct
 328       {
 329         ffestpDeleteIx ix;
 330         bool label;
 331         bool left;
 332         ffeexprContext context;
 333       }
 334     find;
 335     struct
 336       {
 337         ffestpInquireIx ix;
 338         bool label;
 339         bool left;
 340         ffeexprContext context;
 341         bool may_be_iolength;
 342       }
 343     inquire;
 344     struct
 345       {
 346         ffestpOpenIx ix;
 347         bool label;
 348         bool left;
 349         ffeexprContext context;
 350       }
 351     open;
 352     struct
 353       {
 354         ffestpReadIx ix;
 355         bool label;
 356         bool left;
 357         ffeexprContext context;
 358       }
 359     read;
 360     struct
 361       {
 362         ffestpRewriteIx ix;
 363         bool label;
 364         bool left;
 365         ffeexprContext context;
 366       }
 367     rewrite;
 368     struct
 369       {
 370         ffestpWriteIx ix;
 371         bool label;
 372         bool left;
 373         ffeexprContext context;
 374       }
 375     vxtcode;
 376     struct
 377       {
 378         ffestpWriteIx ix;
 379         bool label;
 380         bool left;
 381         ffeexprContext context;
 382       }
 383     write;
 384 #if FFESTR_F90
 385     struct
 386       {
 387         bool started;
 388       }
 389     structure;
 390 #endif
 391     struct
 392       {
 393         bool started;
 394       }
 395     common;
 396     struct
 397       {
 398         bool started;
 399       }
 400     dimension;
 401     struct
 402       {
 403         bool started;
 404       }
 405     dimlist;
 406     struct
 407       {
 408         char *badname;
 409         ffestrFirst first_kw;
 410         bool is_subr;
 411       }
 412     dummy;
 413     struct
 414       {
 415         ffebld kind;            /* Kind type parameter, if any. */
 416         ffelexToken kindt;      /* Kind type first token, if any. */
 417         ffebld len;             /* Length type parameter, if any. */
 418         ffelexToken lent;       /* Length type parameter, if any. */
 419         ffelexHandler handler;
 420         ffelexToken recursive;
 421         ffebld expr;
 422         ffesttTokenList toklist;/* For ambiguity resolution. */
 423         ffesttImpList imps;     /* List of IMPLICIT letters. */
 424         ffelexHandler imp_handler;      /* Call if paren list wasn't letters. */
 425         char *badname;
 426         ffestrOther kw;         /* INTENT(IN/OUT/INOUT). */
 427         ffestpType type;
 428         bool parameter;         /* If PARAMETER attribute seen (governs =expr
 429                                    context). */
 430         bool coloncolon;        /* If COLONCOLON seen (allows =expr). */
 431         bool aster_after;       /* "*" seen after, not before,
 432                                    [RECURSIVE]FUNCTIONxyz. */
 433         bool empty;             /* Ambig function dummy arg list empty so
 434                                    far? */
 435         bool imp_started;       /* Started IMPLICIT statement already. */
 436         bool imp_seen_comma;    /* TRUE if next COMMA within parens means not
 437                                    R541. */
 438       }
 439     decl;
 440     struct
 441       {
 442         bool started;
 443       }
 444     vxtparam;
 445   };                            /* Merge with the one in ffestb later. */
 446
 447 /* Private include files. */
 448
 449
 450 /* Internal structure definitions. */
 451
 452
 453 /* Static objects accessed by functions in this module. */
 454
 455 static union ffestb_subrargs_u_ ffestb_subrargs_;
 456 static union ffestb_local_u_ ffestb_local_;
 457
 458 /* Static functions (internal). */
 459
 460 static void ffestb_subr_ambig_to_ents_ (void);
 461 static ffelexHandler ffestb_subr_ambig_nope_ (ffelexToken t);
 462 static ffelexHandler ffestb_subr_dimlist_ (ffelexToken ft, ffebld expr,
 463                                            ffelexToken t);
 464 static ffelexHandler ffestb_subr_dimlist_1_ (ffelexToken ft, ffebld expr,
 465                                              ffelexToken t);
 466 static ffelexHandler ffestb_subr_dimlist_2_ (ffelexToken ft, ffebld expr,
 467                                              ffelexToken t);
 468 static ffelexHandler ffestb_subr_name_list_ (ffelexToken t);
 469 static ffelexHandler ffestb_subr_name_list_1_ (ffelexToken t);
 470 static void ffestb_subr_R1001_append_p_ (void);
 471 static ffelexHandler ffestb_decl_kindparam_ (ffelexToken t);
 472 static ffelexHandler ffestb_decl_kindparam_1_ (ffelexToken t);
 473 static ffelexHandler ffestb_decl_kindparam_2_ (ffelexToken ft, ffebld expr,
 474                                                ffelexToken t);
 475 static ffelexHandler ffestb_decl_starkind_ (ffelexToken t);
 476 static ffelexHandler ffestb_decl_starlen_ (ffelexToken t);
 477 static ffelexHandler ffestb_decl_starlen_1_ (ffelexToken ft, ffebld expr,
 478                                              ffelexToken t);
 479 static ffelexHandler ffestb_decl_typeparams_ (ffelexToken t);
 480 static ffelexHandler ffestb_decl_typeparams_1_ (ffelexToken t);
 481 static ffelexHandler ffestb_decl_typeparams_2_ (ffelexToken ft, ffebld expr,
 482                                                 ffelexToken t);
 483 static ffelexHandler ffestb_decl_typeparams_3_ (ffelexToken ft, ffebld expr,
 484                                                 ffelexToken t);
 485 #if FFESTR_F90
 486 static ffelexHandler ffestb_decl_typetype1_ (ffelexToken t);
 487 static ffelexHandler ffestb_decl_typetype2_ (ffelexToken t);
 488 #endif
 489 static ffelexHandler ffestb_subr_label_list_ (ffelexToken t);
 490 static ffelexHandler ffestb_subr_label_list_1_ (ffelexToken t);
 491 static ffelexHandler ffestb_do1_ (ffelexToken t);
 492 static ffelexHandler ffestb_do2_ (ffelexToken t);
 493 static ffelexHandler ffestb_do3_ (ffelexToken t);
 494 static ffelexHandler ffestb_do4_ (ffelexToken ft, ffebld expr,
 495                                   ffelexToken t);
 496 static ffelexHandler ffestb_do5_ (ffelexToken t);
 497 static ffelexHandler ffestb_do6_ (ffelexToken ft, ffebld expr,
 498                                   ffelexToken t);
 499 static ffelexHandler ffestb_do7_ (ffelexToken ft, ffebld expr,
 500                                   ffelexToken t);
 501 static ffelexHandler ffestb_do8_ (ffelexToken ft, ffebld expr,
 502                                   ffelexToken t);
 503 static ffelexHandler ffestb_do9_ (ffelexToken ft, ffebld expr,
 504                                   ffelexToken t);
 505 static ffelexHandler ffestb_else1_ (ffelexToken t);
 506 static ffelexHandler ffestb_else2_ (ffelexToken ft, ffebld expr,
 507                                     ffelexToken t);
 508 static ffelexHandler ffestb_else3_ (ffelexToken t);
 509 static ffelexHandler ffestb_else4_ (ffelexToken t);
 510 static ffelexHandler ffestb_else5_ (ffelexToken t);
 511 static ffelexHandler ffestb_end1_ (ffelexToken t);
 512 static ffelexHandler ffestb_end2_ (ffelexToken t);
 513 static ffelexHandler ffestb_end3_ (ffelexToken t);
 514 static ffelexHandler ffestb_goto1_ (ffelexToken t);
 515 static ffelexHandler ffestb_goto2_ (ffelexToken t);
 516 static ffelexHandler ffestb_goto3_ (ffelexToken t);
 517 static ffelexHandler ffestb_goto4_ (ffelexToken ft, ffebld expr,
 518                                     ffelexToken t);
 519 static ffelexHandler ffestb_goto5_ (ffelexToken ft, ffebld expr,
 520                                     ffelexToken t);
 521 static ffelexHandler ffestb_goto6_ (ffelexToken t);
 522 static ffelexHandler ffestb_goto7_ (ffelexToken t);
 523 static ffelexHandler ffestb_halt1_ (ffelexToken ft, ffebld expr,
 524                                     ffelexToken t);
 525 static ffelexHandler ffestb_if1_ (ffelexToken ft, ffebld expr,
 526                                   ffelexToken t);
 527 static ffelexHandler ffestb_if2_ (ffelexToken t);
 528 static ffelexHandler ffestb_if3_ (ffelexToken t);
 529 static ffelexHandler ffestb_let1_ (ffelexToken ft, ffebld expr,
 530                                    ffelexToken t);
 531 static ffelexHandler ffestb_let2_ (ffelexToken ft, ffebld expr,
 532                                    ffelexToken t);
 533 #if FFESTR_F90
 534 static ffelexHandler ffestb_type1_ (ffelexToken t);
 535 static ffelexHandler ffestb_type2_ (ffelexToken t);
 536 static ffelexHandler ffestb_type3_ (ffelexToken t);
 537 static ffelexHandler ffestb_type4_ (ffelexToken t);
 538 #endif
 539 #if FFESTR_F90
 540 static ffelexHandler ffestb_varlist1_ (ffelexToken t);
 541 static ffelexHandler ffestb_varlist2_ (ffelexToken t);
 542 static ffelexHandler ffestb_varlist3_ (ffelexToken t);
 543 static ffelexHandler ffestb_varlist4_ (ffelexToken t);
 544 #endif
 545 static ffelexHandler ffestb_varlist5_ (ffelexToken t);
 546 static ffelexHandler ffestb_varlist6_ (ffelexToken t);
 547 #if FFESTR_F90
 548 static ffelexHandler ffestb_where1_ (ffelexToken ft, ffebld expr,
 549                                      ffelexToken t);
 550 static ffelexHandler ffestb_where2_ (ffelexToken t);
 551 static ffelexHandler ffestb_where3_ (ffelexToken t);
 552 #endif
 553 static ffelexHandler ffestb_R5221_ (ffelexToken t);
 554 static ffelexHandler ffestb_R5222_ (ffelexToken t);
 555 static ffelexHandler ffestb_R5223_ (ffelexToken t);
 556 static ffelexHandler ffestb_R5224_ (ffelexToken t);
 557 static ffelexHandler ffestb_R5281_ (ffelexToken ft, ffebld expr,
 558                                     ffelexToken t);
 559 static ffelexHandler ffestb_R5282_ (ffelexToken ft, ffebld expr,
 560                                     ffelexToken t);
 561 static ffelexHandler ffestb_R5283_ (ffelexToken ft, ffebld expr,
 562                                     ffelexToken t);
 563 static ffelexHandler ffestb_R5284_ (ffelexToken t);
 564 static ffelexHandler ffestb_R5371_ (ffelexToken ft, ffebld expr,
 565                                     ffelexToken t);
 566 static ffelexHandler ffestb_R5372_ (ffelexToken ft, ffebld expr,
 567                                     ffelexToken t);
 568 static ffelexHandler ffestb_R5373_ (ffelexToken t);
 569 static ffelexHandler ffestb_R5421_ (ffelexToken t);
 570 static ffelexHandler ffestb_R5422_ (ffelexToken t);
 571 static ffelexHandler ffestb_R5423_ (ffelexToken t);
 572 static ffelexHandler ffestb_R5424_ (ffelexToken t);
 573 static ffelexHandler ffestb_R5425_ (ffelexToken t);
 574 static ffelexHandler ffestb_R5441_ (ffelexToken ft, ffebld expr,
 575                                     ffelexToken t);
 576 static ffelexHandler ffestb_R5442_ (ffelexToken ft, ffebld expr,
 577                                     ffelexToken t);
 578 static ffelexHandler ffestb_R5443_ (ffelexToken t);
 579 static ffelexHandler ffestb_R5444_ (ffelexToken t);
 580 static ffelexHandler ffestb_R8341_ (ffelexToken t);
 581 static ffelexHandler ffestb_R8351_ (ffelexToken t);
 582 static ffelexHandler ffestb_R8381_ (ffelexToken t);
 583 static ffelexHandler ffestb_R8382_ (ffelexToken t);
 584 static ffelexHandler ffestb_R8383_ (ffelexToken ft, ffebld expr,
 585                                     ffelexToken t);
 586 static ffelexHandler ffestb_R8401_ (ffelexToken ft, ffebld expr,
 587                                     ffelexToken t);
 588 static ffelexHandler ffestb_R8402_ (ffelexToken t);
 589 static ffelexHandler ffestb_R8403_ (ffelexToken t);
 590 static ffelexHandler ffestb_R8404_ (ffelexToken t);
 591 static ffelexHandler ffestb_R8405_ (ffelexToken t);
 592 static ffelexHandler ffestb_R8406_ (ffelexToken t);
 593 static ffelexHandler ffestb_R8407_ (ffelexToken t);
 594 static ffelexHandler ffestb_R11021_ (ffelexToken t);
 595 static ffelexHandler ffestb_R1111_1_ (ffelexToken t);
 596 static ffelexHandler ffestb_R1111_2_ (ffelexToken t);
 597 static ffelexHandler ffestb_R12121_ (ffelexToken ft, ffebld expr,
 598                                      ffelexToken t);
 599 static ffelexHandler ffestb_R12271_ (ffelexToken ft, ffebld expr,
 600                                      ffelexToken t);
 601 static ffelexHandler ffestb_construct1_ (ffelexToken t);
 602 static ffelexHandler ffestb_construct2_ (ffelexToken t);
 603 #if FFESTR_F90
 604 static ffelexHandler ffestb_heap1_ (ffelexToken ft, ffebld expr,
 605                                     ffelexToken t);
 606 static ffelexHandler ffestb_heap2_ (ffelexToken t);
 607 static ffelexHandler ffestb_heap3_ (ffelexToken t);
 608 static ffelexHandler ffestb_heap4_ (ffelexToken ft, ffebld expr,
 609                                     ffelexToken t);
 610 static ffelexHandler ffestb_heap5_ (ffelexToken t);
 611 #endif
 612 #if FFESTR_F90
 613 static ffelexHandler ffestb_module1_ (ffelexToken t);
 614 static ffelexHandler ffestb_module2_ (ffelexToken t);
 615 static ffelexHandler ffestb_module3_ (ffelexToken t);
 616 #endif
 617 static ffelexHandler ffestb_R8091_ (ffelexToken t);
 618 static ffelexHandler ffestb_R8092_ (ffelexToken ft, ffebld expr,
 619                                     ffelexToken t);
 620 static ffelexHandler ffestb_R8093_ (ffelexToken t);
 621 static ffelexHandler ffestb_R8101_ (ffelexToken t);
 622 static ffelexHandler ffestb_R8102_ (ffelexToken t);
 623 static ffelexHandler ffestb_R8103_ (ffelexToken ft, ffebld expr,
 624                                     ffelexToken t);
 625 static ffelexHandler ffestb_R8104_ (ffelexToken ft, ffebld expr,
 626                                     ffelexToken t);
 627 static ffelexHandler ffestb_R10011_ (ffelexToken t);
 628 static ffelexHandler ffestb_R10012_ (ffelexToken t);
 629 static ffelexHandler ffestb_R10013_ (ffelexToken t);
 630 static ffelexHandler ffestb_R10014_ (ffelexToken t);
 631 static ffelexHandler ffestb_R10015_ (ffelexToken t);
 632 static ffelexHandler ffestb_R10016_ (ffelexToken t);
 633 static ffelexHandler ffestb_R10017_ (ffelexToken t);
 634 static ffelexHandler ffestb_R10018_ (ffelexToken t);
 635 static ffelexHandler ffestb_R10019_ (ffelexToken t);
 636 static ffelexHandler ffestb_R100110_ (ffelexToken t);
 637 static ffelexHandler ffestb_R100111_ (ffelexToken t);
 638 static ffelexHandler ffestb_R100112_ (ffelexToken t);
 639 static ffelexHandler ffestb_R100113_ (ffelexToken t);
 640 static ffelexHandler ffestb_R100114_ (ffelexToken t);
 641 static ffelexHandler ffestb_R100115_ (ffelexToken ft, ffebld expr,
 642                                       ffelexToken t);
 643 static ffelexHandler ffestb_R100116_ (ffelexToken ft, ffebld expr,
 644                                       ffelexToken t);
 645 static ffelexHandler ffestb_R100117_ (ffelexToken ft, ffebld expr,
 646                                       ffelexToken t);
 647 static ffelexHandler ffestb_R100118_ (ffelexToken ft, ffebld expr,
 648                                       ffelexToken t);
 649 #if FFESTR_F90
 650 static ffelexHandler ffestb_R11071_ (ffelexToken t);
 651 static ffelexHandler ffestb_R11072_ (ffelexToken t);
 652 static ffelexHandler ffestb_R11073_ (ffelexToken t);
 653 static ffelexHandler ffestb_R11074_ (ffelexToken t);
 654 static ffelexHandler ffestb_R11075_ (ffelexToken t);
 655 static ffelexHandler ffestb_R11076_ (ffelexToken t);
 656 static ffelexHandler ffestb_R11077_ (ffelexToken t);
 657 static ffelexHandler ffestb_R11078_ (ffelexToken t);
 658 static ffelexHandler ffestb_R11079_ (ffelexToken t);
 659 static ffelexHandler ffestb_R110710_ (ffelexToken t);
 660 static ffelexHandler ffestb_R110711_ (ffelexToken t);
 661 static ffelexHandler ffestb_R110712_ (ffelexToken t);
 662 #endif
 663 #if FFESTR_F90
 664 static ffelexHandler ffestb_R12021_ (ffelexToken t);
 665 static ffelexHandler ffestb_R12022_ (ffelexToken t);
 666 static ffelexHandler ffestb_R12023_ (ffelexToken t);
 667 static ffelexHandler ffestb_R12024_ (ffelexToken t);
 668 static ffelexHandler ffestb_R12025_ (ffelexToken t);
 669 static ffelexHandler ffestb_R12026_ (ffelexToken t);
 670 #endif
 671 static ffelexHandler ffestb_S3P41_ (ffelexToken ft, ffebld expr,
 672                                     ffelexToken t);
 673 static ffelexHandler ffestb_V0141_ (ffelexToken t);
 674 static ffelexHandler ffestb_V0142_ (ffelexToken t);
 675 static ffelexHandler ffestb_V0143_ (ffelexToken t);
 676 static ffelexHandler ffestb_V0144_ (ffelexToken t);
 677 #if FFESTR_VXT
 678 static ffelexHandler ffestb_V0251_ (ffelexToken t);
 679 static ffelexHandler ffestb_V0252_ (ffelexToken ft, ffebld expr,
 680                                     ffelexToken t);
 681 static ffelexHandler ffestb_V0253_ (ffelexToken ft, ffebld expr,
 682                                     ffelexToken t);
 683 static ffelexHandler ffestb_V0254_ (ffelexToken ft, ffebld expr,
 684                                     ffelexToken t);
 685 static ffelexHandler ffestb_V0255_ (ffelexToken t);
 686 static ffelexHandler ffestb_V0256_ (ffelexToken t);
 687 static ffelexHandler ffestb_V0257_ (ffelexToken ft, ffebld expr,
 688                                     ffelexToken t);
 689 static ffelexHandler ffestb_V0258_ (ffelexToken t);
 690 #endif
 691 #if FFESTB_KILL_EASY_
 692 static void ffestb_subr_kill_easy_ (ffestpInquireIx max);
 693 #else
 694 static void ffestb_subr_kill_accept_ (void);
 695 static void ffestb_subr_kill_beru_ (void);
 696 static void ffestb_subr_kill_close_ (void);
 697 static void ffestb_subr_kill_delete_ (void);
 698 static void ffestb_subr_kill_find_ (void);      /* Not written yet. */
 699 static void ffestb_subr_kill_inquire_ (void);
 700 static void ffestb_subr_kill_open_ (void);
 701 static void ffestb_subr_kill_print_ (void);
 702 static void ffestb_subr_kill_read_ (void);
 703 static void ffestb_subr_kill_rewrite_ (void);
 704 static void ffestb_subr_kill_type_ (void);
 705 static void ffestb_subr_kill_vxtcode_ (void);   /* Not written yet. */
 706 static void ffestb_subr_kill_write_ (void);
 707 #endif
 708 static ffelexHandler ffestb_beru1_ (ffelexToken ft, ffebld expr,
 709                                     ffelexToken t);
 710 static ffelexHandler ffestb_beru2_ (ffelexToken t);
 711 static ffelexHandler ffestb_beru3_ (ffelexToken t);
 712 static ffelexHandler ffestb_beru4_ (ffelexToken ft, ffebld expr,
 713                                     ffelexToken t);
 714 static ffelexHandler ffestb_beru5_ (ffelexToken t);
 715 static ffelexHandler ffestb_beru6_ (ffelexToken t);
 716 static ffelexHandler ffestb_beru7_ (ffelexToken ft, ffebld expr,
 717                                     ffelexToken t);
 718 static ffelexHandler ffestb_beru8_ (ffelexToken t);
 719 static ffelexHandler ffestb_beru9_ (ffelexToken t);
 720 static ffelexHandler ffestb_beru10_ (ffelexToken t);
 721 #if FFESTR_VXT
 722 static ffelexHandler ffestb_vxtcode1_ (ffelexToken ft, ffebld expr,
 723                                        ffelexToken t);
 724 static ffelexHandler ffestb_vxtcode2_ (ffelexToken ft, ffebld expr,
 725                                        ffelexToken t);
 726 static ffelexHandler ffestb_vxtcode3_ (ffelexToken ft, ffebld expr,
 727                                        ffelexToken t);
 728 static ffelexHandler ffestb_vxtcode4_ (ffelexToken t);
 729 static ffelexHandler ffestb_vxtcode5_ (ffelexToken t);
 730 static ffelexHandler ffestb_vxtcode6_ (ffelexToken ft, ffebld expr,
 731                                        ffelexToken t);
 732 static ffelexHandler ffestb_vxtcode7_ (ffelexToken t);
 733 static ffelexHandler ffestb_vxtcode8_ (ffelexToken t);
 734 static ffelexHandler ffestb_vxtcode9_ (ffelexToken t);
 735 static ffelexHandler ffestb_vxtcode10_ (ffelexToken ft, ffebld expr,
 736                                         ffelexToken t);
 737 #endif
 738 static ffelexHandler ffestb_R9041_ (ffelexToken t);
 739 static ffelexHandler ffestb_R9042_ (ffelexToken t);
 740 static ffelexHandler ffestb_R9043_ (ffelexToken ft, ffebld expr,
 741                                     ffelexToken t);
 742 static ffelexHandler ffestb_R9044_ (ffelexToken t);
 743 static ffelexHandler ffestb_R9045_ (ffelexToken t);
 744 static ffelexHandler ffestb_R9046_ (ffelexToken ft, ffebld expr,
 745                                     ffelexToken t);
 746 static ffelexHandler ffestb_R9047_ (ffelexToken t);
 747 static ffelexHandler ffestb_R9048_ (ffelexToken t);
 748 static ffelexHandler ffestb_R9049_ (ffelexToken t);
 749 static ffelexHandler ffestb_R9071_ (ffelexToken t);
 750 static ffelexHandler ffestb_R9072_ (ffelexToken t);
 751 static ffelexHandler ffestb_R9073_ (ffelexToken ft, ffebld expr,
 752                                     ffelexToken t);
 753 static ffelexHandler ffestb_R9074_ (ffelexToken t);
 754 static ffelexHandler ffestb_R9075_ (ffelexToken t);
 755 static ffelexHandler ffestb_R9076_ (ffelexToken ft, ffebld expr,
 756                                     ffelexToken t);
 757 static ffelexHandler ffestb_R9077_ (ffelexToken t);
 758 static ffelexHandler ffestb_R9078_ (ffelexToken t);
 759 static ffelexHandler ffestb_R9079_ (ffelexToken t);
 760 static ffelexHandler ffestb_R9091_ (ffelexToken ft, ffebld expr,
 761                                     ffelexToken t);
 762 static ffelexHandler ffestb_R9092_ (ffelexToken t);
 763 static ffelexHandler ffestb_R9093_ (ffelexToken t);
 764 static ffelexHandler ffestb_R9094_ (ffelexToken ft, ffebld expr,
 765                                     ffelexToken t);
 766 static ffelexHandler ffestb_R9095_ (ffelexToken t);
 767 static ffelexHandler ffestb_R9096_ (ffelexToken t);
 768 static ffelexHandler ffestb_R9097_ (ffelexToken ft, ffebld expr,
 769                                     ffelexToken t);
 770 static ffelexHandler ffestb_R9098_ (ffelexToken t);
 771 static ffelexHandler ffestb_R9099_ (ffelexToken t);
 772 static ffelexHandler ffestb_R90910_ (ffelexToken ft, ffebld expr,
 773                                      ffelexToken t);
 774 static ffelexHandler ffestb_R90911_ (ffelexToken t);
 775 static ffelexHandler ffestb_R90912_ (ffelexToken t);
 776 static ffelexHandler ffestb_R90913_ (ffelexToken t);
 777 static ffelexHandler ffestb_R90914_ (ffelexToken ft, ffebld expr,
 778                                      ffelexToken t);
 779 static ffelexHandler ffestb_R90915_ (ffelexToken ft, ffebld expr,
 780                                      ffelexToken t);
 781 static ffelexHandler ffestb_R9101_ (ffelexToken t);
 782 static ffelexHandler ffestb_R9102_ (ffelexToken t);
 783 static ffelexHandler ffestb_R9103_ (ffelexToken ft, ffebld expr,
 784                                     ffelexToken t);
 785 static ffelexHandler ffestb_R9104_ (ffelexToken t);
 786 static ffelexHandler ffestb_R9105_ (ffelexToken t);
 787 static ffelexHandler ffestb_R9106_ (ffelexToken ft, ffebld expr,
 788                                     ffelexToken t);
 789 static ffelexHandler ffestb_R9107_ (ffelexToken t);
 790 static ffelexHandler ffestb_R9108_ (ffelexToken t);
 791 static ffelexHandler ffestb_R9109_ (ffelexToken ft, ffebld expr,
 792                                     ffelexToken t);
 793 static ffelexHandler ffestb_R91010_ (ffelexToken t);
 794 static ffelexHandler ffestb_R91011_ (ffelexToken t);
 795 static ffelexHandler ffestb_R91012_ (ffelexToken t);
 796 static ffelexHandler ffestb_R91013_ (ffelexToken ft, ffebld expr,
 797                                      ffelexToken t);
 798 static ffelexHandler ffestb_R91014_ (ffelexToken ft, ffebld expr,
 799                                      ffelexToken t);
 800 static ffelexHandler ffestb_R9111_ (ffelexToken ft, ffebld expr,
 801                                     ffelexToken t);
 802 static ffelexHandler ffestb_R9112_ (ffelexToken ft, ffebld expr,
 803                                     ffelexToken t);
 804 static ffelexHandler ffestb_R9231_ (ffelexToken t);
 805 static ffelexHandler ffestb_R9232_ (ffelexToken t);
 806 static ffelexHandler ffestb_R9233_ (ffelexToken ft, ffebld expr,
 807                                     ffelexToken t);
 808 static ffelexHandler ffestb_R9234_ (ffelexToken t);
 809 static ffelexHandler ffestb_R9235_ (ffelexToken t);
 810 static ffelexHandler ffestb_R9236_ (ffelexToken ft, ffebld expr,
 811                                     ffelexToken t);
 812 static ffelexHandler ffestb_R9237_ (ffelexToken t);
 813 static ffelexHandler ffestb_R9238_ (ffelexToken t);
 814 static ffelexHandler ffestb_R9239_ (ffelexToken t);
 815 static ffelexHandler ffestb_R92310_ (ffelexToken t);
 816 static ffelexHandler ffestb_R92311_ (ffelexToken ft, ffebld expr,
 817                                      ffelexToken t);
 818 #if FFESTR_VXT
 819 static ffelexHandler ffestb_V0181_ (ffelexToken t);
 820 static ffelexHandler ffestb_V0182_ (ffelexToken t);
 821 static ffelexHandler ffestb_V0183_ (ffelexToken ft, ffebld expr,
 822                                     ffelexToken t);
 823 static ffelexHandler ffestb_V0184_ (ffelexToken t);
 824 static ffelexHandler ffestb_V0185_ (ffelexToken t);
 825 static ffelexHandler ffestb_V0186_ (ffelexToken ft, ffebld expr,
 826                                     ffelexToken t);
 827 static ffelexHandler ffestb_V0187_ (ffelexToken t);
 828 static ffelexHandler ffestb_V0188_ (ffelexToken t);
 829 static ffelexHandler ffestb_V0189_ (ffelexToken ft, ffebld expr,
 830                                     ffelexToken t);
 831 static ffelexHandler ffestb_V01810_ (ffelexToken t);
 832 static ffelexHandler ffestb_V01811_ (ffelexToken t);
 833 static ffelexHandler ffestb_V01812_ (ffelexToken t);
 834 static ffelexHandler ffestb_V01813_ (ffelexToken ft, ffebld expr,
 835                                      ffelexToken t);
 836 static ffelexHandler ffestb_V0191_ (ffelexToken ft, ffebld expr,
 837                                     ffelexToken t);
 838 static ffelexHandler ffestb_V0192_ (ffelexToken ft, ffebld expr,
 839                                     ffelexToken t);
 840 #endif
 841 static ffelexHandler ffestb_V0201_ (ffelexToken ft, ffebld expr,
 842                                     ffelexToken t);
 843 static ffelexHandler ffestb_V0202_ (ffelexToken ft, ffebld expr,
 844                                     ffelexToken t);
 845 #if FFESTR_VXT
 846 static ffelexHandler ffestb_V0211_ (ffelexToken t);
 847 static ffelexHandler ffestb_V0212_ (ffelexToken t);
 848 static ffelexHandler ffestb_V0213_ (ffelexToken ft, ffebld expr,
 849                                     ffelexToken t);
 850 static ffelexHandler ffestb_V0214_ (ffelexToken t);
 851 static ffelexHandler ffestb_V0215_ (ffelexToken t);
 852 static ffelexHandler ffestb_V0216_ (ffelexToken ft, ffebld expr,
 853                                     ffelexToken t);
 854 static ffelexHandler ffestb_V0217_ (ffelexToken t);
 855 static ffelexHandler ffestb_V0218_ (ffelexToken t);
 856 static ffelexHandler ffestb_V0219_ (ffelexToken t);
 857 static ffelexHandler ffestb_V0261_ (ffelexToken t);
 858 static ffelexHandler ffestb_V0262_ (ffelexToken t);
 859 static ffelexHandler ffestb_V0263_ (ffelexToken ft, ffebld expr,
 860                                     ffelexToken t);
 861 static ffelexHandler ffestb_V0264_ (ffelexToken t);
 862 static ffelexHandler ffestb_V0265_ (ffelexToken t);
 863 static ffelexHandler ffestb_V0266_ (ffelexToken ft, ffebld expr,
 864                                     ffelexToken t);
 865 static ffelexHandler ffestb_V0267_ (ffelexToken t);
 866 static ffelexHandler ffestb_V0268_ (ffelexToken t);
 867 static ffelexHandler ffestb_V0269_ (ffelexToken t);
 868 #endif
 869 #if FFESTR_F90
 870 static ffelexHandler ffestb_dimlist1_ (ffelexToken t);
 871 static ffelexHandler ffestb_dimlist2_ (ffelexToken t);
 872 static ffelexHandler ffestb_dimlist3_ (ffelexToken t);
 873 static ffelexHandler ffestb_dimlist4_ (ffelexToken t);
 874 #endif
 875 static ffelexHandler ffestb_dummy1_ (ffelexToken t);
 876 static ffelexHandler ffestb_dummy2_ (ffelexToken t);
 877 static ffelexHandler ffestb_R5241_ (ffelexToken t);
 878 static ffelexHandler ffestb_R5242_ (ffelexToken t);
 879 static ffelexHandler ffestb_R5243_ (ffelexToken t);
 880 static ffelexHandler ffestb_R5244_ (ffelexToken t);
 881 static ffelexHandler ffestb_R5471_ (ffelexToken t);
 882 static ffelexHandler ffestb_R5472_ (ffelexToken t);
 883 static ffelexHandler ffestb_R5473_ (ffelexToken t);
 884 static ffelexHandler ffestb_R5474_ (ffelexToken t);
 885 static ffelexHandler ffestb_R5475_ (ffelexToken t);
 886 static ffelexHandler ffestb_R5476_ (ffelexToken t);
 887 static ffelexHandler ffestb_R5477_ (ffelexToken t);
 888 #if FFESTR_F90
 889 static ffelexHandler ffestb_R6241_ (ffelexToken ft, ffebld expr,
 890                                     ffelexToken t);
 891 static ffelexHandler ffestb_R6242_ (ffelexToken t);
 892 #endif
 893 static ffelexHandler ffestb_R12291_ (ffelexToken t);
 894 static ffelexHandler ffestb_R12292_ (ffelexToken ft, ffebld expr,
 895                                      ffelexToken t);
 896 static ffelexHandler ffestb_decl_chartype1_ (ffelexToken t);
 897 #if FFESTR_F90
 898 static ffelexHandler ffestb_decl_recursive1_ (ffelexToken t);
 899 static ffelexHandler ffestb_decl_recursive2_ (ffelexToken t);
 900 static ffelexHandler ffestb_decl_recursive3_ (ffelexToken t);
 901 static ffelexHandler ffestb_decl_recursive4_ (ffelexToken t);
 902 #endif
 903 static ffelexHandler ffestb_decl_attrs_ (ffelexToken t);
 904 static ffelexHandler ffestb_decl_attrs_1_ (ffelexToken t);
 905 static ffelexHandler ffestb_decl_attrs_2_ (ffelexToken t);
 906 #if FFESTR_F90
 907 static ffelexHandler ffestb_decl_attrs_3_ (ffelexToken t);
 908 static ffelexHandler ffestb_decl_attrs_4_ (ffelexToken t);
 909 static ffelexHandler ffestb_decl_attrs_5_ (ffelexToken t);
 910 static ffelexHandler ffestb_decl_attrs_6_ (ffelexToken t);
 911 #endif
 912 static ffelexHandler ffestb_decl_attrs_7_ (ffelexToken t);
 913 static ffelexHandler ffestb_decl_attrsp_ (ffelexToken t);
 914 static ffelexHandler ffestb_decl_ents_ (ffelexToken t);
 915 static ffelexHandler ffestb_decl_ents_1_ (ffelexToken t);
 916 static ffelexHandler ffestb_decl_ents_2_ (ffelexToken t);
 917 static ffelexHandler ffestb_decl_ents_3_ (ffelexToken t);
 918 static ffelexHandler ffestb_decl_ents_4_ (ffelexToken t);
 919 static ffelexHandler ffestb_decl_ents_5_ (ffelexToken t);
 920 static ffelexHandler ffestb_decl_ents_6_ (ffelexToken ft, ffebld expr,
 921                                           ffelexToken t);
 922 static ffelexHandler ffestb_decl_ents_7_ (ffelexToken t);
 923 static ffelexHandler ffestb_decl_ents_8_ (ffelexToken ft, ffebld expr,
 924                                           ffelexToken t);
 925 static ffelexHandler ffestb_decl_ents_9_ (ffelexToken ft, ffebld expr,
 926                                           ffelexToken t);
 927 static ffelexHandler ffestb_decl_ents_10_ (ffelexToken ft, ffebld expr,
 928                                            ffelexToken t);
 929 static ffelexHandler ffestb_decl_ents_11_ (ffelexToken t);
 930 static ffelexHandler ffestb_decl_entsp_ (ffelexToken t);
 931 static ffelexHandler ffestb_decl_entsp_1_ (ffelexToken t);
 932 static ffelexHandler ffestb_decl_entsp_2_ (ffelexToken t);
 933 static ffelexHandler ffestb_decl_entsp_3_ (ffelexToken t);
 934 static ffelexHandler ffestb_decl_entsp_4_ (ffelexToken ft, ffebld expr,
 935                                            ffelexToken t);
 936 static ffelexHandler ffestb_decl_entsp_5_ (ffelexToken t);
 937 static ffelexHandler ffestb_decl_entsp_6_ (ffelexToken t);
 938 static ffelexHandler ffestb_decl_entsp_7_ (ffelexToken t);
 939 static ffelexHandler ffestb_decl_entsp_8_ (ffelexToken t);
 940 #if FFESTR_F90
 941 static ffelexHandler ffestb_decl_func_ (ffelexToken t);
 942 #endif
 943 static ffelexHandler ffestb_decl_funcname_ (ffelexToken t);
 944 static ffelexHandler ffestb_decl_funcname_1_ (ffelexToken t);
 945 static ffelexHandler ffestb_decl_funcname_2_ (ffelexToken t);
 946 static ffelexHandler ffestb_decl_funcname_3_ (ffelexToken ft, ffebld expr,
 947                                               ffelexToken t);
 948 static ffelexHandler ffestb_decl_funcname_4_ (ffelexToken t);
 949 static ffelexHandler ffestb_decl_funcname_5_ (ffelexToken t);
 950 static ffelexHandler ffestb_decl_funcname_6_ (ffelexToken t);
 951 static ffelexHandler ffestb_decl_funcname_7_ (ffelexToken t);
 952 static ffelexHandler ffestb_decl_funcname_8_ (ffelexToken t);
 953 static ffelexHandler ffestb_decl_funcname_9_ (ffelexToken t);
 954 #if FFESTR_VXT
 955 static ffelexHandler ffestb_V0031_ (ffelexToken t);
 956 static ffelexHandler ffestb_V0032_ (ffelexToken t);
 957 static ffelexHandler ffestb_V0033_ (ffelexToken t);
 958 static ffelexHandler ffestb_V0034_ (ffelexToken t);
 959 static ffelexHandler ffestb_V0035_ (ffelexToken t);
 960 static ffelexHandler ffestb_V0036_ (ffelexToken t);
 961 static ffelexHandler ffestb_V0161_ (ffelexToken t);
 962 static ffelexHandler ffestb_V0162_ (ffelexToken t);
 963 static ffelexHandler ffestb_V0163_ (ffelexToken t);
 964 static ffelexHandler ffestb_V0164_ (ffelexToken t);
 965 static ffelexHandler ffestb_V0165_ (ffelexToken t);
 966 static ffelexHandler ffestb_V0166_ (ffelexToken t);
 967 #endif
 968 static ffelexHandler ffestb_V0271_ (ffelexToken t);
 969 static ffelexHandler ffestb_V0272_ (ffelexToken ft, ffebld expr,
 970                                     ffelexToken t);
 971 static ffelexHandler ffestb_V0273_ (ffelexToken t);
 972 static ffelexHandler ffestb_decl_R5391_ (ffelexToken t);
 973 static ffelexHandler ffestb_decl_R5392_ (ffelexToken t);
 974 #if FFESTR_F90
 975 static ffelexHandler ffestb_decl_R5393_ (ffelexToken t);
 976 #endif
 977 static ffelexHandler ffestb_decl_R5394_ (ffelexToken t);
 978 static ffelexHandler ffestb_decl_R5395_ (ffelexToken t);
 979 static ffelexHandler ffestb_decl_R539letters_ (ffelexToken t);
 980 static ffelexHandler ffestb_decl_R539letters_1_ (ffelexToken t);
 981 static ffelexHandler ffestb_decl_R539letters_2_ (ffelexToken t);
 982 static ffelexHandler ffestb_decl_R539letters_3_ (ffelexToken t);
 983 static ffelexHandler ffestb_decl_R539letters_4_ (ffelexToken t);
 984 static ffelexHandler ffestb_decl_R539letters_5_ (ffelexToken t);
 985 static ffelexHandler ffestb_decl_R539maybe_ (ffelexToken t);
 986 static ffelexHandler ffestb_decl_R539maybe_1_ (ffelexToken t);
 987 static ffelexHandler ffestb_decl_R539maybe_2_ (ffelexToken t);
 988 static ffelexHandler ffestb_decl_R539maybe_3_ (ffelexToken t);
 989 static ffelexHandler ffestb_decl_R539maybe_4_ (ffelexToken t);
 990 static ffelexHandler ffestb_decl_R539maybe_5_ (ffelexToken t);
 991
 992 /* Internal macros. */
 993
 994 #if FFESTB_KILL_EASY_
 995 #define ffestb_subr_kill_accept_() \
 996       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_acceptix)
 997 #define ffestb_subr_kill_beru_() \
 998       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_beruix)
 999 #define ffestb_subr_kill_close_() \
1000       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_closeix)
1001 #define ffestb_subr_kill_delete_() \
1002       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_deleteix)
1003 #define ffestb_subr_kill_find_() \
1004       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_findix)
1005 #define ffestb_subr_kill_inquire_() \
1006       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_inquireix)
1007 #define ffestb_subr_kill_open_() \
1008       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_openix)
1009 #define ffestb_subr_kill_print_() \
1010       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_printix)
1011 #define ffestb_subr_kill_read_() \
1012       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_readix)
1013 #define ffestb_subr_kill_rewrite_() \
1014       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_rewriteix)
1015 #define ffestb_subr_kill_type_() \
1016       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_typeix)
1017 #define ffestb_subr_kill_vxtcode_() \
1018       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_vxtcodeix)
1019 #define ffestb_subr_kill_write_() \
1020       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_writeix)
1021 #endif
1022 \f
1023 /* ffestb_subr_ambig_nope_ -- Cleans up and aborts ambig w/o confirming
1024
1025    ffestb_subr_ambig_nope_();
1026
1027    Switch from ambiguity handling in _entsp_ functions to handling entities
1028    in _ents_ (perform housekeeping tasks).  */
1029
1030 static ffelexHandler
1031 ffestb_subr_ambig_nope_ (ffelexToken t)
1032 {
1033   if (ffestb_local_.decl.recursive != NULL)
1034     ffelex_token_kill (ffestb_local_.decl.recursive);
1035   if (ffestb_local_.decl.kindt != NULL)
1036     ffelex_token_kill (ffestb_local_.decl.kindt);
1037   if (ffestb_local_.decl.lent != NULL)
1038     ffelex_token_kill (ffestb_local_.decl.lent);
1039   ffelex_token_kill (ffesta_tokens[1]);
1040   ffelex_token_kill (ffesta_tokens[2]);
1041   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
1042   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
1043   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1044 }
1045
1046 /* ffestb_subr_ambig_to_ents_ -- Switches from ambiguity to entity decl
1047
1048    ffestb_subr_ambig_to_ents_();
1049
1050    Switch from ambiguity handling in _entsp_ functions to handling entities
1051    in _ents_ (perform housekeeping tasks).  */
1052
1053 static void
1054 ffestb_subr_ambig_to_ents_ ()
1055 {
1056   ffelexToken nt;
1057
1058   nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
1059   ffelex_token_kill (ffesta_tokens[1]);
1060   ffelex_token_kill (ffesta_tokens[2]);
1061   ffesta_tokens[1] = nt;
1062   if (ffestb_local_.decl.recursive != NULL)
1063     ffelex_token_kill (ffestb_local_.decl.recursive);
1064   if (!ffestb_local_.decl.aster_after)
1065     {
1066       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
1067         {
1068           if (!ffesta_is_inhibited ())
1069             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1070                           ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
1071                            ffestb_local_.decl.len, ffestb_local_.decl.lent);
1072           if (ffestb_local_.decl.kindt != NULL)
1073             {
1074               ffelex_token_kill (ffestb_local_.decl.kindt);
1075               ffestb_local_.decl.kind = NULL;
1076               ffestb_local_.decl.kindt = NULL;
1077             }
1078           if (ffestb_local_.decl.lent != NULL)
1079             {
1080               ffelex_token_kill (ffestb_local_.decl.lent);
1081               ffestb_local_.decl.len = NULL;
1082               ffestb_local_.decl.lent = NULL;
1083             }
1084         }
1085       else
1086         {
1087           if (!ffesta_is_inhibited ())
1088             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1089                     ffestb_local_.decl.kind, ffestb_local_.decl.kindt, NULL,
1090                                NULL);
1091           if (ffestb_local_.decl.kindt != NULL)
1092             {
1093               ffelex_token_kill (ffestb_local_.decl.kindt);
1094               ffestb_local_.decl.kind = NULL;
1095               ffestb_local_.decl.kindt = NULL;
1096             }
1097         }
1098       return;
1099     }
1100   if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
1101     {
1102       if (!ffesta_is_inhibited ())
1103         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1104              ffestb_local_.decl.kind, ffestb_local_.decl.kindt, NULL, NULL);
1105       if (ffestb_local_.decl.kindt != NULL)
1106         {
1107           ffelex_token_kill (ffestb_local_.decl.kindt);
1108           ffestb_local_.decl.kind = NULL;
1109           ffestb_local_.decl.kindt = NULL;
1110         }
1111     }
1112   else if (!ffesta_is_inhibited ())
1113     ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1114                        NULL, NULL, NULL, NULL);
1115   /* NAME/NAMES token already in ffesta_tokens[1]. */
1116 }
1117
1118 /* ffestb_subr_dimlist_ -- OPEN_PAREN expr
1119
1120    (ffestb_subr_dimlist_)  // to expression handler
1121
1122    Deal with a dimension list.
1123
1124    19-Dec-90  JCB  1.1
1125       Detect too many dimensions if backend wants it.  */
1126
1127 static ffelexHandler
1128 ffestb_subr_dimlist_ (ffelexToken ft, ffebld expr, ffelexToken t)
1129 {
1130   switch (ffelex_token_type (t))
1131     {
1132     case FFELEX_typeCLOSE_PAREN:
1133       if (expr == NULL)
1134         break;
1135 #ifdef FFECOM_dimensionsMAX
1136       if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
1137         {
1138           ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
1139           ffestb_subrargs_.dim_list.ok = TRUE;  /* Not a parse error, really. */
1140           return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1141         }
1142 #endif
1143       ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, NULL, expr,
1144                              ffelex_token_use (t));
1145       ffestb_subrargs_.dim_list.ok = TRUE;
1146       return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1147
1148     case FFELEX_typeCOMMA:
1149       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1150         break;
1151 #ifdef FFECOM_dimensionsMAX
1152       if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
1153         {
1154           ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
1155           return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1156                                               ffestb_subrargs_.dim_list.ctx,
1157                                   (ffeexprCallback) ffestb_subr_dimlist_2_);
1158         }
1159 #endif
1160       ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, NULL, expr,
1161                              ffelex_token_use (t));
1162       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1163                                           ffestb_subrargs_.dim_list.ctx,
1164                                     (ffeexprCallback) ffestb_subr_dimlist_);
1165
1166     case FFELEX_typeCOLON:
1167       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1168         break;
1169 #ifdef FFECOM_dimensionsMAX
1170       if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
1171         {
1172           ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
1173           return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1174                                               ffestb_subrargs_.dim_list.ctx,
1175                                   (ffeexprCallback) ffestb_subr_dimlist_2_);
1176         }
1177 #endif
1178       ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, expr, NULL,
1179                              ffelex_token_use (t));     /* NULL second expr for
1180                                                            now, just plug in. */
1181       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1182                                           ffestb_subrargs_.dim_list.ctx,
1183                                   (ffeexprCallback) ffestb_subr_dimlist_1_);
1184
1185     default:
1186       break;
1187     }
1188
1189   ffestb_subrargs_.dim_list.ok = FALSE;
1190   return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
1191 }
1192
1193 /* ffestb_subr_dimlist_1_ -- OPEN_PAREN expr COLON expr
1194
1195    (ffestb_subr_dimlist_1_)  // to expression handler
1196
1197    Get the upper bound.  */
1198
1199 static ffelexHandler
1200 ffestb_subr_dimlist_1_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
1201 {
1202   switch (ffelex_token_type (t))
1203     {
1204     case FFELEX_typeCLOSE_PAREN:
1205       ffestb_subrargs_.dim_list.dims->previous->upper = expr;
1206       ffestb_subrargs_.dim_list.ok = TRUE;
1207       return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1208
1209     case FFELEX_typeCOMMA:
1210       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1211         break;
1212       ffestb_subrargs_.dim_list.dims->previous->upper = expr;
1213       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1214       ffestb_subrargs_.dim_list.ctx, (ffeexprCallback) ffestb_subr_dimlist_);
1215
1216     default:
1217       break;
1218     }
1219
1220   ffestb_subrargs_.dim_list.ok = FALSE;
1221   return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
1222 }
1223
1224 /* ffestb_subr_dimlist_2_ -- OPEN_PAREN too-many-dim-exprs
1225
1226    (ffestb_subr_dimlist_2_)  // to expression handler
1227
1228    Get the upper bound.  */
1229
1230 static ffelexHandler
1231 ffestb_subr_dimlist_2_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
1232 {
1233   switch (ffelex_token_type (t))
1234     {
1235     case FFELEX_typeCLOSE_PAREN:
1236       ffestb_subrargs_.dim_list.ok = TRUE;      /* Not a parse error, really. */
1237       return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1238
1239     case FFELEX_typeCOMMA:
1240     case FFELEX_typeCOLON:
1241       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1242         break;
1243       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1244                                           ffestb_subrargs_.dim_list.ctx,
1245                                   (ffeexprCallback) ffestb_subr_dimlist_2_);
1246
1247     default:
1248       break;
1249     }
1250
1251   ffestb_subrargs_.dim_list.ok = FALSE;
1252   return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
1253 }
1254
1255 /* ffestb_subr_name_list_ -- Collect a list of name args and close-paren
1256
1257    return ffestb_subr_name_list_;  // to lexer after seeing OPEN_PAREN
1258
1259    This implements R1224 in the Fortran 90 spec.  The arg list may be
1260    empty, or be a comma-separated list (an optional trailing comma currently
1261    results in a warning but no other effect) of arguments.  For functions,
1262    however, "*" is invalid (we implement dummy-arg-name, rather than R1224
1263    dummy-arg, which itself is either dummy-arg-name or "*").  */
1264
1265 static ffelexHandler
1266 ffestb_subr_name_list_ (ffelexToken t)
1267 {
1268   switch (ffelex_token_type (t))
1269     {
1270     case FFELEX_typeCLOSE_PAREN:
1271       if (ffestt_tokenlist_count (ffestb_subrargs_.name_list.args) != 0)
1272         {                       /* Trailing comma, warn. */
1273           ffebad_start (FFEBAD_TRAILING_COMMA);
1274           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
1275           ffebad_finish ();
1276         }
1277       ffestb_subrargs_.name_list.ok = TRUE;
1278       ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1279       if (ffestb_subrargs_.name_list.names)
1280         ffelex_set_names (TRUE);
1281       return (ffelexHandler) ffestb_subrargs_.name_list.handler;
1282
1283     case FFELEX_typeASTERISK:
1284       if (!ffestb_subrargs_.name_list.is_subr)
1285         break;
1286
1287     case FFELEX_typeNAME:
1288       ffestt_tokenlist_append (ffestb_subrargs_.name_list.args,
1289                                ffelex_token_use (t));
1290       return (ffelexHandler) ffestb_subr_name_list_1_;
1291
1292     default:
1293       break;
1294     }
1295
1296   ffestb_subrargs_.name_list.ok = FALSE;
1297   ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1298   if (ffestb_subrargs_.name_list.names)
1299     ffelex_set_names (TRUE);
1300   return (ffelexHandler) (*ffestb_subrargs_.name_list.handler) (t);
1301 }
1302
1303 /* ffestb_subr_name_list_1_ -- NAME or ASTERISK
1304
1305    return ffestb_subr_name_list_1_;  // to lexer
1306
1307    The next token must be COMMA or CLOSE_PAREN, either way go to original
1308    state, but only after adding the appropriate name list item.  */
1309
1310 static ffelexHandler
1311 ffestb_subr_name_list_1_ (ffelexToken t)
1312 {
1313   switch (ffelex_token_type (t))
1314     {
1315     case FFELEX_typeCOMMA:
1316       return (ffelexHandler) ffestb_subr_name_list_;
1317
1318     case FFELEX_typeCLOSE_PAREN:
1319       ffestb_subrargs_.name_list.ok = TRUE;
1320       ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1321       if (ffestb_subrargs_.name_list.names)
1322         ffelex_set_names (TRUE);
1323       return (ffelexHandler) ffestb_subrargs_.name_list.handler;
1324
1325     default:
1326       ffestb_subrargs_.name_list.ok = FALSE;
1327       ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1328       if (ffestb_subrargs_.name_list.names)
1329         ffelex_set_names (TRUE);
1330       return (ffelexHandler) (*ffestb_subrargs_.name_list.handler) (t);
1331     }
1332 }
1333
1334 static void
1335 ffestb_subr_R1001_append_p_ (void)
1336 {
1337   ffesttFormatList f;
1338
1339   if (!ffestb_local_.format.pre.present)
1340     {
1341       ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_P_SPEC, ffestb_local_.format.t);
1342       ffelex_token_kill (ffestb_local_.format.t);
1343       return;
1344     }
1345
1346   f = ffestt_formatlist_append (ffestb_local_.format.f);
1347   f->type = FFESTP_formattypeP;
1348   f->t = ffestb_local_.format.t;
1349   f->u.R1010.val = ffestb_local_.format.pre;
1350 }
1351
1352 /* ffestb_decl_kindparam_ -- "type" OPEN_PAREN
1353
1354    return ffestb_decl_kindparam_;  // to lexer
1355
1356    Handle "[KIND=]expr)".  */
1357
1358 static ffelexHandler
1359 ffestb_decl_kindparam_ (ffelexToken t)
1360 {
1361   switch (ffelex_token_type (t))
1362     {
1363     case FFELEX_typeNAME:
1364       ffesta_tokens[1] = ffelex_token_use (t);
1365       return (ffelexHandler) ffestb_decl_kindparam_1_;
1366
1367     default:
1368       return (ffelexHandler) (*((ffelexHandler)
1369                                 ffeexpr_rhs (ffesta_output_pool,
1370                                              FFEEXPR_contextKINDTYPE,
1371                                (ffeexprCallback) ffestb_decl_kindparam_2_)))
1372         (t);
1373     }
1374 }
1375
1376 /* ffestb_decl_kindparam_1_ -- "type" OPEN_PAREN NAME
1377
1378    return ffestb_decl_kindparam_1_;  // to lexer
1379
1380    Handle "[KIND=]expr)".  */
1381
1382 static ffelexHandler
1383 ffestb_decl_kindparam_1_ (ffelexToken t)
1384 {
1385   ffelexHandler next;
1386   ffelexToken nt;
1387
1388   switch (ffelex_token_type (t))
1389     {
1390     case FFELEX_typeEQUALS:
1391       ffesta_confirmed ();
1392       if (ffestr_other (ffesta_tokens[1]) != FFESTR_otherKIND)
1393         break;
1394       ffelex_token_kill (ffesta_tokens[1]);
1395       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1396        FFEEXPR_contextKINDTYPE, (ffeexprCallback) ffestb_decl_kindparam_2_);
1397
1398     default:
1399       nt = ffesta_tokens[1];
1400       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1401       FFEEXPR_contextKINDTYPE, (ffeexprCallback) ffestb_decl_kindparam_2_)))
1402         (nt);
1403       ffelex_token_kill (nt);
1404       return (ffelexHandler) (*next) (t);
1405     }
1406
1407   if (ffestb_local_.decl.recursive != NULL)
1408     ffelex_token_kill (ffestb_local_.decl.recursive);
1409   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1410                      ffestb_local_.decl.badname,
1411                      ffesta_tokens[1]);
1412   ffelex_token_kill (ffesta_tokens[1]);
1413   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1414 }
1415
1416 /* ffestb_decl_kindparam_2_ -- "type" OPEN_PAREN ["KIND="] expr
1417
1418    (ffestb_decl_kindparam_2_)  // to expression handler
1419
1420    Handle "[KIND=]expr)".  */
1421
1422 static ffelexHandler
1423 ffestb_decl_kindparam_2_ (ffelexToken ft, ffebld expr, ffelexToken t)
1424 {
1425   switch (ffelex_token_type (t))
1426     {
1427     case FFELEX_typeCLOSE_PAREN:
1428       ffestb_local_.decl.kind = expr;
1429       ffestb_local_.decl.kindt = ffelex_token_use (ft);
1430       ffestb_local_.decl.len = NULL;
1431       ffestb_local_.decl.lent = NULL;
1432       ffelex_set_names (TRUE);
1433       return (ffelexHandler) ffestb_local_.decl.handler;
1434
1435     default:
1436       break;
1437     }
1438
1439   if (ffestb_local_.decl.recursive != NULL)
1440     ffelex_token_kill (ffestb_local_.decl.recursive);
1441   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1442                     ffestb_local_.decl.badname,
1443                     t);
1444   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1445 }
1446
1447 /* ffestb_decl_starkind_ -- "type" ASTERISK
1448
1449    return ffestb_decl_starkind_;  // to lexer
1450
1451    Handle NUMBER.  */
1452
1453 static ffelexHandler
1454 ffestb_decl_starkind_ (ffelexToken t)
1455 {
1456   switch (ffelex_token_type (t))
1457     {
1458     case FFELEX_typeNUMBER:
1459       ffestb_local_.decl.kindt = ffelex_token_use (t);
1460       ffestb_local_.decl.kind = NULL;
1461       ffestb_local_.decl.len = NULL;
1462       ffestb_local_.decl.lent = NULL;
1463       ffelex_set_names (TRUE);
1464       return (ffelexHandler) ffestb_local_.decl.handler;
1465
1466     default:
1467       break;
1468     }
1469
1470   if (ffestb_local_.decl.recursive != NULL)
1471     ffelex_token_kill (ffestb_local_.decl.recursive);
1472   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1473                     ffestb_local_.decl.badname,
1474                     t);
1475   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1476 }
1477
1478 /* ffestb_decl_starlen_ -- "CHARACTER" ASTERISK
1479
1480    return ffestb_decl_starlen_;  // to lexer
1481
1482    Handle NUMBER.  */
1483
1484 static ffelexHandler
1485 ffestb_decl_starlen_ (ffelexToken t)
1486 {
1487   switch (ffelex_token_type (t))
1488     {
1489     case FFELEX_typeNUMBER:
1490       ffestb_local_.decl.kind = NULL;
1491       ffestb_local_.decl.kindt = NULL;
1492       ffestb_local_.decl.len = NULL;
1493       ffestb_local_.decl.lent = ffelex_token_use (t);
1494       ffelex_set_names (TRUE);
1495       return (ffelexHandler) ffestb_local_.decl.handler;
1496
1497     case FFELEX_typeOPEN_PAREN:
1498       ffestb_local_.decl.kind = NULL;
1499       ffestb_local_.decl.kindt = NULL;
1500       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1501                                           FFEEXPR_contextCHARACTERSIZE,
1502                                   (ffeexprCallback) ffestb_decl_starlen_1_);
1503
1504     default:
1505       break;
1506     }
1507
1508   if (ffestb_local_.decl.recursive != NULL)
1509     ffelex_token_kill (ffestb_local_.decl.recursive);
1510   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1511                     ffestb_local_.decl.badname,
1512                     t);
1513   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1514 }
1515
1516 /* ffestb_decl_starlen_1_ -- "CHARACTER" ASTERISK OPEN_PAREN expr
1517
1518    (ffestb_decl_starlen_1_)  // to expression handler
1519
1520    Handle CLOSE_PAREN.  */
1521
1522 static ffelexHandler
1523 ffestb_decl_starlen_1_ (ffelexToken ft, ffebld expr, ffelexToken t)
1524 {
1525   switch (ffelex_token_type (t))
1526     {
1527     case FFELEX_typeCLOSE_PAREN:
1528       if (expr == NULL)
1529         break;
1530       ffestb_local_.decl.len = expr;
1531       ffestb_local_.decl.lent = ffelex_token_use (ft);
1532       ffelex_set_names (TRUE);
1533       return (ffelexHandler) ffestb_local_.decl.handler;
1534
1535     default:
1536       break;
1537     }
1538
1539   if (ffestb_local_.decl.recursive != NULL)
1540     ffelex_token_kill (ffestb_local_.decl.recursive);
1541   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1542                     ffestb_local_.decl.badname,
1543                     t);
1544   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1545 }
1546
1547 /* ffestb_decl_typeparams_ -- "CHARACTER" OPEN_PAREN
1548
1549    return ffestb_decl_typeparams_;  // to lexer
1550
1551    Handle "[KIND=]expr)".  */
1552
1553 static ffelexHandler
1554 ffestb_decl_typeparams_ (ffelexToken t)
1555 {
1556   switch (ffelex_token_type (t))
1557     {
1558     case FFELEX_typeNAME:
1559       ffesta_tokens[1] = ffelex_token_use (t);
1560       return (ffelexHandler) ffestb_decl_typeparams_1_;
1561
1562     default:
1563       if (ffestb_local_.decl.lent == NULL)
1564         return (ffelexHandler) (*((ffelexHandler)
1565                                   ffeexpr_rhs (ffesta_output_pool,
1566                                                FFEEXPR_contextCHARACTERSIZE,
1567                               (ffeexprCallback) ffestb_decl_typeparams_2_)))
1568           (t);
1569       if (ffestb_local_.decl.kindt != NULL)
1570         break;
1571       return (ffelexHandler) (*((ffelexHandler)
1572                                 ffeexpr_rhs (ffesta_output_pool,
1573                                              FFEEXPR_contextKINDTYPE,
1574                               (ffeexprCallback) ffestb_decl_typeparams_3_)))
1575         (t);
1576     }
1577
1578   if (ffestb_local_.decl.recursive != NULL)
1579     ffelex_token_kill (ffestb_local_.decl.recursive);
1580   if (ffestb_local_.decl.kindt != NULL)
1581     ffelex_token_kill (ffestb_local_.decl.kindt);
1582   if (ffestb_local_.decl.lent != NULL)
1583     ffelex_token_kill (ffestb_local_.decl.lent);
1584   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1585                     ffestb_local_.decl.badname,
1586                     t);
1587   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1588 }
1589
1590 /* ffestb_decl_typeparams_1_ -- "CHARACTER" OPEN_PAREN NAME
1591
1592    return ffestb_decl_typeparams_1_;  // to lexer
1593
1594    Handle "[KIND=]expr)".  */
1595
1596 static ffelexHandler
1597 ffestb_decl_typeparams_1_ (ffelexToken t)
1598 {
1599   ffelexHandler next;
1600   ffelexToken nt;
1601
1602   switch (ffelex_token_type (t))
1603     {
1604     case FFELEX_typeEQUALS:
1605       ffesta_confirmed ();
1606       switch (ffestr_other (ffesta_tokens[1]))
1607         {
1608         case FFESTR_otherLEN:
1609           if (ffestb_local_.decl.lent != NULL)
1610             break;
1611           ffelex_token_kill (ffesta_tokens[1]);
1612           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1613                                               FFEEXPR_contextCHARACTERSIZE,
1614                                (ffeexprCallback) ffestb_decl_typeparams_2_);
1615
1616         case FFESTR_otherKIND:
1617           if (ffestb_local_.decl.kindt != NULL)
1618             break;
1619           ffelex_token_kill (ffesta_tokens[1]);
1620           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1621                                               FFEEXPR_contextKINDTYPE,
1622                                (ffeexprCallback) ffestb_decl_typeparams_3_);
1623
1624         default:
1625           break;
1626         }
1627       break;
1628
1629     default:
1630       nt = ffesta_tokens[1];
1631       if (ffestb_local_.decl.lent == NULL)
1632         next = (ffelexHandler) (*((ffelexHandler)
1633                                   ffeexpr_rhs (ffesta_output_pool,
1634                                                FFEEXPR_contextCHARACTERSIZE,
1635                               (ffeexprCallback) ffestb_decl_typeparams_2_)))
1636           (nt);
1637       else if (ffestb_local_.decl.kindt == NULL)
1638         next = (ffelexHandler) (*((ffelexHandler)
1639                                   ffeexpr_rhs (ffesta_output_pool,
1640                                                FFEEXPR_contextKINDTYPE,
1641                               (ffeexprCallback) ffestb_decl_typeparams_3_)))
1642           (nt);
1643       else
1644         {
1645           ffesta_tokens[1] = nt;
1646           break;
1647         }
1648       ffelex_token_kill (nt);
1649       return (ffelexHandler) (*next) (t);
1650     }
1651
1652   if (ffestb_local_.decl.recursive != NULL)
1653     ffelex_token_kill (ffestb_local_.decl.recursive);
1654   if (ffestb_local_.decl.kindt != NULL)
1655     ffelex_token_kill (ffestb_local_.decl.kindt);
1656   if (ffestb_local_.decl.lent != NULL)
1657     ffelex_token_kill (ffestb_local_.decl.lent);
1658   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1659                     ffestb_local_.decl.badname,
1660                     ffesta_tokens[1]);
1661   ffelex_token_kill (ffesta_tokens[1]);
1662   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1663 }
1664
1665 /* ffestb_decl_typeparams_2_ -- "CHARACTER" OPEN_PAREN ["LEN="] expr
1666
1667    (ffestb_decl_typeparams_2_)  // to expression handler
1668
1669    Handle "[LEN=]expr)".  */
1670
1671 static ffelexHandler
1672 ffestb_decl_typeparams_2_ (ffelexToken ft, ffebld expr, ffelexToken t)
1673 {
1674   switch (ffelex_token_type (t))
1675     {
1676     case FFELEX_typeCLOSE_PAREN:
1677       ffestb_local_.decl.len = expr;
1678       ffestb_local_.decl.lent = ffelex_token_use (ft);
1679       ffelex_set_names (TRUE);
1680       return (ffelexHandler) ffestb_local_.decl.handler;
1681
1682     case FFELEX_typeCOMMA:
1683       ffestb_local_.decl.len = expr;
1684       ffestb_local_.decl.lent = ffelex_token_use (ft);
1685       return (ffelexHandler) ffestb_decl_typeparams_;
1686
1687     default:
1688       break;
1689     }
1690
1691   if (ffestb_local_.decl.recursive != NULL)
1692     ffelex_token_kill (ffestb_local_.decl.recursive);
1693   if (ffestb_local_.decl.kindt != NULL)
1694     ffelex_token_kill (ffestb_local_.decl.kindt);
1695   if (ffestb_local_.decl.lent != NULL)
1696     ffelex_token_kill (ffestb_local_.decl.lent);
1697   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1698                     ffestb_local_.decl.badname,
1699                     t);
1700   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1701 }
1702
1703 /* ffestb_decl_typeparams_3_ -- "CHARACTER" OPEN_PAREN ["KIND="] expr
1704
1705    (ffestb_decl_typeparams_3_)  // to expression handler
1706
1707    Handle "[KIND=]expr)".  */
1708
1709 static ffelexHandler
1710 ffestb_decl_typeparams_3_ (ffelexToken ft, ffebld expr, ffelexToken t)
1711 {
1712   switch (ffelex_token_type (t))
1713     {
1714     case FFELEX_typeCLOSE_PAREN:
1715       ffestb_local_.decl.kind = expr;
1716       ffestb_local_.decl.kindt = ffelex_token_use (ft);
1717       ffelex_set_names (TRUE);
1718       return (ffelexHandler) ffestb_local_.decl.handler;
1719
1720     case FFELEX_typeCOMMA:
1721       ffestb_local_.decl.kind = expr;
1722       ffestb_local_.decl.kindt = ffelex_token_use (ft);
1723       return (ffelexHandler) ffestb_decl_typeparams_;
1724
1725     default:
1726       break;
1727     }
1728
1729   if (ffestb_local_.decl.recursive != NULL)
1730     ffelex_token_kill (ffestb_local_.decl.recursive);
1731   if (ffestb_local_.decl.kindt != NULL)
1732     ffelex_token_kill (ffestb_local_.decl.kindt);
1733   if (ffestb_local_.decl.lent != NULL)
1734     ffelex_token_kill (ffestb_local_.decl.lent);
1735   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1736                     ffestb_local_.decl.badname,
1737                     t);
1738   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1739 }
1740
1741 /* ffestb_decl_typetype1_ -- "TYPE" OPEN_PAREN
1742
1743    return ffestb_decl_typetype1_;  // to lexer
1744
1745    Handle NAME.  */
1746
1747 #if FFESTR_F90
1748 static ffelexHandler
1749 ffestb_decl_typetype1_ (ffelexToken t)
1750 {
1751   switch (ffelex_token_type (t))
1752     {
1753     case FFELEX_typeNAME:
1754       ffestb_local_.decl.kindt = ffelex_token_use (t);
1755       return (ffelexHandler) ffestb_decl_typetype2_;
1756
1757     default:
1758       break;
1759     }
1760
1761   if (ffestb_local_.decl.recursive != NULL)
1762     ffelex_token_kill (ffestb_local_.decl.recursive);
1763   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1764                     ffestb_local_.decl.badname,
1765                     t);
1766   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1767 }
1768
1769 /* ffestb_decl_typetype2_ -- "TYPE" OPEN_PAREN NAME
1770
1771    return ffestb_decl_typetype2_;  // to lexer
1772
1773    Handle CLOSE_PAREN.  */
1774
1775 static ffelexHandler
1776 ffestb_decl_typetype2_ (ffelexToken t)
1777 {
1778   switch (ffelex_token_type (t))
1779     {
1780     case FFELEX_typeCLOSE_PAREN:
1781       ffestb_local_.decl.type = FFESTP_typeTYPE;
1782       ffestb_local_.decl.kind = NULL;
1783       ffestb_local_.decl.len = NULL;
1784       ffestb_local_.decl.lent = NULL;
1785       ffelex_set_names (TRUE);
1786       return (ffelexHandler) ffestb_local_.decl.handler;
1787
1788     default:
1789       break;
1790     }
1791
1792   if (ffestb_local_.decl.recursive != NULL)
1793     ffelex_token_kill (ffestb_local_.decl.recursive);
1794   ffelex_token_kill (ffestb_local_.decl.kindt);
1795   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1796                     ffestb_local_.decl.badname,
1797                     t);
1798   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1799 }
1800
1801 #endif
1802 /* ffestb_subr_label_list_ -- Collect a tokenlist of labels and close-paren
1803
1804    return ffestb_subr_label_list_;  // to lexer after seeing OPEN_PAREN
1805
1806    First token must be a NUMBER.  Must be followed by zero or more COMMA
1807    NUMBER pairs.  Must then be followed by a CLOSE_PAREN.  If all ok, put
1808    the NUMBER tokens in a token list and return via the handler for the
1809    token after CLOSE_PAREN.  Else return via
1810    same handler, but with the ok return value set FALSE.  */
1811
1812 static ffelexHandler
1813 ffestb_subr_label_list_ (ffelexToken t)
1814 {
1815   if (ffelex_token_type (t) == FFELEX_typeNUMBER)
1816     {
1817       ffestt_tokenlist_append (ffestb_subrargs_.label_list.labels,
1818                                ffelex_token_use (t));
1819       return (ffelexHandler) ffestb_subr_label_list_1_;
1820     }
1821
1822   ffestb_subrargs_.label_list.ok = FALSE;
1823   return (ffelexHandler) (*ffestb_subrargs_.label_list.handler) (t);
1824 }
1825
1826 /* ffestb_subr_label_list_1_ -- NUMBER
1827
1828    return ffestb_subr_label_list_1_;  // to lexer after seeing NUMBER
1829
1830    The next token must be COMMA, in which case go back to
1831    ffestb_subr_label_list_, or CLOSE_PAREN, in which case set ok to TRUE
1832    and go to the handler.  */
1833
1834 static ffelexHandler
1835 ffestb_subr_label_list_1_ (ffelexToken t)
1836 {
1837   switch (ffelex_token_type (t))
1838     {
1839     case FFELEX_typeCOMMA:
1840       return (ffelexHandler) ffestb_subr_label_list_;
1841
1842     case FFELEX_typeCLOSE_PAREN:
1843       ffestb_subrargs_.label_list.ok = TRUE;
1844       return (ffelexHandler) ffestb_subrargs_.label_list.handler;
1845
1846     default:
1847       ffestb_subrargs_.label_list.ok = FALSE;
1848       return (ffelexHandler) (*ffestb_subrargs_.label_list.handler) (t);
1849     }
1850 }
1851
1852 /* ffestb_do -- Parse the DO statement
1853
1854    return ffestb_do;  // to lexer
1855
1856    Make sure the statement has a valid form for the DO statement.  If it
1857    does, implement the statement.  */
1858
1859 ffelexHandler
1860 ffestb_do (ffelexToken t)
1861 {
1862   ffeTokenLength i;
1863   char *p;
1864   ffelexHandler next;
1865   ffelexToken nt;
1866   ffestrSecond kw;
1867
1868   switch (ffelex_token_type (ffesta_tokens[0]))
1869     {
1870     case FFELEX_typeNAME:
1871       if (ffesta_first_kw != FFESTR_firstDO)
1872         goto bad_0;             /* :::::::::::::::::::: */
1873       switch (ffelex_token_type (t))
1874         {
1875         case FFELEX_typeNUMBER:
1876           ffesta_confirmed ();
1877           ffesta_tokens[1] = ffelex_token_use (t);
1878           return (ffelexHandler) ffestb_do1_;
1879
1880         case FFELEX_typeCOMMA:
1881           ffesta_confirmed ();
1882           ffesta_tokens[1] = NULL;
1883           return (ffelexHandler) ffestb_do2_;
1884
1885         case FFELEX_typeNAME:
1886           ffesta_confirmed ();
1887           ffesta_tokens[1] = NULL;
1888           ffesta_tokens[2] = ffelex_token_use (t);
1889           return (ffelexHandler) ffestb_do3_;
1890
1891         case FFELEX_typeEOS:
1892         case FFELEX_typeSEMICOLON:
1893           ffesta_confirmed ();
1894           ffesta_tokens[1] = NULL;
1895           return (ffelexHandler) ffestb_do1_ (t);
1896
1897         case FFELEX_typeCOLONCOLON:
1898           ffesta_confirmed ();  /* Error, but clearly intended. */
1899           goto bad_1;           /* :::::::::::::::::::: */
1900
1901         default:
1902           goto bad_1;           /* :::::::::::::::::::: */
1903         }
1904
1905     case FFELEX_typeNAMES:
1906       if (ffesta_first_kw != FFESTR_firstDO)
1907         goto bad_0;             /* :::::::::::::::::::: */
1908       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDO);
1909       switch (ffelex_token_type (t))
1910         {
1911         case FFELEX_typeCOLONCOLON:
1912           ffesta_confirmed ();  /* Error, but clearly intended. */
1913           goto bad_1;           /* :::::::::::::::::::: */
1914
1915         default:
1916           goto bad_1;           /* :::::::::::::::::::: */
1917
1918         case FFELEX_typeOPEN_PAREN:     /* Must be "DO" label "WHILE". */
1919           if (!isdigit (*p))
1920             goto bad_i;         /* :::::::::::::::::::: */
1921           ffesta_tokens[1] = ffelex_token_number_from_names (ffesta_tokens[0],
1922                                                              i);
1923           p += ffelex_token_length (ffesta_tokens[1]);
1924           i += ffelex_token_length (ffesta_tokens[1]);
1925           if (((*p) != 'W') && ((*p) != 'w'))
1926             goto bad_i1;        /* :::::::::::::::::::: */
1927           nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
1928           kw = ffestr_second (nt);
1929           ffelex_token_kill (nt);
1930           if (kw != FFESTR_secondWHILE)
1931             goto bad_i1;        /* :::::::::::::::::::: */
1932           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1933                      FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
1934
1935         case FFELEX_typeCOMMA:
1936           ffesta_confirmed ();
1937           if (*p == '\0')
1938             {
1939               ffesta_tokens[1] = NULL;
1940               return (ffelexHandler) ffestb_do2_;
1941             }
1942           if (!isdigit (*p))
1943             goto bad_i;         /* :::::::::::::::::::: */
1944           ffesta_tokens[1] = ffelex_token_number_from_names (ffesta_tokens[0],
1945                                                              i);
1946           p += ffelex_token_length (ffesta_tokens[1]);
1947           i += ffelex_token_length (ffesta_tokens[1]);
1948           if (*p != '\0')
1949             goto bad_i1;        /* :::::::::::::::::::: */
1950           return (ffelexHandler) ffestb_do2_;
1951
1952         case FFELEX_typeEQUALS:
1953           if (isdigit (*p))
1954             {
1955               ffesta_tokens[1]
1956                 = ffelex_token_number_from_names (ffesta_tokens[0], i);
1957               p += ffelex_token_length (ffesta_tokens[1]);
1958               i += ffelex_token_length (ffesta_tokens[1]);
1959             }
1960           else
1961             ffesta_tokens[1] = NULL;
1962           if (!ffesrc_is_name_init (*p))
1963             goto bad_i1;        /* :::::::::::::::::::: */
1964           nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
1965           next = (ffelexHandler) (*((ffelexHandler) ffeexpr_lhs
1966                                     (ffesta_output_pool, FFEEXPR_contextDO,
1967                                      (ffeexprCallback) ffestb_do6_)))
1968             (nt);
1969           ffelex_token_kill (nt);       /* Will get it back in _6_... */
1970           return (ffelexHandler) (*next) (t);
1971
1972         case FFELEX_typeEOS:
1973         case FFELEX_typeSEMICOLON:
1974           ffesta_confirmed ();
1975           if (isdigit (*p))
1976             {
1977               ffesta_tokens[1]
1978                 = ffelex_token_number_from_names (ffesta_tokens[0], i);
1979               p += ffelex_token_length (ffesta_tokens[1]);
1980               i += ffelex_token_length (ffesta_tokens[1]);
1981             }
1982           else
1983             ffesta_tokens[1] = NULL;
1984           if (*p != '\0')
1985             goto bad_i1;        /* :::::::::::::::::::: */
1986           return (ffelexHandler) ffestb_do1_ (t);
1987         }
1988
1989     default:
1990       goto bad_0;               /* :::::::::::::::::::: */
1991     }
1992
1993 bad_0:                          /* :::::::::::::::::::: */
1994   if (ffesta_construct_name != NULL)
1995     {
1996       ffelex_token_kill (ffesta_construct_name);
1997       ffesta_construct_name = NULL;
1998     }
1999   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0]);
2000   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2001
2002 bad_1:                          /* :::::::::::::::::::: */
2003   if (ffesta_construct_name != NULL)
2004     {
2005       ffelex_token_kill (ffesta_construct_name);
2006       ffesta_construct_name = NULL;
2007     }
2008   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2009   return (ffelexHandler) ffelex_swallow_tokens (t,
2010                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
2011
2012 bad_i1:                 /* :::::::::::::::::::: */
2013   if (ffesta_tokens[1])
2014     ffelex_token_kill (ffesta_tokens[1]);
2015
2016 bad_i:                          /* :::::::::::::::::::: */
2017   if (ffesta_construct_name != NULL)
2018     {
2019       ffelex_token_kill (ffesta_construct_name);
2020       ffesta_construct_name = NULL;
2021     }
2022   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0], i, t);
2023   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2024 }
2025
2026 /* ffestb_dowhile -- Parse the DOWHILE statement
2027
2028    return ffestb_dowhile;  // to lexer
2029
2030    Make sure the statement has a valid form for the DOWHILE statement.  If it
2031    does, implement the statement.  */
2032
2033 ffelexHandler
2034 ffestb_dowhile (ffelexToken t)
2035 {
2036   ffeTokenLength i;
2037   char *p;
2038   ffelexHandler next;
2039   ffelexToken nt;
2040
2041   switch (ffelex_token_type (ffesta_tokens[0]))
2042     {
2043     case FFELEX_typeNAMES:
2044       if (ffesta_first_kw != FFESTR_firstDOWHILE)
2045         goto bad_0;             /* :::::::::::::::::::: */
2046       switch (ffelex_token_type (t))
2047         {
2048         case FFELEX_typeEOS:
2049         case FFELEX_typeSEMICOLON:
2050         case FFELEX_typeCOMMA:
2051         case FFELEX_typeCOLONCOLON:
2052           ffesta_confirmed ();  /* Error, but clearly intended. */
2053           goto bad_1;           /* :::::::::::::::::::: */
2054
2055         default:
2056           goto bad_1;           /* :::::::::::::::::::: */
2057
2058         case FFELEX_typeOPEN_PAREN:
2059           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDOWHILE);
2060           if (*p != '\0')
2061             goto bad_i;         /* :::::::::::::::::::: */
2062           ffesta_tokens[1] = NULL;
2063           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2064                      FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
2065
2066         case FFELEX_typeEQUALS:/* Not really DOWHILE, but DOWHILExyz=.... */
2067           ffesta_tokens[1] = NULL;
2068           nt = ffelex_token_name_from_names (ffesta_tokens[0], FFESTR_firstlDO,
2069                                              0);
2070           next = (ffelexHandler) (*((ffelexHandler) ffeexpr_lhs
2071                                     (ffesta_output_pool, FFEEXPR_contextDO,
2072                                      (ffeexprCallback) ffestb_do6_)))
2073             (nt);
2074           ffelex_token_kill (nt);       /* Will get it back in _6_... */
2075           return (ffelexHandler) (*next) (t);
2076         }
2077
2078     default:
2079       goto bad_0;               /* :::::::::::::::::::: */
2080     }
2081
2082 bad_0:                          /* :::::::::::::::::::: */
2083   if (ffesta_construct_name != NULL)
2084     {
2085       ffelex_token_kill (ffesta_construct_name);
2086       ffesta_construct_name = NULL;
2087     }
2088   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0]);
2089   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2090
2091 bad_1:                          /* :::::::::::::::::::: */
2092   if (ffesta_construct_name != NULL)
2093     {
2094       ffelex_token_kill (ffesta_construct_name);
2095       ffesta_construct_name = NULL;
2096     }
2097   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2098   return (ffelexHandler) ffelex_swallow_tokens (t,
2099                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
2100
2101 bad_i:                          /* :::::::::::::::::::: */
2102   if (ffesta_construct_name != NULL)
2103     {
2104       ffelex_token_kill (ffesta_construct_name);
2105       ffesta_construct_name = NULL;
2106     }
2107   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0], i, t);
2108   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2109 }
2110
2111 /* ffestb_do1_ -- "DO" [label]
2112
2113    return ffestb_do1_;  // to lexer
2114
2115    Make sure the statement has a valid form for the DO statement.  If it
2116    does, implement the statement.  */
2117
2118 static ffelexHandler
2119 ffestb_do1_ (ffelexToken t)
2120 {
2121   switch (ffelex_token_type (t))
2122     {
2123     case FFELEX_typeCOMMA:
2124       ffesta_confirmed ();
2125       return (ffelexHandler) ffestb_do2_;
2126
2127     case FFELEX_typeEOS:
2128     case FFELEX_typeSEMICOLON:
2129       ffesta_confirmed ();
2130       if (!ffesta_is_inhibited ())
2131         {
2132           if (ffesta_tokens[1] != NULL)
2133             ffestc_R819B (ffesta_construct_name, ffesta_tokens[1], NULL,
2134                           NULL);
2135           else
2136             ffestc_R820B (ffesta_construct_name, NULL, NULL);
2137         }
2138       if (ffesta_tokens[1] != NULL)
2139         ffelex_token_kill (ffesta_tokens[1]);
2140       if (ffesta_construct_name != NULL)
2141         {
2142           ffelex_token_kill (ffesta_construct_name);
2143           ffesta_construct_name = NULL;
2144         }
2145       return (ffelexHandler) ffesta_zero (t);
2146
2147     case FFELEX_typeNAME:
2148       return (ffelexHandler) ffestb_do2_ (t);
2149
2150     default:
2151       break;
2152     }
2153
2154   if (ffesta_tokens[1] != NULL)
2155     ffelex_token_kill (ffesta_tokens[1]);
2156   if (ffesta_construct_name != NULL)
2157     {
2158       ffelex_token_kill (ffesta_construct_name);
2159       ffesta_construct_name = NULL;
2160     }
2161   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2162   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2163 }
2164
2165 /* ffestb_do2_ -- "DO" [label] [,]
2166
2167    return ffestb_do2_;  // to lexer
2168
2169    Make sure the statement has a valid form for the DO statement.  If it
2170    does, implement the statement.  */
2171
2172 static ffelexHandler
2173 ffestb_do2_ (ffelexToken t)
2174 {
2175   switch (ffelex_token_type (t))
2176     {
2177     case FFELEX_typeNAME:
2178       ffesta_tokens[2] = ffelex_token_use (t);
2179       return (ffelexHandler) ffestb_do3_;
2180
2181     default:
2182       break;
2183     }
2184
2185   if (ffesta_tokens[1] != NULL)
2186     ffelex_token_kill (ffesta_tokens[1]);
2187   if (ffesta_construct_name != NULL)
2188     {
2189       ffelex_token_kill (ffesta_construct_name);
2190       ffesta_construct_name = NULL;
2191     }
2192   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2193   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2194 }
2195
2196 /* ffestb_do3_ -- "DO" [label] [,] NAME
2197
2198    return ffestb_do3_;  // to lexer
2199
2200    Make sure the statement has a valid form for the DO statement.  If it
2201    does, implement the statement.  */
2202
2203 static ffelexHandler
2204 ffestb_do3_ (ffelexToken t)
2205 {
2206   ffelexHandler next;
2207
2208   switch (ffelex_token_type (t))
2209     {
2210     case FFELEX_typeEQUALS:
2211       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
2212                          FFEEXPR_contextDO, (ffeexprCallback) ffestb_do6_)))
2213         (ffesta_tokens[2]);
2214       ffelex_token_kill (ffesta_tokens[2]);     /* Will get it back in _6_... */
2215       return (ffelexHandler) (*next) (t);
2216
2217     case FFELEX_typeOPEN_PAREN:
2218       if (ffestr_second (ffesta_tokens[2]) != FFESTR_secondWHILE)
2219         {
2220           if (ffesta_tokens[1] != NULL)
2221             ffelex_token_kill (ffesta_tokens[1]);
2222           if (ffesta_construct_name != NULL)
2223             {
2224               ffelex_token_kill (ffesta_construct_name);
2225               ffesta_construct_name = NULL;
2226             }
2227           ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[2]);
2228           ffelex_token_kill (ffesta_tokens[2]);
2229           return (ffelexHandler) ffelex_swallow_tokens (t,
2230                                                (ffelexHandler) ffesta_zero);    /* Invalid token. */
2231         }
2232       ffelex_token_kill (ffesta_tokens[2]);
2233       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2234                      FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
2235
2236     default:
2237       break;
2238     }
2239
2240   ffelex_token_kill (ffesta_tokens[2]);
2241   if (ffesta_tokens[1] != NULL)
2242     ffelex_token_kill (ffesta_tokens[1]);
2243   if (ffesta_construct_name != NULL)
2244     {
2245       ffelex_token_kill (ffesta_construct_name);
2246       ffesta_construct_name = NULL;
2247     }
2248   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2249   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2250 }
2251
2252 /* ffestb_do4_ -- "DO" [label] [,] "WHILE" OPEN_PAREN expr
2253
2254    (ffestb_do4_)  // to expression handler
2255
2256    Make sure the statement has a valid form for the DO statement.  If it
2257    does, implement the statement.  */
2258
2259 static ffelexHandler
2260 ffestb_do4_ (ffelexToken ft, ffebld expr, ffelexToken t)
2261 {
2262   switch (ffelex_token_type (t))
2263     {
2264     case FFELEX_typeCLOSE_PAREN:
2265       if (expr == NULL)
2266         break;
2267       ffesta_tokens[2] = ffelex_token_use (ft);
2268       ffestb_local_.dowhile.expr = expr;
2269       return (ffelexHandler) ffestb_do5_;
2270
2271     default:
2272       break;
2273     }
2274
2275   if (ffesta_tokens[1] != NULL)
2276     ffelex_token_kill (ffesta_tokens[1]);
2277   if (ffesta_construct_name != NULL)
2278     {
2279       ffelex_token_kill (ffesta_construct_name);
2280       ffesta_construct_name = NULL;
2281     }
2282   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2283   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2284 }
2285
2286 /* ffestb_do5_ -- "DO" [label] [,] "WHILE" OPEN_PAREN expr CLOSE_PAREN
2287
2288    return ffestb_do5_;  // to lexer
2289
2290    Make sure the statement has a valid form for the DO statement.  If it
2291    does, implement the statement.  */
2292
2293 static ffelexHandler
2294 ffestb_do5_ (ffelexToken t)
2295 {
2296   switch (ffelex_token_type (t))
2297     {
2298     case FFELEX_typeEOS:
2299     case FFELEX_typeSEMICOLON:
2300       ffesta_confirmed ();
2301       if (!ffesta_is_inhibited ())
2302         {
2303           if (ffesta_tokens[1] != NULL)
2304             ffestc_R819B (ffesta_construct_name, ffesta_tokens[1],
2305                           ffestb_local_.dowhile.expr, ffesta_tokens[2]);
2306           else
2307             ffestc_R820B (ffesta_construct_name, ffestb_local_.dowhile.expr,
2308                           ffesta_tokens[2]);
2309         }
2310       ffelex_token_kill (ffesta_tokens[2]);
2311       if (ffesta_tokens[1] != NULL)
2312         ffelex_token_kill (ffesta_tokens[1]);
2313       if (ffesta_construct_name != NULL)
2314         {
2315           ffelex_token_kill (ffesta_construct_name);
2316           ffesta_construct_name = NULL;
2317         }
2318       return (ffelexHandler) ffesta_zero (t);
2319
2320     default:
2321       break;
2322     }
2323
2324   ffelex_token_kill (ffesta_tokens[2]);
2325   if (ffesta_tokens[1] != NULL)
2326     ffelex_token_kill (ffesta_tokens[1]);
2327   if (ffesta_construct_name != NULL)
2328     {
2329       ffelex_token_kill (ffesta_construct_name);
2330       ffesta_construct_name = NULL;
2331     }
2332   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2333   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2334 }
2335
2336 /* ffestb_do6_ -- "DO" [label] [,] var-expr
2337
2338    (ffestb_do6_)  // to expression handler
2339
2340    Make sure the statement has a valid form for the DO statement.  If it
2341    does, implement the statement.  */
2342
2343 static ffelexHandler
2344 ffestb_do6_ (ffelexToken ft, ffebld expr, ffelexToken t)
2345 {
2346   /* _3_ already ensured that this would be an EQUALS token.  If not, it is a
2347      bug in the FFE. */
2348
2349   assert (ffelex_token_type (t) == FFELEX_typeEQUALS);
2350
2351   ffesta_tokens[2] = ffelex_token_use (ft);
2352   ffestb_local_.do_stmt.var = expr;
2353   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2354                           FFEEXPR_contextDO, (ffeexprCallback) ffestb_do7_);
2355 }
2356
2357 /* ffestb_do7_ -- "DO" [label] [,] var-expr EQUALS expr
2358
2359    (ffestb_do7_)  // to expression handler
2360
2361    Make sure the statement has a valid form for the DO statement.  If it
2362    does, implement the statement.  */
2363
2364 static ffelexHandler
2365 ffestb_do7_ (ffelexToken ft, ffebld expr, ffelexToken t)
2366 {
2367   switch (ffelex_token_type (t))
2368     {
2369     case FFELEX_typeCOMMA:
2370       ffesta_confirmed ();
2371       if (expr == NULL)
2372         break;
2373       ffesta_tokens[3] = ffelex_token_use (ft);
2374       ffestb_local_.do_stmt.start = expr;
2375       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2376                           FFEEXPR_contextDO, (ffeexprCallback) ffestb_do8_);
2377
2378     default:
2379       break;
2380     }
2381
2382   ffelex_token_kill (ffesta_tokens[2]);
2383   if (ffesta_tokens[1] != NULL)
2384     ffelex_token_kill (ffesta_tokens[1]);
2385   if (ffesta_construct_name != NULL)
2386     {
2387       ffelex_token_kill (ffesta_construct_name);
2388       ffesta_construct_name = NULL;
2389     }
2390   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2391   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2392 }
2393
2394 /* ffestb_do8_ -- "DO" [label] [,] var-expr EQUALS expr COMMA expr
2395
2396    (ffestb_do8_)  // to expression handler
2397
2398    Make sure the statement has a valid form for the DO statement.  If it
2399    does, implement the statement.  */
2400
2401 static ffelexHandler
2402 ffestb_do8_ (ffelexToken ft, ffebld expr, ffelexToken t)
2403 {
2404   switch (ffelex_token_type (t))
2405     {
2406     case FFELEX_typeCOMMA:
2407       if (expr == NULL)
2408         break;
2409       ffesta_tokens[4] = ffelex_token_use (ft);
2410       ffestb_local_.do_stmt.end = expr;
2411       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2412                           FFEEXPR_contextDO, (ffeexprCallback) ffestb_do9_);
2413
2414     case FFELEX_typeEOS:
2415     case FFELEX_typeSEMICOLON:
2416       if (expr == NULL)
2417         break;
2418       ffesta_tokens[4] = ffelex_token_use (ft);
2419       ffestb_local_.do_stmt.end = expr;
2420       return (ffelexHandler) ffestb_do9_ (NULL, NULL, t);
2421
2422     default:
2423       break;
2424     }
2425
2426   ffelex_token_kill (ffesta_tokens[3]);
2427   ffelex_token_kill (ffesta_tokens[2]);
2428   if (ffesta_tokens[1] != NULL)
2429     ffelex_token_kill (ffesta_tokens[1]);
2430   if (ffesta_construct_name != NULL)
2431     {
2432       ffelex_token_kill (ffesta_construct_name);
2433       ffesta_construct_name = NULL;
2434     }
2435   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2436   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2437 }
2438
2439 /* ffestb_do9_ -- "DO" [label] [,] var-expr EQUALS expr COMMA expr
2440                   [COMMA expr]
2441
2442    (ffestb_do9_)  // to expression handler
2443
2444    Make sure the statement has a valid form for the DO statement.  If it
2445    does, implement the statement.  */
2446
2447 static ffelexHandler
2448 ffestb_do9_ (ffelexToken ft, ffebld expr, ffelexToken t)
2449 {
2450   switch (ffelex_token_type (t))
2451     {
2452     case FFELEX_typeEOS:
2453     case FFELEX_typeSEMICOLON:
2454       if ((expr == NULL) && (ft != NULL))
2455         break;
2456       if (!ffesta_is_inhibited ())
2457         {
2458           if (ffesta_tokens[1] != NULL)
2459             ffestc_R819A (ffesta_construct_name, ffesta_tokens[1],
2460                           ffestb_local_.do_stmt.var, ffesta_tokens[2],
2461                           ffestb_local_.do_stmt.start, ffesta_tokens[3],
2462                      ffestb_local_.do_stmt.end, ffesta_tokens[4], expr, ft);
2463           else
2464             ffestc_R820A (ffesta_construct_name, ffestb_local_.do_stmt.var,
2465                           ffesta_tokens[2], ffestb_local_.do_stmt.start,
2466                           ffesta_tokens[3], ffestb_local_.do_stmt.end,
2467                           ffesta_tokens[4], expr, ft);
2468         }
2469       ffelex_token_kill (ffesta_tokens[4]);
2470       ffelex_token_kill (ffesta_tokens[3]);
2471       ffelex_token_kill (ffesta_tokens[2]);
2472       if (ffesta_tokens[1] != NULL)
2473         ffelex_token_kill (ffesta_tokens[1]);
2474       if (ffesta_construct_name != NULL)
2475         {
2476           ffelex_token_kill (ffesta_construct_name);
2477           ffesta_construct_name = NULL;
2478         }
2479
2480       return (ffelexHandler) ffesta_zero (t);
2481
2482     default:
2483       break;
2484     }
2485
2486   ffelex_token_kill (ffesta_tokens[4]);
2487   ffelex_token_kill (ffesta_tokens[3]);
2488   ffelex_token_kill (ffesta_tokens[2]);
2489   if (ffesta_tokens[1] != NULL)
2490     ffelex_token_kill (ffesta_tokens[1]);
2491   if (ffesta_construct_name != NULL)
2492     {
2493       ffelex_token_kill (ffesta_construct_name);
2494       ffesta_construct_name = NULL;
2495     }
2496   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2497   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2498 }
2499
2500 /* ffestb_else -- Parse the ELSE statement
2501
2502    return ffestb_else;  // to lexer
2503
2504    Make sure the statement has a valid form for the ELSE statement.  If it
2505    does, implement the statement.  */
2506
2507 ffelexHandler
2508 ffestb_else (ffelexToken t)
2509 {
2510   ffeTokenLength i;
2511   char *p;
2512
2513   switch (ffelex_token_type (ffesta_tokens[0]))
2514     {
2515     case FFELEX_typeNAME:
2516       if (ffesta_first_kw != FFESTR_firstELSE)
2517         goto bad_0;             /* :::::::::::::::::::: */
2518       switch (ffelex_token_type (t))
2519         {
2520         case FFELEX_typeEOS:
2521         case FFELEX_typeSEMICOLON:
2522           ffesta_confirmed ();
2523           ffesta_tokens[1] = NULL;
2524           ffestb_args.elsexyz.second = FFESTR_secondNone;
2525           return (ffelexHandler) ffestb_else1_ (t);
2526
2527         case FFELEX_typeCOMMA:
2528         case FFELEX_typeCOLONCOLON:
2529           ffesta_confirmed ();  /* Error, but clearly intended. */
2530           goto bad_1;           /* :::::::::::::::::::: */
2531
2532         default:
2533           goto bad_1;           /* :::::::::::::::::::: */
2534
2535         case FFELEX_typeNAME:
2536           break;
2537         }
2538
2539       ffesta_confirmed ();
2540       ffestb_args.elsexyz.second = ffesta_second_kw;
2541       ffesta_tokens[1] = ffelex_token_use (t);
2542       return (ffelexHandler) ffestb_else1_;
2543
2544     case FFELEX_typeNAMES:
2545       if (ffesta_first_kw != FFESTR_firstELSE)
2546         goto bad_0;             /* :::::::::::::::::::: */
2547       switch (ffelex_token_type (t))
2548         {
2549         case FFELEX_typeCOMMA:
2550         case FFELEX_typeCOLONCOLON:
2551           ffesta_confirmed ();  /* Error, but clearly intended. */
2552           goto bad_1;           /* :::::::::::::::::::: */
2553
2554         default:
2555           goto bad_1;           /* :::::::::::::::::::: */
2556
2557         case FFELEX_typeEOS:
2558         case FFELEX_typeSEMICOLON:
2559           break;
2560         }
2561       ffesta_confirmed ();
2562       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlELSE)
2563         {
2564           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlELSE);
2565           if (!ffesrc_is_name_init (*p))
2566             goto bad_i;         /* :::::::::::::::::::: */
2567           ffesta_tokens[1]
2568             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
2569         }
2570       else
2571         ffesta_tokens[1] = NULL;
2572       ffestb_args.elsexyz.second = FFESTR_secondNone;
2573       return (ffelexHandler) ffestb_else1_ (t);
2574
2575     default:
2576       goto bad_0;               /* :::::::::::::::::::: */
2577     }
2578
2579 bad_0:                          /* :::::::::::::::::::: */
2580   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0]);
2581   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2582
2583 bad_1:                          /* :::::::::::::::::::: */
2584   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
2585   return (ffelexHandler) ffelex_swallow_tokens (t,
2586                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
2587
2588 bad_i:                          /* :::::::::::::::::::: */
2589   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0], i, t);
2590   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2591 }
2592
2593 /* ffestb_elsexyz -- Parse an ELSEIF/ELSEWHERE statement
2594
2595    return ffestb_elsexyz;  // to lexer
2596
2597    Expects len and second to be set in ffestb_args.elsexyz to the length
2598    of the ELSExyz keyword involved and the corresponding ffestrSecond value.  */
2599
2600 ffelexHandler
2601 ffestb_elsexyz (ffelexToken t)
2602 {
2603   ffeTokenLength i;
2604   char *p;
2605
2606   switch (ffelex_token_type (ffesta_tokens[0]))
2607     {
2608     case FFELEX_typeNAME:
2609       switch (ffelex_token_type (t))
2610         {
2611         case FFELEX_typeEOS:
2612         case FFELEX_typeSEMICOLON:
2613           if (ffesta_first_kw == FFESTR_firstELSEIF)
2614             goto bad_0;         /* :::::::::::::::::::: */
2615           ffesta_confirmed ();
2616           ffesta_tokens[1] = NULL;
2617           return (ffelexHandler) ffestb_else1_ (t);
2618
2619         case FFELEX_typeNAME:
2620           ffesta_confirmed ();
2621           goto bad_1;           /* :::::::::::::::::::: */
2622
2623         case FFELEX_typeOPEN_PAREN:
2624           if (ffesta_first_kw != FFESTR_firstELSEIF)
2625             goto bad_0;         /* :::::::::::::::::::: */
2626           ffesta_tokens[1] = NULL;
2627           return (ffelexHandler) ffestb_else1_ (t);
2628
2629         case FFELEX_typeCOMMA:
2630         case FFELEX_typeCOLONCOLON:
2631           ffesta_confirmed ();  /* Error, but clearly intended. */
2632           goto bad_1;           /* :::::::::::::::::::: */
2633
2634         default:
2635           goto bad_1;           /* :::::::::::::::::::: */
2636         }
2637
2638     case FFELEX_typeNAMES:
2639       switch (ffelex_token_type (t))
2640         {
2641         case FFELEX_typeCOMMA:
2642         case FFELEX_typeCOLONCOLON:
2643           ffesta_confirmed ();  /* Error, but clearly intended. */
2644           goto bad_1;           /* :::::::::::::::::::: */
2645
2646         default:
2647           goto bad_1;           /* :::::::::::::::::::: */
2648
2649         case FFELEX_typeOPEN_PAREN:
2650           if (ffesta_first_kw != FFESTR_firstELSEIF)
2651             goto bad_1;         /* :::::::::::::::::::: */
2652           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlELSEIF)
2653             {
2654               i = FFESTR_firstlELSEIF;
2655               goto bad_i;       /* :::::::::::::::::::: */
2656             }
2657           ffesta_tokens[1] = NULL;
2658           return (ffelexHandler) ffestb_else1_ (t);
2659
2660         case FFELEX_typeEOS:
2661         case FFELEX_typeSEMICOLON:
2662           break;
2663         }
2664       ffesta_confirmed ();
2665       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlELSE);
2666       ffesta_tokens[1]
2667         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
2668 #if FFESTR_F90
2669       if ((ffestb_args.elsexyz.second == FFESTR_secondWHERE)
2670           && (ffelex_token_length (ffesta_tokens[1]) != FFESTR_secondlWHERE))
2671         ffestb_args.elsexyz.second = FFESTR_secondNone;
2672 #endif
2673       return (ffelexHandler) ffestb_else1_ (t);
2674
2675     default:
2676       goto bad_0;               /* :::::::::::::::::::: */
2677     }
2678
2679 bad_0:                          /* :::::::::::::::::::: */
2680   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0]);
2681   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2682
2683 bad_1:                          /* :::::::::::::::::::: */
2684   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
2685   return (ffelexHandler) ffelex_swallow_tokens (t,
2686                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
2687
2688 bad_i:                          /* :::::::::::::::::::: */
2689   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE IF", ffesta_tokens[0], i, t);
2690   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2691 }
2692
2693 /* ffestb_else1_ -- "ELSE" (NAME)
2694
2695    return ffestb_else1_;  // to lexer
2696
2697    If EOS/SEMICOLON, implement the appropriate statement (keep in mind that
2698    "ELSE WHERE" is ambiguous at the syntactic level).  If OPEN_PAREN, start
2699    expression analysis with callback at _2_.  */
2700
2701 static ffelexHandler
2702 ffestb_else1_ (ffelexToken t)
2703 {
2704   switch (ffelex_token_type (t))
2705     {
2706     case FFELEX_typeOPEN_PAREN:
2707       if (ffestb_args.elsexyz.second == FFESTR_secondIF)
2708         {
2709           if (ffesta_tokens[1] != NULL)
2710             ffelex_token_kill (ffesta_tokens[1]);
2711           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2712                         FFEEXPR_contextIF, (ffeexprCallback) ffestb_else2_);
2713         }
2714       /* Fall through. */
2715     default:
2716       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
2717       if (ffesta_tokens[1] != NULL)
2718         ffelex_token_kill (ffesta_tokens[1]);
2719       return (ffelexHandler) ffelex_swallow_tokens (t,
2720                                                (ffelexHandler) ffesta_zero);
2721
2722     case FFELEX_typeEOS:
2723     case FFELEX_typeSEMICOLON:
2724       ffesta_confirmed ();
2725       break;
2726
2727     }
2728
2729   switch (ffestb_args.elsexyz.second)
2730     {
2731 #if FFESTR_F90
2732     case FFESTR_secondWHERE:
2733       if (!ffesta_is_inhibited ())
2734         if ((ffesta_first_kw == FFESTR_firstELSEWHERE)
2735             && (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME))
2736           ffestc_R744 ();
2737         else
2738           ffestc_elsewhere (ffesta_tokens[1]);  /* R744 or R805. */
2739       break;
2740 #endif
2741
2742     default:
2743       if (!ffesta_is_inhibited ())
2744         ffestc_R805 (ffesta_tokens[1]);
2745       break;
2746     }
2747
2748   if (ffesta_tokens[1] != NULL)
2749     ffelex_token_kill (ffesta_tokens[1]);
2750   return (ffelexHandler) ffesta_zero (t);
2751 }
2752
2753 /* ffestb_else2_ -- "ELSE" "IF" OPEN_PAREN expr
2754
2755    (ffestb_else2_)  // to expression handler
2756
2757    Make sure the next token is CLOSE_PAREN.  */
2758
2759 static ffelexHandler
2760 ffestb_else2_ (ffelexToken ft, ffebld expr, ffelexToken t)
2761 {
2762   ffestb_local_.else_stmt.expr = expr;
2763
2764   switch (ffelex_token_type (t))
2765     {
2766     case FFELEX_typeCLOSE_PAREN:
2767       if (expr == NULL)
2768         break;
2769       ffesta_tokens[1] = ffelex_token_use (ft);
2770       ffelex_set_names (TRUE);
2771       return (ffelexHandler) ffestb_else3_;
2772
2773     default:
2774       break;
2775     }
2776
2777   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2778   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2779 }
2780
2781 /* ffestb_else3_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN
2782
2783    return ffestb_else3_;  // to lexer
2784
2785    Make sure the next token is "THEN".  */
2786
2787 static ffelexHandler
2788 ffestb_else3_ (ffelexToken t)
2789 {
2790   ffeTokenLength i;
2791   char *p;
2792
2793   ffelex_set_names (FALSE);
2794
2795   switch (ffelex_token_type (t))
2796     {
2797     case FFELEX_typeNAME:
2798       ffesta_confirmed ();
2799       if (ffestr_first (t) == FFESTR_firstTHEN)
2800         return (ffelexHandler) ffestb_else4_;
2801       break;
2802
2803     case FFELEX_typeNAMES:
2804       ffesta_confirmed ();
2805       if (ffestr_first (t) != FFESTR_firstTHEN)
2806         break;
2807       if (ffelex_token_length (t) == FFESTR_firstlTHEN)
2808         return (ffelexHandler) ffestb_else4_;
2809       p = ffelex_token_text (t) + (i = FFESTR_firstlTHEN);
2810       if (!ffesrc_is_name_init (*p))
2811         goto bad_i;             /* :::::::::::::::::::: */
2812       ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
2813       return (ffelexHandler) ffestb_else5_;
2814
2815     default:
2816       break;
2817     }
2818
2819   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2820   ffelex_token_kill (ffesta_tokens[1]);
2821   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2822
2823 bad_i:                          /* :::::::::::::::::::: */
2824   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t, i, NULL);
2825   ffelex_token_kill (ffesta_tokens[1]);
2826   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2827 }
2828
2829 /* ffestb_else4_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN "THEN"
2830
2831    return ffestb_else4_;  // to lexer
2832
2833    Handle a NAME or EOS/SEMICOLON, then go to state _5_.  */
2834
2835 static ffelexHandler
2836 ffestb_else4_ (ffelexToken t)
2837 {
2838   ffelex_set_names (FALSE);
2839
2840   switch (ffelex_token_type (t))
2841     {
2842     case FFELEX_typeEOS:
2843     case FFELEX_typeSEMICOLON:
2844       ffesta_tokens[2] = NULL;
2845       return (ffelexHandler) ffestb_else5_ (t);
2846
2847     case FFELEX_typeNAME:
2848       ffesta_tokens[2] = ffelex_token_use (t);
2849       return (ffelexHandler) ffestb_else5_;
2850
2851     default:
2852       break;
2853     }
2854
2855   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2856   ffelex_token_kill (ffesta_tokens[1]);
2857   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2858 }
2859
2860 /* ffestb_else5_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN "THEN"
2861
2862    return ffestb_else5_;  // to lexer
2863
2864    Make sure the next token is EOS or SEMICOLON; implement R804.  */
2865
2866 static ffelexHandler
2867 ffestb_else5_ (ffelexToken t)
2868 {
2869   switch (ffelex_token_type (t))
2870     {
2871     case FFELEX_typeEOS:
2872     case FFELEX_typeSEMICOLON:
2873       if (!ffesta_is_inhibited ())
2874         ffestc_R804 (ffestb_local_.else_stmt.expr, ffesta_tokens[1],
2875                      ffesta_tokens[2]);
2876       ffelex_token_kill (ffesta_tokens[1]);
2877       if (ffesta_tokens[2] != NULL)
2878         ffelex_token_kill (ffesta_tokens[2]);
2879       return (ffelexHandler) ffesta_zero (t);
2880
2881     default:
2882       break;
2883     }
2884
2885   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2886   ffelex_token_kill (ffesta_tokens[1]);
2887   if (ffesta_tokens[2] != NULL)
2888     ffelex_token_kill (ffesta_tokens[2]);
2889   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2890 }
2891
2892 /* ffestb_end -- Parse the END statement
2893
2894    return ffestb_end;  // to lexer
2895
2896    Make sure the statement has a valid form for the END statement.  If it
2897    does, implement the statement.  */
2898
2899 ffelexHandler
2900 ffestb_end (ffelexToken t)
2901 {
2902   ffeTokenLength i;
2903
2904   switch (ffelex_token_type (ffesta_tokens[0]))
2905     {
2906     case FFELEX_typeNAME:
2907       if (ffesta_first_kw != FFESTR_firstEND)
2908         goto bad_0;             /* :::::::::::::::::::: */
2909       switch (ffelex_token_type (t))
2910         {
2911         case FFELEX_typeEOS:
2912         case FFELEX_typeSEMICOLON:
2913           ffesta_tokens[1] = NULL;
2914           ffestb_args.endxyz.second = FFESTR_secondNone;
2915           return (ffelexHandler) ffestb_end3_ (t);
2916
2917         case FFELEX_typeCOMMA:
2918         case FFELEX_typeCOLONCOLON:
2919           ffesta_confirmed ();  /* Error, but clearly intended. */
2920           goto bad_1;           /* :::::::::::::::::::: */
2921
2922         default:
2923           goto bad_1;           /* :::::::::::::::::::: */
2924
2925         case FFELEX_typeNAME:
2926           break;
2927         }
2928
2929       ffesta_confirmed ();
2930       ffestb_args.endxyz.second = ffesta_second_kw;
2931       switch (ffesta_second_kw)
2932         {
2933         case FFESTR_secondFILE:
2934           ffestb_args.beru.badname = "ENDFILE";
2935           return (ffelexHandler) ffestb_beru;
2936
2937         case FFESTR_secondBLOCK:
2938           return (ffelexHandler) ffestb_end1_;
2939
2940 #if FFESTR_F90
2941         case FFESTR_secondINTERFACE:
2942 #endif
2943 #if FFESTR_VXT
2944         case FFESTR_secondMAP:
2945         case FFESTR_secondSTRUCTURE:
2946         case FFESTR_secondUNION:
2947 #endif
2948 #if FFESTR_F90
2949         case FFESTR_secondWHERE:
2950           ffesta_tokens[1] = NULL;
2951           return (ffelexHandler) ffestb_end3_;
2952 #endif
2953
2954         case FFESTR_secondNone:
2955           goto bad_1;           /* :::::::::::::::::::: */
2956
2957         default:
2958           return (ffelexHandler) ffestb_end2_;
2959         }
2960
2961     case FFELEX_typeNAMES:
2962       if (ffesta_first_kw != FFESTR_firstEND)
2963         goto bad_0;             /* :::::::::::::::::::: */
2964       switch (ffelex_token_type (t))
2965         {
2966         case FFELEX_typeCOMMA:
2967         case FFELEX_typeCOLONCOLON:
2968           ffesta_confirmed ();  /* Error, but clearly intended. */
2969           goto bad_1;           /* :::::::::::::::::::: */
2970
2971         default:
2972           goto bad_1;           /* :::::::::::::::::::: */
2973
2974         case FFELEX_typeEOS:
2975         case FFELEX_typeSEMICOLON:
2976           break;
2977         }
2978       ffesta_confirmed ();
2979       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlEND)
2980         {
2981           i = FFESTR_firstlEND;
2982           goto bad_i;           /* :::::::::::::::::::: */
2983         }
2984       ffesta_tokens[1] = NULL;
2985       ffestb_args.endxyz.second = FFESTR_secondNone;
2986       return (ffelexHandler) ffestb_end3_ (t);
2987
2988     default:
2989       goto bad_0;               /* :::::::::::::::::::: */
2990     }
2991
2992 bad_0:                          /* :::::::::::::::::::: */
2993   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
2994   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2995
2996 bad_1:                          /* :::::::::::::::::::: */
2997   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
2998   return (ffelexHandler) ffelex_swallow_tokens (t,
2999                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
3000
3001 bad_i:                          /* :::::::::::::::::::: */
3002   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0], i, t);
3003   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3004 }
3005
3006 /* ffestb_endxyz -- Parse an ENDxyz statement
3007
3008    return ffestb_endxyz;  // to lexer
3009
3010    Expects len and second to be set in ffestb_args.endxyz to the length
3011    of the ENDxyz keyword involved and the corresponding ffestrSecond value.  */
3012
3013 ffelexHandler
3014 ffestb_endxyz (ffelexToken t)
3015 {
3016   ffeTokenLength i;
3017   char *p;
3018
3019   switch (ffelex_token_type (ffesta_tokens[0]))
3020     {
3021     case FFELEX_typeNAME:
3022       switch (ffelex_token_type (t))
3023         {
3024         case FFELEX_typeEOS:
3025         case FFELEX_typeSEMICOLON:
3026           ffesta_confirmed ();
3027           ffesta_tokens[1] = NULL;
3028           return (ffelexHandler) ffestb_end3_ (t);
3029
3030         case FFELEX_typeNAME:
3031           ffesta_confirmed ();
3032           switch (ffestb_args.endxyz.second)
3033             {
3034 #if FFESTR_F90
3035             case FFESTR_secondINTERFACE:
3036 #endif
3037 #if FFESTR_VXT
3038             case FFESTR_secondMAP:
3039             case FFESTR_secondSTRUCTURE:
3040             case FFESTR_secondUNION:
3041 #endif
3042 #if FFESTR_F90
3043             case FFESTR_secondWHERE:
3044               goto bad_1;       /* :::::::::::::::::::: */
3045 #endif
3046
3047             case FFESTR_secondBLOCK:
3048               if (ffesta_second_kw != FFESTR_secondDATA)
3049                 goto bad_1;     /* :::::::::::::::::::: */
3050               return (ffelexHandler) ffestb_end2_;
3051
3052             default:
3053               return (ffelexHandler) ffestb_end2_ (t);
3054             }
3055
3056         case FFELEX_typeCOMMA:
3057         case FFELEX_typeCOLONCOLON:
3058           ffesta_confirmed ();  /* Error, but clearly intended. */
3059           goto bad_1;           /* :::::::::::::::::::: */
3060
3061         default:
3062           goto bad_1;           /* :::::::::::::::::::: */
3063         }
3064
3065     case FFELEX_typeNAMES:
3066       switch (ffelex_token_type (t))
3067         {
3068         case FFELEX_typeCOMMA:
3069         case FFELEX_typeCOLONCOLON:
3070           ffesta_confirmed ();  /* Error, but clearly intended. */
3071           goto bad_1;           /* :::::::::::::::::::: */
3072
3073         default:
3074           goto bad_1;           /* :::::::::::::::::::: */
3075
3076         case FFELEX_typeEOS:
3077         case FFELEX_typeSEMICOLON:
3078           break;
3079         }
3080       ffesta_confirmed ();
3081       if (ffestb_args.endxyz.second == FFESTR_secondBLOCK)
3082         {
3083           i = FFESTR_firstlEND;
3084           goto bad_i;           /* :::::::::::::::::::: */
3085         }
3086       if (ffelex_token_length (ffesta_tokens[0]) != ffestb_args.endxyz.len)
3087         {
3088           p = ffelex_token_text (ffesta_tokens[0])
3089             + (i = ffestb_args.endxyz.len);
3090           switch (ffestb_args.endxyz.second)
3091             {
3092 #if FFESTR_F90
3093             case FFESTR_secondINTERFACE:
3094 #endif
3095 #if FFESTR_VXT
3096             case FFESTR_secondMAP:
3097             case FFESTR_secondSTRUCTURE:
3098             case FFESTR_secondUNION:
3099 #endif
3100 #if FFESTR_F90
3101             case FFESTR_secondWHERE:
3102               goto bad_i;       /* :::::::::::::::::::: */
3103 #endif
3104
3105             default:
3106               break;
3107             }
3108           if (!ffesrc_is_name_init (*p))
3109             goto bad_i;         /* :::::::::::::::::::: */
3110           ffesta_tokens[1]
3111             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
3112           return (ffelexHandler) ffestb_end3_ (t);
3113         }
3114       ffesta_tokens[1] = NULL;
3115       return (ffelexHandler) ffestb_end3_ (t);
3116
3117     default:
3118       goto bad_0;               /* :::::::::::::::::::: */
3119     }
3120
3121 bad_0:                          /* :::::::::::::::::::: */
3122   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
3123   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3124
3125 bad_1:                          /* :::::::::::::::::::: */
3126   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3127   return (ffelexHandler) ffelex_swallow_tokens (t,
3128                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
3129
3130 bad_i:                          /* :::::::::::::::::::: */
3131   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0], i, t);
3132   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3133 }
3134
3135 /* ffestb_end1_ -- "END" "BLOCK"
3136
3137    return ffestb_end1_;  // to lexer
3138
3139    Make sure the next token is "DATA".  */
3140
3141 static ffelexHandler
3142 ffestb_end1_ (ffelexToken t)
3143 {
3144   if ((ffelex_token_type (t) == FFELEX_typeNAME)
3145       && (ffesrc_strcmp_2c (ffe_case_match (), ffelex_token_text (t), "DATA",
3146                             "data", "Data")
3147           == 0))
3148     {
3149       return (ffelexHandler) ffestb_end2_;
3150     }
3151
3152   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3153   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3154 }
3155
3156 /* ffestb_end2_ -- "END" <unit-kind>
3157
3158    return ffestb_end2_;  // to lexer
3159
3160    Make sure the next token is a NAME or EOS.  */
3161
3162 static ffelexHandler
3163 ffestb_end2_ (ffelexToken t)
3164 {
3165   switch (ffelex_token_type (t))
3166     {
3167     case FFELEX_typeNAME:
3168       ffesta_tokens[1] = ffelex_token_use (t);
3169       return (ffelexHandler) ffestb_end3_;
3170
3171     case FFELEX_typeEOS:
3172     case FFELEX_typeSEMICOLON:
3173       ffesta_tokens[1] = NULL;
3174       return (ffelexHandler) ffestb_end3_ (t);
3175
3176     default:
3177       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3178       return (ffelexHandler) ffelex_swallow_tokens (t,
3179                                                (ffelexHandler) ffesta_zero);
3180     }
3181 }
3182
3183 /* ffestb_end3_ -- "END" <unit-kind> (NAME)
3184
3185    return ffestb_end3_;  // to lexer
3186
3187    Make sure the next token is an EOS, then implement the statement.  */
3188
3189 static ffelexHandler
3190 ffestb_end3_ (ffelexToken t)
3191 {
3192   switch (ffelex_token_type (t))
3193     {
3194     default:
3195       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3196       if (ffesta_tokens[1] != NULL)
3197         ffelex_token_kill (ffesta_tokens[1]);
3198       return (ffelexHandler) ffelex_swallow_tokens (t,
3199                                                (ffelexHandler) ffesta_zero);
3200
3201     case FFELEX_typeEOS:
3202     case FFELEX_typeSEMICOLON:
3203       ffesta_confirmed ();
3204       if (ffestb_args.endxyz.second == FFESTR_secondNone)
3205         {
3206           if (!ffesta_is_inhibited ())
3207             ffestc_end ();
3208           return (ffelexHandler) ffesta_zero (t);
3209         }
3210       break;
3211     }
3212
3213   switch (ffestb_args.endxyz.second)
3214     {
3215 #if FFESTR_F90
3216     case FFESTR_secondTYPE:
3217       if (!ffesta_is_inhibited ())
3218         ffestc_R425 (ffesta_tokens[1]);
3219       break;
3220 #endif
3221
3222 #if FFESTR_F90
3223     case FFESTR_secondWHERE:
3224       if (!ffesta_is_inhibited ())
3225         ffestc_R745 ();
3226       break;
3227 #endif
3228
3229     case FFESTR_secondIF:
3230       if (!ffesta_is_inhibited ())
3231         ffestc_R806 (ffesta_tokens[1]);
3232       break;
3233
3234     case FFESTR_secondSELECT:
3235       if (!ffesta_is_inhibited ())
3236         ffestc_R811 (ffesta_tokens[1]);
3237       break;
3238
3239     case FFESTR_secondDO:
3240       if (!ffesta_is_inhibited ())
3241         ffestc_R825 (ffesta_tokens[1]);
3242       break;
3243
3244     case FFESTR_secondPROGRAM:
3245       if (!ffesta_is_inhibited ())
3246         ffestc_R1103 (ffesta_tokens[1]);
3247       break;
3248
3249 #if FFESTR_F90
3250     case FFESTR_secondMODULE:
3251       if (!ffesta_is_inhibited ())
3252         ffestc_R1106 (ffesta_tokens[1]);
3253       break;
3254 #endif
3255     case FFESTR_secondBLOCK:
3256     case FFESTR_secondBLOCKDATA:
3257       if (!ffesta_is_inhibited ())
3258         ffestc_R1112 (ffesta_tokens[1]);
3259       break;
3260
3261 #if FFESTR_F90
3262     case FFESTR_secondINTERFACE:
3263       if (!ffesta_is_inhibited ())
3264         ffestc_R1203 ();
3265       break;
3266 #endif
3267
3268     case FFESTR_secondFUNCTION:
3269       if (!ffesta_is_inhibited ())
3270         ffestc_R1221 (ffesta_tokens[1]);
3271       break;
3272
3273     case FFESTR_secondSUBROUTINE:
3274       if (!ffesta_is_inhibited ())
3275         ffestc_R1225 (ffesta_tokens[1]);
3276       break;
3277
3278 #if FFESTR_VXT
3279     case FFESTR_secondSTRUCTURE:
3280       if (!ffesta_is_inhibited ())
3281         ffestc_V004 ();
3282       break;
3283 #endif
3284
3285 #if FFESTR_VXT
3286     case FFESTR_secondUNION:
3287       if (!ffesta_is_inhibited ())
3288         ffestc_V010 ();
3289       break;
3290 #endif
3291
3292 #if FFESTR_VXT
3293     case FFESTR_secondMAP:
3294       if (!ffesta_is_inhibited ())
3295         ffestc_V013 ();
3296       break;
3297 #endif
3298
3299     default:
3300       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
3301       if (ffesta_tokens[1] != NULL)
3302         ffelex_token_kill (ffesta_tokens[1]);
3303       return (ffelexHandler) ffelex_swallow_tokens (t,
3304                                                (ffelexHandler) ffesta_zero);
3305     }
3306
3307   if (ffesta_tokens[1] != NULL)
3308     ffelex_token_kill (ffesta_tokens[1]);
3309   return (ffelexHandler) ffesta_zero (t);
3310 }
3311
3312 /* ffestb_goto -- Parse the GOTO statement
3313
3314    return ffestb_goto;  // to lexer
3315
3316    Make sure the statement has a valid form for the GOTO statement.  If it
3317    does, implement the statement.  */
3318
3319 ffelexHandler
3320 ffestb_goto (ffelexToken t)
3321 {
3322   ffeTokenLength i;
3323   char *p;
3324   ffelexHandler next;
3325   ffelexToken nt;
3326
3327   switch (ffelex_token_type (ffesta_tokens[0]))
3328     {
3329     case FFELEX_typeNAME:
3330       switch (ffesta_first_kw)
3331         {
3332         case FFESTR_firstGO:
3333           if ((ffelex_token_type (t) != FFELEX_typeNAME)
3334               || (ffesta_second_kw != FFESTR_secondTO))
3335             goto bad_1;         /* :::::::::::::::::::: */
3336           ffesta_confirmed ();
3337           return (ffelexHandler) ffestb_goto1_;
3338
3339         case FFESTR_firstGOTO:
3340           return (ffelexHandler) ffestb_goto1_ (t);
3341
3342         default:
3343           goto bad_0;           /* :::::::::::::::::::: */
3344         }
3345
3346     case FFELEX_typeNAMES:
3347       if (ffesta_first_kw != FFESTR_firstGOTO)
3348         goto bad_0;             /* :::::::::::::::::::: */
3349       switch (ffelex_token_type (t))
3350         {
3351         case FFELEX_typeCOLONCOLON:
3352           ffesta_confirmed ();  /* Error, but clearly intended. */
3353           goto bad_1;           /* :::::::::::::::::::: */
3354
3355         default:
3356           goto bad_1;           /* :::::::::::::::::::: */
3357
3358         case FFELEX_typeOPEN_PAREN:
3359         case FFELEX_typePERCENT:        /* Since GOTO I%J is apparently valid
3360                                            in '90. */
3361         case FFELEX_typeCOMMA:
3362           break;
3363
3364         case FFELEX_typeEOS:
3365         case FFELEX_typeSEMICOLON:
3366           ffesta_confirmed ();
3367           break;
3368         }
3369       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlGOTO)
3370         {
3371           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlGOTO);
3372           if (isdigit (*p))
3373             {
3374               nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
3375               p += ffelex_token_length (nt);
3376               i += ffelex_token_length (nt);
3377               if (*p != '\0')
3378                 {
3379                   ffelex_token_kill (nt);
3380                   goto bad_i;   /* :::::::::::::::::::: */
3381                 }
3382             }
3383           else if (ffesrc_is_name_init (*p))
3384             {
3385               nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
3386             }
3387           else
3388             goto bad_i;         /* :::::::::::::::::::: */
3389           next = (ffelexHandler) ffestb_goto1_ (nt);
3390           ffelex_token_kill (nt);
3391           return (ffelexHandler) (*next) (t);
3392         }
3393       return (ffelexHandler) ffestb_goto1_ (t);
3394
3395     default:
3396       goto bad_0;               /* :::::::::::::::::::: */
3397     }
3398
3399 bad_0:                          /* :::::::::::::::::::: */
3400   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", ffesta_tokens[0]);
3401   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3402
3403 bad_1:                          /* :::::::::::::::::::: */
3404   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
3405   return (ffelexHandler) ffelex_swallow_tokens (t,
3406                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
3407
3408 bad_i:                          /* :::::::::::::::::::: */
3409   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "GO TO", ffesta_tokens[0], i, t);
3410   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3411 }
3412
3413 /* ffestb_goto1_ -- "GOTO" or "GO" "TO"
3414
3415    return ffestb_goto1_;  // to lexer
3416
3417    Make sure the statement has a valid form for the GOTO statement.  If it
3418    does, implement the statement.  */
3419
3420 static ffelexHandler
3421 ffestb_goto1_ (ffelexToken t)
3422 {
3423   switch (ffelex_token_type (t))
3424     {
3425     case FFELEX_typeNUMBER:
3426       if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
3427         ffesta_confirmed ();
3428       ffesta_tokens[1] = ffelex_token_use (t);
3429       return (ffelexHandler) ffestb_goto2_;
3430
3431     case FFELEX_typeOPEN_PAREN:
3432       ffesta_tokens[1] = ffelex_token_use (t);
3433       ffestb_subrargs_.label_list.labels = ffestt_tokenlist_create ();
3434       ffestb_subrargs_.label_list.handler = (ffelexHandler) ffestb_goto3_;
3435       return (ffelexHandler) ffestb_subr_label_list_;
3436
3437     case FFELEX_typeNAME:
3438       if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
3439         ffesta_confirmed ();
3440       return (ffelexHandler) (*((ffelexHandler)
3441                                 ffeexpr_lhs (ffesta_output_pool,
3442                                              FFEEXPR_contextAGOTO,
3443                                           (ffeexprCallback) ffestb_goto4_)))
3444         (t);
3445
3446     case FFELEX_typeEOS:
3447     case FFELEX_typeSEMICOLON:
3448     case FFELEX_typeCOMMA:
3449     case FFELEX_typeCOLONCOLON:
3450       ffesta_confirmed ();      /* Error, but clearly intended. */
3451       break;
3452
3453     default:
3454       break;
3455     }
3456
3457   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
3458   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3459 }
3460
3461 /* ffestb_goto2_ -- "GO/TO" NUMBER
3462
3463    return ffestb_goto2_;  // to lexer
3464
3465    Make sure the statement has a valid form for the GOTO statement.  If it
3466    does, implement the statement.  */
3467
3468 static ffelexHandler
3469 ffestb_goto2_ (ffelexToken t)
3470 {
3471   switch (ffelex_token_type (t))
3472     {
3473     case FFELEX_typeEOS:
3474     case FFELEX_typeSEMICOLON:
3475       ffesta_confirmed ();
3476       if (!ffesta_is_inhibited ())
3477         ffestc_R836 (ffesta_tokens[1]);
3478       ffelex_token_kill (ffesta_tokens[1]);
3479       return (ffelexHandler) ffesta_zero (t);
3480
3481     default:
3482       break;
3483     }
3484
3485   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
3486   ffelex_token_kill (ffesta_tokens[1]);
3487   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3488 }
3489
3490 /* ffestb_goto3_ -- "GO/TO" OPEN_PAREN label-list CLOSE_PAREN
3491
3492    return ffestb_goto3_;  // to lexer
3493
3494    Make sure the statement has a valid form for the GOTO statement.  If it
3495    does, implement the statement.  */
3496
3497 static ffelexHandler
3498 ffestb_goto3_ (ffelexToken t)
3499 {
3500   if (!ffestb_subrargs_.label_list.ok)
3501     goto bad;                   /* :::::::::::::::::::: */
3502
3503   switch (ffelex_token_type (t))
3504     {
3505     case FFELEX_typeCOMMA:
3506       ffesta_confirmed ();
3507       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextCGOTO,
3508                                           (ffeexprCallback) ffestb_goto5_);
3509
3510     case FFELEX_typeEQUALS:
3511     case FFELEX_typePOINTS:
3512     case FFELEX_typeEOS:
3513     case FFELEX_typeSEMICOLON:
3514       break;
3515
3516     default:
3517       ffesta_confirmed ();
3518       /* Fall through. */
3519     case FFELEX_typeOPEN_PAREN: /* Could still be assignment!! */
3520       return (ffelexHandler) (*((ffelexHandler)
3521                       ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextCGOTO,
3522                                    (ffeexprCallback) ffestb_goto5_)))
3523         (t);
3524     }
3525
3526 bad:                            /* :::::::::::::::::::: */
3527   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "computed-GOTO", t);
3528   ffelex_token_kill (ffesta_tokens[1]);
3529   ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3530   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3531 }
3532
3533 /* ffestb_goto4_ -- "GO/TO" expr
3534
3535    (ffestb_goto4_)  // to expression handler
3536
3537    Make sure the statement has a valid form for the GOTO statement.  If it
3538    does, implement the statement.  */
3539
3540 static ffelexHandler
3541 ffestb_goto4_ (ffelexToken ft, ffebld expr, ffelexToken t)
3542 {
3543   switch (ffelex_token_type (t))
3544     {
3545     case FFELEX_typeCOMMA:
3546       ffesta_confirmed ();
3547       if (expr == NULL)
3548         break;
3549       ffesta_tokens[1] = ffelex_token_use (ft);
3550       ffestb_local_.go_to.expr = expr;
3551       return (ffelexHandler) ffestb_goto6_;
3552
3553     case FFELEX_typeOPEN_PAREN:
3554       if (expr == NULL)
3555         break;
3556       ffesta_tokens[1] = ffelex_token_use (ft);
3557       ffestb_local_.go_to.expr = expr;
3558       return (ffelexHandler) ffestb_goto6_ (t);
3559
3560     case FFELEX_typeEOS:
3561     case FFELEX_typeSEMICOLON:
3562       ffesta_confirmed ();
3563       if (expr == NULL)
3564         break;
3565       if (!ffesta_is_inhibited ())
3566         ffestc_R839 (expr, ft, NULL);
3567       return (ffelexHandler) ffesta_zero (t);
3568
3569     default:
3570       break;
3571     }
3572
3573   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
3574   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3575 }
3576
3577 /* ffestb_goto5_ -- "GO/TO" OPEN_PAREN label-list CLOSE_PAREN (COMMA) expr
3578
3579    (ffestb_goto5_)  // to expression handler
3580
3581    Make sure the statement has a valid form for the GOTO statement.  If it
3582    does, implement the statement.  */
3583
3584 static ffelexHandler
3585 ffestb_goto5_ (ffelexToken ft, ffebld expr, ffelexToken t)
3586 {
3587   switch (ffelex_token_type (t))
3588     {
3589     case FFELEX_typeEOS:
3590     case FFELEX_typeSEMICOLON:
3591       if (expr == NULL)
3592         break;
3593       ffesta_confirmed ();
3594       if (!ffesta_is_inhibited ())
3595         ffestc_R837 (ffestb_subrargs_.label_list.labels, expr, ft);
3596       ffelex_token_kill (ffesta_tokens[1]);
3597       ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3598       return (ffelexHandler) ffesta_zero (t);
3599
3600     default:
3601       break;
3602     }
3603
3604   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "computed-GOTO", t);
3605   ffelex_token_kill (ffesta_tokens[1]);
3606   ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3607   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3608 }
3609
3610 /* ffestb_goto6_ -- "GO/TO" expr (COMMA)
3611
3612    return ffestb_goto6_;  // to lexer
3613
3614    Make sure the statement has a valid form for the GOTO statement.  If it
3615    does, implement the statement.  */
3616
3617 static ffelexHandler
3618 ffestb_goto6_ (ffelexToken t)
3619 {
3620   switch (ffelex_token_type (t))
3621     {
3622     case FFELEX_typeOPEN_PAREN:
3623       ffesta_tokens[2] = ffelex_token_use (t);
3624       ffestb_subrargs_.label_list.labels = ffestt_tokenlist_create ();
3625       ffestb_subrargs_.label_list.handler = (ffelexHandler) ffestb_goto7_;
3626       return (ffelexHandler) ffestb_subr_label_list_;
3627
3628     default:
3629       break;
3630     }
3631
3632   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
3633   ffelex_token_kill (ffesta_tokens[1]);
3634   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3635 }
3636
3637 /* ffestb_goto7_ -- "GO/TO" expr (COMMA) OPEN_PAREN label-list CLOSE_PAREN
3638
3639    return ffestb_goto7_;  // to lexer
3640
3641    Make sure the statement has a valid form for the GOTO statement.  If it
3642    does, implement the statement.  */
3643
3644 static ffelexHandler
3645 ffestb_goto7_ (ffelexToken t)
3646 {
3647   if (!ffestb_subrargs_.label_list.ok)
3648     goto bad;                   /* :::::::::::::::::::: */
3649
3650   switch (ffelex_token_type (t))
3651     {
3652     case FFELEX_typeEOS:
3653     case FFELEX_typeSEMICOLON:
3654       ffesta_confirmed ();
3655       if (!ffesta_is_inhibited ())
3656         ffestc_R839 (ffestb_local_.go_to.expr, ffesta_tokens[1],
3657                      ffestb_subrargs_.label_list.labels);
3658       ffelex_token_kill (ffesta_tokens[1]);
3659       ffelex_token_kill (ffesta_tokens[2]);
3660       ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3661       return (ffelexHandler) ffesta_zero (t);
3662
3663     default:
3664       break;
3665     }
3666
3667 bad:                            /* :::::::::::::::::::: */
3668   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
3669   ffelex_token_kill (ffesta_tokens[1]);
3670   ffelex_token_kill (ffesta_tokens[2]);
3671   ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3672   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3673 }
3674
3675 /* ffestb_halt -- Parse the STOP/PAUSE statement
3676
3677    return ffestb_halt;  // to lexer
3678
3679    Make sure the statement has a valid form for the STOP/PAUSE statement.  If
3680    it does, implement the statement.  */
3681
3682 ffelexHandler
3683 ffestb_halt (ffelexToken t)
3684 {
3685   ffelexHandler next;
3686
3687   switch (ffelex_token_type (ffesta_tokens[0]))
3688     {
3689     case FFELEX_typeNAME:
3690       switch (ffelex_token_type (t))
3691         {
3692         case FFELEX_typeCOMMA:
3693         case FFELEX_typeCOLONCOLON:
3694           ffesta_confirmed ();  /* Error, but clearly intended. */
3695           goto bad_1;           /* :::::::::::::::::::: */
3696
3697         default:
3698           goto bad_1;           /* :::::::::::::::::::: */
3699
3700         case FFELEX_typeEOS:
3701         case FFELEX_typeSEMICOLON:
3702         case FFELEX_typeNAME:
3703         case FFELEX_typeNUMBER:
3704         case FFELEX_typeAPOSTROPHE:
3705         case FFELEX_typeQUOTE:
3706           ffesta_confirmed ();
3707           break;
3708         }
3709
3710       return (ffelexHandler) (*((ffelexHandler)
3711                                 ffeexpr_rhs (ffesta_output_pool,
3712                                              FFEEXPR_contextSTOP,
3713                                           (ffeexprCallback) ffestb_halt1_)))
3714         (t);
3715
3716     case FFELEX_typeNAMES:
3717       switch (ffelex_token_type (t))
3718         {
3719         default:
3720           goto bad_1;           /* :::::::::::::::::::: */
3721
3722         case FFELEX_typeEOS:
3723         case FFELEX_typeSEMICOLON:
3724         case FFELEX_typeNAME:
3725         case FFELEX_typeNUMBER:
3726         case FFELEX_typeAPOSTROPHE:
3727         case FFELEX_typeQUOTE:
3728           ffesta_confirmed ();
3729           break;
3730         }
3731       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
3732                                           FFEEXPR_contextSTOP,
3733                                           (ffeexprCallback) ffestb_halt1_);
3734       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
3735                                                    ffestb_args.halt.len);
3736       if (next == NULL)
3737         return (ffelexHandler) ffelex_swallow_tokens (t,
3738                                                (ffelexHandler) ffesta_zero);
3739       return (ffelexHandler) (*next) (t);
3740
3741     default:
3742       goto bad_0;               /* :::::::::::::::::::: */
3743     }
3744
3745 bad_0:                          /* :::::::::::::::::::: */
3746   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
3747                      (ffesta_first_kw == FFESTR_firstSTOP)
3748                      ? "STOP" : "PAUSE",
3749                      ffesta_tokens[0]);
3750   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3751
3752 bad_1:                          /* :::::::::::::::::::: */
3753   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
3754                      (ffesta_first_kw == FFESTR_firstSTOP)
3755                      ? "STOP" : "PAUSE",
3756                      t);
3757   return (ffelexHandler) ffelex_swallow_tokens (t,
3758                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
3759 }
3760
3761 /* ffestb_halt1_ -- "STOP/PAUSE" expr
3762
3763    (ffestb_halt1_)  // to expression handler
3764
3765    Make sure the next token is an EOS or SEMICOLON.  */
3766
3767 static ffelexHandler
3768 ffestb_halt1_ (ffelexToken ft, ffebld expr, ffelexToken t)
3769 {
3770   switch (ffelex_token_type (t))
3771     {
3772     case FFELEX_typeEOS:
3773     case FFELEX_typeSEMICOLON:
3774       ffesta_confirmed ();
3775       if (!ffesta_is_inhibited ())
3776         {
3777           if (ffesta_first_kw == FFESTR_firstSTOP)
3778             ffestc_R842 (expr, ft);
3779           else
3780             ffestc_R843 (expr, ft);
3781         }
3782       return (ffelexHandler) ffesta_zero (t);
3783
3784     default:
3785       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
3786                          (ffesta_first_kw == FFESTR_firstSTOP)
3787                          ? "STOP" : "PAUSE",
3788                          t);
3789       break;
3790     }
3791
3792   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3793 }
3794
3795 /* ffestb_if -- Parse an IF statement
3796
3797    return ffestb_if;  // to lexer
3798
3799    Make sure the statement has a valid form for an IF statement.
3800    If it does, implement the statement.  */
3801
3802 ffelexHandler
3803 ffestb_if (ffelexToken t)
3804 {
3805   switch (ffelex_token_type (ffesta_tokens[0]))
3806     {
3807     case FFELEX_typeNAME:
3808       if (ffesta_first_kw != FFESTR_firstIF)
3809         goto bad_0;             /* :::::::::::::::::::: */
3810       break;
3811
3812     case FFELEX_typeNAMES:
3813       if (ffesta_first_kw != FFESTR_firstIF)
3814         goto bad_0;             /* :::::::::::::::::::: */
3815       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlIF)
3816         goto bad_0;             /* :::::::::::::::::::: */
3817       break;
3818
3819     default:
3820       goto bad_0;               /* :::::::::::::::::::: */
3821     }
3822
3823   switch (ffelex_token_type (t))
3824     {
3825     case FFELEX_typeOPEN_PAREN:
3826       break;
3827
3828     case FFELEX_typeEOS:
3829     case FFELEX_typeSEMICOLON:
3830     case FFELEX_typeCOMMA:
3831     case FFELEX_typeCOLONCOLON:
3832       ffesta_confirmed ();      /* Error, but clearly intended. */
3833       goto bad_1;               /* :::::::::::::::::::: */
3834
3835     default:
3836       goto bad_1;               /* :::::::::::::::::::: */
3837     }
3838
3839   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextIF,
3840                                       (ffeexprCallback) ffestb_if1_);
3841
3842 bad_0:                          /* :::::::::::::::::::: */
3843   if (ffesta_construct_name != NULL)
3844     {
3845       ffelex_token_kill (ffesta_construct_name);
3846       ffesta_construct_name = NULL;
3847     }
3848   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", ffesta_tokens[0]);
3849   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3850
3851 bad_1:                          /* :::::::::::::::::::: */
3852   if (ffesta_construct_name != NULL)
3853     {
3854       ffelex_token_kill (ffesta_construct_name);
3855       ffesta_construct_name = NULL;
3856     }
3857   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
3858   return (ffelexHandler) ffelex_swallow_tokens (t,
3859                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
3860 }
3861
3862 /* ffestb_if1_ -- "IF" OPEN_PAREN expr
3863
3864    (ffestb_if1_)  // to expression handler
3865
3866    Make sure the next token is CLOSE_PAREN.  */
3867
3868 static ffelexHandler
3869 ffestb_if1_ (ffelexToken ft, ffebld expr, ffelexToken t)
3870 {
3871   ffestb_local_.if_stmt.expr = expr;
3872
3873   switch (ffelex_token_type (t))
3874     {
3875     case FFELEX_typeCLOSE_PAREN:
3876       if (expr == NULL)
3877         break;
3878       ffesta_tokens[1] = ffelex_token_use (ft);
3879       ffelex_set_names (TRUE);
3880       return (ffelexHandler) ffestb_if2_;
3881
3882     default:
3883       break;
3884     }
3885
3886   if (ffesta_construct_name != NULL)
3887     {
3888       ffelex_token_kill (ffesta_construct_name);
3889       ffesta_construct_name = NULL;
3890     }
3891   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
3892   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3893 }
3894
3895 /* ffestb_if2_ -- "IF" OPEN_PAREN expr CLOSE_PAREN
3896
3897    return ffestb_if2_;  // to lexer
3898
3899    Make sure the next token is NAME.  */
3900
3901 static ffelexHandler
3902 ffestb_if2_ (ffelexToken t)
3903 {
3904   ffelex_set_names (FALSE);
3905
3906   switch (ffelex_token_type (t))
3907     {
3908     case FFELEX_typeNAME:
3909     case FFELEX_typeNAMES:
3910       ffesta_confirmed ();
3911       ffesta_tokens[2] = ffelex_token_use (t);
3912       return (ffelexHandler) ffestb_if3_;
3913
3914     default:
3915       break;
3916     }
3917
3918   ffelex_token_kill (ffesta_tokens[1]);
3919   if ((ffesta_construct_name == NULL)
3920       || (ffelex_token_type (t) != FFELEX_typeNUMBER))
3921     ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
3922   else
3923     ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
3924                        ffesta_construct_name, t);
3925   if (ffesta_construct_name != NULL)
3926     {
3927       ffelex_token_kill (ffesta_construct_name);
3928       ffesta_construct_name = NULL;
3929     }
3930   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3931 }
3932
3933 /* ffestb_if3_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NAME
3934
3935    return ffestb_if3_;  // to lexer
3936
3937    If the next token is EOS or SEMICOLON and the preceding NAME was "THEN",
3938    implement R803.  Else, implement R807 and send the preceding NAME followed
3939    by the current token.  */
3940
3941 static ffelexHandler
3942 ffestb_if3_ (ffelexToken t)
3943 {
3944   ffelexHandler next;
3945
3946   switch (ffelex_token_type (t))
3947     {
3948     case FFELEX_typeEOS:
3949     case FFELEX_typeSEMICOLON:
3950       if (ffestr_first (ffesta_tokens[2]) == FFESTR_firstTHEN)
3951         {
3952           if (!ffesta_is_inhibited ())
3953             ffestc_R803 (ffesta_construct_name, ffestb_local_.if_stmt.expr,
3954                          ffesta_tokens[1]);
3955           ffelex_token_kill (ffesta_tokens[1]);
3956           ffelex_token_kill (ffesta_tokens[2]);
3957           if (ffesta_construct_name != NULL)
3958             {
3959               ffelex_token_kill (ffesta_construct_name);
3960               ffesta_construct_name = NULL;
3961             }
3962           return (ffelexHandler) ffesta_zero (t);
3963         }
3964       break;
3965
3966     default:
3967       break;
3968     }
3969
3970   if (ffesta_construct_name != NULL)
3971     {
3972       if (!ffesta_is_inhibited ())
3973         ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
3974                            ffesta_construct_name, ffesta_tokens[2]);
3975       ffelex_token_kill (ffesta_construct_name);
3976       ffesta_construct_name = NULL;
3977       ffelex_token_kill (ffesta_tokens[1]);
3978       ffelex_token_kill (ffesta_tokens[2]);
3979       return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3980     }
3981
3982   if (!ffesta_is_inhibited ())
3983     ffestc_R807 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
3984   ffelex_token_kill (ffesta_tokens[1]);
3985   {
3986     ffelexToken my_2 = ffesta_tokens[2];
3987
3988     next = (ffelexHandler) ffesta_two (my_2, t);
3989     ffelex_token_kill (my_2);
3990   }
3991   return (ffelexHandler) next;
3992 }
3993
3994 /* ffestb_where -- Parse a WHERE statement
3995
3996    return ffestb_where;  // to lexer
3997
3998    Make sure the statement has a valid form for a WHERE statement.
3999    If it does, implement the statement.  */
4000
4001 #if FFESTR_F90
4002 ffelexHandler
4003 ffestb_where (ffelexToken t)
4004 {
4005   switch (ffelex_token_type (ffesta_tokens[0]))
4006     {
4007     case FFELEX_typeNAME:
4008       if (ffesta_first_kw != FFESTR_firstWHERE)
4009         goto bad_0;             /* :::::::::::::::::::: */
4010       break;
4011
4012     case FFELEX_typeNAMES:
4013       if (ffesta_first_kw != FFESTR_firstWHERE)
4014         goto bad_0;             /* :::::::::::::::::::: */
4015       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlWHERE)
4016         goto bad_0;             /* :::::::::::::::::::: */
4017       break;
4018
4019     default:
4020       goto bad_0;               /* :::::::::::::::::::: */
4021     }
4022
4023   switch (ffelex_token_type (t))
4024     {
4025     case FFELEX_typeOPEN_PAREN:
4026       break;
4027
4028     case FFELEX_typeEOS:
4029     case FFELEX_typeSEMICOLON:
4030     case FFELEX_typeCOMMA:
4031     case FFELEX_typeCOLONCOLON:
4032       ffesta_confirmed ();      /* Error, but clearly intended. */
4033       goto bad_1;               /* :::::::::::::::::::: */
4034
4035     default:
4036       goto bad_1;               /* :::::::::::::::::::: */
4037     }
4038
4039   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextWHERE,
4040                                       (ffeexprCallback) ffestb_where1_);
4041
4042 bad_0:                          /* :::::::::::::::::::: */
4043   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", ffesta_tokens[0]);
4044   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4045
4046 bad_1:                          /* :::::::::::::::::::: */
4047   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
4048   return (ffelexHandler) ffelex_swallow_tokens (t,
4049                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
4050 }
4051
4052 #endif
4053 /* ffestb_where1_ -- "WHERE" OPEN_PAREN expr
4054
4055    (ffestb_where1_)  // to expression handler
4056
4057    Make sure the next token is CLOSE_PAREN.  */
4058
4059 #if FFESTR_F90
4060 static ffelexHandler
4061 ffestb_where1_ (ffelexToken ft, ffebld expr, ffelexToken t)
4062 {
4063   ffestb_local_.if_stmt.expr = expr;
4064
4065   switch (ffelex_token_type (t))
4066     {
4067     case FFELEX_typeCLOSE_PAREN:
4068       if (expr == NULL)
4069         break;
4070       ffesta_tokens[1] = ffelex_token_use (ft);
4071       ffelex_set_names (TRUE);
4072       return (ffelexHandler) ffestb_where2_;
4073
4074     default:
4075       break;
4076     }
4077
4078   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
4079   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4080 }
4081
4082 #endif
4083 /* ffestb_where2_ -- "WHERE" OPEN_PAREN expr CLOSE_PAREN
4084
4085    return ffestb_where2_;  // to lexer
4086
4087    Make sure the next token is NAME.  */
4088
4089 #if FFESTR_F90
4090 static ffelexHandler
4091 ffestb_where2_ (ffelexToken t)
4092 {
4093   ffelex_set_names (FALSE);
4094
4095   switch (ffelex_token_type (t))
4096     {
4097     case FFELEX_typeNAME:
4098     case FFELEX_typeNAMES:
4099       ffesta_confirmed ();
4100       ffesta_tokens[2] = ffelex_token_use (t);
4101       return (ffelexHandler) ffestb_where3_;
4102
4103     case FFELEX_typeEOS:
4104     case FFELEX_typeSEMICOLON:
4105       ffesta_confirmed ();
4106       if (!ffesta_is_inhibited ())
4107         ffestc_R742 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
4108       ffelex_token_kill (ffesta_tokens[1]);
4109       return (ffelexHandler) ffesta_zero (t);
4110
4111     default:
4112       break;
4113     }
4114
4115   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
4116   ffelex_token_kill (ffesta_tokens[1]);
4117   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4118 }
4119
4120 #endif
4121 /* ffestb_where3_ -- "WHERE" OPEN_PAREN expr CLOSE_PAREN NAME
4122
4123    return ffestb_where3_;  // to lexer
4124
4125    Implement R742.  */
4126
4127 #if FFESTR_F90
4128 static ffelexHandler
4129 ffestb_where3_ (ffelexToken t)
4130 {
4131   ffelexHandler next;
4132   ffelexToken my_2 = ffesta_tokens[2];
4133
4134   if (!ffesta_is_inhibited ())
4135     ffestc_R740 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
4136   ffelex_token_kill (ffesta_tokens[1]);
4137   next = (ffelexHandler) ffesta_two (my_2, t);
4138   ffelex_token_kill (my_2);
4139   return (ffelexHandler) next;
4140 }
4141
4142 #endif
4143 /* ffestb_let -- Parse an assignment statement
4144
4145    return ffestb_let;  // to lexer
4146
4147    Make sure the statement has a valid form for an assignment statement.  If
4148    it does, implement the statement.  */
4149
4150 ffelexHandler
4151 ffestb_let (ffelexToken t)
4152 {
4153   ffelexHandler next;
4154   bool vxtparam;                /* TRUE if it might really be a VXT PARAMETER
4155                                    stmt. */
4156   char *p;
4157
4158   switch (ffelex_token_type (ffesta_tokens[0]))
4159     {
4160     case FFELEX_typeNAME:
4161       vxtparam = FALSE;
4162       break;
4163
4164     case FFELEX_typeNAMES:
4165       vxtparam = TRUE;
4166       break;
4167
4168     default:
4169       goto bad_0;               /* :::::::::::::::::::: */
4170     }
4171
4172   switch (ffelex_token_type (t))
4173     {
4174     case FFELEX_typeOPEN_PAREN:
4175     case FFELEX_typePERCENT:
4176     case FFELEX_typePOINTS:
4177       ffestb_local_.let.vxtparam = FALSE;
4178       break;
4179
4180     case FFELEX_typeEQUALS:
4181       if (!vxtparam || (ffesta_first_kw != FFESTR_firstPARAMETER))
4182         {
4183           ffestb_local_.let.vxtparam = FALSE;
4184           break;
4185         }
4186       p = ffelex_token_text (ffesta_tokens[0]) + FFESTR_firstlPARAMETER;
4187       ffestb_local_.let.vxtparam = ffesrc_is_name_init (*p);
4188       break;
4189
4190     default:
4191       goto bad_1;               /* :::::::::::::::::::: */
4192     }
4193
4194   next = (ffelexHandler) (*((ffelexHandler)
4195                             ffeexpr_lhs (ffesta_output_pool,
4196                                          FFEEXPR_contextLET,
4197                                          (ffeexprCallback) ffestb_let1_)))
4198     (ffesta_tokens[0]);
4199   return (ffelexHandler) (*next) (t);
4200
4201 bad_0:                          /* :::::::::::::::::::: */
4202   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", ffesta_tokens[0]);
4203   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4204
4205 bad_1:                          /* :::::::::::::::::::: */
4206   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", t);
4207   return (ffelexHandler) ffelex_swallow_tokens (t,
4208                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
4209 }
4210
4211 /* ffestb_let1_ -- expr
4212
4213    (ffestb_let1_)  // to expression handler
4214
4215    Make sure the next token is EQUALS or POINTS.  */
4216
4217 static ffelexHandler
4218 ffestb_let1_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
4219 {
4220   ffestb_local_.let.dest = expr;
4221
4222   switch (ffelex_token_type (t))
4223     {
4224 #if FFESTR_F90
4225     case FFELEX_typePOINTS:
4226 #endif
4227     case FFELEX_typeEQUALS:
4228       if (expr == NULL)
4229         break;
4230       ffesta_tokens[1] = ffelex_token_use (t);
4231       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
4232                         FFEEXPR_contextLET, (ffeexprCallback) ffestb_let2_);
4233
4234     default:
4235       break;
4236     }
4237
4238   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", t);
4239   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4240 }
4241
4242 /* ffestb_let2_ -- expr EQUALS/POINTS expr
4243
4244    (ffestb_end2_)  // to expression handler
4245
4246    Make sure the next token is EOS or SEMICOLON; implement the statement.  */
4247
4248 static ffelexHandler
4249 ffestb_let2_ (ffelexToken ft, ffebld expr, ffelexToken t)
4250 {
4251   switch (ffelex_token_type (t))
4252     {
4253     case FFELEX_typeEOS:
4254     case FFELEX_typeSEMICOLON:
4255       if (expr == NULL)
4256         break;
4257       if (ffestb_local_.let.vxtparam && !ffestc_is_let_not_V027 ())
4258         break;
4259       ffesta_confirmed ();
4260       if (!ffesta_is_inhibited ())
4261 #if FFESTR_F90
4262         if (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeEQUALS)
4263 #endif
4264           ffestc_let (ffestb_local_.let.dest, expr, ft);
4265 #if FFESTR_F90
4266         else
4267           ffestc_R738 (ffestb_local_.let.dest, expr, ft);
4268 #endif
4269       ffelex_token_kill (ffesta_tokens[1]);
4270       return (ffelexHandler) ffesta_zero (t);
4271
4272     default:
4273       break;
4274     }
4275
4276   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
4277                      (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeEQUALS)
4278                      ? "assignment" : "pointer-assignment",
4279                      t);
4280   ffelex_token_kill (ffesta_tokens[1]);
4281   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4282 }
4283
4284 /* ffestb_type -- Parse the TYPE statement
4285
4286    return ffestb_type;  // to lexer
4287
4288    Make sure the statement has a valid form for the TYPE statement.  If
4289    it does, implement the statement.  */
4290
4291 #if FFESTR_F90
4292 ffelexHandler
4293 ffestb_type (ffelexToken t)
4294 {
4295   ffeTokenLength i;
4296   char *p;
4297
4298   switch (ffelex_token_type (ffesta_tokens[0]))
4299     {
4300     case FFELEX_typeNAME:
4301       if (ffesta_first_kw != FFESTR_firstTYPE)
4302         goto bad_0;             /* :::::::::::::::::::: */
4303       switch (ffelex_token_type (t))
4304         {
4305         case FFELEX_typeEOS:
4306         case FFELEX_typeSEMICOLON:
4307         case FFELEX_typeCOLONCOLON:
4308           ffesta_confirmed ();  /* Error, but clearly intended. */
4309           goto bad_1;           /* :::::::::::::::::::: */
4310
4311         default:
4312           goto bad_1;           /* :::::::::::::::::::: */
4313
4314         case FFELEX_typeCOMMA:
4315           ffesta_confirmed ();
4316           return (ffelexHandler) ffestb_type1_;
4317
4318         case FFELEX_typeNAME:   /* No confirm here, because ambig w/V020 VXT
4319                                    TYPE. */
4320           ffesta_tokens[1] = NULL;
4321           ffesta_tokens[2] = ffelex_token_use (t);
4322           return (ffelexHandler) ffestb_type4_;
4323         }
4324
4325     case FFELEX_typeNAMES:
4326       if (ffesta_first_kw != FFESTR_firstTYPE)
4327         goto bad_0;             /* :::::::::::::::::::: */
4328       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlTYPE);
4329       switch (ffelex_token_type (t))
4330         {
4331         default:
4332           goto bad_1;           /* :::::::::::::::::::: */
4333
4334         case FFELEX_typeCOMMA:
4335           if (*p != '\0')
4336             goto bad_i;         /* :::::::::::::::::::: */
4337           ffesta_confirmed ();
4338           ffelex_set_names (TRUE);
4339           return (ffelexHandler) ffestb_type1_;
4340
4341         case FFELEX_typeEOS:
4342         case FFELEX_typeSEMICOLON:
4343           break;
4344         }
4345       if (!ffesrc_is_name_init (*p))
4346         goto bad_i;             /* :::::::::::::::::::: */
4347       ffesta_tokens[1] = NULL;
4348       ffesta_tokens[2]
4349         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
4350       return (ffelexHandler) ffestb_type4_ (t);
4351
4352     default:
4353       goto bad_0;               /* :::::::::::::::::::: */
4354     }
4355
4356 bad_0:                          /* :::::::::::::::::::: */
4357   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", ffesta_tokens[0]);
4358   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4359
4360 bad_1:                          /* :::::::::::::::::::: */
4361   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4362   return (ffelexHandler) ffelex_swallow_tokens (t,
4363                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
4364
4365 bad_i:                          /* :::::::::::::::::::: */
4366   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "TYPE", ffesta_tokens[0], i, t);
4367   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4368 }
4369
4370 /* ffestb_type1_ -- "TYPE" COMMA
4371
4372    return ffestb_type1_;  // to lexer
4373
4374    Make sure the next token is a NAME.  */
4375
4376 static ffelexHandler
4377 ffestb_type1_ (ffelexToken t)
4378 {
4379   ffeTokenLength i;
4380   char *p;
4381
4382   ffelex_set_names (FALSE);
4383
4384   switch (ffelex_token_type (t))
4385     {
4386     case FFELEX_typeNAME:
4387       ffesta_tokens[1] = ffelex_token_use (t);
4388       ffestb_local_.type.kw = ffestr_other (t);
4389       switch (ffestb_local_.varlist.kw)
4390         {
4391         case FFESTR_otherPUBLIC:
4392         case FFESTR_otherPRIVATE:
4393           return (ffelexHandler) ffestb_type2_;
4394
4395         default:
4396           ffelex_token_kill (ffesta_tokens[1]);
4397           break;
4398         }
4399       break;
4400
4401     case FFELEX_typeNAMES:
4402       ffesta_tokens[1] = ffelex_token_use (t);
4403       ffestb_local_.type.kw = ffestr_other (t);
4404       switch (ffestb_local_.varlist.kw)
4405         {
4406         case FFESTR_otherPUBLIC:
4407           p = ffelex_token_text (t) + (i = FFESTR_otherlPUBLIC);
4408           if (*p == '\0')
4409             return (ffelexHandler) ffestb_type2_;
4410           if (!ffesrc_is_name_init (*p))
4411             goto bad_i1;        /* :::::::::::::::::::: */
4412           ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
4413           return (ffelexHandler) ffestb_type4_;
4414
4415         case FFESTR_otherPRIVATE:
4416           p = ffelex_token_text (t) + (i = FFESTR_otherlPRIVATE);
4417           if (*p == '\0')
4418             return (ffelexHandler) ffestb_type2_;
4419           if (!ffesrc_is_name_init (*p))
4420             goto bad_i1;        /* :::::::::::::::::::: */
4421           ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
4422           return (ffelexHandler) ffestb_type4_;
4423
4424         default:
4425           ffelex_token_kill (ffesta_tokens[1]);
4426           break;
4427         }
4428       break;
4429
4430     default:
4431       break;
4432     }
4433
4434   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4435   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4436
4437 bad_i1:                 /* :::::::::::::::::::: */
4438   ffelex_token_kill (ffesta_tokens[1]);
4439   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "TYPE", t, i, NULL);
4440   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4441 }
4442
4443 /* ffestb_type2_ -- "TYPE" COMMA NAME
4444
4445    return ffestb_type2_;  // to lexer
4446
4447    Handle COLONCOLON or NAME.  */
4448
4449 static ffelexHandler
4450 ffestb_type2_ (ffelexToken t)
4451 {
4452   switch (ffelex_token_type (t))
4453     {
4454     case FFELEX_typeCOLONCOLON:
4455       return (ffelexHandler) ffestb_type3_;
4456
4457     case FFELEX_typeNAME:
4458       return (ffelexHandler) ffestb_type3_ (t);
4459
4460     default:
4461       break;
4462     }
4463
4464   if (ffesta_tokens[1] != NULL)
4465     ffelex_token_kill (ffesta_tokens[1]);
4466   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4467   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4468 }
4469
4470 /* ffestb_type3_ -- "TYPE" [COMMA NAME [COLONCOLON]]
4471
4472    return ffestb_type3_;  // to lexer
4473
4474    Make sure the next token is a NAME.  */
4475
4476 static ffelexHandler
4477 ffestb_type3_ (ffelexToken t)
4478 {
4479   switch (ffelex_token_type (t))
4480     {
4481     case FFELEX_typeNAME:
4482       ffesta_tokens[2] = ffelex_token_use (t);
4483       return (ffelexHandler) ffestb_type4_;
4484
4485     default:
4486       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4487       break;
4488     }
4489
4490   if (ffesta_tokens[1] != NULL)
4491     ffelex_token_kill (ffesta_tokens[1]);
4492   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4493 }
4494
4495 /* ffestb_type4_ -- "TYPE" [COMMA NAME [COLONCOLON]] NAME
4496
4497    return ffestb_type4_;  // to lexer
4498
4499    Make sure the next token is an EOS or SEMICOLON.  */
4500
4501 static ffelexHandler
4502 ffestb_type4_ (ffelexToken t)
4503 {
4504   switch (ffelex_token_type (t))
4505     {
4506     case FFELEX_typeEOS:
4507     case FFELEX_typeSEMICOLON:
4508       ffesta_confirmed ();
4509       if (!ffesta_is_inhibited ())
4510         ffestc_R424 (ffesta_tokens[1], ffestb_local_.type.kw,
4511                      ffesta_tokens[2]);
4512       if (ffesta_tokens[1] != NULL)
4513         ffelex_token_kill (ffesta_tokens[1]);
4514       ffelex_token_kill (ffesta_tokens[2]);
4515       return (ffelexHandler) ffesta_zero (t);
4516
4517     default:
4518       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4519       break;
4520     }
4521
4522   if (ffesta_tokens[1] != NULL)
4523     ffelex_token_kill (ffesta_tokens[1]);
4524   ffelex_token_kill (ffesta_tokens[2]);
4525   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4526 }
4527
4528 #endif
4529 /* ffestb_varlist -- Parse EXTERNAL/INTENT/INTRINSIC/OPTIONAL/PUBLIC/PRIVATE
4530                      statement
4531
4532    return ffestb_varlist;  // to lexer
4533
4534    Make sure the statement has a valid form.  If it
4535    does, implement the statement.  */
4536
4537 ffelexHandler
4538 ffestb_varlist (ffelexToken t)
4539 {
4540   ffeTokenLength i;
4541   char *p;
4542   ffelexToken nt;
4543   ffelexHandler next;
4544
4545   switch (ffelex_token_type (ffesta_tokens[0]))
4546     {
4547     case FFELEX_typeNAME:
4548       switch (ffelex_token_type (t))
4549         {
4550         case FFELEX_typeEOS:
4551         case FFELEX_typeSEMICOLON:
4552           ffesta_confirmed ();
4553           switch (ffesta_first_kw)
4554             {
4555 #if FFESTR_F90
4556             case FFESTR_firstPUBLIC:
4557               if (!ffesta_is_inhibited ())
4558                 ffestc_R521A ();
4559               return (ffelexHandler) ffesta_zero (t);
4560
4561             case FFESTR_firstPRIVATE:
4562               if (!ffesta_is_inhibited ())
4563                 ffestc_private ();      /* Either R523A or R521B. */
4564               return (ffelexHandler) ffesta_zero (t);
4565 #endif
4566
4567             default:
4568               goto bad_1;       /* :::::::::::::::::::: */
4569             }
4570
4571         case FFELEX_typeCOMMA:
4572           ffesta_confirmed ();  /* Error, but clearly intended. */
4573           goto bad_1;           /* :::::::::::::::::::: */
4574
4575         case FFELEX_typeCOLONCOLON:
4576           ffesta_confirmed ();
4577           switch (ffesta_first_kw)
4578             {
4579 #if FFESTR_F90
4580             case FFESTR_firstOPTIONAL:
4581               if (!ffesta_is_inhibited ())
4582                 ffestc_R520_start ();
4583               break;
4584
4585             case FFESTR_firstPUBLIC:
4586               if (!ffesta_is_inhibited ())
4587                 ffestc_R521Astart ();
4588               break;
4589
4590             case FFESTR_firstPRIVATE:
4591               if (!ffesta_is_inhibited ())
4592                 ffestc_R521Bstart ();
4593               break;
4594 #endif
4595
4596             default:
4597               ffesta_confirmed ();      /* Error, but clearly intended. */
4598               goto bad_1;       /* :::::::::::::::::::: */
4599             }
4600           return (ffelexHandler) ffestb_varlist5_;
4601
4602         default:
4603           goto bad_1;           /* :::::::::::::::::::: */
4604
4605         case FFELEX_typeOPEN_PAREN:
4606           switch (ffesta_first_kw)
4607             {
4608 #if FFESTR_F90
4609             case FFESTR_firstINTENT:
4610               return (ffelexHandler) ffestb_varlist1_;
4611 #endif
4612
4613             default:
4614               goto bad_1;       /* :::::::::::::::::::: */
4615             }
4616
4617         case FFELEX_typeNAME:
4618           ffesta_confirmed ();
4619           switch (ffesta_first_kw)
4620             {
4621             case FFESTR_firstEXTERNAL:
4622               if (!ffesta_is_inhibited ())
4623                 ffestc_R1207_start ();
4624               break;
4625
4626 #if FFESTR_F90
4627             case FFESTR_firstINTENT:
4628               goto bad_1;       /* :::::::::::::::::::: */
4629 #endif
4630
4631             case FFESTR_firstINTRINSIC:
4632               if (!ffesta_is_inhibited ())
4633                 ffestc_R1208_start ();
4634               break;
4635
4636 #if FFESTR_F90
4637             case FFESTR_firstOPTIONAL:
4638               if (!ffesta_is_inhibited ())
4639                 ffestc_R520_start ();
4640               break;
4641 #endif
4642
4643 #if FFESTR_F90
4644             case FFESTR_firstPUBLIC:
4645               if (!ffesta_is_inhibited ())
4646                 ffestc_R521Astart ();
4647               break;
4648
4649             case FFESTR_firstPRIVATE:
4650               if (!ffesta_is_inhibited ())
4651                 ffestc_R521Bstart ();
4652               break;
4653 #endif
4654
4655             default:
4656               break;
4657             }
4658           return (ffelexHandler) ffestb_varlist5_ (t);
4659         }
4660
4661     case FFELEX_typeNAMES:
4662       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.varlist.len);
4663       switch (ffelex_token_type (t))
4664         {
4665         case FFELEX_typeEOS:
4666         case FFELEX_typeSEMICOLON:
4667           ffesta_confirmed ();
4668           switch (ffesta_first_kw)
4669             {
4670 #if FFESTR_F90
4671             case FFESTR_firstINTENT:
4672               goto bad_1;       /* :::::::::::::::::::: */
4673 #endif
4674
4675             default:
4676               break;
4677             }
4678           if (*p != '\0')
4679             break;
4680           switch (ffesta_first_kw)
4681             {
4682 #if FFESTR_F90
4683             case FFESTR_firstPUBLIC:
4684               if (!ffesta_is_inhibited ())
4685                 ffestc_R521A ();
4686               return (ffelexHandler) ffesta_zero (t);
4687
4688             case FFESTR_firstPRIVATE:
4689               if (!ffesta_is_inhibited ())
4690                 ffestc_private ();      /* Either R423A or R521B. */
4691               return (ffelexHandler) ffesta_zero (t);
4692 #endif
4693
4694             default:
4695               goto bad_1;       /* :::::::::::::::::::: */
4696             }
4697
4698         case FFELEX_typeCOMMA:
4699           ffesta_confirmed ();  /* Error, but clearly intended. */
4700           switch (ffesta_first_kw)
4701             {
4702 #if FFESTR_F90
4703             case FFESTR_firstINTENT:
4704               goto bad_1;       /* :::::::::::::::::::: */
4705 #endif
4706
4707             default:
4708               break;
4709             }
4710           if (*p != '\0')
4711             break;
4712           goto bad_1;           /* :::::::::::::::::::: */
4713
4714         case FFELEX_typeCOLONCOLON:
4715           ffesta_confirmed ();
4716           switch (ffesta_first_kw)
4717             {
4718 #if FFESTR_F90
4719             case FFESTR_firstOPTIONAL:
4720               if (!ffesta_is_inhibited ())
4721                 ffestc_R520_start ();
4722               break;
4723 #endif
4724
4725 #if FFESTR_F90
4726             case FFESTR_firstPUBLIC:
4727               if (!ffesta_is_inhibited ())
4728                 ffestc_R521Astart ();
4729               break;
4730
4731             case FFESTR_firstPRIVATE:
4732               if (!ffesta_is_inhibited ())
4733                 ffestc_R521Bstart ();
4734               break;
4735 #endif
4736
4737             default:
4738               goto bad_1;       /* :::::::::::::::::::: */
4739             }
4740           return (ffelexHandler) ffestb_varlist5_;
4741
4742         case FFELEX_typeOPEN_PAREN:
4743           switch (ffesta_first_kw)
4744             {
4745 #if FFESTR_F90
4746             case FFESTR_firstINTENT:
4747               if (*p != '\0')
4748                 goto bad_1;     /* :::::::::::::::::::: */
4749               return (ffelexHandler) ffestb_varlist1_;
4750 #endif
4751
4752             default:
4753               goto bad_1;       /* :::::::::::::::::::: */
4754             }
4755
4756         case FFELEX_typeNAME:
4757           ffesta_confirmed ();
4758           switch (ffesta_first_kw)
4759             {
4760             case FFESTR_firstEXTERNAL:
4761               if (!ffesta_is_inhibited ())
4762                 ffestc_R1207_start ();
4763               break;
4764
4765 #if FFESTR_F90
4766             case FFESTR_firstINTENT:
4767               goto bad_1;       /* :::::::::::::::::::: */
4768 #endif
4769
4770             case FFESTR_firstINTRINSIC:
4771               if (!ffesta_is_inhibited ())
4772                 ffestc_R1208_start ();
4773               break;
4774
4775 #if FFESTR_F90
4776             case FFESTR_firstOPTIONAL:
4777               if (!ffesta_is_inhibited ())
4778                 ffestc_R520_start ();
4779               break;
4780 #endif
4781
4782 #if FFESTR_F90
4783             case FFESTR_firstPUBLIC:
4784               if (!ffesta_is_inhibited ())
4785                 ffestc_R521Astart ();
4786               break;
4787
4788             case FFESTR_firstPRIVATE:
4789               if (!ffesta_is_inhibited ())
4790                 ffestc_R521Bstart ();
4791               break;
4792 #endif
4793
4794             default:
4795               break;
4796             }
4797           return (ffelexHandler) ffestb_varlist5_ (t);
4798
4799         default:
4800           goto bad_1;           /* :::::::::::::::::::: */
4801         }
4802
4803       /* Here, we have at least one char after the first keyword and t is
4804          COMMA or EOS/SEMICOLON.  Also we know that this form is valid for
4805          only the statements reaching here (specifically, INTENT won't reach
4806          here). */
4807
4808       if (!ffesrc_is_name_init (*p))
4809         goto bad_i;             /* :::::::::::::::::::: */
4810       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
4811       if (!ffesta_is_inhibited ())
4812         {
4813           switch (ffesta_first_kw)
4814             {
4815             case FFESTR_firstEXTERNAL:
4816               ffestc_R1207_start ();
4817               break;
4818
4819             case FFESTR_firstINTRINSIC:
4820               ffestc_R1208_start ();
4821               break;
4822
4823 #if FFESTR_F90
4824             case FFESTR_firstOPTIONAL:
4825               ffestc_R520_start ();
4826               break;
4827 #endif
4828
4829 #if FFESTR_F90
4830             case FFESTR_firstPUBLIC:
4831               ffestc_R521Astart ();
4832               break;
4833
4834             case FFESTR_firstPRIVATE:
4835               ffestc_R521Bstart ();
4836               break;
4837 #endif
4838
4839             default:
4840               assert (FALSE);
4841             }
4842         }
4843       next = (ffelexHandler) ffestb_varlist5_ (nt);
4844       ffelex_token_kill (nt);
4845       return (ffelexHandler) (*next) (t);
4846
4847     default:
4848       goto bad_0;               /* :::::::::::::::::::: */
4849     }
4850
4851 bad_0:                          /* :::::::::::::::::::: */
4852   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, ffesta_tokens[0]);
4853   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4854
4855 bad_1:                          /* :::::::::::::::::::: */
4856   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4857   return (ffelexHandler) ffelex_swallow_tokens (t,
4858                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
4859
4860 bad_i:                          /* :::::::::::::::::::: */
4861   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, ffesta_tokens[0], i, t);
4862   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4863 }
4864
4865 /* ffestb_varlist1_ -- "INTENT" OPEN_PAREN
4866
4867    return ffestb_varlist1_;  // to lexer
4868
4869    Handle NAME.  */
4870
4871 #if FFESTR_F90
4872 static ffelexHandler
4873 ffestb_varlist1_ (ffelexToken t)
4874 {
4875   switch (ffelex_token_type (t))
4876     {
4877     case FFELEX_typeNAME:
4878       ffesta_tokens[1] = ffelex_token_use (t);
4879       ffestb_local_.varlist.kw = ffestr_other (t);
4880       switch (ffestb_local_.varlist.kw)
4881         {
4882         case FFESTR_otherIN:
4883           return (ffelexHandler) ffestb_varlist2_;
4884
4885         case FFESTR_otherINOUT:
4886           return (ffelexHandler) ffestb_varlist3_;
4887
4888         case FFESTR_otherOUT:
4889           return (ffelexHandler) ffestb_varlist3_;
4890
4891         default:
4892           ffelex_token_kill (ffesta_tokens[1]);
4893           break;
4894         }
4895       break;
4896
4897     default:
4898       break;
4899     }
4900
4901   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4902   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4903 }
4904
4905 /* ffestb_varlist2_ -- "INTENT" OPEN_PAREN "IN"
4906
4907    return ffestb_varlist2_;  // to lexer
4908
4909    Handle NAME.  */
4910
4911 static ffelexHandler
4912 ffestb_varlist2_ (ffelexToken t)
4913 {
4914   switch (ffelex_token_type (t))
4915     {
4916     case FFELEX_typeNAME:
4917       switch (ffestr_other (t))
4918         {
4919         case FFESTR_otherOUT:
4920           ffestb_local_.varlist.kw = FFESTR_otherINOUT;
4921           return (ffelexHandler) ffestb_varlist3_;
4922
4923         default:
4924           break;
4925         }
4926       break;
4927
4928     case FFELEX_typeCLOSE_PAREN:
4929       return (ffelexHandler) ffestb_varlist4_;
4930
4931     default:
4932       break;
4933     }
4934
4935   ffelex_token_kill (ffesta_tokens[1]);
4936   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4937   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4938 }
4939
4940 /* ffestb_varlist3_ -- "INTENT" OPEN_PAREN NAME ["OUT"]
4941
4942    return ffestb_varlist3_;  // to lexer
4943
4944    Handle CLOSE_PAREN.  */
4945
4946 static ffelexHandler
4947 ffestb_varlist3_ (ffelexToken t)
4948 {
4949   switch (ffelex_token_type (t))
4950     {
4951     case FFELEX_typeCLOSE_PAREN:
4952       return (ffelexHandler) ffestb_varlist4_;
4953
4954     default:
4955       break;
4956     }
4957
4958   ffelex_token_kill (ffesta_tokens[1]);
4959   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4960   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4961 }
4962
4963 /* ffestb_varlist4_ -- "INTENT" OPEN_PAREN NAME ["OUT"] CLOSE_PAREN
4964
4965    return ffestb_varlist4_;  // to lexer
4966
4967    Handle COLONCOLON or NAME.  */
4968
4969 static ffelexHandler
4970 ffestb_varlist4_ (ffelexToken t)
4971 {
4972   switch (ffelex_token_type (t))
4973     {
4974     case FFELEX_typeCOLONCOLON:
4975       ffesta_confirmed ();
4976       if (!ffesta_is_inhibited ())
4977         ffestc_R519_start (ffesta_tokens[1], ffestb_local_.varlist.kw);
4978       ffelex_token_kill (ffesta_tokens[1]);
4979       return (ffelexHandler) ffestb_varlist5_;
4980
4981     case FFELEX_typeNAME:
4982       ffesta_confirmed ();
4983       if (!ffesta_is_inhibited ())
4984         ffestc_R519_start (ffesta_tokens[1], ffestb_local_.varlist.kw);
4985       ffelex_token_kill (ffesta_tokens[1]);
4986       return (ffelexHandler) ffestb_varlist5_ (t);
4987
4988     default:
4989       break;
4990     }
4991
4992   ffelex_token_kill (ffesta_tokens[1]);
4993   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4994   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4995 }
4996
4997 #endif
4998 /* ffestb_varlist5_ -- Handles the list of variable names
4999
5000    return ffestb_varlist5_;  // to lexer
5001
5002    Handle NAME.  */
5003
5004 static ffelexHandler
5005 ffestb_varlist5_ (ffelexToken t)
5006 {
5007   switch (ffelex_token_type (t))
5008     {
5009     case FFELEX_typeNAME:
5010       ffesta_tokens[1] = ffelex_token_use (t);
5011       return (ffelexHandler) ffestb_varlist6_;
5012
5013     default:
5014       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
5015       break;
5016     }
5017
5018   if (!ffesta_is_inhibited ())
5019     {
5020       switch (ffesta_first_kw)
5021         {
5022         case FFESTR_firstEXTERNAL:
5023           ffestc_R1207_finish ();
5024           break;
5025
5026 #if FFESTR_F90
5027         case FFESTR_firstINTENT:
5028           ffestc_R519_finish ();
5029           break;
5030 #endif
5031
5032         case FFESTR_firstINTRINSIC:
5033           ffestc_R1208_finish ();
5034           break;
5035
5036 #if FFESTR_F90
5037         case FFESTR_firstOPTIONAL:
5038           ffestc_R520_finish ();
5039           break;
5040 #endif
5041
5042 #if FFESTR_F90
5043         case FFESTR_firstPUBLIC:
5044           ffestc_R521Afinish ();
5045           break;
5046
5047         case FFESTR_firstPRIVATE:
5048           ffestc_R521Bfinish ();
5049           break;
5050 #endif
5051
5052         default:
5053           assert (FALSE);
5054         }
5055     }
5056   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5057 }
5058
5059 /* ffestb_varlist6_ -- (whatever) NAME
5060
5061    return ffestb_varlist6_;  // to lexer
5062
5063    Handle COMMA or EOS/SEMICOLON.  */
5064
5065 static ffelexHandler
5066 ffestb_varlist6_ (ffelexToken t)
5067 {
5068   switch (ffelex_token_type (t))
5069     {
5070     case FFELEX_typeCOMMA:
5071       if (!ffesta_is_inhibited ())
5072         {
5073           switch (ffesta_first_kw)
5074             {
5075             case FFESTR_firstEXTERNAL:
5076               ffestc_R1207_item (ffesta_tokens[1]);
5077               break;
5078
5079 #if FFESTR_F90
5080             case FFESTR_firstINTENT:
5081               ffestc_R519_item (ffesta_tokens[1]);
5082               break;
5083 #endif
5084
5085             case FFESTR_firstINTRINSIC:
5086               ffestc_R1208_item (ffesta_tokens[1]);
5087               break;
5088
5089 #if FFESTR_F90
5090             case FFESTR_firstOPTIONAL:
5091               ffestc_R520_item (ffesta_tokens[1]);
5092               break;
5093 #endif
5094
5095 #if FFESTR_F90
5096             case FFESTR_firstPUBLIC:
5097               ffestc_R521Aitem (ffesta_tokens[1]);
5098               break;
5099
5100             case FFESTR_firstPRIVATE:
5101               ffestc_R521Bitem (ffesta_tokens[1]);
5102               break;
5103 #endif
5104
5105             default:
5106               assert (FALSE);
5107             }
5108         }
5109       ffelex_token_kill (ffesta_tokens[1]);
5110       return (ffelexHandler) ffestb_varlist5_;
5111
5112     case FFELEX_typeEOS:
5113     case FFELEX_typeSEMICOLON:
5114       if (!ffesta_is_inhibited ())
5115         {
5116           switch (ffesta_first_kw)
5117             {
5118             case FFESTR_firstEXTERNAL:
5119               ffestc_R1207_item (ffesta_tokens[1]);
5120               ffestc_R1207_finish ();
5121               break;
5122
5123 #if FFESTR_F90
5124             case FFESTR_firstINTENT:
5125               ffestc_R519_item (ffesta_tokens[1]);
5126               ffestc_R519_finish ();
5127               break;
5128 #endif
5129
5130             case FFESTR_firstINTRINSIC:
5131               ffestc_R1208_item (ffesta_tokens[1]);
5132               ffestc_R1208_finish ();
5133               break;
5134
5135 #if FFESTR_F90
5136             case FFESTR_firstOPTIONAL:
5137               ffestc_R520_item (ffesta_tokens[1]);
5138               ffestc_R520_finish ();
5139               break;
5140 #endif
5141
5142 #if FFESTR_F90
5143             case FFESTR_firstPUBLIC:
5144               ffestc_R521Aitem (ffesta_tokens[1]);
5145               ffestc_R521Afinish ();
5146               break;
5147
5148             case FFESTR_firstPRIVATE:
5149               ffestc_R521Bitem (ffesta_tokens[1]);
5150               ffestc_R521Bfinish ();
5151               break;
5152 #endif
5153
5154             default:
5155               assert (FALSE);
5156             }
5157         }
5158       ffelex_token_kill (ffesta_tokens[1]);
5159       return (ffelexHandler) ffesta_zero (t);
5160
5161     default:
5162       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
5163       break;
5164     }
5165
5166   if (!ffesta_is_inhibited ())
5167     {
5168       switch (ffesta_first_kw)
5169         {
5170         case FFESTR_firstEXTERNAL:
5171           ffestc_R1207_finish ();
5172           break;
5173
5174 #if FFESTR_F90
5175         case FFESTR_firstINTENT:
5176           ffestc_R519_finish ();
5177           break;
5178 #endif
5179
5180         case FFESTR_firstINTRINSIC:
5181           ffestc_R1208_finish ();
5182           break;
5183
5184 #if FFESTR_F90
5185         case FFESTR_firstOPTIONAL:
5186           ffestc_R520_finish ();
5187           break;
5188 #endif
5189
5190 #if FFESTR_F90
5191         case FFESTR_firstPUBLIC:
5192           ffestc_R521Afinish ();
5193           break;
5194
5195         case FFESTR_firstPRIVATE:
5196           ffestc_R521Bfinish ();
5197           break;
5198 #endif
5199
5200         default:
5201           assert (FALSE);
5202         }
5203     }
5204   ffelex_token_kill (ffesta_tokens[1]);
5205   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5206 }
5207
5208 /* ffestb_R423B -- Parse the SEQUENCE statement
5209
5210    return ffestb_R423B;  // to lexer
5211
5212    Make sure the statement has a valid form for the SEQUENCE statement.  If
5213    it does, implement the statement.  */
5214
5215 #if FFESTR_F90
5216 ffelexHandler
5217 ffestb_R423B (ffelexToken t)
5218 {
5219   char *p;
5220   ffeTokenLength i;
5221
5222   switch (ffelex_token_type (ffesta_tokens[0]))
5223     {
5224     case FFELEX_typeNAME:
5225       if (ffesta_first_kw != FFESTR_firstSEQUENCE)
5226         goto bad_0;             /* :::::::::::::::::::: */
5227       break;
5228
5229     case FFELEX_typeNAMES:
5230       if (ffesta_first_kw != FFESTR_firstSEQUENCE)
5231         goto bad_0;             /* :::::::::::::::::::: */
5232       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlSEQUENCE)
5233         {
5234           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSEQUENCE);
5235           goto bad_i;           /* :::::::::::::::::::: */
5236         }
5237       break;
5238
5239     default:
5240       goto bad_0;               /* :::::::::::::::::::: */
5241     }
5242
5243   switch (ffelex_token_type (t))
5244     {
5245     case FFELEX_typeEOS:
5246     case FFELEX_typeSEMICOLON:
5247       ffesta_confirmed ();
5248       if (!ffesta_is_inhibited ())
5249         ffestc_R423B ();
5250       return (ffelexHandler) ffesta_zero (t);
5251
5252     case FFELEX_typeCOMMA:
5253     case FFELEX_typeCOLONCOLON:
5254       ffesta_confirmed ();      /* Error, but clearly intended. */
5255       goto bad_1;               /* :::::::::::::::::::: */
5256
5257     default:
5258       goto bad_1;               /* :::::::::::::::::::: */
5259     }
5260
5261 bad_0:                          /* :::::::::::::::::::: */
5262   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", ffesta_tokens[0]);
5263   return (ffelexHandler) ffelex_swallow_tokens (t,
5264                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
5265
5266 bad_1:                          /* :::::::::::::::::::: */
5267   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", t);
5268   return (ffelexHandler) ffelex_swallow_tokens (t,
5269                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
5270
5271 bad_i:                          /* :::::::::::::::::::: */
5272   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", ffesta_tokens[0], i, t);
5273   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5274 }
5275
5276 #endif
5277 /* ffestb_R522 -- Parse the SAVE statement
5278
5279    return ffestb_R522;  // to lexer
5280
5281    Make sure the statement has a valid form for the SAVE statement.  If it
5282    does, implement the statement.  */
5283
5284 ffelexHandler
5285 ffestb_R522 (ffelexToken t)
5286 {
5287   ffeTokenLength i;
5288   char *p;
5289   ffelexToken nt;
5290   ffelexHandler next;
5291
5292   switch (ffelex_token_type (ffesta_tokens[0]))
5293     {
5294     case FFELEX_typeNAME:
5295       if (ffesta_first_kw != FFESTR_firstSAVE)
5296         goto bad_0;             /* :::::::::::::::::::: */
5297       switch (ffelex_token_type (t))
5298         {
5299         case FFELEX_typeCOMMA:
5300           ffesta_confirmed ();  /* Error, but clearly intended. */
5301           goto bad_1;           /* :::::::::::::::::::: */
5302
5303         default:
5304           goto bad_1;           /* :::::::::::::::::::: */
5305
5306         case FFELEX_typeEOS:
5307         case FFELEX_typeSEMICOLON:
5308           ffesta_confirmed ();
5309           if (!ffesta_is_inhibited ())
5310             ffestc_R522 ();
5311           return (ffelexHandler) ffesta_zero (t);
5312
5313         case FFELEX_typeNAME:
5314         case FFELEX_typeSLASH:
5315           ffesta_confirmed ();
5316           if (!ffesta_is_inhibited ())
5317             ffestc_R522start ();
5318           return (ffelexHandler) ffestb_R5221_ (t);
5319
5320         case FFELEX_typeCOLONCOLON:
5321           ffesta_confirmed ();
5322           if (!ffesta_is_inhibited ())
5323             ffestc_R522start ();
5324           return (ffelexHandler) ffestb_R5221_;
5325         }
5326
5327     case FFELEX_typeNAMES:
5328       if (ffesta_first_kw != FFESTR_firstSAVE)
5329         goto bad_0;             /* :::::::::::::::::::: */
5330       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSAVE);
5331       switch (ffelex_token_type (t))
5332         {
5333         default:
5334           goto bad_1;           /* :::::::::::::::::::: */
5335
5336         case FFELEX_typeCOMMA:
5337           ffesta_confirmed ();
5338           break;
5339
5340         case FFELEX_typeEOS:
5341         case FFELEX_typeSEMICOLON:
5342           ffesta_confirmed ();
5343           if (*p != '\0')
5344             break;
5345           if (!ffesta_is_inhibited ())
5346             ffestc_R522 ();
5347           return (ffelexHandler) ffesta_zero (t);
5348
5349         case FFELEX_typeSLASH:
5350           ffesta_confirmed ();
5351           if (*p != '\0')
5352             goto bad_i;         /* :::::::::::::::::::: */
5353           if (!ffesta_is_inhibited ())
5354             ffestc_R522start ();
5355           return (ffelexHandler) ffestb_R5221_ (t);
5356
5357         case FFELEX_typeCOLONCOLON:
5358           ffesta_confirmed ();
5359           if (*p != '\0')
5360             goto bad_i;         /* :::::::::::::::::::: */
5361           if (!ffesta_is_inhibited ())
5362             ffestc_R522start ();
5363           return (ffelexHandler) ffestb_R5221_;
5364         }
5365
5366       /* Here, we have at least one char after "SAVE" and t is COMMA or
5367          EOS/SEMICOLON. */
5368
5369       if (!ffesrc_is_name_init (*p))
5370         goto bad_i;             /* :::::::::::::::::::: */
5371       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
5372       if (!ffesta_is_inhibited ())
5373         ffestc_R522start ();
5374       next = (ffelexHandler) ffestb_R5221_ (nt);
5375       ffelex_token_kill (nt);
5376       return (ffelexHandler) (*next) (t);
5377
5378     default:
5379       goto bad_0;               /* :::::::::::::::::::: */
5380     }
5381
5382 bad_0:                          /* :::::::::::::::::::: */
5383   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", ffesta_tokens[0]);
5384   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5385
5386 bad_1:                          /* :::::::::::::::::::: */
5387   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5388   return (ffelexHandler) ffelex_swallow_tokens (t,
5389                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
5390
5391 bad_i:                          /* :::::::::::::::::::: */
5392   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SAVE", ffesta_tokens[0], i, t);
5393   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5394 }
5395
5396 /* ffestb_R5221_ -- "SAVE" [COLONCOLON]
5397
5398    return ffestb_R5221_;  // to lexer
5399
5400    Handle NAME or SLASH.  */
5401
5402 static ffelexHandler
5403 ffestb_R5221_ (ffelexToken t)
5404 {
5405   switch (ffelex_token_type (t))
5406     {
5407     case FFELEX_typeNAME:
5408       ffestb_local_.R522.is_cblock = FALSE;
5409       ffesta_tokens[1] = ffelex_token_use (t);
5410       return (ffelexHandler) ffestb_R5224_;
5411
5412     case FFELEX_typeSLASH:
5413       ffestb_local_.R522.is_cblock = TRUE;
5414       return (ffelexHandler) ffestb_R5222_;
5415
5416     default:
5417       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5418       break;
5419     }
5420
5421   if (!ffesta_is_inhibited ())
5422     ffestc_R522finish ();
5423   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5424 }
5425
5426 /* ffestb_R5222_ -- "SAVE" [COLONCOLON] SLASH
5427
5428    return ffestb_R5222_;  // to lexer
5429
5430    Handle NAME.  */
5431
5432 static ffelexHandler
5433 ffestb_R5222_ (ffelexToken t)
5434 {
5435   switch (ffelex_token_type (t))
5436     {
5437     case FFELEX_typeNAME:
5438       ffesta_tokens[1] = ffelex_token_use (t);
5439       return (ffelexHandler) ffestb_R5223_;
5440
5441     default:
5442       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5443       break;
5444     }
5445
5446   if (!ffesta_is_inhibited ())
5447     ffestc_R522finish ();
5448   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5449 }
5450
5451 /* ffestb_R5223_ -- "SAVE" [COLONCOLON] SLASH NAME
5452
5453    return ffestb_R5223_;  // to lexer
5454
5455    Handle SLASH.  */
5456
5457 static ffelexHandler
5458 ffestb_R5223_ (ffelexToken t)
5459 {
5460   switch (ffelex_token_type (t))
5461     {
5462     case FFELEX_typeSLASH:
5463       return (ffelexHandler) ffestb_R5224_;
5464
5465     default:
5466       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5467       break;
5468     }
5469
5470   if (!ffesta_is_inhibited ())
5471     ffestc_R522finish ();
5472   ffelex_token_kill (ffesta_tokens[1]);
5473   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5474 }
5475
5476 /* ffestb_R5224_ -- "SAVE" [COLONCOLON] R523
5477
5478    return ffestb_R5224_;  // to lexer
5479
5480    Handle COMMA or EOS/SEMICOLON.  */
5481
5482 static ffelexHandler
5483 ffestb_R5224_ (ffelexToken t)
5484 {
5485   switch (ffelex_token_type (t))
5486     {
5487     case FFELEX_typeCOMMA:
5488       if (!ffesta_is_inhibited ())
5489         {
5490           if (ffestb_local_.R522.is_cblock)
5491             ffestc_R522item_cblock (ffesta_tokens[1]);
5492           else
5493             ffestc_R522item_object (ffesta_tokens[1]);
5494         }
5495       ffelex_token_kill (ffesta_tokens[1]);
5496       return (ffelexHandler) ffestb_R5221_;
5497
5498     case FFELEX_typeEOS:
5499     case FFELEX_typeSEMICOLON:
5500       if (!ffesta_is_inhibited ())
5501         {
5502           if (ffestb_local_.R522.is_cblock)
5503             ffestc_R522item_cblock (ffesta_tokens[1]);
5504           else
5505             ffestc_R522item_object (ffesta_tokens[1]);
5506           ffestc_R522finish ();
5507         }
5508       ffelex_token_kill (ffesta_tokens[1]);
5509       return (ffelexHandler) ffesta_zero (t);
5510
5511     default:
5512       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5513       break;
5514     }
5515
5516   if (!ffesta_is_inhibited ())
5517     ffestc_R522finish ();
5518   ffelex_token_kill (ffesta_tokens[1]);
5519   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5520 }
5521
5522 /* ffestb_R528 -- Parse the DATA statement
5523
5524    return ffestb_R528;  // to lexer
5525
5526    Make sure the statement has a valid form for the DATA statement.  If it
5527    does, implement the statement.  */
5528
5529 ffelexHandler
5530 ffestb_R528 (ffelexToken t)
5531 {
5532   char *p;
5533   ffeTokenLength i;
5534   ffelexToken nt;
5535   ffelexHandler next;
5536
5537   switch (ffelex_token_type (ffesta_tokens[0]))
5538     {
5539     case FFELEX_typeNAME:
5540       if (ffesta_first_kw != FFESTR_firstDATA)
5541         goto bad_0;             /* :::::::::::::::::::: */
5542       switch (ffelex_token_type (t))
5543         {
5544         case FFELEX_typeCOMMA:
5545         case FFELEX_typeEOS:
5546         case FFELEX_typeSEMICOLON:
5547         case FFELEX_typeSLASH:
5548         case FFELEX_typeCOLONCOLON:
5549           ffesta_confirmed ();  /* Error, but clearly intended. */
5550           goto bad_1;           /* :::::::::::::::::::: */
5551
5552         default:
5553           goto bad_1;           /* :::::::::::::::::::: */
5554
5555         case FFELEX_typeNAME:
5556           ffesta_confirmed ();
5557           break;
5558
5559         case FFELEX_typeOPEN_PAREN:
5560           break;
5561         }
5562       ffestb_local_.data.started = FALSE;
5563       return (ffelexHandler) (*((ffelexHandler)
5564                                 ffeexpr_lhs (ffesta_output_pool,
5565                                              FFEEXPR_contextDATA,
5566                                           (ffeexprCallback) ffestb_R5281_)))
5567         (t);
5568
5569     case FFELEX_typeNAMES:
5570       if (ffesta_first_kw != FFESTR_firstDATA)
5571         goto bad_0;             /* :::::::::::::::::::: */
5572       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDATA);
5573       switch (ffelex_token_type (t))
5574         {
5575         case FFELEX_typeEOS:
5576         case FFELEX_typeSEMICOLON:
5577         case FFELEX_typeCOLONCOLON:
5578           ffesta_confirmed ();  /* Error, but clearly intended. */
5579           goto bad_1;           /* :::::::::::::::::::: */
5580
5581         default:
5582           goto bad_1;           /* :::::::::::::::::::: */
5583
5584         case FFELEX_typeOPEN_PAREN:
5585           if (*p == '\0')
5586             {
5587               ffestb_local_.data.started = FALSE;
5588               return (ffelexHandler) (*((ffelexHandler)
5589                                         ffeexpr_lhs (ffesta_output_pool,
5590                                                      FFEEXPR_contextDATA,
5591                                                      (ffeexprCallback)
5592                                                      ffestb_R5281_)))
5593                 (t);
5594             }
5595           break;
5596
5597         case FFELEX_typeCOMMA:
5598         case FFELEX_typeSLASH:
5599           ffesta_confirmed ();
5600           break;
5601         }
5602       if (!ffesrc_is_name_init (*p))
5603         goto bad_i;             /* :::::::::::::::::::: */
5604       ffestb_local_.data.started = FALSE;
5605       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
5606       next = (ffelexHandler) (*((ffelexHandler)
5607                                 ffeexpr_lhs (ffesta_output_pool,
5608                                              FFEEXPR_contextDATA,
5609                                           (ffeexprCallback) ffestb_R5281_)))
5610         (nt);
5611       ffelex_token_kill (nt);
5612       return (ffelexHandler) (*next) (t);
5613
5614     default:
5615       goto bad_0;               /* :::::::::::::::::::: */
5616     }
5617
5618 bad_0:                          /* :::::::::::::::::::: */
5619   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", ffesta_tokens[0]);
5620   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5621
5622 bad_1:                          /* :::::::::::::::::::: */
5623   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5624   return (ffelexHandler) ffelex_swallow_tokens (t,
5625                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
5626
5627 bad_i:                          /* :::::::::::::::::::: */
5628   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DATA", ffesta_tokens[0], i, t);
5629   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5630 }
5631
5632 /* ffestb_R5281_ -- "DATA" expr-list
5633
5634    (ffestb_R5281_)  // to expression handler
5635
5636    Handle COMMA or SLASH.  */
5637
5638 static ffelexHandler
5639 ffestb_R5281_ (ffelexToken ft, ffebld expr, ffelexToken t)
5640 {
5641   switch (ffelex_token_type (t))
5642     {
5643     case FFELEX_typeCOMMA:
5644       ffesta_confirmed ();
5645       if (expr == NULL)
5646         break;
5647       if (!ffesta_is_inhibited ())
5648         {
5649           if (!ffestb_local_.data.started)
5650             {
5651               ffestc_R528_start ();
5652               ffestb_local_.data.started = TRUE;
5653             }
5654           ffestc_R528_item_object (expr, ft);
5655         }
5656       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5657                                           FFEEXPR_contextDATA,
5658                                           (ffeexprCallback) ffestb_R5281_);
5659
5660     case FFELEX_typeSLASH:
5661       ffesta_confirmed ();
5662       if (expr == NULL)
5663         break;
5664       if (!ffesta_is_inhibited ())
5665         {
5666           if (!ffestb_local_.data.started)
5667             {
5668               ffestc_R528_start ();
5669               ffestb_local_.data.started = TRUE;
5670             }
5671           ffestc_R528_item_object (expr, ft);
5672           ffestc_R528_item_startvals ();
5673         }
5674       return (ffelexHandler) ffeexpr_rhs
5675         (ffesta_output_pool, FFEEXPR_contextDATA,
5676          (ffeexprCallback) ffestb_R5282_);
5677
5678     default:
5679       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5680       break;
5681     }
5682
5683   if (ffestb_local_.data.started && !ffesta_is_inhibited ())
5684     ffestc_R528_finish ();
5685   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5686 }
5687
5688 /* ffestb_R5282_ -- "DATA" expr-list SLASH expr-list
5689
5690    (ffestb_R5282_)  // to expression handler
5691
5692    Handle ASTERISK, COMMA, or SLASH.  */
5693
5694 static ffelexHandler
5695 ffestb_R5282_ (ffelexToken ft, ffebld expr, ffelexToken t)
5696 {
5697   switch (ffelex_token_type (t))
5698     {
5699     case FFELEX_typeCOMMA:
5700       if (expr == NULL)
5701         break;
5702       if (!ffesta_is_inhibited ())
5703         ffestc_R528_item_value (NULL, NULL, expr, ft);
5704       return (ffelexHandler) ffeexpr_rhs
5705         (ffesta_output_pool, FFEEXPR_contextDATA,
5706          (ffeexprCallback) ffestb_R5282_);
5707
5708     case FFELEX_typeASTERISK:
5709       if (expr == NULL)
5710         break;
5711       ffestb_local_.data.expr = expr;
5712       ffesta_tokens[1] = ffelex_token_use (ft);
5713       return (ffelexHandler) ffeexpr_rhs
5714         (ffesta_output_pool, FFEEXPR_contextDATA,
5715          (ffeexprCallback) ffestb_R5283_);
5716
5717     case FFELEX_typeSLASH:
5718       if (expr == NULL)
5719         break;
5720       if (!ffesta_is_inhibited ())
5721         {
5722           ffestc_R528_item_value (NULL, NULL, expr, ft);
5723           ffestc_R528_item_endvals (t);
5724         }
5725       return (ffelexHandler) ffestb_R5284_;
5726
5727     default:
5728       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5729       break;
5730     }
5731
5732   if (!ffesta_is_inhibited ())
5733     {
5734       ffestc_R528_item_endvals (t);
5735       ffestc_R528_finish ();
5736     }
5737   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5738 }
5739
5740 /* ffestb_R5283_ -- "DATA" expr-list SLASH expr ASTERISK expr
5741
5742    (ffestb_R5283_)  // to expression handler
5743
5744    Handle COMMA or SLASH.  */
5745
5746 static ffelexHandler
5747 ffestb_R5283_ (ffelexToken ft, ffebld expr, ffelexToken t)
5748 {
5749   switch (ffelex_token_type (t))
5750     {
5751     case FFELEX_typeCOMMA:
5752       if (expr == NULL)
5753         break;
5754       if (!ffesta_is_inhibited ())
5755         ffestc_R528_item_value (ffestb_local_.data.expr, ffesta_tokens[1],
5756                                 expr, ft);
5757       ffelex_token_kill (ffesta_tokens[1]);
5758       return (ffelexHandler) ffeexpr_rhs
5759         (ffesta_output_pool, FFEEXPR_contextDATA,
5760          (ffeexprCallback) ffestb_R5282_);
5761
5762     case FFELEX_typeSLASH:
5763       if (expr == NULL)
5764         break;
5765       if (!ffesta_is_inhibited ())
5766         {
5767           ffestc_R528_item_value (ffestb_local_.data.expr, ffesta_tokens[1],
5768                                   expr, ft);
5769           ffestc_R528_item_endvals (t);
5770         }
5771       ffelex_token_kill (ffesta_tokens[1]);
5772       return (ffelexHandler) ffestb_R5284_;
5773
5774     default:
5775       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5776       break;
5777     }
5778
5779   if (!ffesta_is_inhibited ())
5780     {
5781       ffestc_R528_item_endvals (t);
5782       ffestc_R528_finish ();
5783     }
5784   ffelex_token_kill (ffesta_tokens[1]);
5785   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5786 }
5787
5788 /* ffestb_R5284_ -- "DATA" expr-list SLASH expr-list SLASH
5789
5790    return ffestb_R5284_;  // to lexer
5791
5792    Handle [COMMA] NAME or EOS/SEMICOLON.  */
5793
5794 static ffelexHandler
5795 ffestb_R5284_ (ffelexToken t)
5796 {
5797   switch (ffelex_token_type (t))
5798     {
5799     case FFELEX_typeCOMMA:
5800       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5801                                           FFEEXPR_contextDATA,
5802                                           (ffeexprCallback) ffestb_R5281_);
5803
5804     case FFELEX_typeNAME:
5805     case FFELEX_typeOPEN_PAREN:
5806       return (ffelexHandler) (*((ffelexHandler)
5807                                 ffeexpr_lhs (ffesta_output_pool,
5808                                              FFEEXPR_contextDATA,
5809                                           (ffeexprCallback) ffestb_R5281_)))
5810         (t);
5811
5812     case FFELEX_typeEOS:
5813     case FFELEX_typeSEMICOLON:
5814       if (!ffesta_is_inhibited ())
5815         ffestc_R528_finish ();
5816       return (ffelexHandler) ffesta_zero (t);
5817
5818     default:
5819       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5820       break;
5821     }
5822
5823   if (!ffesta_is_inhibited ())
5824     ffestc_R528_finish ();
5825   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5826 }
5827
5828 /* ffestb_R537 -- Parse a PARAMETER statement
5829
5830    return ffestb_R537;  // to lexer
5831
5832    Make sure the statement has a valid form for an PARAMETER statement.
5833    If it does, implement the statement.  */
5834
5835 ffelexHandler
5836 ffestb_R537 (ffelexToken t)
5837 {
5838   switch (ffelex_token_type (ffesta_tokens[0]))
5839     {
5840     case FFELEX_typeNAME:
5841       if (ffesta_first_kw != FFESTR_firstPARAMETER)
5842         goto bad_0;             /* :::::::::::::::::::: */
5843       break;
5844
5845     case FFELEX_typeNAMES:
5846       if (ffesta_first_kw != FFESTR_firstPARAMETER)
5847         goto bad_0;             /* :::::::::::::::::::: */
5848       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlPARAMETER)
5849         goto bad_0;             /* :::::::::::::::::::: */
5850       break;
5851
5852     default:
5853       goto bad_0;               /* :::::::::::::::::::: */
5854     }
5855
5856   switch (ffelex_token_type (t))
5857     {
5858     case FFELEX_typeOPEN_PAREN:
5859       break;
5860
5861     case FFELEX_typeEOS:
5862     case FFELEX_typeSEMICOLON:
5863     case FFELEX_typeCOMMA:
5864     case FFELEX_typeCOLONCOLON:
5865       ffesta_confirmed ();      /* Error, but clearly intended. */
5866       goto bad_1;               /* :::::::::::::::::::: */
5867
5868     default:
5869       goto bad_1;               /* :::::::::::::::::::: */
5870     }
5871
5872   ffestb_local_.parameter.started = FALSE;
5873   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5874                                       FFEEXPR_contextPARAMETER,
5875                                       (ffeexprCallback) ffestb_R5371_);
5876
5877 bad_0:                          /* :::::::::::::::::::: */
5878   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0]);
5879   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5880
5881 bad_1:                          /* :::::::::::::::::::: */
5882   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
5883   return (ffelexHandler) ffelex_swallow_tokens (t,
5884                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
5885 }
5886
5887 /* ffestb_R5371_ -- "PARAMETER" OPEN_PAREN expr
5888
5889    (ffestb_R5371_)  // to expression handler
5890
5891    Make sure the next token is EQUALS.  */
5892
5893 static ffelexHandler
5894 ffestb_R5371_ (ffelexToken ft, ffebld expr, ffelexToken t)
5895 {
5896   ffestb_local_.parameter.expr = expr;
5897
5898   switch (ffelex_token_type (t))
5899     {
5900     case FFELEX_typeEQUALS:
5901       ffesta_confirmed ();
5902       if (expr == NULL)
5903         break;
5904       ffesta_tokens[1] = ffelex_token_use (ft);
5905       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
5906                  FFEEXPR_contextPARAMETER, (ffeexprCallback) ffestb_R5372_);
5907
5908     default:
5909       break;
5910     }
5911
5912   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
5913   if (ffestb_local_.parameter.started)
5914     ffestc_R537_finish ();
5915   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5916 }
5917
5918 /* ffestb_R5372_ -- "PARAMETER" OPEN_PAREN expr EQUALS expr
5919
5920    (ffestb_R5372_)  // to expression handler
5921
5922    Make sure the next token is COMMA or CLOSE_PAREN.  */
5923
5924 static ffelexHandler
5925 ffestb_R5372_ (ffelexToken ft, ffebld expr, ffelexToken t)
5926 {
5927   switch (ffelex_token_type (t))
5928     {
5929     case FFELEX_typeCOMMA:
5930       if (expr == NULL)
5931         break;
5932       if (!ffesta_is_inhibited ())
5933         {
5934           if (!ffestb_local_.parameter.started)
5935             {
5936               ffestc_R537_start ();
5937               ffestb_local_.parameter.started = TRUE;
5938             }
5939           ffestc_R537_item (ffestb_local_.parameter.expr, ffesta_tokens[1],
5940                             expr, ft);
5941         }
5942       ffelex_token_kill (ffesta_tokens[1]);
5943       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5944                                           FFEEXPR_contextPARAMETER,
5945                                           (ffeexprCallback) ffestb_R5371_);
5946
5947     case FFELEX_typeCLOSE_PAREN:
5948       if (expr == NULL)
5949         break;
5950       if (!ffesta_is_inhibited ())
5951         {
5952           if (!ffestb_local_.parameter.started)
5953             {
5954               ffestc_R537_start ();
5955               ffestb_local_.parameter.started = TRUE;
5956             }
5957           ffestc_R537_item (ffestb_local_.parameter.expr, ffesta_tokens[1],
5958                             expr, ft);
5959           ffestc_R537_finish ();
5960         }
5961       ffelex_token_kill (ffesta_tokens[1]);
5962       return (ffelexHandler) ffestb_R5373_;
5963
5964     default:
5965       break;
5966     }
5967
5968   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
5969   if (ffestb_local_.parameter.started)
5970     ffestc_R537_finish ();
5971   ffelex_token_kill (ffesta_tokens[1]);
5972   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5973 }
5974
5975 /* ffestb_R5373_ -- "PARAMETER" OPEN_PAREN expr EQUALS expr CLOSE_PAREN
5976
5977    return ffestb_R5373_;  // to lexer
5978
5979    Make sure the next token is EOS or SEMICOLON, or generate an error.  All
5980    cleanup has already been done, by the way.  */
5981
5982 static ffelexHandler
5983 ffestb_R5373_ (ffelexToken t)
5984 {
5985   switch (ffelex_token_type (t))
5986     {
5987     case FFELEX_typeEOS:
5988     case FFELEX_typeSEMICOLON:
5989       return (ffelexHandler) ffesta_zero (t);
5990
5991     default:
5992       break;
5993     }
5994
5995   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
5996   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5997 }
5998
5999 /* ffestb_R542 -- Parse the NAMELIST statement
6000
6001    return ffestb_R542;  // to lexer
6002
6003    Make sure the statement has a valid form for the NAMELIST statement.  If it
6004    does, implement the statement.  */
6005
6006 ffelexHandler
6007 ffestb_R542 (ffelexToken t)
6008 {
6009   char *p;
6010   ffeTokenLength i;
6011
6012   switch (ffelex_token_type (ffesta_tokens[0]))
6013     {
6014     case FFELEX_typeNAME:
6015       if (ffesta_first_kw != FFESTR_firstNAMELIST)
6016         goto bad_0;             /* :::::::::::::::::::: */
6017       break;
6018
6019     case FFELEX_typeNAMES:
6020       if (ffesta_first_kw != FFESTR_firstNAMELIST)
6021         goto bad_0;             /* :::::::::::::::::::: */
6022       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlNAMELIST);
6023       if (*p != '\0')
6024         goto bad_i;             /* :::::::::::::::::::: */
6025       break;
6026
6027     default:
6028       goto bad_0;               /* :::::::::::::::::::: */
6029     }
6030
6031   switch (ffelex_token_type (t))
6032     {
6033     case FFELEX_typeCOMMA:
6034     case FFELEX_typeEOS:
6035     case FFELEX_typeSEMICOLON:
6036     case FFELEX_typeCOLONCOLON:
6037       ffesta_confirmed ();      /* Error, but clearly intended. */
6038       goto bad_1;               /* :::::::::::::::::::: */
6039
6040     default:
6041       goto bad_1;               /* :::::::::::::::::::: */
6042
6043     case FFELEX_typeSLASH:
6044       break;
6045     }
6046
6047   ffesta_confirmed ();
6048   if (!ffesta_is_inhibited ())
6049     ffestc_R542_start ();
6050   return (ffelexHandler) ffestb_R5421_;
6051
6052 bad_0:                          /* :::::::::::::::::::: */
6053   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", ffesta_tokens[0]);
6054   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6055
6056 bad_1:                          /* :::::::::::::::::::: */
6057   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6058   return (ffelexHandler) ffelex_swallow_tokens (t,
6059                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6060
6061 bad_i:                          /* :::::::::::::::::::: */
6062   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "NAMELIST", ffesta_tokens[0], i, t);
6063   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6064 }
6065
6066 /* ffestb_R5421_ -- "NAMELIST" SLASH
6067
6068    return ffestb_R5421_;  // to lexer
6069
6070    Handle NAME.  */
6071
6072 static ffelexHandler
6073 ffestb_R5421_ (ffelexToken t)
6074 {
6075   switch (ffelex_token_type (t))
6076     {
6077     case FFELEX_typeNAME:
6078       if (!ffesta_is_inhibited ())
6079         ffestc_R542_item_nlist (t);
6080       return (ffelexHandler) ffestb_R5422_;
6081
6082     default:
6083       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6084       break;
6085     }
6086
6087   if (!ffesta_is_inhibited ())
6088     ffestc_R542_finish ();
6089   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6090 }
6091
6092 /* ffestb_R5422_ -- "NAMELIST" SLASH NAME
6093
6094    return ffestb_R5422_;  // to lexer
6095
6096    Handle SLASH.  */
6097
6098 static ffelexHandler
6099 ffestb_R5422_ (ffelexToken t)
6100 {
6101   switch (ffelex_token_type (t))
6102     {
6103     case FFELEX_typeSLASH:
6104       return (ffelexHandler) ffestb_R5423_;
6105
6106     default:
6107       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6108       break;
6109     }
6110
6111   if (!ffesta_is_inhibited ())
6112     ffestc_R542_finish ();
6113   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6114 }
6115
6116 /* ffestb_R5423_ -- "NAMELIST" SLASH NAME SLASH
6117
6118    return ffestb_R5423_;  // to lexer
6119
6120    Handle NAME.  */
6121
6122 static ffelexHandler
6123 ffestb_R5423_ (ffelexToken t)
6124 {
6125   switch (ffelex_token_type (t))
6126     {
6127     case FFELEX_typeNAME:
6128       if (!ffesta_is_inhibited ())
6129         ffestc_R542_item_nitem (t);
6130       return (ffelexHandler) ffestb_R5424_;
6131
6132     default:
6133       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6134       break;
6135     }
6136
6137   if (!ffesta_is_inhibited ())
6138     ffestc_R542_finish ();
6139   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6140 }
6141
6142 /* ffestb_R5424_ -- "NAMELIST" SLASH NAME SLASH NAME
6143
6144    return ffestb_R5424_;  // to lexer
6145
6146    Handle COMMA, EOS/SEMICOLON, or SLASH.  */
6147
6148 static ffelexHandler
6149 ffestb_R5424_ (ffelexToken t)
6150 {
6151   switch (ffelex_token_type (t))
6152     {
6153     case FFELEX_typeCOMMA:
6154       return (ffelexHandler) ffestb_R5425_;
6155
6156     case FFELEX_typeEOS:
6157     case FFELEX_typeSEMICOLON:
6158       if (!ffesta_is_inhibited ())
6159         ffestc_R542_finish ();
6160       return (ffelexHandler) ffesta_zero (t);
6161
6162     case FFELEX_typeSLASH:
6163       return (ffelexHandler) ffestb_R5421_;
6164
6165     default:
6166       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6167       break;
6168     }
6169
6170   if (!ffesta_is_inhibited ())
6171     ffestc_R542_finish ();
6172   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6173 }
6174
6175 /* ffestb_R5425_ -- "NAMELIST" SLASH NAME SLASH NAME COMMA
6176
6177    return ffestb_R5425_;  // to lexer
6178
6179    Handle NAME or SLASH.  */
6180
6181 static ffelexHandler
6182 ffestb_R5425_ (ffelexToken t)
6183 {
6184   switch (ffelex_token_type (t))
6185     {
6186     case FFELEX_typeNAME:
6187       if (!ffesta_is_inhibited ())
6188         ffestc_R542_item_nitem (t);
6189       return (ffelexHandler) ffestb_R5424_;
6190
6191     case FFELEX_typeSLASH:
6192       return (ffelexHandler) ffestb_R5421_;
6193
6194     default:
6195       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6196       break;
6197     }
6198
6199   if (!ffesta_is_inhibited ())
6200     ffestc_R542_finish ();
6201   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6202 }
6203
6204 /* ffestb_R544 -- Parse an EQUIVALENCE statement
6205
6206    return ffestb_R544;  // to lexer
6207
6208    Make sure the statement has a valid form for an EQUIVALENCE statement.
6209    If it does, implement the statement.  */
6210
6211 ffelexHandler
6212 ffestb_R544 (ffelexToken t)
6213 {
6214   switch (ffelex_token_type (ffesta_tokens[0]))
6215     {
6216     case FFELEX_typeNAME:
6217       if (ffesta_first_kw != FFESTR_firstEQUIVALENCE)
6218         goto bad_0;             /* :::::::::::::::::::: */
6219       break;
6220
6221     case FFELEX_typeNAMES:
6222       if (ffesta_first_kw != FFESTR_firstEQUIVALENCE)
6223         goto bad_0;             /* :::::::::::::::::::: */
6224       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlEQUIVALENCE)
6225         goto bad_0;             /* :::::::::::::::::::: */
6226       break;
6227
6228     default:
6229       goto bad_0;               /* :::::::::::::::::::: */
6230     }
6231
6232   switch (ffelex_token_type (t))
6233     {
6234     case FFELEX_typeOPEN_PAREN:
6235       break;
6236
6237     case FFELEX_typeEOS:
6238     case FFELEX_typeSEMICOLON:
6239     case FFELEX_typeCOMMA:
6240     case FFELEX_typeCOLONCOLON:
6241       ffesta_confirmed ();      /* Error, but clearly intended. */
6242       goto bad_1;               /* :::::::::::::::::::: */
6243
6244     default:
6245       goto bad_1;               /* :::::::::::::::::::: */
6246     }
6247
6248   ffestb_local_.equivalence.started = FALSE;
6249   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6250                                       FFEEXPR_contextEQUIVALENCE,
6251                                       (ffeexprCallback) ffestb_R5441_);
6252
6253 bad_0:                          /* :::::::::::::::::::: */
6254   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", ffesta_tokens[0]);
6255   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6256
6257 bad_1:                          /* :::::::::::::::::::: */
6258   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6259   return (ffelexHandler) ffelex_swallow_tokens (t,
6260                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6261 }
6262
6263 /* ffestb_R5441_ -- "EQUIVALENCE" OPEN_PAREN expr
6264
6265    (ffestb_R5441_)  // to expression handler
6266
6267    Make sure the next token is COMMA.  */
6268
6269 static ffelexHandler
6270 ffestb_R5441_ (ffelexToken ft, ffebld expr, ffelexToken t)
6271 {
6272   switch (ffelex_token_type (t))
6273     {
6274     case FFELEX_typeCOMMA:
6275       if (expr == NULL)
6276         break;
6277       ffestb_local_.equivalence.exprs = ffestt_exprlist_create ();
6278       ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
6279                               ffelex_token_use (ft));
6280       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6281                                           FFEEXPR_contextEQUIVALENCE,
6282                                           (ffeexprCallback) ffestb_R5442_);
6283
6284     default:
6285       break;
6286     }
6287
6288   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6289   if (ffestb_local_.equivalence.started)
6290     ffestc_R544_finish ();
6291   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6292 }
6293
6294 /* ffestb_R5442_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr
6295
6296    (ffestb_R5442_)  // to expression handler
6297
6298    Make sure the next token is COMMA or CLOSE_PAREN.  For COMMA, we just
6299    append the expression to our list and continue; for CLOSE_PAREN, we
6300    append the expression and move to _3_.  */
6301
6302 static ffelexHandler
6303 ffestb_R5442_ (ffelexToken ft, ffebld expr, ffelexToken t)
6304 {
6305   switch (ffelex_token_type (t))
6306     {
6307     case FFELEX_typeCOMMA:
6308       if (expr == NULL)
6309         break;
6310       ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
6311                               ffelex_token_use (ft));
6312       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6313                                           FFEEXPR_contextEQUIVALENCE,
6314                                           (ffeexprCallback) ffestb_R5442_);
6315
6316     case FFELEX_typeCLOSE_PAREN:
6317       if (expr == NULL)
6318         break;
6319       ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
6320                               ffelex_token_use (ft));
6321       return (ffelexHandler) ffestb_R5443_;
6322
6323     default:
6324       break;
6325     }
6326
6327   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6328   if (ffestb_local_.equivalence.started)
6329     ffestc_R544_finish ();
6330   ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6331   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6332 }
6333
6334 /* ffestb_R5443_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr CLOSE_PAREN
6335
6336    return ffestb_R5443_;  // to lexer
6337
6338    Make sure the next token is COMMA or EOS/SEMICOLON.  */
6339
6340 static ffelexHandler
6341 ffestb_R5443_ (ffelexToken t)
6342 {
6343   switch (ffelex_token_type (t))
6344     {
6345     case FFELEX_typeCOMMA:
6346       ffesta_confirmed ();
6347       if (!ffesta_is_inhibited ())
6348         {
6349           if (!ffestb_local_.equivalence.started)
6350             {
6351               ffestc_R544_start ();
6352               ffestb_local_.equivalence.started = TRUE;
6353             }
6354           ffestc_R544_item (ffestb_local_.equivalence.exprs);
6355         }
6356       ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6357       return (ffelexHandler) ffestb_R5444_;
6358
6359     case FFELEX_typeEOS:
6360     case FFELEX_typeSEMICOLON:
6361       ffesta_confirmed ();
6362       if (!ffesta_is_inhibited ())
6363         {
6364           if (!ffestb_local_.equivalence.started)
6365             {
6366               ffestc_R544_start ();
6367               ffestb_local_.equivalence.started = TRUE;
6368             }
6369           ffestc_R544_item (ffestb_local_.equivalence.exprs);
6370           ffestc_R544_finish ();
6371         }
6372       ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6373       return (ffelexHandler) ffesta_zero (t);
6374
6375     default:
6376       break;
6377     }
6378
6379   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6380   if (ffestb_local_.equivalence.started)
6381     ffestc_R544_finish ();
6382   ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6383   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6384 }
6385
6386 /* ffestb_R5444_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr CLOSE_PAREN COMMA
6387
6388    return ffestb_R5444_;  // to lexer
6389
6390    Make sure the next token is OPEN_PAREN, or generate an error.  */
6391
6392 static ffelexHandler
6393 ffestb_R5444_ (ffelexToken t)
6394 {
6395   switch (ffelex_token_type (t))
6396     {
6397     case FFELEX_typeOPEN_PAREN:
6398       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6399                                           FFEEXPR_contextEQUIVALENCE,
6400                                           (ffeexprCallback) ffestb_R5441_);
6401
6402     default:
6403       break;
6404     }
6405
6406   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6407   if (ffestb_local_.equivalence.started)
6408     ffestc_R544_finish ();
6409   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6410 }
6411
6412 /* ffestb_R834 -- Parse the CYCLE statement
6413
6414    return ffestb_R834;  // to lexer
6415
6416    Make sure the statement has a valid form for the CYCLE statement.  If
6417    it does, implement the statement.  */
6418
6419 ffelexHandler
6420 ffestb_R834 (ffelexToken t)
6421 {
6422   ffeTokenLength i;
6423   char *p;
6424
6425   switch (ffelex_token_type (ffesta_tokens[0]))
6426     {
6427     case FFELEX_typeNAME:
6428       if (ffesta_first_kw != FFESTR_firstCYCLE)
6429         goto bad_0;             /* :::::::::::::::::::: */
6430       switch (ffelex_token_type (t))
6431         {
6432         case FFELEX_typeCOMMA:
6433         case FFELEX_typeCOLONCOLON:
6434           ffesta_confirmed ();  /* Error, but clearly intended. */
6435           goto bad_1;           /* :::::::::::::::::::: */
6436
6437         default:
6438           goto bad_1;           /* :::::::::::::::::::: */
6439
6440         case FFELEX_typeNAME:
6441           ffesta_confirmed ();
6442           ffesta_tokens[1] = ffelex_token_use (t);
6443           return (ffelexHandler) ffestb_R8341_;
6444
6445         case FFELEX_typeEOS:
6446         case FFELEX_typeSEMICOLON:
6447           ffesta_confirmed ();
6448           ffesta_tokens[1] = NULL;
6449           return (ffelexHandler) ffestb_R8341_ (t);
6450         }
6451
6452     case FFELEX_typeNAMES:
6453       if (ffesta_first_kw != FFESTR_firstCYCLE)
6454         goto bad_0;             /* :::::::::::::::::::: */
6455       switch (ffelex_token_type (t))
6456         {
6457         default:
6458           goto bad_1;           /* :::::::::::::::::::: */
6459
6460         case FFELEX_typeEOS:
6461         case FFELEX_typeSEMICOLON:
6462           break;
6463         }
6464       ffesta_confirmed ();
6465       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCYCLE);
6466       if (*p == '\0')
6467         {
6468           ffesta_tokens[1] = NULL;
6469         }
6470       else
6471         {
6472           if (!ffesrc_is_name_init (*p))
6473             goto bad_i;         /* :::::::::::::::::::: */
6474           ffesta_tokens[1]
6475             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
6476         }
6477       return (ffelexHandler) ffestb_R8341_ (t);
6478
6479     default:
6480       goto bad_0;               /* :::::::::::::::::::: */
6481     }
6482
6483 bad_0:                          /* :::::::::::::::::::: */
6484   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", ffesta_tokens[0]);
6485   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6486
6487 bad_1:                          /* :::::::::::::::::::: */
6488   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", t);
6489   return (ffelexHandler) ffelex_swallow_tokens (t,
6490                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6491
6492 bad_i:                          /* :::::::::::::::::::: */
6493   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CYCLE", ffesta_tokens[0], i, t);
6494   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6495 }
6496
6497 /* ffestb_R8341_ -- "CYCLE" [NAME]
6498
6499    return ffestb_R8341_;  // to lexer
6500
6501    Make sure the next token is an EOS or SEMICOLON.  */
6502
6503 static ffelexHandler
6504 ffestb_R8341_ (ffelexToken t)
6505 {
6506   switch (ffelex_token_type (t))
6507     {
6508     case FFELEX_typeEOS:
6509     case FFELEX_typeSEMICOLON:
6510       ffesta_confirmed ();
6511       if (!ffesta_is_inhibited ())
6512         ffestc_R834 (ffesta_tokens[1]);
6513       if (ffesta_tokens[1] != NULL)
6514         ffelex_token_kill (ffesta_tokens[1]);
6515       return (ffelexHandler) ffesta_zero (t);
6516
6517     default:
6518       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", t);
6519       break;
6520     }
6521
6522   if (ffesta_tokens[1] != NULL)
6523     ffelex_token_kill (ffesta_tokens[1]);
6524   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6525 }
6526
6527 /* ffestb_R835 -- Parse the EXIT statement
6528
6529    return ffestb_R835;  // to lexer
6530
6531    Make sure the statement has a valid form for the EXIT statement.  If
6532    it does, implement the statement.  */
6533
6534 ffelexHandler
6535 ffestb_R835 (ffelexToken t)
6536 {
6537   ffeTokenLength i;
6538   char *p;
6539
6540   switch (ffelex_token_type (ffesta_tokens[0]))
6541     {
6542     case FFELEX_typeNAME:
6543       if (ffesta_first_kw != FFESTR_firstEXIT)
6544         goto bad_0;             /* :::::::::::::::::::: */
6545       switch (ffelex_token_type (t))
6546         {
6547         case FFELEX_typeCOMMA:
6548         case FFELEX_typeCOLONCOLON:
6549           ffesta_confirmed ();  /* Error, but clearly intended. */
6550           goto bad_1;           /* :::::::::::::::::::: */
6551
6552         default:
6553           goto bad_1;           /* :::::::::::::::::::: */
6554
6555         case FFELEX_typeNAME:
6556           ffesta_confirmed ();
6557           ffesta_tokens[1] = ffelex_token_use (t);
6558           return (ffelexHandler) ffestb_R8351_;
6559
6560         case FFELEX_typeEOS:
6561         case FFELEX_typeSEMICOLON:
6562           ffesta_confirmed ();
6563           ffesta_tokens[1] = NULL;
6564           return (ffelexHandler) ffestb_R8351_ (t);
6565         }
6566
6567     case FFELEX_typeNAMES:
6568       if (ffesta_first_kw != FFESTR_firstEXIT)
6569         goto bad_0;             /* :::::::::::::::::::: */
6570       switch (ffelex_token_type (t))
6571         {
6572         default:
6573           goto bad_1;           /* :::::::::::::::::::: */
6574
6575         case FFELEX_typeEOS:
6576         case FFELEX_typeSEMICOLON:
6577           break;
6578         }
6579       ffesta_confirmed ();
6580       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlEXIT);
6581       if (*p == '\0')
6582         {
6583           ffesta_tokens[1] = NULL;
6584         }
6585       else
6586         {
6587           if (!ffesrc_is_name_init (*p))
6588             goto bad_i;         /* :::::::::::::::::::: */
6589           ffesta_tokens[1]
6590             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
6591         }
6592       return (ffelexHandler) ffestb_R8351_ (t);
6593
6594     default:
6595       goto bad_0;               /* :::::::::::::::::::: */
6596     }
6597
6598 bad_0:                          /* :::::::::::::::::::: */
6599   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", ffesta_tokens[0]);
6600   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6601
6602 bad_1:                          /* :::::::::::::::::::: */
6603   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", t);
6604   return (ffelexHandler) ffelex_swallow_tokens (t,
6605                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6606
6607 bad_i:                          /* :::::::::::::::::::: */
6608   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "EXIT", ffesta_tokens[0], i, t);
6609   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6610 }
6611
6612 /* ffestb_R8351_ -- "EXIT" [NAME]
6613
6614    return ffestb_R8351_;  // to lexer
6615
6616    Make sure the next token is an EOS or SEMICOLON.  */
6617
6618 static ffelexHandler
6619 ffestb_R8351_ (ffelexToken t)
6620 {
6621   switch (ffelex_token_type (t))
6622     {
6623     case FFELEX_typeEOS:
6624     case FFELEX_typeSEMICOLON:
6625       ffesta_confirmed ();
6626       if (!ffesta_is_inhibited ())
6627         ffestc_R835 (ffesta_tokens[1]);
6628       if (ffesta_tokens[1] != NULL)
6629         ffelex_token_kill (ffesta_tokens[1]);
6630       return (ffelexHandler) ffesta_zero (t);
6631
6632     default:
6633       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", t);
6634       break;
6635     }
6636
6637   if (ffesta_tokens[1] != NULL)
6638     ffelex_token_kill (ffesta_tokens[1]);
6639   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6640 }
6641
6642 /* ffestb_R838 -- Parse the ASSIGN statement
6643
6644    return ffestb_R838;  // to lexer
6645
6646    Make sure the statement has a valid form for the ASSIGN statement.  If it
6647    does, implement the statement.  */
6648
6649 ffelexHandler
6650 ffestb_R838 (ffelexToken t)
6651 {
6652   char *p;
6653   ffeTokenLength i;
6654   ffelexHandler next;
6655   ffelexToken et;               /* First token in target. */
6656
6657   switch (ffelex_token_type (ffesta_tokens[0]))
6658     {
6659     case FFELEX_typeNAME:
6660       if (ffesta_first_kw != FFESTR_firstASSIGN)
6661         goto bad_0;             /* :::::::::::::::::::: */
6662       switch (ffelex_token_type (t))
6663         {
6664         case FFELEX_typeEOS:
6665         case FFELEX_typeSEMICOLON:
6666         case FFELEX_typeCOMMA:
6667         case FFELEX_typeCOLONCOLON:
6668           ffesta_confirmed ();  /* Error, but clearly intended. */
6669           goto bad_1;           /* :::::::::::::::::::: */
6670
6671         default:
6672           goto bad_1;           /* :::::::::::::::::::: */
6673
6674         case FFELEX_typeNUMBER:
6675           break;
6676         }
6677       ffesta_tokens[1] = ffelex_token_use (t);
6678       ffesta_confirmed ();
6679       return (ffelexHandler) ffestb_R8381_;
6680
6681     case FFELEX_typeNAMES:
6682       if (ffesta_first_kw != FFESTR_firstASSIGN)
6683         goto bad_0;             /* :::::::::::::::::::: */
6684
6685       switch (ffelex_token_type (t))
6686         {
6687         case FFELEX_typeEOS:
6688         case FFELEX_typeSEMICOLON:
6689           ffesta_confirmed ();
6690           /* Fall through. */
6691         case FFELEX_typePERCENT:
6692         case FFELEX_typeOPEN_PAREN:
6693           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlASSIGN);
6694           if (!isdigit (*p))
6695             goto bad_i;         /* :::::::::::::::::::: */
6696           ffesta_tokens[1]
6697             = ffelex_token_number_from_names (ffesta_tokens[0], i);
6698           p += ffelex_token_length (ffesta_tokens[1]);  /* Skip to "TO". */
6699           i += ffelex_token_length (ffesta_tokens[1]);
6700           if (!ffesrc_char_match_init (*p, 'T', 't')    /* "TO". */
6701               || (++i, !ffesrc_char_match_noninit (*++p, 'O', 'o')))
6702             {
6703             bad_i_1:            /* :::::::::::::::::::: */
6704               ffelex_token_kill (ffesta_tokens[1]);
6705               goto bad_i;       /* :::::::::::::::::::: */
6706             }
6707           ++p, ++i;
6708           if (!ffesrc_is_name_init (*p))
6709             goto bad_i_1;       /* :::::::::::::::::::: */
6710           et = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
6711           next = (ffelexHandler)
6712             (*((ffelexHandler)
6713                ffeexpr_lhs (ffesta_output_pool,
6714                             FFEEXPR_contextASSIGN,
6715                             (ffeexprCallback)
6716                             ffestb_R8383_)))
6717             (et);
6718           ffelex_token_kill (et);
6719           return (ffelexHandler) (*next) (t);
6720
6721         case FFELEX_typeCOMMA:
6722         case FFELEX_typeCOLONCOLON:
6723           ffesta_confirmed ();  /* Error, but clearly intended. */
6724           goto bad_1;           /* :::::::::::::::::::: */
6725
6726         default:
6727           goto bad_1;           /* :::::::::::::::::::: */
6728         }
6729
6730     default:
6731       goto bad_0;               /* :::::::::::::::::::: */
6732     }
6733
6734 bad_0:                          /* :::::::::::::::::::: */
6735   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", ffesta_tokens[0]);
6736   return (ffelexHandler) ffelex_swallow_tokens (t,
6737                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
6738
6739 bad_1:                          /* :::::::::::::::::::: */
6740   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6741   return (ffelexHandler) ffelex_swallow_tokens (t,
6742                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6743
6744 bad_i:                          /* :::::::::::::::::::: */
6745   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ASSIGN", ffesta_tokens[0], i, t);
6746   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6747 }
6748
6749 /* ffestb_R8381_ -- "ASSIGN" NUMBER
6750
6751    return ffestb_R8381_;  // to lexer
6752
6753    Make sure the next token is "TO".  */
6754
6755 static ffelexHandler
6756 ffestb_R8381_ (ffelexToken t)
6757 {
6758   if ((ffelex_token_type (t) == FFELEX_typeNAME)
6759   && (ffesrc_strcmp_2c (ffe_case_match (), ffelex_token_text (t), "TO", "to",
6760                         "To") == 0))
6761     {
6762       return (ffelexHandler) ffestb_R8382_;
6763     }
6764
6765   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6766   if (ffelex_token_type (t) == FFELEX_typeNAME)
6767     return (ffelexHandler) ffestb_R8382_ (t);   /* Maybe user forgot "TO". */
6768
6769   ffelex_token_kill (ffesta_tokens[1]);
6770   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6771 }
6772
6773 /* ffestb_R8382_ -- "ASSIGN" NUMBER ("TO")
6774
6775    return ffestb_R8382_;  // to lexer
6776
6777    Make sure the next token is a name, then pass it along to the expression
6778    evaluator as an LHS expression.  The callback function is _3_.  */
6779
6780 static ffelexHandler
6781 ffestb_R8382_ (ffelexToken t)
6782 {
6783   if (ffelex_token_type (t) == FFELEX_typeNAME)
6784     {
6785       return (ffelexHandler)
6786       (*((ffelexHandler)
6787          ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextASSIGN,
6788                       (ffeexprCallback) ffestb_R8383_)))
6789       (t);
6790     }
6791
6792   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6793   ffelex_token_kill (ffesta_tokens[1]);
6794   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6795 }
6796
6797 /* ffestb_R8383_ -- "ASSIGN" NUMBER ("TO") expression
6798
6799    (ffestb_R8383_)  // to expression handler
6800
6801    Make sure the next token is an EOS or SEMICOLON.  */
6802
6803 static ffelexHandler
6804 ffestb_R8383_ (ffelexToken ft, ffebld expr, ffelexToken t)
6805 {
6806   switch (ffelex_token_type (t))
6807     {
6808     case FFELEX_typeEOS:
6809     case FFELEX_typeSEMICOLON:
6810       ffesta_confirmed ();
6811       if (expr == NULL)
6812         break;
6813       if (!ffesta_is_inhibited ())
6814         ffestc_R838 (ffesta_tokens[1], expr, ft);
6815       ffelex_token_kill (ffesta_tokens[1]);
6816       return (ffelexHandler) ffesta_zero (t);
6817
6818     default:
6819       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6820       break;
6821     }
6822
6823   ffelex_token_kill (ffesta_tokens[1]);
6824   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6825 }
6826
6827 /* ffestb_R840 -- Parse an arithmetic-IF statement
6828
6829    return ffestb_R840;  // to lexer
6830
6831    Make sure the statement has a valid form for an arithmetic-IF statement.
6832    If it does, implement the statement.  */
6833
6834 ffelexHandler
6835 ffestb_R840 (ffelexToken t)
6836 {
6837   switch (ffelex_token_type (ffesta_tokens[0]))
6838     {
6839     case FFELEX_typeNAME:
6840       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlIF)
6841         goto bad_0;             /* :::::::::::::::::::: */
6842       if (ffesta_first_kw != FFESTR_firstIF)
6843         goto bad_0;             /* :::::::::::::::::::: */
6844       break;
6845
6846     case FFELEX_typeNAMES:
6847       if (ffesta_first_kw != FFESTR_firstIF)
6848         goto bad_0;             /* :::::::::::::::::::: */
6849       break;
6850
6851     default:
6852       goto bad_0;               /* :::::::::::::::::::: */
6853     }
6854
6855   switch (ffelex_token_type (t))
6856     {
6857     case FFELEX_typeOPEN_PAREN:
6858       break;
6859
6860     default:
6861       goto bad_1;               /* :::::::::::::::::::: */
6862     }
6863
6864   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextARITHIF,
6865                                       (ffeexprCallback) ffestb_R8401_);
6866
6867 bad_0:                          /* :::::::::::::::::::: */
6868   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", ffesta_tokens[0]);
6869   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6870
6871 bad_1:                          /* :::::::::::::::::::: */
6872   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6873   return (ffelexHandler) ffelex_swallow_tokens (t,
6874                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6875 }
6876
6877 /* ffestb_R8401_ -- "IF" OPEN_PAREN expr
6878
6879    (ffestb_R8401_)  // to expression handler
6880
6881    Make sure the next token is CLOSE_PAREN.  */
6882
6883 static ffelexHandler
6884 ffestb_R8401_ (ffelexToken ft, ffebld expr, ffelexToken t)
6885 {
6886   ffestb_local_.if_stmt.expr = expr;
6887
6888   switch (ffelex_token_type (t))
6889     {
6890     case FFELEX_typeCLOSE_PAREN:
6891       if (expr == NULL)
6892         break;
6893       ffesta_tokens[1] = ffelex_token_use (ft);
6894       ffelex_set_names (TRUE);  /* In case it's a logical IF instead. */
6895       return (ffelexHandler) ffestb_R8402_;
6896
6897     default:
6898       break;
6899     }
6900
6901   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6902   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6903 }
6904
6905 /* ffestb_R8402_ -- "IF" OPEN_PAREN expr CLOSE_PAREN
6906
6907    return ffestb_R8402_;  // to lexer
6908
6909    Make sure the next token is NUMBER.  */
6910
6911 static ffelexHandler
6912 ffestb_R8402_ (ffelexToken t)
6913 {
6914   ffelex_set_names (FALSE);
6915
6916   switch (ffelex_token_type (t))
6917     {
6918     case FFELEX_typeNUMBER:
6919       ffesta_confirmed ();
6920       ffesta_tokens[2] = ffelex_token_use (t);
6921       return (ffelexHandler) ffestb_R8403_;
6922
6923     default:
6924       break;
6925     }
6926
6927   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6928   ffelex_token_kill (ffesta_tokens[1]);
6929   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6930 }
6931
6932 /* ffestb_R8403_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER
6933
6934    return ffestb_R8403_;  // to lexer
6935
6936    Make sure the next token is COMMA.  */
6937
6938 static ffelexHandler
6939 ffestb_R8403_ (ffelexToken t)
6940 {
6941   switch (ffelex_token_type (t))
6942     {
6943     case FFELEX_typeCOMMA:
6944       return (ffelexHandler) ffestb_R8404_;
6945
6946     default:
6947       break;
6948     }
6949
6950   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6951   ffelex_token_kill (ffesta_tokens[1]);
6952   ffelex_token_kill (ffesta_tokens[2]);
6953   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6954 }
6955
6956 /* ffestb_R8404_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA
6957
6958    return ffestb_R8404_;  // to lexer
6959
6960    Make sure the next token is NUMBER.  */
6961
6962 static ffelexHandler
6963 ffestb_R8404_ (ffelexToken t)
6964 {
6965   switch (ffelex_token_type (t))
6966     {
6967     case FFELEX_typeNUMBER:
6968       ffesta_tokens[3] = ffelex_token_use (t);
6969       return (ffelexHandler) ffestb_R8405_;
6970
6971     default:
6972       break;
6973     }
6974
6975   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6976   ffelex_token_kill (ffesta_tokens[1]);
6977   ffelex_token_kill (ffesta_tokens[2]);
6978   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6979 }
6980
6981 /* ffestb_R8405_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER
6982
6983    return ffestb_R8405_;  // to lexer
6984
6985    Make sure the next token is COMMA.  */
6986
6987 static ffelexHandler
6988 ffestb_R8405_ (ffelexToken t)
6989 {
6990   switch (ffelex_token_type (t))
6991     {
6992     case FFELEX_typeCOMMA:
6993       return (ffelexHandler) ffestb_R8406_;
6994
6995     default:
6996       break;
6997     }
6998
6999   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
7000   ffelex_token_kill (ffesta_tokens[1]);
7001   ffelex_token_kill (ffesta_tokens[2]);
7002   ffelex_token_kill (ffesta_tokens[3]);
7003   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7004 }
7005
7006 /* ffestb_R8406_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER COMMA
7007
7008    return ffestb_R8406_;  // to lexer
7009
7010    Make sure the next token is NUMBER.  */
7011
7012 static ffelexHandler
7013 ffestb_R8406_ (ffelexToken t)
7014 {
7015   switch (ffelex_token_type (t))
7016     {
7017     case FFELEX_typeNUMBER:
7018       ffesta_tokens[4] = ffelex_token_use (t);
7019       return (ffelexHandler) ffestb_R8407_;
7020
7021     default:
7022       break;
7023     }
7024
7025   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
7026   ffelex_token_kill (ffesta_tokens[1]);
7027   ffelex_token_kill (ffesta_tokens[2]);
7028   ffelex_token_kill (ffesta_tokens[3]);
7029   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7030 }
7031
7032 /* ffestb_R8407_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER COMMA
7033                     NUMBER
7034
7035    return ffestb_R8407_;  // to lexer
7036
7037    Make sure the next token is EOS or SEMICOLON.  */
7038
7039 static ffelexHandler
7040 ffestb_R8407_ (ffelexToken t)
7041 {
7042   switch (ffelex_token_type (t))
7043     {
7044     case FFELEX_typeEOS:
7045     case FFELEX_typeSEMICOLON:
7046       if (!ffesta_is_inhibited ())
7047         ffestc_R840 (ffestb_local_.if_stmt.expr, ffesta_tokens[1],
7048                      ffesta_tokens[2], ffesta_tokens[3], ffesta_tokens[4]);
7049       ffelex_token_kill (ffesta_tokens[1]);
7050       ffelex_token_kill (ffesta_tokens[2]);
7051       ffelex_token_kill (ffesta_tokens[3]);
7052       ffelex_token_kill (ffesta_tokens[4]);
7053       return (ffelexHandler) ffesta_zero (t);
7054
7055     default:
7056       break;
7057     }
7058
7059   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
7060   ffelex_token_kill (ffesta_tokens[1]);
7061   ffelex_token_kill (ffesta_tokens[2]);
7062   ffelex_token_kill (ffesta_tokens[3]);
7063   ffelex_token_kill (ffesta_tokens[4]);
7064   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7065 }
7066
7067 /* ffestb_R841 -- Parse the CONTINUE statement
7068
7069    return ffestb_R841;  // to lexer
7070
7071    Make sure the statement has a valid form for the CONTINUE statement.  If
7072    it does, implement the statement.  */
7073
7074 ffelexHandler
7075 ffestb_R841 (ffelexToken t)
7076 {
7077   char *p;
7078   ffeTokenLength i;
7079
7080   switch (ffelex_token_type (ffesta_tokens[0]))
7081     {
7082     case FFELEX_typeNAME:
7083       if (ffesta_first_kw != FFESTR_firstCONTINUE)
7084         goto bad_0;             /* :::::::::::::::::::: */
7085       break;
7086
7087     case FFELEX_typeNAMES:
7088       if (ffesta_first_kw != FFESTR_firstCONTINUE)
7089         goto bad_0;             /* :::::::::::::::::::: */
7090       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCONTINUE)
7091         {
7092           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCONTINUE);
7093           goto bad_i;           /* :::::::::::::::::::: */
7094         }
7095       break;
7096
7097     default:
7098       goto bad_0;               /* :::::::::::::::::::: */
7099     }
7100
7101   switch (ffelex_token_type (t))
7102     {
7103     case FFELEX_typeEOS:
7104     case FFELEX_typeSEMICOLON:
7105       ffesta_confirmed ();
7106       if (!ffesta_is_inhibited ())
7107         ffestc_R841 ();
7108       return (ffelexHandler) ffesta_zero (t);
7109
7110     case FFELEX_typeCOMMA:
7111     case FFELEX_typeCOLONCOLON:
7112       ffesta_confirmed ();      /* Error, but clearly intended. */
7113       goto bad_1;               /* :::::::::::::::::::: */
7114
7115     default:
7116       goto bad_1;               /* :::::::::::::::::::: */
7117     }
7118
7119 bad_0:                          /* :::::::::::::::::::: */
7120   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTINUE", ffesta_tokens[0]);
7121   return (ffelexHandler) ffelex_swallow_tokens (t,
7122                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
7123
7124 bad_1:                          /* :::::::::::::::::::: */
7125   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTINUE", t);
7126   return (ffelexHandler) ffelex_swallow_tokens (t,
7127                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7128
7129 bad_i:                          /* :::::::::::::::::::: */
7130   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CONTINUE", ffesta_tokens[0], i, t);
7131   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7132 }
7133
7134 /* ffestb_R1102 -- Parse the PROGRAM statement
7135
7136    return ffestb_R1102;  // to lexer
7137
7138    Make sure the statement has a valid form for the PROGRAM statement.  If it
7139    does, implement the statement.  */
7140
7141 ffelexHandler
7142 ffestb_R1102 (ffelexToken t)
7143 {
7144   ffeTokenLength i;
7145   char *p;
7146
7147   switch (ffelex_token_type (ffesta_tokens[0]))
7148     {
7149     case FFELEX_typeNAME:
7150       if (ffesta_first_kw != FFESTR_firstPROGRAM)
7151         goto bad_0;             /* :::::::::::::::::::: */
7152       switch (ffelex_token_type (t))
7153         {
7154         case FFELEX_typeEOS:
7155         case FFELEX_typeSEMICOLON:
7156         case FFELEX_typeCOMMA:
7157         case FFELEX_typeCOLONCOLON:
7158           ffesta_confirmed ();  /* Error, but clearly intended. */
7159           goto bad_1;           /* :::::::::::::::::::: */
7160
7161         default:
7162           goto bad_1;           /* :::::::::::::::::::: */
7163
7164         case FFELEX_typeNAME:
7165           break;
7166         }
7167
7168       ffesta_confirmed ();
7169       ffesta_tokens[1] = ffelex_token_use (t);
7170       return (ffelexHandler) ffestb_R11021_;
7171
7172     case FFELEX_typeNAMES:
7173       if (ffesta_first_kw != FFESTR_firstPROGRAM)
7174         goto bad_0;             /* :::::::::::::::::::: */
7175       switch (ffelex_token_type (t))
7176         {
7177         case FFELEX_typeCOMMA:
7178         case FFELEX_typeCOLONCOLON:
7179           ffesta_confirmed ();  /* Error, but clearly intended. */
7180           goto bad_1;           /* :::::::::::::::::::: */
7181
7182         default:
7183           goto bad_1;           /* :::::::::::::::::::: */
7184
7185         case FFELEX_typeEOS:
7186         case FFELEX_typeSEMICOLON:
7187           break;
7188         }
7189       ffesta_confirmed ();
7190       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlPROGRAM);
7191       if (!ffesrc_is_name_init (*p))
7192         goto bad_i;             /* :::::::::::::::::::: */
7193       ffesta_tokens[1]
7194         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
7195       return (ffelexHandler) ffestb_R11021_ (t);
7196
7197     default:
7198       goto bad_0;               /* :::::::::::::::::::: */
7199     }
7200
7201 bad_0:                          /* :::::::::::::::::::: */
7202   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", ffesta_tokens[0]);
7203   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7204
7205 bad_1:                          /* :::::::::::::::::::: */
7206   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", t);
7207   return (ffelexHandler) ffelex_swallow_tokens (t,
7208                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7209
7210 bad_i:                          /* :::::::::::::::::::: */
7211   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "PROGRAM", ffesta_tokens[0], i, t);
7212   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7213 }
7214
7215 /* ffestb_R11021_ -- "PROGRAM" NAME
7216
7217    return ffestb_R11021_;  // to lexer
7218
7219    Make sure the next token is an EOS or SEMICOLON.  */
7220
7221 static ffelexHandler
7222 ffestb_R11021_ (ffelexToken t)
7223 {
7224   switch (ffelex_token_type (t))
7225     {
7226     case FFELEX_typeEOS:
7227     case FFELEX_typeSEMICOLON:
7228       ffesta_confirmed ();
7229       if (!ffesta_is_inhibited ())
7230         ffestc_R1102 (ffesta_tokens[1]);
7231       ffelex_token_kill (ffesta_tokens[1]);
7232       return (ffelexHandler) ffesta_zero (t);
7233
7234     default:
7235       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", t);
7236       break;
7237     }
7238
7239   ffelex_token_kill (ffesta_tokens[1]);
7240   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7241 }
7242
7243 /* ffestb_block -- Parse the BLOCK DATA statement
7244
7245    return ffestb_block;  // to lexer
7246
7247    Make sure the statement has a valid form for the BLOCK DATA statement.  If
7248    it does, implement the statement.  */
7249
7250 ffelexHandler
7251 ffestb_block (ffelexToken t)
7252 {
7253   switch (ffelex_token_type (ffesta_tokens[0]))
7254     {
7255     case FFELEX_typeNAME:
7256       if (ffesta_first_kw != FFESTR_firstBLOCK)
7257         goto bad_0;             /* :::::::::::::::::::: */
7258       switch (ffelex_token_type (t))
7259         {
7260         default:
7261           goto bad_1;           /* :::::::::::::::::::: */
7262
7263         case FFELEX_typeNAME:
7264           if (ffesta_second_kw != FFESTR_secondDATA)
7265             goto bad_1;         /* :::::::::::::::::::: */
7266           break;
7267         }
7268
7269       ffesta_confirmed ();
7270       return (ffelexHandler) ffestb_R1111_1_;
7271
7272     default:
7273       goto bad_0;               /* :::::::::::::::::::: */
7274     }
7275
7276 bad_0:                          /* :::::::::::::::::::: */
7277   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0]);
7278   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7279
7280 bad_1:                          /* :::::::::::::::::::: */
7281   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7282   return (ffelexHandler) ffelex_swallow_tokens (t,
7283                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7284 }
7285
7286 /* ffestb_blockdata -- Parse the BLOCKDATA statement
7287
7288    return ffestb_blockdata;  // to lexer
7289
7290    Make sure the statement has a valid form for the BLOCKDATA statement.  If
7291    it does, implement the statement.  */
7292
7293 ffelexHandler
7294 ffestb_blockdata (ffelexToken t)
7295 {
7296   ffeTokenLength i;
7297   char *p;
7298
7299   switch (ffelex_token_type (ffesta_tokens[0]))
7300     {
7301     case FFELEX_typeNAME:
7302       if (ffesta_first_kw != FFESTR_firstBLOCKDATA)
7303         goto bad_0;             /* :::::::::::::::::::: */
7304       switch (ffelex_token_type (t))
7305         {
7306         case FFELEX_typeCOMMA:
7307         case FFELEX_typeCOLONCOLON:
7308           ffesta_confirmed ();  /* Error, but clearly intended. */
7309           goto bad_1;           /* :::::::::::::::::::: */
7310
7311         default:
7312           goto bad_1;           /* :::::::::::::::::::: */
7313
7314         case FFELEX_typeNAME:
7315           ffesta_confirmed ();
7316           ffesta_tokens[1] = ffelex_token_use (t);
7317           return (ffelexHandler) ffestb_R1111_2_;
7318
7319         case FFELEX_typeEOS:
7320         case FFELEX_typeSEMICOLON:
7321           ffesta_confirmed ();
7322           ffesta_tokens[1] = NULL;
7323           return (ffelexHandler) ffestb_R1111_2_ (t);
7324         }
7325
7326     case FFELEX_typeNAMES:
7327       if (ffesta_first_kw != FFESTR_firstBLOCKDATA)
7328         goto bad_0;             /* :::::::::::::::::::: */
7329       switch (ffelex_token_type (t))
7330         {
7331         default:
7332           goto bad_1;           /* :::::::::::::::::::: */
7333
7334         case FFELEX_typeEOS:
7335         case FFELEX_typeSEMICOLON:
7336           break;
7337         }
7338       ffesta_confirmed ();
7339       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlBLOCKDATA);
7340       if (*p == '\0')
7341         {
7342           ffesta_tokens[1] = NULL;
7343         }
7344       else
7345         {
7346           if (!ffesrc_is_name_init (*p))
7347             goto bad_i;         /* :::::::::::::::::::: */
7348           ffesta_tokens[1]
7349             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
7350         }
7351       return (ffelexHandler) ffestb_R1111_2_ (t);
7352
7353     default:
7354       goto bad_0;               /* :::::::::::::::::::: */
7355     }
7356
7357 bad_0:                          /* :::::::::::::::::::: */
7358   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0]);
7359   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7360
7361 bad_1:                          /* :::::::::::::::::::: */
7362   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7363   return (ffelexHandler) ffelex_swallow_tokens (t,
7364                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7365
7366 bad_i:                          /* :::::::::::::::::::: */
7367   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0], i, t);
7368   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7369 }
7370
7371 /* ffestb_R1111_1_ -- "BLOCK" "DATA"
7372
7373    return ffestb_R1111_1_;  // to lexer
7374
7375    Make sure the next token is a NAME, EOS, or SEMICOLON token.  */
7376
7377 static ffelexHandler
7378 ffestb_R1111_1_ (ffelexToken t)
7379 {
7380   switch (ffelex_token_type (t))
7381     {
7382     case FFELEX_typeNAME:
7383       ffesta_tokens[1] = ffelex_token_use (t);
7384       return (ffelexHandler) ffestb_R1111_2_;
7385
7386     case FFELEX_typeEOS:
7387     case FFELEX_typeSEMICOLON:
7388       ffesta_tokens[1] = NULL;
7389       return (ffelexHandler) ffestb_R1111_2_ (t);
7390
7391     default:
7392       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7393       break;
7394     }
7395
7396   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7397 }
7398
7399 /* ffestb_R1111_2_ -- "BLOCK/DATA" NAME
7400
7401    return ffestb_R1111_2_;  // to lexer
7402
7403    Make sure the next token is an EOS or SEMICOLON.  */
7404
7405 static ffelexHandler
7406 ffestb_R1111_2_ (ffelexToken t)
7407 {
7408   switch (ffelex_token_type (t))
7409     {
7410     case FFELEX_typeEOS:
7411     case FFELEX_typeSEMICOLON:
7412       ffesta_confirmed ();
7413       if (!ffesta_is_inhibited ())
7414         ffestc_R1111 (ffesta_tokens[1]);
7415       if (ffesta_tokens[1] != NULL)
7416         ffelex_token_kill (ffesta_tokens[1]);
7417       return (ffelexHandler) ffesta_zero (t);
7418
7419     default:
7420       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7421       break;
7422     }
7423
7424   if (ffesta_tokens[1] != NULL)
7425     ffelex_token_kill (ffesta_tokens[1]);
7426   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7427 }
7428
7429 /* ffestb_R1212 -- Parse the CALL statement
7430
7431    return ffestb_R1212;  // to lexer
7432
7433    Make sure the statement has a valid form for the CALL statement.  If it
7434    does, implement the statement.  */
7435
7436 ffelexHandler
7437 ffestb_R1212 (ffelexToken t)
7438 {
7439   ffeTokenLength i;
7440   char *p;
7441   ffelexHandler next;
7442   ffelexToken nt;
7443
7444   switch (ffelex_token_type (ffesta_tokens[0]))
7445     {
7446     case FFELEX_typeNAME:
7447       if (ffesta_first_kw != FFESTR_firstCALL)
7448         goto bad_0;             /* :::::::::::::::::::: */
7449       switch (ffelex_token_type (t))
7450         {
7451         case FFELEX_typeEOS:
7452         case FFELEX_typeSEMICOLON:
7453         case FFELEX_typeCOMMA:
7454         case FFELEX_typeCOLONCOLON:
7455           ffesta_confirmed ();  /* Error, but clearly intended. */
7456           goto bad_1;           /* :::::::::::::::::::: */
7457
7458         default:
7459           goto bad_1;           /* :::::::::::::::::::: */
7460
7461         case FFELEX_typeNAME:
7462           break;
7463         }
7464       ffesta_confirmed ();
7465       return (ffelexHandler)
7466         (*((ffelexHandler)
7467            ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextSUBROUTINEREF,
7468                         (ffeexprCallback) ffestb_R12121_)))
7469         (t);
7470
7471     case FFELEX_typeNAMES:
7472       if (ffesta_first_kw != FFESTR_firstCALL)
7473         goto bad_0;             /* :::::::::::::::::::: */
7474       switch (ffelex_token_type (t))
7475         {
7476         case FFELEX_typeCOLONCOLON:
7477         case FFELEX_typeCOMMA:
7478           ffesta_confirmed ();  /* Error, but clearly intended. */
7479           goto bad_1;           /* :::::::::::::::::::: */
7480
7481         default:
7482           goto bad_1;           /* :::::::::::::::::::: */
7483
7484         case FFELEX_typeOPEN_PAREN:
7485           break;
7486
7487         case FFELEX_typeEOS:
7488         case FFELEX_typeSEMICOLON:
7489           ffesta_confirmed ();
7490           break;
7491         }
7492       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCALL);
7493       if (!ffesrc_is_name_init (*p))
7494         goto bad_i;             /* :::::::::::::::::::: */
7495       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
7496       next = (ffelexHandler)
7497         (*((ffelexHandler)
7498            ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextSUBROUTINEREF,
7499                         (ffeexprCallback) ffestb_R12121_)))
7500         (nt);
7501       ffelex_token_kill (nt);
7502       return (ffelexHandler) (*next) (t);
7503
7504     default:
7505       goto bad_0;               /* :::::::::::::::::::: */
7506     }
7507
7508 bad_0:                          /* :::::::::::::::::::: */
7509   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", ffesta_tokens[0]);
7510   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7511
7512 bad_1:                          /* :::::::::::::::::::: */
7513   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", t);
7514   return (ffelexHandler) ffelex_swallow_tokens (t,
7515                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7516
7517 bad_i:                          /* :::::::::::::::::::: */
7518   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CALL", ffesta_tokens[0], i, t);
7519   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7520 }
7521
7522 /* ffestb_R12121_ -- "CALL" expr
7523
7524    (ffestb_R12121_)  // to expression handler
7525
7526    Make sure the statement has a valid form for the CALL statement.  If it
7527    does, implement the statement.  */
7528
7529 static ffelexHandler
7530 ffestb_R12121_ (ffelexToken ft, ffebld expr, ffelexToken t)
7531 {
7532   switch (ffelex_token_type (t))
7533     {
7534     case FFELEX_typeEOS:
7535     case FFELEX_typeSEMICOLON:
7536       ffesta_confirmed ();
7537       if (expr == NULL)
7538         break;
7539       if (!ffesta_is_inhibited ())
7540         ffestc_R1212 (expr, ft);
7541       return (ffelexHandler) ffesta_zero (t);
7542
7543     default:
7544       break;
7545     }
7546
7547   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", t);
7548   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7549 }
7550
7551 /* ffestb_R1227 -- Parse the RETURN statement
7552
7553    return ffestb_R1227;  // to lexer
7554
7555    Make sure the statement has a valid form for the RETURN statement.  If it
7556    does, implement the statement.  */
7557
7558 ffelexHandler
7559 ffestb_R1227 (ffelexToken t)
7560 {
7561   ffelexHandler next;
7562
7563   switch (ffelex_token_type (ffesta_tokens[0]))
7564     {
7565     case FFELEX_typeNAME:
7566       if (ffesta_first_kw != FFESTR_firstRETURN)
7567         goto bad_0;             /* :::::::::::::::::::: */
7568       switch (ffelex_token_type (t))
7569         {
7570         case FFELEX_typeCOMMA:
7571         case FFELEX_typeCOLONCOLON:
7572           ffesta_confirmed ();  /* Error, but clearly intended. */
7573           goto bad_1;           /* :::::::::::::::::::: */
7574
7575         case FFELEX_typeEQUALS:
7576         case FFELEX_typePOINTS:
7577         case FFELEX_typeCOLON:
7578           goto bad_1;           /* :::::::::::::::::::: */
7579
7580         case FFELEX_typeEOS:
7581         case FFELEX_typeSEMICOLON:
7582         case FFELEX_typeNAME:
7583         case FFELEX_typeNUMBER:
7584           ffesta_confirmed ();
7585           break;
7586
7587         default:
7588           break;
7589         }
7590
7591       return (ffelexHandler) (*((ffelexHandler)
7592                      ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextRETURN,
7593                                   (ffeexprCallback) ffestb_R12271_)))
7594         (t);
7595
7596     case FFELEX_typeNAMES:
7597       if (ffesta_first_kw != FFESTR_firstRETURN)
7598         goto bad_0;             /* :::::::::::::::::::: */
7599       switch (ffelex_token_type (t))
7600         {
7601         case FFELEX_typeCOMMA:
7602         case FFELEX_typeCOLONCOLON:
7603           ffesta_confirmed ();  /* Error, but clearly intended. */
7604           goto bad_1;           /* :::::::::::::::::::: */
7605
7606         case FFELEX_typeEQUALS:
7607         case FFELEX_typePOINTS:
7608         case FFELEX_typeCOLON:
7609           goto bad_1;           /* :::::::::::::::::::: */
7610
7611         case FFELEX_typeEOS:
7612         case FFELEX_typeSEMICOLON:
7613           ffesta_confirmed ();
7614           break;
7615
7616         default:
7617           break;
7618         }
7619       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
7620                    FFEEXPR_contextRETURN, (ffeexprCallback) ffestb_R12271_);
7621       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
7622                                                    FFESTR_firstlRETURN);
7623       if (next == NULL)
7624         return (ffelexHandler) ffelex_swallow_tokens (t,
7625                                                (ffelexHandler) ffesta_zero);
7626       return (ffelexHandler) (*next) (t);
7627
7628     default:
7629       goto bad_0;               /* :::::::::::::::::::: */
7630     }
7631
7632 bad_0:                          /* :::::::::::::::::::: */
7633   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", ffesta_tokens[0]);
7634   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7635
7636 bad_1:                          /* :::::::::::::::::::: */
7637   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", t);
7638   return (ffelexHandler) ffelex_swallow_tokens (t,
7639                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7640 }
7641
7642 /* ffestb_R12271_ -- "RETURN" expr
7643
7644    (ffestb_R12271_)  // to expression handler
7645
7646    Make sure the next token is an EOS or SEMICOLON.  */
7647
7648 static ffelexHandler
7649 ffestb_R12271_ (ffelexToken ft, ffebld expr, ffelexToken t)
7650 {
7651   switch (ffelex_token_type (t))
7652     {
7653     case FFELEX_typeEOS:
7654     case FFELEX_typeSEMICOLON:
7655       ffesta_confirmed ();
7656       if (!ffesta_is_inhibited ())
7657         ffestc_R1227 (expr, ft);
7658       return (ffelexHandler) ffesta_zero (t);
7659
7660     default:
7661       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", t);
7662       break;
7663     }
7664
7665   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7666 }
7667
7668 /* ffestb_R1228 -- Parse the CONTAINS statement
7669
7670    return ffestb_R1228;  // to lexer
7671
7672    Make sure the statement has a valid form for the CONTAINS statement.  If
7673    it does, implement the statement.  */
7674
7675 #if FFESTR_F90
7676 ffelexHandler
7677 ffestb_R1228 (ffelexToken t)
7678 {
7679   char *p;
7680   ffeTokenLength i;
7681
7682   switch (ffelex_token_type (ffesta_tokens[0]))
7683     {
7684     case FFELEX_typeNAME:
7685       if (ffesta_first_kw != FFESTR_firstCONTAINS)
7686         goto bad_0;             /* :::::::::::::::::::: */
7687       break;
7688
7689     case FFELEX_typeNAMES:
7690       if (ffesta_first_kw != FFESTR_firstCONTAINS)
7691         goto bad_0;             /* :::::::::::::::::::: */
7692       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCONTAINS)
7693         {
7694           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCONTAINS);
7695           goto bad_i;           /* :::::::::::::::::::: */
7696         }
7697       break;
7698
7699     default:
7700       goto bad_0;               /* :::::::::::::::::::: */
7701     }
7702
7703   switch (ffelex_token_type (t))
7704     {
7705     case FFELEX_typeEOS:
7706     case FFELEX_typeSEMICOLON:
7707       ffesta_confirmed ();
7708       if (!ffesta_is_inhibited ())
7709         ffestc_R1228 ();
7710       return (ffelexHandler) ffesta_zero (t);
7711
7712     case FFELEX_typeCOMMA:
7713     case FFELEX_typeCOLONCOLON:
7714       ffesta_confirmed ();      /* Error, but clearly intended. */
7715       goto bad_1;               /* :::::::::::::::::::: */
7716
7717     default:
7718       goto bad_1;               /* :::::::::::::::::::: */
7719     }
7720
7721 bad_0:                          /* :::::::::::::::::::: */
7722   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTAINS", ffesta_tokens[0]);
7723   return (ffelexHandler) ffelex_swallow_tokens (t,
7724                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
7725
7726 bad_1:                          /* :::::::::::::::::::: */
7727   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTAINS", t);
7728   return (ffelexHandler) ffelex_swallow_tokens (t,
7729                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7730
7731 bad_i:                          /* :::::::::::::::::::: */
7732   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CONTAINS", ffesta_tokens[0], i, t);
7733   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7734 }
7735
7736 #endif
7737 /* ffestb_V009 -- Parse the UNION statement
7738
7739    return ffestb_V009;  // to lexer
7740
7741    Make sure the statement has a valid form for the UNION statement.  If
7742    it does, implement the statement.  */
7743
7744 #if FFESTR_VXT
7745 ffelexHandler
7746 ffestb_V009 (ffelexToken t)
7747 {
7748   char *p;
7749   ffeTokenLength i;
7750
7751   switch (ffelex_token_type (ffesta_tokens[0]))
7752     {
7753     case FFELEX_typeNAME:
7754       if (ffesta_first_kw != FFESTR_firstUNION)
7755         goto bad_0;             /* :::::::::::::::::::: */
7756       break;
7757
7758     case FFELEX_typeNAMES:
7759       if (ffesta_first_kw != FFESTR_firstUNION)
7760         goto bad_0;             /* :::::::::::::::::::: */
7761       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlUNION)
7762         {
7763           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlUNION);
7764           goto bad_i;           /* :::::::::::::::::::: */
7765         }
7766       break;
7767
7768     default:
7769       goto bad_0;               /* :::::::::::::::::::: */
7770     }
7771
7772   switch (ffelex_token_type (t))
7773     {
7774     case FFELEX_typeEOS:
7775     case FFELEX_typeSEMICOLON:
7776       ffesta_confirmed ();
7777       if (!ffesta_is_inhibited ())
7778         ffestc_V009 ();
7779       return (ffelexHandler) ffesta_zero (t);
7780
7781     case FFELEX_typeCOMMA:
7782     case FFELEX_typeCOLONCOLON:
7783       ffesta_confirmed ();      /* Error, but clearly intended. */
7784       goto bad_1;               /* :::::::::::::::::::: */
7785
7786     default:
7787       goto bad_1;               /* :::::::::::::::::::: */
7788     }
7789
7790 bad_0:                          /* :::::::::::::::::::: */
7791   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "UNION", ffesta_tokens[0]);
7792   return (ffelexHandler) ffelex_swallow_tokens (t,
7793                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
7794
7795 bad_1:                          /* :::::::::::::::::::: */
7796   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "UNION", t);
7797   return (ffelexHandler) ffelex_swallow_tokens (t,
7798                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7799
7800 bad_i:                          /* :::::::::::::::::::: */
7801   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "UNION", ffesta_tokens[0], i, t);
7802   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7803 }
7804
7805 #endif
7806 /* ffestb_construct -- Parse a construct name
7807
7808    return ffestb_construct;  // to lexer
7809
7810    Make sure the statement can have a construct name (if-then-stmt, do-stmt,
7811    select-case-stmt).  */
7812
7813 ffelexHandler
7814 ffestb_construct (ffelexToken t UNUSED)
7815 {
7816   /* This handler gets invoked only when token 0 is NAME/NAMES and token 1 is
7817      COLON. */
7818
7819   ffesta_confirmed ();
7820   ffelex_set_names (TRUE);
7821   return (ffelexHandler) ffestb_construct1_;
7822 }
7823
7824 /* ffestb_construct1_ -- NAME COLON
7825
7826    return ffestb_construct1_;  // to lexer
7827
7828    Make sure we've got a NAME that is DO, DOWHILE, IF, SELECT, or SELECTCASE.  */
7829
7830 static ffelexHandler
7831 ffestb_construct1_ (ffelexToken t)
7832 {
7833   ffelex_set_names (FALSE);
7834
7835   switch (ffelex_token_type (t))
7836     {
7837     case FFELEX_typeNAME:
7838       ffesta_first_kw = ffestr_first (t);
7839       switch (ffesta_first_kw)
7840         {
7841         case FFESTR_firstIF:
7842           ffestb_local_.construct.next = (ffelexHandler) ffestb_if;
7843           break;
7844
7845         case FFESTR_firstDO:
7846           ffestb_local_.construct.next = (ffelexHandler) ffestb_do;
7847           break;
7848
7849         case FFESTR_firstDOWHILE:
7850           ffestb_local_.construct.next = (ffelexHandler) ffestb_dowhile;
7851           break;
7852
7853         case FFESTR_firstSELECT:
7854         case FFESTR_firstSELECTCASE:
7855           ffestb_local_.construct.next = (ffelexHandler) ffestb_R809;
7856           break;
7857
7858         default:
7859           goto bad;             /* :::::::::::::::::::: */
7860         }
7861       ffesta_construct_name = ffesta_tokens[0];
7862       ffesta_tokens[0] = ffelex_token_use (t);
7863       return (ffelexHandler) ffestb_construct2_;
7864
7865     case FFELEX_typeNAMES:
7866       ffesta_first_kw = ffestr_first (t);
7867       switch (ffesta_first_kw)
7868         {
7869         case FFESTR_firstIF:
7870           if (ffelex_token_length (t) != FFESTR_firstlIF)
7871             goto bad;           /* :::::::::::::::::::: */
7872           ffestb_local_.construct.next = (ffelexHandler) ffestb_if;
7873           break;
7874
7875         case FFESTR_firstDO:
7876           ffestb_local_.construct.next = (ffelexHandler) ffestb_do;
7877           break;
7878
7879         case FFESTR_firstDOWHILE:
7880           if (ffelex_token_length (t) != FFESTR_firstlDOWHILE)
7881             goto bad;           /* :::::::::::::::::::: */
7882           ffestb_local_.construct.next = (ffelexHandler) ffestb_dowhile;
7883           break;
7884
7885         case FFESTR_firstSELECTCASE:
7886           if (ffelex_token_length (t) != FFESTR_firstlSELECTCASE)
7887             goto bad;           /* :::::::::::::::::::: */
7888           ffestb_local_.construct.next = (ffelexHandler) ffestb_R809;
7889           break;
7890
7891         default:
7892           goto bad;             /* :::::::::::::::::::: */
7893         }
7894       ffesta_construct_name = ffesta_tokens[0];
7895       ffesta_tokens[0] = ffelex_token_use (t);
7896       return (ffelexHandler) ffestb_construct2_;
7897
7898     default:
7899       break;
7900     }
7901
7902 bad:                            /* :::::::::::::::::::: */
7903   ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
7904                      ffesta_tokens[0], t);
7905   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7906 }
7907
7908 /* ffestb_construct2_ -- NAME COLON "DO/DOWHILE/IF/SELECT/SELECTCASE"
7909
7910    return ffestb_construct2_;  // to lexer
7911
7912    This extra step is needed to set ffesta_second_kw if the second token
7913    (here) is a NAME, so DO and SELECT can continue to expect it.  */
7914
7915 static ffelexHandler
7916 ffestb_construct2_ (ffelexToken t)
7917 {
7918   if (ffelex_token_type (t) == FFELEX_typeNAME)
7919     ffesta_second_kw = ffestr_second (t);
7920   return (ffelexHandler) (*ffestb_local_.construct.next) (t);
7921 }
7922
7923 /* ffestb_heap -- Parse an ALLOCATE/DEALLOCATE statement
7924
7925    return ffestb_heap;  // to lexer
7926
7927    Make sure the statement has a valid form for an ALLOCATE/DEALLOCATE
7928    statement.  If it does, implement the statement.  */
7929
7930 #if FFESTR_F90
7931 ffelexHandler
7932 ffestb_heap (ffelexToken t)
7933 {
7934   switch (ffelex_token_type (ffesta_tokens[0]))
7935     {
7936     case FFELEX_typeNAME:
7937       break;
7938
7939     case FFELEX_typeNAMES:
7940       if (ffelex_token_length (ffesta_tokens[0]) != ffestb_args.heap.len)
7941         goto bad_0;             /* :::::::::::::::::::: */
7942       break;
7943
7944     default:
7945       goto bad_0;               /* :::::::::::::::::::: */
7946     }
7947
7948   switch (ffelex_token_type (t))
7949     {
7950     case FFELEX_typeOPEN_PAREN:
7951       break;
7952
7953     case FFELEX_typeEOS:
7954     case FFELEX_typeSEMICOLON:
7955     case FFELEX_typeCOMMA:
7956     case FFELEX_typeCOLONCOLON:
7957       ffesta_confirmed ();      /* Error, but clearly intended. */
7958       goto bad_1;               /* :::::::::::::::::::: */
7959
7960     default:
7961       goto bad_1;               /* :::::::::::::::::::: */
7962     }
7963
7964   ffestb_local_.heap.exprs = ffestt_exprlist_create ();
7965   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
7966                                       ffestb_args.heap.ctx,
7967                                       (ffeexprCallback) ffestb_heap1_);
7968
7969 bad_0:                          /* :::::::::::::::::::: */
7970   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, ffesta_tokens[0]);
7971   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7972
7973 bad_1:                          /* :::::::::::::::::::: */
7974   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
7975   return (ffelexHandler) ffelex_swallow_tokens (t,
7976                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7977 }
7978
7979 /* ffestb_heap1_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr
7980
7981    (ffestb_heap1_)  // to expression handler
7982
7983    Make sure the next token is COMMA.  */
7984
7985 static ffelexHandler
7986 ffestb_heap1_ (ffelexToken ft, ffebld expr, ffelexToken t)
7987 {
7988   switch (ffelex_token_type (t))
7989     {
7990     case FFELEX_typeCOMMA:
7991       if (expr == NULL)
7992         break;
7993       ffestt_exprlist_append (ffestb_local_.heap.exprs, expr,
7994                               ffelex_token_use (t));
7995       return (ffelexHandler) ffestb_heap2_;
7996
7997     case FFELEX_typeCLOSE_PAREN:
7998       if (expr == NULL)
7999         break;
8000       ffestt_exprlist_append (ffestb_local_.heap.exprs, expr,
8001                               ffelex_token_use (t));
8002       ffesta_tokens[1] = NULL;
8003       ffestb_local_.heap.expr = NULL;
8004       return (ffelexHandler) ffestb_heap5_;
8005
8006     default:
8007       break;
8008     }
8009
8010   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8011   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8012   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8013 }
8014
8015 /* ffestb_heap2_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr COMMA
8016
8017    return ffestb_heap2_;  // to lexer
8018
8019    Make sure the next token is NAME.  */
8020
8021 static ffelexHandler
8022 ffestb_heap2_ (ffelexToken t)
8023 {
8024   switch (ffelex_token_type (t))
8025     {
8026     case FFELEX_typeNAME:
8027       ffesta_tokens[1] = ffelex_token_use (t);
8028       return (ffelexHandler) ffestb_heap3_;
8029
8030     default:
8031       break;
8032     }
8033
8034   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8035   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8036   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8037 }
8038
8039 /* ffestb_heap3_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr COMMA NAME
8040
8041    return ffestb_heap3_;  // to lexer
8042
8043    If token is EQUALS, make sure NAME was "STAT" and handle STAT variable;
8044    else pass NAME and token to expression handler.  */
8045
8046 static ffelexHandler
8047 ffestb_heap3_ (ffelexToken t)
8048 {
8049   ffelexHandler next;
8050
8051   switch (ffelex_token_type (t))
8052     {
8053     case FFELEX_typeEQUALS:
8054       ffesta_confirmed ();
8055       if (ffestr_other (ffesta_tokens[1]) != FFESTR_otherSTAT)
8056         break;
8057       ffelex_token_kill (ffesta_tokens[1]);
8058       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
8059                                           FFEEXPR_contextHEAPSTAT,
8060                                           (ffeexprCallback) ffestb_heap4_);
8061
8062     default:
8063       next = (ffelexHandler)
8064         (*((ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
8065                                         ffestb_args.heap.ctx,
8066                                         (ffeexprCallback) ffestb_heap1_)))
8067         (ffesta_tokens[1]);
8068       ffelex_token_kill (ffesta_tokens[1]);
8069       return (ffelexHandler) (*next) (t);
8070     }
8071
8072   ffelex_token_kill (ffesta_tokens[1]);
8073   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8074   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8075   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8076 }
8077
8078 /* ffestb_heap4_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN ... COMMA "STAT" EQUALS
8079                     expr
8080
8081    (ffestb_heap4_)  // to expression handler
8082
8083    Make sure the next token is CLOSE_PAREN.  */
8084
8085 static ffelexHandler
8086 ffestb_heap4_ (ffelexToken ft, ffebld expr, ffelexToken t)
8087 {
8088   switch (ffelex_token_type (t))
8089     {
8090     case FFELEX_typeCLOSE_PAREN:
8091       if (expr == NULL)
8092         break;
8093       ffesta_tokens[1] = ffelex_token_use (ft);
8094       ffestb_local_.heap.expr = expr;
8095       return (ffelexHandler) ffestb_heap5_;
8096
8097     default:
8098       break;
8099     }
8100
8101   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8102   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8103   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8104 }
8105
8106 /* ffestb_heap5_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN ... CLOSE_PAREN
8107
8108    return ffestb_heap5_;  // to lexer
8109
8110    Make sure the next token is EOS/SEMICOLON.  */
8111
8112 static ffelexHandler
8113 ffestb_heap5_ (ffelexToken t)
8114 {
8115   switch (ffelex_token_type (t))
8116     {
8117     case FFELEX_typeEOS:
8118     case FFELEX_typeSEMICOLON:
8119       ffesta_confirmed ();
8120       if (!ffesta_is_inhibited ())
8121         if (ffesta_first_kw == FFESTR_firstALLOCATE)
8122           ffestc_R620 (ffestb_local_.heap.exprs, ffestb_local_.heap.expr,
8123                        ffesta_tokens[1]);
8124         else
8125           ffestc_R625 (ffestb_local_.heap.exprs, ffestb_local_.heap.expr,
8126                        ffesta_tokens[1]);
8127       ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8128       if (ffesta_tokens[1] != NULL)
8129         ffelex_token_kill (ffesta_tokens[1]);
8130       return (ffelexHandler) ffesta_zero (t);
8131
8132     default:
8133       break;
8134     }
8135
8136   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8137   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8138   if (ffesta_tokens[1] != NULL)
8139     ffelex_token_kill (ffesta_tokens[1]);
8140   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8141 }
8142
8143 #endif
8144 /* ffestb_module -- Parse the MODULEPROCEDURE statement
8145
8146    return ffestb_module;  // to lexer
8147
8148    Make sure the statement has a valid form for the MODULEPROCEDURE statement.
8149    If it does, implement the statement.
8150
8151    31-May-90  JCB  1.1
8152       Confirm NAME==MODULE followed by standard four invalid tokens, so we
8153       get decent message if somebody forgets that MODULE requires a name.  */
8154
8155 #if FFESTR_F90
8156 ffelexHandler
8157 ffestb_module (ffelexToken t)
8158 {
8159   ffeTokenLength i;
8160   char *p;
8161   ffelexToken nt;
8162   ffelexToken mt;               /* Name in MODULE PROCEDUREname, i.e.
8163                                    includes "PROCEDURE". */
8164
8165   switch (ffelex_token_type (ffesta_tokens[0]))
8166     {
8167     case FFELEX_typeNAME:
8168       if (ffesta_first_kw != FFESTR_firstMODULE)
8169         goto bad_0;             /* :::::::::::::::::::: */
8170       switch (ffelex_token_type (t))
8171         {
8172         case FFELEX_typeNAME:
8173           break;
8174
8175         case FFELEX_typeCOLONCOLON:
8176         case FFELEX_typeCOMMA:
8177         case FFELEX_typeEOS:
8178         case FFELEX_typeSEMICOLON:
8179           ffesta_confirmed ();
8180           goto bad_1m;          /* :::::::::::::::::::: */
8181
8182         default:
8183           goto bad_1m;          /* :::::::::::::::::::: */
8184         }
8185
8186       ffesta_confirmed ();
8187       if (ffesta_second_kw != FFESTR_secondPROCEDURE)
8188         {
8189           ffesta_tokens[1] = ffelex_token_use (t);
8190           return (ffelexHandler) ffestb_module3_;
8191         }
8192       ffestb_local_.moduleprocedure.started = FALSE;
8193       ffesta_tokens[1] = ffelex_token_use (t);
8194       return (ffelexHandler) ffestb_module1_;
8195
8196     case FFELEX_typeNAMES:
8197       p = ffelex_token_text (ffesta_tokens[0])
8198         + (i = FFESTR_firstlMODULEPROCEDURE);
8199       if ((ffesta_first_kw == FFESTR_firstMODULE)
8200           || ((ffesta_first_kw == FFESTR_firstMODULEPROCEDURE)
8201               && !ffesrc_is_name_init (*p)))
8202         {                       /* Definitely not "MODULE PROCEDURE name". */
8203           switch (ffelex_token_type (t))
8204             {
8205             case FFELEX_typeCOMMA:
8206             case FFELEX_typeCOLONCOLON:
8207               ffesta_confirmed ();      /* Error, but clearly intended. */
8208               goto bad_1m;      /* :::::::::::::::::::: */
8209
8210             default:
8211               goto bad_1m;      /* :::::::::::::::::::: */
8212
8213             case FFELEX_typeEOS:
8214             case FFELEX_typeSEMICOLON:
8215               ffesta_confirmed ();
8216               break;
8217             }
8218           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlMODULE);
8219           if (!ffesrc_is_name_init (*p))
8220             goto bad_im;        /* :::::::::::::::::::: */
8221           nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
8222           if (!ffesta_is_inhibited ())
8223             ffestc_R1105 (nt);
8224           ffelex_token_kill (nt);
8225           return (ffelexHandler) ffesta_zero (t);
8226         }
8227
8228       /* Here we know that we're indeed looking at a MODULEPROCEDURE
8229          statement rather than MODULE and that the character following
8230          MODULEPROCEDURE in the NAMES token is a valid first character for a
8231          NAME.  This means that unless the second token is COMMA, we have an
8232          ambiguous statement that can be read either as MODULE PROCEDURE name
8233          or MODULE PROCEDUREname, the former being an R1205, the latter an
8234          R1105. */
8235
8236       if (ffesta_first_kw != FFESTR_firstMODULEPROCEDURE)
8237         goto bad_0;             /* :::::::::::::::::::: */
8238       switch (ffelex_token_type (t))
8239         {
8240         case FFELEX_typeCOLONCOLON:
8241           ffesta_confirmed ();  /* Error, but clearly intended. */
8242           goto bad_1;           /* :::::::::::::::::::: */
8243
8244         default:
8245           goto bad_1;           /* :::::::::::::::::::: */
8246
8247         case FFELEX_typeCOMMA:  /* Aha, clearly not MODULE PROCEDUREname. */
8248           ffesta_confirmed ();
8249           ffestb_local_.moduleprocedure.started = FALSE;
8250           ffesta_tokens[1]
8251             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
8252           return (ffelexHandler) ffestb_module2_ (t);
8253
8254         case FFELEX_typeEOS:    /* MODULE PROCEDURE name or MODULE
8255                                    PROCEDUREname. */
8256         case FFELEX_typeSEMICOLON:
8257           ffesta_confirmed ();
8258           break;
8259         }
8260       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
8261       mt = ffelex_token_name_from_names (ffesta_tokens[0], FFESTR_firstlMODULE,
8262                                          0);
8263       if (!ffesta_is_inhibited ())
8264         ffestc_module (mt, nt); /* Implement ambiguous statement. */
8265       ffelex_token_kill (nt);
8266       ffelex_token_kill (mt);
8267       return (ffelexHandler) ffesta_zero (t);
8268
8269     default:
8270       goto bad_0;               /* :::::::::::::::::::: */
8271     }
8272
8273 bad_0:                          /* :::::::::::::::::::: */
8274   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", ffesta_tokens[0]);
8275   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8276
8277 bad_1:                          /* :::::::::::::::::::: */
8278   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
8279   return (ffelexHandler) ffelex_swallow_tokens (t,
8280                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
8281
8282 bad_1m:                 /* :::::::::::::::::::: */
8283   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE", t);
8284   return (ffelexHandler) ffelex_swallow_tokens (t,
8285                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
8286
8287 bad_im:                 /* :::::::::::::::::::: */
8288   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "MODULE", ffesta_tokens[0], i, t);
8289   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8290 }
8291
8292 /* ffestb_module1_ -- "MODULEPROCEDURE" or "MODULE" "PROCEDURE"
8293
8294    return ffestb_module1_;  // to lexer
8295
8296    Make sure the statement has a valid form for the MODULEPROCEDURE statement.  If it
8297    does, implement the statement.  */
8298
8299 static ffelexHandler
8300 ffestb_module1_ (ffelexToken t)
8301 {
8302   switch (ffelex_token_type (t))
8303     {
8304     case FFELEX_typeNAME:
8305       if (!ffestb_local_.moduleprocedure.started
8306           && (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME))
8307         {
8308           ffesta_confirmed ();
8309           ffelex_token_kill (ffesta_tokens[1]);
8310         }
8311       ffesta_tokens[1] = ffelex_token_use (t);
8312       return (ffelexHandler) ffestb_module2_;
8313
8314     case FFELEX_typeEOS:
8315     case FFELEX_typeSEMICOLON:
8316       if (ffestb_local_.moduleprocedure.started)
8317         break;                  /* Error if we've already seen NAME COMMA. */
8318       ffesta_confirmed ();
8319       if (!ffesta_is_inhibited ())
8320         ffestc_R1105 (ffesta_tokens[1]);
8321       ffelex_token_kill (ffesta_tokens[1]);
8322       return (ffelexHandler) ffesta_zero (t);
8323
8324     case FFELEX_typeCOMMA:
8325     case FFELEX_typeCOLONCOLON:
8326       ffesta_confirmed ();      /* Error, but clearly intended. */
8327       break;
8328
8329     default:
8330       break;
8331     }
8332
8333   if (ffestb_local_.moduleprocedure.started && !ffesta_is_inhibited ())
8334     ffestc_R1205_finish ();
8335   else if (!ffestb_local_.moduleprocedure.started)
8336     ffelex_token_kill (ffesta_tokens[1]);
8337   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
8338   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8339 }
8340
8341 /* ffestb_module2_ -- "MODULE/PROCEDURE" NAME
8342
8343    return ffestb_module2_;  // to lexer
8344
8345    Make sure the statement has a valid form for the MODULEPROCEDURE statement.  If it
8346    does, implement the statement.  */
8347
8348 static ffelexHandler
8349 ffestb_module2_ (ffelexToken t)
8350 {
8351   switch (ffelex_token_type (t))
8352     {
8353     case FFELEX_typeEOS:
8354     case FFELEX_typeSEMICOLON:
8355       if (!ffestb_local_.moduleprocedure.started)
8356         {
8357           ffesta_confirmed ();
8358           if (!ffesta_is_inhibited ())
8359             ffestc_R1205_start ();
8360         }
8361       if (!ffesta_is_inhibited ())
8362         {
8363           ffestc_R1205_item (ffesta_tokens[1]);
8364           ffestc_R1205_finish ();
8365         }
8366       ffelex_token_kill (ffesta_tokens[1]);
8367       return (ffelexHandler) ffesta_zero (t);
8368
8369     case FFELEX_typeCOMMA:
8370       if (!ffestb_local_.moduleprocedure.started)
8371         {
8372           ffestb_local_.moduleprocedure.started = TRUE;
8373           ffesta_confirmed ();
8374           if (!ffesta_is_inhibited ())
8375             ffestc_R1205_start ();
8376         }
8377       if (!ffesta_is_inhibited ())
8378         ffestc_R1205_item (ffesta_tokens[1]);
8379       ffelex_token_kill (ffesta_tokens[1]);
8380       return (ffelexHandler) ffestb_module1_;
8381
8382     default:
8383       break;
8384     }
8385
8386   if (ffestb_local_.moduleprocedure.started && !ffesta_is_inhibited ())
8387     ffestc_R1205_finish ();
8388   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
8389   ffelex_token_kill (ffesta_tokens[1]);
8390   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8391 }
8392
8393 /* ffestb_module3_ -- "MODULE" NAME
8394
8395    return ffestb_module3_;  // to lexer
8396
8397    Make sure the statement has a valid form for the MODULE statement.  If it
8398    does, implement the statement.  */
8399
8400 static ffelexHandler
8401 ffestb_module3_ (ffelexToken t)
8402 {
8403   switch (ffelex_token_type (t))
8404     {
8405     case FFELEX_typeEOS:
8406     case FFELEX_typeSEMICOLON:
8407       if (!ffesta_is_inhibited ())
8408         ffestc_R1105 (ffesta_tokens[1]);
8409       ffelex_token_kill (ffesta_tokens[1]);
8410       return (ffelexHandler) ffesta_zero (t);
8411
8412     default:
8413       break;
8414     }
8415
8416   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE", t);
8417   ffelex_token_kill (ffesta_tokens[1]);
8418   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8419 }
8420
8421 #endif
8422 /* ffestb_R809 -- Parse the SELECTCASE statement
8423
8424    return ffestb_R809;  // to lexer
8425
8426    Make sure the statement has a valid form for the SELECTCASE statement.
8427    If it does, implement the statement.  */
8428
8429 ffelexHandler
8430 ffestb_R809 (ffelexToken t)
8431 {
8432   ffeTokenLength i;
8433   char *p;
8434
8435   switch (ffelex_token_type (ffesta_tokens[0]))
8436     {
8437     case FFELEX_typeNAME:
8438       switch (ffesta_first_kw)
8439         {
8440         case FFESTR_firstSELECT:
8441           if ((ffelex_token_type (t) != FFELEX_typeNAME)
8442               || (ffesta_second_kw != FFESTR_secondCASE))
8443             goto bad_1;         /* :::::::::::::::::::: */
8444           ffesta_confirmed ();
8445           return (ffelexHandler) ffestb_R8091_;
8446
8447         case FFESTR_firstSELECTCASE:
8448           return (ffelexHandler) ffestb_R8091_ (t);
8449
8450         default:
8451           goto bad_0;           /* :::::::::::::::::::: */
8452         }
8453
8454     case FFELEX_typeNAMES:
8455       if (ffesta_first_kw != FFESTR_firstSELECTCASE)
8456         goto bad_0;             /* :::::::::::::::::::: */
8457       switch (ffelex_token_type (t))
8458         {
8459         case FFELEX_typeCOMMA:
8460         case FFELEX_typeEOS:
8461         case FFELEX_typeSEMICOLON:
8462         case FFELEX_typeCOLONCOLON:
8463           ffesta_confirmed ();  /* Error, but clearly intended. */
8464           goto bad_1;           /* :::::::::::::::::::: */
8465
8466         default:
8467           goto bad_1;           /* :::::::::::::::::::: */
8468
8469         case FFELEX_typeOPEN_PAREN:
8470           break;
8471         }
8472       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSELECTCASE);
8473       if (*p != '\0')
8474         goto bad_i;             /* :::::::::::::::::::: */
8475       return (ffelexHandler) ffestb_R8091_ (t);
8476
8477     default:
8478       goto bad_0;               /* :::::::::::::::::::: */
8479     }
8480
8481 bad_0:                          /* :::::::::::::::::::: */
8482   if (ffesta_construct_name != NULL)
8483     {
8484       ffelex_token_kill (ffesta_construct_name);
8485       ffesta_construct_name = NULL;
8486     }
8487   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", ffesta_tokens[0]);
8488   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8489
8490 bad_1:                          /* :::::::::::::::::::: */
8491   if (ffesta_construct_name != NULL)
8492     {
8493       ffelex_token_kill (ffesta_construct_name);
8494       ffesta_construct_name = NULL;
8495     }
8496   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8497   return (ffelexHandler) ffelex_swallow_tokens (t,
8498                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
8499
8500 bad_i:                          /* :::::::::::::::::::: */
8501   if (ffesta_construct_name != NULL)
8502     {
8503       ffelex_token_kill (ffesta_construct_name);
8504       ffesta_construct_name = NULL;
8505     }
8506   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", ffesta_tokens[0], i, t);
8507   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8508 }
8509
8510 /* ffestb_R8091_ -- "SELECTCASE" or "SELECT" "CASE"
8511
8512    return ffestb_R8091_;  // to lexer
8513
8514    Make sure the statement has a valid form for the SELECTCASE statement.  If it
8515    does, implement the statement.  */
8516
8517 static ffelexHandler
8518 ffestb_R8091_ (ffelexToken t)
8519 {
8520   switch (ffelex_token_type (t))
8521     {
8522     case FFELEX_typeOPEN_PAREN:
8523       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8524                 FFEEXPR_contextSELECTCASE, (ffeexprCallback) ffestb_R8092_);
8525
8526     case FFELEX_typeEOS:
8527     case FFELEX_typeSEMICOLON:
8528     case FFELEX_typeCOMMA:
8529     case FFELEX_typeCOLONCOLON:
8530       ffesta_confirmed ();      /* Error, but clearly intended. */
8531       break;
8532
8533     default:
8534       break;
8535     }
8536
8537   if (ffesta_construct_name != NULL)
8538     {
8539       ffelex_token_kill (ffesta_construct_name);
8540       ffesta_construct_name = NULL;
8541     }
8542   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8543   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8544 }
8545
8546 /* ffestb_R8092_ -- "SELECT/CASE" OPEN_PAREN expr
8547
8548    (ffestb_R8092_)  // to expression handler
8549
8550    Make sure the statement has a valid form for the SELECTCASE statement.  If it
8551    does, implement the statement.  */
8552
8553 static ffelexHandler
8554 ffestb_R8092_ (ffelexToken ft, ffebld expr, ffelexToken t)
8555 {
8556   switch (ffelex_token_type (t))
8557     {
8558     case FFELEX_typeCLOSE_PAREN:
8559       if (expr == NULL)
8560         break;
8561       ffesta_tokens[1] = ffelex_token_use (ft);
8562       ffestb_local_.selectcase.expr = expr;
8563       return (ffelexHandler) ffestb_R8093_;
8564
8565     default:
8566       break;
8567     }
8568
8569   if (ffesta_construct_name != NULL)
8570     {
8571       ffelex_token_kill (ffesta_construct_name);
8572       ffesta_construct_name = NULL;
8573     }
8574   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8575   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8576 }
8577
8578 /* ffestb_R8093_ -- "SELECT/CASE" OPEN_PAREN expr CLOSE_PAREN
8579
8580    return ffestb_R8093_;  // to lexer
8581
8582    Make sure the statement has a valid form for the SELECTCASE statement.  If it
8583    does, implement the statement.  */
8584
8585 static ffelexHandler
8586 ffestb_R8093_ (ffelexToken t)
8587 {
8588   switch (ffelex_token_type (t))
8589     {
8590     case FFELEX_typeEOS:
8591     case FFELEX_typeSEMICOLON:
8592       ffesta_confirmed ();
8593       if (!ffesta_is_inhibited ())
8594         ffestc_R809 (ffesta_construct_name, ffestb_local_.selectcase.expr,
8595                      ffesta_tokens[1]);
8596       ffelex_token_kill (ffesta_tokens[1]);
8597       if (ffesta_construct_name != NULL)
8598         {
8599           ffelex_token_kill (ffesta_construct_name);
8600           ffesta_construct_name = NULL;
8601         }
8602       return ffesta_zero (t);
8603
8604     case FFELEX_typeCOMMA:
8605     case FFELEX_typeCOLONCOLON:
8606       ffesta_confirmed ();      /* Error, but clearly intended. */
8607       break;
8608
8609     default:
8610       break;
8611     }
8612
8613   ffelex_token_kill (ffesta_tokens[1]);
8614   if (ffesta_construct_name != NULL)
8615     {
8616       ffelex_token_kill (ffesta_construct_name);
8617       ffesta_construct_name = NULL;
8618     }
8619   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8620   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8621 }
8622
8623 /* ffestb_R810 -- Parse the CASE statement
8624
8625    return ffestb_R810;  // to lexer
8626
8627    Make sure the statement has a valid form for the CASE statement.
8628    If it does, implement the statement.  */
8629
8630 ffelexHandler
8631 ffestb_R810 (ffelexToken t)
8632 {
8633   ffeTokenLength i;
8634   char *p;
8635
8636   switch (ffelex_token_type (ffesta_tokens[0]))
8637     {
8638     case FFELEX_typeNAME:
8639       if (ffesta_first_kw != FFESTR_firstCASE)
8640         goto bad_0;             /* :::::::::::::::::::: */
8641       switch (ffelex_token_type (t))
8642         {
8643         case FFELEX_typeCOMMA:
8644         case FFELEX_typeEOS:
8645         case FFELEX_typeSEMICOLON:
8646         case FFELEX_typeCOLONCOLON:
8647           ffesta_confirmed ();  /* Error, but clearly intended. */
8648           goto bad_1;           /* :::::::::::::::::::: */
8649
8650         default:
8651           goto bad_1;           /* :::::::::::::::::::: */
8652
8653         case FFELEX_typeNAME:
8654           ffesta_confirmed ();
8655           if (ffesta_second_kw != FFESTR_secondDEFAULT)
8656             goto bad_1;         /* :::::::::::::::::::: */
8657           ffestb_local_.case_stmt.cases = NULL;
8658           return (ffelexHandler) ffestb_R8101_;
8659
8660         case FFELEX_typeOPEN_PAREN:
8661           ffestb_local_.case_stmt.cases = ffestt_caselist_create ();
8662           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8663                       FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8664         }
8665
8666     case FFELEX_typeNAMES:
8667       switch (ffesta_first_kw)
8668         {
8669         case FFESTR_firstCASEDEFAULT:
8670           switch (ffelex_token_type (t))
8671             {
8672             case FFELEX_typeCOMMA:
8673             case FFELEX_typeCOLONCOLON:
8674               ffesta_confirmed ();      /* Error, but clearly intended. */
8675               goto bad_1;       /* :::::::::::::::::::: */
8676
8677             default:
8678               goto bad_1;       /* :::::::::::::::::::: */
8679
8680             case FFELEX_typeEOS:
8681             case FFELEX_typeSEMICOLON:
8682               ffesta_confirmed ();
8683               break;
8684             }
8685           ffestb_local_.case_stmt.cases = NULL;
8686           p = ffelex_token_text (ffesta_tokens[0])
8687             + (i = FFESTR_firstlCASEDEFAULT);
8688           if (*p == '\0')
8689             return (ffelexHandler) ffestb_R8101_ (t);
8690           if (!ffesrc_is_name_init (*p))
8691             goto bad_i;         /* :::::::::::::::::::: */
8692           ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i,
8693                                                            0);
8694           return (ffelexHandler) ffestb_R8102_ (t);
8695
8696         case FFESTR_firstCASE:
8697           break;
8698
8699         default:
8700           goto bad_0;           /* :::::::::::::::::::: */
8701         }
8702
8703       switch (ffelex_token_type (t))
8704         {
8705         case FFELEX_typeCOMMA:
8706         case FFELEX_typeEOS:
8707         case FFELEX_typeSEMICOLON:
8708         case FFELEX_typeCOLONCOLON:
8709           ffesta_confirmed ();  /* Error, but clearly intended. */
8710           goto bad_1;           /* :::::::::::::::::::: */
8711
8712         default:
8713           goto bad_1;           /* :::::::::::::::::::: */
8714
8715         case FFELEX_typeOPEN_PAREN:
8716           break;
8717         }
8718       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCASE);
8719       if (*p != '\0')
8720         goto bad_i;             /* :::::::::::::::::::: */
8721       ffestb_local_.case_stmt.cases = ffestt_caselist_create ();
8722       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8723                       FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8724
8725     default:
8726       goto bad_0;               /* :::::::::::::::::::: */
8727     }
8728
8729 bad_0:                          /* :::::::::::::::::::: */
8730   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", ffesta_tokens[0]);
8731   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8732
8733 bad_1:                          /* :::::::::::::::::::: */
8734   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8735   return (ffelexHandler) ffelex_swallow_tokens (t,
8736                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
8737
8738 bad_i:                          /* :::::::::::::::::::: */
8739   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CASE", ffesta_tokens[0], i, t);
8740   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8741 }
8742
8743 /* ffestb_R8101_ -- "CASE" case-selector
8744
8745    return ffestb_R8101_;  // to lexer
8746
8747    Make sure the statement has a valid form for the CASE statement.  If it
8748    does, implement the statement.  */
8749
8750 static ffelexHandler
8751 ffestb_R8101_ (ffelexToken t)
8752 {
8753   switch (ffelex_token_type (t))
8754     {
8755     case FFELEX_typeNAME:
8756       ffesta_tokens[1] = ffelex_token_use (t);
8757       return (ffelexHandler) ffestb_R8102_;
8758
8759     case FFELEX_typeEOS:
8760     case FFELEX_typeSEMICOLON:
8761       ffesta_tokens[1] = NULL;
8762       return (ffelexHandler) ffestb_R8102_ (t);
8763
8764     case FFELEX_typeCOMMA:
8765     case FFELEX_typeCOLONCOLON:
8766       ffesta_confirmed ();      /* Error, but clearly intended. */
8767       break;
8768
8769     default:
8770       break;
8771     }
8772
8773   if (ffestb_local_.case_stmt.cases != NULL)
8774     ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8775   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8776   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8777 }
8778
8779 /* ffestb_R8102_ -- "CASE" case-selector [NAME]
8780
8781    return ffestb_R8102_;  // to lexer
8782
8783    Make sure the statement has a valid form for the CASE statement.  If it
8784    does, implement the statement.  */
8785
8786 static ffelexHandler
8787 ffestb_R8102_ (ffelexToken t)
8788 {
8789   switch (ffelex_token_type (t))
8790     {
8791     case FFELEX_typeEOS:
8792     case FFELEX_typeSEMICOLON:
8793       ffesta_confirmed ();
8794       if (!ffesta_is_inhibited ())
8795         ffestc_R810 (ffestb_local_.case_stmt.cases, ffesta_tokens[1]);
8796       if (ffestb_local_.case_stmt.cases != NULL)
8797         ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8798       if (ffesta_tokens[1] != NULL)
8799         ffelex_token_kill (ffesta_tokens[1]);
8800       return (ffelexHandler) ffesta_zero (t);
8801
8802     case FFELEX_typeCOMMA:
8803     case FFELEX_typeCOLONCOLON:
8804       ffesta_confirmed ();      /* Error, but clearly intended. */
8805       break;
8806
8807     default:
8808       break;
8809     }
8810
8811   if (ffestb_local_.case_stmt.cases != NULL)
8812     ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8813   if (ffesta_tokens[1] != NULL)
8814     ffelex_token_kill (ffesta_tokens[1]);
8815   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8816   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8817 }
8818
8819 /* ffestb_R8103_ -- "CASE" OPEN_PAREN expr
8820
8821    (ffestb_R8103_)  // to expression handler
8822
8823    Make sure the statement has a valid form for the CASE statement.  If it
8824    does, implement the statement.  */
8825
8826 static ffelexHandler
8827 ffestb_R8103_ (ffelexToken ft, ffebld expr, ffelexToken t)
8828 {
8829   switch (ffelex_token_type (t))
8830     {
8831     case FFELEX_typeCLOSE_PAREN:
8832       ffestt_caselist_append (ffestb_local_.case_stmt.cases, FALSE, expr, NULL,
8833                               ffelex_token_use (ft));
8834       return (ffelexHandler) ffestb_R8101_;
8835
8836     case FFELEX_typeCOMMA:
8837       ffestt_caselist_append (ffestb_local_.case_stmt.cases, FALSE, expr, NULL,
8838                               ffelex_token_use (ft));
8839       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8840                       FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8841
8842     case FFELEX_typeCOLON:
8843       ffestt_caselist_append (ffestb_local_.case_stmt.cases, TRUE, expr, NULL,
8844                               ffelex_token_use (ft));   /* NULL second expr for
8845                                                            now, just plug in. */
8846       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8847                       FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8104_);
8848
8849     default:
8850       break;
8851     }
8852
8853   ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8854   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8855   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8856 }
8857
8858 /* ffestb_R8104_ -- "CASE" OPEN_PAREN expr COLON expr
8859
8860    (ffestb_R8104_)  // to expression handler
8861
8862    Make sure the statement has a valid form for the CASE statement.  If it
8863    does, implement the statement.  */
8864
8865 static ffelexHandler
8866 ffestb_R8104_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
8867 {
8868   switch (ffelex_token_type (t))
8869     {
8870     case FFELEX_typeCLOSE_PAREN:
8871       ffestb_local_.case_stmt.cases->previous->expr2 = expr;
8872       return (ffelexHandler) ffestb_R8101_;
8873
8874     case FFELEX_typeCOMMA:
8875       ffestb_local_.case_stmt.cases->previous->expr2 = expr;
8876       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8877                       FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8878
8879     default:
8880       break;
8881     }
8882
8883   ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8884   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8885   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8886 }
8887
8888 /* ffestb_R1001 -- Parse a FORMAT statement
8889
8890    return ffestb_R1001;  // to lexer
8891
8892    Make sure the statement has a valid form for an FORMAT statement.
8893    If it does, implement the statement.  */
8894
8895 ffelexHandler
8896 ffestb_R1001 (ffelexToken t)
8897 {
8898   ffesttFormatList f;
8899
8900   switch (ffelex_token_type (ffesta_tokens[0]))
8901     {
8902     case FFELEX_typeNAME:
8903       if (ffesta_first_kw != FFESTR_firstFORMAT)
8904         goto bad_0;             /* :::::::::::::::::::: */
8905       break;
8906
8907     case FFELEX_typeNAMES:
8908       if (ffesta_first_kw != FFESTR_firstFORMAT)
8909         goto bad_0;             /* :::::::::::::::::::: */
8910       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlFORMAT)
8911         goto bad_0;             /* :::::::::::::::::::: */
8912       break;
8913
8914     default:
8915       goto bad_0;               /* :::::::::::::::::::: */
8916     }
8917
8918   switch (ffelex_token_type (t))
8919     {
8920     case FFELEX_typeOPEN_PAREN:
8921       ffestb_local_.format.complained = FALSE;
8922       ffestb_local_.format.f = NULL;    /* No parent yet. */
8923       ffestb_local_.format.f = ffestt_formatlist_create (NULL,
8924                                                       ffelex_token_use (t));
8925       ffelex_set_names_pure (TRUE);     /* Have even free-form lexer give us
8926                                            NAMES. */
8927       return (ffelexHandler) ffestb_R10011_;
8928
8929     case FFELEX_typeOPEN_ARRAY:/* "(/". */
8930       ffesta_confirmed ();
8931       ffestb_local_.format.complained = FALSE;
8932       ffestb_local_.format.f = ffestt_formatlist_create (NULL,
8933                                                       ffelex_token_use (t));
8934       f = ffestt_formatlist_append (ffestb_local_.format.f);
8935       f->type = FFESTP_formattypeSLASH;
8936       f->t = ffelex_token_use (t);
8937       f->u.R1010.val.present = FALSE;
8938       f->u.R1010.val.rtexpr = FALSE;
8939       f->u.R1010.val.t = NULL;
8940       f->u.R1010.val.u.unsigned_val = 1;
8941       ffelex_set_names_pure (TRUE);     /* Have even free-form lexer give us
8942                                            NAMES. */
8943       return (ffelexHandler) ffestb_R100112_;
8944
8945     case FFELEX_typeEOS:
8946     case FFELEX_typeSEMICOLON:
8947     case FFELEX_typeCOMMA:
8948     case FFELEX_typeCOLONCOLON:
8949       ffesta_confirmed ();      /* Error, but clearly intended. */
8950       goto bad_1;               /* :::::::::::::::::::: */
8951
8952     default:
8953       goto bad_1;               /* :::::::::::::::::::: */
8954     }
8955
8956 bad_0:                          /* :::::::::::::::::::: */
8957   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", ffesta_tokens[0]);
8958   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8959
8960 bad_1:                          /* :::::::::::::::::::: */
8961   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
8962   return (ffelexHandler) ffelex_swallow_tokens (t,
8963                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
8964 }
8965
8966 /* ffestb_R10011_ -- "FORMAT" OPEN_PAREN expr
8967
8968    return ffestb_R10011_;  // to lexer
8969
8970    For CLOSE_PAREN, wrap up the format list and if it is the top-level one,
8971    exit.  For anything else, pass it to _2_.  */
8972
8973 static ffelexHandler
8974 ffestb_R10011_ (ffelexToken t)
8975 {
8976   ffesttFormatList f;
8977
8978   switch (ffelex_token_type (t))
8979     {
8980     case FFELEX_typeCLOSE_PAREN:
8981       break;
8982
8983     default:
8984       return (ffelexHandler) ffestb_R10012_ (t);
8985     }
8986
8987   /* If we have a format we're working on, continue working on it. */
8988
8989   f = ffestb_local_.format.f->u.root.parent;
8990
8991   if (f != NULL)
8992     {
8993       ffestb_local_.format.f = f->next;
8994       return (ffelexHandler) ffestb_R100111_;
8995     }
8996
8997   return (ffelexHandler) ffestb_R100114_;
8998 }
8999
9000 /* ffestb_R10012_ -- "FORMAT" OPEN_PAREN [format-item-list]
9001
9002    return ffestb_R10012_;  // to lexer
9003
9004    The initial state for a format-item.  Here, just handle the initial
9005    number, sign for number, or run-time expression.  Also handle spurious
9006    comma, close-paren (indicating spurious comma), close-array (like
9007    close-paren but preceded by slash), and quoted strings.  */
9008
9009 static ffelexHandler
9010 ffestb_R10012_ (ffelexToken t)
9011 {
9012   unsigned long unsigned_val;
9013   ffesttFormatList f;
9014
9015   switch (ffelex_token_type (t))
9016     {
9017     case FFELEX_typeOPEN_ANGLE:
9018       ffesta_confirmed ();
9019       ffestb_local_.format.pre.t = ffelex_token_use (t);
9020       ffelex_set_names_pure (FALSE);
9021       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
9022         {
9023           ffestb_local_.format.complained = TRUE;
9024           ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
9025           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9026           ffebad_finish ();
9027         }
9028       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
9029                   FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100115_);
9030
9031     case FFELEX_typeNUMBER:
9032       ffestb_local_.format.sign = FALSE;        /* No sign present. */
9033       ffestb_local_.format.pre.present = TRUE;
9034       ffestb_local_.format.pre.rtexpr = FALSE;
9035       ffestb_local_.format.pre.t = ffelex_token_use (t);
9036       ffestb_local_.format.pre.u.unsigned_val = unsigned_val
9037         = strtoul (ffelex_token_text (t), NULL, 10);
9038       ffelex_set_expecting_hollerith (unsigned_val, '\0',
9039                                       ffelex_token_where_line (t),
9040                                       ffelex_token_where_column (t));
9041       return (ffelexHandler) ffestb_R10014_;
9042
9043     case FFELEX_typePLUS:
9044       ffestb_local_.format.sign = TRUE; /* Positive. */
9045       ffestb_local_.format.pre.t = ffelex_token_use (t);
9046       return (ffelexHandler) ffestb_R10013_;
9047
9048     case FFELEX_typeMINUS:
9049       ffestb_local_.format.sign = FALSE;        /* Negative. */
9050       ffestb_local_.format.pre.t = ffelex_token_use (t);
9051       return (ffelexHandler) ffestb_R10013_;
9052
9053     case FFELEX_typeCOLON:
9054     case FFELEX_typeCOLONCOLON:/* "::". */
9055     case FFELEX_typeSLASH:
9056     case FFELEX_typeCONCAT:     /* "//". */
9057     case FFELEX_typeNAMES:
9058     case FFELEX_typeDOLLAR:
9059     case FFELEX_typeOPEN_PAREN:
9060     case FFELEX_typeOPEN_ARRAY:/* "(/". */
9061       ffestb_local_.format.sign = FALSE;        /* No sign present. */
9062       ffestb_local_.format.pre.present = FALSE;
9063       ffestb_local_.format.pre.rtexpr = FALSE;
9064       ffestb_local_.format.pre.t = NULL;
9065       ffestb_local_.format.pre.u.unsigned_val = 1;
9066       return (ffelexHandler) ffestb_R10014_ (t);
9067
9068     case FFELEX_typeCOMMA:
9069       ffebad_start (FFEBAD_FORMAT_EXTRA_COMMA);
9070       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9071       ffebad_finish ();
9072       return (ffelexHandler) ffestb_R10012_;
9073
9074     case FFELEX_typeCLOSE_PAREN:
9075       ffebad_start (FFEBAD_FORMAT_EXTRA_COMMA);
9076       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9077       ffebad_finish ();
9078       f = ffestb_local_.format.f->u.root.parent;
9079       if (f == NULL)
9080         return (ffelexHandler) ffestb_R100114_;
9081       ffestb_local_.format.f = f->next;
9082       return (ffelexHandler) ffestb_R100111_;
9083
9084     case FFELEX_typeCLOSE_ARRAY:        /* "/)". */
9085       f = ffestt_formatlist_append (ffestb_local_.format.f);
9086       f->type = FFESTP_formattypeSLASH;
9087       f->t = ffelex_token_use (t);
9088       f->u.R1010.val.present = FALSE;
9089       f->u.R1010.val.rtexpr = FALSE;
9090       f->u.R1010.val.t = NULL;
9091       f->u.R1010.val.u.unsigned_val = 1;
9092       f = ffestb_local_.format.f->u.root.parent;
9093       if (f == NULL)
9094         return (ffelexHandler) ffestb_R100114_;
9095       ffestb_local_.format.f = f->next;
9096       return (ffelexHandler) ffestb_R100111_;
9097
9098     case FFELEX_typeEOS:
9099     case FFELEX_typeSEMICOLON:
9100       ffesta_confirmed ();
9101       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
9102       for (f = ffestb_local_.format.f;
9103            f->u.root.parent != NULL;
9104            f = f->u.root.parent->next)
9105         ;
9106       ffestb_local_.format.f = f;
9107       return (ffelexHandler) ffestb_R100114_ (t);
9108
9109     case FFELEX_typeQUOTE:
9110       if (ffe_is_vxt ())
9111         break;                  /* Error, probably something like FORMAT("17)
9112                                    = X. */
9113       ffelex_set_expecting_hollerith (-1, '\"',
9114                                       ffelex_token_where_line (t),
9115                                       ffelex_token_where_column (t));   /* Don't have to unset
9116                                                                            this one. */
9117       return (ffelexHandler) ffestb_R100113_;
9118
9119     case FFELEX_typeAPOSTROPHE:
9120 #if 0                           /* No apparent need for this, and not killed
9121                                    anywhere. */
9122       ffesta_tokens[1] = ffelex_token_use (t);
9123 #endif
9124       ffelex_set_expecting_hollerith (-1, '\'',
9125                                       ffelex_token_where_line (t),
9126                                       ffelex_token_where_column (t));   /* Don't have to unset
9127                                                                            this one. */
9128       return (ffelexHandler) ffestb_R100113_;
9129
9130     default:
9131       break;
9132     }
9133
9134   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
9135   ffestt_formatlist_kill (ffestb_local_.format.f);
9136   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
9137 }
9138
9139 /* ffestb_R10013_ -- "FORMAT" OPEN_PAREN [format-item-list] PLUS/MINUS
9140
9141    return ffestb_R10013_;  // to lexer
9142
9143    Expect a NUMBER or complain about and then ignore the PLUS/MINUS.  */
9144
9145 static ffelexHandler
9146 ffestb_R10013_ (ffelexToken t)
9147 {
9148   unsigned long unsigned_val;
9149
9150   switch (ffelex_token_type (t))
9151     {
9152     case FFELEX_typeNUMBER:
9153       ffestb_local_.format.pre.present = TRUE;
9154       ffestb_local_.format.pre.rtexpr = FALSE;
9155       unsigned_val = strtoul (ffelex_token_text (t), NULL, 10);
9156       ffestb_local_.format.pre.u.signed_val = ffestb_local_.format.sign
9157         ? unsigned_val : -unsigned_val;
9158       ffestb_local_.format.sign = TRUE; /* Sign present. */
9159       return (ffelexHandler) ffestb_R10014_;
9160
9161     default:
9162       ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9163       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9164                    ffelex_token_where_column (ffestb_local_.format.pre.t));
9165       ffebad_finish ();
9166       ffelex_token_kill (ffestb_local_.format.pre.t);
9167       return (ffelexHandler) ffestb_R10012_ (t);
9168     }
9169 }
9170
9171 /* ffestb_R10014_ -- "FORMAT" OPEN_PAREN [format-item-list] [[+/-] NUMBER]
9172
9173    return ffestb_R10014_;  // to lexer
9174
9175    Here is where we expect to see the actual NAMES, COLON, SLASH, OPEN_PAREN,
9176    OPEN_ARRAY, COLONCOLON, CONCAT, DOLLAR, or HOLLERITH that identifies what
9177    kind of format-item we're dealing with.  But if we see a NUMBER instead, it
9178    means free-form spaces number like "5 6 X", so scale the current number
9179    accordingly and reenter this state.  (I really wouldn't be surprised if
9180    they change this spacing rule in the F90 spec so that you can't embed
9181    spaces within numbers or within keywords like BN in a free-source-form
9182    program.)  */
9183
9184 static ffelexHandler
9185 ffestb_R10014_ (ffelexToken t)
9186 {
9187   ffesttFormatList f;
9188   ffeTokenLength i;
9189   char *p;
9190   ffestrFormat kw;
9191
9192   ffelex_set_expecting_hollerith (0, '\0',
9193                                   ffewhere_line_unknown (),
9194                                   ffewhere_column_unknown ());
9195
9196   switch (ffelex_token_type (t))
9197     {
9198     case FFELEX_typeHOLLERITH:
9199       f = ffestt_formatlist_append (ffestb_local_.format.f);
9200       f->type = FFESTP_formattypeR1016;
9201       f->t = ffelex_token_use (t);
9202       ffelex_token_kill (ffestb_local_.format.pre.t);   /* It WAS present! */
9203       return (ffelexHandler) ffestb_R100111_;
9204
9205     case FFELEX_typeNUMBER:
9206       assert (ffestb_local_.format.pre.present);
9207       ffesta_confirmed ();
9208       if (ffestb_local_.format.pre.rtexpr)
9209         {
9210           ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
9211           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9212           ffebad_finish ();
9213           return (ffelexHandler) ffestb_R10014_;
9214         }
9215       if (ffestb_local_.format.sign)
9216         {
9217           for (i = ffelex_token_length (t) + 1; i > 0; --i)
9218             ffestb_local_.format.pre.u.signed_val *= 10;
9219           ffestb_local_.format.pre.u.signed_val += strtoul (ffelex_token_text (t),
9220                                                             NULL, 10);
9221         }
9222       else
9223         {
9224           for (i = ffelex_token_length (t) + 1; i > 0; --i)
9225             ffestb_local_.format.pre.u.unsigned_val *= 10;
9226           ffestb_local_.format.pre.u.unsigned_val += strtoul (ffelex_token_text (t),
9227                                                               NULL, 10);
9228           ffelex_set_expecting_hollerith (ffestb_local_.format.pre.u.unsigned_val,
9229                                           '\0',
9230                                           ffelex_token_where_line (t),
9231                                           ffelex_token_where_column (t));
9232         }
9233       return (ffelexHandler) ffestb_R10014_;
9234
9235     case FFELEX_typeCOLONCOLON: /* "::". */
9236       if (ffestb_local_.format.pre.present)
9237         {
9238           ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_COLON_SPEC,
9239                             ffestb_local_.format.pre.t);
9240           ffelex_token_kill (ffestb_local_.format.pre.t);
9241           ffestb_local_.format.pre.present = FALSE;
9242         }
9243       else
9244         {
9245           f = ffestt_formatlist_append (ffestb_local_.format.f);
9246           f->type = FFESTP_formattypeCOLON;
9247           f->t = ffelex_token_use (t);
9248           f->u.R1010.val.present = FALSE;
9249           f->u.R1010.val.rtexpr = FALSE;
9250           f->u.R1010.val.t = NULL;
9251           f->u.R1010.val.u.unsigned_val = 1;
9252         }
9253       f = ffestt_formatlist_append (ffestb_local_.format.f);
9254       f->type = FFESTP_formattypeCOLON;
9255       f->t = ffelex_token_use (t);
9256       f->u.R1010.val.present = FALSE;
9257       f->u.R1010.val.rtexpr = FALSE;
9258       f->u.R1010.val.t = NULL;
9259       f->u.R1010.val.u.unsigned_val = 1;
9260       return (ffelexHandler) ffestb_R100112_;
9261
9262     case FFELEX_typeCOLON:
9263       if (ffestb_local_.format.pre.present)
9264         {
9265           ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_COLON_SPEC,
9266                             ffestb_local_.format.pre.t);
9267           ffelex_token_kill (ffestb_local_.format.pre.t);
9268           return (ffelexHandler) ffestb_R100112_;
9269         }
9270       f = ffestt_formatlist_append (ffestb_local_.format.f);
9271       f->type = FFESTP_formattypeCOLON;
9272       f->t = ffelex_token_use (t);
9273       f->u.R1010.val.present = FALSE;
9274       f->u.R1010.val.rtexpr = FALSE;
9275       f->u.R1010.val.t = NULL;
9276       f->u.R1010.val.u.unsigned_val = 1;
9277       return (ffelexHandler) ffestb_R100112_;
9278
9279     case FFELEX_typeCONCAT:     /* "//". */
9280       if (ffestb_local_.format.sign)
9281         {
9282           ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9283           ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9284                     ffelex_token_where_column (ffestb_local_.format.pre.t));
9285           ffebad_finish ();
9286           ffestb_local_.format.pre.u.unsigned_val
9287             = (ffestb_local_.format.pre.u.signed_val < 0)
9288             ? -ffestb_local_.format.pre.u.signed_val
9289             : ffestb_local_.format.pre.u.signed_val;
9290         }
9291       f = ffestt_formatlist_append (ffestb_local_.format.f);
9292       f->type = FFESTP_formattypeSLASH;
9293       f->t = ffelex_token_use (t);
9294       f->u.R1010.val = ffestb_local_.format.pre;
9295       ffestb_local_.format.pre.present = FALSE;
9296       ffestb_local_.format.pre.rtexpr = FALSE;
9297       ffestb_local_.format.pre.t = NULL;
9298       ffestb_local_.format.pre.u.unsigned_val = 1;
9299       f = ffestt_formatlist_append (ffestb_local_.format.f);
9300       f->type = FFESTP_formattypeSLASH;
9301       f->t = ffelex_token_use (t);
9302       f->u.R1010.val = ffestb_local_.format.pre;
9303       return (ffelexHandler) ffestb_R100112_;
9304
9305     case FFELEX_typeSLASH:
9306       if (ffestb_local_.format.sign)
9307         {
9308           ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9309           ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9310                     ffelex_token_where_column (ffestb_local_.format.pre.t));
9311           ffebad_finish ();
9312           ffestb_local_.format.pre.u.unsigned_val
9313             = (ffestb_local_.format.pre.u.signed_val < 0)
9314             ? -ffestb_local_.format.pre.u.signed_val
9315             : ffestb_local_.format.pre.u.signed_val;
9316         }
9317       f = ffestt_formatlist_append (ffestb_local_.format.f);
9318       f->type = FFESTP_formattypeSLASH;
9319       f->t = ffelex_token_use (t);
9320       f->u.R1010.val = ffestb_local_.format.pre;
9321       return (ffelexHandler) ffestb_R100112_;
9322
9323     case FFELEX_typeOPEN_PAREN:
9324       if (ffestb_local_.format.sign)
9325         {
9326           ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9327           ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9328                     ffelex_token_where_column (ffestb_local_.format.pre.t));
9329           ffebad_finish ();
9330           ffestb_local_.format.pre.u.unsigned_val
9331             = (ffestb_local_.format.pre.u.signed_val < 0)
9332             ? -ffestb_local_.format.pre.u.signed_val
9333             : ffestb_local_.format.pre.u.signed_val;
9334         }
9335       f = ffestt_formatlist_append (ffestb_local_.format.f);
9336       f->type = FFESTP_formattypeFORMAT;
9337       f->t = ffelex_token_use (t);
9338       f->u.R1003D.R1004 = ffestb_local_.format.pre;
9339       f->u.R1003D.format = ffestb_local_.format.f
9340         = ffestt_formatlist_create (f, ffelex_token_use (t));
9341       return (ffelexHandler) ffestb_R10011_;
9342
9343     case FFELEX_typeOPEN_ARRAY:/* "(/". */
9344       if (ffestb_local_.format.sign)
9345         {
9346           ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9347           ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9348                     ffelex_token_where_column (ffestb_local_.format.pre.t));
9349           ffebad_finish ();
9350           ffestb_local_.format.pre.u.unsigned_val
9351             = (ffestb_local_.format.pre.u.signed_val < 0)
9352             ? -ffestb_local_.format.pre.u.signed_val
9353             : ffestb_local_.format.pre.u.signed_val;
9354         }
9355       f = ffestt_formatlist_append (ffestb_local_.format.f);
9356       f->type = FFESTP_formattypeFORMAT;
9357       f->t = ffelex_token_use (t);
9358       f->u.R1003D.R1004 = ffestb_local_.format.pre;
9359       f->u.R1003D.format = ffestb_local_.format.f
9360         = ffestt_formatlist_create (f, ffelex_token_use (t));
9361       f = ffestt_formatlist_append (ffestb_local_.format.f);
9362       f->type = FFESTP_formattypeSLASH;
9363       f->t = ffelex_token_use (t);
9364       f->u.R1010.val.present = FALSE;
9365       f->u.R1010.val.rtexpr = FALSE;
9366       f->u.R1010.val.t = NULL;
9367       f->u.R1010.val.u.unsigned_val = 1;
9368       return (ffelexHandler) ffestb_R100112_;
9369
9370     case FFELEX_typeCLOSE_ARRAY:        /* "/)". */
9371       f = ffestt_formatlist_append (ffestb_local_.format.f);
9372       f->type = FFESTP_formattypeSLASH;
9373       f->t = ffelex_token_use (t);
9374       f->u.R1010.val = ffestb_local_.format.pre;
9375       f = ffestb_local_.format.f->u.root.parent;
9376       if (f == NULL)
9377         return (ffelexHandler) ffestb_R100114_;
9378       ffestb_local_.format.f = f->next;
9379       return (ffelexHandler) ffestb_R100111_;
9380
9381     case FFELEX_typeQUOTE:
9382       if (ffe_is_vxt ())
9383         break;                  /* A totally bad character in a VXT FORMAT. */
9384       ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
9385       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9386                    ffelex_token_where_column (ffestb_local_.format.pre.t));
9387       ffebad_finish ();
9388       ffelex_token_kill (ffestb_local_.format.pre.t);
9389       ffesta_confirmed ();
9390 #if 0                           /* No apparent need for this, and not killed
9391                                    anywhere. */
9392       ffesta_tokens[1] = ffelex_token_use (t);
9393 #endif
9394       ffelex_set_expecting_hollerith (-1, '\"',
9395                                       ffelex_token_where_line (t),
9396                                       ffelex_token_where_column (t));   /* Don't have to unset
9397                                                                            this one. */
9398       return (ffelexHandler) ffestb_R100113_;
9399
9400     case FFELEX_typeAPOSTROPHE:
9401       ffesta_confirmed ();
9402       ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
9403       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9404                    ffelex_token_where_column (ffestb_local_.format.pre.t));
9405       ffebad_finish ();
9406       ffelex_token_kill (ffestb_local_.format.pre.t);
9407 #if 0                           /* No apparent need for this, and not killed
9408                                    anywhere. */
9409       ffesta_tokens[1] = ffelex_token_use (t);
9410 #endif
9411       ffelex_set_expecting_hollerith (-1, '\'', ffelex_token_where_line (t),
9412                                       ffelex_token_where_column (t));   /* Don't have to unset
9413                                                                            this one. */
9414       return (ffelexHandler) ffestb_R100113_;
9415
9416     case FFELEX_typeEOS:
9417     case FFELEX_typeSEMICOLON:
9418       ffesta_confirmed ();
9419       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
9420       for (f = ffestb_local_.format.f;
9421            f->u.root.parent != NULL;
9422            f = f->u.root.parent->next)
9423         ;
9424       ffestb_local_.format.f = f;
9425       ffelex_token_kill (ffestb_local_.format.pre.t);
9426       return (ffelexHandler) ffestb_R100114_ (t);
9427
9428     case FFELEX_typeDOLLAR:
9429       ffestb_local_.format.t = ffelex_token_use (t);
9430       if (ffestb_local_.format.pre.present)
9431         ffesta_confirmed ();    /* Number preceding this invalid elsewhere. */
9432       ffestb_local_.format.current = FFESTP_formattypeDOLLAR;
9433       return (ffelexHandler) ffestb_R10015_;
9434
9435     case FFELEX_typeNAMES:
9436       kw = ffestr_format (t);
9437       ffestb_local_.format.t = ffelex_token_use (t);
9438       switch (kw)
9439         {
9440         case FFESTR_formatI:
9441           if (ffestb_local_.format.pre.present)
9442             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9443           ffestb_local_.format.current = FFESTP_formattypeI;
9444           i = FFESTR_formatlI;
9445           break;
9446
9447         case FFESTR_formatB:
9448           if (ffestb_local_.format.pre.present)
9449             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9450           ffestb_local_.format.current = FFESTP_formattypeB;
9451           i = FFESTR_formatlB;
9452           break;
9453
9454         case FFESTR_formatO:
9455           if (ffestb_local_.format.pre.present)
9456             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9457           ffestb_local_.format.current = FFESTP_formattypeO;
9458           i = FFESTR_formatlO;
9459           break;
9460
9461         case FFESTR_formatZ:
9462           if (ffestb_local_.format.pre.present)
9463             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9464           ffestb_local_.format.current = FFESTP_formattypeZ;
9465           i = FFESTR_formatlZ;
9466           break;
9467
9468         case FFESTR_formatF:
9469           if (ffestb_local_.format.pre.present)
9470             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9471           ffestb_local_.format.current = FFESTP_formattypeF;
9472           i = FFESTR_formatlF;
9473           break;
9474
9475         case FFESTR_formatE:
9476           ffestb_local_.format.current = FFESTP_formattypeE;
9477           i = FFESTR_formatlE;
9478           break;
9479
9480         case FFESTR_formatEN:
9481           if (ffestb_local_.format.pre.present)
9482             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9483           ffestb_local_.format.current = FFESTP_formattypeEN;
9484           i = FFESTR_formatlEN;
9485           break;
9486
9487         case FFESTR_formatG:
9488           if (ffestb_local_.format.pre.present)
9489             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9490           ffestb_local_.format.current = FFESTP_formattypeG;
9491           i = FFESTR_formatlG;
9492           break;
9493
9494         case FFESTR_formatL:
9495           if (ffestb_local_.format.pre.present)
9496             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9497           ffestb_local_.format.current = FFESTP_formattypeL;
9498           i = FFESTR_formatlL;
9499           break;
9500
9501         case FFESTR_formatA:
9502           if (ffestb_local_.format.pre.present)
9503             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9504           ffestb_local_.format.current = FFESTP_formattypeA;
9505           i = FFESTR_formatlA;
9506           break;
9507
9508         case FFESTR_formatD:
9509           ffestb_local_.format.current = FFESTP_formattypeD;
9510           i = FFESTR_formatlD;
9511           break;
9512
9513         case FFESTR_formatQ:
9514           ffestb_local_.format.current = FFESTP_formattypeQ;
9515           i = FFESTR_formatlQ;
9516           break;
9517
9518         case FFESTR_formatDOLLAR:
9519           if (ffestb_local_.format.pre.present)
9520             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9521           ffestb_local_.format.current = FFESTP_formattypeDOLLAR;
9522           i = FFESTR_formatlDOLLAR;
9523           break;
9524
9525         case FFESTR_formatP:
9526           if (ffestb_local_.format.pre.present)
9527             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9528           ffestb_local_.format.current = FFESTP_formattypeP;
9529           i = FFESTR_formatlP;
9530           break;
9531
9532         case FFESTR_formatT:
9533           if (ffestb_local_.format.pre.present)
9534             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9535           ffestb_local_.format.current = FFESTP_formattypeT;
9536           i = FFESTR_formatlT;
9537           break;
9538
9539         case FFESTR_formatTL:
9540           if (ffestb_local_.format.pre.present)
9541             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9542           ffestb_local_.format.current = FFESTP_formattypeTL;
9543           i = FFESTR_formatlTL;
9544           break;
9545
9546         case FFESTR_formatTR:
9547           if (ffestb_local_.format.pre.present)
9548             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9549           ffestb_local_.format.current = FFESTP_formattypeTR;
9550           i = FFESTR_formatlTR;
9551           break;
9552
9553         case FFESTR_formatX:
9554           if (ffestb_local_.format.pre.present)
9555             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9556           ffestb_local_.format.current = FFESTP_formattypeX;
9557           i = FFESTR_formatlX;
9558           break;
9559
9560         case FFESTR_formatS:
9561           if (ffestb_local_.format.pre.present)
9562             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9563           ffestb_local_.format.current = FFESTP_formattypeS;
9564           i = FFESTR_formatlS;
9565           break;
9566
9567         case FFESTR_formatSP:
9568           if (ffestb_local_.format.pre.present)
9569             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9570           ffestb_local_.format.current = FFESTP_formattypeSP;
9571           i = FFESTR_formatlSP;
9572           break;
9573
9574         case FFESTR_formatSS:
9575           if (ffestb_local_.format.pre.present)
9576             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9577           ffestb_local_.format.current = FFESTP_formattypeSS;
9578           i = FFESTR_formatlSS;
9579           break;
9580
9581         case FFESTR_formatBN:
9582           if (ffestb_local_.format.pre.present)
9583             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9584           ffestb_local_.format.current = FFESTP_formattypeBN;
9585           i = FFESTR_formatlBN;
9586           break;
9587
9588         case FFESTR_formatBZ:
9589           if (ffestb_local_.format.pre.present)
9590             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9591           ffestb_local_.format.current = FFESTP_formattypeBZ;
9592           i = FFESTR_formatlBZ;
9593           break;
9594
9595         case FFESTR_formatH:    /* Error, either "H" or "<expr>H". */
9596           if (ffestb_local_.format.pre.present)
9597             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9598           ffestb_local_.format.current = FFESTP_formattypeH;
9599           i = FFESTR_formatlH;
9600           break;
9601
9602         case FFESTR_formatPD:
9603           if (ffestb_local_.format.pre.present)
9604             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9605           ffestb_subr_R1001_append_p_ ();
9606           ffestb_local_.format.t = ffelex_token_name_from_names (t,
9607                                                         FFESTR_formatlP, 1);
9608           ffestb_local_.format.sign = FALSE;
9609           ffestb_local_.format.pre.present = FALSE;
9610           ffestb_local_.format.pre.rtexpr = FALSE;
9611           ffestb_local_.format.pre.t = NULL;
9612           ffestb_local_.format.pre.u.unsigned_val = 1;
9613           ffestb_local_.format.current = FFESTP_formattypeD;
9614           i = FFESTR_formatlPD;
9615           break;
9616
9617         case FFESTR_formatPE:
9618           if (ffestb_local_.format.pre.present)
9619             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9620           ffestb_subr_R1001_append_p_ ();
9621           ffestb_local_.format.t = ffelex_token_name_from_names (t,
9622                                                         FFESTR_formatlP, 1);
9623           ffestb_local_.format.sign = FALSE;
9624           ffestb_local_.format.pre.present = FALSE;
9625           ffestb_local_.format.pre.rtexpr = FALSE;
9626           ffestb_local_.format.pre.t = NULL;
9627           ffestb_local_.format.pre.u.unsigned_val = 1;
9628           ffestb_local_.format.current = FFESTP_formattypeE;
9629           i = FFESTR_formatlPE;
9630           break;
9631
9632         case FFESTR_formatPEN:
9633           if (ffestb_local_.format.pre.present)
9634             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9635           ffestb_subr_R1001_append_p_ ();
9636           ffestb_local_.format.t = ffelex_token_name_from_names (t,
9637                                                         FFESTR_formatlP, 1);
9638           ffestb_local_.format.sign = FALSE;
9639           ffestb_local_.format.pre.present = FALSE;
9640           ffestb_local_.format.pre.rtexpr = FALSE;
9641           ffestb_local_.format.pre.t = NULL;
9642           ffestb_local_.format.pre.u.unsigned_val = 1;
9643           ffestb_local_.format.current = FFESTP_formattypeEN;
9644           i = FFESTR_formatlPEN;
9645           break;
9646
9647         case FFESTR_formatPF:
9648           if (ffestb_local_.format.pre.present)
9649             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9650           ffestb_subr_R1001_append_p_ ();
9651           ffestb_local_.format.t = ffelex_token_name_from_names (t,
9652                                                         FFESTR_formatlP, 1);
9653           ffestb_local_.format.sign = FALSE;
9654           ffestb_local_.format.pre.present = FALSE;
9655           ffestb_local_.format.pre.rtexpr = FALSE;
9656           ffestb_local_.format.pre.t = NULL;
9657           ffestb_local_.format.pre.u.unsigned_val = 1;
9658           ffestb_local_.format.current = FFESTP_formattypeF;
9659           i = FFESTR_formatlPF;
9660           break;
9661
9662         case FFESTR_formatPG:
9663           if (ffestb_local_.format.pre.present)
9664             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9665           ffestb_subr_R1001_append_p_ ();
9666           ffestb_local_.format.t = ffelex_token_name_from_names (t,
9667                                                         FFESTR_formatlP, 1);
9668           ffestb_local_.format.sign = FALSE;
9669           ffestb_local_.format.pre.present = FALSE;
9670           ffestb_local_.format.pre.rtexpr = FALSE;
9671           ffestb_local_.format.pre.t = NULL;
9672           ffestb_local_.format.pre.u.unsigned_val = 1;
9673           ffestb_local_.format.current = FFESTP_formattypeG;
9674           i = FFESTR_formatlPG;
9675           break;
9676
9677         default:
9678           if (ffestb_local_.format.pre.present)
9679             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9680           ffestb_local_.format.current = FFESTP_formattypeNone;
9681           p = strpbrk (ffelex_token_text (t), "0123456789");
9682           if (p == NULL)
9683             i = ffelex_token_length (t);
9684           else
9685             i = p - ffelex_token_text (t);
9686           break;
9687         }
9688       p = ffelex_token_text (t) + i;
9689       if (*p == '\0')
9690         return (ffelexHandler) ffestb_R10015_;
9691       if (!isdigit (*p))
9692         {
9693           if (ffestb_local_.format.current == FFESTP_formattypeH)
9694             p = strpbrk (p, "0123456789");
9695           else
9696             {
9697               p = NULL;
9698               ffestb_local_.format.current = FFESTP_formattypeNone;
9699             }
9700           if (p == NULL)
9701             return (ffelexHandler) ffestb_R10015_;
9702           i = p - ffelex_token_text (t);        /* Collect digits. */
9703         }
9704       ffestb_local_.format.post.present = TRUE;
9705       ffestb_local_.format.post.rtexpr = FALSE;
9706       ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
9707       ffestb_local_.format.post.u.unsigned_val
9708         = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
9709       p += ffelex_token_length (ffestb_local_.format.post.t);
9710       i += ffelex_token_length (ffestb_local_.format.post.t);
9711       if (*p == '\0')
9712         return (ffelexHandler) ffestb_R10016_;
9713       if ((kw != FFESTR_formatP) || !ffelex_is_firstnamechar (*p))
9714         {
9715           if (ffestb_local_.format.current != FFESTP_formattypeH)
9716             ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
9717           return (ffelexHandler) ffestb_R10016_;
9718         }
9719
9720       /* Here we have [number]P[number][text].  Treat as
9721          [number]P,[number][text]. */
9722
9723       ffestb_subr_R1001_append_p_ ();
9724       t = ffestb_local_.format.t = ffelex_token_names_from_names (t, i, 0);
9725       ffestb_local_.format.sign = FALSE;
9726       ffestb_local_.format.pre = ffestb_local_.format.post;
9727       kw = ffestr_format (t);
9728       switch (kw)
9729         {                       /* Only a few possibilities here. */
9730         case FFESTR_formatD:
9731           ffestb_local_.format.current = FFESTP_formattypeD;
9732           i = FFESTR_formatlD;
9733           break;
9734
9735         case FFESTR_formatE:
9736           ffestb_local_.format.current = FFESTP_formattypeE;
9737           i = FFESTR_formatlE;
9738           break;
9739
9740         case FFESTR_formatEN:
9741           ffestb_local_.format.current = FFESTP_formattypeEN;
9742           i = FFESTR_formatlEN;
9743           break;
9744
9745         case FFESTR_formatF:
9746           ffestb_local_.format.current = FFESTP_formattypeF;
9747           i = FFESTR_formatlF;
9748           break;
9749
9750         case FFESTR_formatG:
9751           ffestb_local_.format.current = FFESTP_formattypeG;
9752           i = FFESTR_formatlG;
9753           break;
9754
9755         default:
9756           ffebad_start (FFEBAD_FORMAT_P_NOCOMMA);
9757           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9758           ffebad_finish ();
9759           ffestb_local_.format.current = FFESTP_formattypeNone;
9760           p = strpbrk (ffelex_token_text (t), "0123456789");
9761           if (p == NULL)
9762             i = ffelex_token_length (t);
9763           else
9764             i = p - ffelex_token_text (t);
9765         }
9766       p = ffelex_token_text (t) + i;
9767       if (*p == '\0')
9768         return (ffelexHandler) ffestb_R10015_;
9769       if (!isdigit (*p))
9770         {
9771           ffestb_local_.format.current = FFESTP_formattypeNone;
9772           p = strpbrk (p, "0123456789");
9773           if (p == NULL)
9774             return (ffelexHandler) ffestb_R10015_;
9775           i = p - ffelex_token_text (t);        /* Collect digits anyway. */
9776         }
9777       ffestb_local_.format.post.present = TRUE;
9778       ffestb_local_.format.post.rtexpr = FALSE;
9779       ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
9780       ffestb_local_.format.post.u.unsigned_val
9781         = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
9782       p += ffelex_token_length (ffestb_local_.format.post.t);
9783       i += ffelex_token_length (ffestb_local_.format.post.t);
9784       if (*p == '\0')
9785         return (ffelexHandler) ffestb_R10016_;
9786       ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
9787       return (ffelexHandler) ffestb_R10016_;
9788
9789     default:
9790       break;
9791     }
9792
9793   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
9794   if (ffestb_local_.format.pre.present)
9795     ffelex_token_kill (ffestb_local_.format.pre.t);
9796   ffestt_formatlist_kill (ffestb_local_.format.f);
9797   return (ffelexHandler) ffelex_swallow_tokens (t,
9798                                                 (ffelexHandler) ffesta_zero);
9799 }
9800
9801 /* ffestb_R10015_ -- [[+/-] NUMBER] NAMES
9802
9803    return ffestb_R10015_;  // to lexer
9804
9805    Here we've gotten at least the initial mnemonic for the edit descriptor.
9806    We expect either a NUMBER, for the post-mnemonic value, a NAMES, for
9807    further clarification (in free-form only, sigh) of the mnemonic, or
9808    anything else.  In all cases we go to _6_, with the difference that for
9809    NUMBER and NAMES we send the next token rather than the current token.  */
9810
9811 static ffelexHandler
9812 ffestb_R10015_ (ffelexToken t)
9813 {
9814   bool split_pea;               /* New NAMES requires splitting kP from new
9815                                    edit desc. */
9816   ffestrFormat kw;
9817   char *p;
9818   ffeTokenLength i;
9819
9820   switch (ffelex_token_type (t))
9821     {
9822     case FFELEX_typeOPEN_ANGLE:
9823       ffesta_confirmed ();
9824       ffestb_local_.format.post.t = ffelex_token_use (t);
9825       ffelex_set_names_pure (FALSE);
9826       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
9827         {
9828           ffestb_local_.format.complained = TRUE;
9829           ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
9830           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9831           ffebad_finish ();
9832         }
9833       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
9834                   FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100116_);
9835
9836     case FFELEX_typeNUMBER:
9837       ffestb_local_.format.post.present = TRUE;
9838       ffestb_local_.format.post.rtexpr = FALSE;
9839       ffestb_local_.format.post.t = ffelex_token_use (t);
9840       ffestb_local_.format.post.u.unsigned_val
9841         = strtoul (ffelex_token_text (t), NULL, 10);
9842       return (ffelexHandler) ffestb_R10016_;
9843
9844     case FFELEX_typeNAMES:
9845       ffesta_confirmed ();      /* NAMES " " NAMES invalid elsewhere in
9846                                    free-form. */
9847       kw = ffestr_format (t);
9848       switch (ffestb_local_.format.current)
9849         {
9850         case FFESTP_formattypeP:
9851           split_pea = TRUE;
9852           break;
9853
9854         case FFESTP_formattypeH:        /* An error, maintain this indicator. */
9855           kw = FFESTR_formatNone;
9856           split_pea = FALSE;
9857           break;
9858
9859         default:
9860           split_pea = FALSE;
9861           break;
9862         }
9863
9864       switch (kw)
9865         {
9866         case FFESTR_formatF:
9867           switch (ffestb_local_.format.current)
9868             {
9869             case FFESTP_formattypeP:
9870               ffestb_local_.format.current = FFESTP_formattypeF;
9871               break;
9872
9873             default:
9874               ffestb_local_.format.current = FFESTP_formattypeNone;
9875               break;
9876             }
9877           i = FFESTR_formatlF;
9878           break;
9879
9880         case FFESTR_formatE:
9881           switch (ffestb_local_.format.current)
9882             {
9883             case FFESTP_formattypeP:
9884               ffestb_local_.format.current = FFESTP_formattypeE;
9885               break;
9886
9887             default:
9888               ffestb_local_.format.current = FFESTP_formattypeNone;
9889               break;
9890             }
9891           i = FFESTR_formatlE;
9892           break;
9893
9894         case FFESTR_formatEN:
9895           switch (ffestb_local_.format.current)
9896             {
9897             case FFESTP_formattypeP:
9898               ffestb_local_.format.current = FFESTP_formattypeEN;
9899               break;
9900
9901             default:
9902               ffestb_local_.format.current = FFESTP_formattypeNone;
9903               break;
9904             }
9905           i = FFESTR_formatlEN;
9906           break;
9907
9908         case FFESTR_formatG:
9909           switch (ffestb_local_.format.current)
9910             {
9911             case FFESTP_formattypeP:
9912               ffestb_local_.format.current = FFESTP_formattypeG;
9913               break;
9914
9915             default:
9916               ffestb_local_.format.current = FFESTP_formattypeNone;
9917               break;
9918             }
9919           i = FFESTR_formatlG;
9920           break;
9921
9922         case FFESTR_formatL:
9923           switch (ffestb_local_.format.current)
9924             {
9925             case FFESTP_formattypeT:
9926               ffestb_local_.format.current = FFESTP_formattypeTL;
9927               break;
9928
9929             default:
9930               ffestb_local_.format.current = FFESTP_formattypeNone;
9931               break;
9932             }
9933           i = FFESTR_formatlL;
9934           break;
9935
9936         case FFESTR_formatD:
9937           switch (ffestb_local_.format.current)
9938             {
9939             case FFESTP_formattypeP:
9940               ffestb_local_.format.current = FFESTP_formattypeD;
9941               break;
9942
9943             default:
9944               ffestb_local_.format.current = FFESTP_formattypeNone;
9945               break;
9946             }
9947           i = FFESTR_formatlD;
9948           break;
9949
9950         case FFESTR_formatS:
9951           switch (ffestb_local_.format.current)
9952             {
9953             case FFESTP_formattypeS:
9954               ffestb_local_.format.current = FFESTP_formattypeSS;
9955               break;
9956
9957             default:
9958               ffestb_local_.format.current = FFESTP_formattypeNone;
9959               break;
9960             }
9961           i = FFESTR_formatlS;
9962           break;
9963
9964         case FFESTR_formatP:
9965           switch (ffestb_local_.format.current)
9966             {
9967             case FFESTP_formattypeS:
9968               ffestb_local_.format.current = FFESTP_formattypeSP;
9969               break;
9970
9971             default:
9972               ffestb_local_.format.current = FFESTP_formattypeNone;
9973               break;
9974             }
9975           i = FFESTR_formatlP;
9976           break;
9977
9978         case FFESTR_formatR:
9979           switch (ffestb_local_.format.current)
9980             {
9981             case FFESTP_formattypeT:
9982               ffestb_local_.format.current = FFESTP_formattypeTR;
9983               break;
9984
9985             default:
9986               ffestb_local_.format.current = FFESTP_formattypeNone;
9987               break;
9988             }
9989           i = FFESTR_formatlR;
9990           break;
9991
9992         case FFESTR_formatZ:
9993           switch (ffestb_local_.format.current)
9994             {
9995             case FFESTP_formattypeB:
9996               ffestb_local_.format.current = FFESTP_formattypeBZ;
9997               break;
9998
9999             default:
10000               ffestb_local_.format.current = FFESTP_formattypeNone;
10001               break;
10002             }
10003           i = FFESTR_formatlZ;
10004           break;
10005
10006         case FFESTR_formatN:
10007           switch (ffestb_local_.format.current)
10008             {
10009             case FFESTP_formattypeE:
10010               ffestb_local_.format.current = FFESTP_formattypeEN;
10011               break;
10012
10013             case FFESTP_formattypeB:
10014               ffestb_local_.format.current = FFESTP_formattypeBN;
10015               break;
10016
10017             default:
10018               ffestb_local_.format.current = FFESTP_formattypeNone;
10019               break;
10020             }
10021           i = FFESTR_formatlN;
10022           break;
10023
10024         default:
10025           if (ffestb_local_.format.current != FFESTP_formattypeH)
10026             ffestb_local_.format.current = FFESTP_formattypeNone;
10027           split_pea = FALSE;    /* Go ahead and let the P be in the party. */
10028           p = strpbrk (ffelex_token_text (t), "0123456789");
10029           if (p == NULL)
10030             i = ffelex_token_length (t);
10031           else
10032             i = p - ffelex_token_text (t);
10033         }
10034
10035       if (split_pea)
10036         {
10037           ffestb_subr_R1001_append_p_ ();
10038           ffestb_local_.format.t = ffelex_token_use (t);
10039           ffestb_local_.format.sign = FALSE;
10040           ffestb_local_.format.pre.present = FALSE;
10041           ffestb_local_.format.pre.rtexpr = FALSE;
10042           ffestb_local_.format.pre.t = NULL;
10043           ffestb_local_.format.pre.u.unsigned_val = 1;
10044         }
10045
10046       p = ffelex_token_text (t) + i;
10047       if (*p == '\0')
10048         return (ffelexHandler) ffestb_R10015_;
10049       if (!isdigit (*p))
10050         {
10051           ffestb_local_.format.current = FFESTP_formattypeNone;
10052           p = strpbrk (p, "0123456789");
10053           if (p == NULL)
10054             return (ffelexHandler) ffestb_R10015_;
10055           i = p - ffelex_token_text (t);        /* Collect digits anyway. */
10056         }
10057       ffestb_local_.format.post.present = TRUE;
10058       ffestb_local_.format.post.rtexpr = FALSE;
10059       ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
10060       ffestb_local_.format.post.u.unsigned_val
10061         = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
10062       p += ffelex_token_length (ffestb_local_.format.post.t);
10063       i += ffelex_token_length (ffestb_local_.format.post.t);
10064       if (*p == '\0')
10065         return (ffelexHandler) ffestb_R10016_;
10066       ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
10067       return (ffelexHandler) ffestb_R10016_;
10068
10069     default:
10070       ffestb_local_.format.post.present = FALSE;
10071       ffestb_local_.format.post.rtexpr = FALSE;
10072       ffestb_local_.format.post.t = NULL;
10073       ffestb_local_.format.post.u.unsigned_val = 1;
10074       return (ffelexHandler) ffestb_R10016_ (t);
10075     }
10076 }
10077
10078 /* ffestb_R10016_ -- [[+/-] NUMBER] NAMES NUMBER
10079
10080    return ffestb_R10016_;  // to lexer
10081
10082    Expect a PERIOD here.  Maybe find a NUMBER to append to the current
10083    number, in which case return to this state.  Maybe find a NAMES to switch
10084    from a kP descriptor to a new descriptor (else the NAMES is spurious),
10085    in which case generator the P item and go to state _4_.  Anything
10086    else, pass token on to state _8_.  */
10087
10088 static ffelexHandler
10089 ffestb_R10016_ (ffelexToken t)
10090 {
10091   ffeTokenLength i;
10092
10093   switch (ffelex_token_type (t))
10094     {
10095     case FFELEX_typePERIOD:
10096       return (ffelexHandler) ffestb_R10017_;
10097
10098     case FFELEX_typeNUMBER:
10099       assert (ffestb_local_.format.post.present);
10100       ffesta_confirmed ();
10101       if (ffestb_local_.format.post.rtexpr)
10102         {
10103           ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
10104           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10105           ffebad_finish ();
10106           return (ffelexHandler) ffestb_R10016_;
10107         }
10108       for (i = ffelex_token_length (t) + 1; i > 0; --i)
10109         ffestb_local_.format.post.u.unsigned_val *= 10;
10110       ffestb_local_.format.post.u.unsigned_val += strtoul (ffelex_token_text (t),
10111                                                            NULL, 10);
10112       return (ffelexHandler) ffestb_R10016_;
10113
10114     case FFELEX_typeNAMES:
10115       ffesta_confirmed ();      /* NUMBER " " NAMES invalid elsewhere. */
10116       if (ffestb_local_.format.current != FFESTP_formattypeP)
10117         {
10118           ffesta_ffebad_1t (FFEBAD_FORMAT_TEXT_IN_NUMBER, t);
10119           return (ffelexHandler) ffestb_R10016_;
10120         }
10121       ffestb_subr_R1001_append_p_ ();
10122       ffestb_local_.format.sign = FALSE;
10123       ffestb_local_.format.pre = ffestb_local_.format.post;
10124       return (ffelexHandler) ffestb_R10014_ (t);
10125
10126     default:
10127       ffestb_local_.format.dot.present = FALSE;
10128       ffestb_local_.format.dot.rtexpr = FALSE;
10129       ffestb_local_.format.dot.t = NULL;
10130       ffestb_local_.format.dot.u.unsigned_val = 1;
10131       return (ffelexHandler) ffestb_R10018_ (t);
10132     }
10133 }
10134
10135 /* ffestb_R10017_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD
10136
10137    return ffestb_R10017_;  // to lexer
10138
10139    Here we've gotten the period following the edit descriptor.
10140    We expect either a NUMBER, for the dot value, or something else, which
10141    probably means we're not even close to being in a real FORMAT statement.  */
10142
10143 static ffelexHandler
10144 ffestb_R10017_ (ffelexToken t)
10145 {
10146   switch (ffelex_token_type (t))
10147     {
10148     case FFELEX_typeOPEN_ANGLE:
10149       ffestb_local_.format.dot.t = ffelex_token_use (t);
10150       ffelex_set_names_pure (FALSE);
10151       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
10152         {
10153           ffestb_local_.format.complained = TRUE;
10154           ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
10155           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10156           ffebad_finish ();
10157         }
10158       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
10159                   FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100117_);
10160
10161     case FFELEX_typeNUMBER:
10162       ffestb_local_.format.dot.present = TRUE;
10163       ffestb_local_.format.dot.rtexpr = FALSE;
10164       ffestb_local_.format.dot.t = ffelex_token_use (t);
10165       ffestb_local_.format.dot.u.unsigned_val
10166         = strtoul (ffelex_token_text (t), NULL, 10);
10167       return (ffelexHandler) ffestb_R10018_;
10168
10169     default:
10170       ffelex_token_kill (ffestb_local_.format.t);
10171       if (ffestb_local_.format.pre.present)
10172         ffelex_token_kill (ffestb_local_.format.pre.t);
10173       if (ffestb_local_.format.post.present)
10174         ffelex_token_kill (ffestb_local_.format.post.t);
10175       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_DOT, t);
10176       ffestt_formatlist_kill (ffestb_local_.format.f);
10177       return (ffelexHandler) ffelex_swallow_tokens (t,
10178                                                (ffelexHandler) ffesta_zero);
10179     }
10180 }
10181
10182 /* ffestb_R10018_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD NUMBER
10183
10184    return ffestb_R10018_;  // to lexer
10185
10186    Expect a NAMES here, which must begin with "E" to be valid.  Maybe find a
10187    NUMBER to append to the current number, in which case return to this state.
10188    Anything else, pass token on to state _10_.  */
10189
10190 static ffelexHandler
10191 ffestb_R10018_ (ffelexToken t)
10192 {
10193   ffeTokenLength i;
10194   char *p;
10195
10196   switch (ffelex_token_type (t))
10197     {
10198     case FFELEX_typeNUMBER:
10199       assert (ffestb_local_.format.dot.present);
10200       ffesta_confirmed ();
10201       if (ffestb_local_.format.dot.rtexpr)
10202         {
10203           ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
10204           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10205           ffebad_finish ();
10206           return (ffelexHandler) ffestb_R10018_;
10207         }
10208       for (i = ffelex_token_length (t) + 1; i > 0; --i)
10209         ffestb_local_.format.dot.u.unsigned_val *= 10;
10210       ffestb_local_.format.dot.u.unsigned_val += strtoul (ffelex_token_text (t),
10211                                                           NULL, 10);
10212       return (ffelexHandler) ffestb_R10018_;
10213
10214     case FFELEX_typeNAMES:
10215       if (!ffesrc_char_match_init (*(p = ffelex_token_text (t)), 'E', 'e'))
10216         {
10217           ffesta_ffebad_1t (FFEBAD_FORMAT_TEXT_IN_NUMBER, t);
10218           return (ffelexHandler) ffestb_R10018_;
10219         }
10220       if (*++p == '\0')
10221         return (ffelexHandler) ffestb_R10019_;  /* Go get NUMBER. */
10222       i = 1;
10223       if (!isdigit (*p))
10224         {
10225           ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, 1, NULL);
10226           return (ffelexHandler) ffestb_R10018_;
10227         }
10228       ffestb_local_.format.exp.present = TRUE;
10229       ffestb_local_.format.exp.rtexpr = FALSE;
10230       ffestb_local_.format.exp.t = ffelex_token_number_from_names (t, i);
10231       ffestb_local_.format.exp.u.unsigned_val
10232         = strtoul (ffelex_token_text (ffestb_local_.format.exp.t), NULL, 10);
10233       p += ffelex_token_length (ffestb_local_.format.exp.t);
10234       i += ffelex_token_length (ffestb_local_.format.exp.t);
10235       if (*p == '\0')
10236         return (ffelexHandler) ffestb_R100110_;
10237       ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
10238       return (ffelexHandler) ffestb_R100110_;
10239
10240     default:
10241       ffestb_local_.format.exp.present = FALSE;
10242       ffestb_local_.format.exp.rtexpr = FALSE;
10243       ffestb_local_.format.exp.t = NULL;
10244       ffestb_local_.format.exp.u.unsigned_val = 1;
10245       return (ffelexHandler) ffestb_R100110_ (t);
10246     }
10247 }
10248
10249 /* ffestb_R10019_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD NUMBER "E"
10250
10251    return ffestb_R10019_;  // to lexer
10252
10253    Here we've gotten the "E" following the edit descriptor.
10254    We expect either a NUMBER, for the exponent value, or something else.  */
10255
10256 static ffelexHandler
10257 ffestb_R10019_ (ffelexToken t)
10258 {
10259   switch (ffelex_token_type (t))
10260     {
10261     case FFELEX_typeOPEN_ANGLE:
10262       ffestb_local_.format.exp.t = ffelex_token_use (t);
10263       ffelex_set_names_pure (FALSE);
10264       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
10265         {
10266           ffestb_local_.format.complained = TRUE;
10267           ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
10268           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10269           ffebad_finish ();
10270         }
10271       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
10272                   FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100118_);
10273
10274     case FFELEX_typeNUMBER:
10275       ffestb_local_.format.exp.present = TRUE;
10276       ffestb_local_.format.exp.rtexpr = FALSE;
10277       ffestb_local_.format.exp.t = ffelex_token_use (t);
10278       ffestb_local_.format.exp.u.unsigned_val
10279         = strtoul (ffelex_token_text (t), NULL, 10);
10280       return (ffelexHandler) ffestb_R100110_;
10281
10282     default:
10283       ffelex_token_kill (ffestb_local_.format.t);
10284       if (ffestb_local_.format.pre.present)
10285         ffelex_token_kill (ffestb_local_.format.pre.t);
10286       if (ffestb_local_.format.post.present)
10287         ffelex_token_kill (ffestb_local_.format.post.t);
10288       if (ffestb_local_.format.dot.present)
10289         ffelex_token_kill (ffestb_local_.format.dot.t);
10290       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_EXP, t);
10291       ffestt_formatlist_kill (ffestb_local_.format.f);
10292       return (ffelexHandler) ffelex_swallow_tokens (t,
10293                                                (ffelexHandler) ffesta_zero);
10294     }
10295 }
10296
10297 /* ffestb_R100110_ -- [[+/-] NUMBER] NAMES NUMBER [PERIOD NUMBER ["E" NUMBER]]
10298
10299    return ffestb_R100110_;  // to lexer
10300
10301    Maybe find a NUMBER to append to the current number, in which case return
10302    to this state.  Anything else, handle current descriptor, then pass token
10303    on to state _10_.  */
10304
10305 static ffelexHandler
10306 ffestb_R100110_ (ffelexToken t)
10307 {
10308   ffeTokenLength i;
10309   enum expect
10310     {
10311       required,
10312       optional,
10313       disallowed
10314     };
10315   ffebad err;
10316   enum expect pre;
10317   enum expect post;
10318   enum expect dot;
10319   enum expect exp;
10320   bool R1005;
10321   ffesttFormatList f;
10322
10323   switch (ffelex_token_type (t))
10324     {
10325     case FFELEX_typeNUMBER:
10326       assert (ffestb_local_.format.exp.present);
10327       ffesta_confirmed ();
10328       if (ffestb_local_.format.exp.rtexpr)
10329         {
10330           ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
10331           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10332           ffebad_finish ();
10333           return (ffelexHandler) ffestb_R100110_;
10334         }
10335       for (i = ffelex_token_length (t) + 1; i > 0; --i)
10336         ffestb_local_.format.exp.u.unsigned_val *= 10;
10337       ffestb_local_.format.exp.u.unsigned_val += strtoul (ffelex_token_text (t),
10338                                                           NULL, 10);
10339       return (ffelexHandler) ffestb_R100110_;
10340
10341     default:
10342       if (ffestb_local_.format.sign
10343           && (ffestb_local_.format.current != FFESTP_formattypeP)
10344           && (ffestb_local_.format.current != FFESTP_formattypeH))
10345         {
10346           ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
10347           ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
10348                     ffelex_token_where_column (ffestb_local_.format.pre.t));
10349           ffebad_finish ();
10350           ffestb_local_.format.pre.u.unsigned_val
10351             = (ffestb_local_.format.pre.u.signed_val < 0)
10352             ? -ffestb_local_.format.pre.u.signed_val
10353             : ffestb_local_.format.pre.u.signed_val;
10354         }
10355       switch (ffestb_local_.format.current)
10356         {
10357         case FFESTP_formattypeI:
10358           err = FFEBAD_FORMAT_BAD_I_SPEC;
10359           pre = optional;
10360           post = required;
10361           dot = optional;
10362           exp = disallowed;
10363           R1005 = TRUE;
10364           break;
10365
10366         case FFESTP_formattypeB:
10367           err = FFEBAD_FORMAT_BAD_B_SPEC;
10368           pre = optional;
10369           post = required;
10370           dot = optional;
10371           exp = disallowed;
10372           R1005 = TRUE;
10373           break;
10374
10375         case FFESTP_formattypeO:
10376           err = FFEBAD_FORMAT_BAD_O_SPEC;
10377           pre = optional;
10378           post = required;
10379           dot = optional;
10380           exp = disallowed;
10381           R1005 = TRUE;
10382           break;
10383
10384         case FFESTP_formattypeZ:
10385           err = FFEBAD_FORMAT_BAD_Z_SPEC;
10386           pre = optional;
10387           post = required;
10388           dot = optional;
10389           exp = disallowed;
10390           R1005 = TRUE;
10391           break;
10392
10393         case FFESTP_formattypeF:
10394           err = FFEBAD_FORMAT_BAD_F_SPEC;
10395           pre = optional;
10396           post = required;
10397           dot = required;
10398           exp = disallowed;
10399           R1005 = TRUE;
10400           break;
10401
10402         case FFESTP_formattypeE:
10403           err = FFEBAD_FORMAT_BAD_E_SPEC;
10404           pre = optional;
10405           post = required;
10406           dot = required;
10407           exp = optional;
10408           R1005 = TRUE;
10409           break;
10410
10411         case FFESTP_formattypeEN:
10412           err = FFEBAD_FORMAT_BAD_EN_SPEC;
10413           pre = optional;
10414           post = required;
10415           dot = required;
10416           exp = optional;
10417           R1005 = TRUE;
10418           break;
10419
10420         case FFESTP_formattypeG:
10421           err = FFEBAD_FORMAT_BAD_G_SPEC;
10422           pre = optional;
10423           post = required;
10424           dot = required;
10425           exp = optional;
10426           R1005 = TRUE;
10427           break;
10428
10429         case FFESTP_formattypeL:
10430           err = FFEBAD_FORMAT_BAD_L_SPEC;
10431           pre = optional;
10432           post = required;
10433           dot = disallowed;
10434           exp = disallowed;
10435           R1005 = TRUE;
10436           break;
10437
10438         case FFESTP_formattypeA:
10439           err = FFEBAD_FORMAT_BAD_A_SPEC;
10440           pre = optional;
10441           post = optional;
10442           dot = disallowed;
10443           exp = disallowed;
10444           R1005 = TRUE;
10445           break;
10446
10447         case FFESTP_formattypeD:
10448           err = FFEBAD_FORMAT_BAD_D_SPEC;
10449           pre = optional;
10450           post = required;
10451           dot = required;
10452           exp = disallowed;
10453           R1005 = TRUE;
10454           break;
10455
10456         case FFESTP_formattypeQ:
10457           err = FFEBAD_FORMAT_BAD_Q_SPEC;
10458           pre = disallowed;
10459           post = disallowed;
10460           dot = disallowed;
10461           exp = disallowed;
10462           R1005 = FALSE;
10463           break;
10464
10465         case FFESTP_formattypeDOLLAR:
10466           err = FFEBAD_FORMAT_BAD_DOLLAR_SPEC;
10467           pre = disallowed;
10468           post = disallowed;
10469           dot = disallowed;
10470           exp = disallowed;
10471           R1005 = FALSE;
10472           break;
10473
10474         case FFESTP_formattypeP:
10475           err = FFEBAD_FORMAT_BAD_P_SPEC;
10476           pre = required;
10477           post = disallowed;
10478           dot = disallowed;
10479           exp = disallowed;
10480           R1005 = FALSE;
10481           break;
10482
10483         case FFESTP_formattypeT:
10484           err = FFEBAD_FORMAT_BAD_T_SPEC;
10485           pre = disallowed;
10486           post = required;
10487           dot = disallowed;
10488           exp = disallowed;
10489           R1005 = FALSE;
10490           break;
10491
10492         case FFESTP_formattypeTL:
10493           err = FFEBAD_FORMAT_BAD_TL_SPEC;
10494           pre = disallowed;
10495           post = required;
10496           dot = disallowed;
10497           exp = disallowed;
10498           R1005 = FALSE;
10499           break;
10500
10501         case FFESTP_formattypeTR:
10502           err = FFEBAD_FORMAT_BAD_TR_SPEC;
10503           pre = disallowed;
10504           post = required;
10505           dot = disallowed;
10506           exp = disallowed;
10507           R1005 = FALSE;
10508           break;
10509
10510         case FFESTP_formattypeX:
10511           err = FFEBAD_FORMAT_BAD_X_SPEC;
10512           pre = required;
10513           post = disallowed;
10514           dot = disallowed;
10515           exp = disallowed;
10516           R1005 = FALSE;
10517           break;
10518
10519         case FFESTP_formattypeS:
10520           err = FFEBAD_FORMAT_BAD_S_SPEC;
10521           pre = disallowed;
10522           post = disallowed;
10523           dot = disallowed;
10524           exp = disallowed;
10525           R1005 = FALSE;
10526           break;
10527
10528         case FFESTP_formattypeSP:
10529           err = FFEBAD_FORMAT_BAD_SP_SPEC;
10530           pre = disallowed;
10531           post = disallowed;
10532           dot = disallowed;
10533           exp = disallowed;
10534           R1005 = FALSE;
10535           break;
10536
10537         case FFESTP_formattypeSS:
10538           err = FFEBAD_FORMAT_BAD_SS_SPEC;
10539           pre = disallowed;
10540           post = disallowed;
10541           dot = disallowed;
10542           exp = disallowed;
10543           R1005 = FALSE;
10544           break;
10545
10546         case FFESTP_formattypeBN:
10547           err = FFEBAD_FORMAT_BAD_BN_SPEC;
10548           pre = disallowed;
10549           post = disallowed;
10550           dot = disallowed;
10551           exp = disallowed;
10552           R1005 = FALSE;
10553           break;
10554
10555         case FFESTP_formattypeBZ:
10556           err = FFEBAD_FORMAT_BAD_BZ_SPEC;
10557           pre = disallowed;
10558           post = disallowed;
10559           dot = disallowed;
10560           exp = disallowed;
10561           R1005 = FALSE;
10562           break;
10563
10564         case FFESTP_formattypeH:        /* Definitely an error, make sure of
10565                                            it. */
10566           err = FFEBAD_FORMAT_BAD_H_SPEC;
10567           pre = ffestb_local_.format.pre.present ? disallowed : required;
10568           post = disallowed;
10569           dot = disallowed;
10570           exp = disallowed;
10571           R1005 = FALSE;
10572           break;
10573
10574         case FFESTP_formattypeNone:
10575           ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_SPEC,
10576                             ffestb_local_.format.t);
10577
10578         clean_up_to_11_:        /* :::::::::::::::::::: */
10579
10580           ffelex_token_kill (ffestb_local_.format.t);
10581           if (ffestb_local_.format.pre.present)
10582             ffelex_token_kill (ffestb_local_.format.pre.t);
10583           if (ffestb_local_.format.post.present)
10584             ffelex_token_kill (ffestb_local_.format.post.t);
10585           if (ffestb_local_.format.dot.present)
10586             ffelex_token_kill (ffestb_local_.format.dot.t);
10587           if (ffestb_local_.format.exp.present)
10588             ffelex_token_kill (ffestb_local_.format.exp.t);
10589           return (ffelexHandler) ffestb_R100111_ (t);
10590
10591         default:
10592           assert ("bad format item" == NULL);
10593           err = FFEBAD_FORMAT_BAD_H_SPEC;
10594           pre = disallowed;
10595           post = disallowed;
10596           dot = disallowed;
10597           exp = disallowed;
10598           R1005 = FALSE;
10599           break;
10600         }
10601       if (((pre == disallowed) && ffestb_local_.format.pre.present)
10602           || ((pre == required) && !ffestb_local_.format.pre.present))
10603         {
10604           ffesta_ffebad_1t (err, (pre == required)
10605                      ? ffestb_local_.format.t : ffestb_local_.format.pre.t);
10606           goto clean_up_to_11_; /* :::::::::::::::::::: */
10607         }
10608       if (((post == disallowed) && ffestb_local_.format.post.present)
10609           || ((post == required) && !ffestb_local_.format.post.present))
10610         {
10611           ffesta_ffebad_1t (err, (post == required)
10612                     ? ffestb_local_.format.t : ffestb_local_.format.post.t);
10613           goto clean_up_to_11_; /* :::::::::::::::::::: */
10614         }
10615       if (((dot == disallowed) && ffestb_local_.format.dot.present)
10616           || ((dot == required) && !ffestb_local_.format.dot.present))
10617         {
10618           ffesta_ffebad_1t (err, (dot == required)
10619                      ? ffestb_local_.format.t : ffestb_local_.format.dot.t);
10620           goto clean_up_to_11_; /* :::::::::::::::::::: */
10621         }
10622       if (((exp == disallowed) && ffestb_local_.format.exp.present)
10623           || ((exp == required) && !ffestb_local_.format.exp.present))
10624         {
10625           ffesta_ffebad_1t (err, (exp == required)
10626                      ? ffestb_local_.format.t : ffestb_local_.format.exp.t);
10627           goto clean_up_to_11_; /* :::::::::::::::::::: */
10628         }
10629       f = ffestt_formatlist_append (ffestb_local_.format.f);
10630       f->type = ffestb_local_.format.current;
10631       f->t = ffestb_local_.format.t;
10632       if (R1005)
10633         {
10634           f->u.R1005.R1004 = ffestb_local_.format.pre;
10635           f->u.R1005.R1006 = ffestb_local_.format.post;
10636           f->u.R1005.R1007_or_R1008 = ffestb_local_.format.dot;
10637           f->u.R1005.R1009 = ffestb_local_.format.exp;
10638         }
10639       else
10640         /* Must be R1010. */
10641         {
10642           if (pre == disallowed)
10643             f->u.R1010.val = ffestb_local_.format.post;
10644           else
10645             f->u.R1010.val = ffestb_local_.format.pre;
10646         }
10647       return (ffelexHandler) ffestb_R100111_ (t);
10648     }
10649 }
10650
10651 /* ffestb_R100111_ -- edit-descriptor
10652
10653    return ffestb_R100111_;  // to lexer
10654
10655    Expect a COMMA, CLOSE_PAREN, CLOSE_ARRAY, COLON, COLONCOLON, SLASH, or
10656    CONCAT, or complain about missing comma.  */
10657
10658 static ffelexHandler
10659 ffestb_R100111_ (ffelexToken t)
10660 {
10661   ffesttFormatList f;
10662
10663   switch (ffelex_token_type (t))
10664     {
10665     case FFELEX_typeCOMMA:
10666       return (ffelexHandler) ffestb_R10012_;
10667
10668     case FFELEX_typeCOLON:
10669     case FFELEX_typeCOLONCOLON:
10670     case FFELEX_typeSLASH:
10671     case FFELEX_typeCONCAT:
10672       return (ffelexHandler) ffestb_R10012_ (t);
10673
10674     case FFELEX_typeCLOSE_PAREN:
10675       f = ffestb_local_.format.f->u.root.parent;
10676       if (f == NULL)
10677         return (ffelexHandler) ffestb_R100114_;
10678       ffestb_local_.format.f = f->next;
10679       return (ffelexHandler) ffestb_R100111_;
10680
10681     case FFELEX_typeCLOSE_ARRAY:        /* "/)". */
10682       f = ffestt_formatlist_append (ffestb_local_.format.f);
10683       f->type = FFESTP_formattypeSLASH;
10684       f->t = ffelex_token_use (t);
10685       f->u.R1010.val.present = FALSE;
10686       f->u.R1010.val.rtexpr = FALSE;
10687       f->u.R1010.val.t = NULL;
10688       f->u.R1010.val.u.unsigned_val = 1;
10689       f = ffestb_local_.format.f->u.root.parent;
10690       if (f == NULL)
10691         return (ffelexHandler) ffestb_R100114_;
10692       ffestb_local_.format.f = f->next;
10693       return (ffelexHandler) ffestb_R100111_;
10694
10695     case FFELEX_typeOPEN_ANGLE:
10696     case FFELEX_typeDOLLAR:
10697     case FFELEX_typeNUMBER:
10698     case FFELEX_typeOPEN_PAREN:
10699     case FFELEX_typeOPEN_ARRAY:
10700     case FFELEX_typeQUOTE:
10701     case FFELEX_typeAPOSTROPHE:
10702     case FFELEX_typeNAMES:
10703       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_COMMA, t);
10704       return (ffelexHandler) ffestb_R10012_ (t);
10705
10706     case FFELEX_typeEOS:
10707     case FFELEX_typeSEMICOLON:
10708       ffesta_confirmed ();
10709       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
10710       for (f = ffestb_local_.format.f;
10711            f->u.root.parent != NULL;
10712            f = f->u.root.parent->next)
10713         ;
10714       ffestb_local_.format.f = f;
10715       return (ffelexHandler) ffestb_R100114_ (t);
10716
10717     default:
10718       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10719       ffestt_formatlist_kill (ffestb_local_.format.f);
10720       return (ffelexHandler) ffelex_swallow_tokens (t,
10721                                                (ffelexHandler) ffesta_zero);
10722     }
10723 }
10724
10725 /* ffestb_R100112_ -- COLON, COLONCOLON, SLASH, OPEN_ARRAY, or CONCAT
10726
10727    return ffestb_R100112_;  // to lexer
10728
10729    Like _11_ except the COMMA is optional.  */
10730
10731 static ffelexHandler
10732 ffestb_R100112_ (ffelexToken t)
10733 {
10734   ffesttFormatList f;
10735
10736   switch (ffelex_token_type (t))
10737     {
10738     case FFELEX_typeCOMMA:
10739       return (ffelexHandler) ffestb_R10012_;
10740
10741     case FFELEX_typeCOLON:
10742     case FFELEX_typeCOLONCOLON:
10743     case FFELEX_typeSLASH:
10744     case FFELEX_typeCONCAT:
10745     case FFELEX_typeOPEN_ANGLE:
10746     case FFELEX_typeNAMES:
10747     case FFELEX_typeDOLLAR:
10748     case FFELEX_typeNUMBER:
10749     case FFELEX_typeOPEN_PAREN:
10750     case FFELEX_typeOPEN_ARRAY:
10751     case FFELEX_typeQUOTE:
10752     case FFELEX_typeAPOSTROPHE:
10753     case FFELEX_typePLUS:
10754     case FFELEX_typeMINUS:
10755       return (ffelexHandler) ffestb_R10012_ (t);
10756
10757     case FFELEX_typeCLOSE_PAREN:
10758       f = ffestb_local_.format.f->u.root.parent;
10759       if (f == NULL)
10760         return (ffelexHandler) ffestb_R100114_;
10761       ffestb_local_.format.f = f->next;
10762       return (ffelexHandler) ffestb_R100111_;
10763
10764     case FFELEX_typeCLOSE_ARRAY:        /* "/)". */
10765       f = ffestt_formatlist_append (ffestb_local_.format.f);
10766       f->type = FFESTP_formattypeSLASH;
10767       f->t = ffelex_token_use (t);
10768       f->u.R1010.val.present = FALSE;
10769       f->u.R1010.val.rtexpr = FALSE;
10770       f->u.R1010.val.t = NULL;
10771       f->u.R1010.val.u.unsigned_val = 1;
10772       f = ffestb_local_.format.f->u.root.parent;
10773       if (f == NULL)
10774         return (ffelexHandler) ffestb_R100114_;
10775       ffestb_local_.format.f = f->next;
10776       return (ffelexHandler) ffestb_R100111_;
10777
10778     case FFELEX_typeEOS:
10779     case FFELEX_typeSEMICOLON:
10780       ffesta_confirmed ();
10781       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
10782       for (f = ffestb_local_.format.f;
10783            f->u.root.parent != NULL;
10784            f = f->u.root.parent->next)
10785         ;
10786       ffestb_local_.format.f = f;
10787       return (ffelexHandler) ffestb_R100114_ (t);
10788
10789     default:
10790       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10791       ffestt_formatlist_kill (ffestb_local_.format.f);
10792       return (ffelexHandler) ffelex_swallow_tokens (t,
10793                                                (ffelexHandler) ffesta_zero);
10794     }
10795 }
10796
10797 /* ffestb_R100113_ -- Handle CHARACTER token.
10798
10799    return ffestb_R100113_;  // to lexer
10800
10801    Append the format item to the list, go to _11_.  */
10802
10803 static ffelexHandler
10804 ffestb_R100113_ (ffelexToken t)
10805 {
10806   ffesttFormatList f;
10807
10808   assert (ffelex_token_type (t) == FFELEX_typeCHARACTER);
10809
10810   if (ffe_is_pedantic_not_90 () && (ffelex_token_length (t) == 0))
10811     {
10812       ffebad_start (FFEBAD_NULL_CHAR_CONST);
10813       ffebad_here (0, ffelex_token_where_line (t),
10814                    ffelex_token_where_column (t));
10815       ffebad_finish ();
10816     }
10817
10818   f = ffestt_formatlist_append (ffestb_local_.format.f);
10819   f->type = FFESTP_formattypeR1016;
10820   f->t = ffelex_token_use (t);
10821   return (ffelexHandler) ffestb_R100111_;
10822 }
10823
10824 /* ffestb_R100114_ -- "FORMAT" OPEN_PAREN format-item-list CLOSE_PAREN
10825
10826    return ffestb_R100114_;  // to lexer
10827
10828    Handle EOS/SEMICOLON or something else.  */
10829
10830 static ffelexHandler
10831 ffestb_R100114_ (ffelexToken t)
10832 {
10833   ffelex_set_names_pure (FALSE);
10834
10835   switch (ffelex_token_type (t))
10836     {
10837     case FFELEX_typeEOS:
10838     case FFELEX_typeSEMICOLON:
10839       ffesta_confirmed ();
10840       if (!ffesta_is_inhibited () && !ffestb_local_.format.complained)
10841         ffestc_R1001 (ffestb_local_.format.f);
10842       ffestt_formatlist_kill (ffestb_local_.format.f);
10843       return (ffelexHandler) ffesta_zero (t);
10844
10845     default:
10846       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10847       ffestt_formatlist_kill (ffestb_local_.format.f);
10848       return (ffelexHandler) ffelex_swallow_tokens (t,
10849                                                (ffelexHandler) ffesta_zero);
10850     }
10851 }
10852
10853 /* ffestb_R100115_ -- OPEN_ANGLE expr
10854
10855    (ffestb_R100115_)  // to expression handler
10856
10857    Handle expression prior to the edit descriptor.  */
10858
10859 static ffelexHandler
10860 ffestb_R100115_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10861 {
10862   switch (ffelex_token_type (t))
10863     {
10864     case FFELEX_typeCLOSE_ANGLE:
10865       ffestb_local_.format.pre.present = TRUE;
10866       ffestb_local_.format.pre.rtexpr = TRUE;
10867       ffestb_local_.format.pre.u.expr = expr;
10868       ffelex_set_names_pure (TRUE);
10869       return (ffelexHandler) ffestb_R10014_;
10870
10871     default:
10872       ffelex_token_kill (ffestb_local_.format.pre.t);
10873       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10874       ffestt_formatlist_kill (ffestb_local_.format.f);
10875       return (ffelexHandler) ffelex_swallow_tokens (t,
10876                                                (ffelexHandler) ffesta_zero);
10877     }
10878 }
10879
10880 /* ffestb_R100116_ -- "[n]X" OPEN_ANGLE expr
10881
10882    (ffestb_R100116_)  // to expression handler
10883
10884    Handle expression after the edit descriptor.  */
10885
10886 static ffelexHandler
10887 ffestb_R100116_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10888 {
10889   switch (ffelex_token_type (t))
10890     {
10891     case FFELEX_typeCLOSE_ANGLE:
10892       ffestb_local_.format.post.present = TRUE;
10893       ffestb_local_.format.post.rtexpr = TRUE;
10894       ffestb_local_.format.post.u.expr = expr;
10895       ffelex_set_names_pure (TRUE);
10896       return (ffelexHandler) ffestb_R10016_;
10897
10898     default:
10899       ffelex_token_kill (ffestb_local_.format.t);
10900       ffelex_token_kill (ffestb_local_.format.post.t);
10901       if (ffestb_local_.format.pre.present)
10902         ffelex_token_kill (ffestb_local_.format.pre.t);
10903       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10904       ffestt_formatlist_kill (ffestb_local_.format.f);
10905       return (ffelexHandler) ffelex_swallow_tokens (t,
10906                                                (ffelexHandler) ffesta_zero);
10907     }
10908 }
10909
10910 /* ffestb_R100117_ -- "[n]X[n]." OPEN_ANGLE expr
10911
10912    (ffestb_R100117_)  // to expression handler
10913
10914    Handle expression after the PERIOD.  */
10915
10916 static ffelexHandler
10917 ffestb_R100117_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10918 {
10919   switch (ffelex_token_type (t))
10920     {
10921     case FFELEX_typeCLOSE_ANGLE:
10922       ffestb_local_.format.dot.present = TRUE;
10923       ffestb_local_.format.dot.rtexpr = TRUE;
10924       ffestb_local_.format.dot.u.expr = expr;
10925       ffelex_set_names_pure (TRUE);
10926       return (ffelexHandler) ffestb_R10018_;
10927
10928     default:
10929       ffelex_token_kill (ffestb_local_.format.t);
10930       ffelex_token_kill (ffestb_local_.format.dot.t);
10931       if (ffestb_local_.format.pre.present)
10932         ffelex_token_kill (ffestb_local_.format.pre.t);
10933       if (ffestb_local_.format.post.present)
10934         ffelex_token_kill (ffestb_local_.format.post.t);
10935       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10936       ffestt_formatlist_kill (ffestb_local_.format.f);
10937       return (ffelexHandler) ffelex_swallow_tokens (t,
10938                                                (ffelexHandler) ffesta_zero);
10939     }
10940 }
10941
10942 /* ffestb_R100118_ -- "[n]X[n].[n]E" OPEN_ANGLE expr
10943
10944    (ffestb_R100118_)  // to expression handler
10945
10946    Handle expression after the "E".  */
10947
10948 static ffelexHandler
10949 ffestb_R100118_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10950 {
10951   switch (ffelex_token_type (t))
10952     {
10953     case FFELEX_typeCLOSE_ANGLE:
10954       ffestb_local_.format.exp.present = TRUE;
10955       ffestb_local_.format.exp.rtexpr = TRUE;
10956       ffestb_local_.format.exp.u.expr = expr;
10957       ffelex_set_names_pure (TRUE);
10958       return (ffelexHandler) ffestb_R100110_;
10959
10960     default:
10961       ffelex_token_kill (ffestb_local_.format.t);
10962       ffelex_token_kill (ffestb_local_.format.exp.t);
10963       if (ffestb_local_.format.pre.present)
10964         ffelex_token_kill (ffestb_local_.format.pre.t);
10965       if (ffestb_local_.format.post.present)
10966         ffelex_token_kill (ffestb_local_.format.post.t);
10967       if (ffestb_local_.format.dot.present)
10968         ffelex_token_kill (ffestb_local_.format.dot.t);
10969       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10970       ffestt_formatlist_kill (ffestb_local_.format.f);
10971       return (ffelexHandler) ffelex_swallow_tokens (t,
10972                                                (ffelexHandler) ffesta_zero);
10973     }
10974 }
10975
10976 /* ffestb_R1107 -- Parse the USE statement
10977
10978    return ffestb_R1107;  // to lexer
10979
10980    Make sure the statement has a valid form for the USE statement.
10981    If it does, implement the statement.  */
10982
10983 #if FFESTR_F90
10984 ffelexHandler
10985 ffestb_R1107 (ffelexToken t)
10986 {
10987   ffeTokenLength i;
10988   char *p;
10989
10990   switch (ffelex_token_type (ffesta_tokens[0]))
10991     {
10992     case FFELEX_typeNAME:
10993       if (ffesta_first_kw != FFESTR_firstUSE)
10994         goto bad_0;             /* :::::::::::::::::::: */
10995       switch (ffelex_token_type (t))
10996         {
10997         case FFELEX_typeNAME:
10998           break;
10999
11000         case FFELEX_typeEOS:
11001         case FFELEX_typeSEMICOLON:
11002         case FFELEX_typeCOMMA:
11003         case FFELEX_typeCOLONCOLON:
11004           ffesta_confirmed ();  /* Error, but clearly intended. */
11005           goto bad_1;           /* :::::::::::::::::::: */
11006
11007         default:
11008           goto bad_0;           /* :::::::::::::::::::: */
11009         }
11010       ffesta_confirmed ();
11011       ffesta_tokens[1] = ffelex_token_use (t);
11012       return (ffelexHandler) ffestb_R11071_;
11013
11014     case FFELEX_typeNAMES:
11015       if (ffesta_first_kw != FFESTR_firstUSE)
11016         goto bad_0;             /* :::::::::::::::::::: */
11017       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlUSE);
11018       if (!ffesrc_is_name_init (*p))
11019         goto bad_i;             /* :::::::::::::::::::: */
11020       switch (ffelex_token_type (t))
11021         {
11022         case FFELEX_typeCOLONCOLON:
11023           ffesta_confirmed ();  /* Error, but clearly intended. */
11024           goto bad_1;           /* :::::::::::::::::::: */
11025
11026         default:
11027           goto bad_1;           /* :::::::::::::::::::: */
11028
11029         case FFELEX_typeCOMMA:
11030         case FFELEX_typeEOS:
11031         case FFELEX_typeSEMICOLON:
11032           break;
11033         }
11034       ffesta_confirmed ();
11035       ffesta_tokens[1]
11036         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
11037       return (ffelexHandler) ffestb_R11071_ (t);
11038
11039     default:
11040       goto bad_0;               /* :::::::::::::::::::: */
11041     }
11042
11043 bad_0:                          /* :::::::::::::::::::: */
11044   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", ffesta_tokens[0]);
11045   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11046
11047 bad_1:                          /* :::::::::::::::::::: */
11048   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11049   return (ffelexHandler) ffelex_swallow_tokens (t,
11050                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
11051
11052 bad_i:                          /* :::::::::::::::::::: */
11053   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "USE", ffesta_tokens[0], i, t);
11054   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11055 }
11056
11057 /* ffestb_R11071_ -- "USE" NAME
11058
11059    return ffestb_R11071_;  // to lexer
11060
11061    Make sure the statement has a valid form for the USE statement.  If it
11062    does, implement the statement.  */
11063
11064 static ffelexHandler
11065 ffestb_R11071_ (ffelexToken t)
11066 {
11067   switch (ffelex_token_type (t))
11068     {
11069     case FFELEX_typeEOS:
11070     case FFELEX_typeSEMICOLON:
11071       if (!ffesta_is_inhibited ())
11072         {
11073           ffestc_R1107_start (ffesta_tokens[1], FALSE);
11074           ffestc_R1107_finish ();
11075         }
11076       ffelex_token_kill (ffesta_tokens[1]);
11077       return (ffelexHandler) ffesta_zero (t);
11078
11079     case FFELEX_typeCOMMA:
11080       return (ffelexHandler) ffestb_R11072_;
11081
11082     default:
11083       break;
11084     }
11085
11086   ffelex_token_kill (ffesta_tokens[1]);
11087   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11088   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11089 }
11090
11091 /* ffestb_R11072_ -- "USE" NAME COMMA
11092
11093    return ffestb_R11072_;  // to lexer
11094
11095    Make sure the statement has a valid form for the USE statement.  If it
11096    does, implement the statement.  */
11097
11098 static ffelexHandler
11099 ffestb_R11072_ (ffelexToken t)
11100 {
11101   switch (ffelex_token_type (t))
11102     {
11103     case FFELEX_typeNAME:
11104       ffesta_tokens[2] = ffelex_token_use (t);
11105       return (ffelexHandler) ffestb_R11073_;
11106
11107     default:
11108       break;
11109     }
11110
11111   ffelex_token_kill (ffesta_tokens[1]);
11112   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11113   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11114 }
11115
11116 /* ffestb_R11073_ -- "USE" NAME COMMA NAME
11117
11118    return ffestb_R11073_;  // to lexer
11119
11120    Make sure the statement has a valid form for the USE statement.  If it
11121    does, implement the statement.  */
11122
11123 static ffelexHandler
11124 ffestb_R11073_ (ffelexToken t)
11125 {
11126   switch (ffelex_token_type (t))
11127     {
11128     case FFELEX_typeCOLON:
11129       if (ffestr_other (ffesta_tokens[2]) != FFESTR_otherONLY)
11130         break;
11131       if (!ffesta_is_inhibited ())
11132         ffestc_R1107_start (ffesta_tokens[1], TRUE);
11133       ffelex_token_kill (ffesta_tokens[1]);
11134       ffelex_token_kill (ffesta_tokens[2]);
11135       return (ffelexHandler) ffestb_R11074_;
11136
11137     case FFELEX_typePOINTS:
11138       if (!ffesta_is_inhibited ())
11139         ffestc_R1107_start (ffesta_tokens[1], FALSE);
11140       ffelex_token_kill (ffesta_tokens[1]);
11141       ffesta_tokens[1] = ffesta_tokens[2];
11142       return (ffelexHandler) ffestb_R110711_;
11143
11144     default:
11145       break;
11146     }
11147
11148   ffelex_token_kill (ffesta_tokens[1]);
11149   ffelex_token_kill (ffesta_tokens[2]);
11150   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11151   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11152 }
11153
11154 /* ffestb_R11074_ -- "USE" NAME COMMA "ONLY" COLON
11155
11156    return ffestb_R11074_;  // to lexer
11157
11158    Make sure the statement has a valid form for the USE statement.  If it
11159    does, implement the statement.  */
11160
11161 static ffelexHandler
11162 ffestb_R11074_ (ffelexToken t)
11163 {
11164   switch (ffelex_token_type (t))
11165     {
11166     case FFELEX_typeNAME:
11167       ffesta_tokens[1] = ffelex_token_use (t);
11168       return (ffelexHandler) ffestb_R11075_;
11169
11170     case FFELEX_typeEOS:
11171     case FFELEX_typeSEMICOLON:
11172       if (!ffesta_is_inhibited ())
11173         ffestc_R1107_finish ();
11174       return (ffelexHandler) ffesta_zero (t);
11175
11176     default:
11177       break;
11178     }
11179
11180   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11181   ffestc_R1107_finish ();
11182   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11183 }
11184
11185 /* ffestb_R11075_ -- "USE" NAME COMMA "ONLY" COLON NAME
11186
11187    return ffestb_R11075_;  // to lexer
11188
11189    Make sure the statement has a valid form for the USE statement.  If it
11190    does, implement the statement.  */
11191
11192 static ffelexHandler
11193 ffestb_R11075_ (ffelexToken t)
11194 {
11195   switch (ffelex_token_type (t))
11196     {
11197     case FFELEX_typeEOS:
11198     case FFELEX_typeSEMICOLON:
11199       if (!ffesta_is_inhibited ())
11200         {
11201           ffestc_R1107_item (NULL, ffesta_tokens[1]);
11202           ffestc_R1107_finish ();
11203         }
11204       ffelex_token_kill (ffesta_tokens[1]);
11205       return (ffelexHandler) ffesta_zero (t);
11206
11207     case FFELEX_typeCOMMA:
11208       if (!ffesta_is_inhibited ())
11209         ffestc_R1107_item (NULL, ffesta_tokens[1]);
11210       ffelex_token_kill (ffesta_tokens[1]);
11211       return (ffelexHandler) ffestb_R11078_;
11212
11213     case FFELEX_typePOINTS:
11214       return (ffelexHandler) ffestb_R11076_;
11215
11216     default:
11217       break;
11218     }
11219
11220   ffelex_token_kill (ffesta_tokens[1]);
11221   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11222   ffestc_R1107_finish ();
11223   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11224 }
11225
11226 /* ffestb_R11076_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS
11227
11228    return ffestb_R11076_;  // to lexer
11229
11230    Make sure the statement has a valid form for the USE statement.  If it
11231    does, implement the statement.  */
11232
11233 static ffelexHandler
11234 ffestb_R11076_ (ffelexToken t)
11235 {
11236   switch (ffelex_token_type (t))
11237     {
11238     case FFELEX_typeNAME:
11239       if (!ffesta_is_inhibited ())
11240         ffestc_R1107_item (ffesta_tokens[1], t);
11241       ffelex_token_kill (ffesta_tokens[1]);
11242       return (ffelexHandler) ffestb_R11077_;
11243
11244     default:
11245       break;
11246     }
11247
11248   ffelex_token_kill (ffesta_tokens[1]);
11249   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11250   ffestc_R1107_finish ();
11251   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11252 }
11253
11254 /* ffestb_R11077_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS NAME
11255
11256    return ffestb_R11077_;  // to lexer
11257
11258    Make sure the statement has a valid form for the USE statement.  If it
11259    does, implement the statement.  */
11260
11261 static ffelexHandler
11262 ffestb_R11077_ (ffelexToken t)
11263 {
11264   switch (ffelex_token_type (t))
11265     {
11266     case FFELEX_typeEOS:
11267     case FFELEX_typeSEMICOLON:
11268       if (!ffesta_is_inhibited ())
11269         ffestc_R1107_finish ();
11270       return (ffelexHandler) ffesta_zero (t);
11271
11272     case FFELEX_typeCOMMA:
11273       return (ffelexHandler) ffestb_R11078_;
11274
11275     default:
11276       break;
11277     }
11278
11279   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11280   ffestc_R1107_finish ();
11281   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11282 }
11283
11284 /* ffestb_R11078_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS NAME COMMA
11285
11286    return ffestb_R11078_;  // to lexer
11287
11288    Make sure the statement has a valid form for the USE statement.  If it
11289    does, implement the statement.  */
11290
11291 static ffelexHandler
11292 ffestb_R11078_ (ffelexToken t)
11293 {
11294   switch (ffelex_token_type (t))
11295     {
11296     case FFELEX_typeNAME:
11297       ffesta_tokens[1] = ffelex_token_use (t);
11298       return (ffelexHandler) ffestb_R11075_;
11299
11300     default:
11301       break;
11302     }
11303
11304   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11305   ffestc_R1107_finish ();
11306   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11307 }
11308
11309 /* ffestb_R11079_ -- "USE" NAME COMMA
11310
11311    return ffestb_R11079_;  // to lexer
11312
11313    Make sure the statement has a valid form for the USE statement.  If it
11314    does, implement the statement.  */
11315
11316 static ffelexHandler
11317 ffestb_R11079_ (ffelexToken t)
11318 {
11319   switch (ffelex_token_type (t))
11320     {
11321     case FFELEX_typeNAME:
11322       ffesta_tokens[1] = ffelex_token_use (t);
11323       return (ffelexHandler) ffestb_R110710_;
11324
11325     default:
11326       break;
11327     }
11328
11329   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11330   ffestc_R1107_finish ();
11331   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11332 }
11333
11334 /* ffestb_R110710_ -- "USE" NAME COMMA NAME
11335
11336    return ffestb_R110710_;  // to lexer
11337
11338    Make sure the statement has a valid form for the USE statement.  If it
11339    does, implement the statement.  */
11340
11341 static ffelexHandler
11342 ffestb_R110710_ (ffelexToken t)
11343 {
11344   switch (ffelex_token_type (t))
11345     {
11346     case FFELEX_typePOINTS:
11347       return (ffelexHandler) ffestb_R110711_;
11348
11349     default:
11350       break;
11351     }
11352
11353   ffelex_token_kill (ffesta_tokens[1]);
11354   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11355   ffestc_R1107_finish ();
11356   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11357 }
11358
11359 /* ffestb_R110711_ -- "USE" NAME COMMA NAME POINTS
11360
11361    return ffestb_R110711_;  // to lexer
11362
11363    Make sure the statement has a valid form for the USE statement.  If it
11364    does, implement the statement.  */
11365
11366 static ffelexHandler
11367 ffestb_R110711_ (ffelexToken t)
11368 {
11369   switch (ffelex_token_type (t))
11370     {
11371     case FFELEX_typeNAME:
11372       if (!ffesta_is_inhibited ())
11373         ffestc_R1107_item (ffesta_tokens[1], t);
11374       ffelex_token_kill (ffesta_tokens[1]);
11375       return (ffelexHandler) ffestb_R110712_;
11376
11377     default:
11378       break;
11379     }
11380
11381   ffelex_token_kill (ffesta_tokens[1]);
11382   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11383   ffestc_R1107_finish ();
11384   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11385 }
11386
11387 /* ffestb_R110712_ -- "USE" NAME COMMA NAME POINTS NAME
11388
11389    return ffestb_R110712_;  // to lexer
11390
11391    Make sure the statement has a valid form for the USE statement.  If it
11392    does, implement the statement.  */
11393
11394 static ffelexHandler
11395 ffestb_R110712_ (ffelexToken t)
11396 {
11397   switch (ffelex_token_type (t))
11398     {
11399     case FFELEX_typeEOS:
11400     case FFELEX_typeSEMICOLON:
11401       if (!ffesta_is_inhibited ())
11402         ffestc_R1107_finish ();
11403       return (ffelexHandler) ffesta_zero (t);
11404
11405     case FFELEX_typeCOMMA:
11406       return (ffelexHandler) ffestb_R11079_;
11407
11408     default:
11409       break;
11410     }
11411
11412   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11413   ffestc_R1107_finish ();
11414   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11415 }
11416
11417 #endif
11418 /* ffestb_R1202 -- Parse the INTERFACE statement
11419
11420    return ffestb_R1202;  // to lexer
11421
11422    Make sure the statement has a valid form for the INTERFACE statement.
11423    If it does, implement the statement.
11424
11425    15-May-90  JCB  1.1
11426       Allow INTERFACE by itself; missed this
11427       valid form when originally doing syntactic analysis code.  */
11428
11429 #if FFESTR_F90
11430 ffelexHandler
11431 ffestb_R1202 (ffelexToken t)
11432 {
11433   ffeTokenLength i;
11434   char *p;
11435
11436   switch (ffelex_token_type (ffesta_tokens[0]))
11437     {
11438     case FFELEX_typeNAME:
11439       if (ffesta_first_kw != FFESTR_firstINTERFACE)
11440         goto bad_0;             /* :::::::::::::::::::: */
11441       switch (ffelex_token_type (t))
11442         {
11443         case FFELEX_typeNAME:
11444           break;
11445
11446         case FFELEX_typeEOS:
11447         case FFELEX_typeSEMICOLON:
11448           ffesta_confirmed ();
11449           if (!ffesta_is_inhibited ())
11450             ffestc_R1202 (FFESTP_definedoperatorNone, NULL);
11451           return (ffelexHandler) ffesta_zero (t);
11452
11453         case FFELEX_typeCOMMA:
11454         case FFELEX_typeCOLONCOLON:
11455           ffesta_confirmed ();  /* Error, but clearly intended. */
11456           goto bad_1;           /* :::::::::::::::::::: */
11457
11458         default:
11459           goto bad_1;           /* :::::::::::::::::::: */
11460         }
11461
11462       ffesta_confirmed ();
11463       switch (ffesta_second_kw)
11464         {
11465         case FFESTR_secondOPERATOR:
11466           ffestb_local_.interface.operator = FFESTP_definedoperatorOPERATOR;
11467           break;
11468
11469         case FFESTR_secondASSIGNMENT:
11470           ffestb_local_.interface.operator = FFESTP_definedoperatorASSIGNMENT;
11471           break;
11472
11473         default:
11474           ffestb_local_.interface.operator = FFESTP_definedoperatorNone;
11475           break;
11476         }
11477       ffesta_tokens[1] = ffelex_token_use (t);
11478       return (ffelexHandler) ffestb_R12021_;
11479
11480     case FFELEX_typeNAMES:
11481       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlINTERFACE);
11482       switch (ffesta_first_kw)
11483         {
11484         case FFESTR_firstINTERFACEOPERATOR:
11485           if (*(ffelex_token_text (ffesta_tokens[0])
11486                 + FFESTR_firstlINTERFACEOPERATOR) == '\0')
11487             ffestb_local_.interface.operator
11488               = FFESTP_definedoperatorOPERATOR;
11489           break;
11490
11491         case FFESTR_firstINTERFACEASSGNMNT:
11492           if (*(ffelex_token_text (ffesta_tokens[0])
11493                 + FFESTR_firstlINTERFACEASSGNMNT) == '\0')
11494             ffestb_local_.interface.operator
11495               = FFESTP_definedoperatorASSIGNMENT;
11496           break;
11497
11498         case FFESTR_firstINTERFACE:
11499           ffestb_local_.interface.operator = FFESTP_definedoperatorNone;
11500           break;
11501
11502         default:
11503           goto bad_0;           /* :::::::::::::::::::: */
11504         }
11505       switch (ffelex_token_type (t))
11506         {
11507         case FFELEX_typeCOMMA:
11508         case FFELEX_typeCOLONCOLON:
11509           ffesta_confirmed ();  /* Error, but clearly intended. */
11510           goto bad_1;           /* :::::::::::::::::::: */
11511
11512         default:
11513           goto bad_1;           /* :::::::::::::::::::: */
11514
11515         case FFELEX_typeOPEN_PAREN:
11516         case FFELEX_typeOPEN_ARRAY:     /* Sigh. */
11517           break;
11518
11519         case FFELEX_typeEOS:
11520         case FFELEX_typeSEMICOLON:
11521           ffesta_confirmed ();
11522           if (*p == '\0')
11523             {
11524               if (!ffesta_is_inhibited ())
11525                 ffestc_R1202 (FFESTP_definedoperatorNone, NULL);
11526               return (ffelexHandler) ffesta_zero (t);
11527             }
11528           break;
11529         }
11530       if (!ffesrc_is_name_init (*p))
11531         goto bad_i;             /* :::::::::::::::::::: */
11532       ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
11533       return (ffelexHandler) ffestb_R12021_ (t);
11534
11535     default:
11536       goto bad_0;               /* :::::::::::::::::::: */
11537     }
11538
11539 bad_0:                          /* :::::::::::::::::::: */
11540   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", ffesta_tokens[0]);
11541   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11542
11543 bad_1:                          /* :::::::::::::::::::: */
11544   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11545   return (ffelexHandler) ffelex_swallow_tokens (t,
11546                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
11547
11548 bad_i:                          /* :::::::::::::::::::: */
11549   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "INTERFACE", ffesta_tokens[0], i, t);
11550   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11551 }
11552
11553 /* ffestb_R12021_ -- "INTERFACE" NAME
11554
11555    return ffestb_R12021_;  // to lexer
11556
11557    Make sure the statement has a valid form for the INTERFACE statement.  If
11558    it does, implement the statement.  */
11559
11560 static ffelexHandler
11561 ffestb_R12021_ (ffelexToken t)
11562 {
11563   ffestb_local_.interface.slash = TRUE; /* Slash follows open paren. */
11564
11565   switch (ffelex_token_type (t))
11566     {
11567     case FFELEX_typeEOS:
11568     case FFELEX_typeSEMICOLON:
11569       if (!ffesta_is_inhibited ())
11570         ffestc_R1202 (FFESTP_definedoperatorNone, ffesta_tokens[1]);
11571       ffelex_token_kill (ffesta_tokens[1]);
11572       return (ffelexHandler) ffesta_zero (t);
11573
11574     case FFELEX_typeOPEN_PAREN:
11575       ffestb_local_.interface.slash = FALSE;    /* Slash doesn't follow. */
11576       /* Fall through. */
11577     case FFELEX_typeOPEN_ARRAY:
11578       switch (ffestb_local_.interface.operator)
11579         {
11580         case FFESTP_definedoperatorNone:
11581           break;
11582
11583         case FFESTP_definedoperatorOPERATOR:
11584           ffestb_local_.interface.assignment = FALSE;
11585           return (ffelexHandler) ffestb_R12022_;
11586
11587         case FFESTP_definedoperatorASSIGNMENT:
11588           ffestb_local_.interface.assignment = TRUE;
11589           return (ffelexHandler) ffestb_R12022_;
11590
11591         default:
11592           assert (FALSE);
11593         }
11594       break;
11595
11596     case FFELEX_typeCOMMA:
11597     case FFELEX_typeCOLONCOLON:
11598       ffesta_confirmed ();      /* Error, but clearly intended. */
11599       break;
11600
11601     default:
11602       break;
11603     }
11604
11605   ffelex_token_kill (ffesta_tokens[1]);
11606   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11607   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11608 }
11609
11610 /* ffestb_R12022_ -- "INTERFACE" "OPERATOR/ASSIGNMENT" OPEN_PAREN
11611
11612    return ffestb_R12022_;  // to lexer
11613
11614    Make sure the statement has a valid form for the INTERFACE statement.  If
11615    it does, implement the statement.  */
11616
11617 static ffelexHandler
11618 ffestb_R12022_ (ffelexToken t)
11619 {
11620   ffesta_tokens[2] = ffelex_token_use (t);
11621
11622   switch (ffelex_token_type (t))
11623     {
11624     case FFELEX_typePERIOD:
11625       if (ffestb_local_.interface.slash)
11626         break;
11627       return (ffelexHandler) ffestb_R12023_;
11628
11629     case FFELEX_typePOWER:
11630       if (ffestb_local_.interface.slash)
11631         break;
11632       ffestb_local_.interface.operator = FFESTP_definedoperatorPOWER;
11633       return (ffelexHandler) ffestb_R12025_;
11634
11635     case FFELEX_typeASTERISK:
11636       if (ffestb_local_.interface.slash)
11637         break;
11638       ffestb_local_.interface.operator = FFESTP_definedoperatorMULT;
11639       return (ffelexHandler) ffestb_R12025_;
11640
11641     case FFELEX_typePLUS:
11642       if (ffestb_local_.interface.slash)
11643         break;
11644       ffestb_local_.interface.operator = FFESTP_definedoperatorADD;
11645       return (ffelexHandler) ffestb_R12025_;
11646
11647     case FFELEX_typeCONCAT:
11648       if (ffestb_local_.interface.slash)
11649         break;
11650       ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
11651       return (ffelexHandler) ffestb_R12025_;
11652
11653     case FFELEX_typeSLASH:
11654       if (ffestb_local_.interface.slash)
11655         {
11656           ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
11657           return (ffelexHandler) ffestb_R12025_;
11658         }
11659       ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
11660       return (ffelexHandler) ffestb_R12025_;
11661
11662     case FFELEX_typeMINUS:
11663       if (ffestb_local_.interface.slash)
11664         break;
11665       ffestb_local_.interface.operator = FFESTP_definedoperatorSUBTRACT;
11666       return (ffelexHandler) ffestb_R12025_;
11667
11668     case FFELEX_typeREL_EQ:
11669       if (ffestb_local_.interface.slash)
11670         break;
11671       ffestb_local_.interface.operator = FFESTP_definedoperatorEQ;
11672       return (ffelexHandler) ffestb_R12025_;
11673
11674     case FFELEX_typeREL_NE:
11675       if (ffestb_local_.interface.slash)
11676         break;
11677       ffestb_local_.interface.operator = FFESTP_definedoperatorNE;
11678       return (ffelexHandler) ffestb_R12025_;
11679
11680     case FFELEX_typeOPEN_ANGLE:
11681       if (ffestb_local_.interface.slash)
11682         break;
11683       ffestb_local_.interface.operator = FFESTP_definedoperatorLT;
11684       return (ffelexHandler) ffestb_R12025_;
11685
11686     case FFELEX_typeREL_LE:
11687       if (ffestb_local_.interface.slash)
11688         break;
11689       ffestb_local_.interface.operator = FFESTP_definedoperatorLE;
11690       return (ffelexHandler) ffestb_R12025_;
11691
11692     case FFELEX_typeCLOSE_ANGLE:
11693       if (ffestb_local_.interface.slash)
11694         break;
11695       ffestb_local_.interface.operator = FFESTP_definedoperatorGT;
11696       return (ffelexHandler) ffestb_R12025_;
11697
11698     case FFELEX_typeREL_GE:
11699       if (ffestb_local_.interface.slash)
11700         break;
11701       ffestb_local_.interface.operator = FFESTP_definedoperatorGE;
11702       return (ffelexHandler) ffestb_R12025_;
11703
11704     case FFELEX_typeEQUALS:
11705       if (ffestb_local_.interface.slash)
11706         {
11707           ffestb_local_.interface.operator = FFESTP_definedoperatorNE;
11708           return (ffelexHandler) ffestb_R12025_;
11709         }
11710       ffestb_local_.interface.operator = FFESTP_definedoperatorASSIGNMENT;
11711       return (ffelexHandler) ffestb_R12025_;
11712
11713     case FFELEX_typeCLOSE_ARRAY:
11714       if (!ffestb_local_.interface.slash)
11715         {
11716           ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
11717           return (ffelexHandler) ffestb_R12026_;
11718         }
11719       ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
11720       return (ffelexHandler) ffestb_R12026_;
11721
11722     case FFELEX_typeCLOSE_PAREN:
11723       if (!ffestb_local_.interface.slash)
11724         break;
11725       ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
11726       return (ffelexHandler) ffestb_R12026_;
11727
11728     default:
11729       break;
11730     }
11731
11732   ffelex_token_kill (ffesta_tokens[1]);
11733   ffelex_token_kill (ffesta_tokens[2]);
11734   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11735   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11736 }
11737
11738 /* ffestb_R12023_ -- "INTERFACE" NAME OPEN_PAREN PERIOD
11739
11740    return ffestb_R12023_;  // to lexer
11741
11742    Make sure the statement has a valid form for the INTERFACE statement.  If
11743    it does, implement the statement.  */
11744
11745 static ffelexHandler
11746 ffestb_R12023_ (ffelexToken t)
11747 {
11748   switch (ffelex_token_type (t))
11749     {
11750     case FFELEX_typeNAME:
11751       ffelex_token_kill (ffesta_tokens[2]);
11752       ffesta_tokens[2] = ffelex_token_use (t);
11753       return (ffelexHandler) ffestb_R12024_;
11754
11755     default:
11756       break;
11757     }
11758
11759   ffelex_token_kill (ffesta_tokens[1]);
11760   ffelex_token_kill (ffesta_tokens[2]);
11761   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11762   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11763 }
11764
11765 /* ffestb_R12024_ -- "INTERFACE" NAME OPEN_PAREN PERIOD NAME
11766
11767    return ffestb_R12024_;  // to lexer
11768
11769    Make sure the statement has a valid form for the INTERFACE statement.  If
11770    it does, implement the statement.  */
11771
11772 static ffelexHandler
11773 ffestb_R12024_ (ffelexToken t)
11774 {
11775   switch (ffelex_token_type (t))
11776     {
11777     case FFELEX_typePERIOD:
11778       return (ffelexHandler) ffestb_R12025_;
11779
11780     default:
11781       break;
11782     }
11783
11784   ffelex_token_kill (ffesta_tokens[1]);
11785   ffelex_token_kill (ffesta_tokens[2]);
11786   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11787   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11788 }
11789
11790 /* ffestb_R12025_ -- "INTERFACE" NAME OPEN_PAREN operator
11791
11792    return ffestb_R12025_;  // to lexer
11793
11794    Make sure the statement has a valid form for the INTERFACE statement.  If
11795    it does, implement the statement.  */
11796
11797 static ffelexHandler
11798 ffestb_R12025_ (ffelexToken t)
11799 {
11800   switch (ffelex_token_type (t))
11801     {
11802     case FFELEX_typeCLOSE_PAREN:
11803       return (ffelexHandler) ffestb_R12026_;
11804
11805     default:
11806       break;
11807     }
11808
11809   ffelex_token_kill (ffesta_tokens[1]);
11810   ffelex_token_kill (ffesta_tokens[2]);
11811   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11812   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11813 }
11814
11815 /* ffestb_R12026_ -- "INTERFACE" NAME OPEN_PAREN operator CLOSE_PAREN
11816
11817    return ffestb_R12026_;  // to lexer
11818
11819    Make sure the statement has a valid form for the INTERFACE statement.  If
11820    it does, implement the statement.  */
11821
11822 static ffelexHandler
11823 ffestb_R12026_ (ffelexToken t)
11824 {
11825   char *p;
11826
11827   switch (ffelex_token_type (t))
11828     {
11829     case FFELEX_typeEOS:
11830     case FFELEX_typeSEMICOLON:
11831       ffesta_confirmed ();
11832       if (ffestb_local_.interface.assignment
11833           && (ffestb_local_.interface.operator
11834               != FFESTP_definedoperatorASSIGNMENT))
11835         {
11836           ffebad_start (FFEBAD_INTERFACE_ASSIGNMENT);
11837           ffebad_here (0, ffelex_token_where_line (ffesta_tokens[1]),
11838                        ffelex_token_where_column (ffesta_tokens[1]));
11839           ffebad_here (1, ffelex_token_where_line (ffesta_tokens[2]),
11840                        ffelex_token_where_column (ffesta_tokens[2]));
11841           ffebad_finish ();
11842         }
11843       switch (ffelex_token_type (ffesta_tokens[2]))
11844         {
11845         case FFELEX_typeNAME:
11846           switch (ffestr_other (ffesta_tokens[2]))
11847             {
11848             case FFESTR_otherNOT:
11849               if (!ffesta_is_inhibited ())
11850                 ffestc_R1202 (FFESTP_definedoperatorNOT, NULL);
11851               break;
11852
11853             case FFESTR_otherAND:
11854               if (!ffesta_is_inhibited ())
11855                 ffestc_R1202 (FFESTP_definedoperatorAND, NULL);
11856               break;
11857
11858             case FFESTR_otherOR:
11859               if (!ffesta_is_inhibited ())
11860                 ffestc_R1202 (FFESTP_definedoperatorOR, NULL);
11861               break;
11862
11863             case FFESTR_otherEQV:
11864               if (!ffesta_is_inhibited ())
11865                 ffestc_R1202 (FFESTP_definedoperatorEQV, NULL);
11866               break;
11867
11868             case FFESTR_otherNEQV:
11869               if (!ffesta_is_inhibited ())
11870                 ffestc_R1202 (FFESTP_definedoperatorNEQV, NULL);
11871               break;
11872
11873             case FFESTR_otherEQ:
11874               if (!ffesta_is_inhibited ())
11875                 ffestc_R1202 (FFESTP_definedoperatorEQ, NULL);
11876               break;
11877
11878             case FFESTR_otherNE:
11879               if (!ffesta_is_inhibited ())
11880                 ffestc_R1202 (FFESTP_definedoperatorNE, NULL);
11881               break;
11882
11883             case FFESTR_otherLT:
11884               if (!ffesta_is_inhibited ())
11885                 ffestc_R1202 (FFESTP_definedoperatorLT, NULL);
11886               break;
11887
11888             case FFESTR_otherLE:
11889               if (!ffesta_is_inhibited ())
11890                 ffestc_R1202 (FFESTP_definedoperatorLE, NULL);
11891               break;
11892
11893             case FFESTR_otherGT:
11894               if (!ffesta_is_inhibited ())
11895                 ffestc_R1202 (FFESTP_definedoperatorGT, NULL);
11896               break;
11897
11898             case FFESTR_otherGE:
11899               if (!ffesta_is_inhibited ())
11900                 ffestc_R1202 (FFESTP_definedoperatorGE, NULL);
11901               break;
11902
11903             default:
11904               for (p = ffelex_token_text (ffesta_tokens[2]); *p != '\0'; ++p)
11905                 {
11906                   if (!isalpha (*p))
11907                     {
11908                       ffelex_token_kill (ffesta_tokens[1]);
11909                       ffelex_token_kill (ffesta_tokens[2]);
11910                       ffesta_ffebad_1t (FFEBAD_INTERFACE_NONLETTER,
11911                                         ffesta_tokens[2]);
11912                       return (ffelexHandler) ffelex_swallow_tokens (t,
11913                                                (ffelexHandler) ffesta_zero);
11914                     }
11915                 }
11916               if (!ffesta_is_inhibited ())
11917                 ffestc_R1202 (FFESTP_definedoperatorOPERATOR,
11918                               ffesta_tokens[2]);
11919             }
11920           break;
11921
11922         case FFELEX_typeEQUALS:
11923           if (!ffestb_local_.interface.assignment
11924               && (ffestb_local_.interface.operator
11925                   == FFESTP_definedoperatorASSIGNMENT))
11926             {
11927               ffebad_start (FFEBAD_INTERFACE_OPERATOR);
11928               ffebad_here (0, ffelex_token_where_line (ffesta_tokens[1]),
11929                            ffelex_token_where_column (ffesta_tokens[1]));
11930               ffebad_here (1, ffelex_token_where_line (ffesta_tokens[2]),
11931                            ffelex_token_where_column (ffesta_tokens[2]));
11932               ffebad_finish ();
11933             }
11934           if (!ffesta_is_inhibited ())
11935             ffestc_R1202 (ffestb_local_.interface.operator, NULL);
11936           break;
11937
11938         default:
11939           if (!ffesta_is_inhibited ())
11940             ffestc_R1202 (ffestb_local_.interface.operator, NULL);
11941         }
11942       ffelex_token_kill (ffesta_tokens[1]);
11943       ffelex_token_kill (ffesta_tokens[2]);
11944       return (ffelexHandler) ffesta_zero (t);
11945
11946     default:
11947       break;
11948     }
11949
11950   ffelex_token_kill (ffesta_tokens[1]);
11951   ffelex_token_kill (ffesta_tokens[2]);
11952   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11953   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11954 }
11955
11956 #endif
11957 /* ffestb_S3P4 -- Parse the INCLUDE line
11958
11959    return ffestb_S3P4;  // to lexer
11960
11961    Make sure the statement has a valid form for the INCLUDE line.  If it
11962    does, implement the statement.  */
11963
11964 ffelexHandler
11965 ffestb_S3P4 (ffelexToken t)
11966 {
11967   ffeTokenLength i;
11968   char *p;
11969   ffelexHandler next;
11970   ffelexToken nt;
11971   ffelexToken ut;
11972
11973   switch (ffelex_token_type (ffesta_tokens[0]))
11974     {
11975     case FFELEX_typeNAME:
11976       if (ffesta_first_kw != FFESTR_firstINCLUDE)
11977         goto bad_0;             /* :::::::::::::::::::: */
11978       switch (ffelex_token_type (t))
11979         {
11980         case FFELEX_typeNUMBER:
11981         case FFELEX_typeAPOSTROPHE:
11982         case FFELEX_typeQUOTE:
11983           break;
11984
11985         default:
11986           goto bad_1;           /* :::::::::::::::::::: */
11987         }
11988       ffesta_confirmed ();
11989       return (ffelexHandler) (*((ffelexHandler)
11990                     ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextINCLUDE,
11991                                  (ffeexprCallback) ffestb_S3P41_)))
11992         (t);
11993
11994     case FFELEX_typeNAMES:
11995       if (ffesta_first_kw != FFESTR_firstINCLUDE)
11996         goto bad_0;             /* :::::::::::::::::::: */
11997       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlINCLUDE);
11998       switch (ffelex_token_type (t))
11999         {
12000         default:
12001           goto bad_1;           /* :::::::::::::::::::: */
12002
12003         case FFELEX_typeAPOSTROPHE:
12004         case FFELEX_typeQUOTE:
12005           break;
12006         }
12007       ffesta_confirmed ();
12008       if (*p == '\0')
12009         return (ffelexHandler) (*((ffelexHandler)
12010                     ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextINCLUDE,
12011                                  (ffeexprCallback) ffestb_S3P41_)))
12012           (t);
12013       if (!isdigit (*p))
12014         goto bad_i;             /* :::::::::::::::::::: */
12015       nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
12016       p += ffelex_token_length (nt);
12017       i += ffelex_token_length (nt);
12018       if ((*p != '_') || (++i, *++p != '\0'))
12019         {
12020           ffelex_token_kill (nt);
12021           goto bad_i;           /* :::::::::::::::::::: */
12022         }
12023       ut = ffelex_token_uscore_from_names (ffesta_tokens[0], i - 1);
12024       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs
12025                                 (ffesta_output_pool, FFEEXPR_contextINCLUDE,
12026                                  (ffeexprCallback) ffestb_S3P41_)))
12027         (nt);
12028       ffelex_token_kill (nt);
12029       next = (ffelexHandler) (*next) (ut);
12030       ffelex_token_kill (ut);
12031       return (ffelexHandler) (*next) (t);
12032
12033     default:
12034       goto bad_0;               /* :::::::::::::::::::: */
12035     }
12036
12037 bad_0:                          /* :::::::::::::::::::: */
12038   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", ffesta_tokens[0]);
12039   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12040
12041 bad_1:                          /* :::::::::::::::::::: */
12042   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", t);
12043   return (ffelexHandler) ffelex_swallow_tokens (t,
12044                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
12045
12046 bad_i:                          /* :::::::::::::::::::: */
12047   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "INCLUDE", ffesta_tokens[0], i, t);
12048   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12049 }
12050
12051 /* ffestb_S3P41_ -- "INCLUDE" [NUMBER "_"] expr
12052
12053    (ffestb_S3P41_)  // to expression handler
12054
12055    Make sure the next token is an EOS, but not a SEMICOLON.  */
12056
12057 static ffelexHandler
12058 ffestb_S3P41_ (ffelexToken ft, ffebld expr, ffelexToken t)
12059 {
12060   switch (ffelex_token_type (t))
12061     {
12062     case FFELEX_typeEOS:
12063     case FFELEX_typeSEMICOLON:
12064       if (expr == NULL)
12065         break;
12066       if (!ffesta_is_inhibited ())
12067         {
12068           if (ffe_is_pedantic ()
12069               && ((ffelex_token_type (t) == FFELEX_typeSEMICOLON)
12070                   || ffesta_line_has_semicolons))
12071             {
12072               ffebad_start_msg ("INCLUDE at %0 not the only statement on the source line", FFEBAD_severityWARNING);
12073               ffebad_here (0, ffelex_token_where_line (ffesta_tokens[0]),
12074                            ffelex_token_where_column (ffesta_tokens[0]));
12075               ffebad_finish ();
12076             }
12077           ffestc_S3P4 (expr, ft);
12078         }
12079       return (ffelexHandler) ffesta_zero (t);
12080
12081     default:
12082       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", t);
12083       break;
12084     }
12085
12086   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12087 }
12088
12089 /* ffestb_V012 -- Parse the MAP statement
12090
12091    return ffestb_V012;  // to lexer
12092
12093    Make sure the statement has a valid form for the MAP statement.  If
12094    it does, implement the statement.  */
12095
12096 #if FFESTR_VXT
12097 ffelexHandler
12098 ffestb_V012 (ffelexToken t)
12099 {
12100   char *p;
12101   ffeTokenLength i;
12102
12103   switch (ffelex_token_type (ffesta_tokens[0]))
12104     {
12105     case FFELEX_typeNAME:
12106       if (ffesta_first_kw != FFESTR_firstMAP)
12107         goto bad_0;             /* :::::::::::::::::::: */
12108       break;
12109
12110     case FFELEX_typeNAMES:
12111       if (ffesta_first_kw != FFESTR_firstMAP)
12112         goto bad_0;             /* :::::::::::::::::::: */
12113       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlMAP)
12114         {
12115           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlMAP);
12116           goto bad_i;           /* :::::::::::::::::::: */
12117         }
12118       break;
12119
12120     default:
12121       goto bad_0;               /* :::::::::::::::::::: */
12122     }
12123
12124   switch (ffelex_token_type (t))
12125     {
12126     case FFELEX_typeEOS:
12127     case FFELEX_typeSEMICOLON:
12128       ffesta_confirmed ();
12129       if (!ffesta_is_inhibited ())
12130         ffestc_V012 ();
12131       return (ffelexHandler) ffesta_zero (t);
12132
12133     case FFELEX_typeCOMMA:
12134     case FFELEX_typeCOLONCOLON:
12135       ffesta_confirmed ();      /* Error, but clearly intended. */
12136       goto bad_1;               /* :::::::::::::::::::: */
12137
12138     default:
12139       goto bad_1;               /* :::::::::::::::::::: */
12140     }
12141
12142 bad_0:                          /* :::::::::::::::::::: */
12143   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MAP", ffesta_tokens[0]);
12144   return (ffelexHandler) ffelex_swallow_tokens (t,
12145                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
12146
12147 bad_1:                          /* :::::::::::::::::::: */
12148   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MAP", t);
12149   return (ffelexHandler) ffelex_swallow_tokens (t,
12150                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
12151
12152 bad_i:                          /* :::::::::::::::::::: */
12153   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "MAP", ffesta_tokens[0], i, t);
12154   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12155 }
12156
12157 #endif
12158 /* ffestb_V014 -- Parse the VOLATILE statement
12159
12160    return ffestb_V014;  // to lexer
12161
12162    Make sure the statement has a valid form for the VOLATILE statement.  If it
12163    does, implement the statement.  */
12164
12165 ffelexHandler
12166 ffestb_V014 (ffelexToken t)
12167 {
12168   ffeTokenLength i;
12169   char *p;
12170   ffelexToken nt;
12171   ffelexHandler next;
12172
12173   switch (ffelex_token_type (ffesta_tokens[0]))
12174     {
12175     case FFELEX_typeNAME:
12176       if (ffesta_first_kw != FFESTR_firstVOLATILE)
12177         goto bad_0;             /* :::::::::::::::::::: */
12178       switch (ffelex_token_type (t))
12179         {
12180         case FFELEX_typeEOS:
12181         case FFELEX_typeSEMICOLON:
12182         case FFELEX_typeCOMMA:
12183           ffesta_confirmed ();  /* Error, but clearly intended. */
12184           goto bad_1;           /* :::::::::::::::::::: */
12185
12186         default:
12187           goto bad_1;           /* :::::::::::::::::::: */
12188
12189         case FFELEX_typeNAME:
12190         case FFELEX_typeSLASH:
12191           ffesta_confirmed ();
12192           if (!ffesta_is_inhibited ())
12193             ffestc_V014_start ();
12194           return (ffelexHandler) ffestb_V0141_ (t);
12195
12196         case FFELEX_typeCOLONCOLON:
12197           ffesta_confirmed ();
12198           if (!ffesta_is_inhibited ())
12199             ffestc_V014_start ();
12200           return (ffelexHandler) ffestb_V0141_;
12201         }
12202
12203     case FFELEX_typeNAMES:
12204       if (ffesta_first_kw != FFESTR_firstVOLATILE)
12205         goto bad_0;             /* :::::::::::::::::::: */
12206       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlVOLATILE);
12207       switch (ffelex_token_type (t))
12208         {
12209         default:
12210           goto bad_1;           /* :::::::::::::::::::: */
12211
12212         case FFELEX_typeCOMMA:
12213         case FFELEX_typeEOS:
12214         case FFELEX_typeSEMICOLON:
12215           ffesta_confirmed ();
12216           break;
12217
12218         case FFELEX_typeSLASH:
12219           ffesta_confirmed ();
12220           if (*p != '\0')
12221             goto bad_i;         /* :::::::::::::::::::: */
12222           if (!ffesta_is_inhibited ())
12223             ffestc_V014_start ();
12224           return (ffelexHandler) ffestb_V0141_ (t);
12225
12226         case FFELEX_typeCOLONCOLON:
12227           ffesta_confirmed ();
12228           if (*p != '\0')
12229             goto bad_i;         /* :::::::::::::::::::: */
12230           if (!ffesta_is_inhibited ())
12231             ffestc_V014_start ();
12232           return (ffelexHandler) ffestb_V0141_;
12233         }
12234
12235       /* Here, we have at least one char after "VOLATILE" and t is COMMA or
12236          EOS/SEMICOLON. */
12237
12238       if (!ffesrc_is_name_init (*p))
12239         goto bad_i;             /* :::::::::::::::::::: */
12240       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
12241       if (!ffesta_is_inhibited ())
12242         ffestc_V014_start ();
12243       next = (ffelexHandler) ffestb_V0141_ (nt);
12244       ffelex_token_kill (nt);
12245       return (ffelexHandler) (*next) (t);
12246
12247     default:
12248       goto bad_0;               /* :::::::::::::::::::: */
12249     }
12250
12251 bad_0:                          /* :::::::::::::::::::: */
12252   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", ffesta_tokens[0]);
12253   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12254
12255 bad_1:                          /* :::::::::::::::::::: */
12256   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12257   return (ffelexHandler) ffelex_swallow_tokens (t,
12258                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
12259
12260 bad_i:                          /* :::::::::::::::::::: */
12261   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "VOLATILE", ffesta_tokens[0], i, t);
12262   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12263 }
12264
12265 /* ffestb_V0141_ -- "VOLATILE" [COLONCOLON]
12266
12267    return ffestb_V0141_;  // to lexer
12268
12269    Handle NAME or SLASH.  */
12270
12271 static ffelexHandler
12272 ffestb_V0141_ (ffelexToken t)
12273 {
12274   switch (ffelex_token_type (t))
12275     {
12276     case FFELEX_typeNAME:
12277       ffestb_local_.V014.is_cblock = FALSE;
12278       ffesta_tokens[1] = ffelex_token_use (t);
12279       return (ffelexHandler) ffestb_V0144_;
12280
12281     case FFELEX_typeSLASH:
12282       ffestb_local_.V014.is_cblock = TRUE;
12283       return (ffelexHandler) ffestb_V0142_;
12284
12285     default:
12286       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12287       break;
12288     }
12289
12290   if (!ffesta_is_inhibited ())
12291     ffestc_V014_finish ();
12292   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12293 }
12294
12295 /* ffestb_V0142_ -- "VOLATILE" [COLONCOLON] SLASH
12296
12297    return ffestb_V0142_;  // to lexer
12298
12299    Handle NAME.  */
12300
12301 static ffelexHandler
12302 ffestb_V0142_ (ffelexToken t)
12303 {
12304   switch (ffelex_token_type (t))
12305     {
12306     case FFELEX_typeNAME:
12307       ffesta_tokens[1] = ffelex_token_use (t);
12308       return (ffelexHandler) ffestb_V0143_;
12309
12310     default:
12311       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12312       break;
12313     }
12314
12315   if (!ffesta_is_inhibited ())
12316     ffestc_V014_finish ();
12317   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12318 }
12319
12320 /* ffestb_V0143_ -- "VOLATILE" [COLONCOLON] SLASH NAME
12321
12322    return ffestb_V0143_;  // to lexer
12323
12324    Handle SLASH.  */
12325
12326 static ffelexHandler
12327 ffestb_V0143_ (ffelexToken t)
12328 {
12329   switch (ffelex_token_type (t))
12330     {
12331     case FFELEX_typeSLASH:
12332       return (ffelexHandler) ffestb_V0144_;
12333
12334     default:
12335       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12336       break;
12337     }
12338
12339   if (!ffesta_is_inhibited ())
12340     ffestc_V014_finish ();
12341   ffelex_token_kill (ffesta_tokens[1]);
12342   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12343 }
12344
12345 /* ffestb_V0144_ -- "VOLATILE" [COLONCOLON] R523
12346
12347    return ffestb_V0144_;  // to lexer
12348
12349    Handle COMMA or EOS/SEMICOLON.  */
12350
12351 static ffelexHandler
12352 ffestb_V0144_ (ffelexToken t)
12353 {
12354   switch (ffelex_token_type (t))
12355     {
12356     case FFELEX_typeCOMMA:
12357       if (!ffesta_is_inhibited ())
12358         {
12359           if (ffestb_local_.V014.is_cblock)
12360             ffestc_V014_item_cblock (ffesta_tokens[1]);
12361           else
12362             ffestc_V014_item_object (ffesta_tokens[1]);
12363         }
12364       ffelex_token_kill (ffesta_tokens[1]);
12365       return (ffelexHandler) ffestb_V0141_;
12366
12367     case FFELEX_typeEOS:
12368     case FFELEX_typeSEMICOLON:
12369       if (!ffesta_is_inhibited ())
12370         {
12371           if (ffestb_local_.V014.is_cblock)
12372             ffestc_V014_item_cblock (ffesta_tokens[1]);
12373           else
12374             ffestc_V014_item_object (ffesta_tokens[1]);
12375           ffestc_V014_finish ();
12376         }
12377       ffelex_token_kill (ffesta_tokens[1]);
12378       return (ffelexHandler) ffesta_zero (t);
12379
12380     default:
12381       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12382       break;
12383     }
12384
12385   if (!ffesta_is_inhibited ())
12386     ffestc_V014_finish ();
12387   ffelex_token_kill (ffesta_tokens[1]);
12388   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12389 }
12390
12391 /* ffestb_V025 -- Parse the DEFINEFILE statement
12392
12393    return ffestb_V025;  // to lexer
12394
12395    Make sure the statement has a valid form for the DEFINEFILE statement.
12396    If it does, implement the statement.  */
12397
12398 #if FFESTR_VXT
12399 ffelexHandler
12400 ffestb_V025 (ffelexToken t)
12401 {
12402   ffeTokenLength i;
12403   char *p;
12404   ffelexToken nt;
12405   ffelexHandler next;
12406
12407   ffestb_local_.V025.started = FALSE;
12408   switch (ffelex_token_type (ffesta_tokens[0]))
12409     {
12410     case FFELEX_typeNAME:
12411       switch (ffesta_first_kw)
12412         {
12413         case FFESTR_firstDEFINE:
12414           if ((ffelex_token_type (t) != FFELEX_typeNAME)
12415               || (ffesta_second_kw != FFESTR_secondFILE))
12416             goto bad_1;         /* :::::::::::::::::::: */
12417           ffesta_confirmed ();
12418           return (ffelexHandler) ffestb_V0251_;
12419
12420         case FFESTR_firstDEFINEFILE:
12421           return (ffelexHandler) ffestb_V0251_ (t);
12422
12423         default:
12424           goto bad_0;           /* :::::::::::::::::::: */
12425         }
12426
12427     case FFELEX_typeNAMES:
12428       if (ffesta_first_kw != FFESTR_firstDEFINEFILE)
12429         goto bad_0;             /* :::::::::::::::::::: */
12430       switch (ffelex_token_type (t))
12431         {
12432         case FFELEX_typeCOMMA:
12433         case FFELEX_typeEOS:
12434         case FFELEX_typeSEMICOLON:
12435         case FFELEX_typeCOLONCOLON:
12436           ffesta_confirmed ();  /* Error, but clearly intended. */
12437           goto bad_1;           /* :::::::::::::::::::: */
12438
12439         default:
12440           goto bad_1;           /* :::::::::::::::::::: */
12441
12442         case FFELEX_typeOPEN_PAREN:
12443           break;
12444         }
12445       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDEFINEFILE);
12446       if (isdigit (*p))
12447         nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
12448       else if (ffesrc_is_name_init (*p))
12449         nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
12450       else
12451         goto bad_i;             /* :::::::::::::::::::: */
12452       next = (ffelexHandler) ffestb_V0251_ (nt);
12453       ffelex_token_kill (nt);
12454       return (ffelexHandler) (*next) (t);
12455
12456     default:
12457       goto bad_0;               /* :::::::::::::::::::: */
12458     }
12459
12460 bad_0:                          /* :::::::::::::::::::: */
12461   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", ffesta_tokens[0]);
12462   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12463
12464 bad_1:                          /* :::::::::::::::::::: */
12465   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12466   return (ffelexHandler) ffelex_swallow_tokens (t,
12467                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
12468
12469 bad_i:                          /* :::::::::::::::::::: */
12470   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", ffesta_tokens[0], i, t);
12471   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12472 }
12473
12474 /* ffestb_V0251_ -- "DEFINEFILE" or "DEFINE" "FILE"
12475
12476    return ffestb_V0251_;  // to lexer
12477
12478    Make sure the statement has a valid form for the DEFINEFILE statement.  If it
12479    does, implement the statement.  */
12480
12481 static ffelexHandler
12482 ffestb_V0251_ (ffelexToken t)
12483 {
12484   switch (ffelex_token_type (t))
12485     {
12486     case FFELEX_typeNAME:
12487     case FFELEX_typeNUMBER:
12488       if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
12489         ffesta_confirmed ();
12490       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12491               FFEEXPR_contextFILEUNIT_DF, (ffeexprCallback) ffestb_V0252_)))
12492         (t);
12493
12494     case FFELEX_typeEOS:
12495     case FFELEX_typeSEMICOLON:
12496     case FFELEX_typeCOMMA:
12497     case FFELEX_typeCOLONCOLON:
12498       ffesta_confirmed ();      /* Error, but clearly intended. */
12499       break;
12500
12501     default:
12502       break;
12503     }
12504
12505   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12506   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12507 }
12508
12509 /* ffestb_V0252_ -- "DEFINEFILE" expr
12510
12511    (ffestb_V0252_)  // to expression handler
12512
12513    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12514    it does, implement the statement.  */
12515
12516 static ffelexHandler
12517 ffestb_V0252_ (ffelexToken ft, ffebld expr, ffelexToken t)
12518 {
12519   switch (ffelex_token_type (t))
12520     {
12521     case FFELEX_typeOPEN_PAREN:
12522       ffestb_local_.V025.u = expr;
12523       ffesta_tokens[1] = ffelex_token_use (ft);
12524       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12525                    FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0253_);
12526
12527     default:
12528       break;
12529     }
12530
12531   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12532   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12533 }
12534
12535 /* ffestb_V0253_ -- "DEFINEFILE" expr OPEN_PAREN expr
12536
12537    (ffestb_V0253_)  // to expression handler
12538
12539    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12540    it does, implement the statement.  */
12541
12542 static ffelexHandler
12543 ffestb_V0253_ (ffelexToken ft, ffebld expr, ffelexToken t)
12544 {
12545   switch (ffelex_token_type (t))
12546     {
12547     case FFELEX_typeCOMMA:
12548       ffestb_local_.V025.m = expr;
12549       ffesta_tokens[2] = ffelex_token_use (ft);
12550       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12551                    FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0254_);
12552
12553     default:
12554       break;
12555     }
12556
12557   ffelex_token_kill (ffesta_tokens[1]);
12558   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12559   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12560 }
12561
12562 /* ffestb_V0254_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr
12563
12564    (ffestb_V0254_)  // to expression handler
12565
12566    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12567    it does, implement the statement.  */
12568
12569 static ffelexHandler
12570 ffestb_V0254_ (ffelexToken ft, ffebld expr, ffelexToken t)
12571 {
12572   switch (ffelex_token_type (t))
12573     {
12574     case FFELEX_typeCOMMA:
12575       ffestb_local_.V025.n = expr;
12576       ffesta_tokens[3] = ffelex_token_use (ft);
12577       return (ffelexHandler) ffestb_V0255_;
12578
12579     default:
12580       break;
12581     }
12582
12583   ffelex_token_kill (ffesta_tokens[1]);
12584   ffelex_token_kill (ffesta_tokens[2]);
12585   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12586   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12587 }
12588
12589 /* ffestb_V0255_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA
12590
12591    return ffestb_V0255_;  // to lexer
12592
12593    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12594    it does, implement the statement.  */
12595
12596 static ffelexHandler
12597 ffestb_V0255_ (ffelexToken t)
12598 {
12599   char *p;
12600
12601   switch (ffelex_token_type (t))
12602     {
12603     case FFELEX_typeNAME:
12604       p = ffelex_token_text (t);
12605       if (!ffesrc_char_match_init (*p, 'U', 'u') || (*++p != '\0'))
12606         break;
12607       return (ffelexHandler) ffestb_V0256_;
12608
12609     default:
12610       break;
12611     }
12612
12613   ffelex_token_kill (ffesta_tokens[1]);
12614   ffelex_token_kill (ffesta_tokens[2]);
12615   ffelex_token_kill (ffesta_tokens[3]);
12616   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12617   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12618 }
12619
12620 /* ffestb_V0256_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
12621
12622    return ffestb_V0256_;  // to lexer
12623
12624    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12625    it does, implement the statement.  */
12626
12627 static ffelexHandler
12628 ffestb_V0256_ (ffelexToken t)
12629 {
12630   switch (ffelex_token_type (t))
12631     {
12632     case FFELEX_typeCOMMA:
12633       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
12634                                           FFEEXPR_contextFILEASSOC,
12635                                           (ffeexprCallback) ffestb_V0257_);
12636
12637     default:
12638       break;
12639     }
12640
12641   ffelex_token_kill (ffesta_tokens[1]);
12642   ffelex_token_kill (ffesta_tokens[2]);
12643   ffelex_token_kill (ffesta_tokens[3]);
12644   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12645   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12646 }
12647
12648 /* ffestb_V0257_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
12649                     COMMA expr
12650
12651    (ffestb_V0257_)  // to expression handler
12652
12653    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12654    it does, implement the statement.  */
12655
12656 static ffelexHandler
12657 ffestb_V0257_ (ffelexToken ft, ffebld expr, ffelexToken t)
12658 {
12659   switch (ffelex_token_type (t))
12660     {
12661     case FFELEX_typeCLOSE_PAREN:
12662       ffestb_local_.V025.asv = expr;
12663       ffesta_tokens[4] = ffelex_token_use (ft);
12664       return (ffelexHandler) ffestb_V0258_;
12665
12666     default:
12667       break;
12668     }
12669
12670   ffelex_token_kill (ffesta_tokens[1]);
12671   ffelex_token_kill (ffesta_tokens[2]);
12672   ffelex_token_kill (ffesta_tokens[3]);
12673   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12674   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12675 }
12676
12677 /* ffestb_V0258_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
12678                     COMMA expr CLOSE_PAREN
12679
12680    return ffestb_V0258_;  // to lexer
12681
12682    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12683    it does, implement the statement.  */
12684
12685 static ffelexHandler
12686 ffestb_V0258_ (ffelexToken t)
12687 {
12688   switch (ffelex_token_type (t))
12689     {
12690     case FFELEX_typeCOMMA:
12691     case FFELEX_typeEOS:
12692     case FFELEX_typeSEMICOLON:
12693       if (!ffestb_local_.V025.started)
12694         {
12695           ffesta_confirmed ();
12696           if (!ffesta_is_inhibited ())
12697             ffestc_V025_start ();
12698           ffestb_local_.V025.started = TRUE;
12699         }
12700       if (!ffesta_is_inhibited ())
12701         ffestc_V025_item (ffestb_local_.V025.u, ffesta_tokens[1],
12702                           ffestb_local_.V025.m, ffesta_tokens[2],
12703                           ffestb_local_.V025.n, ffesta_tokens[3],
12704                           ffestb_local_.V025.asv, ffesta_tokens[4]);
12705       ffelex_token_kill (ffesta_tokens[1]);
12706       ffelex_token_kill (ffesta_tokens[2]);
12707       ffelex_token_kill (ffesta_tokens[3]);
12708       ffelex_token_kill (ffesta_tokens[4]);
12709       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
12710         return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12711                FFEEXPR_contextFILEUNIT_DF, (ffeexprCallback) ffestb_V0252_);
12712       if (!ffesta_is_inhibited ())
12713         ffestc_V025_finish ();
12714       return (ffelexHandler) ffesta_zero (t);
12715
12716     default:
12717       break;
12718     }
12719
12720   ffelex_token_kill (ffesta_tokens[1]);
12721   ffelex_token_kill (ffesta_tokens[2]);
12722   ffelex_token_kill (ffesta_tokens[3]);
12723   ffelex_token_kill (ffesta_tokens[4]);
12724   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12725   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12726 }
12727
12728 #endif
12729 /* ffestb_subr_kill_easy_ -- Kill I/O statement data structure
12730
12731    ffestb_subr_kill_easy_();
12732
12733    Kills all tokens in the I/O data structure.  Assumes that they are
12734    overlaid with each other (union) in ffest_private.h and the typing
12735    and structure references assume (though not necessarily dangerous if
12736    FALSE) that INQUIRE has the most file elements.  */
12737
12738 #if FFESTB_KILL_EASY_
12739 static void
12740 ffestb_subr_kill_easy_ (ffestpInquireIx max)
12741 {
12742   ffestpInquireIx ix;
12743
12744   for (ix = 0; ix < max; ++ix)
12745     {
12746       if (ffestp_file.inquire.inquire_spec[ix].kw_or_val_present)
12747         {
12748           if (ffestp_file.inquire.inquire_spec[ix].kw_present)
12749             ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].kw);
12750           if (ffestp_file.inquire.inquire_spec[ix].value_present)
12751             ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].value);
12752         }
12753     }
12754 }
12755
12756 #endif
12757 /* ffestb_subr_kill_accept_ -- Kill ACCEPT statement data structure
12758
12759    ffestb_subr_kill_accept_();
12760
12761    Kills all tokens in the ACCEPT data structure.  */
12762
12763 #if !FFESTB_KILL_EASY_
12764 static void
12765 ffestb_subr_kill_accept_ ()
12766 {
12767   ffestpAcceptIx ix;
12768
12769   for (ix = 0; ix < FFESTP_acceptix; ++ix)
12770     {
12771       if (ffestp_file.accept.accept_spec[ix].kw_or_val_present)
12772         {
12773           if (ffestp_file.accept.accept_spec[ix].kw_present)
12774             ffelex_token_kill (ffestp_file.accept.accept_spec[ix].kw);
12775           if (ffestp_file.accept.accept_spec[ix].value_present)
12776             ffelex_token_kill (ffestp_file.accept.accept_spec[ix].value);
12777         }
12778     }
12779 }
12780
12781 #endif
12782 /* ffestb_subr_kill_beru_ -- Kill BACKSPACE/ENDFILE/REWIND/UNLOCK statement
12783                             data structure
12784
12785    ffestb_subr_kill_beru_();
12786
12787    Kills all tokens in the BACKSPACE/ENDFILE/REWIND/UNLOCK data structure.  */
12788
12789 #if !FFESTB_KILL_EASY_
12790 static void
12791 ffestb_subr_kill_beru_ ()
12792 {
12793   ffestpBeruIx ix;
12794
12795   for (ix = 0; ix < FFESTP_beruix; ++ix)
12796     {
12797       if (ffestp_file.beru.beru_spec[ix].kw_or_val_present)
12798         {
12799           if (ffestp_file.beru.beru_spec[ix].kw_present)
12800             ffelex_token_kill (ffestp_file.beru.beru_spec[ix].kw);
12801           if (ffestp_file.beru.beru_spec[ix].value_present)
12802             ffelex_token_kill (ffestp_file.beru.beru_spec[ix].value);
12803         }
12804     }
12805 }
12806
12807 #endif
12808 /* ffestb_subr_kill_close_ -- Kill CLOSE statement data structure
12809
12810    ffestb_subr_kill_close_();
12811
12812    Kills all tokens in the CLOSE data structure.  */
12813
12814 #if !FFESTB_KILL_EASY_
12815 static void
12816 ffestb_subr_kill_close_ ()
12817 {
12818   ffestpCloseIx ix;
12819
12820   for (ix = 0; ix < FFESTP_closeix; ++ix)
12821     {
12822       if (ffestp_file.close.close_spec[ix].kw_or_val_present)
12823         {
12824           if (ffestp_file.close.close_spec[ix].kw_present)
12825             ffelex_token_kill (ffestp_file.close.close_spec[ix].kw);
12826           if (ffestp_file.close.close_spec[ix].value_present)
12827             ffelex_token_kill (ffestp_file.close.close_spec[ix].value);
12828         }
12829     }
12830 }
12831
12832 #endif
12833 /* ffestb_subr_kill_delete_ -- Kill DELETE statement data structure
12834
12835    ffestb_subr_kill_delete_();
12836
12837    Kills all tokens in the DELETE data structure.  */
12838
12839 #if !FFESTB_KILL_EASY_
12840 static void
12841 ffestb_subr_kill_delete_ ()
12842 {
12843   ffestpDeleteIx ix;
12844
12845   for (ix = 0; ix < FFESTP_deleteix; ++ix)
12846     {
12847       if (ffestp_file.delete.delete_spec[ix].kw_or_val_present)
12848         {
12849           if (ffestp_file.delete.delete_spec[ix].kw_present)
12850             ffelex_token_kill (ffestp_file.delete.delete_spec[ix].kw);
12851           if (ffestp_file.delete.delete_spec[ix].value_present)
12852             ffelex_token_kill (ffestp_file.delete.delete_spec[ix].value);
12853         }
12854     }
12855 }
12856
12857 #endif
12858 /* ffestb_subr_kill_inquire_ -- Kill INQUIRE statement data structure
12859
12860    ffestb_subr_kill_inquire_();
12861
12862    Kills all tokens in the INQUIRE data structure.  */
12863
12864 #if !FFESTB_KILL_EASY_
12865 static void
12866 ffestb_subr_kill_inquire_ ()
12867 {
12868   ffestpInquireIx ix;
12869
12870   for (ix = 0; ix < FFESTP_inquireix; ++ix)
12871     {
12872       if (ffestp_file.inquire.inquire_spec[ix].kw_or_val_present)
12873         {
12874           if (ffestp_file.inquire.inquire_spec[ix].kw_present)
12875             ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].kw);
12876           if (ffestp_file.inquire.inquire_spec[ix].value_present)
12877             ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].value);
12878         }
12879     }
12880 }
12881
12882 #endif
12883 /* ffestb_subr_kill_open_ -- Kill OPEN statement data structure
12884
12885    ffestb_subr_kill_open_();
12886
12887    Kills all tokens in the OPEN data structure.  */
12888
12889 #if !FFESTB_KILL_EASY_
12890 static void
12891 ffestb_subr_kill_open_ ()
12892 {
12893   ffestpOpenIx ix;
12894
12895   for (ix = 0; ix < FFESTP_openix; ++ix)
12896     {
12897       if (ffestp_file.open.open_spec[ix].kw_or_val_present)
12898         {
12899           if (ffestp_file.open.open_spec[ix].kw_present)
12900             ffelex_token_kill (ffestp_file.open.open_spec[ix].kw);
12901           if (ffestp_file.open.open_spec[ix].value_present)
12902             ffelex_token_kill (ffestp_file.open.open_spec[ix].value);
12903         }
12904     }
12905 }
12906
12907 #endif
12908 /* ffestb_subr_kill_print_ -- Kill PRINT statement data structure
12909
12910    ffestb_subr_kill_print_();
12911
12912    Kills all tokens in the PRINT data structure.  */
12913
12914 #if !FFESTB_KILL_EASY_
12915 static void
12916 ffestb_subr_kill_print_ ()
12917 {
12918   ffestpPrintIx ix;
12919
12920   for (ix = 0; ix < FFESTP_printix; ++ix)
12921     {
12922       if (ffestp_file.print.print_spec[ix].kw_or_val_present)
12923         {
12924           if (ffestp_file.print.print_spec[ix].kw_present)
12925             ffelex_token_kill (ffestp_file.print.print_spec[ix].kw);
12926           if (ffestp_file.print.print_spec[ix].value_present)
12927             ffelex_token_kill (ffestp_file.print.print_spec[ix].value);
12928         }
12929     }
12930 }
12931
12932 #endif
12933 /* ffestb_subr_kill_read_ -- Kill READ statement data structure
12934
12935    ffestb_subr_kill_read_();
12936
12937    Kills all tokens in the READ data structure.  */
12938
12939 #if !FFESTB_KILL_EASY_
12940 static void
12941 ffestb_subr_kill_read_ ()
12942 {
12943   ffestpReadIx ix;
12944
12945   for (ix = 0; ix < FFESTP_readix; ++ix)
12946     {
12947       if (ffestp_file.read.read_spec[ix].kw_or_val_present)
12948         {
12949           if (ffestp_file.read.read_spec[ix].kw_present)
12950             ffelex_token_kill (ffestp_file.read.read_spec[ix].kw);
12951           if (ffestp_file.read.read_spec[ix].value_present)
12952             ffelex_token_kill (ffestp_file.read.read_spec[ix].value);
12953         }
12954     }
12955 }
12956
12957 #endif
12958 /* ffestb_subr_kill_rewrite_ -- Kill REWRITE statement data structure
12959
12960    ffestb_subr_kill_rewrite_();
12961
12962    Kills all tokens in the REWRITE data structure.  */
12963
12964 #if !FFESTB_KILL_EASY_
12965 static void
12966 ffestb_subr_kill_rewrite_ ()
12967 {
12968   ffestpRewriteIx ix;
12969
12970   for (ix = 0; ix < FFESTP_rewriteix; ++ix)
12971     {
12972       if (ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present)
12973         {
12974           if (ffestp_file.rewrite.rewrite_spec[ix].kw_present)
12975             ffelex_token_kill (ffestp_file.rewrite.rewrite_spec[ix].kw);
12976           if (ffestp_file.rewrite.rewrite_spec[ix].value_present)
12977             ffelex_token_kill (ffestp_file.rewrite.rewrite_spec[ix].value);
12978         }
12979     }
12980 }
12981
12982 #endif
12983 /* ffestb_subr_kill_type_ -- Kill TYPE statement data structure
12984
12985    ffestb_subr_kill_type_();
12986
12987    Kills all tokens in the TYPE data structure.  */
12988
12989 #if !FFESTB_KILL_EASY_
12990 static void
12991 ffestb_subr_kill_type_ ()
12992 {
12993   ffestpTypeIx ix;
12994
12995   for (ix = 0; ix < FFESTP_typeix; ++ix)
12996     {
12997       if (ffestp_file.type.type_spec[ix].kw_or_val_present)
12998         {
12999           if (ffestp_file.type.type_spec[ix].kw_present)
13000             ffelex_token_kill (ffestp_file.type.type_spec[ix].kw);
13001           if (ffestp_file.type.type_spec[ix].value_present)
13002             ffelex_token_kill (ffestp_file.type.type_spec[ix].value);
13003         }
13004     }
13005 }
13006
13007 #endif
13008 /* ffestb_subr_kill_write_ -- Kill WRITE statement data structure
13009
13010    ffestb_subr_kill_write_();
13011
13012    Kills all tokens in the WRITE data structure.  */
13013
13014 #if !FFESTB_KILL_EASY_
13015 static void
13016 ffestb_subr_kill_write_ ()
13017 {
13018   ffestpWriteIx ix;
13019
13020   for (ix = 0; ix < FFESTP_writeix; ++ix)
13021     {
13022       if (ffestp_file.write.write_spec[ix].kw_or_val_present)
13023         {
13024           if (ffestp_file.write.write_spec[ix].kw_present)
13025             ffelex_token_kill (ffestp_file.write.write_spec[ix].kw);
13026           if (ffestp_file.write.write_spec[ix].value_present)
13027             ffelex_token_kill (ffestp_file.write.write_spec[ix].value);
13028         }
13029     }
13030 }
13031
13032 #endif
13033 /* ffestb_beru -- Parse the BACKSPACE/ENDFILE/REWIND/UNLOCK statement
13034
13035    return ffestb_beru;  // to lexer
13036
13037    Make sure the statement has a valid form for the BACKSPACE/ENDFILE/REWIND/
13038    UNLOCK statement.  If it does, implement the statement.  */
13039
13040 ffelexHandler
13041 ffestb_beru (ffelexToken t)
13042 {
13043   ffelexHandler next;
13044   ffestpBeruIx ix;
13045
13046   switch (ffelex_token_type (ffesta_tokens[0]))
13047     {
13048     case FFELEX_typeNAME:
13049       switch (ffelex_token_type (t))
13050         {
13051         case FFELEX_typeCOMMA:
13052         case FFELEX_typeCOLONCOLON:
13053         case FFELEX_typeEOS:
13054         case FFELEX_typeSEMICOLON:
13055           ffesta_confirmed ();  /* Error, but clearly intended. */
13056           goto bad_1;           /* :::::::::::::::::::: */
13057
13058         case FFELEX_typeEQUALS:
13059         case FFELEX_typePOINTS:
13060         case FFELEX_typeCOLON:
13061           goto bad_1;           /* :::::::::::::::::::: */
13062
13063         case FFELEX_typeNAME:
13064         case FFELEX_typeNUMBER:
13065           ffesta_confirmed ();
13066           break;
13067
13068         case FFELEX_typeOPEN_PAREN:
13069           for (ix = 0; ix < FFESTP_beruix; ++ix)
13070             ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13071           ffesta_tokens[1] = ffelex_token_use (t);
13072           return (ffelexHandler) ffestb_beru2_;
13073
13074         default:
13075           break;
13076         }
13077
13078       for (ix = 0; ix < FFESTP_beruix; ++ix)
13079         ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13080       return (ffelexHandler) (*((ffelexHandler)
13081                                 ffeexpr_rhs (ffesta_output_pool,
13082                                              FFEEXPR_contextFILENUM,
13083                                           (ffeexprCallback) ffestb_beru1_)))
13084         (t);
13085
13086     case FFELEX_typeNAMES:
13087       switch (ffelex_token_type (t))
13088         {
13089         case FFELEX_typeCOMMA:
13090         case FFELEX_typeCOLONCOLON:
13091           ffesta_confirmed ();  /* Error, but clearly intended. */
13092           goto bad_1;           /* :::::::::::::::::::: */
13093
13094         case FFELEX_typeEQUALS:
13095         case FFELEX_typePOINTS:
13096         case FFELEX_typeCOLON:
13097           goto bad_1;           /* :::::::::::::::::::: */
13098
13099         case FFELEX_typeEOS:
13100         case FFELEX_typeSEMICOLON:
13101           ffesta_confirmed ();
13102           break;
13103
13104         case FFELEX_typeOPEN_PAREN:
13105           if (ffelex_token_length (ffesta_tokens[0])
13106               != ffestb_args.beru.len)
13107             break;
13108
13109           for (ix = 0; ix < FFESTP_beruix; ++ix)
13110             ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13111           ffesta_tokens[1] = ffelex_token_use (t);
13112           return (ffelexHandler) ffestb_beru2_;
13113
13114         default:
13115           break;
13116         }
13117       for (ix = 0; ix < FFESTP_beruix; ++ix)
13118         ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13119       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13120                    FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_beru1_);
13121       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
13122                                                    ffestb_args.beru.len);
13123       if (next == NULL)
13124         return (ffelexHandler) ffelex_swallow_tokens (t,
13125                                                (ffelexHandler) ffesta_zero);
13126       return (ffelexHandler) (*next) (t);
13127
13128     default:
13129       goto bad_0;               /* :::::::::::::::::::: */
13130     }
13131
13132 bad_0:                          /* :::::::::::::::::::: */
13133   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, ffesta_tokens[0]);
13134   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13135
13136 bad_1:                          /* :::::::::::::::::::: */
13137   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13138   return (ffelexHandler) ffelex_swallow_tokens (t,
13139                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
13140 }
13141
13142 /* ffestb_beru1_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" expr
13143
13144    (ffestb_beru1_)  // to expression handler
13145
13146    Make sure the next token is an EOS or SEMICOLON.  */
13147
13148 static ffelexHandler
13149 ffestb_beru1_ (ffelexToken ft, ffebld expr, ffelexToken t)
13150 {
13151   switch (ffelex_token_type (t))
13152     {
13153     case FFELEX_typeEOS:
13154     case FFELEX_typeSEMICOLON:
13155       if (expr == NULL)
13156         break;
13157       ffesta_confirmed ();
13158       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_or_val_present
13159         = TRUE;
13160       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_present = FALSE;
13161       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_present = TRUE;
13162       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_is_label
13163         = FALSE;
13164       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value
13165         = ffelex_token_use (ft);
13166       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].u.expr = expr;
13167       if (!ffesta_is_inhibited ())
13168         {
13169           switch (ffesta_first_kw)
13170             {
13171             case FFESTR_firstBACKSPACE:
13172               ffestc_R919 ();
13173               break;
13174
13175             case FFESTR_firstENDFILE:
13176             case FFESTR_firstEND:
13177               ffestc_R920 ();
13178               break;
13179
13180             case FFESTR_firstREWIND:
13181               ffestc_R921 ();
13182               break;
13183
13184 #if FFESTR_VXT
13185             case FFESTR_firstUNLOCK:
13186               ffestc_V022 ();
13187               break;
13188 #endif
13189
13190             default:
13191               assert (FALSE);
13192             }
13193         }
13194       ffestb_subr_kill_beru_ ();
13195       return (ffelexHandler) ffesta_zero (t);
13196
13197     default:
13198       break;
13199     }
13200
13201   ffestb_subr_kill_beru_ ();
13202   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13203   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13204 }
13205
13206 /* ffestb_beru2_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN
13207
13208    return ffestb_beru2_;  // to lexer
13209
13210    Handle expr construct (not NAME=expr construct) here.  */
13211
13212 static ffelexHandler
13213 ffestb_beru2_ (ffelexToken t)
13214 {
13215   ffelexToken nt;
13216   ffelexHandler next;
13217
13218   switch (ffelex_token_type (t))
13219     {
13220     case FFELEX_typeNAME:
13221       ffesta_tokens[2] = ffelex_token_use (t);
13222       return (ffelexHandler) ffestb_beru3_;
13223
13224     default:
13225       nt = ffesta_tokens[1];
13226       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13227              FFEEXPR_contextFILENUMAMBIG, (ffeexprCallback) ffestb_beru4_)))
13228         (nt);
13229       ffelex_token_kill (nt);
13230       return (ffelexHandler) (*next) (t);
13231     }
13232 }
13233
13234 /* ffestb_beru3_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN NAME
13235
13236    return ffestb_beru3_;  // to lexer
13237
13238    If EQUALS here, go to states that handle it.  Else, send NAME and this
13239    token thru expression handler.  */
13240
13241 static ffelexHandler
13242 ffestb_beru3_ (ffelexToken t)
13243 {
13244   ffelexHandler next;
13245   ffelexToken nt;
13246   ffelexToken ot;
13247
13248   switch (ffelex_token_type (t))
13249     {
13250     case FFELEX_typeEQUALS:
13251       ffelex_token_kill (ffesta_tokens[1]);
13252       nt = ffesta_tokens[2];
13253       next = (ffelexHandler) ffestb_beru5_ (nt);
13254       ffelex_token_kill (nt);
13255       return (ffelexHandler) (*next) (t);
13256
13257     default:
13258       nt = ffesta_tokens[1];
13259       ot = ffesta_tokens[2];
13260       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13261              FFEEXPR_contextFILENUMAMBIG, (ffeexprCallback) ffestb_beru4_)))
13262         (nt);
13263       ffelex_token_kill (nt);
13264       next = (ffelexHandler) (*next) (ot);
13265       ffelex_token_kill (ot);
13266       return (ffelexHandler) (*next) (t);
13267     }
13268 }
13269
13270 /* ffestb_beru4_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN expr [CLOSE_PAREN]
13271
13272    (ffestb_beru4_)  // to expression handler
13273
13274    Handle COMMA or EOS/SEMICOLON here.
13275
13276    15-Feb-91  JCB  1.2
13277       Now using new mechanism whereby expr comes back as opITEM if the
13278       expr is considered part (or all) of an I/O control list (and should
13279       be stripped of its outer opITEM node) or not if it is considered
13280       a plain unit number that happens to have been enclosed in parens.
13281    26-Mar-90  JCB  1.1
13282       No longer expecting close-paren here because of constructs like
13283       BACKSPACE (5)+2, so now expecting either COMMA because it was a
13284       construct like BACKSPACE (5+2,... or EOS/SEMICOLON because it is like
13285       the former construct.  Ah, the vagaries of Fortran.  */
13286
13287 static ffelexHandler
13288 ffestb_beru4_ (ffelexToken ft, ffebld expr, ffelexToken t)
13289 {
13290   bool inlist;
13291
13292   switch (ffelex_token_type (t))
13293     {
13294     case FFELEX_typeCOMMA:
13295     case FFELEX_typeEOS:
13296     case FFELEX_typeSEMICOLON:
13297     case FFELEX_typeCLOSE_PAREN:
13298       if (expr == NULL)
13299         break;
13300       if (ffebld_op (expr) == FFEBLD_opITEM)
13301         {
13302           inlist = TRUE;
13303           expr = ffebld_head (expr);
13304         }
13305       else
13306         inlist = FALSE;
13307       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_or_val_present
13308         = TRUE;
13309       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_present = FALSE;
13310       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_present = TRUE;
13311       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_is_label
13312         = FALSE;
13313       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value
13314         = ffelex_token_use (ft);
13315       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].u.expr = expr;
13316       if (inlist)
13317         return (ffelexHandler) ffestb_beru9_ (t);
13318       return (ffelexHandler) ffestb_beru10_ (t);
13319
13320     default:
13321       break;
13322     }
13323
13324   ffestb_subr_kill_beru_ ();
13325   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13326   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13327 }
13328
13329 /* ffestb_beru5_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN [external-file-unit
13330                     COMMA]
13331
13332    return ffestb_beru5_;  // to lexer
13333
13334    Handle expr construct (not NAME=expr construct) here.  */
13335
13336 static ffelexHandler
13337 ffestb_beru5_ (ffelexToken t)
13338 {
13339   ffestrGenio kw;
13340
13341   ffestb_local_.beru.label = FALSE;
13342
13343   switch (ffelex_token_type (t))
13344     {
13345     case FFELEX_typeNAME:
13346       kw = ffestr_genio (t);
13347       switch (kw)
13348         {
13349         case FFESTR_genioERR:
13350           ffestb_local_.beru.ix = FFESTP_beruixERR;
13351           ffestb_local_.beru.label = TRUE;
13352           break;
13353
13354         case FFESTR_genioIOSTAT:
13355           ffestb_local_.beru.ix = FFESTP_beruixIOSTAT;
13356           ffestb_local_.beru.left = TRUE;
13357           ffestb_local_.beru.context = FFEEXPR_contextFILEINT;
13358           break;
13359
13360         case FFESTR_genioUNIT:
13361           ffestb_local_.beru.ix = FFESTP_beruixUNIT;
13362           ffestb_local_.beru.left = FALSE;
13363           ffestb_local_.beru.context = FFEEXPR_contextFILENUM;
13364           break;
13365
13366         default:
13367           goto bad;             /* :::::::::::::::::::: */
13368         }
13369       if (ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13370           .kw_or_val_present)
13371         break;                  /* Can't specify a keyword twice! */
13372       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13373         .kw_or_val_present = TRUE;
13374       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13375         .kw_present = TRUE;
13376       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13377         .value_present = FALSE;
13378       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value_is_label
13379         = ffestb_local_.beru.label;
13380       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].kw
13381         = ffelex_token_use (t);
13382       return (ffelexHandler) ffestb_beru6_;
13383
13384     default:
13385       break;
13386     }
13387
13388 bad:                            /* :::::::::::::::::::: */
13389   ffestb_subr_kill_beru_ ();
13390   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13391   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13392 }
13393
13394 /* ffestb_beru6_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN [external-file-unit
13395                     COMMA] NAME
13396
13397    return ffestb_beru6_;  // to lexer
13398
13399    Make sure EQUALS here, send next token to expression handler.  */
13400
13401 static ffelexHandler
13402 ffestb_beru6_ (ffelexToken t)
13403 {
13404
13405   switch (ffelex_token_type (t))
13406     {
13407     case FFELEX_typeEQUALS:
13408       ffesta_confirmed ();
13409       if (ffestb_local_.beru.label)
13410         return (ffelexHandler) ffestb_beru8_;
13411       if (ffestb_local_.beru.left)
13412         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13413                                             ffestb_local_.beru.context,
13414                                             (ffeexprCallback) ffestb_beru7_);
13415       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13416                                           ffestb_local_.beru.context,
13417                                           (ffeexprCallback) ffestb_beru7_);
13418
13419     default:
13420       break;
13421     }
13422
13423   ffestb_subr_kill_beru_ ();
13424   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13425   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13426 }
13427
13428 /* ffestb_beru7_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS expr
13429
13430    (ffestb_beru7_)  // to expression handler
13431
13432    Handle COMMA or CLOSE_PAREN here.  */
13433
13434 static ffelexHandler
13435 ffestb_beru7_ (ffelexToken ft, ffebld expr, ffelexToken t)
13436 {
13437   switch (ffelex_token_type (t))
13438     {
13439     case FFELEX_typeCOMMA:
13440     case FFELEX_typeCLOSE_PAREN:
13441       if (expr == NULL)
13442         break;
13443       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value_present
13444         = TRUE;
13445       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value
13446         = ffelex_token_use (ft);
13447       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].u.expr = expr;
13448       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
13449         return (ffelexHandler) ffestb_beru5_;
13450       return (ffelexHandler) ffestb_beru10_;
13451
13452     default:
13453       break;
13454     }
13455
13456   ffestb_subr_kill_beru_ ();
13457   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13458   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13459 }
13460
13461 /* ffestb_beru8_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS
13462
13463    return ffestb_beru8_;  // to lexer
13464
13465    Handle NUMBER for label here.  */
13466
13467 static ffelexHandler
13468 ffestb_beru8_ (ffelexToken t)
13469 {
13470   switch (ffelex_token_type (t))
13471     {
13472     case FFELEX_typeNUMBER:
13473       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value_present
13474         = TRUE;
13475       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value
13476         = ffelex_token_use (t);
13477       return (ffelexHandler) ffestb_beru9_;
13478
13479     default:
13480       break;
13481     }
13482
13483   ffestb_subr_kill_beru_ ();
13484   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13485   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13486 }
13487
13488 /* ffestb_beru9_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS
13489                    NUMBER
13490
13491    return ffestb_beru9_;  // to lexer
13492
13493    Handle COMMA or CLOSE_PAREN here.  */
13494
13495 static ffelexHandler
13496 ffestb_beru9_ (ffelexToken t)
13497 {
13498   switch (ffelex_token_type (t))
13499     {
13500     case FFELEX_typeCOMMA:
13501       return (ffelexHandler) ffestb_beru5_;
13502
13503     case FFELEX_typeCLOSE_PAREN:
13504       return (ffelexHandler) ffestb_beru10_;
13505
13506     default:
13507       break;
13508     }
13509
13510   ffestb_subr_kill_beru_ ();
13511   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13512   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13513 }
13514
13515 /* ffestb_beru10_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... CLOSE_PAREN
13516
13517    return ffestb_beru10_;  // to lexer
13518
13519    Handle EOS or SEMICOLON here.  */
13520
13521 static ffelexHandler
13522 ffestb_beru10_ (ffelexToken t)
13523 {
13524   switch (ffelex_token_type (t))
13525     {
13526     case FFELEX_typeEOS:
13527     case FFELEX_typeSEMICOLON:
13528       ffesta_confirmed ();
13529       if (!ffesta_is_inhibited ())
13530         {
13531           switch (ffesta_first_kw)
13532             {
13533             case FFESTR_firstBACKSPACE:
13534               ffestc_R919 ();
13535               break;
13536
13537             case FFESTR_firstENDFILE:
13538             case FFESTR_firstEND:
13539               ffestc_R920 ();
13540               break;
13541
13542             case FFESTR_firstREWIND:
13543               ffestc_R921 ();
13544               break;
13545
13546 #if FFESTR_VXT
13547             case FFESTR_firstUNLOCK:
13548               ffestc_V022 ();
13549               break;
13550 #endif
13551
13552             default:
13553               assert (FALSE);
13554             }
13555         }
13556       ffestb_subr_kill_beru_ ();
13557       return (ffelexHandler) ffesta_zero (t);
13558
13559     default:
13560       break;
13561     }
13562
13563   ffestb_subr_kill_beru_ ();
13564   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13565   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13566 }
13567
13568 /* ffestb_vxtcode -- Parse the VXT DECODE/ENCODE statement
13569
13570    return ffestb_vxtcode;  // to lexer
13571
13572    Make sure the statement has a valid form for the VXT DECODE/ENCODE
13573    statement.  If it does, implement the statement.  */
13574
13575 #if FFESTR_VXT
13576 ffelexHandler
13577 ffestb_vxtcode (ffelexToken t)
13578 {
13579   ffestpVxtcodeIx ix;
13580
13581   switch (ffelex_token_type (ffesta_tokens[0]))
13582     {
13583     case FFELEX_typeNAME:
13584       switch (ffelex_token_type (t))
13585         {
13586         case FFELEX_typeCOMMA:
13587         case FFELEX_typeCOLONCOLON:
13588         case FFELEX_typeEOS:
13589         case FFELEX_typeSEMICOLON:
13590         case FFELEX_typeNAME:
13591         case FFELEX_typeNUMBER:
13592           ffesta_confirmed ();  /* Error, but clearly intended. */
13593           goto bad_1;           /* :::::::::::::::::::: */
13594
13595         default:
13596           goto bad_1;           /* :::::::::::::::::::: */
13597
13598         case FFELEX_typeOPEN_PAREN:
13599           for (ix = 0; ix < FFESTP_vxtcodeix; ++ix)
13600             ffestp_file.vxtcode.vxtcode_spec[ix].kw_or_val_present = FALSE;
13601           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13602                 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_vxtcode1_);
13603         }
13604
13605     case FFELEX_typeNAMES:
13606       switch (ffelex_token_type (t))
13607         {
13608         case FFELEX_typeEOS:
13609         case FFELEX_typeSEMICOLON:
13610         case FFELEX_typeCOMMA:
13611         case FFELEX_typeCOLONCOLON:
13612           ffesta_confirmed ();  /* Error, but clearly intended. */
13613           goto bad_1;           /* :::::::::::::::::::: */
13614
13615         default:
13616           goto bad_1;           /* :::::::::::::::::::: */
13617
13618         case FFELEX_typeOPEN_PAREN:
13619           if (ffelex_token_length (ffesta_tokens[0])
13620               != ffestb_args.vxtcode.len)
13621             goto bad_0;         /* :::::::::::::::::::: */
13622
13623           for (ix = 0; ix < FFESTP_vxtcodeix; ++ix)
13624             ffestp_file.vxtcode.vxtcode_spec[ix].kw_or_val_present = FALSE;
13625           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13626                 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_vxtcode1_);
13627         }
13628
13629     default:
13630       goto bad_0;               /* :::::::::::::::::::: */
13631     }
13632
13633 bad_0:                          /* :::::::::::::::::::: */
13634   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, ffesta_tokens[0]);
13635   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13636
13637 bad_1:                          /* :::::::::::::::::::: */
13638   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13639   return (ffelexHandler) ffelex_swallow_tokens (t,
13640                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
13641 }
13642
13643 /* ffestb_vxtcode1_ -- "VXTCODE" OPEN_PAREN expr
13644
13645    (ffestb_vxtcode1_)  // to expression handler
13646
13647    Handle COMMA here.  */
13648
13649 static ffelexHandler
13650 ffestb_vxtcode1_ (ffelexToken ft, ffebld expr, ffelexToken t)
13651 {
13652   switch (ffelex_token_type (t))
13653     {
13654     case FFELEX_typeCOMMA:
13655       if (expr == NULL)
13656         break;
13657       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].kw_or_val_present
13658         = TRUE;
13659       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].kw_present = FALSE;
13660       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value_present = TRUE;
13661       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value_is_label
13662         = FALSE;
13663       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value
13664         = ffelex_token_use (ft);
13665       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].u.expr = expr;
13666       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13667              FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_vxtcode2_);
13668
13669     default:
13670       break;
13671     }
13672
13673   ffestb_subr_kill_vxtcode_ ();
13674   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13675   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13676 }
13677
13678 /* ffestb_vxtcode2_ -- "VXTCODE" OPEN_PAREN expr COMMA expr
13679
13680    (ffestb_vxtcode2_)  // to expression handler
13681
13682    Handle COMMA here.  */
13683
13684 static ffelexHandler
13685 ffestb_vxtcode2_ (ffelexToken ft, ffebld expr, ffelexToken t)
13686 {
13687   switch (ffelex_token_type (t))
13688     {
13689     case FFELEX_typeCOMMA:
13690       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].kw_or_val_present
13691         = TRUE;
13692       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].kw_present = FALSE;
13693       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value_present = TRUE;
13694       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value_is_label
13695         = (expr == NULL);
13696       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value
13697         = ffelex_token_use (ft);
13698       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].u.expr = expr;
13699       if (ffesta_first_kw == FFESTR_firstENCODE)
13700         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13701                                             FFEEXPR_contextFILEVXTCODE,
13702                                         (ffeexprCallback) ffestb_vxtcode3_);
13703       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13704                                           FFEEXPR_contextFILEVXTCODE,
13705                                         (ffeexprCallback) ffestb_vxtcode3_);
13706
13707     default:
13708       break;
13709     }
13710
13711   ffestb_subr_kill_vxtcode_ ();
13712   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13713   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13714 }
13715
13716 /* ffestb_vxtcode3_ -- "VXTCODE" OPEN_PAREN expr COMMA expr COMMA expr
13717
13718    (ffestb_vxtcode3_)  // to expression handler
13719
13720    Handle COMMA or CLOSE_PAREN here.  */
13721
13722 static ffelexHandler
13723 ffestb_vxtcode3_ (ffelexToken ft, ffebld expr, ffelexToken t)
13724 {
13725   switch (ffelex_token_type (t))
13726     {
13727     case FFELEX_typeCOMMA:
13728     case FFELEX_typeCLOSE_PAREN:
13729       if (expr == NULL)
13730         break;
13731       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].kw_or_val_present
13732         = TRUE;
13733       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].kw_present = FALSE;
13734       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value_present = TRUE;
13735       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value_is_label
13736         = FALSE;
13737       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value
13738         = ffelex_token_use (ft);
13739       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].u.expr = expr;
13740       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
13741         return (ffelexHandler) ffestb_vxtcode4_;
13742       return (ffelexHandler) ffestb_vxtcode9_;
13743
13744     default:
13745       break;
13746     }
13747
13748   ffestb_subr_kill_vxtcode_ ();
13749   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13750   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13751 }
13752
13753 /* ffestb_vxtcode4_ -- "VXTCODE" OPEN_PAREN ...
13754
13755    return ffestb_vxtcode4_;  // to lexer
13756
13757    Handle NAME=expr construct here.  */
13758
13759 static ffelexHandler
13760 ffestb_vxtcode4_ (ffelexToken t)
13761 {
13762   ffestrGenio kw;
13763
13764   ffestb_local_.vxtcode.label = FALSE;
13765
13766   switch (ffelex_token_type (t))
13767     {
13768     case FFELEX_typeNAME:
13769       kw = ffestr_genio (t);
13770       switch (kw)
13771         {
13772         case FFESTR_genioERR:
13773           ffestb_local_.vxtcode.ix = FFESTP_vxtcodeixERR;
13774           ffestb_local_.vxtcode.label = TRUE;
13775           break;
13776
13777         case FFESTR_genioIOSTAT:
13778           ffestb_local_.vxtcode.ix = FFESTP_vxtcodeixIOSTAT;
13779           ffestb_local_.vxtcode.left = TRUE;
13780           ffestb_local_.vxtcode.context = FFEEXPR_contextFILEINT;
13781           break;
13782
13783         default:
13784           goto bad;             /* :::::::::::::::::::: */
13785         }
13786       if (ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13787           .kw_or_val_present)
13788         break;                  /* Can't specify a keyword twice! */
13789       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13790         .kw_or_val_present = TRUE;
13791       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13792         .kw_present = TRUE;
13793       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13794         .value_present = FALSE;
13795       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value_is_label
13796         = ffestb_local_.vxtcode.label;
13797       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].kw
13798         = ffelex_token_use (t);
13799       return (ffelexHandler) ffestb_vxtcode5_;
13800
13801     default:
13802       break;
13803     }
13804
13805 bad:                            /* :::::::::::::::::::: */
13806   ffestb_subr_kill_vxtcode_ ();
13807   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13808   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13809 }
13810
13811 /* ffestb_vxtcode5_ -- "VXTCODE" OPEN_PAREN [external-file-unit COMMA [format
13812                    COMMA]] NAME
13813
13814    return ffestb_vxtcode5_;  // to lexer
13815
13816    Make sure EQUALS here, send next token to expression handler.  */
13817
13818 static ffelexHandler
13819 ffestb_vxtcode5_ (ffelexToken t)
13820 {
13821   switch (ffelex_token_type (t))
13822     {
13823     case FFELEX_typeEQUALS:
13824       ffesta_confirmed ();
13825       if (ffestb_local_.vxtcode.label)
13826         return (ffelexHandler) ffestb_vxtcode7_;
13827       if (ffestb_local_.vxtcode.left)
13828         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13829                                             ffestb_local_.vxtcode.context,
13830                                         (ffeexprCallback) ffestb_vxtcode6_);
13831       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13832                                           ffestb_local_.vxtcode.context,
13833                                         (ffeexprCallback) ffestb_vxtcode6_);
13834
13835     default:
13836       break;
13837     }
13838
13839   ffestb_subr_kill_vxtcode_ ();
13840   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13841   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13842 }
13843
13844 /* ffestb_vxtcode6_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS expr
13845
13846    (ffestb_vxtcode6_)  // to expression handler
13847
13848    Handle COMMA or CLOSE_PAREN here.  */
13849
13850 static ffelexHandler
13851 ffestb_vxtcode6_ (ffelexToken ft, ffebld expr, ffelexToken t)
13852 {
13853   switch (ffelex_token_type (t))
13854     {
13855     case FFELEX_typeCOMMA:
13856     case FFELEX_typeCLOSE_PAREN:
13857       if (expr == NULL)
13858         break;
13859       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value_present
13860         = TRUE;
13861       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value
13862         = ffelex_token_use (ft);
13863       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].u.expr = expr;
13864       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
13865         return (ffelexHandler) ffestb_vxtcode4_;
13866       return (ffelexHandler) ffestb_vxtcode9_;
13867
13868     default:
13869       break;
13870     }
13871
13872   ffestb_subr_kill_vxtcode_ ();
13873   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13874   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13875 }
13876
13877 /* ffestb_vxtcode7_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS
13878
13879    return ffestb_vxtcode7_;  // to lexer
13880
13881    Handle NUMBER for label here.  */
13882
13883 static ffelexHandler
13884 ffestb_vxtcode7_ (ffelexToken t)
13885 {
13886   switch (ffelex_token_type (t))
13887     {
13888     case FFELEX_typeNUMBER:
13889       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value_present
13890         = TRUE;
13891       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value
13892         = ffelex_token_use (t);
13893       return (ffelexHandler) ffestb_vxtcode8_;
13894
13895     default:
13896       break;
13897     }
13898
13899   ffestb_subr_kill_vxtcode_ ();
13900   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13901   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13902 }
13903
13904 /* ffestb_vxtcode8_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS NUMBER
13905
13906    return ffestb_vxtcode8_;  // to lexer
13907
13908    Handle COMMA or CLOSE_PAREN here.  */
13909
13910 static ffelexHandler
13911 ffestb_vxtcode8_ (ffelexToken t)
13912 {
13913   switch (ffelex_token_type (t))
13914     {
13915     case FFELEX_typeCOMMA:
13916       return (ffelexHandler) ffestb_vxtcode4_;
13917
13918     case FFELEX_typeCLOSE_PAREN:
13919       return (ffelexHandler) ffestb_vxtcode9_;
13920
13921     default:
13922       break;
13923     }
13924
13925   ffestb_subr_kill_vxtcode_ ();
13926   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13927   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13928 }
13929
13930 /* ffestb_vxtcode9_ -- "VXTCODE" OPEN_PAREN ... CLOSE_PAREN
13931
13932    return ffestb_vxtcode9_;  // to lexer
13933
13934    Handle EOS or SEMICOLON here.
13935
13936    07-Jun-90  JCB  1.1
13937       Context for ENCODE/DECODE expressions is now IOLISTDF instead of IOLIST
13938       since they apply to internal files.  */
13939
13940 static ffelexHandler
13941 ffestb_vxtcode9_ (ffelexToken t)
13942 {
13943   ffelexHandler next;
13944
13945   switch (ffelex_token_type (t))
13946     {
13947     case FFELEX_typeEOS:
13948     case FFELEX_typeSEMICOLON:
13949       ffesta_confirmed ();
13950       if (!ffesta_is_inhibited ())
13951         {
13952           if (ffesta_first_kw == FFESTR_firstENCODE)
13953             {
13954               ffestc_V023_start ();
13955               ffestc_V023_finish ();
13956             }
13957           else
13958             {
13959               ffestc_V024_start ();
13960               ffestc_V024_finish ();
13961             }
13962         }
13963       ffestb_subr_kill_vxtcode_ ();
13964       return (ffelexHandler) ffesta_zero (t);
13965
13966     case FFELEX_typeNAME:
13967     case FFELEX_typeOPEN_PAREN:
13968     case FFELEX_typeCOMMA:
13969       ffesta_confirmed ();
13970       if (!ffesta_is_inhibited ())
13971         if (ffesta_first_kw == FFESTR_firstENCODE)
13972           ffestc_V023_start ();
13973         else
13974           ffestc_V024_start ();
13975       ffestb_subr_kill_vxtcode_ ();
13976       if (ffesta_first_kw == FFESTR_firstDECODE)
13977         next = (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13978                                             FFEEXPR_contextIOLISTDF,
13979                                        (ffeexprCallback) ffestb_vxtcode10_);
13980       else
13981         next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13982                                             FFEEXPR_contextIOLISTDF,
13983                                        (ffeexprCallback) ffestb_vxtcode10_);
13984
13985       /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
13986          (f2c provides this extension, as do other compilers, supposedly.) */
13987
13988       if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
13989         return next;
13990
13991       return (ffelexHandler) (*next) (t);
13992
13993     default:
13994       break;
13995     }
13996
13997   ffestb_subr_kill_vxtcode_ ();
13998   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13999   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14000 }
14001
14002 /* ffestb_vxtcode10_ -- "VXTCODE(...)" expr
14003
14004    (ffestb_vxtcode10_)  // to expression handler
14005
14006    Handle COMMA or EOS/SEMICOLON here.
14007
14008    07-Jun-90  JCB  1.1
14009       Context for ENCODE/DECODE expressions is now IOLISTDF instead of IOLIST
14010       since they apply to internal files.  */
14011
14012 static ffelexHandler
14013 ffestb_vxtcode10_ (ffelexToken ft, ffebld expr, ffelexToken t)
14014 {
14015   switch (ffelex_token_type (t))
14016     {
14017     case FFELEX_typeCOMMA:
14018       if (expr == NULL)
14019         break;
14020       if (!ffesta_is_inhibited ())
14021         if (ffesta_first_kw == FFESTR_firstENCODE)
14022           ffestc_V023_item (expr, ft);
14023         else
14024           ffestc_V024_item (expr, ft);
14025       if (ffesta_first_kw == FFESTR_firstDECODE)
14026         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
14027                                             FFEEXPR_contextIOLISTDF,
14028                                        (ffeexprCallback) ffestb_vxtcode10_);
14029       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14030                                           FFEEXPR_contextIOLISTDF,
14031                                        (ffeexprCallback) ffestb_vxtcode10_);
14032
14033     case FFELEX_typeEOS:
14034     case FFELEX_typeSEMICOLON:
14035       if (expr == NULL)
14036         break;
14037       if (!ffesta_is_inhibited ())
14038         {
14039           if (ffesta_first_kw == FFESTR_firstENCODE)
14040             {
14041               ffestc_V023_item (expr, ft);
14042               ffestc_V023_finish ();
14043             }
14044           else
14045             {
14046               ffestc_V024_item (expr, ft);
14047               ffestc_V024_finish ();
14048             }
14049         }
14050       return (ffelexHandler) ffesta_zero (t);
14051
14052     default:
14053       break;
14054     }
14055
14056   if (!ffesta_is_inhibited ())
14057     if (ffesta_first_kw == FFESTR_firstENCODE)
14058       ffestc_V023_finish ();
14059     else
14060       ffestc_V024_finish ();
14061   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
14062   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14063 }
14064
14065 #endif
14066 /* ffestb_R904 -- Parse an OPEN statement
14067
14068    return ffestb_R904;  // to lexer
14069
14070    Make sure the statement has a valid form for an OPEN statement.
14071    If it does, implement the statement.  */
14072
14073 ffelexHandler
14074 ffestb_R904 (ffelexToken t)
14075 {
14076   ffestpOpenIx ix;
14077
14078   switch (ffelex_token_type (ffesta_tokens[0]))
14079     {
14080     case FFELEX_typeNAME:
14081       if (ffesta_first_kw != FFESTR_firstOPEN)
14082         goto bad_0;             /* :::::::::::::::::::: */
14083       break;
14084
14085     case FFELEX_typeNAMES:
14086       if (ffesta_first_kw != FFESTR_firstOPEN)
14087         goto bad_0;             /* :::::::::::::::::::: */
14088       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlOPEN)
14089         goto bad_0;             /* :::::::::::::::::::: */
14090       break;
14091
14092     default:
14093       goto bad_0;               /* :::::::::::::::::::: */
14094     }
14095
14096   switch (ffelex_token_type (t))
14097     {
14098     case FFELEX_typeOPEN_PAREN:
14099       break;
14100
14101     case FFELEX_typeEOS:
14102     case FFELEX_typeSEMICOLON:
14103     case FFELEX_typeCOMMA:
14104     case FFELEX_typeCOLONCOLON:
14105       ffesta_confirmed ();      /* Error, but clearly intended. */
14106       goto bad_1;               /* :::::::::::::::::::: */
14107
14108     default:
14109       goto bad_1;               /* :::::::::::::::::::: */
14110     }
14111
14112   for (ix = 0; ix < FFESTP_openix; ++ix)
14113     ffestp_file.open.open_spec[ix].kw_or_val_present = FALSE;
14114
14115   return (ffelexHandler) ffestb_R9041_;
14116
14117 bad_0:                          /* :::::::::::::::::::: */
14118   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", ffesta_tokens[0]);
14119   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14120
14121 bad_1:                          /* :::::::::::::::::::: */
14122   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14123   return (ffelexHandler) ffelex_swallow_tokens (t,
14124                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
14125 }
14126
14127 /* ffestb_R9041_ -- "OPEN" OPEN_PAREN
14128
14129    return ffestb_R9041_;  // to lexer
14130
14131    Handle expr construct (not NAME=expr construct) here.  */
14132
14133 static ffelexHandler
14134 ffestb_R9041_ (ffelexToken t)
14135 {
14136   switch (ffelex_token_type (t))
14137     {
14138     case FFELEX_typeNAME:
14139       ffesta_tokens[1] = ffelex_token_use (t);
14140       return (ffelexHandler) ffestb_R9042_;
14141
14142     default:
14143       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14144                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9043_)))
14145         (t);
14146     }
14147 }
14148
14149 /* ffestb_R9042_ -- "OPEN" OPEN_PAREN NAME
14150
14151    return ffestb_R9042_;  // to lexer
14152
14153    If EQUALS here, go to states that handle it.  Else, send NAME and this
14154    token thru expression handler.  */
14155
14156 static ffelexHandler
14157 ffestb_R9042_ (ffelexToken t)
14158 {
14159   ffelexHandler next;
14160   ffelexToken nt;
14161
14162   switch (ffelex_token_type (t))
14163     {
14164     case FFELEX_typeEQUALS:
14165       nt = ffesta_tokens[1];
14166       next = (ffelexHandler) ffestb_R9044_ (nt);
14167       ffelex_token_kill (nt);
14168       return (ffelexHandler) (*next) (t);
14169
14170     default:
14171       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14172                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9043_)))
14173         (ffesta_tokens[1]);
14174       ffelex_token_kill (ffesta_tokens[1]);
14175       return (ffelexHandler) (*next) (t);
14176     }
14177 }
14178
14179 /* ffestb_R9043_ -- "OPEN" OPEN_PAREN expr
14180
14181    (ffestb_R9043_)  // to expression handler
14182
14183    Handle COMMA or CLOSE_PAREN here.  */
14184
14185 static ffelexHandler
14186 ffestb_R9043_ (ffelexToken ft, ffebld expr, ffelexToken t)
14187 {
14188   switch (ffelex_token_type (t))
14189     {
14190     case FFELEX_typeCOMMA:
14191     case FFELEX_typeCLOSE_PAREN:
14192       if (expr == NULL)
14193         break;
14194       ffestp_file.open.open_spec[FFESTP_openixUNIT].kw_or_val_present
14195         = TRUE;
14196       ffestp_file.open.open_spec[FFESTP_openixUNIT].kw_present = FALSE;
14197       ffestp_file.open.open_spec[FFESTP_openixUNIT].value_present = TRUE;
14198       ffestp_file.open.open_spec[FFESTP_openixUNIT].value_is_label
14199         = FALSE;
14200       ffestp_file.open.open_spec[FFESTP_openixUNIT].value
14201         = ffelex_token_use (ft);
14202       ffestp_file.open.open_spec[FFESTP_openixUNIT].u.expr = expr;
14203       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14204         return (ffelexHandler) ffestb_R9044_;
14205       return (ffelexHandler) ffestb_R9049_;
14206
14207     default:
14208       break;
14209     }
14210
14211   ffestb_subr_kill_open_ ();
14212   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14213   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14214 }
14215
14216 /* ffestb_R9044_ -- "OPEN" OPEN_PAREN [external-file-unit COMMA]
14217
14218    return ffestb_R9044_;  // to lexer
14219
14220    Handle expr construct (not NAME=expr construct) here.  */
14221
14222 static ffelexHandler
14223 ffestb_R9044_ (ffelexToken t)
14224 {
14225   ffestrOpen kw;
14226
14227   ffestb_local_.open.label = FALSE;
14228
14229   switch (ffelex_token_type (t))
14230     {
14231     case FFELEX_typeNAME:
14232       kw = ffestr_open (t);
14233       switch (kw)
14234         {
14235         case FFESTR_openACCESS:
14236           ffestb_local_.open.ix = FFESTP_openixACCESS;
14237           ffestb_local_.open.left = FALSE;
14238           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14239           break;
14240
14241         case FFESTR_openACTION:
14242           ffestb_local_.open.ix = FFESTP_openixACTION;
14243           ffestb_local_.open.left = FALSE;
14244           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14245           break;
14246
14247         case FFESTR_openASSOCIATEVARIABLE:
14248           ffestb_local_.open.ix = FFESTP_openixASSOCIATEVARIABLE;
14249           ffestb_local_.open.left = TRUE;
14250           ffestb_local_.open.context = FFEEXPR_contextFILEASSOC;
14251           break;
14252
14253         case FFESTR_openBLANK:
14254           ffestb_local_.open.ix = FFESTP_openixBLANK;
14255           ffestb_local_.open.left = FALSE;
14256           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14257           break;
14258
14259         case FFESTR_openBLOCKSIZE:
14260           ffestb_local_.open.ix = FFESTP_openixBLOCKSIZE;
14261           ffestb_local_.open.left = FALSE;
14262           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14263           break;
14264
14265         case FFESTR_openBUFFERCOUNT:
14266           ffestb_local_.open.ix = FFESTP_openixBUFFERCOUNT;
14267           ffestb_local_.open.left = FALSE;
14268           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14269           break;
14270
14271         case FFESTR_openCARRIAGECONTROL:
14272           ffestb_local_.open.ix = FFESTP_openixCARRIAGECONTROL;
14273           ffestb_local_.open.left = FALSE;
14274           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14275           break;
14276
14277         case FFESTR_openDEFAULTFILE:
14278           ffestb_local_.open.ix = FFESTP_openixDEFAULTFILE;
14279           ffestb_local_.open.left = FALSE;
14280           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14281           break;
14282
14283         case FFESTR_openDELIM:
14284           ffestb_local_.open.ix = FFESTP_openixDELIM;
14285           ffestb_local_.open.left = FALSE;
14286           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14287           break;
14288
14289         case FFESTR_openDISP:
14290         case FFESTR_openDISPOSE:
14291           ffestb_local_.open.ix = FFESTP_openixDISPOSE;
14292           ffestb_local_.open.left = FALSE;
14293           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14294           break;
14295
14296         case FFESTR_openERR:
14297           ffestb_local_.open.ix = FFESTP_openixERR;
14298           ffestb_local_.open.label = TRUE;
14299           break;
14300
14301         case FFESTR_openEXTENDSIZE:
14302           ffestb_local_.open.ix = FFESTP_openixEXTENDSIZE;
14303           ffestb_local_.open.left = FALSE;
14304           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14305           break;
14306
14307         case FFESTR_openFILE:
14308         case FFESTR_openNAME:
14309           ffestb_local_.open.ix = FFESTP_openixFILE;
14310           ffestb_local_.open.left = FALSE;
14311           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14312           break;
14313
14314         case FFESTR_openFORM:
14315           ffestb_local_.open.ix = FFESTP_openixFORM;
14316           ffestb_local_.open.left = FALSE;
14317           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14318           break;
14319
14320         case FFESTR_openINITIALSIZE:
14321           ffestb_local_.open.ix = FFESTP_openixINITIALSIZE;
14322           ffestb_local_.open.left = FALSE;
14323           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14324           break;
14325
14326         case FFESTR_openIOSTAT:
14327           ffestb_local_.open.ix = FFESTP_openixIOSTAT;
14328           ffestb_local_.open.left = TRUE;
14329           ffestb_local_.open.context = FFEEXPR_contextFILEINT;
14330           break;
14331
14332 #if 0                           /* Haven't added support for expression
14333                                    context yet (though easy). */
14334         case FFESTR_openKEY:
14335           ffestb_local_.open.ix = FFESTP_openixKEY;
14336           ffestb_local_.open.left = FALSE;
14337           ffestb_local_.open.context = FFEEXPR_contextFILEKEY;
14338           break;
14339 #endif
14340
14341         case FFESTR_openMAXREC:
14342           ffestb_local_.open.ix = FFESTP_openixMAXREC;
14343           ffestb_local_.open.left = FALSE;
14344           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14345           break;
14346
14347         case FFESTR_openNOSPANBLOCKS:
14348           if (ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14349               .kw_or_val_present)
14350             goto bad;           /* :::::::::::::::::::: */
14351           ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14352             .kw_or_val_present = TRUE;
14353           ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14354             .kw_present = TRUE;
14355           ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14356             .value_present = FALSE;
14357           ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS].kw
14358             = ffelex_token_use (t);
14359           return (ffelexHandler) ffestb_R9048_;
14360
14361         case FFESTR_openORGANIZATION:
14362           ffestb_local_.open.ix = FFESTP_openixORGANIZATION;
14363           ffestb_local_.open.left = FALSE;
14364           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14365           break;
14366
14367         case FFESTR_openPAD:
14368           ffestb_local_.open.ix = FFESTP_openixPAD;
14369           ffestb_local_.open.left = FALSE;
14370           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14371           break;
14372
14373         case FFESTR_openPOSITION:
14374           ffestb_local_.open.ix = FFESTP_openixPOSITION;
14375           ffestb_local_.open.left = FALSE;
14376           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14377           break;
14378
14379         case FFESTR_openREADONLY:
14380           if (ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14381               .kw_or_val_present)
14382             goto bad;           /* :::::::::::::::::::: */
14383           ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14384             .kw_or_val_present = TRUE;
14385           ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14386             .kw_present = TRUE;
14387           ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14388             .value_present = FALSE;
14389           ffestp_file.open.open_spec[FFESTP_openixREADONLY].kw
14390             = ffelex_token_use (t);
14391           return (ffelexHandler) ffestb_R9048_;
14392
14393         case FFESTR_openRECL:
14394         case FFESTR_openRECORDSIZE:
14395           ffestb_local_.open.ix = FFESTP_openixRECL;
14396           ffestb_local_.open.left = FALSE;
14397           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14398           break;
14399
14400         case FFESTR_openRECORDTYPE:
14401           ffestb_local_.open.ix = FFESTP_openixRECORDTYPE;
14402           ffestb_local_.open.left = FALSE;
14403           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14404           break;
14405
14406         case FFESTR_openSHARED:
14407           if (ffestp_file.open.open_spec[FFESTP_openixSHARED]
14408               .kw_or_val_present)
14409             goto bad;           /* :::::::::::::::::::: */
14410           ffestp_file.open.open_spec[FFESTP_openixSHARED]
14411             .kw_or_val_present = TRUE;
14412           ffestp_file.open.open_spec[FFESTP_openixSHARED]
14413             .kw_present = TRUE;
14414           ffestp_file.open.open_spec[FFESTP_openixSHARED]
14415             .value_present = FALSE;
14416           ffestp_file.open.open_spec[FFESTP_openixSHARED].kw
14417             = ffelex_token_use (t);
14418           return (ffelexHandler) ffestb_R9048_;
14419
14420         case FFESTR_openSTATUS:
14421         case FFESTR_openTYPE:
14422           ffestb_local_.open.ix = FFESTP_openixSTATUS;
14423           ffestb_local_.open.left = FALSE;
14424           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14425           break;
14426
14427         case FFESTR_openUNIT:
14428           ffestb_local_.open.ix = FFESTP_openixUNIT;
14429           ffestb_local_.open.left = FALSE;
14430           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14431           break;
14432
14433         case FFESTR_openUSEROPEN:
14434           ffestb_local_.open.ix = FFESTP_openixUSEROPEN;
14435           ffestb_local_.open.left = TRUE;
14436           ffestb_local_.open.context = FFEEXPR_contextFILEEXTFUNC;
14437           break;
14438
14439         default:
14440           goto bad;             /* :::::::::::::::::::: */
14441         }
14442       if (ffestp_file.open.open_spec[ffestb_local_.open.ix]
14443           .kw_or_val_present)
14444         break;                  /* Can't specify a keyword twice! */
14445       ffestp_file.open.open_spec[ffestb_local_.open.ix]
14446         .kw_or_val_present = TRUE;
14447       ffestp_file.open.open_spec[ffestb_local_.open.ix]
14448         .kw_present = TRUE;
14449       ffestp_file.open.open_spec[ffestb_local_.open.ix]
14450         .value_present = FALSE;
14451       ffestp_file.open.open_spec[ffestb_local_.open.ix].value_is_label
14452         = ffestb_local_.open.label;
14453       ffestp_file.open.open_spec[ffestb_local_.open.ix].kw
14454         = ffelex_token_use (t);
14455       return (ffelexHandler) ffestb_R9045_;
14456
14457     default:
14458       break;
14459     }
14460
14461 bad:                            /* :::::::::::::::::::: */
14462   ffestb_subr_kill_open_ ();
14463   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14464   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14465 }
14466
14467 /* ffestb_R9045_ -- "OPEN" OPEN_PAREN [external-file-unit COMMA] NAME
14468
14469    return ffestb_R9045_;  // to lexer
14470
14471    Make sure EQUALS here, send next token to expression handler.  */
14472
14473 static ffelexHandler
14474 ffestb_R9045_ (ffelexToken t)
14475 {
14476   switch (ffelex_token_type (t))
14477     {
14478     case FFELEX_typeEQUALS:
14479       ffesta_confirmed ();
14480       if (ffestb_local_.open.label)
14481         return (ffelexHandler) ffestb_R9047_;
14482       if (ffestb_local_.open.left)
14483         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
14484                                             ffestb_local_.open.context,
14485                                             (ffeexprCallback) ffestb_R9046_);
14486       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14487                                           ffestb_local_.open.context,
14488                                           (ffeexprCallback) ffestb_R9046_);
14489
14490     default:
14491       break;
14492     }
14493
14494   ffestb_subr_kill_open_ ();
14495   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14496   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14497 }
14498
14499 /* ffestb_R9046_ -- "OPEN" OPEN_PAREN ... NAME EQUALS expr
14500
14501    (ffestb_R9046_)  // to expression handler
14502
14503    Handle COMMA or CLOSE_PAREN here.  */
14504
14505 static ffelexHandler
14506 ffestb_R9046_ (ffelexToken ft, ffebld expr, ffelexToken t)
14507 {
14508   switch (ffelex_token_type (t))
14509     {
14510     case FFELEX_typeCOMMA:
14511     case FFELEX_typeCLOSE_PAREN:
14512       if (expr == NULL)
14513         break;
14514       ffestp_file.open.open_spec[ffestb_local_.open.ix].value_present
14515         = TRUE;
14516       ffestp_file.open.open_spec[ffestb_local_.open.ix].value
14517         = ffelex_token_use (ft);
14518       ffestp_file.open.open_spec[ffestb_local_.open.ix].u.expr = expr;
14519       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14520         return (ffelexHandler) ffestb_R9044_;
14521       return (ffelexHandler) ffestb_R9049_;
14522
14523     default:
14524       break;
14525     }
14526
14527   ffestb_subr_kill_open_ ();
14528   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14529   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14530 }
14531
14532 /* ffestb_R9047_ -- "OPEN" OPEN_PAREN ... NAME EQUALS
14533
14534    return ffestb_R9047_;  // to lexer
14535
14536    Handle NUMBER for label here.  */
14537
14538 static ffelexHandler
14539 ffestb_R9047_ (ffelexToken t)
14540 {
14541   switch (ffelex_token_type (t))
14542     {
14543     case FFELEX_typeNUMBER:
14544       ffestp_file.open.open_spec[ffestb_local_.open.ix].value_present
14545         = TRUE;
14546       ffestp_file.open.open_spec[ffestb_local_.open.ix].value
14547         = ffelex_token_use (t);
14548       return (ffelexHandler) ffestb_R9048_;
14549
14550     default:
14551       break;
14552     }
14553
14554   ffestb_subr_kill_open_ ();
14555   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14556   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14557 }
14558
14559 /* ffestb_R9048_ -- "OPEN" OPEN_PAREN ... NAME EQUALS NUMBER
14560
14561    return ffestb_R9048_;  // to lexer
14562
14563    Handle COMMA or CLOSE_PAREN here.  */
14564
14565 static ffelexHandler
14566 ffestb_R9048_ (ffelexToken t)
14567 {
14568   switch (ffelex_token_type (t))
14569     {
14570     case FFELEX_typeCOMMA:
14571       return (ffelexHandler) ffestb_R9044_;
14572
14573     case FFELEX_typeCLOSE_PAREN:
14574       return (ffelexHandler) ffestb_R9049_;
14575
14576     default:
14577       break;
14578     }
14579
14580   ffestb_subr_kill_open_ ();
14581   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14582   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14583 }
14584
14585 /* ffestb_R9049_ -- "OPEN" OPEN_PAREN ... CLOSE_PAREN
14586
14587    return ffestb_R9049_;  // to lexer
14588
14589    Handle EOS or SEMICOLON here.  */
14590
14591 static ffelexHandler
14592 ffestb_R9049_ (ffelexToken t)
14593 {
14594   switch (ffelex_token_type (t))
14595     {
14596     case FFELEX_typeEOS:
14597     case FFELEX_typeSEMICOLON:
14598       ffesta_confirmed ();
14599       if (!ffesta_is_inhibited ())
14600         ffestc_R904 ();
14601       ffestb_subr_kill_open_ ();
14602       return (ffelexHandler) ffesta_zero (t);
14603
14604     default:
14605       break;
14606     }
14607
14608   ffestb_subr_kill_open_ ();
14609   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14610   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14611 }
14612
14613 /* ffestb_R907 -- Parse a CLOSE statement
14614
14615    return ffestb_R907;  // to lexer
14616
14617    Make sure the statement has a valid form for a CLOSE statement.
14618    If it does, implement the statement.  */
14619
14620 ffelexHandler
14621 ffestb_R907 (ffelexToken t)
14622 {
14623   ffestpCloseIx ix;
14624
14625   switch (ffelex_token_type (ffesta_tokens[0]))
14626     {
14627     case FFELEX_typeNAME:
14628       if (ffesta_first_kw != FFESTR_firstCLOSE)
14629         goto bad_0;             /* :::::::::::::::::::: */
14630       break;
14631
14632     case FFELEX_typeNAMES:
14633       if (ffesta_first_kw != FFESTR_firstCLOSE)
14634         goto bad_0;             /* :::::::::::::::::::: */
14635       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCLOSE)
14636         goto bad_0;             /* :::::::::::::::::::: */
14637       break;
14638
14639     default:
14640       goto bad_0;               /* :::::::::::::::::::: */
14641     }
14642
14643   switch (ffelex_token_type (t))
14644     {
14645     case FFELEX_typeOPEN_PAREN:
14646       break;
14647
14648     case FFELEX_typeEOS:
14649     case FFELEX_typeSEMICOLON:
14650     case FFELEX_typeCOMMA:
14651     case FFELEX_typeCOLONCOLON:
14652       ffesta_confirmed ();      /* Error, but clearly intended. */
14653       goto bad_1;               /* :::::::::::::::::::: */
14654
14655     default:
14656       goto bad_1;               /* :::::::::::::::::::: */
14657     }
14658
14659   for (ix = 0; ix < FFESTP_closeix; ++ix)
14660     ffestp_file.close.close_spec[ix].kw_or_val_present = FALSE;
14661
14662   return (ffelexHandler) ffestb_R9071_;
14663
14664 bad_0:                          /* :::::::::::::::::::: */
14665   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", ffesta_tokens[0]);
14666   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14667
14668 bad_1:                          /* :::::::::::::::::::: */
14669   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14670   return (ffelexHandler) ffelex_swallow_tokens (t,
14671                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
14672 }
14673
14674 /* ffestb_R9071_ -- "CLOSE" OPEN_PAREN
14675
14676    return ffestb_R9071_;  // to lexer
14677
14678    Handle expr construct (not NAME=expr construct) here.  */
14679
14680 static ffelexHandler
14681 ffestb_R9071_ (ffelexToken t)
14682 {
14683   switch (ffelex_token_type (t))
14684     {
14685     case FFELEX_typeNAME:
14686       ffesta_tokens[1] = ffelex_token_use (t);
14687       return (ffelexHandler) ffestb_R9072_;
14688
14689     default:
14690       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14691                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9073_)))
14692         (t);
14693     }
14694 }
14695
14696 /* ffestb_R9072_ -- "CLOSE" OPEN_PAREN NAME
14697
14698    return ffestb_R9072_;  // to lexer
14699
14700    If EQUALS here, go to states that handle it.  Else, send NAME and this
14701    token thru expression handler.  */
14702
14703 static ffelexHandler
14704 ffestb_R9072_ (ffelexToken t)
14705 {
14706   ffelexHandler next;
14707   ffelexToken nt;
14708
14709   switch (ffelex_token_type (t))
14710     {
14711     case FFELEX_typeEQUALS:
14712       nt = ffesta_tokens[1];
14713       next = (ffelexHandler) ffestb_R9074_ (nt);
14714       ffelex_token_kill (nt);
14715       return (ffelexHandler) (*next) (t);
14716
14717     default:
14718       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14719                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9073_)))
14720         (ffesta_tokens[1]);
14721       ffelex_token_kill (ffesta_tokens[1]);
14722       return (ffelexHandler) (*next) (t);
14723     }
14724 }
14725
14726 /* ffestb_R9073_ -- "CLOSE" OPEN_PAREN expr
14727
14728    (ffestb_R9073_)  // to expression handler
14729
14730    Handle COMMA or CLOSE_PAREN here.  */
14731
14732 static ffelexHandler
14733 ffestb_R9073_ (ffelexToken ft, ffebld expr, ffelexToken t)
14734 {
14735   switch (ffelex_token_type (t))
14736     {
14737     case FFELEX_typeCOMMA:
14738     case FFELEX_typeCLOSE_PAREN:
14739       if (expr == NULL)
14740         break;
14741       ffestp_file.close.close_spec[FFESTP_closeixUNIT].kw_or_val_present
14742         = TRUE;
14743       ffestp_file.close.close_spec[FFESTP_closeixUNIT].kw_present = FALSE;
14744       ffestp_file.close.close_spec[FFESTP_closeixUNIT].value_present = TRUE;
14745       ffestp_file.close.close_spec[FFESTP_closeixUNIT].value_is_label
14746         = FALSE;
14747       ffestp_file.close.close_spec[FFESTP_closeixUNIT].value
14748         = ffelex_token_use (ft);
14749       ffestp_file.close.close_spec[FFESTP_closeixUNIT].u.expr = expr;
14750       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14751         return (ffelexHandler) ffestb_R9074_;
14752       return (ffelexHandler) ffestb_R9079_;
14753
14754     default:
14755       break;
14756     }
14757
14758   ffestb_subr_kill_close_ ();
14759   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14760   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14761 }
14762
14763 /* ffestb_R9074_ -- "CLOSE" OPEN_PAREN [external-file-unit COMMA]
14764
14765    return ffestb_R9074_;  // to lexer
14766
14767    Handle expr construct (not NAME=expr construct) here.  */
14768
14769 static ffelexHandler
14770 ffestb_R9074_ (ffelexToken t)
14771 {
14772   ffestrGenio kw;
14773
14774   ffestb_local_.close.label = FALSE;
14775
14776   switch (ffelex_token_type (t))
14777     {
14778     case FFELEX_typeNAME:
14779       kw = ffestr_genio (t);
14780       switch (kw)
14781         {
14782         case FFESTR_genioERR:
14783           ffestb_local_.close.ix = FFESTP_closeixERR;
14784           ffestb_local_.close.label = TRUE;
14785           break;
14786
14787         case FFESTR_genioIOSTAT:
14788           ffestb_local_.close.ix = FFESTP_closeixIOSTAT;
14789           ffestb_local_.close.left = TRUE;
14790           ffestb_local_.close.context = FFEEXPR_contextFILEINT;
14791           break;
14792
14793         case FFESTR_genioSTATUS:
14794         case FFESTR_genioDISP:
14795         case FFESTR_genioDISPOSE:
14796           ffestb_local_.close.ix = FFESTP_closeixSTATUS;
14797           ffestb_local_.close.left = FALSE;
14798           ffestb_local_.close.context = FFEEXPR_contextFILEDFCHAR;
14799           break;
14800
14801         case FFESTR_genioUNIT:
14802           ffestb_local_.close.ix = FFESTP_closeixUNIT;
14803           ffestb_local_.close.left = FALSE;
14804           ffestb_local_.close.context = FFEEXPR_contextFILENUM;
14805           break;
14806
14807         default:
14808           goto bad;             /* :::::::::::::::::::: */
14809         }
14810       if (ffestp_file.close.close_spec[ffestb_local_.close.ix]
14811           .kw_or_val_present)
14812         break;                  /* Can't specify a keyword twice! */
14813       ffestp_file.close.close_spec[ffestb_local_.close.ix]
14814         .kw_or_val_present = TRUE;
14815       ffestp_file.close.close_spec[ffestb_local_.close.ix]
14816         .kw_present = TRUE;
14817       ffestp_file.close.close_spec[ffestb_local_.close.ix]
14818         .value_present = FALSE;
14819       ffestp_file.close.close_spec[ffestb_local_.close.ix].value_is_label
14820         = ffestb_local_.close.label;
14821       ffestp_file.close.close_spec[ffestb_local_.close.ix].kw
14822         = ffelex_token_use (t);
14823       return (ffelexHandler) ffestb_R9075_;
14824
14825     default:
14826       break;
14827     }
14828
14829 bad:                            /* :::::::::::::::::::: */
14830   ffestb_subr_kill_close_ ();
14831   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14832   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14833 }
14834
14835 /* ffestb_R9075_ -- "CLOSE" OPEN_PAREN [external-file-unit COMMA] NAME
14836
14837    return ffestb_R9075_;  // to lexer
14838
14839    Make sure EQUALS here, send next token to expression handler.  */
14840
14841 static ffelexHandler
14842 ffestb_R9075_ (ffelexToken t)
14843 {
14844   switch (ffelex_token_type (t))
14845     {
14846     case FFELEX_typeEQUALS:
14847       ffesta_confirmed ();
14848       if (ffestb_local_.close.label)
14849         return (ffelexHandler) ffestb_R9077_;
14850       if (ffestb_local_.close.left)
14851         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
14852                                             ffestb_local_.close.context,
14853                                             (ffeexprCallback) ffestb_R9076_);
14854       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14855                                           ffestb_local_.close.context,
14856                                           (ffeexprCallback) ffestb_R9076_);
14857
14858     default:
14859       break;
14860     }
14861
14862   ffestb_subr_kill_close_ ();
14863   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14864   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14865 }
14866
14867 /* ffestb_R9076_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS expr
14868
14869    (ffestb_R9076_)  // to expression handler
14870
14871    Handle COMMA or CLOSE_PAREN here.  */
14872
14873 static ffelexHandler
14874 ffestb_R9076_ (ffelexToken ft, ffebld expr, ffelexToken t)
14875 {
14876   switch (ffelex_token_type (t))
14877     {
14878     case FFELEX_typeCOMMA:
14879     case FFELEX_typeCLOSE_PAREN:
14880       if (expr == NULL)
14881         break;
14882       ffestp_file.close.close_spec[ffestb_local_.close.ix].value_present
14883         = TRUE;
14884       ffestp_file.close.close_spec[ffestb_local_.close.ix].value
14885         = ffelex_token_use (ft);
14886       ffestp_file.close.close_spec[ffestb_local_.close.ix].u.expr = expr;
14887       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14888         return (ffelexHandler) ffestb_R9074_;
14889       return (ffelexHandler) ffestb_R9079_;
14890
14891     default:
14892       break;
14893     }
14894
14895   ffestb_subr_kill_close_ ();
14896   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14897   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14898 }
14899
14900 /* ffestb_R9077_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS
14901
14902    return ffestb_R9077_;  // to lexer
14903
14904    Handle NUMBER for label here.  */
14905
14906 static ffelexHandler
14907 ffestb_R9077_ (ffelexToken t)
14908 {
14909   switch (ffelex_token_type (t))
14910     {
14911     case FFELEX_typeNUMBER:
14912       ffestp_file.close.close_spec[ffestb_local_.close.ix].value_present
14913         = TRUE;
14914       ffestp_file.close.close_spec[ffestb_local_.close.ix].value
14915         = ffelex_token_use (t);
14916       return (ffelexHandler) ffestb_R9078_;
14917
14918     default:
14919       break;
14920     }
14921
14922   ffestb_subr_kill_close_ ();
14923   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14924   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14925 }
14926
14927 /* ffestb_R9078_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS NUMBER
14928
14929    return ffestb_R9078_;  // to lexer
14930
14931    Handle COMMA or CLOSE_PAREN here.  */
14932
14933 static ffelexHandler
14934 ffestb_R9078_ (ffelexToken t)
14935 {
14936   switch (ffelex_token_type (t))
14937     {
14938     case FFELEX_typeCOMMA:
14939       return (ffelexHandler) ffestb_R9074_;
14940
14941     case FFELEX_typeCLOSE_PAREN:
14942       return (ffelexHandler) ffestb_R9079_;
14943
14944     default:
14945       break;
14946     }
14947
14948   ffestb_subr_kill_close_ ();
14949   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14950   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14951 }
14952
14953 /* ffestb_R9079_ -- "CLOSE" OPEN_PAREN ... CLOSE_PAREN
14954
14955    return ffestb_R9079_;  // to lexer
14956
14957    Handle EOS or SEMICOLON here.  */
14958
14959 static ffelexHandler
14960 ffestb_R9079_ (ffelexToken t)
14961 {
14962   switch (ffelex_token_type (t))
14963     {
14964     case FFELEX_typeEOS:
14965     case FFELEX_typeSEMICOLON:
14966       ffesta_confirmed ();
14967       if (!ffesta_is_inhibited ())
14968         ffestc_R907 ();
14969       ffestb_subr_kill_close_ ();
14970       return (ffelexHandler) ffesta_zero (t);
14971
14972     default:
14973       break;
14974     }
14975
14976   ffestb_subr_kill_close_ ();
14977   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14978   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14979 }
14980
14981 /* ffestb_R909 -- Parse the READ statement
14982
14983    return ffestb_R909;  // to lexer
14984
14985    Make sure the statement has a valid form for the READ
14986    statement.  If it does, implement the statement.  */
14987
14988 ffelexHandler
14989 ffestb_R909 (ffelexToken t)
14990 {
14991   ffelexHandler next;
14992   ffestpReadIx ix;
14993
14994   switch (ffelex_token_type (ffesta_tokens[0]))
14995     {
14996     case FFELEX_typeNAME:
14997       if (ffesta_first_kw != FFESTR_firstREAD)
14998         goto bad_0;             /* :::::::::::::::::::: */
14999       switch (ffelex_token_type (t))
15000         {
15001         case FFELEX_typeCOMMA:
15002         case FFELEX_typeCOLONCOLON:
15003         case FFELEX_typeEOS:
15004         case FFELEX_typeSEMICOLON:
15005           ffesta_confirmed ();  /* Error, but clearly intended. */
15006           goto bad_1;           /* :::::::::::::::::::: */
15007
15008         case FFELEX_typeEQUALS:
15009         case FFELEX_typePOINTS:
15010         case FFELEX_typeCOLON:
15011           goto bad_1;           /* :::::::::::::::::::: */
15012
15013         case FFELEX_typeNAME:
15014         case FFELEX_typeNUMBER:
15015           ffesta_confirmed ();
15016           break;
15017
15018         case FFELEX_typeOPEN_PAREN:
15019           for (ix = 0; ix < FFESTP_readix; ++ix)
15020             ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15021           ffesta_tokens[1] = ffelex_token_use (t);
15022           return (ffelexHandler) ffestb_R9092_;
15023
15024         default:
15025           break;
15026         }
15027
15028       for (ix = 0; ix < FFESTP_readix; ++ix)
15029         ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15030       return (ffelexHandler) (*((ffelexHandler)
15031                                 ffeexpr_rhs (ffesta_output_pool,
15032             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9091_)))
15033         (t);
15034
15035     case FFELEX_typeNAMES:
15036       if (ffesta_first_kw != FFESTR_firstREAD)
15037         goto bad_0;             /* :::::::::::::::::::: */
15038       switch (ffelex_token_type (t))
15039         {
15040         case FFELEX_typeEOS:
15041         case FFELEX_typeSEMICOLON:
15042         case FFELEX_typeCOMMA:
15043           ffesta_confirmed ();
15044           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREAD)
15045             break;
15046           goto bad_1;           /* :::::::::::::::::::: */
15047
15048         case FFELEX_typeCOLONCOLON:
15049           ffesta_confirmed ();  /* Error, but clearly intended. */
15050           goto bad_1;           /* :::::::::::::::::::: */
15051
15052         case FFELEX_typeEQUALS:
15053         case FFELEX_typePOINTS:
15054         case FFELEX_typeCOLON:
15055           goto bad_1;           /* :::::::::::::::::::: */
15056
15057         case FFELEX_typeOPEN_PAREN:
15058           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREAD)
15059             break;
15060
15061           for (ix = 0; ix < FFESTP_readix; ++ix)
15062             ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15063           ffesta_tokens[1] = ffelex_token_use (t);
15064           return (ffelexHandler) ffestb_R9092_;
15065
15066         default:
15067           break;
15068         }
15069       for (ix = 0; ix < FFESTP_readix; ++ix)
15070         ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15071       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15072              FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9091_);
15073       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
15074                                                    FFESTR_firstlREAD);
15075       if (next == NULL)
15076         return (ffelexHandler) ffelex_swallow_tokens (t,
15077                                                (ffelexHandler) ffesta_zero);
15078       return (ffelexHandler) (*next) (t);
15079
15080     default:
15081       goto bad_0;               /* :::::::::::::::::::: */
15082     }
15083
15084 bad_0:                          /* :::::::::::::::::::: */
15085   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", ffesta_tokens[0]);
15086   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15087
15088 bad_1:                          /* :::::::::::::::::::: */
15089   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15090   return (ffelexHandler) ffelex_swallow_tokens (t,
15091                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
15092 }
15093
15094 /* ffestb_R9091_ -- "READ" expr
15095
15096    (ffestb_R9091_)  // to expression handler
15097
15098    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
15099
15100 static ffelexHandler
15101 ffestb_R9091_ (ffelexToken ft, ffebld expr, ffelexToken t)
15102 {
15103   switch (ffelex_token_type (t))
15104     {
15105     case FFELEX_typeEOS:
15106     case FFELEX_typeSEMICOLON:
15107     case FFELEX_typeCOMMA:
15108       ffesta_confirmed ();
15109       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
15110         = TRUE;
15111       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
15112       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
15113       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
15114         = (expr == NULL);
15115       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
15116         = ffelex_token_use (ft);
15117       ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
15118       if (!ffesta_is_inhibited ())
15119         ffestc_R909_start (TRUE);
15120       ffestb_subr_kill_read_ ();
15121       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15122         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
15123                                             ffestc_context_iolist (),
15124                                           (ffeexprCallback) ffestb_R90915_);
15125       if (!ffesta_is_inhibited ())
15126         ffestc_R909_finish ();
15127       return (ffelexHandler) ffesta_zero (t);
15128
15129     default:
15130       break;
15131     }
15132
15133   ffestb_subr_kill_read_ ();
15134   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15135   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15136 }
15137
15138 /* ffestb_R9092_ -- "READ" OPEN_PAREN
15139
15140    return ffestb_R9092_;  // to lexer
15141
15142    Handle expr construct (not NAME=expr construct) here.  */
15143
15144 static ffelexHandler
15145 ffestb_R9092_ (ffelexToken t)
15146 {
15147   ffelexToken nt;
15148   ffelexHandler next;
15149
15150   switch (ffelex_token_type (t))
15151     {
15152     case FFELEX_typeNAME:
15153       ffesta_tokens[2] = ffelex_token_use (t);
15154       return (ffelexHandler) ffestb_R9093_;
15155
15156     default:
15157       nt = ffesta_tokens[1];
15158       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15159             FFEEXPR_contextFILEUNITAMBIG, (ffeexprCallback) ffestb_R9094_)))
15160         (nt);
15161       ffelex_token_kill (nt);
15162       return (ffelexHandler) (*next) (t);
15163     }
15164 }
15165
15166 /* ffestb_R9093_ -- "READ" OPEN_PAREN NAME
15167
15168    return ffestb_R9093_;  // to lexer
15169
15170    If EQUALS here, go to states that handle it.  Else, send NAME and this
15171    token thru expression handler.  */
15172
15173 static ffelexHandler
15174 ffestb_R9093_ (ffelexToken t)
15175 {
15176   ffelexHandler next;
15177   ffelexToken nt;
15178   ffelexToken ot;
15179
15180   switch (ffelex_token_type (t))
15181     {
15182     case FFELEX_typeEQUALS:
15183       ffelex_token_kill (ffesta_tokens[1]);
15184       nt = ffesta_tokens[2];
15185       next = (ffelexHandler) ffestb_R9098_ (nt);
15186       ffelex_token_kill (nt);
15187       return (ffelexHandler) (*next) (t);
15188
15189     default:
15190       nt = ffesta_tokens[1];
15191       ot = ffesta_tokens[2];
15192       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15193             FFEEXPR_contextFILEUNITAMBIG, (ffeexprCallback) ffestb_R9094_)))
15194         (nt);
15195       ffelex_token_kill (nt);
15196       next = (ffelexHandler) (*next) (ot);
15197       ffelex_token_kill (ot);
15198       return (ffelexHandler) (*next) (t);
15199     }
15200 }
15201
15202 /* ffestb_R9094_ -- "READ" OPEN_PAREN expr [CLOSE_PAREN]
15203
15204    (ffestb_R9094_)  // to expression handler
15205
15206    Handle COMMA or EOS/SEMICOLON here.
15207
15208    15-Feb-91  JCB  1.1
15209       Use new ffeexpr mechanism whereby the expr is encased in an opITEM if
15210       ffeexpr decided it was an item in a control list (hence a unit
15211       specifier), or a format specifier otherwise.  */
15212
15213 static ffelexHandler
15214 ffestb_R9094_ (ffelexToken ft, ffebld expr, ffelexToken t)
15215 {
15216   if (expr == NULL)
15217     goto bad;                   /* :::::::::::::::::::: */
15218
15219   if (ffebld_op (expr) != FFEBLD_opITEM)
15220     {
15221       switch (ffelex_token_type (t))
15222         {
15223         case FFELEX_typeCOMMA:
15224         case FFELEX_typeEOS:
15225         case FFELEX_typeSEMICOLON:
15226           ffesta_confirmed ();
15227           ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
15228             = TRUE;
15229           ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
15230           ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
15231           ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
15232             = FALSE;
15233           ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
15234             = ffelex_token_use (ft);
15235           ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
15236           if (!ffesta_is_inhibited ())
15237             ffestc_R909_start (TRUE);
15238           ffestb_subr_kill_read_ ();
15239           if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15240             return (ffelexHandler)
15241               ffeexpr_lhs (ffesta_output_pool,
15242                            ffestc_context_iolist (),
15243                            (ffeexprCallback) ffestb_R90915_);
15244           if (!ffesta_is_inhibited ())
15245             ffestc_R909_finish ();
15246           return (ffelexHandler) ffesta_zero (t);
15247
15248         default:
15249           goto bad;             /* :::::::::::::::::::: */
15250         }
15251     }
15252
15253   expr = ffebld_head (expr);
15254
15255   if (expr == NULL)
15256     goto bad;                   /* :::::::::::::::::::: */
15257
15258   switch (ffelex_token_type (t))
15259     {
15260     case FFELEX_typeCOMMA:
15261     case FFELEX_typeCLOSE_PAREN:
15262       ffestp_file.read.read_spec[FFESTP_readixUNIT].kw_or_val_present
15263         = TRUE;
15264       ffestp_file.read.read_spec[FFESTP_readixUNIT].kw_present = FALSE;
15265       ffestp_file.read.read_spec[FFESTP_readixUNIT].value_present = TRUE;
15266       ffestp_file.read.read_spec[FFESTP_readixUNIT].value_is_label
15267         = FALSE;
15268       ffestp_file.read.read_spec[FFESTP_readixUNIT].value
15269         = ffelex_token_use (ft);
15270       ffestp_file.read.read_spec[FFESTP_readixUNIT].u.expr = expr;
15271       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15272         return (ffelexHandler) ffestb_R9095_;
15273       return (ffelexHandler) ffestb_R90913_;
15274
15275     default:
15276       break;
15277     }
15278
15279 bad:                            /* :::::::::::::::::::: */
15280   ffestb_subr_kill_read_ ();
15281   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15282   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15283 }
15284
15285 /* ffestb_R9095_ -- "READ" OPEN_PAREN expr COMMA
15286
15287    return ffestb_R9095_;  // to lexer
15288
15289    Handle expr construct (not NAME=expr construct) here.  */
15290
15291 static ffelexHandler
15292 ffestb_R9095_ (ffelexToken t)
15293 {
15294   switch (ffelex_token_type (t))
15295     {
15296     case FFELEX_typeNAME:
15297       ffesta_tokens[1] = ffelex_token_use (t);
15298       return (ffelexHandler) ffestb_R9096_;
15299
15300     default:
15301       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15302             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9097_)))
15303         (t);
15304     }
15305 }
15306
15307 /* ffestb_R9096_ -- "READ" OPEN_PAREN expr COMMA NAME
15308
15309    return ffestb_R9096_;  // to lexer
15310
15311    If EQUALS here, go to states that handle it.  Else, send NAME and this
15312    token thru expression handler.  */
15313
15314 static ffelexHandler
15315 ffestb_R9096_ (ffelexToken t)
15316 {
15317   ffelexHandler next;
15318   ffelexToken nt;
15319
15320   switch (ffelex_token_type (t))
15321     {
15322     case FFELEX_typeEQUALS:
15323       nt = ffesta_tokens[1];
15324       next = (ffelexHandler) ffestb_R9098_ (nt);
15325       ffelex_token_kill (nt);
15326       return (ffelexHandler) (*next) (t);
15327
15328     default:
15329       nt = ffesta_tokens[1];
15330       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15331             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9097_)))
15332         (nt);
15333       ffelex_token_kill (nt);
15334       return (ffelexHandler) (*next) (t);
15335     }
15336 }
15337
15338 /* ffestb_R9097_ -- "READ" OPEN_PAREN expr COMMA expr
15339
15340    (ffestb_R9097_)  // to expression handler
15341
15342    Handle COMMA or CLOSE_PAREN here.  */
15343
15344 static ffelexHandler
15345 ffestb_R9097_ (ffelexToken ft, ffebld expr, ffelexToken t)
15346 {
15347   switch (ffelex_token_type (t))
15348     {
15349     case FFELEX_typeCOMMA:
15350     case FFELEX_typeCLOSE_PAREN:
15351       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
15352         = TRUE;
15353       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
15354       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
15355       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
15356         = (expr == NULL);
15357       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
15358         = ffelex_token_use (ft);
15359       ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
15360       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15361         return (ffelexHandler) ffestb_R9098_;
15362       return (ffelexHandler) ffestb_R90913_;
15363
15364     default:
15365       break;
15366     }
15367
15368   ffestb_subr_kill_read_ ();
15369   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15370   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15371 }
15372
15373 /* ffestb_R9098_ -- "READ" OPEN_PAREN [external-file-unit COMMA [format
15374                    COMMA]]
15375
15376    return ffestb_R9098_;  // to lexer
15377
15378    Handle expr construct (not NAME=expr construct) here.  */
15379
15380 static ffelexHandler
15381 ffestb_R9098_ (ffelexToken t)
15382 {
15383   ffestrGenio kw;
15384
15385   ffestb_local_.read.label = FALSE;
15386
15387   switch (ffelex_token_type (t))
15388     {
15389     case FFELEX_typeNAME:
15390       kw = ffestr_genio (t);
15391       switch (kw)
15392         {
15393         case FFESTR_genioADVANCE:
15394           ffestb_local_.read.ix = FFESTP_readixADVANCE;
15395           ffestb_local_.read.left = FALSE;
15396           ffestb_local_.read.context = FFEEXPR_contextFILEDFCHAR;
15397           break;
15398
15399         case FFESTR_genioEOR:
15400           ffestb_local_.read.ix = FFESTP_readixEOR;
15401           ffestb_local_.read.label = TRUE;
15402           break;
15403
15404         case FFESTR_genioERR:
15405           ffestb_local_.read.ix = FFESTP_readixERR;
15406           ffestb_local_.read.label = TRUE;
15407           break;
15408
15409         case FFESTR_genioEND:
15410           ffestb_local_.read.ix = FFESTP_readixEND;
15411           ffestb_local_.read.label = TRUE;
15412           break;
15413
15414         case FFESTR_genioFMT:
15415           ffestb_local_.read.ix = FFESTP_readixFORMAT;
15416           ffestb_local_.read.left = FALSE;
15417           ffestb_local_.read.context = FFEEXPR_contextFILEFORMAT;
15418           break;
15419
15420         case FFESTR_genioIOSTAT:
15421           ffestb_local_.read.ix = FFESTP_readixIOSTAT;
15422           ffestb_local_.read.left = TRUE;
15423           ffestb_local_.read.context = FFEEXPR_contextFILEINT;
15424           break;
15425
15426         case FFESTR_genioKEY:
15427         case FFESTR_genioKEYEQ:
15428           ffestb_local_.read.ix = FFESTP_readixKEYEQ;
15429           ffestb_local_.read.left = FALSE;
15430           ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
15431           break;
15432
15433         case FFESTR_genioKEYGE:
15434           ffestb_local_.read.ix = FFESTP_readixKEYGE;
15435           ffestb_local_.read.left = FALSE;
15436           ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
15437           break;
15438
15439         case FFESTR_genioKEYGT:
15440           ffestb_local_.read.ix = FFESTP_readixKEYGT;
15441           ffestb_local_.read.left = FALSE;
15442           ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
15443           break;
15444
15445         case FFESTR_genioKEYID:
15446           ffestb_local_.read.ix = FFESTP_readixKEYID;
15447           ffestb_local_.read.left = FALSE;
15448           ffestb_local_.read.context = FFEEXPR_contextFILENUM;
15449           break;
15450
15451         case FFESTR_genioNML:
15452           ffestb_local_.read.ix = FFESTP_readixFORMAT;
15453           ffestb_local_.read.left = TRUE;
15454           ffestb_local_.read.context = FFEEXPR_contextFILENAMELIST;
15455           break;
15456
15457         case FFESTR_genioNULLS:
15458           ffestb_local_.read.ix = FFESTP_readixNULLS;
15459           ffestb_local_.read.left = TRUE;
15460           ffestb_local_.read.context = FFEEXPR_contextFILEINT;
15461           break;
15462
15463         case FFESTR_genioREC:
15464           ffestb_local_.read.ix = FFESTP_readixREC;
15465           ffestb_local_.read.left = FALSE;
15466           ffestb_local_.read.context = FFEEXPR_contextFILENUM;
15467           break;
15468
15469         case FFESTR_genioSIZE:
15470           ffestb_local_.read.ix = FFESTP_readixSIZE;
15471           ffestb_local_.read.left = TRUE;
15472           ffestb_local_.read.context = FFEEXPR_contextFILEINT;
15473           break;
15474
15475         case FFESTR_genioUNIT:
15476           ffestb_local_.read.ix = FFESTP_readixUNIT;
15477           ffestb_local_.read.left = FALSE;
15478           ffestb_local_.read.context = FFEEXPR_contextFILEUNIT;
15479           break;
15480
15481         default:
15482           goto bad;             /* :::::::::::::::::::: */
15483         }
15484       if (ffestp_file.read.read_spec[ffestb_local_.read.ix]
15485           .kw_or_val_present)
15486         break;                  /* Can't specify a keyword twice! */
15487       ffestp_file.read.read_spec[ffestb_local_.read.ix]
15488         .kw_or_val_present = TRUE;
15489       ffestp_file.read.read_spec[ffestb_local_.read.ix]
15490         .kw_present = TRUE;
15491       ffestp_file.read.read_spec[ffestb_local_.read.ix]
15492         .value_present = FALSE;
15493       ffestp_file.read.read_spec[ffestb_local_.read.ix].value_is_label
15494         = ffestb_local_.read.label;
15495       ffestp_file.read.read_spec[ffestb_local_.read.ix].kw
15496         = ffelex_token_use (t);
15497       return (ffelexHandler) ffestb_R9099_;
15498
15499     default:
15500       break;
15501     }
15502
15503 bad:                            /* :::::::::::::::::::: */
15504   ffestb_subr_kill_read_ ();
15505   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15506   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15507 }
15508
15509 /* ffestb_R9099_ -- "READ" OPEN_PAREN [external-file-unit COMMA [format
15510                    COMMA]] NAME
15511
15512    return ffestb_R9099_;  // to lexer
15513
15514    Make sure EQUALS here, send next token to expression handler.  */
15515
15516 static ffelexHandler
15517 ffestb_R9099_ (ffelexToken t)
15518 {
15519   switch (ffelex_token_type (t))
15520     {
15521     case FFELEX_typeEQUALS:
15522       ffesta_confirmed ();
15523       if (ffestb_local_.read.label)
15524         return (ffelexHandler) ffestb_R90911_;
15525       if (ffestb_local_.read.left)
15526         return (ffelexHandler)
15527           ffeexpr_lhs (ffesta_output_pool,
15528                        ffestb_local_.read.context,
15529                        (ffeexprCallback) ffestb_R90910_);
15530       return (ffelexHandler)
15531         ffeexpr_rhs (ffesta_output_pool,
15532                      ffestb_local_.read.context,
15533                      (ffeexprCallback) ffestb_R90910_);
15534
15535     default:
15536       break;
15537     }
15538
15539   ffestb_subr_kill_read_ ();
15540   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15541   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15542 }
15543
15544 /* ffestb_R90910_ -- "READ" OPEN_PAREN ... NAME EQUALS expr
15545
15546    (ffestb_R90910_)  // to expression handler
15547
15548    Handle COMMA or CLOSE_PAREN here.  */
15549
15550 static ffelexHandler
15551 ffestb_R90910_ (ffelexToken ft, ffebld expr, ffelexToken t)
15552 {
15553   switch (ffelex_token_type (t))
15554     {
15555     case FFELEX_typeCOMMA:
15556     case FFELEX_typeCLOSE_PAREN:
15557       if (expr == NULL)
15558         {
15559           if (ffestb_local_.read.context == FFEEXPR_contextFILEFORMAT)
15560             ffestp_file.read.read_spec[ffestb_local_.read.ix]
15561               .value_is_label = TRUE;
15562           else
15563             break;
15564         }
15565       ffestp_file.read.read_spec[ffestb_local_.read.ix].value_present
15566         = TRUE;
15567       ffestp_file.read.read_spec[ffestb_local_.read.ix].value
15568         = ffelex_token_use (ft);
15569       ffestp_file.read.read_spec[ffestb_local_.read.ix].u.expr = expr;
15570       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15571         return (ffelexHandler) ffestb_R9098_;
15572       return (ffelexHandler) ffestb_R90913_;
15573
15574     default:
15575       break;
15576     }
15577
15578   ffestb_subr_kill_read_ ();
15579   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15580   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15581 }
15582
15583 /* ffestb_R90911_ -- "READ" OPEN_PAREN ... NAME EQUALS
15584
15585    return ffestb_R90911_;  // to lexer
15586
15587    Handle NUMBER for label here.  */
15588
15589 static ffelexHandler
15590 ffestb_R90911_ (ffelexToken t)
15591 {
15592   switch (ffelex_token_type (t))
15593     {
15594     case FFELEX_typeNUMBER:
15595       ffestp_file.read.read_spec[ffestb_local_.read.ix].value_present
15596         = TRUE;
15597       ffestp_file.read.read_spec[ffestb_local_.read.ix].value
15598         = ffelex_token_use (t);
15599       return (ffelexHandler) ffestb_R90912_;
15600
15601     default:
15602       break;
15603     }
15604
15605   ffestb_subr_kill_read_ ();
15606   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15607   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15608 }
15609
15610 /* ffestb_R90912_ -- "READ" OPEN_PAREN ... NAME EQUALS NUMBER
15611
15612    return ffestb_R90912_;  // to lexer
15613
15614    Handle COMMA or CLOSE_PAREN here.  */
15615
15616 static ffelexHandler
15617 ffestb_R90912_ (ffelexToken t)
15618 {
15619   switch (ffelex_token_type (t))
15620     {
15621     case FFELEX_typeCOMMA:
15622       return (ffelexHandler) ffestb_R9098_;
15623
15624     case FFELEX_typeCLOSE_PAREN:
15625       return (ffelexHandler) ffestb_R90913_;
15626
15627     default:
15628       break;
15629     }
15630
15631   ffestb_subr_kill_read_ ();
15632   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15633   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15634 }
15635
15636 /* ffestb_R90913_ -- "READ" OPEN_PAREN ... CLOSE_PAREN
15637
15638    return ffestb_R90913_;  // to lexer
15639
15640    Handle EOS or SEMICOLON here.
15641
15642    15-Feb-91  JCB  1.1
15643       Fix to allow implied-DO construct here (OPEN_PAREN) -- actually,
15644       don't presume knowledge of what an initial token in an lhs context
15645       is going to be, let ffeexpr_lhs handle that as much as possible.  */
15646
15647 static ffelexHandler
15648 ffestb_R90913_ (ffelexToken t)
15649 {
15650   switch (ffelex_token_type (t))
15651     {
15652     case FFELEX_typeEOS:
15653     case FFELEX_typeSEMICOLON:
15654       ffesta_confirmed ();
15655       if (!ffesta_is_inhibited ())
15656         {
15657           ffestc_R909_start (FALSE);
15658           ffestc_R909_finish ();
15659         }
15660       ffestb_subr_kill_read_ ();
15661       return (ffelexHandler) ffesta_zero (t);
15662
15663     default:
15664       ffesta_confirmed ();
15665       /* Fall through. */
15666     case FFELEX_typeOPEN_PAREN: /* Could still be assignment!! */
15667       break;
15668     }
15669
15670   /* If token isn't NAME or OPEN_PAREN, ffeexpr_lhs will ultimately whine
15671      about it, so leave it up to that code. */
15672
15673   /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.  (f2c
15674      provides this extension, as do other compilers, supposedly.) */
15675
15676   if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
15677     return (ffelexHandler)
15678       ffeexpr_lhs (ffesta_output_pool,
15679                    ffestc_context_iolist (),
15680                    (ffeexprCallback) ffestb_R90914_);
15681
15682   return (ffelexHandler) (*((ffelexHandler)
15683                             ffeexpr_lhs (ffesta_output_pool,
15684                                          ffestc_context_iolist (),
15685                                          (ffeexprCallback) ffestb_R90914_)))
15686     (t);
15687 }
15688
15689 /* ffestb_R90914_ -- "READ(...)" expr
15690
15691    (ffestb_R90914_)  // to expression handler
15692
15693    Handle COMMA or EOS/SEMICOLON here.  */
15694
15695 static ffelexHandler
15696 ffestb_R90914_ (ffelexToken ft, ffebld expr, ffelexToken t)
15697 {
15698   switch (ffelex_token_type (t))
15699     {
15700     case FFELEX_typeCOMMA:
15701       if (expr == NULL)
15702         break;
15703
15704       ffesta_confirmed ();
15705       if (!ffesta_is_inhibited ())
15706         ffestc_R909_start (FALSE);
15707       ffestb_subr_kill_read_ ();
15708
15709       if (!ffesta_is_inhibited ())
15710         ffestc_R909_item (expr, ft);
15711       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
15712                                           ffestc_context_iolist (),
15713                                           (ffeexprCallback) ffestb_R90915_);
15714
15715     case FFELEX_typeEOS:
15716     case FFELEX_typeSEMICOLON:
15717       if (expr == NULL)
15718         break;
15719
15720       ffesta_confirmed ();
15721       if (!ffesta_is_inhibited ())
15722         ffestc_R909_start (FALSE);
15723       ffestb_subr_kill_read_ ();
15724
15725       if (!ffesta_is_inhibited ())
15726         {
15727           ffestc_R909_item (expr, ft);
15728           ffestc_R909_finish ();
15729         }
15730       return (ffelexHandler) ffesta_zero (t);
15731
15732     default:
15733       break;
15734     }
15735
15736   ffestb_subr_kill_read_ ();
15737   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15738   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15739 }
15740
15741 /* ffestb_R90915_ -- "READ(...)" expr COMMA expr
15742
15743    (ffestb_R90915_)  // to expression handler
15744
15745    Handle COMMA or EOS/SEMICOLON here.  */
15746
15747 static ffelexHandler
15748 ffestb_R90915_ (ffelexToken ft, ffebld expr, ffelexToken t)
15749 {
15750   switch (ffelex_token_type (t))
15751     {
15752     case FFELEX_typeCOMMA:
15753       if (expr == NULL)
15754         break;
15755       if (!ffesta_is_inhibited ())
15756         ffestc_R909_item (expr, ft);
15757       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
15758                                           ffestc_context_iolist (),
15759                                           (ffeexprCallback) ffestb_R90915_);
15760
15761     case FFELEX_typeEOS:
15762     case FFELEX_typeSEMICOLON:
15763       if (expr == NULL)
15764         break;
15765       if (!ffesta_is_inhibited ())
15766         {
15767           ffestc_R909_item (expr, ft);
15768           ffestc_R909_finish ();
15769         }
15770       return (ffelexHandler) ffesta_zero (t);
15771
15772     default:
15773       break;
15774     }
15775
15776   if (!ffesta_is_inhibited ())
15777     ffestc_R909_finish ();
15778   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15779   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15780 }
15781
15782 /* ffestb_R910 -- Parse the WRITE statement
15783
15784    return ffestb_R910;  // to lexer
15785
15786    Make sure the statement has a valid form for the WRITE
15787    statement.  If it does, implement the statement.  */
15788
15789 ffelexHandler
15790 ffestb_R910 (ffelexToken t)
15791 {
15792   ffestpWriteIx ix;
15793
15794   switch (ffelex_token_type (ffesta_tokens[0]))
15795     {
15796     case FFELEX_typeNAME:
15797       if (ffesta_first_kw != FFESTR_firstWRITE)
15798         goto bad_0;             /* :::::::::::::::::::: */
15799       switch (ffelex_token_type (t))
15800         {
15801         case FFELEX_typeCOMMA:
15802         case FFELEX_typeCOLONCOLON:
15803         case FFELEX_typeEOS:
15804         case FFELEX_typeSEMICOLON:
15805         case FFELEX_typeNAME:
15806         case FFELEX_typeNUMBER:
15807           ffesta_confirmed ();  /* Error, but clearly intended. */
15808           goto bad_1;           /* :::::::::::::::::::: */
15809
15810         default:
15811           goto bad_1;           /* :::::::::::::::::::: */
15812
15813         case FFELEX_typeOPEN_PAREN:
15814           for (ix = 0; ix < FFESTP_writeix; ++ix)
15815             ffestp_file.write.write_spec[ix].kw_or_val_present = FALSE;
15816           return (ffelexHandler) ffestb_R9101_;
15817         }
15818
15819     case FFELEX_typeNAMES:
15820       if (ffesta_first_kw != FFESTR_firstWRITE)
15821         goto bad_0;             /* :::::::::::::::::::: */
15822       switch (ffelex_token_type (t))
15823         {
15824         case FFELEX_typeEOS:
15825         case FFELEX_typeSEMICOLON:
15826         case FFELEX_typeCOMMA:
15827         case FFELEX_typeCOLONCOLON:
15828           ffesta_confirmed ();  /* Error, but clearly intended. */
15829           goto bad_1;           /* :::::::::::::::::::: */
15830
15831         default:
15832           goto bad_1;           /* :::::::::::::::::::: */
15833
15834         case FFELEX_typeOPEN_PAREN:
15835           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlWRITE)
15836             goto bad_0;         /* :::::::::::::::::::: */
15837
15838           for (ix = 0; ix < FFESTP_writeix; ++ix)
15839             ffestp_file.write.write_spec[ix].kw_or_val_present = FALSE;
15840           return (ffelexHandler) ffestb_R9101_;
15841         }
15842
15843     default:
15844       goto bad_0;               /* :::::::::::::::::::: */
15845     }
15846
15847 bad_0:                          /* :::::::::::::::::::: */
15848   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", ffesta_tokens[0]);
15849   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15850
15851 bad_1:                          /* :::::::::::::::::::: */
15852   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
15853   return (ffelexHandler) ffelex_swallow_tokens (t,
15854                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
15855 }
15856
15857 /* ffestb_R9101_ -- "WRITE" OPEN_PAREN
15858
15859    return ffestb_R9101_;  // to lexer
15860
15861    Handle expr construct (not NAME=expr construct) here.  */
15862
15863 static ffelexHandler
15864 ffestb_R9101_ (ffelexToken t)
15865 {
15866   switch (ffelex_token_type (t))
15867     {
15868     case FFELEX_typeNAME:
15869       ffesta_tokens[1] = ffelex_token_use (t);
15870       return (ffelexHandler) ffestb_R9102_;
15871
15872     default:
15873       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15874                  FFEEXPR_contextFILEUNIT, (ffeexprCallback) ffestb_R9103_)))
15875         (t);
15876     }
15877 }
15878
15879 /* ffestb_R9102_ -- "WRITE" OPEN_PAREN NAME
15880
15881    return ffestb_R9102_;  // to lexer
15882
15883    If EQUALS here, go to states that handle it.  Else, send NAME and this
15884    token thru expression handler.  */
15885
15886 static ffelexHandler
15887 ffestb_R9102_ (ffelexToken t)
15888 {
15889   ffelexHandler next;
15890   ffelexToken nt;
15891
15892   switch (ffelex_token_type (t))
15893     {
15894     case FFELEX_typeEQUALS:
15895       nt = ffesta_tokens[1];
15896       next = (ffelexHandler) ffestb_R9107_ (nt);
15897       ffelex_token_kill (nt);
15898       return (ffelexHandler) (*next) (t);
15899
15900     default:
15901       nt = ffesta_tokens[1];
15902       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15903                  FFEEXPR_contextFILEUNIT, (ffeexprCallback) ffestb_R9103_)))
15904         (nt);
15905       ffelex_token_kill (nt);
15906       return (ffelexHandler) (*next) (t);
15907     }
15908 }
15909
15910 /* ffestb_R9103_ -- "WRITE" OPEN_PAREN expr [CLOSE_PAREN]
15911
15912    (ffestb_R9103_)  // to expression handler
15913
15914    Handle COMMA or EOS/SEMICOLON here.  */
15915
15916 static ffelexHandler
15917 ffestb_R9103_ (ffelexToken ft, ffebld expr, ffelexToken t)
15918 {
15919   switch (ffelex_token_type (t))
15920     {
15921     case FFELEX_typeCOMMA:
15922     case FFELEX_typeCLOSE_PAREN:
15923       if (expr == NULL)
15924         break;
15925       ffestp_file.write.write_spec[FFESTP_writeixUNIT].kw_or_val_present
15926         = TRUE;
15927       ffestp_file.write.write_spec[FFESTP_writeixUNIT].kw_present = FALSE;
15928       ffestp_file.write.write_spec[FFESTP_writeixUNIT].value_present = TRUE;
15929       ffestp_file.write.write_spec[FFESTP_writeixUNIT].value_is_label
15930         = FALSE;
15931       ffestp_file.write.write_spec[FFESTP_writeixUNIT].value
15932         = ffelex_token_use (ft);
15933       ffestp_file.write.write_spec[FFESTP_writeixUNIT].u.expr = expr;
15934       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15935         return (ffelexHandler) ffestb_R9104_;
15936       return (ffelexHandler) ffestb_R91012_;
15937
15938     default:
15939       break;
15940     }
15941
15942   ffestb_subr_kill_write_ ();
15943   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
15944   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15945 }
15946
15947 /* ffestb_R9104_ -- "WRITE" OPEN_PAREN expr COMMA
15948
15949    return ffestb_R9104_;  // to lexer
15950
15951    Handle expr construct (not NAME=expr construct) here.  */
15952
15953 static ffelexHandler
15954 ffestb_R9104_ (ffelexToken t)
15955 {
15956   switch (ffelex_token_type (t))
15957     {
15958     case FFELEX_typeNAME:
15959       ffesta_tokens[1] = ffelex_token_use (t);
15960       return (ffelexHandler) ffestb_R9105_;
15961
15962     default:
15963       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15964             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9106_)))
15965         (t);
15966     }
15967 }
15968
15969 /* ffestb_R9105_ -- "WRITE" OPEN_PAREN expr COMMA NAME
15970
15971    return ffestb_R9105_;  // to lexer
15972
15973    If EQUALS here, go to states that handle it.  Else, send NAME and this
15974    token thru expression handler.  */
15975
15976 static ffelexHandler
15977 ffestb_R9105_ (ffelexToken t)
15978 {
15979   ffelexHandler next;
15980   ffelexToken nt;
15981
15982   switch (ffelex_token_type (t))
15983     {
15984     case FFELEX_typeEQUALS:
15985       nt = ffesta_tokens[1];
15986       next = (ffelexHandler) ffestb_R9107_ (nt);
15987       ffelex_token_kill (nt);
15988       return (ffelexHandler) (*next) (t);
15989
15990     default:
15991       nt = ffesta_tokens[1];
15992       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15993             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9106_)))
15994         (nt);
15995       ffelex_token_kill (nt);
15996       return (ffelexHandler) (*next) (t);
15997     }
15998 }
15999
16000 /* ffestb_R9106_ -- "WRITE" OPEN_PAREN expr COMMA expr
16001
16002    (ffestb_R9106_)  // to expression handler
16003
16004    Handle COMMA or CLOSE_PAREN here.  */
16005
16006 static ffelexHandler
16007 ffestb_R9106_ (ffelexToken ft, ffebld expr, ffelexToken t)
16008 {
16009   switch (ffelex_token_type (t))
16010     {
16011     case FFELEX_typeCOMMA:
16012     case FFELEX_typeCLOSE_PAREN:
16013       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].kw_or_val_present
16014         = TRUE;
16015       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].kw_present = FALSE;
16016       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value_present = TRUE;
16017       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value_is_label
16018         = (expr == NULL);
16019       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value
16020         = ffelex_token_use (ft);
16021       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].u.expr = expr;
16022       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16023         return (ffelexHandler) ffestb_R9107_;
16024       return (ffelexHandler) ffestb_R91012_;
16025
16026     default:
16027       break;
16028     }
16029
16030   ffestb_subr_kill_write_ ();
16031   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16032   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16033 }
16034
16035 /* ffestb_R9107_ -- "WRITE" OPEN_PAREN [external-file-unit COMMA [format
16036                    COMMA]]
16037
16038    return ffestb_R9107_;  // to lexer
16039
16040    Handle expr construct (not NAME=expr construct) here.  */
16041
16042 static ffelexHandler
16043 ffestb_R9107_ (ffelexToken t)
16044 {
16045   ffestrGenio kw;
16046
16047   ffestb_local_.write.label = FALSE;
16048
16049   switch (ffelex_token_type (t))
16050     {
16051     case FFELEX_typeNAME:
16052       kw = ffestr_genio (t);
16053       switch (kw)
16054         {
16055         case FFESTR_genioADVANCE:
16056           ffestb_local_.write.ix = FFESTP_writeixADVANCE;
16057           ffestb_local_.write.left = FALSE;
16058           ffestb_local_.write.context = FFEEXPR_contextFILEDFCHAR;
16059           break;
16060
16061         case FFESTR_genioEOR:
16062           ffestb_local_.write.ix = FFESTP_writeixEOR;
16063           ffestb_local_.write.label = TRUE;
16064           break;
16065
16066         case FFESTR_genioERR:
16067           ffestb_local_.write.ix = FFESTP_writeixERR;
16068           ffestb_local_.write.label = TRUE;
16069           break;
16070
16071         case FFESTR_genioFMT:
16072           ffestb_local_.write.ix = FFESTP_writeixFORMAT;
16073           ffestb_local_.write.left = FALSE;
16074           ffestb_local_.write.context = FFEEXPR_contextFILEFORMAT;
16075           break;
16076
16077         case FFESTR_genioIOSTAT:
16078           ffestb_local_.write.ix = FFESTP_writeixIOSTAT;
16079           ffestb_local_.write.left = TRUE;
16080           ffestb_local_.write.context = FFEEXPR_contextFILEINT;
16081           break;
16082
16083         case FFESTR_genioNML:
16084           ffestb_local_.write.ix = FFESTP_writeixFORMAT;
16085           ffestb_local_.write.left = TRUE;
16086           ffestb_local_.write.context = FFEEXPR_contextFILENAMELIST;
16087           break;
16088
16089         case FFESTR_genioREC:
16090           ffestb_local_.write.ix = FFESTP_writeixREC;
16091           ffestb_local_.write.left = FALSE;
16092           ffestb_local_.write.context = FFEEXPR_contextFILENUM;
16093           break;
16094
16095         case FFESTR_genioUNIT:
16096           ffestb_local_.write.ix = FFESTP_writeixUNIT;
16097           ffestb_local_.write.left = FALSE;
16098           ffestb_local_.write.context = FFEEXPR_contextFILEUNIT;
16099           break;
16100
16101         default:
16102           goto bad;             /* :::::::::::::::::::: */
16103         }
16104       if (ffestp_file.write.write_spec[ffestb_local_.write.ix]
16105           .kw_or_val_present)
16106         break;                  /* Can't specify a keyword twice! */
16107       ffestp_file.write.write_spec[ffestb_local_.write.ix]
16108         .kw_or_val_present = TRUE;
16109       ffestp_file.write.write_spec[ffestb_local_.write.ix]
16110         .kw_present = TRUE;
16111       ffestp_file.write.write_spec[ffestb_local_.write.ix]
16112         .value_present = FALSE;
16113       ffestp_file.write.write_spec[ffestb_local_.write.ix].value_is_label
16114         = ffestb_local_.write.label;
16115       ffestp_file.write.write_spec[ffestb_local_.write.ix].kw
16116         = ffelex_token_use (t);
16117       return (ffelexHandler) ffestb_R9108_;
16118
16119     default:
16120       break;
16121     }
16122
16123 bad:                            /* :::::::::::::::::::: */
16124   ffestb_subr_kill_write_ ();
16125   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16126   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16127 }
16128
16129 /* ffestb_R9108_ -- "WRITE" OPEN_PAREN [external-file-unit COMMA [format
16130                    COMMA]] NAME
16131
16132    return ffestb_R9108_;  // to lexer
16133
16134    Make sure EQUALS here, send next token to expression handler.  */
16135
16136 static ffelexHandler
16137 ffestb_R9108_ (ffelexToken t)
16138 {
16139   switch (ffelex_token_type (t))
16140     {
16141     case FFELEX_typeEQUALS:
16142       ffesta_confirmed ();
16143       if (ffestb_local_.write.label)
16144         return (ffelexHandler) ffestb_R91010_;
16145       if (ffestb_local_.write.left)
16146         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
16147                                             ffestb_local_.write.context,
16148                                             (ffeexprCallback) ffestb_R9109_);
16149       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16150                                           ffestb_local_.write.context,
16151                                           (ffeexprCallback) ffestb_R9109_);
16152
16153     default:
16154       break;
16155     }
16156
16157   ffestb_subr_kill_write_ ();
16158   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16159   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16160 }
16161
16162 /* ffestb_R9109_ -- "WRITE" OPEN_PAREN ... NAME EQUALS expr
16163
16164    (ffestb_R9109_)  // to expression handler
16165
16166    Handle COMMA or CLOSE_PAREN here.  */
16167
16168 static ffelexHandler
16169 ffestb_R9109_ (ffelexToken ft, ffebld expr, ffelexToken t)
16170 {
16171   switch (ffelex_token_type (t))
16172     {
16173     case FFELEX_typeCOMMA:
16174     case FFELEX_typeCLOSE_PAREN:
16175       if (expr == NULL)
16176         {
16177           if (ffestb_local_.write.context == FFEEXPR_contextFILEFORMAT)
16178             ffestp_file.write.write_spec[ffestb_local_.write.ix]
16179               .value_is_label = TRUE;
16180           else
16181             break;
16182         }
16183       ffestp_file.write.write_spec[ffestb_local_.write.ix].value_present
16184         = TRUE;
16185       ffestp_file.write.write_spec[ffestb_local_.write.ix].value
16186         = ffelex_token_use (ft);
16187       ffestp_file.write.write_spec[ffestb_local_.write.ix].u.expr = expr;
16188       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16189         return (ffelexHandler) ffestb_R9107_;
16190       return (ffelexHandler) ffestb_R91012_;
16191
16192     default:
16193       break;
16194     }
16195
16196   ffestb_subr_kill_write_ ();
16197   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16198   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16199 }
16200
16201 /* ffestb_R91010_ -- "WRITE" OPEN_PAREN ... NAME EQUALS
16202
16203    return ffestb_R91010_;  // to lexer
16204
16205    Handle NUMBER for label here.  */
16206
16207 static ffelexHandler
16208 ffestb_R91010_ (ffelexToken t)
16209 {
16210   switch (ffelex_token_type (t))
16211     {
16212     case FFELEX_typeNUMBER:
16213       ffestp_file.write.write_spec[ffestb_local_.write.ix].value_present
16214         = TRUE;
16215       ffestp_file.write.write_spec[ffestb_local_.write.ix].value
16216         = ffelex_token_use (t);
16217       return (ffelexHandler) ffestb_R91011_;
16218
16219     default:
16220       break;
16221     }
16222
16223   ffestb_subr_kill_write_ ();
16224   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16225   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16226 }
16227
16228 /* ffestb_R91011_ -- "WRITE" OPEN_PAREN ... NAME EQUALS NUMBER
16229
16230    return ffestb_R91011_;  // to lexer
16231
16232    Handle COMMA or CLOSE_PAREN here.  */
16233
16234 static ffelexHandler
16235 ffestb_R91011_ (ffelexToken t)
16236 {
16237   switch (ffelex_token_type (t))
16238     {
16239     case FFELEX_typeCOMMA:
16240       return (ffelexHandler) ffestb_R9107_;
16241
16242     case FFELEX_typeCLOSE_PAREN:
16243       return (ffelexHandler) ffestb_R91012_;
16244
16245     default:
16246       break;
16247     }
16248
16249   ffestb_subr_kill_write_ ();
16250   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16251   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16252 }
16253
16254 /* ffestb_R91012_ -- "WRITE" OPEN_PAREN ... CLOSE_PAREN
16255
16256    return ffestb_R91012_;  // to lexer
16257
16258    Handle EOS or SEMICOLON here.  */
16259
16260 static ffelexHandler
16261 ffestb_R91012_ (ffelexToken t)
16262 {
16263   switch (ffelex_token_type (t))
16264     {
16265     case FFELEX_typeEOS:
16266     case FFELEX_typeSEMICOLON:
16267       ffesta_confirmed ();
16268       if (!ffesta_is_inhibited ())
16269         {
16270           ffestc_R910_start ();
16271           ffestc_R910_finish ();
16272         }
16273       ffestb_subr_kill_write_ ();
16274       return (ffelexHandler) ffesta_zero (t);
16275
16276     default:
16277       ffesta_confirmed ();
16278       /* Fall through. */
16279     case FFELEX_typeOPEN_PAREN: /* Could still be assignment!! */
16280
16281       /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
16282          (f2c provides this extension, as do other compilers, supposedly.) */
16283
16284       if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
16285         return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16286                 ffestc_context_iolist (), (ffeexprCallback) ffestb_R91013_);
16287
16288       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16289                ffestc_context_iolist (), (ffeexprCallback) ffestb_R91013_)))
16290         (t);
16291
16292     case FFELEX_typeEQUALS:
16293     case FFELEX_typePOINTS:
16294       break;
16295     }
16296
16297   ffestb_subr_kill_write_ ();
16298   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16299   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16300 }
16301
16302 /* ffestb_R91013_ -- "WRITE(...)" expr
16303
16304    (ffestb_R91013_)  // to expression handler
16305
16306    Handle COMMA or EOS/SEMICOLON here.  */
16307
16308 static ffelexHandler
16309 ffestb_R91013_ (ffelexToken ft, ffebld expr, ffelexToken t)
16310 {
16311   switch (ffelex_token_type (t))
16312     {
16313     case FFELEX_typeCOMMA:
16314       if (expr == NULL)
16315         break;
16316
16317       ffesta_confirmed ();
16318       if (!ffesta_is_inhibited ())
16319         ffestc_R910_start ();
16320       ffestb_subr_kill_write_ ();
16321
16322       if (!ffesta_is_inhibited ())
16323         ffestc_R910_item (expr, ft);
16324       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16325                 ffestc_context_iolist (), (ffeexprCallback) ffestb_R91014_);
16326
16327     case FFELEX_typeEOS:
16328     case FFELEX_typeSEMICOLON:
16329       if (expr == NULL)
16330         break;
16331
16332       ffesta_confirmed ();
16333       if (!ffesta_is_inhibited ())
16334         ffestc_R910_start ();
16335       ffestb_subr_kill_write_ ();
16336
16337       if (!ffesta_is_inhibited ())
16338         {
16339           ffestc_R910_item (expr, ft);
16340           ffestc_R910_finish ();
16341         }
16342       return (ffelexHandler) ffesta_zero (t);
16343
16344     default:
16345       break;
16346     }
16347
16348   ffestb_subr_kill_write_ ();
16349   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16350   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16351 }
16352
16353 /* ffestb_R91014_ -- "WRITE(...)" expr COMMA expr
16354
16355    (ffestb_R91014_)  // to expression handler
16356
16357    Handle COMMA or EOS/SEMICOLON here.  */
16358
16359 static ffelexHandler
16360 ffestb_R91014_ (ffelexToken ft, ffebld expr, ffelexToken t)
16361 {
16362   switch (ffelex_token_type (t))
16363     {
16364     case FFELEX_typeCOMMA:
16365       if (expr == NULL)
16366         break;
16367       if (!ffesta_is_inhibited ())
16368         ffestc_R910_item (expr, ft);
16369       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16370                 ffestc_context_iolist (), (ffeexprCallback) ffestb_R91014_);
16371
16372     case FFELEX_typeEOS:
16373     case FFELEX_typeSEMICOLON:
16374       if (expr == NULL)
16375         break;
16376       if (!ffesta_is_inhibited ())
16377         {
16378           ffestc_R910_item (expr, ft);
16379           ffestc_R910_finish ();
16380         }
16381       return (ffelexHandler) ffesta_zero (t);
16382
16383     default:
16384       break;
16385     }
16386
16387   if (!ffesta_is_inhibited ())
16388     ffestc_R910_finish ();
16389   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16390   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16391 }
16392
16393 /* ffestb_R911 -- Parse the PRINT statement
16394
16395    return ffestb_R911;  // to lexer
16396
16397    Make sure the statement has a valid form for the PRINT
16398    statement.  If it does, implement the statement.  */
16399
16400 ffelexHandler
16401 ffestb_R911 (ffelexToken t)
16402 {
16403   ffelexHandler next;
16404   ffestpPrintIx ix;
16405
16406   switch (ffelex_token_type (ffesta_tokens[0]))
16407     {
16408     case FFELEX_typeNAME:
16409       if (ffesta_first_kw != FFESTR_firstPRINT)
16410         goto bad_0;             /* :::::::::::::::::::: */
16411       switch (ffelex_token_type (t))
16412         {
16413         case FFELEX_typeCOMMA:
16414         case FFELEX_typeCOLONCOLON:
16415         case FFELEX_typeEOS:
16416         case FFELEX_typeSEMICOLON:
16417           ffesta_confirmed ();  /* Error, but clearly intended. */
16418           goto bad_1;           /* :::::::::::::::::::: */
16419
16420         case FFELEX_typeEQUALS:
16421         case FFELEX_typePOINTS:
16422         case FFELEX_typeCOLON:
16423           goto bad_1;           /* :::::::::::::::::::: */
16424
16425         case FFELEX_typeNAME:
16426         case FFELEX_typeNUMBER:
16427           ffesta_confirmed ();
16428           break;
16429
16430         default:
16431           break;
16432         }
16433
16434       for (ix = 0; ix < FFESTP_printix; ++ix)
16435         ffestp_file.print.print_spec[ix].kw_or_val_present = FALSE;
16436       return (ffelexHandler) (*((ffelexHandler)
16437                                 ffeexpr_rhs (ffesta_output_pool,
16438             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9111_)))
16439         (t);
16440
16441     case FFELEX_typeNAMES:
16442       if (ffesta_first_kw != FFESTR_firstPRINT)
16443         goto bad_0;             /* :::::::::::::::::::: */
16444       switch (ffelex_token_type (t))
16445         {
16446         case FFELEX_typeEOS:
16447         case FFELEX_typeSEMICOLON:
16448         case FFELEX_typeCOMMA:
16449           ffesta_confirmed ();
16450           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlPRINT)
16451             break;
16452           goto bad_1;           /* :::::::::::::::::::: */
16453
16454         case FFELEX_typeCOLONCOLON:
16455           ffesta_confirmed ();  /* Error, but clearly intended. */
16456           goto bad_1;           /* :::::::::::::::::::: */
16457
16458         case FFELEX_typeEQUALS:
16459         case FFELEX_typePOINTS:
16460         case FFELEX_typeCOLON:
16461           goto bad_1;           /* :::::::::::::::::::: */
16462
16463         default:
16464           break;
16465         }
16466       for (ix = 0; ix < FFESTP_printix; ++ix)
16467         ffestp_file.print.print_spec[ix].kw_or_val_present = FALSE;
16468       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16469              FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9111_);
16470       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
16471                                                    FFESTR_firstlPRINT);
16472       if (next == NULL)
16473         return (ffelexHandler) ffelex_swallow_tokens (t,
16474                                                (ffelexHandler) ffesta_zero);
16475       return (ffelexHandler) (*next) (t);
16476
16477     default:
16478       goto bad_0;               /* :::::::::::::::::::: */
16479     }
16480
16481 bad_0:                          /* :::::::::::::::::::: */
16482   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", ffesta_tokens[0]);
16483   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16484
16485 bad_1:                          /* :::::::::::::::::::: */
16486   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
16487   return (ffelexHandler) ffelex_swallow_tokens (t,
16488                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
16489 }
16490
16491 /* ffestb_R9111_ -- "PRINT" expr
16492
16493    (ffestb_R9111_)  // to expression handler
16494
16495    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
16496
16497 static ffelexHandler
16498 ffestb_R9111_ (ffelexToken ft, ffebld expr, ffelexToken t)
16499 {
16500   switch (ffelex_token_type (t))
16501     {
16502     case FFELEX_typeEOS:
16503     case FFELEX_typeSEMICOLON:
16504     case FFELEX_typeCOMMA:
16505       ffesta_confirmed ();
16506       ffestp_file.print.print_spec[FFESTP_printixFORMAT].kw_or_val_present
16507         = TRUE;
16508       ffestp_file.print.print_spec[FFESTP_printixFORMAT].kw_present = FALSE;
16509       ffestp_file.print.print_spec[FFESTP_printixFORMAT].value_present = TRUE;
16510       ffestp_file.print.print_spec[FFESTP_printixFORMAT].value_is_label
16511         = (expr == NULL);
16512       ffestp_file.print.print_spec[FFESTP_printixFORMAT].value
16513         = ffelex_token_use (ft);
16514       ffestp_file.print.print_spec[FFESTP_printixFORMAT].u.expr = expr;
16515       if (!ffesta_is_inhibited ())
16516         ffestc_R911_start ();
16517       ffestb_subr_kill_print_ ();
16518       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16519         return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16520                     FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R9112_);
16521       if (!ffesta_is_inhibited ())
16522         ffestc_R911_finish ();
16523       return (ffelexHandler) ffesta_zero (t);
16524
16525     default:
16526       break;
16527     }
16528
16529   ffestb_subr_kill_print_ ();
16530   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
16531   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16532 }
16533
16534 /* ffestb_R9112_ -- "PRINT" expr COMMA expr
16535
16536    (ffestb_R9112_)  // to expression handler
16537
16538    Handle COMMA or EOS/SEMICOLON here.  */
16539
16540 static ffelexHandler
16541 ffestb_R9112_ (ffelexToken ft, ffebld expr, ffelexToken t)
16542 {
16543   switch (ffelex_token_type (t))
16544     {
16545     case FFELEX_typeCOMMA:
16546       if (expr == NULL)
16547         break;
16548       if (!ffesta_is_inhibited ())
16549         ffestc_R911_item (expr, ft);
16550       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16551                     FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R9112_);
16552
16553     case FFELEX_typeEOS:
16554     case FFELEX_typeSEMICOLON:
16555       if (expr == NULL)
16556         break;
16557       if (!ffesta_is_inhibited ())
16558         {
16559           ffestc_R911_item (expr, ft);
16560           ffestc_R911_finish ();
16561         }
16562       return (ffelexHandler) ffesta_zero (t);
16563
16564     default:
16565       break;
16566     }
16567
16568   if (!ffesta_is_inhibited ())
16569     ffestc_R911_finish ();
16570   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
16571   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16572 }
16573
16574 /* ffestb_R923 -- Parse an INQUIRE statement
16575
16576    return ffestb_R923;  // to lexer
16577
16578    Make sure the statement has a valid form for an INQUIRE statement.
16579    If it does, implement the statement.  */
16580
16581 ffelexHandler
16582 ffestb_R923 (ffelexToken t)
16583 {
16584   ffestpInquireIx ix;
16585
16586   switch (ffelex_token_type (ffesta_tokens[0]))
16587     {
16588     case FFELEX_typeNAME:
16589       if (ffesta_first_kw != FFESTR_firstINQUIRE)
16590         goto bad_0;             /* :::::::::::::::::::: */
16591       break;
16592
16593     case FFELEX_typeNAMES:
16594       if (ffesta_first_kw != FFESTR_firstINQUIRE)
16595         goto bad_0;             /* :::::::::::::::::::: */
16596       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlINQUIRE)
16597         goto bad_0;             /* :::::::::::::::::::: */
16598       break;
16599
16600     default:
16601       goto bad_0;               /* :::::::::::::::::::: */
16602     }
16603
16604   switch (ffelex_token_type (t))
16605     {
16606     case FFELEX_typeOPEN_PAREN:
16607       break;
16608
16609     case FFELEX_typeEOS:
16610     case FFELEX_typeSEMICOLON:
16611     case FFELEX_typeCOMMA:
16612     case FFELEX_typeCOLONCOLON:
16613       ffesta_confirmed ();      /* Error, but clearly intended. */
16614       goto bad_1;               /* :::::::::::::::::::: */
16615
16616     default:
16617       goto bad_1;               /* :::::::::::::::::::: */
16618     }
16619
16620   for (ix = 0; ix < FFESTP_inquireix; ++ix)
16621     ffestp_file.inquire.inquire_spec[ix].kw_or_val_present = FALSE;
16622
16623   ffestb_local_.inquire.may_be_iolength = TRUE;
16624   return (ffelexHandler) ffestb_R9231_;
16625
16626 bad_0:                          /* :::::::::::::::::::: */
16627   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", ffesta_tokens[0]);
16628   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16629
16630 bad_1:                          /* :::::::::::::::::::: */
16631   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16632   return (ffelexHandler) ffelex_swallow_tokens (t,
16633                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
16634 }
16635
16636 /* ffestb_R9231_ -- "INQUIRE" OPEN_PAREN
16637
16638    return ffestb_R9231_;  // to lexer
16639
16640    Handle expr construct (not NAME=expr construct) here.  */
16641
16642 static ffelexHandler
16643 ffestb_R9231_ (ffelexToken t)
16644 {
16645   switch (ffelex_token_type (t))
16646     {
16647     case FFELEX_typeNAME:
16648       ffesta_tokens[1] = ffelex_token_use (t);
16649       return (ffelexHandler) ffestb_R9232_;
16650
16651     default:
16652       ffestb_local_.inquire.may_be_iolength = FALSE;
16653       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16654                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9233_)))
16655         (t);
16656     }
16657 }
16658
16659 /* ffestb_R9232_ -- "INQUIRE" OPEN_PAREN NAME
16660
16661    return ffestb_R9232_;  // to lexer
16662
16663    If EQUALS here, go to states that handle it.  Else, send NAME and this
16664    token thru expression handler.  */
16665
16666 static ffelexHandler
16667 ffestb_R9232_ (ffelexToken t)
16668 {
16669   ffelexHandler next;
16670   ffelexToken nt;
16671
16672   switch (ffelex_token_type (t))
16673     {
16674     case FFELEX_typeEQUALS:
16675       nt = ffesta_tokens[1];
16676       next = (ffelexHandler) ffestb_R9234_ (nt);
16677       ffelex_token_kill (nt);
16678       return (ffelexHandler) (*next) (t);
16679
16680     default:
16681       ffestb_local_.inquire.may_be_iolength = FALSE;
16682       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16683                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9233_)))
16684         (ffesta_tokens[1]);
16685       ffelex_token_kill (ffesta_tokens[1]);
16686       return (ffelexHandler) (*next) (t);
16687     }
16688 }
16689
16690 /* ffestb_R9233_ -- "INQUIRE" OPEN_PAREN expr
16691
16692    (ffestb_R9233_)  // to expression handler
16693
16694    Handle COMMA or CLOSE_PAREN here.  */
16695
16696 static ffelexHandler
16697 ffestb_R9233_ (ffelexToken ft, ffebld expr, ffelexToken t)
16698 {
16699   switch (ffelex_token_type (t))
16700     {
16701     case FFELEX_typeCOMMA:
16702     case FFELEX_typeCLOSE_PAREN:
16703       if (expr == NULL)
16704         break;
16705       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].kw_or_val_present
16706         = TRUE;
16707       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].kw_present = FALSE;
16708       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value_present = TRUE;
16709       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value_is_label
16710         = FALSE;
16711       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value
16712         = ffelex_token_use (ft);
16713       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].u.expr = expr;
16714       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16715         return (ffelexHandler) ffestb_R9234_;
16716       return (ffelexHandler) ffestb_R9239_;
16717
16718     default:
16719       break;
16720     }
16721
16722   ffestb_subr_kill_inquire_ ();
16723   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16724   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16725 }
16726
16727 /* ffestb_R9234_ -- "INQUIRE" OPEN_PAREN [external-file-unit COMMA]
16728
16729    return ffestb_R9234_;  // to lexer
16730
16731    Handle expr construct (not NAME=expr construct) here.  */
16732
16733 static ffelexHandler
16734 ffestb_R9234_ (ffelexToken t)
16735 {
16736   ffestrInquire kw;
16737
16738   ffestb_local_.inquire.label = FALSE;
16739
16740   switch (ffelex_token_type (t))
16741     {
16742     case FFELEX_typeNAME:
16743       kw = ffestr_inquire (t);
16744       if (kw != FFESTR_inquireIOLENGTH)
16745         ffestb_local_.inquire.may_be_iolength = FALSE;
16746       switch (kw)
16747         {
16748         case FFESTR_inquireACCESS:
16749           ffestb_local_.inquire.ix = FFESTP_inquireixACCESS;
16750           ffestb_local_.inquire.left = TRUE;
16751           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16752           break;
16753
16754         case FFESTR_inquireACTION:
16755           ffestb_local_.inquire.ix = FFESTP_inquireixACTION;
16756           ffestb_local_.inquire.left = TRUE;
16757           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16758           break;
16759
16760         case FFESTR_inquireBLANK:
16761           ffestb_local_.inquire.ix = FFESTP_inquireixBLANK;
16762           ffestb_local_.inquire.left = TRUE;
16763           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16764           break;
16765
16766         case FFESTR_inquireCARRIAGECONTROL:
16767           ffestb_local_.inquire.ix = FFESTP_inquireixCARRIAGECONTROL;
16768           ffestb_local_.inquire.left = TRUE;
16769           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16770           break;
16771
16772         case FFESTR_inquireDEFAULTFILE:
16773           ffestb_local_.inquire.ix = FFESTP_inquireixDEFAULTFILE;
16774           ffestb_local_.inquire.left = FALSE;
16775           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16776           break;
16777
16778         case FFESTR_inquireDELIM:
16779           ffestb_local_.inquire.ix = FFESTP_inquireixDELIM;
16780           ffestb_local_.inquire.left = TRUE;
16781           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16782           break;
16783
16784         case FFESTR_inquireDIRECT:
16785           ffestb_local_.inquire.ix = FFESTP_inquireixDIRECT;
16786           ffestb_local_.inquire.left = TRUE;
16787           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16788           break;
16789
16790         case FFESTR_inquireERR:
16791           ffestb_local_.inquire.ix = FFESTP_inquireixERR;
16792           ffestb_local_.inquire.label = TRUE;
16793           break;
16794
16795         case FFESTR_inquireEXIST:
16796           ffestb_local_.inquire.ix = FFESTP_inquireixEXIST;
16797           ffestb_local_.inquire.left = TRUE;
16798           ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
16799           break;
16800
16801         case FFESTR_inquireFILE:
16802           ffestb_local_.inquire.ix = FFESTP_inquireixFILE;
16803           ffestb_local_.inquire.left = FALSE;
16804           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16805           break;
16806
16807         case FFESTR_inquireFORM:
16808           ffestb_local_.inquire.ix = FFESTP_inquireixFORM;
16809           ffestb_local_.inquire.left = TRUE;
16810           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16811           break;
16812
16813         case FFESTR_inquireFORMATTED:
16814           ffestb_local_.inquire.ix = FFESTP_inquireixFORMATTED;
16815           ffestb_local_.inquire.left = TRUE;
16816           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16817           break;
16818
16819         case FFESTR_inquireIOLENGTH:
16820           if (!ffestb_local_.inquire.may_be_iolength)
16821             goto bad;           /* :::::::::::::::::::: */
16822           ffestb_local_.inquire.ix = FFESTP_inquireixIOLENGTH;
16823           ffestb_local_.inquire.left = TRUE;
16824           ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16825           break;
16826
16827         case FFESTR_inquireIOSTAT:
16828           ffestb_local_.inquire.ix = FFESTP_inquireixIOSTAT;
16829           ffestb_local_.inquire.left = TRUE;
16830           ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16831           break;
16832
16833         case FFESTR_inquireKEYED:
16834           ffestb_local_.inquire.ix = FFESTP_inquireixKEYED;
16835           ffestb_local_.inquire.left = TRUE;
16836           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16837           break;
16838
16839         case FFESTR_inquireNAME:
16840           ffestb_local_.inquire.ix = FFESTP_inquireixNAME;
16841           ffestb_local_.inquire.left = TRUE;
16842           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16843           break;
16844
16845         case FFESTR_inquireNAMED:
16846           ffestb_local_.inquire.ix = FFESTP_inquireixNAMED;
16847           ffestb_local_.inquire.left = TRUE;
16848           ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
16849           break;
16850
16851         case FFESTR_inquireNEXTREC:
16852           ffestb_local_.inquire.ix = FFESTP_inquireixNEXTREC;
16853           ffestb_local_.inquire.left = TRUE;
16854           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFINT;
16855           break;
16856
16857         case FFESTR_inquireNUMBER:
16858           ffestb_local_.inquire.ix = FFESTP_inquireixNUMBER;
16859           ffestb_local_.inquire.left = TRUE;
16860           ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16861           break;
16862
16863         case FFESTR_inquireOPENED:
16864           ffestb_local_.inquire.ix = FFESTP_inquireixOPENED;
16865           ffestb_local_.inquire.left = TRUE;
16866           ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
16867           break;
16868
16869         case FFESTR_inquireORGANIZATION:
16870           ffestb_local_.inquire.ix = FFESTP_inquireixORGANIZATION;
16871           ffestb_local_.inquire.left = TRUE;
16872           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16873           break;
16874
16875         case FFESTR_inquirePAD:
16876           ffestb_local_.inquire.ix = FFESTP_inquireixPAD;
16877           ffestb_local_.inquire.left = TRUE;
16878           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16879           break;
16880
16881         case FFESTR_inquirePOSITION:
16882           ffestb_local_.inquire.ix = FFESTP_inquireixPOSITION;
16883           ffestb_local_.inquire.left = TRUE;
16884           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16885           break;
16886
16887         case FFESTR_inquireREAD:
16888           ffestb_local_.inquire.ix = FFESTP_inquireixREAD;
16889           ffestb_local_.inquire.left = TRUE;
16890           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16891           break;
16892
16893         case FFESTR_inquireREADWRITE:
16894           ffestb_local_.inquire.ix = FFESTP_inquireixREADWRITE;
16895           ffestb_local_.inquire.left = TRUE;
16896           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16897           break;
16898
16899         case FFESTR_inquireRECL:
16900           ffestb_local_.inquire.ix = FFESTP_inquireixRECL;
16901           ffestb_local_.inquire.left = TRUE;
16902           ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16903           break;
16904
16905         case FFESTR_inquireRECORDTYPE:
16906           ffestb_local_.inquire.ix = FFESTP_inquireixRECORDTYPE;
16907           ffestb_local_.inquire.left = TRUE;
16908           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16909           break;
16910
16911         case FFESTR_inquireSEQUENTIAL:
16912           ffestb_local_.inquire.ix = FFESTP_inquireixSEQUENTIAL;
16913           ffestb_local_.inquire.left = TRUE;
16914           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16915           break;
16916
16917         case FFESTR_inquireUNFORMATTED:
16918           ffestb_local_.inquire.ix = FFESTP_inquireixUNFORMATTED;
16919           ffestb_local_.inquire.left = TRUE;
16920           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16921           break;
16922
16923         case FFESTR_inquireUNIT:
16924           ffestb_local_.inquire.ix = FFESTP_inquireixUNIT;
16925           ffestb_local_.inquire.left = FALSE;
16926           ffestb_local_.inquire.context = FFEEXPR_contextFILENUM;
16927           break;
16928
16929         default:
16930           goto bad;             /* :::::::::::::::::::: */
16931         }
16932       if (ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16933           .kw_or_val_present)
16934         break;                  /* Can't specify a keyword twice! */
16935       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16936         .kw_or_val_present = TRUE;
16937       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16938         .kw_present = TRUE;
16939       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16940         .value_present = FALSE;
16941       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_is_label
16942         = ffestb_local_.inquire.label;
16943       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].kw
16944         = ffelex_token_use (t);
16945       return (ffelexHandler) ffestb_R9235_;
16946
16947     default:
16948       break;
16949     }
16950
16951 bad:                            /* :::::::::::::::::::: */
16952   ffestb_subr_kill_inquire_ ();
16953   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16954   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16955 }
16956
16957 /* ffestb_R9235_ -- "INQUIRE" OPEN_PAREN [external-file-unit COMMA] NAME
16958
16959    return ffestb_R9235_;  // to lexer
16960
16961    Make sure EQUALS here, send next token to expression handler.  */
16962
16963 static ffelexHandler
16964 ffestb_R9235_ (ffelexToken t)
16965 {
16966   switch (ffelex_token_type (t))
16967     {
16968     case FFELEX_typeEQUALS:
16969       ffesta_confirmed ();
16970       if (ffestb_local_.inquire.label)
16971         return (ffelexHandler) ffestb_R9237_;
16972       if (ffestb_local_.inquire.left)
16973         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
16974                                             ffestb_local_.inquire.context,
16975                                             (ffeexprCallback) ffestb_R9236_);
16976       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16977                                           ffestb_local_.inquire.context,
16978                                           (ffeexprCallback) ffestb_R9236_);
16979
16980     default:
16981       break;
16982     }
16983
16984   ffestb_subr_kill_inquire_ ();
16985   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16986   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16987 }
16988
16989 /* ffestb_R9236_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS expr
16990
16991    (ffestb_R9236_)  // to expression handler
16992
16993    Handle COMMA or CLOSE_PAREN here.  */
16994
16995 static ffelexHandler
16996 ffestb_R9236_ (ffelexToken ft, ffebld expr, ffelexToken t)
16997 {
16998   switch (ffelex_token_type (t))
16999     {
17000     case FFELEX_typeCOMMA:
17001       if (ffestb_local_.inquire.ix == FFESTP_inquireixIOLENGTH)
17002         break;                  /* IOLENGTH=expr must be followed by
17003                                    CLOSE_PAREN. */
17004       /* Fall through. */
17005     case FFELEX_typeCLOSE_PAREN:
17006       if (expr == NULL)
17007         break;
17008       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_present
17009         = TRUE;
17010       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value
17011         = ffelex_token_use (ft);
17012       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].u.expr = expr;
17013       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17014         return (ffelexHandler) ffestb_R9234_;
17015       if (ffestb_local_.inquire.ix == FFESTP_inquireixIOLENGTH)
17016         return (ffelexHandler) ffestb_R92310_;
17017       return (ffelexHandler) ffestb_R9239_;
17018
17019     default:
17020       break;
17021     }
17022
17023   ffestb_subr_kill_inquire_ ();
17024   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17025   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17026 }
17027
17028 /* ffestb_R9237_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS
17029
17030    return ffestb_R9237_;  // to lexer
17031
17032    Handle NUMBER for label here.  */
17033
17034 static ffelexHandler
17035 ffestb_R9237_ (ffelexToken t)
17036 {
17037   switch (ffelex_token_type (t))
17038     {
17039     case FFELEX_typeNUMBER:
17040       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_present
17041         = TRUE;
17042       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value
17043         = ffelex_token_use (t);
17044       return (ffelexHandler) ffestb_R9238_;
17045
17046     default:
17047       break;
17048     }
17049
17050   ffestb_subr_kill_inquire_ ();
17051   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17052   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17053 }
17054
17055 /* ffestb_R9238_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS NUMBER
17056
17057    return ffestb_R9238_;  // to lexer
17058
17059    Handle COMMA or CLOSE_PAREN here.  */
17060
17061 static ffelexHandler
17062 ffestb_R9238_ (ffelexToken t)
17063 {
17064   switch (ffelex_token_type (t))
17065     {
17066     case FFELEX_typeCOMMA:
17067       return (ffelexHandler) ffestb_R9234_;
17068
17069     case FFELEX_typeCLOSE_PAREN:
17070       return (ffelexHandler) ffestb_R9239_;
17071
17072     default:
17073       break;
17074     }
17075
17076   ffestb_subr_kill_inquire_ ();
17077   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17078   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17079 }
17080
17081 /* ffestb_R9239_ -- "INQUIRE" OPEN_PAREN ... CLOSE_PAREN
17082
17083    return ffestb_R9239_;  // to lexer
17084
17085    Handle EOS or SEMICOLON here.  */
17086
17087 static ffelexHandler
17088 ffestb_R9239_ (ffelexToken t)
17089 {
17090   switch (ffelex_token_type (t))
17091     {
17092     case FFELEX_typeEOS:
17093     case FFELEX_typeSEMICOLON:
17094       ffesta_confirmed ();
17095       if (!ffesta_is_inhibited ())
17096         ffestc_R923A ();
17097       ffestb_subr_kill_inquire_ ();
17098       return (ffelexHandler) ffesta_zero (t);
17099
17100     default:
17101       break;
17102     }
17103
17104   ffestb_subr_kill_inquire_ ();
17105   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17106   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17107 }
17108
17109 /* ffestb_R92310_ -- "INQUIRE(IOLENGTH=expr)"
17110
17111    return ffestb_R92310_;  // to lexer
17112
17113    Make sure EOS or SEMICOLON not here; begin R923B processing and expect
17114    output IO list.  */
17115
17116 static ffelexHandler
17117 ffestb_R92310_ (ffelexToken t)
17118 {
17119   switch (ffelex_token_type (t))
17120     {
17121     case FFELEX_typeEOS:
17122     case FFELEX_typeSEMICOLON:
17123       break;
17124
17125     default:
17126       ffesta_confirmed ();
17127       if (!ffesta_is_inhibited ())
17128         ffestc_R923B_start ();
17129       ffestb_subr_kill_inquire_ ();
17130       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17131                   FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R92311_)))
17132         (t);
17133     }
17134
17135   ffestb_subr_kill_inquire_ ();
17136   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17137   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17138 }
17139
17140 /* ffestb_R92311_ -- "INQUIRE(IOLENGTH=expr)" expr
17141
17142    (ffestb_R92311_)  // to expression handler
17143
17144    Handle COMMA or EOS/SEMICOLON here.  */
17145
17146 static ffelexHandler
17147 ffestb_R92311_ (ffelexToken ft, ffebld expr, ffelexToken t)
17148 {
17149   switch (ffelex_token_type (t))
17150     {
17151     case FFELEX_typeCOMMA:
17152       if (expr == NULL)
17153         break;
17154       if (!ffesta_is_inhibited ())
17155         ffestc_R923B_item (expr, ft);
17156       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17157                    FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R92311_);
17158
17159     case FFELEX_typeEOS:
17160     case FFELEX_typeSEMICOLON:
17161       if (expr == NULL)
17162         break;
17163       if (!ffesta_is_inhibited ())
17164         {
17165           ffestc_R923B_item (expr, ft);
17166           ffestc_R923B_finish ();
17167         }
17168       return (ffelexHandler) ffesta_zero (t);
17169
17170     default:
17171       break;
17172     }
17173
17174   if (!ffesta_is_inhibited ())
17175     ffestc_R923B_finish ();
17176   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17177   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17178 }
17179
17180 /* ffestb_V018 -- Parse the REWRITE statement
17181
17182    return ffestb_V018;  // to lexer
17183
17184    Make sure the statement has a valid form for the REWRITE
17185    statement.  If it does, implement the statement.  */
17186
17187 #if FFESTR_VXT
17188 ffelexHandler
17189 ffestb_V018 (ffelexToken t)
17190 {
17191   ffestpRewriteIx ix;
17192
17193   switch (ffelex_token_type (ffesta_tokens[0]))
17194     {
17195     case FFELEX_typeNAME:
17196       if (ffesta_first_kw != FFESTR_firstREWRITE)
17197         goto bad_0;             /* :::::::::::::::::::: */
17198       switch (ffelex_token_type (t))
17199         {
17200         case FFELEX_typeCOMMA:
17201         case FFELEX_typeCOLONCOLON:
17202         case FFELEX_typeEOS:
17203         case FFELEX_typeSEMICOLON:
17204         case FFELEX_typeNAME:
17205         case FFELEX_typeNUMBER:
17206           ffesta_confirmed ();  /* Error, but clearly intended. */
17207           goto bad_1;           /* :::::::::::::::::::: */
17208
17209         default:
17210           goto bad_1;           /* :::::::::::::::::::: */
17211
17212         case FFELEX_typeOPEN_PAREN:
17213           for (ix = 0; ix < FFESTP_rewriteix; ++ix)
17214             ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present = FALSE;
17215           return (ffelexHandler) ffestb_V0181_;
17216         }
17217
17218     case FFELEX_typeNAMES:
17219       if (ffesta_first_kw != FFESTR_firstREWRITE)
17220         goto bad_0;             /* :::::::::::::::::::: */
17221       switch (ffelex_token_type (t))
17222         {
17223         case FFELEX_typeEOS:
17224         case FFELEX_typeSEMICOLON:
17225         case FFELEX_typeCOMMA:
17226         case FFELEX_typeCOLONCOLON:
17227           ffesta_confirmed ();  /* Error, but clearly intended. */
17228           goto bad_1;           /* :::::::::::::::::::: */
17229
17230         default:
17231           goto bad_1;           /* :::::::::::::::::::: */
17232
17233         case FFELEX_typeOPEN_PAREN:
17234           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREWRITE)
17235             goto bad_0;         /* :::::::::::::::::::: */
17236
17237           for (ix = 0; ix < FFESTP_rewriteix; ++ix)
17238             ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present = FALSE;
17239           return (ffelexHandler) ffestb_V0181_;
17240         }
17241
17242     default:
17243       goto bad_0;               /* :::::::::::::::::::: */
17244     }
17245
17246 bad_0:                          /* :::::::::::::::::::: */
17247   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", ffesta_tokens[0]);
17248   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17249
17250 bad_1:                          /* :::::::::::::::::::: */
17251   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17252   return (ffelexHandler) ffelex_swallow_tokens (t,
17253                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
17254 }
17255
17256 /* ffestb_V0181_ -- "REWRITE" OPEN_PAREN
17257
17258    return ffestb_V0181_;  // to lexer
17259
17260    Handle expr construct (not NAME=expr construct) here.  */
17261
17262 static ffelexHandler
17263 ffestb_V0181_ (ffelexToken t)
17264 {
17265   switch (ffelex_token_type (t))
17266     {
17267     case FFELEX_typeNAME:
17268       ffesta_tokens[1] = ffelex_token_use (t);
17269       return (ffelexHandler) ffestb_V0182_;
17270
17271     default:
17272       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17273                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0183_)))
17274         (t);
17275     }
17276 }
17277
17278 /* ffestb_V0182_ -- "REWRITE" OPEN_PAREN NAME
17279
17280    return ffestb_V0182_;  // to lexer
17281
17282    If EQUALS here, go to states that handle it.  Else, send NAME and this
17283    token thru expression handler.  */
17284
17285 static ffelexHandler
17286 ffestb_V0182_ (ffelexToken t)
17287 {
17288   ffelexHandler next;
17289   ffelexToken nt;
17290
17291   switch (ffelex_token_type (t))
17292     {
17293     case FFELEX_typeEQUALS:
17294       nt = ffesta_tokens[1];
17295       next = (ffelexHandler) ffestb_V0187_ (nt);
17296       ffelex_token_kill (nt);
17297       return (ffelexHandler) (*next) (t);
17298
17299     default:
17300       nt = ffesta_tokens[1];
17301       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17302                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0183_)))
17303         (nt);
17304       ffelex_token_kill (nt);
17305       return (ffelexHandler) (*next) (t);
17306     }
17307 }
17308
17309 /* ffestb_V0183_ -- "REWRITE" OPEN_PAREN expr [CLOSE_PAREN]
17310
17311    (ffestb_V0183_)  // to expression handler
17312
17313    Handle COMMA or EOS/SEMICOLON here.  */
17314
17315 static ffelexHandler
17316 ffestb_V0183_ (ffelexToken ft, ffebld expr, ffelexToken t)
17317 {
17318   switch (ffelex_token_type (t))
17319     {
17320     case FFELEX_typeCOMMA:
17321     case FFELEX_typeCLOSE_PAREN:
17322       if (expr == NULL)
17323         break;
17324       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].kw_or_val_present
17325         = TRUE;
17326       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].kw_present = FALSE;
17327       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value_present = TRUE;
17328       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value_is_label
17329         = FALSE;
17330       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value
17331         = ffelex_token_use (ft);
17332       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].u.expr = expr;
17333       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17334         return (ffelexHandler) ffestb_V0184_;
17335       return (ffelexHandler) ffestb_V01812_;
17336
17337     default:
17338       break;
17339     }
17340
17341   ffestb_subr_kill_rewrite_ ();
17342   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17343   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17344 }
17345
17346 /* ffestb_V0184_ -- "REWRITE" OPEN_PAREN expr COMMA
17347
17348    return ffestb_V0184_;  // to lexer
17349
17350    Handle expr construct (not NAME=expr construct) here.  */
17351
17352 static ffelexHandler
17353 ffestb_V0184_ (ffelexToken t)
17354 {
17355   switch (ffelex_token_type (t))
17356     {
17357     case FFELEX_typeNAME:
17358       ffesta_tokens[1] = ffelex_token_use (t);
17359       return (ffelexHandler) ffestb_V0185_;
17360
17361     default:
17362       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17363                FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_V0186_)))
17364         (t);
17365     }
17366 }
17367
17368 /* ffestb_V0185_ -- "REWRITE" OPEN_PAREN expr COMMA NAME
17369
17370    return ffestb_V0185_;  // to lexer
17371
17372    If EQUALS here, go to states that handle it.  Else, send NAME and this
17373    token thru expression handler.  */
17374
17375 static ffelexHandler
17376 ffestb_V0185_ (ffelexToken t)
17377 {
17378   ffelexHandler next;
17379   ffelexToken nt;
17380
17381   switch (ffelex_token_type (t))
17382     {
17383     case FFELEX_typeEQUALS:
17384       nt = ffesta_tokens[1];
17385       next = (ffelexHandler) ffestb_V0187_ (nt);
17386       ffelex_token_kill (nt);
17387       return (ffelexHandler) (*next) (t);
17388
17389     default:
17390       nt = ffesta_tokens[1];
17391       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17392                FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_V0186_)))
17393         (nt);
17394       ffelex_token_kill (nt);
17395       return (ffelexHandler) (*next) (t);
17396     }
17397 }
17398
17399 /* ffestb_V0186_ -- "REWRITE" OPEN_PAREN expr COMMA expr
17400
17401    (ffestb_V0186_)  // to expression handler
17402
17403    Handle COMMA or CLOSE_PAREN here.  */
17404
17405 static ffelexHandler
17406 ffestb_V0186_ (ffelexToken ft, ffebld expr, ffelexToken t)
17407 {
17408   switch (ffelex_token_type (t))
17409     {
17410     case FFELEX_typeCOMMA:
17411     case FFELEX_typeCLOSE_PAREN:
17412       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].kw_or_val_present
17413         = TRUE;
17414       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].kw_present = FALSE;
17415       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value_present = TRUE;
17416       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value_is_label
17417         = (expr == NULL);
17418       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value
17419         = ffelex_token_use (ft);
17420       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].u.expr = expr;
17421       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17422         return (ffelexHandler) ffestb_V0187_;
17423       return (ffelexHandler) ffestb_V01812_;
17424
17425     default:
17426       break;
17427     }
17428
17429   ffestb_subr_kill_rewrite_ ();
17430   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17431   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17432 }
17433
17434 /* ffestb_V0187_ -- "REWRITE" OPEN_PAREN [external-file-unit COMMA [format
17435                    COMMA]]
17436
17437    return ffestb_V0187_;  // to lexer
17438
17439    Handle expr construct (not NAME=expr construct) here.  */
17440
17441 static ffelexHandler
17442 ffestb_V0187_ (ffelexToken t)
17443 {
17444   ffestrGenio kw;
17445
17446   ffestb_local_.rewrite.label = FALSE;
17447
17448   switch (ffelex_token_type (t))
17449     {
17450     case FFELEX_typeNAME:
17451       kw = ffestr_genio (t);
17452       switch (kw)
17453         {
17454         case FFESTR_genioERR:
17455           ffestb_local_.rewrite.ix = FFESTP_rewriteixERR;
17456           ffestb_local_.rewrite.label = TRUE;
17457           break;
17458
17459         case FFESTR_genioFMT:
17460           ffestb_local_.rewrite.ix = FFESTP_rewriteixFMT;
17461           ffestb_local_.rewrite.left = FALSE;
17462           ffestb_local_.rewrite.context = FFEEXPR_contextFILEFORMAT;
17463           break;
17464
17465         case FFESTR_genioIOSTAT:
17466           ffestb_local_.rewrite.ix = FFESTP_rewriteixIOSTAT;
17467           ffestb_local_.rewrite.left = TRUE;
17468           ffestb_local_.rewrite.context = FFEEXPR_contextFILEINT;
17469           break;
17470
17471         case FFESTR_genioUNIT:
17472           ffestb_local_.rewrite.ix = FFESTP_rewriteixUNIT;
17473           ffestb_local_.rewrite.left = FALSE;
17474           ffestb_local_.rewrite.context = FFEEXPR_contextFILENUM;
17475           break;
17476
17477         default:
17478           goto bad;             /* :::::::::::::::::::: */
17479         }
17480       if (ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17481           .kw_or_val_present)
17482         break;                  /* Can't specify a keyword twice! */
17483       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17484         .kw_or_val_present = TRUE;
17485       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17486         .kw_present = TRUE;
17487       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17488         .value_present = FALSE;
17489       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_is_label
17490         = ffestb_local_.rewrite.label;
17491       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].kw
17492         = ffelex_token_use (t);
17493       return (ffelexHandler) ffestb_V0188_;
17494
17495     default:
17496       break;
17497     }
17498
17499 bad:                            /* :::::::::::::::::::: */
17500   ffestb_subr_kill_rewrite_ ();
17501   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17502   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17503 }
17504
17505 /* ffestb_V0188_ -- "REWRITE" OPEN_PAREN [external-file-unit COMMA [format
17506                    COMMA]] NAME
17507
17508    return ffestb_V0188_;  // to lexer
17509
17510    Make sure EQUALS here, send next token to expression handler.  */
17511
17512 static ffelexHandler
17513 ffestb_V0188_ (ffelexToken t)
17514 {
17515   switch (ffelex_token_type (t))
17516     {
17517     case FFELEX_typeEQUALS:
17518       ffesta_confirmed ();
17519       if (ffestb_local_.rewrite.label)
17520         return (ffelexHandler) ffestb_V01810_;
17521       if (ffestb_local_.rewrite.left)
17522         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
17523                                             ffestb_local_.rewrite.context,
17524                                             (ffeexprCallback) ffestb_V0189_);
17525       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17526                                           ffestb_local_.rewrite.context,
17527                                           (ffeexprCallback) ffestb_V0189_);
17528
17529     default:
17530       break;
17531     }
17532
17533   ffestb_subr_kill_rewrite_ ();
17534   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17535   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17536 }
17537
17538 /* ffestb_V0189_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS expr
17539
17540    (ffestb_V0189_)  // to expression handler
17541
17542    Handle COMMA or CLOSE_PAREN here.  */
17543
17544 static ffelexHandler
17545 ffestb_V0189_ (ffelexToken ft, ffebld expr, ffelexToken t)
17546 {
17547   switch (ffelex_token_type (t))
17548     {
17549     case FFELEX_typeCOMMA:
17550     case FFELEX_typeCLOSE_PAREN:
17551       if (expr == NULL)
17552         if (ffestb_local_.rewrite.context == FFEEXPR_contextFILEFORMAT)
17553           ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17554             .value_is_label = TRUE;
17555         else
17556           break;
17557       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_present
17558         = TRUE;
17559       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value
17560         = ffelex_token_use (ft);
17561       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].u.expr = expr;
17562       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17563         return (ffelexHandler) ffestb_V0187_;
17564       return (ffelexHandler) ffestb_V01812_;
17565
17566     default:
17567       break;
17568     }
17569
17570   ffestb_subr_kill_rewrite_ ();
17571   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17572   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17573 }
17574
17575 /* ffestb_V01810_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS
17576
17577    return ffestb_V01810_;  // to lexer
17578
17579    Handle NUMBER for label here.  */
17580
17581 static ffelexHandler
17582 ffestb_V01810_ (ffelexToken t)
17583 {
17584   switch (ffelex_token_type (t))
17585     {
17586     case FFELEX_typeNUMBER:
17587       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_present
17588         = TRUE;
17589       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value
17590         = ffelex_token_use (t);
17591       return (ffelexHandler) ffestb_V01811_;
17592
17593     default:
17594       break;
17595     }
17596
17597   ffestb_subr_kill_rewrite_ ();
17598   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17599   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17600 }
17601
17602 /* ffestb_V01811_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS NUMBER
17603
17604    return ffestb_V01811_;  // to lexer
17605
17606    Handle COMMA or CLOSE_PAREN here.  */
17607
17608 static ffelexHandler
17609 ffestb_V01811_ (ffelexToken t)
17610 {
17611   switch (ffelex_token_type (t))
17612     {
17613     case FFELEX_typeCOMMA:
17614       return (ffelexHandler) ffestb_V0187_;
17615
17616     case FFELEX_typeCLOSE_PAREN:
17617       return (ffelexHandler) ffestb_V01812_;
17618
17619     default:
17620       break;
17621     }
17622
17623   ffestb_subr_kill_rewrite_ ();
17624   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17625   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17626 }
17627
17628 /* ffestb_V01812_ -- "REWRITE" OPEN_PAREN ... CLOSE_PAREN
17629
17630    return ffestb_V01812_;  // to lexer
17631
17632    Handle EOS or SEMICOLON here.  */
17633
17634 static ffelexHandler
17635 ffestb_V01812_ (ffelexToken t)
17636 {
17637   switch (ffelex_token_type (t))
17638     {
17639     case FFELEX_typeEOS:
17640     case FFELEX_typeSEMICOLON:
17641       ffesta_confirmed ();
17642       if (!ffesta_is_inhibited ())
17643         {
17644           ffestc_V018_start ();
17645           ffestc_V018_finish ();
17646         }
17647       ffestb_subr_kill_rewrite_ ();
17648       return (ffelexHandler) ffesta_zero (t);
17649
17650     case FFELEX_typeNAME:
17651     case FFELEX_typeOPEN_PAREN:
17652     case FFELEX_typeCOMMA:
17653       ffesta_confirmed ();
17654       if (!ffesta_is_inhibited ())
17655         ffestc_V018_start ();
17656       ffestb_subr_kill_rewrite_ ();
17657
17658       /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
17659          (f2c provides this extension, as do other compilers, supposedly.) */
17660
17661       if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
17662         return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17663                    FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_);
17664
17665       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17666                   FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_)))
17667         (t);
17668
17669     default:
17670       break;
17671     }
17672
17673   ffestb_subr_kill_rewrite_ ();
17674   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17675   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17676 }
17677
17678 /* ffestb_V01813_ -- "REWRITE(...)" expr
17679
17680    (ffestb_V01813_)  // to expression handler
17681
17682    Handle COMMA or EOS/SEMICOLON here.  */
17683
17684 static ffelexHandler
17685 ffestb_V01813_ (ffelexToken ft, ffebld expr, ffelexToken t)
17686 {
17687   switch (ffelex_token_type (t))
17688     {
17689     case FFELEX_typeCOMMA:
17690       if (expr == NULL)
17691         break;
17692       if (!ffesta_is_inhibited ())
17693         ffestc_V018_item (expr, ft);
17694       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17695                    FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_);
17696
17697     case FFELEX_typeEOS:
17698     case FFELEX_typeSEMICOLON:
17699       if (expr == NULL)
17700         break;
17701       if (!ffesta_is_inhibited ())
17702         {
17703           ffestc_V018_item (expr, ft);
17704           ffestc_V018_finish ();
17705         }
17706       return (ffelexHandler) ffesta_zero (t);
17707
17708     default:
17709       break;
17710     }
17711
17712   if (!ffesta_is_inhibited ())
17713     ffestc_V018_finish ();
17714   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17715   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17716 }
17717
17718 /* ffestb_V019 -- Parse the ACCEPT statement
17719
17720    return ffestb_V019;  // to lexer
17721
17722    Make sure the statement has a valid form for the ACCEPT
17723    statement.  If it does, implement the statement.  */
17724
17725 ffelexHandler
17726 ffestb_V019 (ffelexToken t)
17727 {
17728   ffelexHandler next;
17729   ffestpAcceptIx ix;
17730
17731   switch (ffelex_token_type (ffesta_tokens[0]))
17732     {
17733     case FFELEX_typeNAME:
17734       if (ffesta_first_kw != FFESTR_firstACCEPT)
17735         goto bad_0;             /* :::::::::::::::::::: */
17736       switch (ffelex_token_type (t))
17737         {
17738         case FFELEX_typeCOMMA:
17739         case FFELEX_typeCOLONCOLON:
17740         case FFELEX_typeEOS:
17741         case FFELEX_typeSEMICOLON:
17742           ffesta_confirmed ();  /* Error, but clearly intended. */
17743           goto bad_1;           /* :::::::::::::::::::: */
17744
17745         case FFELEX_typeEQUALS:
17746         case FFELEX_typePOINTS:
17747         case FFELEX_typeCOLON:
17748           goto bad_1;           /* :::::::::::::::::::: */
17749
17750         case FFELEX_typeNAME:
17751         case FFELEX_typeNUMBER:
17752           ffesta_confirmed ();
17753           break;
17754
17755         default:
17756           break;
17757         }
17758
17759       for (ix = 0; ix < FFESTP_acceptix; ++ix)
17760         ffestp_file.accept.accept_spec[ix].kw_or_val_present = FALSE;
17761       return (ffelexHandler) (*((ffelexHandler)
17762                                 ffeexpr_rhs (ffesta_output_pool,
17763             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0191_)))
17764         (t);
17765
17766     case FFELEX_typeNAMES:
17767       if (ffesta_first_kw != FFESTR_firstACCEPT)
17768         goto bad_0;             /* :::::::::::::::::::: */
17769       switch (ffelex_token_type (t))
17770         {
17771         case FFELEX_typeEOS:
17772         case FFELEX_typeSEMICOLON:
17773         case FFELEX_typeCOMMA:
17774           ffesta_confirmed ();
17775           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlACCEPT)
17776             break;
17777           goto bad_1;           /* :::::::::::::::::::: */
17778
17779         case FFELEX_typeCOLONCOLON:
17780           ffesta_confirmed ();  /* Error, but clearly intended. */
17781           goto bad_1;           /* :::::::::::::::::::: */
17782
17783         case FFELEX_typeEQUALS:
17784         case FFELEX_typePOINTS:
17785         case FFELEX_typeCOLON:
17786           goto bad_1;           /* :::::::::::::::::::: */
17787
17788         default:
17789           break;
17790         }
17791       for (ix = 0; ix < FFESTP_acceptix; ++ix)
17792         ffestp_file.accept.accept_spec[ix].kw_or_val_present = FALSE;
17793       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17794              FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0191_);
17795       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
17796                                                    FFESTR_firstlACCEPT);
17797       if (next == NULL)
17798         return (ffelexHandler) ffelex_swallow_tokens (t,
17799                                                (ffelexHandler) ffesta_zero);
17800       return (ffelexHandler) (*next) (t);
17801
17802     default:
17803       goto bad_0;               /* :::::::::::::::::::: */
17804     }
17805
17806 bad_0:                          /* :::::::::::::::::::: */
17807   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", ffesta_tokens[0]);
17808   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17809
17810 bad_1:                          /* :::::::::::::::::::: */
17811   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
17812   return (ffelexHandler) ffelex_swallow_tokens (t,
17813                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
17814 }
17815
17816 /* ffestb_V0191_ -- "ACCEPT" expr
17817
17818    (ffestb_V0191_)  // to expression handler
17819
17820    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
17821
17822 static ffelexHandler
17823 ffestb_V0191_ (ffelexToken ft, ffebld expr, ffelexToken t)
17824 {
17825   switch (ffelex_token_type (t))
17826     {
17827     case FFELEX_typeEOS:
17828     case FFELEX_typeSEMICOLON:
17829     case FFELEX_typeCOMMA:
17830       ffesta_confirmed ();
17831       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].kw_or_val_present
17832         = TRUE;
17833       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].kw_present = FALSE;
17834       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value_present = TRUE;
17835       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value_is_label
17836         = (expr == NULL);
17837       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value
17838         = ffelex_token_use (ft);
17839       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].u.expr = expr;
17840       if (!ffesta_is_inhibited ())
17841         ffestc_V019_start ();
17842       ffestb_subr_kill_accept_ ();
17843       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17844         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
17845                                             FFEEXPR_contextIOLIST,
17846                                             (ffeexprCallback) ffestb_V0192_);
17847       if (!ffesta_is_inhibited ())
17848         ffestc_V019_finish ();
17849       return (ffelexHandler) ffesta_zero (t);
17850
17851     default:
17852       break;
17853     }
17854
17855   ffestb_subr_kill_accept_ ();
17856   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
17857   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17858 }
17859
17860 /* ffestb_V0192_ -- "ACCEPT" expr COMMA expr
17861
17862    (ffestb_V0192_)  // to expression handler
17863
17864    Handle COMMA or EOS/SEMICOLON here.  */
17865
17866 static ffelexHandler
17867 ffestb_V0192_ (ffelexToken ft, ffebld expr, ffelexToken t)
17868 {
17869   switch (ffelex_token_type (t))
17870     {
17871     case FFELEX_typeCOMMA:
17872       if (expr == NULL)
17873         break;
17874       if (!ffesta_is_inhibited ())
17875         ffestc_V019_item (expr, ft);
17876       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
17877                                           FFEEXPR_contextIOLIST,
17878                                           (ffeexprCallback) ffestb_V0192_);
17879
17880     case FFELEX_typeEOS:
17881     case FFELEX_typeSEMICOLON:
17882       if (expr == NULL)
17883         break;
17884       if (!ffesta_is_inhibited ())
17885         {
17886           ffestc_V019_item (expr, ft);
17887           ffestc_V019_finish ();
17888         }
17889       return (ffelexHandler) ffesta_zero (t);
17890
17891     default:
17892       break;
17893     }
17894
17895   if (!ffesta_is_inhibited ())
17896     ffestc_V019_finish ();
17897   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
17898   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17899 }
17900
17901 #endif
17902 /* ffestb_V020 -- Parse the TYPE statement
17903
17904    return ffestb_V020;  // to lexer
17905
17906    Make sure the statement has a valid form for the TYPE
17907    statement.  If it does, implement the statement.  */
17908
17909 ffelexHandler
17910 ffestb_V020 (ffelexToken t)
17911 {
17912   ffeTokenLength i;
17913   char *p;
17914   ffelexHandler next;
17915   ffestpTypeIx ix;
17916
17917   switch (ffelex_token_type (ffesta_tokens[0]))
17918     {
17919     case FFELEX_typeNAME:
17920       if (ffesta_first_kw != FFESTR_firstTYPE)
17921         goto bad_0;             /* :::::::::::::::::::: */
17922       switch (ffelex_token_type (t))
17923         {
17924         case FFELEX_typeCOLONCOLON:
17925         case FFELEX_typeEOS:
17926         case FFELEX_typeSEMICOLON:
17927           ffesta_confirmed ();  /* Error, but clearly intended. */
17928           goto bad_1;           /* :::::::::::::::::::: */
17929
17930         case FFELEX_typeEQUALS:
17931         case FFELEX_typePOINTS:
17932         case FFELEX_typeCOLON:
17933         case FFELEX_typeCOMMA:  /* Because "TYPE,PUBLIC::A" is ambiguous with
17934                                    '90. */
17935           goto bad_1;           /* :::::::::::::::::::: */
17936
17937         case FFELEX_typeNUMBER:
17938           ffesta_confirmed ();
17939           break;
17940
17941         case FFELEX_typeNAME:   /* Because TYPE A is ambiguous with '90. */
17942         default:
17943           break;
17944         }
17945
17946       for (ix = 0; ix < FFESTP_typeix; ++ix)
17947         ffestp_file.type.type_spec[ix].kw_or_val_present = FALSE;
17948       return (ffelexHandler) (*((ffelexHandler)
17949                                 ffeexpr_rhs (ffesta_output_pool,
17950             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0201_)))
17951         (t);
17952
17953     case FFELEX_typeNAMES:
17954       if (ffesta_first_kw != FFESTR_firstTYPE)
17955         goto bad_0;             /* :::::::::::::::::::: */
17956       switch (ffelex_token_type (t))
17957         {
17958         case FFELEX_typeEOS:
17959         case FFELEX_typeSEMICOLON:
17960         case FFELEX_typeCOMMA:
17961           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlTYPE)
17962             break;
17963           goto bad_1;           /* :::::::::::::::::::: */
17964
17965         case FFELEX_typeCOLONCOLON:
17966           ffesta_confirmed ();  /* Error, but clearly intended. */
17967           goto bad_1;           /* :::::::::::::::::::: */
17968
17969         case FFELEX_typeOPEN_PAREN:
17970           if (ffelex_token_length (ffesta_tokens[0]) == FFESTR_firstlTYPE)
17971             break;              /* Else might be assignment/stmtfuncdef. */
17972           goto bad_1;           /* :::::::::::::::::::: */
17973
17974         case FFELEX_typeEQUALS:
17975         case FFELEX_typePOINTS:
17976         case FFELEX_typeCOLON:
17977           goto bad_1;           /* :::::::::::::::::::: */
17978
17979         default:
17980           break;
17981         }
17982       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlTYPE);
17983       if (isdigit (*p))
17984         ffesta_confirmed ();    /* Else might be '90 TYPE statement. */
17985       for (ix = 0; ix < FFESTP_typeix; ++ix)
17986         ffestp_file.type.type_spec[ix].kw_or_val_present = FALSE;
17987       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17988              FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0201_);
17989       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
17990                                                    FFESTR_firstlTYPE);
17991       if (next == NULL)
17992         return (ffelexHandler) ffelex_swallow_tokens (t,
17993                                                (ffelexHandler) ffesta_zero);
17994       return (ffelexHandler) (*next) (t);
17995
17996     default:
17997       goto bad_0;               /* :::::::::::::::::::: */
17998     }
17999
18000 bad_0:                          /* :::::::::::::::::::: */
18001   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", ffesta_tokens[0]);
18002   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18003
18004 bad_1:                          /* :::::::::::::::::::: */
18005   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
18006   return (ffelexHandler) ffelex_swallow_tokens (t,
18007                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
18008 }
18009
18010 /* ffestb_V0201_ -- "TYPE" expr
18011
18012    (ffestb_V0201_)  // to expression handler
18013
18014    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
18015
18016 static ffelexHandler
18017 ffestb_V0201_ (ffelexToken ft, ffebld expr, ffelexToken t)
18018 {
18019   bool comma = TRUE;
18020
18021   switch (ffelex_token_type (t))
18022     {
18023     case FFELEX_typeEOS:
18024     case FFELEX_typeSEMICOLON:
18025       if (!ffe_is_vxt () && (expr != NULL)
18026           && (ffebld_op (expr) == FFEBLD_opSYMTER))
18027         break;
18028       comma = FALSE;
18029       /* Fall through. */
18030     case FFELEX_typeCOMMA:
18031       if (!ffe_is_vxt () && comma && (expr != NULL)
18032           && (ffebld_op (expr) == FFEBLD_opPAREN)
18033           && (ffebld_op (ffebld_left (expr)) == FFEBLD_opSYMTER))
18034         break;
18035       ffesta_confirmed ();
18036       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].kw_or_val_present
18037         = TRUE;
18038       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].kw_present = FALSE;
18039       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value_present = TRUE;
18040       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value_is_label
18041         = (expr == NULL);
18042       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value
18043         = ffelex_token_use (ft);
18044       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].u.expr = expr;
18045       if (!ffesta_is_inhibited ())
18046         ffestc_V020_start ();
18047       ffestb_subr_kill_type_ ();
18048       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18049         return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18050                     FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V0202_);
18051       if (!ffesta_is_inhibited ())
18052         ffestc_V020_finish ();
18053       return (ffelexHandler) ffesta_zero (t);
18054
18055     default:
18056       break;
18057     }
18058
18059   ffestb_subr_kill_type_ ();
18060   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
18061   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18062 }
18063
18064 /* ffestb_V0202_ -- "TYPE" expr COMMA expr
18065
18066    (ffestb_V0202_)  // to expression handler
18067
18068    Handle COMMA or EOS/SEMICOLON here.  */
18069
18070 static ffelexHandler
18071 ffestb_V0202_ (ffelexToken ft, ffebld expr, ffelexToken t)
18072 {
18073   switch (ffelex_token_type (t))
18074     {
18075     case FFELEX_typeCOMMA:
18076       if (expr == NULL)
18077         break;
18078       if (!ffesta_is_inhibited ())
18079         ffestc_V020_item (expr, ft);
18080       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18081                     FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V0202_);
18082
18083     case FFELEX_typeEOS:
18084     case FFELEX_typeSEMICOLON:
18085       if (expr == NULL)
18086         break;
18087       if (!ffesta_is_inhibited ())
18088         {
18089           ffestc_V020_item (expr, ft);
18090           ffestc_V020_finish ();
18091         }
18092       return (ffelexHandler) ffesta_zero (t);
18093
18094     default:
18095       break;
18096     }
18097
18098   if (!ffesta_is_inhibited ())
18099     ffestc_V020_finish ();
18100   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
18101   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18102 }
18103
18104 /* ffestb_V021 -- Parse a DELETE statement
18105
18106    return ffestb_V021;  // to lexer
18107
18108    Make sure the statement has a valid form for a DELETE statement.
18109    If it does, implement the statement.  */
18110
18111 #if FFESTR_VXT
18112 ffelexHandler
18113 ffestb_V021 (ffelexToken t)
18114 {
18115   ffestpDeleteIx ix;
18116
18117   switch (ffelex_token_type (ffesta_tokens[0]))
18118     {
18119     case FFELEX_typeNAME:
18120       if (ffesta_first_kw != FFESTR_firstDELETE)
18121         goto bad_0;             /* :::::::::::::::::::: */
18122       break;
18123
18124     case FFELEX_typeNAMES:
18125       if (ffesta_first_kw != FFESTR_firstDELETE)
18126         goto bad_0;             /* :::::::::::::::::::: */
18127       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlDELETE)
18128         goto bad_0;             /* :::::::::::::::::::: */
18129       break;
18130
18131     default:
18132       goto bad_0;               /* :::::::::::::::::::: */
18133     }
18134
18135   switch (ffelex_token_type (t))
18136     {
18137     case FFELEX_typeOPEN_PAREN:
18138       break;
18139
18140     case FFELEX_typeEOS:
18141     case FFELEX_typeSEMICOLON:
18142     case FFELEX_typeCOMMA:
18143     case FFELEX_typeCOLONCOLON:
18144       ffesta_confirmed ();      /* Error, but clearly intended. */
18145       goto bad_1;               /* :::::::::::::::::::: */
18146
18147     default:
18148       goto bad_1;               /* :::::::::::::::::::: */
18149     }
18150
18151   for (ix = 0; ix < FFESTP_deleteix; ++ix)
18152     ffestp_file.delete.delete_spec[ix].kw_or_val_present = FALSE;
18153
18154   return (ffelexHandler) ffestb_V0211_;
18155
18156 bad_0:                          /* :::::::::::::::::::: */
18157   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", ffesta_tokens[0]);
18158   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18159
18160 bad_1:                          /* :::::::::::::::::::: */
18161   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18162   return (ffelexHandler) ffelex_swallow_tokens (t,
18163                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
18164 }
18165
18166 /* ffestb_V0211_ -- "DELETE" OPEN_PAREN
18167
18168    return ffestb_V0211_;  // to lexer
18169
18170    Handle expr construct (not NAME=expr construct) here.  */
18171
18172 static ffelexHandler
18173 ffestb_V0211_ (ffelexToken t)
18174 {
18175   switch (ffelex_token_type (t))
18176     {
18177     case FFELEX_typeNAME:
18178       ffesta_tokens[1] = ffelex_token_use (t);
18179       return (ffelexHandler) ffestb_V0212_;
18180
18181     default:
18182       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18183                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0213_)))
18184         (t);
18185     }
18186 }
18187
18188 /* ffestb_V0212_ -- "DELETE" OPEN_PAREN NAME
18189
18190    return ffestb_V0212_;  // to lexer
18191
18192    If EQUALS here, go to states that handle it.  Else, send NAME and this
18193    token thru expression handler.  */
18194
18195 static ffelexHandler
18196 ffestb_V0212_ (ffelexToken t)
18197 {
18198   ffelexHandler next;
18199   ffelexToken nt;
18200
18201   switch (ffelex_token_type (t))
18202     {
18203     case FFELEX_typeEQUALS:
18204       nt = ffesta_tokens[1];
18205       next = (ffelexHandler) ffestb_V0214_ (nt);
18206       ffelex_token_kill (nt);
18207       return (ffelexHandler) (*next) (t);
18208
18209     default:
18210       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18211                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0213_)))
18212         (ffesta_tokens[1]);
18213       ffelex_token_kill (ffesta_tokens[1]);
18214       return (ffelexHandler) (*next) (t);
18215     }
18216 }
18217
18218 /* ffestb_V0213_ -- "DELETE" OPEN_PAREN expr
18219
18220    (ffestb_V0213_)  // to expression handler
18221
18222    Handle COMMA or DELETE_PAREN here.  */
18223
18224 static ffelexHandler
18225 ffestb_V0213_ (ffelexToken ft, ffebld expr, ffelexToken t)
18226 {
18227   switch (ffelex_token_type (t))
18228     {
18229     case FFELEX_typeCOMMA:
18230     case FFELEX_typeCLOSE_PAREN:
18231       if (expr == NULL)
18232         break;
18233       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].kw_or_val_present
18234         = TRUE;
18235       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].kw_present = FALSE;
18236       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value_present = TRUE;
18237       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value_is_label
18238         = FALSE;
18239       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value
18240         = ffelex_token_use (ft);
18241       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].u.expr = expr;
18242       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18243         return (ffelexHandler) ffestb_V0214_;
18244       return (ffelexHandler) ffestb_V0219_;
18245
18246     default:
18247       break;
18248     }
18249
18250   ffestb_subr_kill_delete_ ();
18251   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18252   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18253 }
18254
18255 /* ffestb_V0214_ -- "DELETE" OPEN_PAREN [external-file-unit COMMA]
18256
18257    return ffestb_V0214_;  // to lexer
18258
18259    Handle expr construct (not NAME=expr construct) here.  */
18260
18261 static ffelexHandler
18262 ffestb_V0214_ (ffelexToken t)
18263 {
18264   ffestrGenio kw;
18265
18266   ffestb_local_.delete.label = FALSE;
18267
18268   switch (ffelex_token_type (t))
18269     {
18270     case FFELEX_typeNAME:
18271       kw = ffestr_genio (t);
18272       switch (kw)
18273         {
18274         case FFESTR_genioERR:
18275           ffestb_local_.delete.ix = FFESTP_deleteixERR;
18276           ffestb_local_.delete.label = TRUE;
18277           break;
18278
18279         case FFESTR_genioIOSTAT:
18280           ffestb_local_.delete.ix = FFESTP_deleteixIOSTAT;
18281           ffestb_local_.delete.left = TRUE;
18282           ffestb_local_.delete.context = FFEEXPR_contextFILEINT;
18283           break;
18284
18285         case FFESTR_genioREC:
18286           ffestb_local_.delete.ix = FFESTP_deleteixREC;
18287           ffestb_local_.delete.left = FALSE;
18288           ffestb_local_.delete.context = FFEEXPR_contextFILENUM;
18289           break;
18290
18291         case FFESTR_genioUNIT:
18292           ffestb_local_.delete.ix = FFESTP_deleteixUNIT;
18293           ffestb_local_.delete.left = FALSE;
18294           ffestb_local_.delete.context = FFEEXPR_contextFILENUM;
18295           break;
18296
18297         default:
18298           goto bad;             /* :::::::::::::::::::: */
18299         }
18300       if (ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18301           .kw_or_val_present)
18302         break;                  /* Can't specify a keyword twice! */
18303       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18304         .kw_or_val_present = TRUE;
18305       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18306         .kw_present = TRUE;
18307       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18308         .value_present = FALSE;
18309       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_is_label
18310         = ffestb_local_.delete.label;
18311       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].kw
18312         = ffelex_token_use (t);
18313       return (ffelexHandler) ffestb_V0215_;
18314
18315     default:
18316       break;
18317     }
18318
18319 bad:                            /* :::::::::::::::::::: */
18320   ffestb_subr_kill_delete_ ();
18321   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18322   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18323 }
18324
18325 /* ffestb_V0215_ -- "DELETE" OPEN_PAREN [external-file-unit COMMA] NAME
18326
18327    return ffestb_V0215_;  // to lexer
18328
18329    Make sure EQUALS here, send next token to expression handler.  */
18330
18331 static ffelexHandler
18332 ffestb_V0215_ (ffelexToken t)
18333 {
18334   switch (ffelex_token_type (t))
18335     {
18336     case FFELEX_typeEQUALS:
18337       ffesta_confirmed ();
18338       if (ffestb_local_.delete.label)
18339         return (ffelexHandler) ffestb_V0217_;
18340       if (ffestb_local_.delete.left)
18341         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
18342                                             ffestb_local_.delete.context,
18343                                             (ffeexprCallback) ffestb_V0216_);
18344       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18345              ffestb_local_.delete.context, (ffeexprCallback) ffestb_V0216_);
18346
18347     default:
18348       break;
18349     }
18350
18351   ffestb_subr_kill_delete_ ();
18352   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18353   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18354 }
18355
18356 /* ffestb_V0216_ -- "DELETE" OPEN_PAREN ... NAME EQUALS expr
18357
18358    (ffestb_V0216_)  // to expression handler
18359
18360    Handle COMMA or CLOSE_PAREN here.  */
18361
18362 static ffelexHandler
18363 ffestb_V0216_ (ffelexToken ft, ffebld expr, ffelexToken t)
18364 {
18365   switch (ffelex_token_type (t))
18366     {
18367     case FFELEX_typeCOMMA:
18368     case FFELEX_typeCLOSE_PAREN:
18369       if (expr == NULL)
18370         break;
18371       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_present
18372         = TRUE;
18373       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value
18374         = ffelex_token_use (ft);
18375       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].u.expr = expr;
18376       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18377         return (ffelexHandler) ffestb_V0214_;
18378       return (ffelexHandler) ffestb_V0219_;
18379
18380     default:
18381       break;
18382     }
18383
18384   ffestb_subr_kill_delete_ ();
18385   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18386   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18387 }
18388
18389 /* ffestb_V0217_ -- "DELETE" OPEN_PAREN ... NAME EQUALS
18390
18391    return ffestb_V0217_;  // to lexer
18392
18393    Handle NUMBER for label here.  */
18394
18395 static ffelexHandler
18396 ffestb_V0217_ (ffelexToken t)
18397 {
18398   switch (ffelex_token_type (t))
18399     {
18400     case FFELEX_typeNUMBER:
18401       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_present
18402         = TRUE;
18403       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value
18404         = ffelex_token_use (t);
18405       return (ffelexHandler) ffestb_V0218_;
18406
18407     default:
18408       break;
18409     }
18410
18411   ffestb_subr_kill_delete_ ();
18412   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18413   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18414 }
18415
18416 /* ffestb_V0218_ -- "DELETE" OPEN_PAREN ... NAME EQUALS NUMBER
18417
18418    return ffestb_V0218_;  // to lexer
18419
18420    Handle COMMA or CLOSE_PAREN here.  */
18421
18422 static ffelexHandler
18423 ffestb_V0218_ (ffelexToken t)
18424 {
18425   switch (ffelex_token_type (t))
18426     {
18427     case FFELEX_typeCOMMA:
18428       return (ffelexHandler) ffestb_V0214_;
18429
18430     case FFELEX_typeCLOSE_PAREN:
18431       return (ffelexHandler) ffestb_V0219_;
18432
18433     default:
18434       break;
18435     }
18436
18437   ffestb_subr_kill_delete_ ();
18438   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18439   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18440 }
18441
18442 /* ffestb_V0219_ -- "DELETE" OPEN_PAREN ... CLOSE_PAREN
18443
18444    return ffestb_V0219_;  // to lexer
18445
18446    Handle EOS or SEMICOLON here.  */
18447
18448 static ffelexHandler
18449 ffestb_V0219_ (ffelexToken t)
18450 {
18451   switch (ffelex_token_type (t))
18452     {
18453     case FFELEX_typeEOS:
18454     case FFELEX_typeSEMICOLON:
18455       ffesta_confirmed ();
18456       if (!ffesta_is_inhibited ())
18457         ffestc_V021 ();
18458       ffestb_subr_kill_delete_ ();
18459       return (ffelexHandler) ffesta_zero (t);
18460
18461     default:
18462       break;
18463     }
18464
18465   ffestb_subr_kill_delete_ ();
18466   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18467   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18468 }
18469
18470 /* ffestb_V026 -- Parse a FIND statement
18471
18472    return ffestb_V026;  // to lexer
18473
18474    Make sure the statement has a valid form for a FIND statement.
18475    If it does, implement the statement.  */
18476
18477 ffelexHandler
18478 ffestb_V026 (ffelexToken t)
18479 {
18480   ffestpFindIx ix;
18481
18482   switch (ffelex_token_type (ffesta_tokens[0]))
18483     {
18484     case FFELEX_typeNAME:
18485       if (ffesta_first_kw != FFESTR_firstFIND)
18486         goto bad_0;             /* :::::::::::::::::::: */
18487       break;
18488
18489     case FFELEX_typeNAMES:
18490       if (ffesta_first_kw != FFESTR_firstFIND)
18491         goto bad_0;             /* :::::::::::::::::::: */
18492       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlFIND)
18493         goto bad_0;             /* :::::::::::::::::::: */
18494       break;
18495
18496     default:
18497       goto bad_0;               /* :::::::::::::::::::: */
18498     }
18499
18500   switch (ffelex_token_type (t))
18501     {
18502     case FFELEX_typeOPEN_PAREN:
18503       break;
18504
18505     case FFELEX_typeEOS:
18506     case FFELEX_typeSEMICOLON:
18507     case FFELEX_typeCOMMA:
18508     case FFELEX_typeCOLONCOLON:
18509       ffesta_confirmed ();      /* Error, but clearly intended. */
18510       goto bad_1;               /* :::::::::::::::::::: */
18511
18512     default:
18513       goto bad_1;               /* :::::::::::::::::::: */
18514     }
18515
18516   for (ix = 0; ix < FFESTP_findix; ++ix)
18517     ffestp_file.find.find_spec[ix].kw_or_val_present = FALSE;
18518
18519   return (ffelexHandler) ffestb_V0261_;
18520
18521 bad_0:                          /* :::::::::::::::::::: */
18522   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", ffesta_tokens[0]);
18523   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18524
18525 bad_1:                          /* :::::::::::::::::::: */
18526   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18527   return (ffelexHandler) ffelex_swallow_tokens (t,
18528                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
18529 }
18530
18531 /* ffestb_V0261_ -- "FIND" OPEN_PAREN
18532
18533    return ffestb_V0261_;  // to lexer
18534
18535    Handle expr construct (not NAME=expr construct) here.  */
18536
18537 static ffelexHandler
18538 ffestb_V0261_ (ffelexToken t)
18539 {
18540   switch (ffelex_token_type (t))
18541     {
18542     case FFELEX_typeNAME:
18543       ffesta_tokens[1] = ffelex_token_use (t);
18544       return (ffelexHandler) ffestb_V0262_;
18545
18546     default:
18547       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18548                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0263_)))
18549         (t);
18550     }
18551 }
18552
18553 /* ffestb_V0262_ -- "FIND" OPEN_PAREN NAME
18554
18555    return ffestb_V0262_;  // to lexer
18556
18557    If EQUALS here, go to states that handle it.  Else, send NAME and this
18558    token thru expression handler.  */
18559
18560 static ffelexHandler
18561 ffestb_V0262_ (ffelexToken t)
18562 {
18563   ffelexHandler next;
18564   ffelexToken nt;
18565
18566   switch (ffelex_token_type (t))
18567     {
18568     case FFELEX_typeEQUALS:
18569       nt = ffesta_tokens[1];
18570       next = (ffelexHandler) ffestb_V0264_ (nt);
18571       ffelex_token_kill (nt);
18572       return (ffelexHandler) (*next) (t);
18573
18574     default:
18575       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18576                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0263_)))
18577         (ffesta_tokens[1]);
18578       ffelex_token_kill (ffesta_tokens[1]);
18579       return (ffelexHandler) (*next) (t);
18580     }
18581 }
18582
18583 /* ffestb_V0263_ -- "FIND" OPEN_PAREN expr
18584
18585    (ffestb_V0263_)  // to expression handler
18586
18587    Handle COMMA or FIND_PAREN here.  */
18588
18589 static ffelexHandler
18590 ffestb_V0263_ (ffelexToken ft, ffebld expr, ffelexToken t)
18591 {
18592   switch (ffelex_token_type (t))
18593     {
18594     case FFELEX_typeCOMMA:
18595     case FFELEX_typeCLOSE_PAREN:
18596       if (expr == NULL)
18597         break;
18598       ffestp_file.find.find_spec[FFESTP_findixUNIT].kw_or_val_present
18599         = TRUE;
18600       ffestp_file.find.find_spec[FFESTP_findixUNIT].kw_present = FALSE;
18601       ffestp_file.find.find_spec[FFESTP_findixUNIT].value_present = TRUE;
18602       ffestp_file.find.find_spec[FFESTP_findixUNIT].value_is_label
18603         = FALSE;
18604       ffestp_file.find.find_spec[FFESTP_findixUNIT].value
18605         = ffelex_token_use (ft);
18606       ffestp_file.find.find_spec[FFESTP_findixUNIT].u.expr = expr;
18607       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18608         return (ffelexHandler) ffestb_V0264_;
18609       return (ffelexHandler) ffestb_V0269_;
18610
18611     default:
18612       break;
18613     }
18614
18615   ffestb_subr_kill_find_ ();
18616   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18617   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18618 }
18619
18620 /* ffestb_V0264_ -- "FIND" OPEN_PAREN [external-file-unit COMMA]
18621
18622    return ffestb_V0264_;  // to lexer
18623
18624    Handle expr construct (not NAME=expr construct) here.  */
18625
18626 static ffelexHandler
18627 ffestb_V0264_ (ffelexToken t)
18628 {
18629   ffestrGenio kw;
18630
18631   ffestb_local_.find.label = FALSE;
18632
18633   switch (ffelex_token_type (t))
18634     {
18635     case FFELEX_typeNAME:
18636       kw = ffestr_genio (t);
18637       switch (kw)
18638         {
18639         case FFESTR_genioERR:
18640           ffestb_local_.find.ix = FFESTP_findixERR;
18641           ffestb_local_.find.label = TRUE;
18642           break;
18643
18644         case FFESTR_genioIOSTAT:
18645           ffestb_local_.find.ix = FFESTP_findixIOSTAT;
18646           ffestb_local_.find.left = TRUE;
18647           ffestb_local_.find.context = FFEEXPR_contextFILEINT;
18648           break;
18649
18650         case FFESTR_genioREC:
18651           ffestb_local_.find.ix = FFESTP_findixREC;
18652           ffestb_local_.find.left = FALSE;
18653           ffestb_local_.find.context = FFEEXPR_contextFILENUM;
18654           break;
18655
18656         case FFESTR_genioUNIT:
18657           ffestb_local_.find.ix = FFESTP_findixUNIT;
18658           ffestb_local_.find.left = FALSE;
18659           ffestb_local_.find.context = FFEEXPR_contextFILENUM;
18660           break;
18661
18662         default:
18663           goto bad;             /* :::::::::::::::::::: */
18664         }
18665       if (ffestp_file.find.find_spec[ffestb_local_.find.ix]
18666           .kw_or_val_present)
18667         break;                  /* Can't specify a keyword twice! */
18668       ffestp_file.find.find_spec[ffestb_local_.find.ix]
18669         .kw_or_val_present = TRUE;
18670       ffestp_file.find.find_spec[ffestb_local_.find.ix]
18671         .kw_present = TRUE;
18672       ffestp_file.find.find_spec[ffestb_local_.find.ix]
18673         .value_present = FALSE;
18674       ffestp_file.find.find_spec[ffestb_local_.find.ix].value_is_label
18675         = ffestb_local_.find.label;
18676       ffestp_file.find.find_spec[ffestb_local_.find.ix].kw
18677         = ffelex_token_use (t);
18678       return (ffelexHandler) ffestb_V0265_;
18679
18680     default:
18681       break;
18682     }
18683
18684 bad:                            /* :::::::::::::::::::: */
18685   ffestb_subr_kill_find_ ();
18686   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18687   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18688 }
18689
18690 /* ffestb_V0265_ -- "FIND" OPEN_PAREN [external-file-unit COMMA] NAME
18691
18692    return ffestb_V0265_;  // to lexer
18693
18694    Make sure EQUALS here, send next token to expression handler.  */
18695
18696 static ffelexHandler
18697 ffestb_V0265_ (ffelexToken t)
18698 {
18699   switch (ffelex_token_type (t))
18700     {
18701     case FFELEX_typeEQUALS:
18702       ffesta_confirmed ();
18703       if (ffestb_local_.find.label)
18704         return (ffelexHandler) ffestb_V0267_;
18705       if (ffestb_local_.find.left)
18706         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
18707                                             ffestb_local_.find.context,
18708                                             (ffeexprCallback) ffestb_V0266_);
18709       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18710                                           ffestb_local_.find.context,
18711                                           (ffeexprCallback) ffestb_V0266_);
18712
18713     default:
18714       break;
18715     }
18716
18717   ffestb_subr_kill_find_ ();
18718   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18719   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18720 }
18721
18722 /* ffestb_V0266_ -- "FIND" OPEN_PAREN ... NAME EQUALS expr
18723
18724    (ffestb_V0266_)  // to expression handler
18725
18726    Handle COMMA or CLOSE_PAREN here.  */
18727
18728 static ffelexHandler
18729 ffestb_V0266_ (ffelexToken ft, ffebld expr, ffelexToken t)
18730 {
18731   switch (ffelex_token_type (t))
18732     {
18733     case FFELEX_typeCOMMA:
18734     case FFELEX_typeCLOSE_PAREN:
18735       if (expr == NULL)
18736         break;
18737       ffestp_file.find.find_spec[ffestb_local_.find.ix].value_present
18738         = TRUE;
18739       ffestp_file.find.find_spec[ffestb_local_.find.ix].value
18740         = ffelex_token_use (ft);
18741       ffestp_file.find.find_spec[ffestb_local_.find.ix].u.expr = expr;
18742       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18743         return (ffelexHandler) ffestb_V0264_;
18744       return (ffelexHandler) ffestb_V0269_;
18745
18746     default:
18747       break;
18748     }
18749
18750   ffestb_subr_kill_find_ ();
18751   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18752   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18753 }
18754
18755 /* ffestb_V0267_ -- "FIND" OPEN_PAREN ... NAME EQUALS
18756
18757    return ffestb_V0267_;  // to lexer
18758
18759    Handle NUMBER for label here.  */
18760
18761 static ffelexHandler
18762 ffestb_V0267_ (ffelexToken t)
18763 {
18764   switch (ffelex_token_type (t))
18765     {
18766     case FFELEX_typeNUMBER:
18767       ffestp_file.find.find_spec[ffestb_local_.find.ix].value_present
18768         = TRUE;
18769       ffestp_file.find.find_spec[ffestb_local_.find.ix].value
18770         = ffelex_token_use (t);
18771       return (ffelexHandler) ffestb_V0268_;
18772
18773     default:
18774       break;
18775     }
18776
18777   ffestb_subr_kill_find_ ();
18778   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18779   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18780 }
18781
18782 /* ffestb_V0268_ -- "FIND" OPEN_PAREN ... NAME EQUALS NUMBER
18783
18784    return ffestb_V0268_;  // to lexer
18785
18786    Handle COMMA or CLOSE_PAREN here.  */
18787
18788 static ffelexHandler
18789 ffestb_V0268_ (ffelexToken t)
18790 {
18791   switch (ffelex_token_type (t))
18792     {
18793     case FFELEX_typeCOMMA:
18794       return (ffelexHandler) ffestb_V0264_;
18795
18796     case FFELEX_typeCLOSE_PAREN:
18797       return (ffelexHandler) ffestb_V0269_;
18798
18799     default:
18800       break;
18801     }
18802
18803   ffestb_subr_kill_find_ ();
18804   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18805   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18806 }
18807
18808 /* ffestb_V0269_ -- "FIND" OPEN_PAREN ... CLOSE_PAREN
18809
18810    return ffestb_V0269_;  // to lexer
18811
18812    Handle EOS or SEMICOLON here.  */
18813
18814 static ffelexHandler
18815 ffestb_V0269_ (ffelexToken t)
18816 {
18817   switch (ffelex_token_type (t))
18818     {
18819     case FFELEX_typeEOS:
18820     case FFELEX_typeSEMICOLON:
18821       ffesta_confirmed ();
18822       if (!ffesta_is_inhibited ())
18823         ffestc_V026 ();
18824       ffestb_subr_kill_find_ ();
18825       return (ffelexHandler) ffesta_zero (t);
18826
18827     default:
18828       break;
18829     }
18830
18831   ffestb_subr_kill_find_ ();
18832   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18833   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18834 }
18835
18836 #endif
18837 /* ffestb_dimlist -- Parse the ALLOCATABLE/POINTER/TARGET statement
18838
18839    return ffestb_dimlist;  // to lexer
18840
18841    Make sure the statement has a valid form for the ALLOCATABLE/POINTER/
18842    TARGET statement.  If it does, implement the statement.  */
18843
18844 #if FFESTR_F90
18845 ffelexHandler
18846 ffestb_dimlist (ffelexToken t)
18847 {
18848   ffeTokenLength i;
18849   char *p;
18850   ffelexToken nt;
18851   ffelexHandler next;
18852
18853   switch (ffelex_token_type (ffesta_tokens[0]))
18854     {
18855     case FFELEX_typeNAME:
18856       switch (ffelex_token_type (t))
18857         {
18858         case FFELEX_typeCOMMA:
18859         case FFELEX_typeEOS:
18860         case FFELEX_typeSEMICOLON:
18861           ffesta_confirmed ();  /* Error, but clearly intended. */
18862           goto bad_1;           /* :::::::::::::::::::: */
18863
18864         default:
18865           goto bad_1;           /* :::::::::::::::::::: */
18866
18867         case FFELEX_typeCOLONCOLON:
18868           ffesta_confirmed ();
18869           if (!ffesta_is_inhibited ())
18870             {
18871               switch (ffesta_first_kw)
18872                 {
18873                 case FFESTR_firstALLOCATABLE:
18874                   ffestc_R525_start ();
18875                   break;
18876
18877                 case FFESTR_firstPOINTER:
18878                   ffestc_R526_start ();
18879                   break;
18880
18881                 case FFESTR_firstTARGET:
18882                   ffestc_R527_start ();
18883                   break;
18884
18885                 default:
18886                   assert (FALSE);
18887                 }
18888             }
18889           ffestb_local_.dimlist.started = TRUE;
18890           return (ffelexHandler) ffestb_dimlist1_;
18891
18892         case FFELEX_typeNAME:
18893           ffesta_confirmed ();
18894           if (!ffesta_is_inhibited ())
18895             {
18896               switch (ffesta_first_kw)
18897                 {
18898                 case FFESTR_firstALLOCATABLE:
18899                   ffestc_R525_start ();
18900                   break;
18901
18902                 case FFESTR_firstPOINTER:
18903                   ffestc_R526_start ();
18904                   break;
18905
18906                 case FFESTR_firstTARGET:
18907                   ffestc_R527_start ();
18908                   break;
18909
18910                 default:
18911                   assert (FALSE);
18912                 }
18913             }
18914           ffestb_local_.dimlist.started = TRUE;
18915           return (ffelexHandler) ffestb_dimlist1_ (t);
18916         }
18917
18918     case FFELEX_typeNAMES:
18919       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.dimlist.len);
18920       switch (ffelex_token_type (t))
18921         {
18922         default:
18923           goto bad_1;           /* :::::::::::::::::::: */
18924
18925         case FFELEX_typeEOS:
18926         case FFELEX_typeSEMICOLON:
18927         case FFELEX_typeCOMMA:
18928           ffesta_confirmed ();
18929           if (!ffesrc_is_name_init (*p))
18930             goto bad_i;         /* :::::::::::::::::::: */
18931           nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
18932           if (!ffesta_is_inhibited ())
18933             {
18934               switch (ffesta_first_kw)
18935                 {
18936                 case FFESTR_firstALLOCATABLE:
18937                   ffestc_R525_start ();
18938                   break;
18939
18940                 case FFESTR_firstPOINTER:
18941                   ffestc_R526_start ();
18942                   break;
18943
18944                 case FFESTR_firstTARGET:
18945                   ffestc_R527_start ();
18946                   break;
18947
18948                 default:
18949                   assert (FALSE);
18950                 }
18951             }
18952           ffestb_local_.dimlist.started = TRUE;
18953           next = (ffelexHandler) ffestb_dimlist1_ (nt);
18954           ffelex_token_kill (nt);
18955           return (ffelexHandler) (*next) (t);
18956
18957         case FFELEX_typeCOLONCOLON:
18958           ffesta_confirmed ();
18959           if (*p != '\0')
18960             goto bad_i;         /* :::::::::::::::::::: */
18961           if (!ffesta_is_inhibited ())
18962             {
18963               switch (ffesta_first_kw)
18964                 {
18965                 case FFESTR_firstALLOCATABLE:
18966                   ffestc_R525_start ();
18967                   break;
18968
18969                 case FFESTR_firstPOINTER:
18970                   ffestc_R526_start ();
18971                   break;
18972
18973                 case FFESTR_firstTARGET:
18974                   ffestc_R527_start ();
18975                   break;
18976
18977                 default:
18978                   assert (FALSE);
18979                 }
18980             }
18981           ffestb_local_.dimlist.started = TRUE;
18982           return (ffelexHandler) ffestb_dimlist1_;
18983
18984         case FFELEX_typeOPEN_PAREN:
18985           if (!ffesrc_is_name_init (*p))
18986             goto bad_i;         /* :::::::::::::::::::: */
18987           nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
18988           ffestb_local_.dimlist.started = FALSE;
18989           next = (ffelexHandler) ffestb_dimlist1_ (nt);
18990           ffelex_token_kill (nt);
18991           return (ffelexHandler) (*next) (t);
18992         }
18993
18994     default:
18995       goto bad_0;               /* :::::::::::::::::::: */
18996     }
18997
18998 bad_0:                          /* :::::::::::::::::::: */
18999   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, ffesta_tokens[0]);
19000   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19001
19002 bad_1:                          /* :::::::::::::::::::: */
19003   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19004   return (ffelexHandler) ffelex_swallow_tokens (t,
19005                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
19006
19007 bad_i:                          /* :::::::::::::::::::: */
19008   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, ffesta_tokens[0], i, t);
19009   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19010 }
19011
19012 /* ffestb_dimlist1_ -- "ALLOCATABLE/POINTER/TARGET" [COLONCOLON]
19013
19014    return ffestb_dimlist1_;  // to lexer
19015
19016    Handle NAME.  */
19017
19018 static ffelexHandler
19019 ffestb_dimlist1_ (ffelexToken t)
19020 {
19021   switch (ffelex_token_type (t))
19022     {
19023     case FFELEX_typeNAME:
19024       ffesta_tokens[1] = ffelex_token_use (t);
19025       return (ffelexHandler) ffestb_dimlist2_;
19026
19027     default:
19028       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19029       break;
19030     }
19031
19032   if (!ffesta_is_inhibited ())
19033     {
19034       switch (ffesta_first_kw)
19035         {
19036         case FFESTR_firstALLOCATABLE:
19037           ffestc_R525_finish ();
19038           break;
19039
19040         case FFESTR_firstPOINTER:
19041           ffestc_R526_finish ();
19042           break;
19043
19044         case FFESTR_firstTARGET:
19045           ffestc_R527_finish ();
19046           break;
19047
19048         default:
19049           assert (FALSE);
19050         }
19051     }
19052   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19053 }
19054
19055 /* ffestb_dimlist2_ -- "ALLOCATABLE/POINTER/TARGET" ... NAME
19056
19057    return ffestb_dimlist2_;  // to lexer
19058
19059    Handle OPEN_PAREN.  */
19060
19061 static ffelexHandler
19062 ffestb_dimlist2_ (ffelexToken t)
19063 {
19064   switch (ffelex_token_type (t))
19065     {
19066     case FFELEX_typeOPEN_PAREN:
19067       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
19068       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_dimlist3_;
19069       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
19070       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLIST;
19071 #ifdef FFECOM_dimensionsMAX
19072       ffestb_subrargs_.dim_list.ndims = 0;
19073 #endif
19074       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
19075             FFEEXPR_contextDIMLIST, (ffeexprCallback) ffestb_subr_dimlist_);
19076
19077     case FFELEX_typeCOMMA:
19078       ffesta_confirmed ();
19079       if (!ffesta_is_inhibited ())
19080         {
19081           if (!ffestb_local_.dimlist.started)
19082             {
19083               switch (ffesta_first_kw)
19084                 {
19085                 case FFESTR_firstALLOCATABLE:
19086                   ffestc_R525_start ();
19087                   break;
19088
19089                 case FFESTR_firstPOINTER:
19090                   ffestc_R526_start ();
19091                   break;
19092
19093                 case FFESTR_firstTARGET:
19094                   ffestc_R527_start ();
19095                   break;
19096
19097                 default:
19098                   assert (FALSE);
19099                 }
19100               ffestb_local_.dimlist.started = TRUE;
19101             }
19102           switch (ffesta_first_kw)
19103             {
19104             case FFESTR_firstALLOCATABLE:
19105               ffestc_R525_item (ffesta_tokens[1], NULL);
19106               break;
19107
19108             case FFESTR_firstPOINTER:
19109               ffestc_R526_item (ffesta_tokens[1], NULL);
19110               break;
19111
19112             case FFESTR_firstTARGET:
19113               ffestc_R527_item (ffesta_tokens[1], NULL);
19114               break;
19115
19116             default:
19117               assert (FALSE);
19118             }
19119         }
19120       ffelex_token_kill (ffesta_tokens[1]);
19121       return (ffelexHandler) ffestb_dimlist4_;
19122
19123     case FFELEX_typeEOS:
19124     case FFELEX_typeSEMICOLON:
19125       ffesta_confirmed ();
19126       if (!ffesta_is_inhibited ())
19127         {
19128           if (!ffestb_local_.dimlist.started)
19129             {
19130               switch (ffesta_first_kw)
19131                 {
19132                 case FFESTR_firstALLOCATABLE:
19133                   ffestc_R525_start ();
19134                   break;
19135
19136                 case FFESTR_firstPOINTER:
19137                   ffestc_R526_start ();
19138                   break;
19139
19140                 case FFESTR_firstTARGET:
19141                   ffestc_R527_start ();
19142                   break;
19143
19144                 default:
19145                   assert (FALSE);
19146                 }
19147             }
19148           switch (ffesta_first_kw)
19149             {
19150             case FFESTR_firstALLOCATABLE:
19151               ffestc_R525_item (ffesta_tokens[1], NULL);
19152               ffestc_R525_finish ();
19153               break;
19154
19155             case FFESTR_firstPOINTER:
19156               ffestc_R526_item (ffesta_tokens[1], NULL);
19157               ffestc_R526_finish ();
19158               break;
19159
19160             case FFESTR_firstTARGET:
19161               ffestc_R527_item (ffesta_tokens[1], NULL);
19162               ffestc_R527_finish ();
19163               break;
19164
19165             default:
19166               assert (FALSE);
19167             }
19168         }
19169       ffelex_token_kill (ffesta_tokens[1]);
19170       return (ffelexHandler) ffesta_zero (t);
19171
19172     default:
19173       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19174       break;
19175     }
19176
19177   if (!ffesta_is_inhibited ())
19178     {
19179       switch (ffesta_first_kw)
19180         {
19181         case FFESTR_firstALLOCATABLE:
19182           ffestc_R525_finish ();
19183           break;
19184
19185         case FFESTR_firstPOINTER:
19186           ffestc_R526_finish ();
19187           break;
19188
19189         case FFESTR_firstTARGET:
19190           ffestc_R527_finish ();
19191           break;
19192
19193         default:
19194           assert (FALSE);
19195         }
19196     }
19197   ffelex_token_kill (ffesta_tokens[1]);
19198   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19199 }
19200
19201 /* ffestb_dimlist3_ -- "ALLOCATABLE/POINTER/TARGET" ... NAME OPEN_PAREN
19202                        dimlist CLOSE_PAREN
19203
19204    return ffestb_dimlist3_;  // to lexer
19205
19206    Handle COMMA or EOS/SEMICOLON.  */
19207
19208 static ffelexHandler
19209 ffestb_dimlist3_ (ffelexToken t)
19210 {
19211   if (!ffestb_subrargs_.dim_list.ok)
19212     goto bad;                   /* :::::::::::::::::::: */
19213
19214   switch (ffelex_token_type (t))
19215     {
19216     case FFELEX_typeCOMMA:
19217       ffesta_confirmed ();
19218       if (!ffesta_is_inhibited ())
19219         {
19220           if (!ffestb_local_.dimlist.started)
19221             {
19222               switch (ffesta_first_kw)
19223                 {
19224                 case FFESTR_firstALLOCATABLE:
19225                   ffestc_R525_start ();
19226                   break;
19227
19228                 case FFESTR_firstPOINTER:
19229                   ffestc_R526_start ();
19230                   break;
19231
19232                 case FFESTR_firstTARGET:
19233                   ffestc_R527_start ();
19234                   break;
19235
19236                 default:
19237                   assert (FALSE);
19238                 }
19239               ffestb_local_.dimlist.started = TRUE;
19240             }
19241           switch (ffesta_first_kw)
19242             {
19243             case FFESTR_firstALLOCATABLE:
19244               ffestc_R525_item (ffesta_tokens[1],
19245                                 ffestb_subrargs_.dim_list.dims);
19246               break;
19247
19248             case FFESTR_firstPOINTER:
19249               ffestc_R526_item (ffesta_tokens[1],
19250                                 ffestb_subrargs_.dim_list.dims);
19251               break;
19252
19253             case FFESTR_firstTARGET:
19254               ffestc_R527_item (ffesta_tokens[1],
19255                                 ffestb_subrargs_.dim_list.dims);
19256               break;
19257
19258             default:
19259               assert (FALSE);
19260             }
19261         }
19262       ffelex_token_kill (ffesta_tokens[1]);
19263       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19264       return (ffelexHandler) ffestb_dimlist4_;
19265
19266     case FFELEX_typeEOS:
19267     case FFELEX_typeSEMICOLON:
19268       ffesta_confirmed ();
19269       if (!ffesta_is_inhibited ())
19270         {
19271           if (!ffestb_local_.dimlist.started)
19272             {
19273               switch (ffesta_first_kw)
19274                 {
19275                 case FFESTR_firstALLOCATABLE:
19276                   ffestc_R525_start ();
19277                   break;
19278
19279                 case FFESTR_firstPOINTER:
19280                   ffestc_R526_start ();
19281                   break;
19282
19283                 case FFESTR_firstTARGET:
19284                   ffestc_R527_start ();
19285                   break;
19286
19287                 default:
19288                   assert (FALSE);
19289                 }
19290             }
19291           switch (ffesta_first_kw)
19292             {
19293             case FFESTR_firstALLOCATABLE:
19294               ffestc_R525_item (ffesta_tokens[1],
19295                                 ffestb_subrargs_.dim_list.dims);
19296               ffestc_R525_finish ();
19297               break;
19298
19299             case FFESTR_firstPOINTER:
19300               ffestc_R526_item (ffesta_tokens[1],
19301                                 ffestb_subrargs_.dim_list.dims);
19302               ffestc_R526_finish ();
19303               break;
19304
19305             case FFESTR_firstTARGET:
19306               ffestc_R527_item (ffesta_tokens[1],
19307                                 ffestb_subrargs_.dim_list.dims);
19308               ffestc_R527_finish ();
19309               break;
19310
19311             default:
19312               assert (FALSE);
19313             }
19314         }
19315       ffelex_token_kill (ffesta_tokens[1]);
19316       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19317       return (ffelexHandler) ffesta_zero (t);
19318
19319     default:
19320       break;
19321     }
19322
19323 bad:                            /* :::::::::::::::::::: */
19324   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19325   if (ffestb_local_.dimlist.started && !ffesta_is_inhibited ())
19326     {
19327       switch (ffesta_first_kw)
19328         {
19329         case FFESTR_firstALLOCATABLE:
19330           ffestc_R525_finish ();
19331           break;
19332
19333         case FFESTR_firstPOINTER:
19334           ffestc_R526_finish ();
19335           break;
19336
19337         case FFESTR_firstTARGET:
19338           ffestc_R527_finish ();
19339           break;
19340
19341         default:
19342           assert (FALSE);
19343         }
19344     }
19345   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19346   ffelex_token_kill (ffesta_tokens[1]);
19347   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19348 }
19349
19350 /* ffestb_dimlist4_ -- "ALLOCATABLE/POINTER/TARGET" ... COMMA
19351
19352    return ffestb_dimlist4_;  // to lexer
19353
19354    Make sure we don't have EOS or SEMICOLON.  */
19355
19356 static ffelexHandler
19357 ffestb_dimlist4_ (ffelexToken t)
19358 {
19359   switch (ffelex_token_type (t))
19360     {
19361     case FFELEX_typeEOS:
19362     case FFELEX_typeSEMICOLON:
19363       if (!ffesta_is_inhibited ())
19364         {
19365           switch (ffesta_first_kw)
19366             {
19367             case FFESTR_firstALLOCATABLE:
19368               ffestc_R525_finish ();
19369               break;
19370
19371             case FFESTR_firstPOINTER:
19372               ffestc_R526_finish ();
19373               break;
19374
19375             case FFESTR_firstTARGET:
19376               ffestc_R527_finish ();
19377               break;
19378
19379             default:
19380               assert (FALSE);
19381             }
19382         }
19383       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19384       return (ffelexHandler) ffesta_zero (t);
19385
19386     default:
19387       return (ffelexHandler) ffestb_dimlist1_ (t);
19388     }
19389 }
19390
19391 #endif
19392 /* ffestb_dummy -- Parse an ENTRY/FUNCTION/SUBROUTINE statement
19393
19394    return ffestb_dummy;  // to lexer
19395
19396    Make sure the statement has a valid form for an ENTRY/FUNCTION/SUBROUTINE
19397    statement.  If it does, implement the statement.  */
19398
19399 ffelexHandler
19400 ffestb_dummy (ffelexToken t)
19401 {
19402   ffeTokenLength i;
19403   char *p;
19404
19405   switch (ffelex_token_type (ffesta_tokens[0]))
19406     {
19407     case FFELEX_typeNAME:
19408       switch (ffelex_token_type (t))
19409         {
19410         case FFELEX_typeEOS:
19411         case FFELEX_typeSEMICOLON:
19412         case FFELEX_typeCOMMA:
19413         case FFELEX_typeCOLONCOLON:
19414           ffesta_confirmed ();  /* Error, but clearly intended. */
19415           goto bad_1;           /* :::::::::::::::::::: */
19416
19417         default:
19418           goto bad_1;           /* :::::::::::::::::::: */
19419
19420         case FFELEX_typeNAME:
19421           break;
19422         }
19423
19424       ffesta_confirmed ();
19425       ffesta_tokens[1] = ffelex_token_use (t);
19426       ffestb_local_.decl.recursive = NULL;
19427       ffestb_local_.dummy.badname = ffestb_args.dummy.badname;
19428       ffestb_local_.dummy.is_subr = ffestb_args.dummy.is_subr;
19429       ffestb_local_.dummy.first_kw = ffesta_first_kw;
19430       return (ffelexHandler) ffestb_dummy1_;
19431
19432     case FFELEX_typeNAMES:
19433       switch (ffelex_token_type (t))
19434         {
19435         case FFELEX_typeCOMMA:
19436         case FFELEX_typeCOLONCOLON:
19437           ffesta_confirmed ();  /* Error, but clearly intended. */
19438           goto bad_1;           /* :::::::::::::::::::: */
19439
19440         default:
19441           goto bad_1;           /* :::::::::::::::::::: */
19442
19443         case FFELEX_typeEOS:
19444         case FFELEX_typeSEMICOLON:
19445           ffesta_confirmed ();
19446           break;
19447
19448         case FFELEX_typeOPEN_PAREN:
19449           break;
19450         }
19451       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.dummy.len);
19452       if (!ffesrc_is_name_init (*p))
19453         goto bad_i;             /* :::::::::::::::::::: */
19454       ffesta_tokens[1]
19455         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
19456       ffestb_local_.decl.recursive = NULL;
19457       ffestb_local_.dummy.badname = ffestb_args.dummy.badname;
19458       ffestb_local_.dummy.is_subr = ffestb_args.dummy.is_subr;
19459       ffestb_local_.dummy.first_kw = ffesta_first_kw;
19460       return (ffelexHandler) ffestb_dummy1_ (t);
19461
19462     default:
19463       goto bad_0;               /* :::::::::::::::::::: */
19464     }
19465
19466 bad_0:                          /* :::::::::::::::::::: */
19467   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, ffesta_tokens[0]);
19468   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19469
19470 bad_1:                          /* :::::::::::::::::::: */
19471   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, t);
19472   return (ffelexHandler) ffelex_swallow_tokens (t,
19473                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
19474
19475 bad_i:                          /* :::::::::::::::::::: */
19476   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, ffesta_tokens[0], i, t);
19477   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19478 }
19479
19480 /* ffestb_dummy1_ -- "ENTRY/FUNCTION/SUBROUTINE" NAME
19481
19482    return ffestb_dummy1_;  // to lexer
19483
19484    Make sure the next token is an EOS, SEMICOLON, or OPEN_PAREN.  In the
19485    former case, just implement a null arg list, else get the arg list and
19486    then implement.  */
19487
19488 static ffelexHandler
19489 ffestb_dummy1_ (ffelexToken t)
19490 {
19491   switch (ffelex_token_type (t))
19492     {
19493     case FFELEX_typeEOS:
19494     case FFELEX_typeSEMICOLON:
19495       if (ffestb_local_.dummy.first_kw == FFESTR_firstFUNCTION)
19496         {
19497           ffesta_confirmed ();  /* Later, not if typename w/o RECURSIVE. */
19498           break;                /* Produce an error message, need that open
19499                                    paren. */
19500         }
19501       ffesta_confirmed ();
19502       if (!ffesta_is_inhibited ())
19503         {                       /* Pretend as though we got a truly NULL
19504                                    list. */
19505           ffestb_subrargs_.name_list.args = NULL;
19506           ffestb_subrargs_.name_list.ok = TRUE;
19507           ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
19508           return (ffelexHandler) ffestb_dummy2_ (t);
19509         }
19510       if (ffestb_local_.decl.recursive != NULL)
19511         ffelex_token_kill (ffestb_local_.decl.recursive);
19512       ffelex_token_kill (ffesta_tokens[1]);
19513       return (ffelexHandler) ffesta_zero (t);
19514
19515     case FFELEX_typeOPEN_PAREN:
19516       ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
19517       ffestb_subrargs_.name_list.handler = (ffelexHandler) ffestb_dummy2_;
19518       ffestb_subrargs_.name_list.is_subr = ffestb_local_.dummy.is_subr;
19519       ffestb_subrargs_.name_list.names = FALSE;
19520       return (ffelexHandler) ffestb_subr_name_list_;
19521
19522     default:
19523       break;
19524     }
19525
19526   if (ffestb_local_.decl.recursive != NULL)
19527     ffelex_token_kill (ffestb_local_.decl.recursive);
19528   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_local_.dummy.badname, t);
19529   ffelex_token_kill (ffesta_tokens[1]);
19530   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19531 }
19532
19533 /* ffestb_dummy2_ -- <dummy-keyword> NAME OPEN_PAREN arg-list CLOSE_PAREN
19534
19535    return ffestb_dummy2_;  // to lexer
19536
19537    Make sure the statement has a valid form for a dummy-def statement.  If it
19538    does, implement the statement.  */
19539
19540 static ffelexHandler
19541 ffestb_dummy2_ (ffelexToken t)
19542 {
19543   if (!ffestb_subrargs_.name_list.ok)
19544     goto bad;                   /* :::::::::::::::::::: */
19545
19546   switch (ffelex_token_type (t))
19547     {
19548     case FFELEX_typeEOS:
19549     case FFELEX_typeSEMICOLON:
19550       ffesta_confirmed ();
19551       if (!ffesta_is_inhibited ())
19552         {
19553           switch (ffestb_local_.dummy.first_kw)
19554             {
19555             case FFESTR_firstFUNCTION:
19556               ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
19557                     ffestb_subrargs_.name_list.close_paren, FFESTP_typeNone,
19558                 NULL, NULL, NULL, NULL, ffestb_local_.decl.recursive, NULL);
19559               break;
19560
19561             case FFESTR_firstSUBROUTINE:
19562               ffestc_R1223 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
19563                             ffestb_subrargs_.name_list.close_paren,
19564                             ffestb_local_.decl.recursive);
19565               break;
19566
19567             case FFESTR_firstENTRY:
19568               ffestc_R1226 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
19569                             ffestb_subrargs_.name_list.close_paren);
19570               break;
19571
19572             default:
19573               assert (FALSE);
19574             }
19575         }
19576       ffelex_token_kill (ffesta_tokens[1]);
19577       if (ffestb_local_.decl.recursive != NULL)
19578         ffelex_token_kill (ffestb_local_.decl.recursive);
19579       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
19580       if (ffestb_subrargs_.name_list.args != NULL)
19581         ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
19582       return (ffelexHandler) ffesta_zero (t);
19583
19584     case FFELEX_typeNAME:
19585       ffesta_confirmed ();
19586       if ((ffestb_local_.dummy.first_kw != FFESTR_firstFUNCTION)
19587           || (ffestr_other (t) != FFESTR_otherRESULT))
19588         break;
19589       ffestb_local_.decl.type = FFESTP_typeNone;
19590       ffestb_local_.decl.kind = NULL;
19591       ffestb_local_.decl.kindt = NULL;
19592       ffestb_local_.decl.len = NULL;
19593       ffestb_local_.decl.lent = NULL;
19594       return (ffelexHandler) ffestb_decl_funcname_6_;
19595
19596     default:
19597       break;
19598     }
19599
19600 bad:                            /* :::::::::::::::::::: */
19601   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_local_.dummy.badname, t);
19602   ffelex_token_kill (ffesta_tokens[1]);
19603   if (ffestb_local_.decl.recursive != NULL)
19604     ffelex_token_kill (ffestb_local_.decl.recursive);
19605   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
19606   if (ffestb_subrargs_.name_list.args != NULL)
19607     ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
19608   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19609 }
19610
19611 /* ffestb_R524 -- Parse the DIMENSION statement
19612
19613    return ffestb_R524;  // to lexer
19614
19615    Make sure the statement has a valid form for the DIMENSION statement.  If
19616    it does, implement the statement.  */
19617
19618 ffelexHandler
19619 ffestb_R524 (ffelexToken t)
19620 {
19621   ffeTokenLength i;
19622   char *p;
19623   ffelexToken nt;
19624   ffelexHandler next;
19625
19626   switch (ffelex_token_type (ffesta_tokens[0]))
19627     {
19628     case FFELEX_typeNAME:
19629       switch (ffelex_token_type (t))
19630         {
19631         case FFELEX_typeCOMMA:
19632         case FFELEX_typeCOLONCOLON:
19633         case FFELEX_typeEOS:
19634         case FFELEX_typeSEMICOLON:
19635           ffesta_confirmed ();  /* Error, but clearly intended. */
19636           goto bad_1;           /* :::::::::::::::::::: */
19637
19638         default:
19639           goto bad_1;           /* :::::::::::::::::::: */
19640
19641         case FFELEX_typeNAME:
19642           ffesta_confirmed ();
19643           if (!ffesta_is_inhibited ())
19644             ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
19645           ffestb_local_.dimension.started = TRUE;
19646           return (ffelexHandler) ffestb_R5241_ (t);
19647         }
19648
19649     case FFELEX_typeNAMES:
19650       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.R524.len);
19651       switch (ffelex_token_type (t))
19652         {
19653         default:
19654           goto bad_1;           /* :::::::::::::::::::: */
19655
19656         case FFELEX_typeEOS:
19657         case FFELEX_typeSEMICOLON:
19658         case FFELEX_typeCOMMA:
19659         case FFELEX_typeCOLONCOLON:
19660           ffesta_confirmed ();
19661           goto bad_1;           /* :::::::::::::::::::: */
19662
19663         case FFELEX_typeOPEN_PAREN:
19664           break;
19665         }
19666
19667       /* Here, we have at least one char after "DIMENSION" and t is
19668          OPEN_PAREN. */
19669
19670       if (!ffesrc_is_name_init (*p))
19671         goto bad_i;             /* :::::::::::::::::::: */
19672       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
19673       ffestb_local_.dimension.started = FALSE;
19674       next = (ffelexHandler) ffestb_R5241_ (nt);
19675       ffelex_token_kill (nt);
19676       return (ffelexHandler) (*next) (t);
19677
19678     default:
19679       goto bad_0;               /* :::::::::::::::::::: */
19680     }
19681
19682 bad_0:                          /* :::::::::::::::::::: */
19683   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, ffesta_tokens[0]);
19684   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19685
19686 bad_1:                          /* :::::::::::::::::::: */
19687   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19688   return (ffelexHandler) ffelex_swallow_tokens (t,
19689                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
19690
19691 bad_i:                          /* :::::::::::::::::::: */
19692   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, ffesta_tokens[0], i, t);
19693   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19694 }
19695
19696 /* ffestb_R5241_ -- "DIMENSION"
19697
19698    return ffestb_R5241_;  // to lexer
19699
19700    Handle NAME.  */
19701
19702 static ffelexHandler
19703 ffestb_R5241_ (ffelexToken t)
19704 {
19705   switch (ffelex_token_type (t))
19706     {
19707     case FFELEX_typeNAME:
19708       ffesta_tokens[1] = ffelex_token_use (t);
19709       return (ffelexHandler) ffestb_R5242_;
19710
19711     default:
19712       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19713       break;
19714     }
19715
19716   if (!ffesta_is_inhibited ())
19717     ffestc_R524_finish ();
19718   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19719 }
19720
19721 /* ffestb_R5242_ -- "DIMENSION" ... NAME
19722
19723    return ffestb_R5242_;  // to lexer
19724
19725    Handle OPEN_PAREN.  */
19726
19727 static ffelexHandler
19728 ffestb_R5242_ (ffelexToken t)
19729 {
19730   switch (ffelex_token_type (t))
19731     {
19732     case FFELEX_typeOPEN_PAREN:
19733       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
19734       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_R5243_;
19735       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
19736       ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
19737         ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
19738 #ifdef FFECOM_dimensionsMAX
19739       ffestb_subrargs_.dim_list.ndims = 0;
19740 #endif
19741       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
19742                                           ffestb_subrargs_.dim_list.ctx,
19743                                     (ffeexprCallback) ffestb_subr_dimlist_);
19744
19745     default:
19746       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19747       break;
19748     }
19749
19750   if (!ffesta_is_inhibited ())
19751     ffestc_R524_finish ();
19752   ffelex_token_kill (ffesta_tokens[1]);
19753   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19754 }
19755
19756 /* ffestb_R5243_ -- "DIMENSION" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
19757
19758    return ffestb_R5243_;  // to lexer
19759
19760    Handle COMMA or EOS/SEMICOLON.  */
19761
19762 static ffelexHandler
19763 ffestb_R5243_ (ffelexToken t)
19764 {
19765   if (!ffestb_subrargs_.dim_list.ok)
19766     goto bad;                   /* :::::::::::::::::::: */
19767
19768   switch (ffelex_token_type (t))
19769     {
19770     case FFELEX_typeCOMMA:
19771       ffesta_confirmed ();
19772       if (!ffesta_is_inhibited ())
19773         {
19774           if (!ffestb_local_.dimension.started)
19775             {
19776               ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
19777               ffestb_local_.dimension.started = TRUE;
19778             }
19779           ffestc_R524_item (ffesta_tokens[1],
19780                             ffestb_subrargs_.dim_list.dims);
19781         }
19782       ffelex_token_kill (ffesta_tokens[1]);
19783       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19784       return (ffelexHandler) ffestb_R5244_;
19785
19786     case FFELEX_typeEOS:
19787     case FFELEX_typeSEMICOLON:
19788       ffesta_confirmed ();
19789       if (!ffesta_is_inhibited ())
19790         {
19791           if (!ffestb_local_.dimension.started)
19792             {
19793               ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
19794               ffestb_local_.dimension.started = TRUE;
19795             }
19796           ffestc_R524_item (ffesta_tokens[1],
19797                             ffestb_subrargs_.dim_list.dims);
19798           ffestc_R524_finish ();
19799         }
19800       ffelex_token_kill (ffesta_tokens[1]);
19801       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19802       return (ffelexHandler) ffesta_zero (t);
19803
19804     default:
19805       break;
19806     }
19807
19808 bad:                            /* :::::::::::::::::::: */
19809   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19810   if (ffestb_local_.dimension.started && !ffesta_is_inhibited ())
19811     ffestc_R524_finish ();
19812   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19813   ffelex_token_kill (ffesta_tokens[1]);
19814   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19815 }
19816
19817 /* ffestb_R5244_ -- "DIMENSION" ... COMMA
19818
19819    return ffestb_R5244_;  // to lexer
19820
19821    Make sure we don't have EOS or SEMICOLON.  */
19822
19823 static ffelexHandler
19824 ffestb_R5244_ (ffelexToken t)
19825 {
19826   switch (ffelex_token_type (t))
19827     {
19828     case FFELEX_typeEOS:
19829     case FFELEX_typeSEMICOLON:
19830       if (!ffesta_is_inhibited ())
19831         ffestc_R524_finish ();
19832       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19833       return (ffelexHandler) ffesta_zero (t);
19834
19835     default:
19836       return (ffelexHandler) ffestb_R5241_ (t);
19837     }
19838 }
19839
19840 /* ffestb_R547 -- Parse the COMMON statement
19841
19842    return ffestb_R547;  // to lexer
19843
19844    Make sure the statement has a valid form for the COMMON statement.  If it
19845    does, implement the statement.  */
19846
19847 ffelexHandler
19848 ffestb_R547 (ffelexToken t)
19849 {
19850   ffeTokenLength i;
19851   char *p;
19852   ffelexToken nt;
19853   ffelexHandler next;
19854
19855   switch (ffelex_token_type (ffesta_tokens[0]))
19856     {
19857     case FFELEX_typeNAME:
19858       if (ffesta_first_kw != FFESTR_firstCOMMON)
19859         goto bad_0;             /* :::::::::::::::::::: */
19860       switch (ffelex_token_type (t))
19861         {
19862         case FFELEX_typeCOMMA:
19863         case FFELEX_typeCOLONCOLON:
19864         case FFELEX_typeEOS:
19865         case FFELEX_typeSEMICOLON:
19866           ffesta_confirmed ();  /* Error, but clearly intended. */
19867           goto bad_1;           /* :::::::::::::::::::: */
19868
19869         default:
19870           goto bad_1;           /* :::::::::::::::::::: */
19871
19872         case FFELEX_typeNAME:
19873         case FFELEX_typeSLASH:
19874         case FFELEX_typeCONCAT:
19875           ffesta_confirmed ();
19876           if (!ffesta_is_inhibited ())
19877             ffestc_R547_start ();
19878           ffestb_local_.common.started = TRUE;
19879           return (ffelexHandler) ffestb_R5471_ (t);
19880         }
19881
19882     case FFELEX_typeNAMES:
19883       if (ffesta_first_kw != FFESTR_firstCOMMON)
19884         goto bad_0;             /* :::::::::::::::::::: */
19885       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCOMMON);
19886       switch (ffelex_token_type (t))
19887         {
19888         default:
19889           goto bad_1;           /* :::::::::::::::::::: */
19890
19891         case FFELEX_typeEOS:
19892         case FFELEX_typeSEMICOLON:
19893         case FFELEX_typeCOMMA:
19894         case FFELEX_typeCOLONCOLON:
19895           ffesta_confirmed ();
19896           break;
19897
19898         case FFELEX_typeSLASH:
19899         case FFELEX_typeCONCAT:
19900           ffesta_confirmed ();
19901           if (*p != '\0')
19902             break;
19903           if (!ffesta_is_inhibited ())
19904             ffestc_R547_start ();
19905           ffestb_local_.common.started = TRUE;
19906           return (ffelexHandler) ffestb_R5471_ (t);
19907
19908         case FFELEX_typeOPEN_PAREN:
19909           break;
19910         }
19911
19912       /* Here, we have at least one char after "COMMON" and t is COMMA,
19913          EOS/SEMICOLON, OPEN_PAREN, SLASH, or CONCAT. */
19914
19915       if (!ffesrc_is_name_init (*p))
19916         goto bad_i;             /* :::::::::::::::::::: */
19917       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
19918       if (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN)
19919         ffestb_local_.common.started = FALSE;
19920       else
19921         {
19922           if (!ffesta_is_inhibited ())
19923             ffestc_R547_start ();
19924           ffestb_local_.common.started = TRUE;
19925         }
19926       next = (ffelexHandler) ffestb_R5471_ (nt);
19927       ffelex_token_kill (nt);
19928       return (ffelexHandler) (*next) (t);
19929
19930     default:
19931       goto bad_0;               /* :::::::::::::::::::: */
19932     }
19933
19934 bad_0:                          /* :::::::::::::::::::: */
19935   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", ffesta_tokens[0]);
19936   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19937
19938 bad_1:                          /* :::::::::::::::::::: */
19939   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
19940   return (ffelexHandler) ffelex_swallow_tokens (t,
19941                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
19942
19943 bad_i:                          /* :::::::::::::::::::: */
19944   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "COMMON", ffesta_tokens[0], i, t);
19945   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19946 }
19947
19948 /* ffestb_R5471_ -- "COMMON"
19949
19950    return ffestb_R5471_;  // to lexer
19951
19952    Handle NAME, SLASH, or CONCAT.  */
19953
19954 static ffelexHandler
19955 ffestb_R5471_ (ffelexToken t)
19956 {
19957   switch (ffelex_token_type (t))
19958     {
19959     case FFELEX_typeNAME:
19960       return (ffelexHandler) ffestb_R5474_ (t);
19961
19962     case FFELEX_typeSLASH:
19963       return (ffelexHandler) ffestb_R5472_;
19964
19965     case FFELEX_typeCONCAT:
19966       if (!ffesta_is_inhibited ())
19967         ffestc_R547_item_cblock (NULL);
19968       return (ffelexHandler) ffestb_R5474_;
19969
19970     default:
19971       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
19972       break;
19973     }
19974
19975   if (!ffesta_is_inhibited ())
19976     ffestc_R547_finish ();
19977   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19978 }
19979
19980 /* ffestb_R5472_ -- "COMMON" SLASH
19981
19982    return ffestb_R5472_;  // to lexer
19983
19984    Handle NAME.  */
19985
19986 static ffelexHandler
19987 ffestb_R5472_ (ffelexToken t)
19988 {
19989   switch (ffelex_token_type (t))
19990     {
19991     case FFELEX_typeNAME:
19992       ffesta_tokens[1] = ffelex_token_use (t);
19993       return (ffelexHandler) ffestb_R5473_;
19994
19995     case FFELEX_typeSLASH:
19996       if (!ffesta_is_inhibited ())
19997         ffestc_R547_item_cblock (NULL);
19998       return (ffelexHandler) ffestb_R5474_;
19999
20000     default:
20001       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20002       break;
20003     }
20004
20005   if (!ffesta_is_inhibited ())
20006     ffestc_R547_finish ();
20007   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20008 }
20009
20010 /* ffestb_R5473_ -- "COMMON" SLASH NAME
20011
20012    return ffestb_R5473_;  // to lexer
20013
20014    Handle SLASH.  */
20015
20016 static ffelexHandler
20017 ffestb_R5473_ (ffelexToken t)
20018 {
20019   switch (ffelex_token_type (t))
20020     {
20021     case FFELEX_typeSLASH:
20022       if (!ffesta_is_inhibited ())
20023         ffestc_R547_item_cblock (ffesta_tokens[1]);
20024       ffelex_token_kill (ffesta_tokens[1]);
20025       return (ffelexHandler) ffestb_R5474_;
20026
20027     default:
20028       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20029       break;
20030     }
20031
20032   if (!ffesta_is_inhibited ())
20033     ffestc_R547_finish ();
20034   ffelex_token_kill (ffesta_tokens[1]);
20035   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20036 }
20037
20038 /* ffestb_R5474_ -- "COMMON" [SLASH NAME SLASH] or "COMMON" CONCAT
20039
20040    return ffestb_R5474_;  // to lexer
20041
20042    Handle NAME.  */
20043
20044 static ffelexHandler
20045 ffestb_R5474_ (ffelexToken t)
20046 {
20047   switch (ffelex_token_type (t))
20048     {
20049     case FFELEX_typeNAME:
20050       ffesta_tokens[1] = ffelex_token_use (t);
20051       return (ffelexHandler) ffestb_R5475_;
20052
20053     default:
20054       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20055       break;
20056     }
20057
20058   if (!ffesta_is_inhibited ())
20059     ffestc_R547_finish ();
20060   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20061 }
20062
20063 /* ffestb_R5475_ -- "COMMON" ... NAME
20064
20065    return ffestb_R5475_;  // to lexer
20066
20067    Handle OPEN_PAREN.  */
20068
20069 static ffelexHandler
20070 ffestb_R5475_ (ffelexToken t)
20071 {
20072   switch (ffelex_token_type (t))
20073     {
20074     case FFELEX_typeOPEN_PAREN:
20075       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
20076       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_R5476_;
20077       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
20078       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
20079 #ifdef FFECOM_dimensionsMAX
20080       ffestb_subrargs_.dim_list.ndims = 0;
20081 #endif
20082       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
20083       FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
20084
20085     case FFELEX_typeCOMMA:
20086       if (!ffesta_is_inhibited ())
20087         ffestc_R547_item_object (ffesta_tokens[1], NULL);
20088       ffelex_token_kill (ffesta_tokens[1]);
20089       return (ffelexHandler) ffestb_R5477_;
20090
20091     case FFELEX_typeSLASH:
20092     case FFELEX_typeCONCAT:
20093       if (!ffesta_is_inhibited ())
20094         ffestc_R547_item_object (ffesta_tokens[1], NULL);
20095       ffelex_token_kill (ffesta_tokens[1]);
20096       return (ffelexHandler) ffestb_R5471_ (t);
20097
20098     case FFELEX_typeEOS:
20099     case FFELEX_typeSEMICOLON:
20100       if (!ffesta_is_inhibited ())
20101         {
20102           ffestc_R547_item_object (ffesta_tokens[1], NULL);
20103           ffestc_R547_finish ();
20104         }
20105       ffelex_token_kill (ffesta_tokens[1]);
20106       return (ffelexHandler) ffesta_zero (t);
20107
20108     default:
20109       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20110       break;
20111     }
20112
20113   if (!ffesta_is_inhibited ())
20114     ffestc_R547_finish ();
20115   ffelex_token_kill (ffesta_tokens[1]);
20116   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20117 }
20118
20119 /* ffestb_R5476_ -- "COMMON" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
20120
20121    return ffestb_R5476_;  // to lexer
20122
20123    Handle COMMA, SLASH, CONCAT, EOS/SEMICOLON.  */
20124
20125 static ffelexHandler
20126 ffestb_R5476_ (ffelexToken t)
20127 {
20128   if (!ffestb_subrargs_.dim_list.ok)
20129     goto bad;                   /* :::::::::::::::::::: */
20130
20131   switch (ffelex_token_type (t))
20132     {
20133     case FFELEX_typeCOMMA:
20134       ffesta_confirmed ();
20135       if (!ffesta_is_inhibited ())
20136         {
20137           if (!ffestb_local_.common.started)
20138             {
20139               ffestc_R547_start ();
20140               ffestb_local_.common.started = TRUE;
20141             }
20142           ffestc_R547_item_object (ffesta_tokens[1],
20143                                    ffestb_subrargs_.dim_list.dims);
20144         }
20145       ffelex_token_kill (ffesta_tokens[1]);
20146       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20147       return (ffelexHandler) ffestb_R5477_;
20148
20149     case FFELEX_typeSLASH:
20150     case FFELEX_typeCONCAT:
20151       ffesta_confirmed ();
20152       if (!ffesta_is_inhibited ())
20153         {
20154           if (!ffestb_local_.common.started)
20155             {
20156               ffestc_R547_start ();
20157               ffestb_local_.common.started = TRUE;
20158             }
20159           ffestc_R547_item_object (ffesta_tokens[1],
20160                                    ffestb_subrargs_.dim_list.dims);
20161         }
20162       ffelex_token_kill (ffesta_tokens[1]);
20163       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20164       return (ffelexHandler) ffestb_R5471_ (t);
20165
20166     case FFELEX_typeEOS:
20167     case FFELEX_typeSEMICOLON:
20168       ffesta_confirmed ();
20169       if (!ffesta_is_inhibited ())
20170         {
20171           if (!ffestb_local_.common.started)
20172             ffestc_R547_start ();
20173           ffestc_R547_item_object (ffesta_tokens[1],
20174                                    ffestb_subrargs_.dim_list.dims);
20175           ffestc_R547_finish ();
20176         }
20177       ffelex_token_kill (ffesta_tokens[1]);
20178       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20179       return (ffelexHandler) ffesta_zero (t);
20180
20181     default:
20182       break;
20183     }
20184
20185 bad:                            /* :::::::::::::::::::: */
20186   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20187   if (ffestb_local_.common.started && !ffesta_is_inhibited ())
20188     ffestc_R547_finish ();
20189   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20190   ffelex_token_kill (ffesta_tokens[1]);
20191   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20192 }
20193
20194 /* ffestb_R5477_ -- "COMMON" ... COMMA
20195
20196    return ffestb_R5477_;  // to lexer
20197
20198    Make sure we don't have EOS or SEMICOLON.  */
20199
20200 static ffelexHandler
20201 ffestb_R5477_ (ffelexToken t)
20202 {
20203   switch (ffelex_token_type (t))
20204     {
20205     case FFELEX_typeEOS:
20206     case FFELEX_typeSEMICOLON:
20207       if (!ffesta_is_inhibited ())
20208         ffestc_R547_finish ();
20209       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20210       return (ffelexHandler) ffesta_zero (t);
20211
20212     default:
20213       return (ffelexHandler) ffestb_R5471_ (t);
20214     }
20215 }
20216
20217 /* ffestb_R624 -- Parse a NULLIFY statement
20218
20219    return ffestb_R624;  // to lexer
20220
20221    Make sure the statement has a valid form for a NULLIFY
20222    statement.  If it does, implement the statement.
20223
20224    31-May-90  JCB  2.0
20225       Rewrite to produce a list of expressions rather than just names; this
20226       eases semantic checking, putting it in expression handling where that
20227       kind of thing gets done anyway, and makes it easier to support more
20228       flexible extensions to Fortran 90 like NULLIFY(FOO%BAR).  */
20229
20230 #if FFESTR_F90
20231 ffelexHandler
20232 ffestb_R624 (ffelexToken t)
20233 {
20234   switch (ffelex_token_type (ffesta_tokens[0]))
20235     {
20236     case FFELEX_typeNAME:
20237       if (ffesta_first_kw != FFESTR_firstNULLIFY)
20238         goto bad_0;             /* :::::::::::::::::::: */
20239       break;
20240
20241     case FFELEX_typeNAMES:
20242       if (ffesta_first_kw != FFESTR_firstNULLIFY)
20243         goto bad_0;             /* :::::::::::::::::::: */
20244       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlNULLIFY)
20245         goto bad_0;             /* :::::::::::::::::::: */
20246       break;
20247
20248     default:
20249       goto bad_0;               /* :::::::::::::::::::: */
20250     }
20251
20252   switch (ffelex_token_type (t))
20253     {
20254     case FFELEX_typeOPEN_PAREN:
20255       break;
20256
20257     case FFELEX_typeEOS:
20258     case FFELEX_typeSEMICOLON:
20259     case FFELEX_typeCOMMA:
20260     case FFELEX_typeCOLONCOLON:
20261     case FFELEX_typeNAME:
20262       ffesta_confirmed ();      /* Error, but clearly intended. */
20263       goto bad_1;               /* :::::::::::::::::::: */
20264
20265     default:
20266       goto bad_1;               /* :::::::::::::::::::: */
20267     }
20268
20269   ffestb_local_.R624.exprs = ffestt_exprlist_create ();
20270   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
20271                                       FFEEXPR_contextNULLIFY,
20272                                       (ffeexprCallback) ffestb_R6241_);
20273
20274 bad_0:                          /* :::::::::::::::::::: */
20275   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", ffesta_tokens[0]);
20276   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20277
20278 bad_1:                          /* :::::::::::::::::::: */
20279   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
20280   return (ffelexHandler) ffelex_swallow_tokens (t,
20281                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
20282 }
20283
20284 /* ffestb_R6241_ -- "NULLIFY" OPEN_PAREN expr
20285
20286    return ffestb_R6241_;  // to lexer
20287
20288    Make sure the statement has a valid form for a NULLIFY statement.  If it
20289    does, implement the statement.
20290
20291    31-May-90  JCB  2.0
20292       Rewrite to produce a list of expressions rather than just names; this
20293       eases semantic checking, putting it in expression handling where that
20294       kind of thing gets done anyway, and makes it easier to support more
20295       flexible extensions to Fortran 90 like NULLIFY(FOO%BAR).  */
20296
20297 static ffelexHandler
20298 ffestb_R6241_ (ffelexToken ft, ffebld expr, ffelexToken t)
20299 {
20300   switch (ffelex_token_type (t))
20301     {
20302     case FFELEX_typeCLOSE_PAREN:
20303       if (expr == NULL)
20304         break;
20305       ffestt_exprlist_append (ffestb_local_.R624.exprs, expr,
20306                               ffelex_token_use (t));
20307       return (ffelexHandler) ffestb_R6242_;
20308
20309     case FFELEX_typeCOMMA:
20310       if (expr == NULL)
20311         break;
20312       ffestt_exprlist_append (ffestb_local_.R624.exprs, expr,
20313                               ffelex_token_use (t));
20314       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
20315                                           FFEEXPR_contextNULLIFY,
20316                                           (ffeexprCallback) ffestb_R6241_);
20317
20318     default:
20319       break;
20320     }
20321
20322   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
20323   ffestt_exprlist_kill (ffestb_local_.R624.exprs);
20324   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20325 }
20326
20327 /* ffestb_R6242_ -- "NULLIFY" OPEN_PAREN expr-list CLOSE_PAREN
20328
20329    return ffestb_R6242_;  // to lexer
20330
20331    Make sure the statement has a valid form for a NULLIFY statement.  If it
20332    does, implement the statement.  */
20333
20334 static ffelexHandler
20335 ffestb_R6242_ (ffelexToken t)
20336 {
20337   switch (ffelex_token_type (t))
20338     {
20339     case FFELEX_typeEOS:
20340     case FFELEX_typeSEMICOLON:
20341       ffesta_confirmed ();
20342       if (!ffesta_is_inhibited ())
20343         ffestc_R624 (ffestb_local_.R624.exprs);
20344       ffestt_exprlist_kill (ffestb_local_.R624.exprs);
20345       return (ffelexHandler) ffesta_zero (t);
20346
20347     default:
20348       break;
20349     }
20350
20351   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
20352   ffestt_exprlist_kill (ffestb_local_.R624.exprs);
20353   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20354 }
20355
20356 #endif
20357 /* ffestb_R1229 -- Parse a STMTFUNCTION statement
20358
20359    return ffestb_R1229;  // to lexer
20360
20361    Make sure the statement has a valid form for a STMTFUNCTION
20362    statement.  If it does, implement the statement.  */
20363
20364 ffelexHandler
20365 ffestb_R1229 (ffelexToken t)
20366 {
20367   switch (ffelex_token_type (ffesta_tokens[0]))
20368     {
20369     case FFELEX_typeNAME:
20370     case FFELEX_typeNAMES:
20371       break;
20372
20373     default:
20374       goto bad_0;               /* :::::::::::::::::::: */
20375     }
20376
20377   switch (ffelex_token_type (t))
20378     {
20379     case FFELEX_typeOPEN_PAREN:
20380       break;
20381
20382     case FFELEX_typeEOS:
20383     case FFELEX_typeSEMICOLON:
20384     case FFELEX_typeCOMMA:
20385     case FFELEX_typeCOLONCOLON:
20386     case FFELEX_typeNAME:
20387       ffesta_confirmed ();      /* Error, but clearly intended. */
20388       goto bad_1;               /* :::::::::::::::::::: */
20389
20390     default:
20391       goto bad_1;               /* :::::::::::::::::::: */
20392     }
20393
20394   ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
20395   ffestb_subrargs_.name_list.handler = (ffelexHandler) ffestb_R12291_;
20396   ffestb_subrargs_.name_list.is_subr = FALSE;   /* No "*" items in list! */
20397   ffestb_subrargs_.name_list.names = TRUE;      /* In case "IF(FOO)CALL
20398                                                    FOO...". */
20399   return (ffelexHandler) ffestb_subr_name_list_;
20400
20401 bad_0:                          /* :::::::::::::::::::: */
20402 bad_1:                          /* :::::::::::::::::::: */
20403   ffesta_ffebad_2t (FFEBAD_UNREC_STMT, ffesta_tokens[0], t);
20404   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20405 }
20406
20407 /* ffestb_R12291_ -- "STMTFUNCTION" OPEN_PAREN dummy-name-list CLOSE_PAREN
20408
20409    return ffestb_R12291_;  // to lexer
20410
20411    Make sure the statement has a valid form for a STMTFUNCTION statement.  If
20412    it does, implement the statement.  */
20413
20414 static ffelexHandler
20415 ffestb_R12291_ (ffelexToken t)
20416 {
20417   ffelex_set_names (FALSE);
20418
20419   if (!ffestb_subrargs_.name_list.ok)
20420     goto bad;                   /* :::::::::::::::::::: */
20421
20422   switch (ffelex_token_type (t))
20423     {
20424     case FFELEX_typeEQUALS:
20425       ffesta_confirmed ();
20426       if (!ffesta_is_inhibited ())
20427         ffestc_R1229_start (ffesta_tokens[0],
20428                             ffestb_subrargs_.name_list.args,
20429                             ffestb_subrargs_.name_list.close_paren);
20430       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
20431       ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
20432       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
20433                  FFEEXPR_contextSFUNCDEF, (ffeexprCallback) ffestb_R12292_);
20434
20435     default:
20436       break;
20437     }
20438
20439 bad:                            /* :::::::::::::::::::: */
20440   ffesta_ffebad_2t (FFEBAD_UNREC_STMT, ffesta_tokens[0], t);
20441   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
20442   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
20443   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20444 }
20445
20446 /* ffestb_R12292_ -- "STMTFUNCTION" OPEN_PAREN dummy-name-list CLOSE_PAREN
20447                      EQUALS expr
20448
20449    (ffestb_R12292_)  // to expression handler
20450
20451    Make sure the statement has a valid form for a STMTFUNCTION statement.  If
20452    it does, implement the statement.  */
20453
20454 static ffelexHandler
20455 ffestb_R12292_ (ffelexToken ft, ffebld expr, ffelexToken t)
20456 {
20457   if (expr == NULL)
20458     goto bad;                   /* :::::::::::::::::::: */
20459
20460   switch (ffelex_token_type (t))
20461     {
20462     case FFELEX_typeEOS:
20463     case FFELEX_typeSEMICOLON:
20464       if (!ffesta_is_inhibited ())
20465         ffestc_R1229_finish (expr, ft);
20466       return (ffelexHandler) ffesta_zero (t);
20467
20468     default:
20469       break;
20470     }
20471
20472 bad:                            /* :::::::::::::::::::: */
20473   ffestc_R1229_finish (NULL, NULL);
20474   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "statement-function-definition", t);
20475   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20476 }
20477
20478 /* ffestb_decl_chartype -- Parse the CHARACTER statement
20479
20480    return ffestb_decl_chartype;  // to lexer
20481
20482    Make sure the statement has a valid form for the CHARACTER statement.  If
20483    it does, implement the statement.  */
20484
20485 ffelexHandler
20486 ffestb_decl_chartype (ffelexToken t)
20487 {
20488   ffeTokenLength i;
20489   char *p;
20490
20491   ffestb_local_.decl.type = FFESTP_typeCHARACTER;
20492   ffestb_local_.decl.recursive = NULL;
20493   ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20494   ffestb_local_.decl.coloncolon = FALSE;        /* No COLONCOLON seen. */
20495
20496   switch (ffelex_token_type (ffesta_tokens[0]))
20497     {
20498     case FFELEX_typeNAME:
20499       if (ffesta_first_kw != FFESTR_firstCHRCTR)
20500         goto bad_0;             /* :::::::::::::::::::: */
20501       switch (ffelex_token_type (t))
20502         {
20503         case FFELEX_typeEOS:
20504         case FFELEX_typeSEMICOLON:
20505           ffesta_confirmed ();  /* Error, but clearly intended. */
20506           goto bad_1;           /* :::::::::::::::::::: */
20507
20508         default:
20509           goto bad_1;           /* :::::::::::::::::::: */
20510
20511         case FFELEX_typeCOMMA:
20512           ffesta_confirmed ();
20513           if (!ffesta_is_inhibited ())
20514             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20515                                NULL, NULL, NULL, NULL);
20516           return (ffelexHandler) ffestb_decl_attrs_;
20517
20518         case FFELEX_typeCOLONCOLON:
20519           ffestb_local_.decl.coloncolon = TRUE;
20520           ffesta_confirmed ();
20521           if (!ffesta_is_inhibited ())
20522             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20523                                NULL, NULL, NULL, NULL);
20524           return (ffelexHandler) ffestb_decl_ents_;
20525
20526         case FFELEX_typeASTERISK:
20527           ffesta_confirmed ();
20528           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_chartype1_;
20529           ffestb_local_.decl.badname = "TYPEDECL";
20530           return (ffelexHandler) ffestb_decl_starlen_;
20531
20532         case FFELEX_typeOPEN_PAREN:
20533           ffestb_local_.decl.kind = NULL;
20534           ffestb_local_.decl.kindt = NULL;
20535           ffestb_local_.decl.len = NULL;
20536           ffestb_local_.decl.lent = NULL;
20537           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20538           ffestb_local_.decl.badname = "_TYPEDECL";
20539           return (ffelexHandler) ffestb_decl_typeparams_;
20540
20541         case FFELEX_typeNAME:
20542           ffesta_confirmed ();
20543           ffestb_local_.decl.kind = NULL;
20544           ffestb_local_.decl.kindt = NULL;
20545           ffestb_local_.decl.len = NULL;
20546           ffestb_local_.decl.lent = NULL;
20547           return (ffelexHandler) ffestb_decl_entsp_ (t);
20548         }
20549
20550     case FFELEX_typeNAMES:
20551       if (ffesta_first_kw != FFESTR_firstCHRCTR)
20552         goto bad_0;             /* :::::::::::::::::::: */
20553       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCHRCTR);
20554       switch (ffelex_token_type (t))
20555         {
20556         default:
20557           goto bad_1;           /* :::::::::::::::::::: */
20558
20559         case FFELEX_typeEOS:
20560         case FFELEX_typeSEMICOLON:
20561           ffesta_confirmed ();
20562           break;
20563
20564         case FFELEX_typeCOMMA:
20565           ffesta_confirmed ();
20566           if (*p != '\0')
20567             break;
20568           if (!ffesta_is_inhibited ())
20569             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20570                                NULL, NULL, NULL, NULL);
20571           return (ffelexHandler) ffestb_decl_attrs_;
20572
20573         case FFELEX_typeCOLONCOLON:
20574           ffestb_local_.decl.coloncolon = TRUE;
20575           ffesta_confirmed ();
20576           if (*p != '\0')
20577             goto bad_i;         /* :::::::::::::::::::: */
20578           if (!ffesta_is_inhibited ())
20579             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20580                                NULL, NULL, NULL, NULL);
20581           return (ffelexHandler) ffestb_decl_ents_;
20582
20583         case FFELEX_typeASTERISK:
20584           ffesta_confirmed ();
20585           if (*p != '\0')
20586             break;
20587           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_chartype1_;
20588           ffestb_local_.decl.badname = "TYPEDECL";
20589           return (ffelexHandler) ffestb_decl_starlen_;
20590
20591         case FFELEX_typeSLASH:
20592           ffesta_confirmed ();
20593           if (*p != '\0')
20594             break;
20595           goto bad_1;           /* :::::::::::::::::::: */
20596
20597         case FFELEX_typeOPEN_PAREN:
20598           if (*p != '\0')
20599             break;
20600           ffestb_local_.decl.kind = NULL;
20601           ffestb_local_.decl.kindt = NULL;
20602           ffestb_local_.decl.len = NULL;
20603           ffestb_local_.decl.lent = NULL;
20604           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20605           ffestb_local_.decl.badname = "TYPEDECL";
20606           return (ffelexHandler) ffestb_decl_typeparams_;
20607         }
20608       if (!ffesrc_is_name_init (*p))
20609         goto bad_i;             /* :::::::::::::::::::: */
20610       ffestb_local_.decl.kind = NULL;
20611       ffestb_local_.decl.kindt = NULL;
20612       ffestb_local_.decl.len = NULL;
20613       ffestb_local_.decl.lent = NULL;
20614       ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
20615       return (ffelexHandler) ffestb_decl_entsp_2_ (t);
20616
20617     default:
20618       goto bad_0;               /* :::::::::::::::::::: */
20619     }
20620
20621 bad_0:                          /* :::::::::::::::::::: */
20622   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20623   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20624
20625 bad_1:                          /* :::::::::::::::::::: */
20626   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20627   return (ffelexHandler) ffelex_swallow_tokens (t,
20628                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
20629
20630 bad_i:                          /* :::::::::::::::::::: */
20631   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
20632   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20633 }
20634
20635 /* ffestb_decl_chartype1_ -- "CHARACTER" ASTERISK char-length
20636
20637    return ffestb_decl_chartype1_;  // to lexer
20638
20639    Handle COMMA, COLONCOLON, or anything else.  */
20640
20641 static ffelexHandler
20642 ffestb_decl_chartype1_ (ffelexToken t)
20643 {
20644   ffelex_set_names (FALSE);
20645
20646   switch (ffelex_token_type (t))
20647     {
20648     case FFELEX_typeCOLONCOLON:
20649       ffestb_local_.decl.coloncolon = TRUE;
20650       /* Fall through. */
20651     case FFELEX_typeCOMMA:
20652       ffesta_confirmed ();
20653       if (!ffesta_is_inhibited ())
20654         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20655                NULL, NULL, ffestb_local_.decl.len, ffestb_local_.decl.lent);
20656       if (ffestb_local_.decl.lent != NULL)
20657         ffelex_token_kill (ffestb_local_.decl.lent);
20658       return (ffelexHandler) ffestb_decl_ents_;
20659
20660     default:
20661       return (ffelexHandler) ffestb_decl_entsp_ (t);
20662     }
20663 }
20664
20665 /* ffestb_decl_dbltype -- Parse the DOUBLEPRECISION/DOUBLECOMPLEX statement
20666
20667    return ffestb_decl_dbltype;  // to lexer
20668
20669    Make sure the statement has a valid form for the DOUBLEPRECISION/
20670    DOUBLECOMPLEX statement.  If it does, implement the statement.  */
20671
20672 ffelexHandler
20673 ffestb_decl_dbltype (ffelexToken t)
20674 {
20675   ffeTokenLength i;
20676   char *p;
20677
20678   ffestb_local_.decl.type = ffestb_args.decl.type;
20679   ffestb_local_.decl.recursive = NULL;
20680   ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20681   ffestb_local_.decl.coloncolon = FALSE;        /* No COLONCOLON seen. */
20682
20683   switch (ffelex_token_type (ffesta_tokens[0]))
20684     {
20685     case FFELEX_typeNAME:
20686       switch (ffelex_token_type (t))
20687         {
20688         case FFELEX_typeEOS:
20689         case FFELEX_typeSEMICOLON:
20690           ffesta_confirmed ();  /* Error, but clearly intended. */
20691           goto bad_1;           /* :::::::::::::::::::: */
20692
20693         default:
20694           goto bad_1;           /* :::::::::::::::::::: */
20695
20696         case FFELEX_typeCOMMA:
20697           ffesta_confirmed ();
20698           if (!ffesta_is_inhibited ())
20699             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20700                                NULL, NULL, NULL, NULL);
20701           return (ffelexHandler) ffestb_decl_attrs_;
20702
20703         case FFELEX_typeCOLONCOLON:
20704           ffestb_local_.decl.coloncolon = TRUE;
20705           ffesta_confirmed ();
20706           if (!ffesta_is_inhibited ())
20707             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20708                                NULL, NULL, NULL, NULL);
20709           return (ffelexHandler) ffestb_decl_ents_;
20710
20711         case FFELEX_typeNAME:
20712           ffesta_confirmed ();
20713           ffestb_local_.decl.kind = NULL;
20714           ffestb_local_.decl.kindt = NULL;
20715           ffestb_local_.decl.len = NULL;
20716           ffestb_local_.decl.lent = NULL;
20717           return (ffelexHandler) ffestb_decl_entsp_ (t);
20718         }
20719
20720     case FFELEX_typeNAMES:
20721       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.decl.len);
20722       switch (ffelex_token_type (t))
20723         {
20724         default:
20725           goto bad_1;           /* :::::::::::::::::::: */
20726
20727         case FFELEX_typeEOS:
20728         case FFELEX_typeSEMICOLON:
20729           ffesta_confirmed ();
20730           break;
20731
20732         case FFELEX_typeCOMMA:
20733           ffesta_confirmed ();
20734           if (*p != '\0')
20735             break;
20736           if (!ffesta_is_inhibited ())
20737             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20738                                NULL, NULL, NULL, NULL);
20739           return (ffelexHandler) ffestb_decl_attrs_;
20740
20741         case FFELEX_typeCOLONCOLON:
20742           ffestb_local_.decl.coloncolon = TRUE;
20743           ffesta_confirmed ();
20744           if (*p != '\0')
20745             goto bad_i;         /* :::::::::::::::::::: */
20746           if (!ffesta_is_inhibited ())
20747             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20748                                NULL, NULL, NULL, NULL);
20749           return (ffelexHandler) ffestb_decl_ents_;
20750
20751         case FFELEX_typeSLASH:
20752           ffesta_confirmed ();
20753           if (*p != '\0')
20754             break;
20755           goto bad_1;           /* :::::::::::::::::::: */
20756
20757         case FFELEX_typeOPEN_PAREN:
20758           if (*p != '\0')
20759             break;
20760           goto bad_1;           /* :::::::::::::::::::: */
20761         }
20762       if (!ffesrc_is_name_init (*p))
20763         goto bad_i;             /* :::::::::::::::::::: */
20764       ffestb_local_.decl.kind = NULL;
20765       ffestb_local_.decl.kindt = NULL;
20766       ffestb_local_.decl.len = NULL;
20767       ffestb_local_.decl.lent = NULL;
20768       ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
20769       return (ffelexHandler) ffestb_decl_entsp_2_ (t);
20770
20771     default:
20772       goto bad_0;               /* :::::::::::::::::::: */
20773     }
20774
20775 bad_0:                          /* :::::::::::::::::::: */
20776   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20777   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20778
20779 bad_1:                          /* :::::::::::::::::::: */
20780   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20781   return (ffelexHandler) ffelex_swallow_tokens (t,
20782                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
20783
20784 bad_i:                          /* :::::::::::::::::::: */
20785   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
20786   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20787 }
20788
20789 /* ffestb_decl_double -- Parse the DOUBLE PRECISION/DOUBLE COMPLEX statement
20790
20791    return ffestb_decl_double;  // to lexer
20792
20793    Make sure the statement has a valid form for the DOUBLE PRECISION/
20794    DOUBLE COMPLEX statement.  If it does, implement the statement.  */
20795
20796 ffelexHandler
20797 ffestb_decl_double (ffelexToken t)
20798 {
20799   ffestb_local_.decl.recursive = NULL;
20800   ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20801   ffestb_local_.decl.coloncolon = FALSE;        /* No COLONCOLON seen. */
20802
20803   switch (ffelex_token_type (ffesta_tokens[0]))
20804     {
20805     case FFELEX_typeNAME:
20806       if (ffesta_first_kw != FFESTR_firstDBL)
20807         goto bad_0;             /* :::::::::::::::::::: */
20808       switch (ffelex_token_type (t))
20809         {
20810         case FFELEX_typeEOS:
20811         case FFELEX_typeSEMICOLON:
20812         case FFELEX_typeCOMMA:
20813         case FFELEX_typeCOLONCOLON:
20814           ffesta_confirmed ();  /* Error, but clearly intended. */
20815           goto bad_1;           /* :::::::::::::::::::: */
20816
20817         default:
20818           goto bad_1;           /* :::::::::::::::::::: */
20819
20820         case FFELEX_typeNAME:
20821           ffesta_confirmed ();
20822           switch (ffestr_second (t))
20823             {
20824             case FFESTR_secondCOMPLEX:
20825               ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
20826               break;
20827
20828             case FFESTR_secondPRECISION:
20829               ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
20830               break;
20831
20832             default:
20833               goto bad_1;       /* :::::::::::::::::::: */
20834             }
20835           ffestb_local_.decl.kind = NULL;
20836           ffestb_local_.decl.kindt = NULL;
20837           ffestb_local_.decl.len = NULL;
20838           ffestb_local_.decl.lent = NULL;
20839           return (ffelexHandler) ffestb_decl_attrsp_;
20840         }
20841
20842     default:
20843       goto bad_0;               /* :::::::::::::::::::: */
20844     }
20845
20846 bad_0:                          /* :::::::::::::::::::: */
20847   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20848   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20849
20850 bad_1:                          /* :::::::::::::::::::: */
20851   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20852   return (ffelexHandler) ffelex_swallow_tokens (t,
20853                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
20854 }
20855
20856 /* ffestb_decl_gentype -- Parse the INTEGER/REAL/COMPLEX/LOGICAL statement
20857
20858    return ffestb_decl_gentype;  // to lexer
20859
20860    Make sure the statement has a valid form for the INTEGER/REAL/COMPLEX/
20861    LOGICAL statement.  If it does, implement the statement.  */
20862
20863 ffelexHandler
20864 ffestb_decl_gentype (ffelexToken t)
20865 {
20866   ffeTokenLength i;
20867   char *p;
20868
20869   ffestb_local_.decl.type = ffestb_args.decl.type;
20870   ffestb_local_.decl.recursive = NULL;
20871   ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20872   ffestb_local_.decl.coloncolon = FALSE;        /* No COLONCOLON seen. */
20873
20874   switch (ffelex_token_type (ffesta_tokens[0]))
20875     {
20876     case FFELEX_typeNAME:
20877       switch (ffelex_token_type (t))
20878         {
20879         case FFELEX_typeEOS:
20880         case FFELEX_typeSEMICOLON:
20881           ffesta_confirmed ();  /* Error, but clearly intended. */
20882           goto bad_1;           /* :::::::::::::::::::: */
20883
20884         default:
20885           goto bad_1;           /* :::::::::::::::::::: */
20886
20887         case FFELEX_typeCOMMA:
20888           ffesta_confirmed ();
20889           if (!ffesta_is_inhibited ())
20890             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20891                                NULL, NULL, NULL, NULL);
20892           return (ffelexHandler) ffestb_decl_attrs_;
20893
20894         case FFELEX_typeCOLONCOLON:
20895           ffestb_local_.decl.coloncolon = TRUE;
20896           ffesta_confirmed ();
20897           if (!ffesta_is_inhibited ())
20898             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20899                                NULL, NULL, NULL, NULL);
20900           return (ffelexHandler) ffestb_decl_ents_;
20901
20902         case FFELEX_typeASTERISK:
20903           ffesta_confirmed ();
20904           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20905           ffestb_local_.decl.badname = "TYPEDECL";
20906           return (ffelexHandler) ffestb_decl_starkind_;
20907
20908         case FFELEX_typeOPEN_PAREN:
20909           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20910           ffestb_local_.decl.badname = "TYPEDECL";
20911           return (ffelexHandler) ffestb_decl_kindparam_;
20912
20913         case FFELEX_typeNAME:
20914           ffesta_confirmed ();
20915           ffestb_local_.decl.kind = NULL;
20916           ffestb_local_.decl.kindt = NULL;
20917           ffestb_local_.decl.len = NULL;
20918           ffestb_local_.decl.lent = NULL;
20919           return (ffelexHandler) ffestb_decl_entsp_ (t);
20920         }
20921
20922     case FFELEX_typeNAMES:
20923       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.decl.len);
20924       switch (ffelex_token_type (t))
20925         {
20926         default:
20927           goto bad_1;           /* :::::::::::::::::::: */
20928
20929         case FFELEX_typeEOS:
20930         case FFELEX_typeSEMICOLON:
20931           ffesta_confirmed ();
20932           break;
20933
20934         case FFELEX_typeCOMMA:
20935           ffesta_confirmed ();
20936           if (*p != '\0')
20937             break;
20938           if (!ffesta_is_inhibited ())
20939             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20940                                NULL, NULL, NULL, NULL);
20941           return (ffelexHandler) ffestb_decl_attrs_;
20942
20943         case FFELEX_typeCOLONCOLON:
20944           ffestb_local_.decl.coloncolon = TRUE;
20945           ffesta_confirmed ();
20946           if (*p != '\0')
20947             goto bad_i;         /* :::::::::::::::::::: */
20948           if (!ffesta_is_inhibited ())
20949             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20950                                NULL, NULL, NULL, NULL);
20951           return (ffelexHandler) ffestb_decl_ents_;
20952
20953         case FFELEX_typeSLASH:
20954           ffesta_confirmed ();
20955           if (*p != '\0')
20956             break;
20957           goto bad_1;           /* :::::::::::::::::::: */
20958
20959         case FFELEX_typeASTERISK:
20960           ffesta_confirmed ();
20961           if (*p != '\0')
20962             break;
20963           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20964           ffestb_local_.decl.badname = "TYPEDECL";
20965           return (ffelexHandler) ffestb_decl_starkind_;
20966
20967         case FFELEX_typeOPEN_PAREN:
20968           if (*p != '\0')
20969             break;
20970           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20971           ffestb_local_.decl.badname = "TYPEDECL";
20972           return (ffelexHandler) ffestb_decl_kindparam_;
20973         }
20974       if (!ffesrc_is_name_init (*p))
20975         goto bad_i;             /* :::::::::::::::::::: */
20976       ffestb_local_.decl.kind = NULL;
20977       ffestb_local_.decl.kindt = NULL;
20978       ffestb_local_.decl.len = NULL;
20979       ffestb_local_.decl.lent = NULL;
20980       ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
20981       return (ffelexHandler) ffestb_decl_entsp_2_ (t);
20982
20983     default:
20984       goto bad_0;               /* :::::::::::::::::::: */
20985     }
20986
20987 bad_0:                          /* :::::::::::::::::::: */
20988   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20989   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20990
20991 bad_1:                          /* :::::::::::::::::::: */
20992   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20993   return (ffelexHandler) ffelex_swallow_tokens (t,
20994                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
20995
20996 bad_i:                          /* :::::::::::::::::::: */
20997   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
20998   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20999 }
21000
21001 /* ffestb_decl_recursive -- Parse the RECURSIVE FUNCTION statement
21002
21003    return ffestb_decl_recursive;  // to lexer
21004
21005    Make sure the statement has a valid form for the RECURSIVE FUNCTION
21006    statement.  If it does, implement the statement.  */
21007
21008 #if FFESTR_F90
21009 ffelexHandler
21010 ffestb_decl_recursive (ffelexToken t)
21011 {
21012   ffeTokenLength i;
21013   char *p;
21014   ffelexToken nt;
21015   ffelexToken ot;
21016   ffelexHandler next;
21017   bool needfunc;
21018
21019   switch (ffelex_token_type (ffesta_tokens[0]))
21020     {
21021     case FFELEX_typeNAME:
21022       if (ffesta_first_kw != FFESTR_firstRECURSIVE)
21023         goto bad_0;             /* :::::::::::::::::::: */
21024       switch (ffelex_token_type (t))
21025         {
21026         case FFELEX_typeEOS:
21027         case FFELEX_typeSEMICOLON:
21028         case FFELEX_typeCOMMA:
21029         case FFELEX_typeCOLONCOLON:
21030           ffesta_confirmed ();  /* Error, but clearly intended. */
21031           goto bad_1;           /* :::::::::::::::::::: */
21032
21033         default:
21034           goto bad_1;           /* :::::::::::::::::::: */
21035
21036         case FFELEX_typeNAME:
21037           break;
21038         }
21039       ffesta_confirmed ();
21040       ffestb_local_.decl.recursive = ffelex_token_use (ffesta_tokens[0]);
21041       switch (ffesta_second_kw)
21042         {
21043         case FFESTR_secondINTEGER:
21044           ffestb_local_.decl.type = FFESTP_typeINTEGER;
21045           return (ffelexHandler) ffestb_decl_recursive1_;
21046
21047         case FFESTR_secondBYTE:
21048           ffestb_local_.decl.type = FFESTP_typeBYTE;
21049           return (ffelexHandler) ffestb_decl_recursive1_;
21050
21051         case FFESTR_secondWORD:
21052           ffestb_local_.decl.type = FFESTP_typeWORD;
21053           return (ffelexHandler) ffestb_decl_recursive1_;
21054
21055         case FFESTR_secondREAL:
21056           ffestb_local_.decl.type = FFESTP_typeREAL;
21057           return (ffelexHandler) ffestb_decl_recursive1_;
21058
21059         case FFESTR_secondCOMPLEX:
21060           ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
21061           return (ffelexHandler) ffestb_decl_recursive1_;
21062
21063         case FFESTR_secondLOGICAL:
21064           ffestb_local_.decl.type = FFESTP_typeLOGICAL;
21065           return (ffelexHandler) ffestb_decl_recursive1_;
21066
21067         case FFESTR_secondCHARACTER:
21068           ffestb_local_.decl.type = FFESTP_typeCHARACTER;
21069           return (ffelexHandler) ffestb_decl_recursive1_;
21070
21071         case FFESTR_secondDOUBLE:
21072           return (ffelexHandler) ffestb_decl_recursive2_;
21073
21074         case FFESTR_secondDOUBLEPRECISION:
21075           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
21076           ffestb_local_.decl.kind = NULL;
21077           ffestb_local_.decl.kindt = NULL;
21078           ffestb_local_.decl.len = NULL;
21079           ffestb_local_.decl.lent = NULL;
21080           return (ffelexHandler) ffestb_decl_func_;
21081
21082         case FFESTR_secondDOUBLECOMPLEX:
21083           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
21084           ffestb_local_.decl.kind = NULL;
21085           ffestb_local_.decl.kindt = NULL;
21086           ffestb_local_.decl.len = NULL;
21087           ffestb_local_.decl.lent = NULL;
21088           return (ffelexHandler) ffestb_decl_func_;
21089
21090         case FFESTR_secondTYPE:
21091           ffestb_local_.decl.type = FFESTP_typeTYPE;
21092           return (ffelexHandler) ffestb_decl_recursive3_;
21093
21094         case FFESTR_secondFUNCTION:
21095           ffestb_local_.dummy.first_kw = FFESTR_firstFUNCTION;
21096           ffestb_local_.dummy.badname = "FUNCTION";
21097           ffestb_local_.dummy.is_subr = FALSE;
21098           return (ffelexHandler) ffestb_decl_recursive4_;
21099
21100         case FFESTR_secondSUBROUTINE:
21101           ffestb_local_.dummy.first_kw = FFESTR_firstSUBROUTINE;
21102           ffestb_local_.dummy.badname = "SUBROUTINE";
21103           ffestb_local_.dummy.is_subr = TRUE;
21104           return (ffelexHandler) ffestb_decl_recursive4_;
21105
21106         default:
21107           ffelex_token_kill (ffestb_local_.decl.recursive);
21108           goto bad_1;           /* :::::::::::::::::::: */
21109         }
21110
21111     case FFELEX_typeNAMES:
21112       if (ffesta_first_kw != FFESTR_firstRECURSIVE)
21113         goto bad_0;             /* :::::::::::::::::::: */
21114       switch (ffelex_token_type (t))
21115         {
21116         case FFELEX_typeCOMMA:
21117         case FFELEX_typeCOLONCOLON:
21118         case FFELEX_typeASTERISK:
21119         case FFELEX_typeSEMICOLON:
21120         case FFELEX_typeEOS:
21121           ffesta_confirmed ();
21122           break;
21123
21124         default:
21125           break;
21126         }
21127       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlRECURSIVE);
21128       if (!ffesrc_is_name_init (*p))
21129         goto bad_0;             /* :::::::::::::::::::: */
21130       ffestb_local_.decl.recursive
21131         = ffelex_token_name_from_names (ffesta_tokens[0], 0,
21132                                         FFESTR_firstlRECURSIVE);
21133       nt = ffelex_token_names_from_names (ffesta_tokens[0],
21134                                           FFESTR_firstlRECURSIVE, 0);
21135       switch (ffestr_first (nt))
21136         {
21137         case FFESTR_firstINTGR:
21138           p = ffelex_token_text (nt) + (i = FFESTR_firstlINTGR);
21139           ffestb_local_.decl.type = FFESTP_typeINTEGER;
21140           needfunc = FALSE;
21141           goto typefunc;        /* :::::::::::::::::::: */
21142
21143         case FFESTR_firstBYTE:
21144           p = ffelex_token_text (nt) + (i = FFESTR_firstlBYTE);
21145           ffestb_local_.decl.type = FFESTP_typeBYTE;
21146           needfunc = FALSE;
21147           goto typefunc;        /* :::::::::::::::::::: */
21148
21149         case FFESTR_firstWORD:
21150           p = ffelex_token_text (nt) + (i = FFESTR_firstlWORD);
21151           ffestb_local_.decl.type = FFESTP_typeWORD;
21152           needfunc = FALSE;
21153           goto typefunc;        /* :::::::::::::::::::: */
21154
21155         case FFESTR_firstREAL:
21156           p = ffelex_token_text (nt) + (i = FFESTR_firstlREAL);
21157           ffestb_local_.decl.type = FFESTP_typeREAL;
21158           needfunc = FALSE;
21159           goto typefunc;        /* :::::::::::::::::::: */
21160
21161         case FFESTR_firstCMPLX:
21162           p = ffelex_token_text (nt) + (i = FFESTR_firstlCMPLX);
21163           ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
21164           needfunc = FALSE;
21165           goto typefunc;        /* :::::::::::::::::::: */
21166
21167         case FFESTR_firstLGCL:
21168           p = ffelex_token_text (nt) + (i = FFESTR_firstlLGCL);
21169           ffestb_local_.decl.type = FFESTP_typeLOGICAL;
21170           needfunc = FALSE;
21171           goto typefunc;        /* :::::::::::::::::::: */
21172
21173         case FFESTR_firstCHRCTR:
21174           p = ffelex_token_text (nt) + (i = FFESTR_firstlCHRCTR);
21175           ffestb_local_.decl.type = FFESTP_typeCHARACTER;
21176           needfunc = FALSE;
21177           goto typefunc;        /* :::::::::::::::::::: */
21178
21179         case FFESTR_firstDBLPRCSN:
21180           p = ffelex_token_text (nt) + (i = FFESTR_firstlDBLPRCSN);
21181           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
21182           needfunc = TRUE;
21183           goto typefunc;        /* :::::::::::::::::::: */
21184
21185         case FFESTR_firstDBLCMPLX:
21186           p = ffelex_token_text (nt) + (i = FFESTR_firstlDBLCMPLX);
21187           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
21188           needfunc = TRUE;
21189           goto typefunc;        /* :::::::::::::::::::: */
21190
21191         case FFESTR_firstTYPE:
21192           p = ffelex_token_text (nt) + (i = FFESTR_firstlTYPE);
21193           ffestb_local_.decl.type = FFESTP_typeTYPE;
21194           next = (ffelexHandler) ffestb_decl_recursive3_;
21195           break;
21196
21197         case FFESTR_firstFUNCTION:
21198           p = ffelex_token_text (nt) + (i = FFESTR_firstlFUNCTION);
21199           ffestb_local_.dummy.first_kw = FFESTR_firstFUNCTION;
21200           ffestb_local_.dummy.badname = "FUNCTION";
21201           ffestb_local_.dummy.is_subr = FALSE;
21202           next = (ffelexHandler) ffestb_decl_recursive4_;
21203           break;
21204
21205         case FFESTR_firstSUBROUTINE:
21206           p = ffelex_token_text (nt) + (i = FFESTR_firstlSUBROUTINE);
21207           ffestb_local_.dummy.first_kw = FFESTR_firstSUBROUTINE;
21208           ffestb_local_.dummy.badname = "SUBROUTINE";
21209           ffestb_local_.dummy.is_subr = TRUE;
21210           next = (ffelexHandler) ffestb_decl_recursive4_;
21211           break;
21212
21213         default:
21214           ffelex_token_kill (ffestb_local_.decl.recursive);
21215           ffelex_token_kill (nt);
21216           goto bad_1;           /* :::::::::::::::::::: */
21217         }
21218       if (*p == '\0')
21219         {
21220           ffelex_token_kill (nt);
21221           return (ffelexHandler) (*next) (t);
21222         }
21223       if (!ffesrc_is_name_init (*p))
21224         goto bad_i;             /* :::::::::::::::::::: */
21225       ot = ffelex_token_name_from_names (nt, i, 0);
21226       ffelex_token_kill (nt);
21227       next = (ffelexHandler) (*next) (ot);
21228       ffelex_token_kill (ot);
21229       return (ffelexHandler) (*next) (t);
21230
21231     default:
21232       goto bad_0;               /* :::::::::::::::::::: */
21233     }
21234
21235 typefunc:                       /* :::::::::::::::::::: */
21236   if (*p == '\0')
21237     {
21238       ffelex_token_kill (nt);
21239       if (needfunc)             /* DOUBLE PRECISION or DOUBLE COMPLEX? */
21240         {
21241           ffelex_token_kill (ffestb_local_.decl.recursive);
21242           goto bad_1;           /* :::::::::::::::::::: */
21243         }
21244       return (ffelexHandler) ffestb_decl_recursive1_ (t);
21245     }
21246   if (!ffesrc_is_name_init (*p))
21247     goto bad_i;                 /* :::::::::::::::::::: */
21248   ot = ffelex_token_names_from_names (nt, i, 0);
21249   ffelex_token_kill (nt);
21250   if (ffestr_first (ot) != FFESTR_firstFUNCTION)
21251     goto bad_o;                 /* :::::::::::::::::::: */
21252   p = ffelex_token_text (ot) + (i = FFESTR_firstlFUNCTION);
21253   if (!ffesrc_is_name_init (*p))
21254     goto bad_i;                 /* :::::::::::::::::::: */
21255   ffesta_tokens[1] = ffelex_token_name_from_names (ot, i, 0);
21256   ffelex_token_kill (ot);
21257   ffestb_local_.decl.kind = NULL;
21258   ffestb_local_.decl.kindt = NULL;
21259   ffestb_local_.decl.len = NULL;
21260   ffestb_local_.decl.lent = NULL;
21261   return (ffelexHandler) ffestb_decl_funcname_1_ (t);
21262
21263 bad_0:                          /* :::::::::::::::::::: */
21264   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ffesta_tokens[0]);
21265   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21266
21267 bad_1:                          /* :::::::::::::::::::: */
21268   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21269   return (ffelexHandler) ffelex_swallow_tokens (t,
21270                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
21271
21272 bad_i:                          /* :::::::::::::::::::: */
21273   ffelex_token_kill (ffestb_local_.decl.recursive);
21274   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", nt, i, t);
21275   ffelex_token_kill (nt);
21276   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21277
21278 bad_o:                          /* :::::::::::::::::::: */
21279   ffelex_token_kill (ffestb_local_.decl.recursive);
21280   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ot);
21281   ffelex_token_kill (ot);
21282   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21283 }
21284
21285 /* ffestb_decl_recursive1_ -- "RECURSIVE" generic-type
21286
21287    return ffestb_decl_recursive1_;  // to lexer
21288
21289    Handle ASTERISK, OPEN_PAREN, or NAME.  */
21290
21291 static ffelexHandler
21292 ffestb_decl_recursive1_ (ffelexToken t)
21293 {
21294   switch (ffelex_token_type (t))
21295     {
21296     case FFELEX_typeASTERISK:
21297       ffesta_confirmed ();
21298       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
21299       ffestb_local_.decl.badname = "TYPEFUNC";
21300       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
21301         return (ffelexHandler) ffestb_decl_starlen_;
21302       return (ffelexHandler) ffestb_decl_starkind_;
21303
21304     case FFELEX_typeOPEN_PAREN:
21305       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
21306       ffestb_local_.decl.badname = "TYPEFUNC";
21307       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
21308         {
21309           ffestb_local_.decl.kind = NULL;
21310           ffestb_local_.decl.kindt = NULL;
21311           ffestb_local_.decl.len = NULL;
21312           ffestb_local_.decl.lent = NULL;
21313           return (ffelexHandler) ffestb_decl_typeparams_;
21314         }
21315       return (ffelexHandler) ffestb_decl_kindparam_;
21316
21317     case FFELEX_typeNAME:
21318       ffestb_local_.decl.kind = NULL;
21319       ffestb_local_.decl.kindt = NULL;
21320       ffestb_local_.decl.len = NULL;
21321       ffestb_local_.decl.lent = NULL;
21322       return (ffelexHandler) ffestb_decl_func_ (t);
21323
21324     default:
21325       break;
21326     }
21327
21328   if (ffestb_local_.decl.recursive != NULL)
21329     ffelex_token_kill (ffestb_local_.decl.recursive);
21330   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21331   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21332 }
21333
21334 /* ffestb_decl_recursive2_ -- "RECURSIVE" "DOUBLE"
21335
21336    return ffestb_decl_recursive2_;  // to lexer
21337
21338    Handle NAME.  */
21339
21340 static ffelexHandler
21341 ffestb_decl_recursive2_ (ffelexToken t)
21342 {
21343   switch (ffelex_token_type (t))
21344     {
21345     case FFELEX_typeNAME:
21346       switch (ffestr_second (t))
21347         {
21348         case FFESTR_secondPRECISION:
21349           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
21350           break;
21351
21352         case FFESTR_secondCOMPLEX:
21353           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
21354           break;
21355
21356         default:
21357           goto bad;             /* :::::::::::::::::::: */
21358         }
21359       ffestb_local_.decl.kind = NULL;
21360       ffestb_local_.decl.kindt = NULL;
21361       ffestb_local_.decl.len = NULL;
21362       ffestb_local_.decl.lent = NULL;
21363       return (ffelexHandler) ffestb_decl_func_;
21364
21365     default:
21366       break;
21367     }
21368
21369 bad:                            /* :::::::::::::::::::: */
21370   if (ffestb_local_.decl.recursive != NULL)
21371     ffelex_token_kill (ffestb_local_.decl.recursive);
21372   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21373   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21374 }
21375
21376 /* ffestb_decl_recursive3_ -- "RECURSIVE" "TYPE"
21377
21378    return ffestb_decl_recursive3_;  // to lexer
21379
21380    Handle OPEN_PAREN.  */
21381
21382 static ffelexHandler
21383 ffestb_decl_recursive3_ (ffelexToken t)
21384 {
21385   switch (ffelex_token_type (t))
21386     {
21387     case FFELEX_typeOPEN_PAREN:
21388       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
21389       ffestb_local_.decl.badname = "TYPEFUNC";
21390       return (ffelexHandler) ffestb_decl_typetype1_;
21391
21392     default:
21393       break;
21394     }
21395
21396   if (ffestb_local_.decl.recursive != NULL)
21397     ffelex_token_kill (ffestb_local_.decl.recursive);
21398   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21399   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21400 }
21401
21402 /* ffestb_decl_recursive4_ -- "RECURSIVE" "FUNCTION/SUBROUTINE"
21403
21404    return ffestb_decl_recursive4_;  // to lexer
21405
21406    Handle OPEN_PAREN.  */
21407
21408 static ffelexHandler
21409 ffestb_decl_recursive4_ (ffelexToken t)
21410 {
21411   switch (ffelex_token_type (t))
21412     {
21413     case FFELEX_typeNAME:
21414       ffesta_tokens[1] = ffelex_token_use (t);
21415       return (ffelexHandler) ffestb_dummy1_;
21416
21417     default:
21418       break;
21419     }
21420
21421   if (ffestb_local_.decl.recursive != NULL)
21422     ffelex_token_kill (ffestb_local_.decl.recursive);
21423   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21424   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21425 }
21426
21427 #endif
21428 /* ffestb_decl_typetype -- Parse the R426/R501/R1219 TYPE statement
21429
21430    return ffestb_decl_typetype;  // to lexer
21431
21432    Make sure the statement has a valid form for the TYPE statement.  If it
21433    does, implement the statement.  */
21434
21435 #if FFESTR_F90
21436 ffelexHandler
21437 ffestb_decl_typetype (ffelexToken t)
21438 {
21439   switch (ffelex_token_type (ffesta_tokens[0]))
21440     {
21441     case FFELEX_typeNAME:
21442       if (ffesta_first_kw != FFESTR_firstTYPE)
21443         goto bad_0;             /* :::::::::::::::::::: */
21444       break;
21445
21446     case FFELEX_typeNAMES:
21447       if (ffesta_first_kw != FFESTR_firstTYPE)
21448         goto bad_0;             /* :::::::::::::::::::: */
21449       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlTYPE)
21450         goto bad_0;             /* :::::::::::::::::::: */
21451       break;
21452
21453     default:
21454       goto bad_0;               /* :::::::::::::::::::: */
21455     }
21456
21457   switch (ffelex_token_type (t))
21458     {
21459     case FFELEX_typeOPEN_PAREN:
21460       break;
21461
21462     case FFELEX_typeEOS:
21463     case FFELEX_typeSEMICOLON:
21464     case FFELEX_typeCOLONCOLON:/* Not COMMA: R424 "TYPE,PUBLIC::A". */
21465       ffesta_confirmed ();      /* Error, but clearly intended. */
21466       goto bad_1;               /* :::::::::::::::::::: */
21467
21468     default:
21469       goto bad_1;               /* :::::::::::::::::::: */
21470     }
21471
21472   ffestb_local_.decl.recursive = NULL;
21473   ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
21474   ffestb_local_.decl.coloncolon = FALSE;        /* No COLONCOLON seen. */
21475
21476   ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
21477   ffestb_local_.decl.badname = "type-declaration";
21478   return (ffelexHandler) ffestb_decl_typetype1_;
21479
21480 bad_0:                          /* :::::::::::::::::::: */
21481   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
21482   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21483
21484 bad_1:                          /* :::::::::::::::::::: */
21485   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21486   return (ffelexHandler) ffelex_swallow_tokens (t,
21487                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
21488 }
21489
21490 #endif
21491 /* ffestb_decl_attrs_ -- "type" [type parameters] COMMA
21492
21493    return ffestb_decl_attrs_;  // to lexer
21494
21495    Handle NAME of an attribute.  */
21496
21497 static ffelexHandler
21498 ffestb_decl_attrs_ (ffelexToken t)
21499 {
21500   switch (ffelex_token_type (t))
21501     {
21502     case FFELEX_typeNAME:
21503       switch (ffestr_first (t))
21504         {
21505 #if FFESTR_F90
21506         case FFESTR_firstALLOCATABLE:
21507           if (!ffesta_is_inhibited ())
21508             ffestc_decl_attrib (FFESTP_attribALLOCATABLE, t,
21509                                 FFESTR_otherNone, NULL);
21510           return (ffelexHandler) ffestb_decl_attrs_7_;
21511 #endif
21512
21513         case FFESTR_firstDIMENSION:
21514           ffesta_tokens[1] = ffelex_token_use (t);
21515           return (ffelexHandler) ffestb_decl_attrs_1_;
21516
21517         case FFESTR_firstEXTERNAL:
21518           if (!ffesta_is_inhibited ())
21519             ffestc_decl_attrib (FFESTP_attribEXTERNAL, t,
21520                                 FFESTR_otherNone, NULL);
21521           return (ffelexHandler) ffestb_decl_attrs_7_;
21522
21523 #if FFESTR_F90
21524         case FFESTR_firstINTENT:
21525           ffesta_tokens[1] = ffelex_token_use (t);
21526           return (ffelexHandler) ffestb_decl_attrs_3_;
21527 #endif
21528
21529         case FFESTR_firstINTRINSIC:
21530           if (!ffesta_is_inhibited ())
21531             ffestc_decl_attrib (FFESTP_attribINTRINSIC, t,
21532                                 FFESTR_otherNone, NULL);
21533           return (ffelexHandler) ffestb_decl_attrs_7_;
21534
21535 #if FFESTR_F90
21536         case FFESTR_firstOPTIONAL:
21537           if (!ffesta_is_inhibited ())
21538             ffestc_decl_attrib (FFESTP_attribOPTIONAL, t,
21539                                 FFESTR_otherNone, NULL);
21540           return (ffelexHandler) ffestb_decl_attrs_7_;
21541 #endif
21542
21543         case FFESTR_firstPARAMETER:
21544           ffestb_local_.decl.parameter = TRUE;
21545           if (!ffesta_is_inhibited ())
21546             ffestc_decl_attrib (FFESTP_attribPARAMETER, t,
21547                                 FFESTR_otherNone, NULL);
21548           return (ffelexHandler) ffestb_decl_attrs_7_;
21549
21550 #if FFESTR_F90
21551         case FFESTR_firstPOINTER:
21552           if (!ffesta_is_inhibited ())
21553             ffestc_decl_attrib (FFESTP_attribPOINTER, t,
21554                                 FFESTR_otherNone, NULL);
21555           return (ffelexHandler) ffestb_decl_attrs_7_;
21556 #endif
21557
21558 #if FFESTR_F90
21559         case FFESTR_firstPRIVATE:
21560           if (!ffesta_is_inhibited ())
21561             ffestc_decl_attrib (FFESTP_attribPRIVATE, t,
21562                                 FFESTR_otherNone, NULL);
21563           return (ffelexHandler) ffestb_decl_attrs_7_;
21564
21565         case FFESTR_firstPUBLIC:
21566           if (!ffesta_is_inhibited ())
21567             ffestc_decl_attrib (FFESTP_attribPUBLIC, t,
21568                                 FFESTR_otherNone, NULL);
21569           return (ffelexHandler) ffestb_decl_attrs_7_;
21570 #endif
21571
21572         case FFESTR_firstSAVE:
21573           if (!ffesta_is_inhibited ())
21574             ffestc_decl_attrib (FFESTP_attribSAVE, t,
21575                                 FFESTR_otherNone, NULL);
21576           return (ffelexHandler) ffestb_decl_attrs_7_;
21577
21578 #if FFESTR_F90
21579         case FFESTR_firstTARGET:
21580           if (!ffesta_is_inhibited ())
21581             ffestc_decl_attrib (FFESTP_attribTARGET, t,
21582                                 FFESTR_otherNone, NULL);
21583           return (ffelexHandler) ffestb_decl_attrs_7_;
21584 #endif
21585
21586         default:
21587           ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21588           return (ffelexHandler) ffestb_decl_attrs_7_;
21589         }
21590       break;
21591
21592     default:
21593       break;
21594     }
21595
21596   if (!ffesta_is_inhibited ())
21597     ffestc_decl_finish ();
21598   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21599   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21600 }
21601
21602 /* ffestb_decl_attrs_1_ -- "type" [type parameters] ",DIMENSION"
21603
21604    return ffestb_decl_attrs_1_;  // to lexer
21605
21606    Handle OPEN_PAREN.  */
21607
21608 static ffelexHandler
21609 ffestb_decl_attrs_1_ (ffelexToken t)
21610 {
21611   switch (ffelex_token_type (t))
21612     {
21613     case FFELEX_typeOPEN_PAREN:
21614       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
21615       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_decl_attrs_2_;
21616       ffestb_subrargs_.dim_list.pool = ffesta_scratch_pool;
21617       ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
21618         ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
21619 #ifdef FFECOM_dimensionsMAX
21620       ffestb_subrargs_.dim_list.ndims = 0;
21621 #endif
21622       return (ffelexHandler) ffeexpr_rhs (ffesta_scratch_pool,
21623                                           ffestb_subrargs_.dim_list.ctx,
21624                                     (ffeexprCallback) ffestb_subr_dimlist_);
21625
21626     case FFELEX_typeCOMMA:
21627     case FFELEX_typeCOLONCOLON:
21628       ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, ffesta_tokens[1]);
21629       ffelex_token_kill (ffesta_tokens[1]);
21630       return (ffelexHandler) ffestb_decl_attrs_7_ (t);
21631
21632     default:
21633       break;
21634     }
21635
21636   if (!ffesta_is_inhibited ())
21637     ffestc_decl_finish ();
21638   ffelex_token_kill (ffesta_tokens[1]);
21639   ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21640   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21641 }
21642
21643 /* ffestb_decl_attrs_2_ -- "type" [type parameters] ",DIMENSION" OPEN_PAREN
21644                           dimlist CLOSE_PAREN
21645
21646    return ffestb_decl_attrs_2_;  // to lexer
21647
21648    Handle COMMA or COLONCOLON.  */
21649
21650 static ffelexHandler
21651 ffestb_decl_attrs_2_ (ffelexToken t)
21652 {
21653   if (!ffestb_subrargs_.dim_list.ok)
21654     goto bad;                   /* :::::::::::::::::::: */
21655
21656   switch (ffelex_token_type (t))
21657     {
21658     case FFELEX_typeCOMMA:
21659     case FFELEX_typeCOLONCOLON:
21660       if (!ffesta_is_inhibited ())
21661         ffestc_decl_attrib (FFESTP_attribDIMENSION, ffesta_tokens[1],
21662                           FFESTR_otherNone, ffestb_subrargs_.dim_list.dims);
21663       ffelex_token_kill (ffesta_tokens[1]);
21664       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
21665       return (ffelexHandler) ffestb_decl_attrs_7_ (t);
21666
21667     default:
21668       break;
21669     }
21670
21671 bad:                            /* :::::::::::::::::::: */
21672   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21673   if (!ffesta_is_inhibited ())
21674     ffestc_decl_finish ();
21675   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
21676   ffelex_token_kill (ffesta_tokens[1]);
21677   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21678 }
21679
21680 /* ffestb_decl_attrs_3_ -- "type" [type parameters] ",INTENT"
21681
21682    return ffestb_decl_attrs_3_;  // to lexer
21683
21684    Handle OPEN_PAREN.  */
21685
21686 #if FFESTR_F90
21687 static ffelexHandler
21688 ffestb_decl_attrs_3_ (ffelexToken t)
21689 {
21690   switch (ffelex_token_type (t))
21691     {
21692     case FFELEX_typeOPEN_PAREN:
21693       return (ffelexHandler) ffestb_decl_attrs_4_;
21694
21695     case FFELEX_typeCOMMA:
21696     case FFELEX_typeCOLONCOLON:
21697       ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, ffesta_tokens[1]);
21698       ffelex_token_kill (ffesta_tokens[1]);
21699       return (ffelexHandler) ffestb_decl_attrs_7_ (t);
21700
21701     default:
21702       break;
21703     }
21704
21705   if (!ffesta_is_inhibited ())
21706     ffestc_decl_finish ();
21707   ffelex_token_kill (ffesta_tokens[1]);
21708   ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21709   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21710 }
21711
21712 /* ffestb_decl_attrs_4_ -- "type" [type parameters] ",INTENT" OPEN_PAREN
21713
21714    return ffestb_decl_attrs_4_;  // to lexer
21715
21716    Handle NAME.  */
21717
21718 static ffelexHandler
21719 ffestb_decl_attrs_4_ (ffelexToken t)
21720 {
21721   switch (ffelex_token_type (t))
21722     {
21723     case FFELEX_typeNAME:
21724       ffestb_local_.decl.kw = ffestr_other (t);
21725       switch (ffestb_local_.decl.kw)
21726         {
21727         case FFESTR_otherIN:
21728           return (ffelexHandler) ffestb_decl_attrs_5_;
21729
21730         case FFESTR_otherINOUT:
21731           return (ffelexHandler) ffestb_decl_attrs_6_;
21732
21733         case FFESTR_otherOUT:
21734           return (ffelexHandler) ffestb_decl_attrs_6_;
21735
21736         default:
21737           ffestb_local_.decl.kw = FFESTR_otherNone;
21738           ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21739           return (ffelexHandler) ffestb_decl_attrs_5_;
21740         }
21741       break;
21742
21743     default:
21744       break;
21745     }
21746
21747   if (!ffesta_is_inhibited ())
21748     ffestc_decl_finish ();
21749   ffelex_token_kill (ffesta_tokens[1]);
21750   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21751   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21752 }
21753
21754 /* ffestb_decl_attrs_5_ -- "type" [type parameters] ",INTENT" OPEN_PAREN "IN"
21755
21756    return ffestb_decl_attrs_5_;  // to lexer
21757
21758    Handle NAME or CLOSE_PAREN.  */
21759
21760 static ffelexHandler
21761 ffestb_decl_attrs_5_ (ffelexToken t)
21762 {
21763   switch (ffelex_token_type (t))
21764     {
21765     case FFELEX_typeNAME:
21766       switch (ffestr_other (t))
21767         {
21768         case FFESTR_otherOUT:
21769           if (ffestb_local_.decl.kw != FFESTR_otherNone)
21770             ffestb_local_.decl.kw = FFESTR_otherINOUT;
21771           return (ffelexHandler) ffestb_decl_attrs_6_;
21772
21773         default:
21774           if (ffestb_local_.decl.kw != FFESTR_otherNone)
21775             {
21776               ffestb_local_.decl.kw = FFESTR_otherNone;
21777               ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21778             }
21779           return (ffelexHandler) ffestb_decl_attrs_5_;
21780         }
21781       break;
21782
21783     case FFELEX_typeCLOSE_PAREN:
21784       return (ffelexHandler) ffestb_decl_attrs_6_ (t);
21785
21786     default:
21787       break;
21788     }
21789
21790   if (!ffesta_is_inhibited ())
21791     ffestc_decl_finish ();
21792   ffelex_token_kill (ffesta_tokens[1]);
21793   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21794   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21795 }
21796
21797 /* ffestb_decl_attrs_6_ -- "type" [type parameters] ",INTENT" OPEN_PAREN "IN"
21798                           ["OUT"]
21799
21800    return ffestb_decl_attrs_6_;  // to lexer
21801
21802    Handle CLOSE_PAREN.  */
21803
21804 static ffelexHandler
21805 ffestb_decl_attrs_6_ (ffelexToken t)
21806 {
21807   switch (ffelex_token_type (t))
21808     {
21809     case FFELEX_typeCLOSE_PAREN:
21810       if ((ffestb_local_.decl.kw != FFESTR_otherNone)
21811           && !ffesta_is_inhibited ())
21812         ffestc_decl_attrib (FFESTP_attribINTENT, ffesta_tokens[1],
21813                             ffestb_local_.decl.kw, NULL);
21814       ffelex_token_kill (ffesta_tokens[1]);
21815       return (ffelexHandler) ffestb_decl_attrs_7_;
21816
21817     default:
21818       break;
21819     }
21820
21821   if (!ffesta_is_inhibited ())
21822     ffestc_decl_finish ();
21823   ffelex_token_kill (ffesta_tokens[1]);
21824   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21825   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21826 }
21827
21828 #endif
21829 /* ffestb_decl_attrs_7_ -- "type" [type parameters] attribute
21830
21831    return ffestb_decl_attrs_7_;  // to lexer
21832
21833    Handle COMMA (another attribute) or COLONCOLON (entities).  */
21834
21835 static ffelexHandler
21836 ffestb_decl_attrs_7_ (ffelexToken t)
21837 {
21838   switch (ffelex_token_type (t))
21839     {
21840     case FFELEX_typeCOMMA:
21841       return (ffelexHandler) ffestb_decl_attrs_;
21842
21843     case FFELEX_typeCOLONCOLON:
21844       ffestb_local_.decl.coloncolon = TRUE;
21845       return (ffelexHandler) ffestb_decl_ents_;
21846
21847     default:
21848       break;
21849     }
21850
21851   if (!ffesta_is_inhibited ())
21852     ffestc_decl_finish ();
21853   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21854   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21855 }
21856
21857 /* ffestb_decl_attrsp_ -- "type" [type parameters]
21858
21859    return ffestb_decl_attrsp_;  // to lexer
21860
21861    Handle COMMA (meaning we have attributes), COLONCOLON (meaning we have
21862    no attributes but entities), or go to entsp to see about functions or
21863    entities.  */
21864
21865 static ffelexHandler
21866 ffestb_decl_attrsp_ (ffelexToken t)
21867 {
21868   ffelex_set_names (FALSE);
21869
21870   switch (ffelex_token_type (t))
21871     {
21872     case FFELEX_typeCOMMA:
21873       ffesta_confirmed ();
21874       if (!ffesta_is_inhibited ())
21875         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
21876                            ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
21877                            ffestb_local_.decl.len, ffestb_local_.decl.lent);
21878       if (ffestb_local_.decl.kindt != NULL)
21879         ffelex_token_kill (ffestb_local_.decl.kindt);
21880       if (ffestb_local_.decl.lent != NULL)
21881         ffelex_token_kill (ffestb_local_.decl.lent);
21882       return (ffelexHandler) ffestb_decl_attrs_;
21883
21884     case FFELEX_typeCOLONCOLON:
21885       ffestb_local_.decl.coloncolon = TRUE;
21886       ffesta_confirmed ();
21887       if (!ffesta_is_inhibited ())
21888         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
21889                            ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
21890                            ffestb_local_.decl.len, ffestb_local_.decl.lent);
21891       if (ffestb_local_.decl.kindt != NULL)
21892         ffelex_token_kill (ffestb_local_.decl.kindt);
21893       if (ffestb_local_.decl.lent != NULL)
21894         ffelex_token_kill (ffestb_local_.decl.lent);
21895       return (ffelexHandler) ffestb_decl_ents_;
21896
21897     default:
21898       return (ffelexHandler) ffestb_decl_entsp_ (t);
21899     }
21900 }
21901
21902 /* ffestb_decl_ents_ -- "type" [type parameters] [attributes "::"]
21903
21904    return ffestb_decl_ents_;  // to lexer
21905
21906    Handle NAME of an entity.  */
21907
21908 static ffelexHandler
21909 ffestb_decl_ents_ (ffelexToken t)
21910 {
21911   switch (ffelex_token_type (t))
21912     {
21913     case FFELEX_typeNAME:
21914       ffesta_tokens[1] = ffelex_token_use (t);
21915       return (ffelexHandler) ffestb_decl_ents_1_;
21916
21917     default:
21918       break;
21919     }
21920
21921   if (!ffesta_is_inhibited ())
21922     ffestc_decl_finish ();
21923   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21924   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21925 }
21926
21927 /* ffestb_decl_ents_1_ -- "type" [type parameters] [attributes "::"] NAME
21928
21929    return ffestb_decl_ents_1_;  // to lexer
21930
21931    Handle ASTERISK, OPEN_PAREN, EQUALS, SLASH, COMMA, or EOS/SEMICOLON.  */
21932
21933 static ffelexHandler
21934 ffestb_decl_ents_1_ (ffelexToken t)
21935 {
21936   switch (ffelex_token_type (t))
21937     {
21938     case FFELEX_typeCOMMA:
21939       if (!ffesta_is_inhibited ())
21940         ffestc_decl_item (ffesta_tokens[1], NULL, NULL, NULL, NULL, NULL, NULL,
21941                           NULL, FALSE);
21942       ffelex_token_kill (ffesta_tokens[1]);
21943       return (ffelexHandler) ffestb_decl_ents_;
21944
21945     case FFELEX_typeEOS:
21946     case FFELEX_typeSEMICOLON:
21947       if (!ffesta_is_inhibited ())
21948         {
21949           ffestc_decl_item (ffesta_tokens[1], NULL, NULL, NULL, NULL, NULL, NULL,
21950                             NULL, FALSE);
21951           ffestc_decl_finish ();
21952         }
21953       ffelex_token_kill (ffesta_tokens[1]);
21954       return (ffelexHandler) ffesta_zero (t);
21955
21956     case FFELEX_typeASTERISK:
21957       ffestb_local_.decl.len = NULL;
21958       ffestb_local_.decl.lent = NULL;
21959       return (ffelexHandler) ffestb_decl_ents_2_;
21960
21961     case FFELEX_typeOPEN_PAREN:
21962       ffestb_local_.decl.kind = NULL;
21963       ffestb_local_.decl.kindt = NULL;
21964       ffestb_local_.decl.len = NULL;
21965       ffestb_local_.decl.lent = NULL;
21966       return (ffelexHandler) ffestb_decl_ents_3_ (t);
21967
21968     case FFELEX_typeEQUALS:
21969     case FFELEX_typeSLASH:
21970       ffestb_local_.decl.kind = NULL;
21971       ffestb_local_.decl.kindt = NULL;
21972       ffestb_subrargs_.dim_list.dims = NULL;
21973       ffestb_local_.decl.len = NULL;
21974       ffestb_local_.decl.lent = NULL;
21975       return (ffelexHandler) ffestb_decl_ents_7_ (t);
21976
21977     default:
21978       break;
21979     }
21980
21981   if (!ffesta_is_inhibited ())
21982     ffestc_decl_finish ();
21983   ffelex_token_kill (ffesta_tokens[1]);
21984   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21985   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21986 }
21987
21988 /* ffestb_decl_ents_2_ -- "type" [type parameters] [attributes "::"] NAME
21989                          ASTERISK
21990
21991    return ffestb_decl_ents_2_;  // to lexer
21992
21993    Handle NUMBER or OPEN_PAREN.  */
21994
21995 static ffelexHandler
21996 ffestb_decl_ents_2_ (ffelexToken t)
21997 {
21998   switch (ffelex_token_type (t))
21999     {
22000     case FFELEX_typeNUMBER:
22001       if (ffestb_local_.decl.type != FFESTP_typeCHARACTER)
22002         {
22003           ffestb_local_.decl.kind = NULL;
22004           ffestb_local_.decl.kindt = ffelex_token_use (t);
22005           return (ffelexHandler) ffestb_decl_ents_3_;
22006         }
22007       /* Fall through. *//* (CHARACTER's *n is always a len spec. */
22008     case FFELEX_typeOPEN_PAREN:/* "*(" is after the (omitted)
22009                                    "(array-spec)". */
22010       ffestb_local_.decl.kind = NULL;
22011       ffestb_local_.decl.kindt = NULL;
22012       ffestb_subrargs_.dim_list.dims = NULL;
22013       return (ffelexHandler) ffestb_decl_ents_5_ (t);
22014
22015     default:
22016       break;
22017     }
22018
22019   if (!ffesta_is_inhibited ())
22020     ffestc_decl_finish ();
22021   ffelex_token_kill (ffesta_tokens[1]);
22022   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22023   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22024 }
22025
22026 /* ffestb_decl_ents_3_ -- "type" [type parameters] [attributes "::"] NAME
22027                          [ASTERISK NUMBER]
22028
22029    return ffestb_decl_ents_3_;  // to lexer
22030
22031    Handle ASTERISK, OPEN_PAREN, EQUALS, SLASH, COMMA, or EOS/SEMICOLON.  */
22032
22033 static ffelexHandler
22034 ffestb_decl_ents_3_ (ffelexToken t)
22035 {
22036   switch (ffelex_token_type (t))
22037     {
22038     case FFELEX_typeCOMMA:
22039       if (!ffesta_is_inhibited ())
22040         ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22041              ffestb_local_.decl.kindt, NULL, NULL, NULL, NULL, NULL, FALSE);
22042       ffelex_token_kill (ffesta_tokens[1]);
22043       if (ffestb_local_.decl.kindt != NULL)
22044         ffelex_token_kill (ffestb_local_.decl.kindt);
22045       return (ffelexHandler) ffestb_decl_ents_;
22046
22047     case FFELEX_typeEOS:
22048     case FFELEX_typeSEMICOLON:
22049       if (!ffesta_is_inhibited ())
22050         {
22051           ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22052              ffestb_local_.decl.kindt, NULL, NULL, NULL, NULL, NULL, FALSE);
22053           ffestc_decl_finish ();
22054         }
22055       ffelex_token_kill (ffesta_tokens[1]);
22056       if (ffestb_local_.decl.kindt != NULL)
22057         ffelex_token_kill (ffestb_local_.decl.kindt);
22058       return (ffelexHandler) ffesta_zero (t);
22059
22060     case FFELEX_typeASTERISK:
22061       ffestb_subrargs_.dim_list.dims = NULL;
22062       return (ffelexHandler) ffestb_decl_ents_5_;
22063
22064     case FFELEX_typeOPEN_PAREN:
22065       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
22066       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_decl_ents_4_;
22067       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
22068       ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
22069         ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
22070 #ifdef FFECOM_dimensionsMAX
22071       ffestb_subrargs_.dim_list.ndims = 0;
22072 #endif
22073       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22074                                           ffestb_subrargs_.dim_list.ctx,
22075                                     (ffeexprCallback) ffestb_subr_dimlist_);
22076
22077     case FFELEX_typeEQUALS:
22078     case FFELEX_typeSLASH:
22079       ffestb_local_.decl.kind = NULL;
22080       ffestb_local_.decl.kindt = NULL;
22081       ffestb_subrargs_.dim_list.dims = NULL;
22082       ffestb_local_.decl.len = NULL;
22083       ffestb_local_.decl.lent = NULL;
22084       return (ffelexHandler) ffestb_decl_ents_7_ (t);
22085
22086     default:
22087       break;
22088     }
22089
22090   if (!ffesta_is_inhibited ())
22091     ffestc_decl_finish ();
22092   ffelex_token_kill (ffesta_tokens[1]);
22093   if (ffestb_local_.decl.kindt != NULL)
22094     ffelex_token_kill (ffestb_local_.decl.kindt);
22095   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22096   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22097 }
22098
22099 /* ffestb_decl_ents_4_ -- "type" [type parameters] [attributes "::"] NAME
22100                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22101
22102    return ffestb_decl_ents_4_;  // to lexer
22103
22104    Handle ASTERISK, EQUALS, SLASH, COMMA, or EOS/SEMICOLON.  */
22105
22106 static ffelexHandler
22107 ffestb_decl_ents_4_ (ffelexToken t)
22108 {
22109   ffelexToken nt;
22110
22111   if (!ffestb_subrargs_.dim_list.ok)
22112     goto bad;                   /* :::::::::::::::::::: */
22113
22114   if (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeNAMES)
22115     {
22116       switch (ffelex_token_type (t))
22117         {
22118         case FFELEX_typeCOMMA:
22119         case FFELEX_typeEOS:
22120         case FFELEX_typeSEMICOLON:
22121         case FFELEX_typeASTERISK:
22122         case FFELEX_typeSLASH:  /* But NOT FFELEX_typeEQUALS. */
22123         case FFELEX_typeCOLONCOLON:     /* Actually an error. */
22124           break;                /* Confirm and handle. */
22125
22126         default:                /* Perhaps EQUALS, as in
22127                                    INTEGERFUNCTIONX(A)=B. */
22128           goto bad;             /* :::::::::::::::::::: */
22129         }
22130       ffesta_confirmed ();
22131       if (!ffesta_is_inhibited ())
22132         {
22133           nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
22134           ffelex_token_kill (ffesta_tokens[1]);
22135           ffesta_tokens[1] = nt;
22136           ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
22137                              NULL, NULL, NULL, NULL);
22138         }
22139     }
22140
22141   switch (ffelex_token_type (t))
22142     {
22143     case FFELEX_typeCOMMA:
22144       if (!ffesta_is_inhibited ())
22145         ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22146                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22147                 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22148                           FALSE);
22149       ffelex_token_kill (ffesta_tokens[1]);
22150       if (ffestb_local_.decl.kindt != NULL)
22151         ffelex_token_kill (ffestb_local_.decl.kindt);
22152       if (ffestb_local_.decl.lent != NULL)
22153         ffelex_token_kill (ffestb_local_.decl.lent);
22154       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22155       return (ffelexHandler) ffestb_decl_ents_;
22156
22157     case FFELEX_typeEOS:
22158     case FFELEX_typeSEMICOLON:
22159       if (!ffesta_is_inhibited ())
22160         {
22161           ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22162                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22163                 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22164                             FALSE);
22165           ffestc_decl_finish ();
22166         }
22167       ffelex_token_kill (ffesta_tokens[1]);
22168       if (ffestb_local_.decl.kindt != NULL)
22169         ffelex_token_kill (ffestb_local_.decl.kindt);
22170       if (ffestb_local_.decl.lent != NULL)
22171         ffelex_token_kill (ffestb_local_.decl.lent);
22172       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22173       return (ffelexHandler) ffesta_zero (t);
22174
22175     case FFELEX_typeASTERISK:
22176       if (ffestb_local_.decl.lent != NULL)
22177         break;                  /* Can't specify "*length" twice. */
22178       return (ffelexHandler) ffestb_decl_ents_5_;
22179
22180     case FFELEX_typeEQUALS:
22181     case FFELEX_typeSLASH:
22182       return (ffelexHandler) ffestb_decl_ents_7_ (t);
22183
22184     default:
22185       break;
22186     }
22187
22188 bad:                            /* :::::::::::::::::::: */
22189   if ((ffelex_token_type (ffesta_tokens[1]) != FFELEX_typeNAMES)
22190       && !ffesta_is_inhibited ())
22191     ffestc_decl_finish ();
22192   ffelex_token_kill (ffesta_tokens[1]);
22193   if (ffestb_local_.decl.kindt != NULL)
22194     ffelex_token_kill (ffestb_local_.decl.kindt);
22195   if (ffestb_local_.decl.lent != NULL)
22196     ffelex_token_kill (ffestb_local_.decl.lent);
22197   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22198   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22199   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22200 }
22201
22202 /* ffestb_decl_ents_5_ -- "type" [type parameters] [attributes "::"] NAME
22203                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22204                          ASTERISK
22205
22206    return ffestb_decl_ents_5_;  // to lexer
22207
22208    Handle NUMBER or OPEN_PAREN.  */
22209
22210 static ffelexHandler
22211 ffestb_decl_ents_5_ (ffelexToken t)
22212 {
22213   switch (ffelex_token_type (t))
22214     {
22215     case FFELEX_typeNUMBER:
22216       ffestb_local_.decl.len = NULL;
22217       ffestb_local_.decl.lent = ffelex_token_use (t);
22218       return (ffelexHandler) ffestb_decl_ents_7_;
22219
22220     case FFELEX_typeOPEN_PAREN:
22221       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22222        FFEEXPR_contextCHARACTERSIZE, (ffeexprCallback) ffestb_decl_ents_6_);
22223
22224     default:
22225       break;
22226     }
22227
22228   if (!ffesta_is_inhibited ())
22229     ffestc_decl_finish ();
22230   ffelex_token_kill (ffesta_tokens[1]);
22231   if (ffestb_local_.decl.kindt != NULL)
22232     ffelex_token_kill (ffestb_local_.decl.kindt);
22233   if (ffestb_subrargs_.dim_list.dims != NULL)
22234     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22235   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22236   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22237 }
22238
22239 /* ffestb_decl_ents_6_ -- "type" [type parameters] [attributes "::"] NAME
22240                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22241                          ASTERISK OPEN_PAREN expr
22242
22243    (ffestb_decl_ents_6_)  // to expression handler
22244
22245    Handle CLOSE_PAREN.  */
22246
22247 static ffelexHandler
22248 ffestb_decl_ents_6_ (ffelexToken ft, ffebld expr, ffelexToken t)
22249 {
22250   switch (ffelex_token_type (t))
22251     {
22252     case FFELEX_typeCLOSE_PAREN:
22253       if (expr == NULL)
22254         break;
22255       ffestb_local_.decl.len = expr;
22256       ffestb_local_.decl.lent = ffelex_token_use (ft);
22257       return (ffelexHandler) ffestb_decl_ents_7_;
22258
22259     default:
22260       break;
22261     }
22262
22263   if (!ffesta_is_inhibited ())
22264     ffestc_decl_finish ();
22265   ffelex_token_kill (ffesta_tokens[1]);
22266   if (ffestb_local_.decl.kindt != NULL)
22267     ffelex_token_kill (ffestb_local_.decl.kindt);
22268   if (ffestb_subrargs_.dim_list.dims != NULL)
22269     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22270   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22271   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22272 }
22273
22274 /* ffestb_decl_ents_7_ -- "type" [type parameters] [attributes "::"] NAME
22275                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22276                          [ASTERISK charlength]
22277
22278    return ffestb_decl_ents_7_;  // to lexer
22279
22280    Handle EQUALS, SLASH, COMMA, or EOS/SEMICOLON.  */
22281
22282 static ffelexHandler
22283 ffestb_decl_ents_7_ (ffelexToken t)
22284 {
22285   switch (ffelex_token_type (t))
22286     {
22287     case FFELEX_typeCOMMA:
22288       if (!ffesta_is_inhibited ())
22289         ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22290                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22291                 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22292                           FALSE);
22293       ffelex_token_kill (ffesta_tokens[1]);
22294       if (ffestb_local_.decl.kindt != NULL)
22295         ffelex_token_kill (ffestb_local_.decl.kindt);
22296       if (ffestb_subrargs_.dim_list.dims != NULL)
22297         ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22298       if (ffestb_local_.decl.lent != NULL)
22299         ffelex_token_kill (ffestb_local_.decl.lent);
22300       return (ffelexHandler) ffestb_decl_ents_;
22301
22302     case FFELEX_typeEOS:
22303     case FFELEX_typeSEMICOLON:
22304       if (!ffesta_is_inhibited ())
22305         {
22306           ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22307                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22308                 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22309                             FALSE);
22310           ffestc_decl_finish ();
22311         }
22312       ffelex_token_kill (ffesta_tokens[1]);
22313       if (ffestb_local_.decl.kindt != NULL)
22314         ffelex_token_kill (ffestb_local_.decl.kindt);
22315       if (ffestb_subrargs_.dim_list.dims != NULL)
22316         ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22317       if (ffestb_local_.decl.lent != NULL)
22318         ffelex_token_kill (ffestb_local_.decl.lent);
22319       return (ffelexHandler) ffesta_zero (t);
22320
22321     case FFELEX_typeEQUALS:
22322       if (!ffestb_local_.decl.coloncolon)
22323         ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_INIT, t);
22324       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22325                      ffestb_local_.decl.parameter ? FFEEXPR_contextPARAMETER
22326            : FFEEXPR_contextINITVAL, (ffeexprCallback) ffestb_decl_ents_8_);
22327
22328     case FFELEX_typeSLASH:
22329       if (!ffesta_is_inhibited ())
22330         {
22331           ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22332                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22333                 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22334                             TRUE);
22335           ffestc_decl_itemstartvals ();
22336         }
22337       ffelex_token_kill (ffesta_tokens[1]);
22338       if (ffestb_local_.decl.kindt != NULL)
22339         ffelex_token_kill (ffestb_local_.decl.kindt);
22340       if (ffestb_subrargs_.dim_list.dims != NULL)
22341         ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22342       if (ffestb_local_.decl.lent != NULL)
22343         ffelex_token_kill (ffestb_local_.decl.lent);
22344       return (ffelexHandler) ffeexpr_rhs
22345         (ffesta_output_pool, FFEEXPR_contextDATA,
22346          (ffeexprCallback) ffestb_decl_ents_9_);
22347
22348     default:
22349       break;
22350     }
22351
22352   if (!ffesta_is_inhibited ())
22353     ffestc_decl_finish ();
22354   ffelex_token_kill (ffesta_tokens[1]);
22355   if (ffestb_local_.decl.kindt != NULL)
22356     ffelex_token_kill (ffestb_local_.decl.kindt);
22357   if (ffestb_subrargs_.dim_list.dims != NULL)
22358     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22359   if (ffestb_local_.decl.lent != NULL)
22360     ffelex_token_kill (ffestb_local_.decl.lent);
22361   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22362   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22363 }
22364
22365 /* ffestb_decl_ents_8_ -- "type" [type parameters] [attributes "::"] NAME
22366                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22367                          [ASTERISK charlength] EQUALS expr
22368
22369    (ffestb_decl_ents_8_)  // to expression handler
22370
22371    Handle COMMA or EOS/SEMICOLON.  */
22372
22373 static ffelexHandler
22374 ffestb_decl_ents_8_ (ffelexToken ft, ffebld expr, ffelexToken t)
22375 {
22376   switch (ffelex_token_type (t))
22377     {
22378     case FFELEX_typeCOMMA:
22379       if (expr == NULL)
22380         break;
22381       if (!ffesta_is_inhibited ())
22382         ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22383                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22384                   ffestb_local_.decl.len, ffestb_local_.decl.lent, expr, ft,
22385                           FALSE);
22386       ffelex_token_kill (ffesta_tokens[1]);
22387       if (ffestb_local_.decl.kindt != NULL)
22388         ffelex_token_kill (ffestb_local_.decl.kindt);
22389       if (ffestb_subrargs_.dim_list.dims != NULL)
22390         ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22391       if (ffestb_local_.decl.lent != NULL)
22392         ffelex_token_kill (ffestb_local_.decl.lent);
22393       return (ffelexHandler) ffestb_decl_ents_;
22394
22395     case FFELEX_typeEOS:
22396     case FFELEX_typeSEMICOLON:
22397       if (!ffesta_is_inhibited ())
22398         {
22399           ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22400                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22401                   ffestb_local_.decl.len, ffestb_local_.decl.lent, expr, ft,
22402                             FALSE);
22403           ffestc_decl_finish ();
22404         }
22405       ffelex_token_kill (ffesta_tokens[1]);
22406       if (ffestb_local_.decl.kindt != NULL)
22407         ffelex_token_kill (ffestb_local_.decl.kindt);
22408       if (ffestb_subrargs_.dim_list.dims != NULL)
22409         ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22410       if (ffestb_local_.decl.lent != NULL)
22411         ffelex_token_kill (ffestb_local_.decl.lent);
22412       return (ffelexHandler) ffesta_zero (t);
22413
22414     default:
22415       break;
22416     }
22417
22418   if (!ffesta_is_inhibited ())
22419     ffestc_decl_finish ();
22420   ffelex_token_kill (ffesta_tokens[1]);
22421   if (ffestb_local_.decl.kindt != NULL)
22422     ffelex_token_kill (ffestb_local_.decl.kindt);
22423   if (ffestb_subrargs_.dim_list.dims != NULL)
22424     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22425   if (ffestb_local_.decl.lent != NULL)
22426     ffelex_token_kill (ffestb_local_.decl.lent);
22427   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22428   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22429 }
22430
22431 /* ffestb_decl_ents_9_ -- "type" ... SLASH expr
22432
22433    (ffestb_decl_ents_9_)  // to expression handler
22434
22435    Handle ASTERISK, COMMA, or SLASH.  */
22436
22437 static ffelexHandler
22438 ffestb_decl_ents_9_ (ffelexToken ft, ffebld expr, ffelexToken t)
22439 {
22440   switch (ffelex_token_type (t))
22441     {
22442     case FFELEX_typeCOMMA:
22443       if (expr == NULL)
22444         break;
22445       if (!ffesta_is_inhibited ())
22446         ffestc_decl_itemvalue (NULL, NULL, expr, ft);
22447       return (ffelexHandler) ffeexpr_rhs
22448         (ffesta_output_pool, FFEEXPR_contextDATA,
22449          (ffeexprCallback) ffestb_decl_ents_9_);
22450
22451     case FFELEX_typeASTERISK:
22452       if (expr == NULL)
22453         break;
22454       ffestb_local_.decl.expr = expr;
22455       ffesta_tokens[1] = ffelex_token_use (ft);
22456       return (ffelexHandler) ffeexpr_rhs
22457         (ffesta_output_pool, FFEEXPR_contextDATA,
22458          (ffeexprCallback) ffestb_decl_ents_10_);
22459
22460     case FFELEX_typeSLASH:
22461       if (expr == NULL)
22462         break;
22463       if (!ffesta_is_inhibited ())
22464         {
22465           ffestc_decl_itemvalue (NULL, NULL, expr, ft);
22466           ffestc_decl_itemendvals (t);
22467         }
22468       return (ffelexHandler) ffestb_decl_ents_11_;
22469
22470     default:
22471       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22472       break;
22473     }
22474
22475   if (!ffesta_is_inhibited ())
22476     {
22477       ffestc_decl_itemendvals (t);
22478       ffestc_decl_finish ();
22479     }
22480   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22481 }
22482
22483 /* ffestb_decl_ents_10_ -- "type" ... SLASH expr ASTERISK expr
22484
22485    (ffestb_decl_ents_10_)  // to expression handler
22486
22487    Handle COMMA or SLASH.  */
22488
22489 static ffelexHandler
22490 ffestb_decl_ents_10_ (ffelexToken ft, ffebld expr, ffelexToken t)
22491 {
22492   switch (ffelex_token_type (t))
22493     {
22494     case FFELEX_typeCOMMA:
22495       if (expr == NULL)
22496         break;
22497       if (!ffesta_is_inhibited ())
22498         ffestc_decl_itemvalue (ffestb_local_.decl.expr, ffesta_tokens[1],
22499                                expr, ft);
22500       ffelex_token_kill (ffesta_tokens[1]);
22501       return (ffelexHandler) ffeexpr_rhs
22502         (ffesta_output_pool, FFEEXPR_contextDATA,
22503          (ffeexprCallback) ffestb_decl_ents_9_);
22504
22505     case FFELEX_typeSLASH:
22506       if (expr == NULL)
22507         break;
22508       if (!ffesta_is_inhibited ())
22509         {
22510           ffestc_decl_itemvalue (ffestb_local_.decl.expr, ffesta_tokens[1],
22511                                  expr, ft);
22512           ffestc_decl_itemendvals (t);
22513         }
22514       ffelex_token_kill (ffesta_tokens[1]);
22515       return (ffelexHandler) ffestb_decl_ents_11_;
22516
22517     default:
22518       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22519       break;
22520     }
22521
22522   if (!ffesta_is_inhibited ())
22523     {
22524       ffestc_decl_itemendvals (t);
22525       ffestc_decl_finish ();
22526     }
22527   ffelex_token_kill (ffesta_tokens[1]);
22528   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22529 }
22530
22531 /* ffestb_decl_ents_11_ -- "type" [type parameters] [attributes "::"] NAME
22532                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22533                          [ASTERISK charlength] SLASH initvals SLASH
22534
22535    return ffestb_decl_ents_11_;  // to lexer
22536
22537    Handle COMMA or EOS/SEMICOLON.  */
22538
22539 static ffelexHandler
22540 ffestb_decl_ents_11_ (ffelexToken t)
22541 {
22542   switch (ffelex_token_type (t))
22543     {
22544     case FFELEX_typeCOMMA:
22545       return (ffelexHandler) ffestb_decl_ents_;
22546
22547     case FFELEX_typeEOS:
22548     case FFELEX_typeSEMICOLON:
22549       if (!ffesta_is_inhibited ())
22550         ffestc_decl_finish ();
22551       return (ffelexHandler) ffesta_zero (t);
22552
22553     default:
22554       break;
22555     }
22556
22557   if (!ffesta_is_inhibited ())
22558     ffestc_decl_finish ();
22559   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22560   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22561 }
22562
22563 /* ffestb_decl_entsp_ -- "type" [type parameters]
22564
22565    return ffestb_decl_entsp_;  // to lexer
22566
22567    Handle NAME or NAMES beginning either an entity (object) declaration or
22568    a function definition..  */
22569
22570 static ffelexHandler
22571 ffestb_decl_entsp_ (ffelexToken t)
22572 {
22573   switch (ffelex_token_type (t))
22574     {
22575     case FFELEX_typeNAME:
22576       ffesta_confirmed ();
22577       ffesta_tokens[1] = ffelex_token_use (t);
22578       return (ffelexHandler) ffestb_decl_entsp_1_;
22579
22580     case FFELEX_typeNAMES:
22581       ffesta_confirmed ();
22582       ffesta_tokens[1] = ffelex_token_use (t);
22583       return (ffelexHandler) ffestb_decl_entsp_2_;
22584
22585     default:
22586       break;
22587     }
22588
22589   if (ffestb_local_.decl.kindt != NULL)
22590     ffelex_token_kill (ffestb_local_.decl.kindt);
22591   if (ffestb_local_.decl.lent != NULL)
22592     ffelex_token_kill (ffestb_local_.decl.lent);
22593   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22594   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22595 }
22596
22597 /* ffestb_decl_entsp_1_ -- "type" [type parameters] NAME
22598
22599    return ffestb_decl_entsp_1_;  // to lexer
22600
22601    If we get another NAME token here, then the previous one must be
22602    "RECURSIVE" or "FUNCTION" and we handle it accordingly.  Otherwise,
22603    we send the previous and current token through to _ents_.  */
22604
22605 static ffelexHandler
22606 ffestb_decl_entsp_1_ (ffelexToken t)
22607 {
22608   switch (ffelex_token_type (t))
22609     {
22610     case FFELEX_typeNAME:
22611       switch (ffestr_first (ffesta_tokens[1]))
22612         {
22613 #if FFESTR_F90
22614         case FFESTR_firstRECURSIVE:
22615           if (ffestr_first (t) != FFESTR_firstFUNCTION)
22616             {
22617               ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22618               break;
22619             }
22620           ffestb_local_.decl.recursive = ffesta_tokens[1];
22621           return (ffelexHandler) ffestb_decl_funcname_;
22622 #endif
22623
22624         case FFESTR_firstFUNCTION:
22625           ffelex_token_kill (ffesta_tokens[1]);
22626           return (ffelexHandler) ffestb_decl_funcname_ (t);
22627
22628         default:
22629           ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ffesta_tokens[1]);
22630           break;
22631         }
22632       break;
22633
22634     default:
22635       if ((ffelex_token_type (ffesta_tokens[1]) != FFELEX_typeNAMES)
22636           && !ffesta_is_inhibited ())
22637         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
22638                            ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
22639                            ffestb_local_.decl.len, ffestb_local_.decl.lent);
22640       if (ffestb_local_.decl.kindt != NULL)
22641         ffelex_token_kill (ffestb_local_.decl.kindt);
22642       if (ffestb_local_.decl.lent != NULL)
22643         ffelex_token_kill (ffestb_local_.decl.lent);
22644       /* NAME/NAMES token already in ffesta_tokens[1]. */
22645       return (ffelexHandler) ffestb_decl_ents_1_ (t);
22646     }
22647
22648   if (ffestb_local_.decl.kindt != NULL)
22649     ffelex_token_kill (ffestb_local_.decl.kindt);
22650   if (ffestb_local_.decl.lent != NULL)
22651     ffelex_token_kill (ffestb_local_.decl.lent);
22652   ffelex_token_kill (ffesta_tokens[1]);
22653   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22654 }
22655
22656 /* ffestb_decl_entsp_2_ -- "type" [type parameters] NAMES
22657
22658    return ffestb_decl_entsp_2_;  // to lexer
22659
22660    If we get an ASTERISK or OPEN_PAREN here, then if the previous NAMES
22661    begins with "FUNCTION" or "RECURSIVEFUNCTION" and is followed by a
22662    first-name-char, we have a possible syntactically ambiguous situation.
22663    Otherwise, we have a straightforward situation just as if we went
22664    through _entsp_1_ instead of here.  */
22665
22666 static ffelexHandler
22667 ffestb_decl_entsp_2_ (ffelexToken t)
22668 {
22669   ffelexToken nt;
22670   bool asterisk_ok;
22671   char *p;
22672   ffeTokenLength i;
22673
22674   switch (ffelex_token_type (t))
22675     {
22676     case FFELEX_typeASTERISK:
22677       ffesta_confirmed ();
22678       switch (ffestb_local_.decl.type)
22679         {
22680         case FFESTP_typeINTEGER:
22681         case FFESTP_typeREAL:
22682         case FFESTP_typeCOMPLEX:
22683         case FFESTP_typeLOGICAL:
22684           asterisk_ok = (ffestb_local_.decl.kindt == NULL);
22685           break;
22686
22687         case FFESTP_typeCHARACTER:
22688           asterisk_ok = (ffestb_local_.decl.lent == NULL);
22689           break;
22690
22691         case FFESTP_typeBYTE:
22692         case FFESTP_typeWORD:
22693         default:
22694           asterisk_ok = FALSE;
22695           break;
22696         }
22697       switch (ffestr_first (ffesta_tokens[1]))
22698         {
22699 #if FFESTR_F90
22700         case FFESTR_firstRECURSIVEFNCTN:
22701           if (!asterisk_ok)
22702             break;              /* For our own convenience, treat as non-FN
22703                                    stmt. */
22704           p = ffelex_token_text (ffesta_tokens[1])
22705             + (i = FFESTR_firstlRECURSIVEFNCTN);
22706           if (!ffesrc_is_name_init (*p))
22707             break;
22708           ffestb_local_.decl.recursive
22709             = ffelex_token_name_from_names (ffesta_tokens[1], 0,
22710                                             FFESTR_firstlRECURSIVEFNCTN);
22711           ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22712                                             FFESTR_firstlRECURSIVEFNCTN, 0);
22713           return (ffelexHandler) ffestb_decl_entsp_3_;
22714 #endif
22715
22716         case FFESTR_firstFUNCTION:
22717           if (!asterisk_ok)
22718             break;              /* For our own convenience, treat as non-FN
22719                                    stmt. */
22720           p = ffelex_token_text (ffesta_tokens[1])
22721             + (i = FFESTR_firstlFUNCTION);
22722           if (!ffesrc_is_name_init (*p))
22723             break;
22724           ffestb_local_.decl.recursive = NULL;
22725           ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22726                                                   FFESTR_firstlFUNCTION, 0);
22727           return (ffelexHandler) ffestb_decl_entsp_3_;
22728
22729         default:
22730           break;
22731         }
22732       break;
22733
22734     case FFELEX_typeOPEN_PAREN:
22735       ffestb_local_.decl.aster_after = FALSE;
22736       switch (ffestr_first (ffesta_tokens[1]))
22737         {
22738 #if FFESTR_F90
22739         case FFESTR_firstRECURSIVEFNCTN:
22740           p = ffelex_token_text (ffesta_tokens[1])
22741             + (i = FFESTR_firstlRECURSIVEFNCTN);
22742           if (!ffesrc_is_name_init (*p))
22743             break;
22744           ffestb_local_.decl.recursive
22745             = ffelex_token_name_from_names (ffesta_tokens[1], 0,
22746                                             FFESTR_firstlRECURSIVEFNCTN);
22747           ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22748                                             FFESTR_firstlRECURSIVEFNCTN, 0);
22749           return (ffelexHandler) ffestb_decl_entsp_5_ (t);
22750 #endif
22751
22752         case FFESTR_firstFUNCTION:
22753           p = ffelex_token_text (ffesta_tokens[1])
22754             + (i = FFESTR_firstlFUNCTION);
22755           if (!ffesrc_is_name_init (*p))
22756             break;
22757           ffestb_local_.decl.recursive = NULL;
22758           ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22759                                                   FFESTR_firstlFUNCTION, 0);
22760           return (ffelexHandler) ffestb_decl_entsp_5_ (t);
22761
22762         default:
22763           break;
22764         }
22765       if ((ffestb_local_.decl.kindt != NULL)
22766           || (ffestb_local_.decl.lent != NULL))
22767         break;                  /* Have kind/len type param, definitely not
22768                                    assignment stmt. */
22769       return (ffelexHandler) ffestb_decl_entsp_1_ (t);
22770
22771     default:
22772       break;
22773     }
22774
22775   nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
22776   ffelex_token_kill (ffesta_tokens[1]);
22777   ffesta_tokens[1] = nt;        /* Change NAMES to NAME. */
22778   return (ffelexHandler) ffestb_decl_entsp_1_ (t);
22779 }
22780
22781 /* ffestb_decl_entsp_3_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22782                              NAME ASTERISK
22783
22784    return ffestb_decl_entsp_3_;  // to lexer
22785
22786    Handle NUMBER or OPEN_PAREN.  */
22787
22788 static ffelexHandler
22789 ffestb_decl_entsp_3_ (ffelexToken t)
22790 {
22791   ffestb_local_.decl.aster_after = TRUE;
22792
22793   switch (ffelex_token_type (t))
22794     {
22795     case FFELEX_typeNUMBER:
22796       switch (ffestb_local_.decl.type)
22797         {
22798         case FFESTP_typeINTEGER:
22799         case FFESTP_typeREAL:
22800         case FFESTP_typeCOMPLEX:
22801         case FFESTP_typeLOGICAL:
22802           ffestb_local_.decl.kindt = ffelex_token_use (t);
22803           break;
22804
22805         case FFESTP_typeCHARACTER:
22806           ffestb_local_.decl.lent = ffelex_token_use (t);
22807           break;
22808
22809         case FFESTP_typeBYTE:
22810         case FFESTP_typeWORD:
22811         default:
22812           assert (FALSE);
22813         }
22814       return (ffelexHandler) ffestb_decl_entsp_5_;
22815
22816     case FFELEX_typeOPEN_PAREN:
22817       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22818                                           FFEEXPR_contextCHARACTERSIZE,
22819                                     (ffeexprCallback) ffestb_decl_entsp_4_);
22820
22821     default:
22822       break;
22823     }
22824
22825   if (ffestb_local_.decl.recursive != NULL)
22826     ffelex_token_kill (ffestb_local_.decl.recursive);
22827   if (ffestb_local_.decl.kindt != NULL)
22828     ffelex_token_kill (ffestb_local_.decl.kindt);
22829   if (ffestb_local_.decl.lent != NULL)
22830     ffelex_token_kill (ffestb_local_.decl.lent);
22831   ffelex_token_kill (ffesta_tokens[1]);
22832   ffelex_token_kill (ffesta_tokens[2]);
22833   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22834   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22835 }
22836
22837 /* ffestb_decl_entsp_4_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22838                              NAME ASTERISK OPEN_PAREN expr
22839
22840    (ffestb_decl_entsp_4_)  // to expression handler
22841
22842    Allow only CLOSE_PAREN; and deal with character-length expression.  */
22843
22844 static ffelexHandler
22845 ffestb_decl_entsp_4_ (ffelexToken ft, ffebld expr, ffelexToken t)
22846 {
22847   switch (ffelex_token_type (t))
22848     {
22849     case FFELEX_typeCLOSE_PAREN:
22850       if (expr == NULL)
22851         break;
22852       switch (ffestb_local_.decl.type)
22853         {
22854         case FFESTP_typeCHARACTER:
22855           ffestb_local_.decl.len = expr;
22856           ffestb_local_.decl.lent = ffelex_token_use (ft);
22857           break;
22858
22859         default:
22860           ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22861           break;
22862         }
22863       return (ffelexHandler) ffestb_decl_entsp_5_;
22864
22865     default:
22866       break;
22867     }
22868
22869   if (ffestb_local_.decl.recursive != NULL)
22870     ffelex_token_kill (ffestb_local_.decl.recursive);
22871   if (ffestb_local_.decl.kindt != NULL)
22872     ffelex_token_kill (ffestb_local_.decl.kindt);
22873   if (ffestb_local_.decl.lent != NULL)
22874     ffelex_token_kill (ffestb_local_.decl.lent);
22875   ffelex_token_kill (ffesta_tokens[1]);
22876   ffelex_token_kill (ffesta_tokens[2]);
22877   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22878   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22879 }
22880
22881 /* ffestb_decl_entsp_5_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22882                              NAME [type parameter]
22883
22884    return ffestb_decl_entsp_5_;  // to lexer
22885
22886    Make sure the next token is an OPEN_PAREN.  Get the arg list or dimension
22887    list.  If it can't be an arg list, or if the CLOSE_PAREN is followed by
22888    something other than EOS/SEMICOLON or NAME, then treat as dimension list
22889    and handle statement as an R426/R501.  If it can't be a dimension list, or
22890    if the CLOSE_PAREN is followed by NAME, treat as an arg list and handle
22891    statement as an R1219.  If it can be either an arg list or a dimension
22892    list and if the CLOSE_PAREN is followed by EOS/SEMICOLON, ask FFESTC
22893    whether to treat the statement as an R426/R501 or an R1219 and act
22894    accordingly.  */
22895
22896 static ffelexHandler
22897 ffestb_decl_entsp_5_ (ffelexToken t)
22898 {
22899   switch (ffelex_token_type (t))
22900     {
22901     case FFELEX_typeOPEN_PAREN:
22902       if (ffestb_local_.decl.aster_after && (ffestb_local_.decl.len != NULL))
22903         {                       /* "CHARACTER[RECURSIVE]FUNCTIONxyz*(len-expr)
22904                                    (..." must be a function-stmt, since the
22905                                    (len-expr) cannot precede (array-spec) in
22906                                    an object declaration but can precede
22907                                    (name-list) in a function stmt. */
22908           ffelex_token_kill (ffesta_tokens[1]);
22909           ffesta_tokens[1] = ffesta_tokens[2];
22910           return (ffelexHandler) ffestb_decl_funcname_4_ (t);
22911         }
22912       ffestb_local_.decl.toklist = ffestt_tokenlist_create ();
22913       ffestb_local_.decl.empty = TRUE;
22914       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
22915       return (ffelexHandler) ffestb_decl_entsp_6_;
22916
22917     default:
22918       break;
22919     }
22920
22921   assert (ffestb_local_.decl.aster_after);
22922   ffesta_confirmed ();          /* We've seen an ASTERISK, so even EQUALS
22923                                    confirmed. */
22924   ffestb_subr_ambig_to_ents_ ();
22925   ffestb_subrargs_.dim_list.dims = NULL;
22926   return (ffelexHandler) ffestb_decl_ents_7_ (t);
22927 }
22928
22929 /* ffestb_decl_entsp_6_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22930                              NAME [type parameter] OPEN_PAREN
22931
22932    return ffestb_decl_entsp_6_;  // to lexer
22933
22934    If CLOSE_PAREN, we definitely have an R1219 function-stmt, since
22935    the notation "name()" is invalid for a declaration.  */
22936
22937 static ffelexHandler
22938 ffestb_decl_entsp_6_ (ffelexToken t)
22939 {
22940   ffelexHandler next;
22941
22942   switch (ffelex_token_type (t))
22943     {
22944     case FFELEX_typeCLOSE_PAREN:
22945       if (!ffestb_local_.decl.empty)
22946         {                       /* Trailing comma, just a warning for
22947                                    stmt func def, so allow ambiguity. */
22948           ffestt_tokenlist_append (ffestb_local_.decl.toklist,
22949                                    ffelex_token_use (t));
22950           return (ffelexHandler) ffestb_decl_entsp_8_;
22951         }
22952       ffelex_token_kill (ffesta_tokens[1]);
22953       ffesta_tokens[1] = ffesta_tokens[2];
22954       next = (ffelexHandler) ffestt_tokenlist_handle
22955         (ffestb_local_.decl.toklist, (ffelexHandler) ffestb_decl_funcname_4_);
22956       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
22957       return (ffelexHandler) (*next) (t);
22958
22959     case FFELEX_typeNAME:
22960       ffestb_local_.decl.empty = FALSE;
22961       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
22962       return (ffelexHandler) ffestb_decl_entsp_7_;
22963
22964     case FFELEX_typeEQUALS:
22965     case FFELEX_typePOINTS:
22966     case FFELEX_typePERCENT:
22967     case FFELEX_typePERIOD:
22968     case FFELEX_typeOPEN_PAREN:
22969       if ((ffestb_local_.decl.kindt != NULL)
22970           || (ffestb_local_.decl.lent != NULL))
22971         break;                  /* type(params)name or type*val name, either
22972                                    way confirmed. */
22973       return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
22974
22975     default:
22976       break;
22977     }
22978
22979   ffesta_confirmed ();
22980   ffestb_subr_ambig_to_ents_ ();
22981   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
22982                                        (ffelexHandler) ffestb_decl_ents_3_);
22983   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
22984   return (ffelexHandler) (*next) (t);
22985 }
22986
22987 /* ffestb_decl_entsp_7_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22988                              NAME [type parameter] OPEN_PAREN NAME
22989
22990    return ffestb_decl_entsp_7_;  // to lexer
22991
22992    Expect COMMA or CLOSE_PAREN to remain ambiguous, else not an R1219
22993    function-stmt.  */
22994
22995 static ffelexHandler
22996 ffestb_decl_entsp_7_ (ffelexToken t)
22997 {
22998   ffelexHandler next;
22999
23000   switch (ffelex_token_type (t))
23001     {
23002     case FFELEX_typeCLOSE_PAREN:
23003       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
23004       return (ffelexHandler) ffestb_decl_entsp_8_;
23005
23006     case FFELEX_typeCOMMA:
23007       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
23008       return (ffelexHandler) ffestb_decl_entsp_6_;
23009
23010     case FFELEX_typeEQUALS:
23011     case FFELEX_typePOINTS:
23012     case FFELEX_typePERCENT:
23013     case FFELEX_typePERIOD:
23014     case FFELEX_typeOPEN_PAREN:
23015       if ((ffestb_local_.decl.kindt != NULL)
23016           || (ffestb_local_.decl.lent != NULL))
23017         break;                  /* type(params)name or type*val name, either
23018                                    way confirmed. */
23019       return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
23020
23021     default:
23022       break;
23023     }
23024
23025   ffesta_confirmed ();
23026   ffestb_subr_ambig_to_ents_ ();
23027   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
23028                                        (ffelexHandler) ffestb_decl_ents_3_);
23029   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
23030   return (ffelexHandler) (*next) (t);
23031 }
23032
23033 /* ffestb_decl_entsp_8_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23034                              NAME [type parameter] OPEN_PAREN name-list
23035                              CLOSE_PAREN
23036
23037    return ffestb_decl_entsp_8_;  // to lexer
23038
23039    If EOS/SEMICOLON, situation remains ambiguous, ask FFESTC to resolve
23040    it.  If NAME (must be "RESULT", but that is checked later on),
23041    definitely an R1219 function-stmt.  Anything else, handle as entity decl.  */
23042
23043 static ffelexHandler
23044 ffestb_decl_entsp_8_ (ffelexToken t)
23045 {
23046   ffelexHandler next;
23047
23048   switch (ffelex_token_type (t))
23049     {
23050     case FFELEX_typeEOS:
23051     case FFELEX_typeSEMICOLON:
23052       ffesta_confirmed ();
23053       if (ffestc_is_decl_not_R1219 ())
23054         break;
23055       /* Fall through. */
23056     case FFELEX_typeNAME:
23057       ffesta_confirmed ();
23058       ffelex_token_kill (ffesta_tokens[1]);
23059       ffesta_tokens[1] = ffesta_tokens[2];
23060       next = (ffelexHandler) ffestt_tokenlist_handle
23061         (ffestb_local_.decl.toklist, (ffelexHandler) ffestb_decl_funcname_4_);
23062       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
23063       return (ffelexHandler) (*next) (t);
23064
23065     case FFELEX_typeEQUALS:
23066     case FFELEX_typePOINTS:
23067     case FFELEX_typePERCENT:
23068     case FFELEX_typePERIOD:
23069     case FFELEX_typeOPEN_PAREN:
23070       if ((ffestb_local_.decl.kindt != NULL)
23071           || (ffestb_local_.decl.lent != NULL))
23072         break;                  /* type(params)name or type*val name, either
23073                                    way confirmed. */
23074       return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
23075
23076     default:
23077       break;
23078     }
23079
23080   ffesta_confirmed ();
23081   ffestb_subr_ambig_to_ents_ ();
23082   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
23083                                        (ffelexHandler) ffestb_decl_ents_3_);
23084   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
23085   return (ffelexHandler) (*next) (t);
23086 }
23087
23088 /* ffestb_decl_func_ -- ["type" [type parameters]] RECURSIVE
23089
23090    return ffestb_decl_func_;  // to lexer
23091
23092    Handle "FUNCTION".  */
23093
23094 #if FFESTR_F90
23095 static ffelexHandler
23096 ffestb_decl_func_ (ffelexToken t)
23097 {
23098   char *p;
23099   ffeTokenLength i;
23100
23101   ffelex_set_names (FALSE);
23102
23103   switch (ffelex_token_type (t))
23104     {
23105     case FFELEX_typeNAME:
23106       if (ffestr_first (t) != FFESTR_firstFUNCTION)
23107         break;
23108       return (ffelexHandler) ffestb_decl_funcname_;
23109
23110     case FFELEX_typeNAMES:
23111       ffesta_confirmed ();
23112       if (ffestr_first (t) != FFESTR_firstFUNCTION)
23113         break;
23114       p = ffelex_token_text (t) + (i = FFESTR_firstlFUNCTION);
23115       if (*p == '\0')
23116         break;
23117       if (!ffesrc_is_name_init (*p))
23118         goto bad_i;             /* :::::::::::::::::::: */
23119       ffesta_tokens[1] = ffelex_token_name_from_names (t, i, 0);
23120       return (ffelexHandler) ffestb_decl_funcname_1_;
23121
23122     default:
23123       break;
23124     }
23125
23126   if (ffestb_local_.decl.recursive != NULL)
23127     ffelex_token_kill (ffestb_local_.decl.recursive);
23128   if (ffestb_local_.decl.kindt != NULL)
23129     ffelex_token_kill (ffestb_local_.decl.kindt);
23130   if (ffestb_local_.decl.lent != NULL)
23131     ffelex_token_kill (ffestb_local_.decl.lent);
23132   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23133   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23134
23135 bad_i:                          /* :::::::::::::::::::: */
23136   if (ffestb_local_.decl.recursive != NULL)
23137     ffelex_token_kill (ffestb_local_.decl.recursive);
23138   if (ffestb_local_.decl.kindt != NULL)
23139     ffelex_token_kill (ffestb_local_.decl.kindt);
23140   if (ffestb_local_.decl.lent != NULL)
23141     ffelex_token_kill (ffestb_local_.decl.lent);
23142   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t, i, NULL);
23143   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23144 }
23145
23146 #endif
23147 /* ffestb_decl_funcname_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23148
23149    return ffestb_decl_funcname_;  // to lexer
23150
23151    Handle NAME of a function.  */
23152
23153 static ffelexHandler
23154 ffestb_decl_funcname_ (ffelexToken t)
23155 {
23156   switch (ffelex_token_type (t))
23157     {
23158     case FFELEX_typeNAME:
23159       ffesta_tokens[1] = ffelex_token_use (t);
23160       return (ffelexHandler) ffestb_decl_funcname_1_;
23161
23162     default:
23163       break;
23164     }
23165
23166   if (ffestb_local_.decl.recursive != NULL)
23167     ffelex_token_kill (ffestb_local_.decl.recursive);
23168   if (ffestb_local_.decl.kindt != NULL)
23169     ffelex_token_kill (ffestb_local_.decl.kindt);
23170   if (ffestb_local_.decl.lent != NULL)
23171     ffelex_token_kill (ffestb_local_.decl.lent);
23172   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23173   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23174 }
23175
23176 /* ffestb_decl_funcname_1_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23177                              NAME
23178
23179    return ffestb_decl_funcname_1_;  // to lexer
23180
23181    Handle ASTERISK or OPEN_PAREN.  */
23182
23183 static ffelexHandler
23184 ffestb_decl_funcname_1_ (ffelexToken t)
23185 {
23186   switch (ffelex_token_type (t))
23187     {
23188     case FFELEX_typeASTERISK:
23189       return (ffelexHandler) ffestb_decl_funcname_2_;
23190
23191     case FFELEX_typeOPEN_PAREN:
23192       return (ffelexHandler) ffestb_decl_funcname_4_ (t);
23193
23194     default:
23195       break;
23196     }
23197
23198   if (ffestb_local_.decl.recursive != NULL)
23199     ffelex_token_kill (ffestb_local_.decl.recursive);
23200   if (ffestb_local_.decl.kindt != NULL)
23201     ffelex_token_kill (ffestb_local_.decl.kindt);
23202   if (ffestb_local_.decl.lent != NULL)
23203     ffelex_token_kill (ffestb_local_.decl.lent);
23204   ffelex_token_kill (ffesta_tokens[1]);
23205   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23206   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23207 }
23208
23209 /* ffestb_decl_funcname_2_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23210                              NAME ASTERISK
23211
23212    return ffestb_decl_funcname_2_;  // to lexer
23213
23214    Handle NUMBER or OPEN_PAREN.  */
23215
23216 static ffelexHandler
23217 ffestb_decl_funcname_2_ (ffelexToken t)
23218 {
23219   switch (ffelex_token_type (t))
23220     {
23221     case FFELEX_typeNUMBER:
23222       switch (ffestb_local_.decl.type)
23223         {
23224         case FFESTP_typeINTEGER:
23225         case FFESTP_typeREAL:
23226         case FFESTP_typeCOMPLEX:
23227         case FFESTP_typeLOGICAL:
23228           if (ffestb_local_.decl.kindt == NULL)
23229             ffestb_local_.decl.kindt = ffelex_token_use (t);
23230           else
23231             ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23232           break;
23233
23234         case FFESTP_typeCHARACTER:
23235           if (ffestb_local_.decl.lent == NULL)
23236             ffestb_local_.decl.lent = ffelex_token_use (t);
23237           else
23238             ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23239           break;
23240
23241         case FFESTP_typeBYTE:
23242         case FFESTP_typeWORD:
23243         default:
23244           ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23245           break;
23246         }
23247       return (ffelexHandler) ffestb_decl_funcname_4_;
23248
23249     case FFELEX_typeOPEN_PAREN:
23250       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
23251                                           FFEEXPR_contextCHARACTERSIZE,
23252                                  (ffeexprCallback) ffestb_decl_funcname_3_);
23253
23254     default:
23255       break;
23256     }
23257
23258   if (ffestb_local_.decl.recursive != NULL)
23259     ffelex_token_kill (ffestb_local_.decl.recursive);
23260   if (ffestb_local_.decl.kindt != NULL)
23261     ffelex_token_kill (ffestb_local_.decl.kindt);
23262   if (ffestb_local_.decl.lent != NULL)
23263     ffelex_token_kill (ffestb_local_.decl.lent);
23264   ffelex_token_kill (ffesta_tokens[1]);
23265   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23266   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23267 }
23268
23269 /* ffestb_decl_funcname_3_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23270                              NAME ASTERISK OPEN_PAREN expr
23271
23272    (ffestb_decl_funcname_3_)  // to expression handler
23273
23274    Allow only CLOSE_PAREN; and deal with character-length expression.  */
23275
23276 static ffelexHandler
23277 ffestb_decl_funcname_3_ (ffelexToken ft, ffebld expr, ffelexToken t)
23278 {
23279   switch (ffelex_token_type (t))
23280     {
23281     case FFELEX_typeCLOSE_PAREN:
23282       if (expr == NULL)
23283         break;
23284       switch (ffestb_local_.decl.type)
23285         {
23286         case FFESTP_typeCHARACTER:
23287           if (ffestb_local_.decl.lent == NULL)
23288             {
23289               ffestb_local_.decl.len = expr;
23290               ffestb_local_.decl.lent = ffelex_token_use (ft);
23291             }
23292           else
23293             ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23294           break;
23295
23296         default:
23297           ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23298           break;
23299         }
23300       return (ffelexHandler) ffestb_decl_funcname_4_;
23301
23302     default:
23303       break;
23304     }
23305
23306   if (ffestb_local_.decl.recursive != NULL)
23307     ffelex_token_kill (ffestb_local_.decl.recursive);
23308   if (ffestb_local_.decl.kindt != NULL)
23309     ffelex_token_kill (ffestb_local_.decl.kindt);
23310   if (ffestb_local_.decl.lent != NULL)
23311     ffelex_token_kill (ffestb_local_.decl.lent);
23312   ffelex_token_kill (ffesta_tokens[1]);
23313   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23314   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23315 }
23316
23317 /* ffestb_decl_funcname_4_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23318                              NAME [type parameter]
23319
23320    return ffestb_decl_funcname_4_;  // to lexer
23321
23322    Make sure the next token is an OPEN_PAREN.  Get the arg list and
23323    then implement.  */
23324
23325 static ffelexHandler
23326 ffestb_decl_funcname_4_ (ffelexToken t)
23327 {
23328   switch (ffelex_token_type (t))
23329     {
23330     case FFELEX_typeOPEN_PAREN:
23331       ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
23332       ffestb_subrargs_.name_list.handler
23333         = (ffelexHandler) ffestb_decl_funcname_5_;
23334       ffestb_subrargs_.name_list.is_subr = FALSE;
23335       ffestb_subrargs_.name_list.names = FALSE;
23336       return (ffelexHandler) ffestb_subr_name_list_;
23337
23338     default:
23339       break;
23340     }
23341
23342   if (ffestb_local_.decl.recursive != NULL)
23343     ffelex_token_kill (ffestb_local_.decl.recursive);
23344   if (ffestb_local_.decl.kindt != NULL)
23345     ffelex_token_kill (ffestb_local_.decl.kindt);
23346   if (ffestb_local_.decl.lent != NULL)
23347     ffelex_token_kill (ffestb_local_.decl.lent);
23348   ffelex_token_kill (ffesta_tokens[1]);
23349   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23350   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23351 }
23352
23353 /* ffestb_decl_funcname_5_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23354                              NAME [type parameter] OPEN_PAREN arg-list
23355                              CLOSE_PAREN
23356
23357    return ffestb_decl_funcname_5_;  // to lexer
23358
23359    Must have EOS/SEMICOLON or "RESULT" here.  */
23360
23361 static ffelexHandler
23362 ffestb_decl_funcname_5_ (ffelexToken t)
23363 {
23364   if (!ffestb_subrargs_.name_list.ok)
23365     goto bad;                   /* :::::::::::::::::::: */
23366
23367   switch (ffelex_token_type (t))
23368     {
23369     case FFELEX_typeEOS:
23370     case FFELEX_typeSEMICOLON:
23371       ffesta_confirmed ();
23372       if (!ffesta_is_inhibited ())
23373         ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
23374             ffestb_subrargs_.name_list.close_paren, ffestb_local_.decl.type,
23375                       ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
23376                       ffestb_local_.decl.len, ffestb_local_.decl.lent,
23377                       ffestb_local_.decl.recursive, NULL);
23378       if (ffestb_local_.decl.recursive != NULL)
23379         ffelex_token_kill (ffestb_local_.decl.recursive);
23380       if (ffestb_local_.decl.kindt != NULL)
23381         ffelex_token_kill (ffestb_local_.decl.kindt);
23382       if (ffestb_local_.decl.lent != NULL)
23383         ffelex_token_kill (ffestb_local_.decl.lent);
23384       ffelex_token_kill (ffesta_tokens[1]);
23385       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23386       ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23387       return (ffelexHandler) ffesta_zero (t);
23388
23389     case FFELEX_typeNAME:
23390       if (ffestr_other (t) != FFESTR_otherRESULT)
23391         break;
23392       return (ffelexHandler) ffestb_decl_funcname_6_;
23393
23394     default:
23395       break;
23396     }
23397
23398 bad:                            /* :::::::::::::::::::: */
23399   if (ffestb_local_.decl.recursive != NULL)
23400     ffelex_token_kill (ffestb_local_.decl.recursive);
23401   if (ffestb_local_.decl.kindt != NULL)
23402     ffelex_token_kill (ffestb_local_.decl.kindt);
23403   if (ffestb_local_.decl.lent != NULL)
23404     ffelex_token_kill (ffestb_local_.decl.lent);
23405   ffelex_token_kill (ffesta_tokens[1]);
23406   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23407   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23408   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23409   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23410 }
23411
23412 /* ffestb_decl_funcname_6_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23413                              NAME [type parameter] OPEN_PAREN arglist
23414                              CLOSE_PAREN "RESULT"
23415
23416    return ffestb_decl_funcname_6_;  // to lexer
23417
23418    Make sure the next token is an OPEN_PAREN.  */
23419
23420 static ffelexHandler
23421 ffestb_decl_funcname_6_ (ffelexToken t)
23422 {
23423   switch (ffelex_token_type (t))
23424     {
23425     case FFELEX_typeOPEN_PAREN:
23426       return (ffelexHandler) ffestb_decl_funcname_7_;
23427
23428     default:
23429       break;
23430     }
23431
23432   if (ffestb_local_.decl.recursive != NULL)
23433     ffelex_token_kill (ffestb_local_.decl.recursive);
23434   if (ffestb_local_.decl.kindt != NULL)
23435     ffelex_token_kill (ffestb_local_.decl.kindt);
23436   if (ffestb_local_.decl.lent != NULL)
23437     ffelex_token_kill (ffestb_local_.decl.lent);
23438   ffelex_token_kill (ffesta_tokens[1]);
23439   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23440   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23441   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23442   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23443 }
23444
23445 /* ffestb_decl_funcname_7_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23446                              NAME [type parameter] OPEN_PAREN arglist
23447                              CLOSE_PAREN "RESULT" OPEN_PAREN
23448
23449    return ffestb_decl_funcname_7_;  // to lexer
23450
23451    Make sure the next token is a NAME.  */
23452
23453 static ffelexHandler
23454 ffestb_decl_funcname_7_ (ffelexToken t)
23455 {
23456   switch (ffelex_token_type (t))
23457     {
23458     case FFELEX_typeNAME:
23459       ffesta_tokens[2] = ffelex_token_use (t);
23460       return (ffelexHandler) ffestb_decl_funcname_8_;
23461
23462     default:
23463       break;
23464     }
23465
23466   if (ffestb_local_.decl.recursive != NULL)
23467     ffelex_token_kill (ffestb_local_.decl.recursive);
23468   if (ffestb_local_.decl.kindt != NULL)
23469     ffelex_token_kill (ffestb_local_.decl.kindt);
23470   if (ffestb_local_.decl.lent != NULL)
23471     ffelex_token_kill (ffestb_local_.decl.lent);
23472   ffelex_token_kill (ffesta_tokens[1]);
23473   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23474   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23475   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23476   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23477 }
23478
23479 /* ffestb_decl_funcname_8_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23480                              NAME [type parameter] OPEN_PAREN arglist
23481                              CLOSE_PAREN "RESULT" OPEN_PAREN NAME
23482
23483    return ffestb_decl_funcname_8_;  // to lexer
23484
23485    Make sure the next token is a CLOSE_PAREN.  */
23486
23487 static ffelexHandler
23488 ffestb_decl_funcname_8_ (ffelexToken t)
23489 {
23490   switch (ffelex_token_type (t))
23491     {
23492     case FFELEX_typeCLOSE_PAREN:
23493       return (ffelexHandler) ffestb_decl_funcname_9_;
23494
23495     default:
23496       break;
23497     }
23498
23499   if (ffestb_local_.decl.recursive != NULL)
23500     ffelex_token_kill (ffestb_local_.decl.recursive);
23501   if (ffestb_local_.decl.kindt != NULL)
23502     ffelex_token_kill (ffestb_local_.decl.kindt);
23503   if (ffestb_local_.decl.lent != NULL)
23504     ffelex_token_kill (ffestb_local_.decl.lent);
23505   ffelex_token_kill (ffesta_tokens[1]);
23506   ffelex_token_kill (ffesta_tokens[2]);
23507   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23508   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23509   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23510   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23511 }
23512
23513 /* ffestb_decl_funcname_9_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23514                              NAME [type parameter] OPEN_PAREN arg-list
23515                              CLOSE_PAREN "RESULT" OPEN_PAREN NAME CLOSE_PAREN
23516
23517    return ffestb_decl_funcname_9_;  // to lexer
23518
23519    Must have EOS/SEMICOLON here.  */
23520
23521 static ffelexHandler
23522 ffestb_decl_funcname_9_ (ffelexToken t)
23523 {
23524   switch (ffelex_token_type (t))
23525     {
23526     case FFELEX_typeEOS:
23527     case FFELEX_typeSEMICOLON:
23528       if (!ffesta_is_inhibited ())
23529         ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
23530             ffestb_subrargs_.name_list.close_paren, ffestb_local_.decl.type,
23531                       ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
23532                       ffestb_local_.decl.len, ffestb_local_.decl.lent,
23533                       ffestb_local_.decl.recursive, ffesta_tokens[2]);
23534       if (ffestb_local_.decl.recursive != NULL)
23535         ffelex_token_kill (ffestb_local_.decl.recursive);
23536       if (ffestb_local_.decl.kindt != NULL)
23537         ffelex_token_kill (ffestb_local_.decl.kindt);
23538       if (ffestb_local_.decl.lent != NULL)
23539         ffelex_token_kill (ffestb_local_.decl.lent);
23540       ffelex_token_kill (ffesta_tokens[1]);
23541       ffelex_token_kill (ffesta_tokens[2]);
23542       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23543       ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23544       return (ffelexHandler) ffesta_zero (t);
23545
23546     default:
23547       break;
23548     }
23549
23550   if (ffestb_local_.decl.recursive != NULL)
23551     ffelex_token_kill (ffestb_local_.decl.recursive);
23552   if (ffestb_local_.decl.kindt != NULL)
23553     ffelex_token_kill (ffestb_local_.decl.kindt);
23554   if (ffestb_local_.decl.lent != NULL)
23555     ffelex_token_kill (ffestb_local_.decl.lent);
23556   ffelex_token_kill (ffesta_tokens[1]);
23557   ffelex_token_kill (ffesta_tokens[2]);
23558   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23559   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23560   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23561   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23562 }
23563
23564 /* ffestb_V003 -- Parse the STRUCTURE statement
23565
23566    return ffestb_V003;  // to lexer
23567
23568    Make sure the statement has a valid form for the STRUCTURE statement.
23569    If it does, implement the statement.  */
23570
23571 #if FFESTR_VXT
23572 ffelexHandler
23573 ffestb_V003 (ffelexToken t)
23574 {
23575   ffeTokenLength i;
23576   char *p;
23577   ffelexToken nt;
23578   ffelexHandler next;
23579
23580   switch (ffelex_token_type (ffesta_tokens[0]))
23581     {
23582     case FFELEX_typeNAME:
23583       if (ffesta_first_kw != FFESTR_firstSTRUCTURE)
23584         goto bad_0;             /* :::::::::::::::::::: */
23585       switch (ffelex_token_type (t))
23586         {
23587         case FFELEX_typeCOMMA:
23588         case FFELEX_typeCOLONCOLON:
23589         case FFELEX_typeEOS:
23590         case FFELEX_typeSEMICOLON:
23591           ffesta_confirmed ();  /* Error, but clearly intended. */
23592           goto bad_1;           /* :::::::::::::::::::: */
23593
23594         default:
23595           goto bad_1;           /* :::::::::::::::::::: */
23596
23597         case FFELEX_typeNAME:
23598           ffesta_confirmed ();
23599           if (!ffesta_is_inhibited ())
23600             ffestc_V003_start (NULL);
23601           ffestb_local_.structure.started = TRUE;
23602           return (ffelexHandler) ffestb_V0034_ (t);
23603
23604         case FFELEX_typeSLASH:
23605           ffesta_confirmed ();
23606           return (ffelexHandler) ffestb_V0031_;
23607         }
23608
23609     case FFELEX_typeNAMES:
23610       if (ffesta_first_kw != FFESTR_firstSTRUCTURE)
23611         goto bad_0;             /* :::::::::::::::::::: */
23612       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSTRUCTURE);
23613       switch (ffelex_token_type (t))
23614         {
23615         default:
23616           goto bad_1;           /* :::::::::::::::::::: */
23617
23618         case FFELEX_typeEOS:
23619         case FFELEX_typeSEMICOLON:
23620         case FFELEX_typeCOMMA:
23621         case FFELEX_typeCOLONCOLON:
23622           ffesta_confirmed ();
23623           break;
23624
23625         case FFELEX_typeSLASH:
23626           ffesta_confirmed ();
23627           if (*p != '\0')
23628             goto bad_1;         /* :::::::::::::::::::: */
23629           return (ffelexHandler) ffestb_V0031_;
23630
23631         case FFELEX_typeOPEN_PAREN:
23632           break;
23633         }
23634
23635       /* Here, we have at least one char after "STRUCTURE" and t is COMMA,
23636          EOS/SEMICOLON, or OPEN_PAREN. */
23637
23638       if (!ffesrc_is_name_init (*p))
23639         goto bad_i;             /* :::::::::::::::::::: */
23640       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
23641       if (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN)
23642         ffestb_local_.structure.started = FALSE;
23643       else
23644         {
23645           if (!ffesta_is_inhibited ())
23646             ffestc_V003_start (NULL);
23647           ffestb_local_.structure.started = TRUE;
23648         }
23649       next = (ffelexHandler) ffestb_V0034_ (nt);
23650       ffelex_token_kill (nt);
23651       return (ffelexHandler) (*next) (t);
23652
23653     default:
23654       goto bad_0;               /* :::::::::::::::::::: */
23655     }
23656
23657 bad_0:                          /* :::::::::::::::::::: */
23658   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", ffesta_tokens[0]);
23659   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23660
23661 bad_1:                          /* :::::::::::::::::::: */
23662   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23663   return (ffelexHandler) ffelex_swallow_tokens (t,
23664                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
23665
23666 bad_i:                          /* :::::::::::::::::::: */
23667   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", ffesta_tokens[0], i, t);
23668   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23669 }
23670
23671 /* ffestb_V0031_ -- "STRUCTURE" SLASH
23672
23673    return ffestb_V0031_;  // to lexer
23674
23675    Handle NAME.  */
23676
23677 static ffelexHandler
23678 ffestb_V0031_ (ffelexToken t)
23679 {
23680   switch (ffelex_token_type (t))
23681     {
23682     case FFELEX_typeNAME:
23683       ffesta_tokens[1] = ffelex_token_use (t);
23684       return (ffelexHandler) ffestb_V0032_;
23685
23686     default:
23687       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23688       break;
23689     }
23690
23691   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23692 }
23693
23694 /* ffestb_V0032_ -- "STRUCTURE" SLASH NAME
23695
23696    return ffestb_V0032_;  // to lexer
23697
23698    Handle SLASH.  */
23699
23700 static ffelexHandler
23701 ffestb_V0032_ (ffelexToken t)
23702 {
23703   switch (ffelex_token_type (t))
23704     {
23705     case FFELEX_typeSLASH:
23706       if (!ffesta_is_inhibited ())
23707         ffestc_V003_start (ffesta_tokens[1]);
23708       ffestb_local_.structure.started = TRUE;
23709       ffelex_token_kill (ffesta_tokens[1]);
23710       return (ffelexHandler) ffestb_V0033_;
23711
23712     default:
23713       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23714       break;
23715     }
23716
23717   ffelex_token_kill (ffesta_tokens[1]);
23718   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23719 }
23720
23721 /* ffestb_V0033_ -- "STRUCTURE" SLASH NAME SLASH
23722
23723    return ffestb_V0033_;  // to lexer
23724
23725    Handle NAME or EOS/SEMICOLON.  */
23726
23727 static ffelexHandler
23728 ffestb_V0033_ (ffelexToken t)
23729 {
23730   switch (ffelex_token_type (t))
23731     {
23732     case FFELEX_typeNAME:
23733       return (ffelexHandler) ffestb_V0034_ (t);
23734
23735     case FFELEX_typeEOS:
23736     case FFELEX_typeSEMICOLON:
23737       if (!ffesta_is_inhibited ())
23738         ffestc_V003_finish ();
23739       return (ffelexHandler) ffesta_zero (t);
23740
23741     default:
23742       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23743       break;
23744     }
23745
23746   ffelex_token_kill (ffesta_tokens[1]);
23747   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23748 }
23749
23750 /* ffestb_V0034_ -- "STRUCTURE" [SLASH NAME SLASH]
23751
23752    return ffestb_V0034_;  // to lexer
23753
23754    Handle NAME.  */
23755
23756 static ffelexHandler
23757 ffestb_V0034_ (ffelexToken t)
23758 {
23759   switch (ffelex_token_type (t))
23760     {
23761     case FFELEX_typeNAME:
23762       ffesta_tokens[1] = ffelex_token_use (t);
23763       return (ffelexHandler) ffestb_V0035_;
23764
23765     default:
23766       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23767       break;
23768     }
23769
23770   if (!ffesta_is_inhibited ())
23771     ffestc_V003_finish ();
23772   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23773 }
23774
23775 /* ffestb_V0035_ -- "STRUCTURE" ... NAME
23776
23777    return ffestb_V0035_;  // to lexer
23778
23779    Handle OPEN_PAREN.  */
23780
23781 static ffelexHandler
23782 ffestb_V0035_ (ffelexToken t)
23783 {
23784   switch (ffelex_token_type (t))
23785     {
23786     case FFELEX_typeOPEN_PAREN:
23787       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
23788       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_V0036_;
23789       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
23790       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
23791 #ifdef FFECOM_dimensionsMAX
23792       ffestb_subrargs_.dim_list.ndims = 0;
23793 #endif
23794       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
23795       FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
23796
23797     case FFELEX_typeCOMMA:
23798       if (!ffesta_is_inhibited ())
23799         ffestc_V003_item (ffesta_tokens[1], NULL);
23800       ffelex_token_kill (ffesta_tokens[1]);
23801       return (ffelexHandler) ffestb_V0034_;
23802
23803     case FFELEX_typeEOS:
23804     case FFELEX_typeSEMICOLON:
23805       if (!ffesta_is_inhibited ())
23806         {
23807           ffestc_V003_item (ffesta_tokens[1], NULL);
23808           ffestc_V003_finish ();
23809         }
23810       ffelex_token_kill (ffesta_tokens[1]);
23811       return (ffelexHandler) ffesta_zero (t);
23812
23813     default:
23814       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23815       break;
23816     }
23817
23818   if (!ffesta_is_inhibited ())
23819     ffestc_V003_finish ();
23820   ffelex_token_kill (ffesta_tokens[1]);
23821   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23822 }
23823
23824 /* ffestb_V0036_ -- "STRUCTURE" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
23825
23826    return ffestb_V0036_;  // to lexer
23827
23828    Handle COMMA or EOS/SEMICOLON.  */
23829
23830 static ffelexHandler
23831 ffestb_V0036_ (ffelexToken t)
23832 {
23833   if (!ffestb_subrargs_.dim_list.ok)
23834     goto bad;                   /* :::::::::::::::::::: */
23835
23836   switch (ffelex_token_type (t))
23837     {
23838     case FFELEX_typeCOMMA:
23839       ffesta_confirmed ();
23840       if (!ffesta_is_inhibited ())
23841         {
23842           if (!ffestb_local_.structure.started)
23843             {
23844               ffestc_V003_start (NULL);
23845               ffestb_local_.structure.started = TRUE;
23846             }
23847           ffestc_V003_item (ffesta_tokens[1],
23848                             ffestb_subrargs_.dim_list.dims);
23849         }
23850       ffelex_token_kill (ffesta_tokens[1]);
23851       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
23852       return (ffelexHandler) ffestb_V0034_;
23853
23854     case FFELEX_typeEOS:
23855     case FFELEX_typeSEMICOLON:
23856       ffesta_confirmed ();
23857       if (!ffesta_is_inhibited ())
23858         {
23859           if (!ffestb_local_.structure.started)
23860             ffestc_V003_start (NULL);
23861           ffestc_V003_item (ffesta_tokens[1],
23862                             ffestb_subrargs_.dim_list.dims);
23863           ffestc_V003_finish ();
23864         }
23865       ffelex_token_kill (ffesta_tokens[1]);
23866       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
23867       return (ffelexHandler) ffesta_zero (t);
23868
23869     default:
23870       break;
23871     }
23872
23873 bad:                            /* :::::::::::::::::::: */
23874   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23875   if (ffestb_local_.structure.started && !ffesta_is_inhibited ())
23876     ffestc_V003_finish ();
23877   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
23878   ffelex_token_kill (ffesta_tokens[1]);
23879   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23880 }
23881
23882 /* ffestb_V016 -- Parse the RECORD statement
23883
23884    return ffestb_V016;  // to lexer
23885
23886    Make sure the statement has a valid form for the RECORD statement.  If it
23887    does, implement the statement.  */
23888
23889 ffelexHandler
23890 ffestb_V016 (ffelexToken t)
23891 {
23892   char *p;
23893   ffeTokenLength i;
23894
23895   switch (ffelex_token_type (ffesta_tokens[0]))
23896     {
23897     case FFELEX_typeNAME:
23898       if (ffesta_first_kw != FFESTR_firstRECORD)
23899         goto bad_0;             /* :::::::::::::::::::: */
23900       break;
23901
23902     case FFELEX_typeNAMES:
23903       if (ffesta_first_kw != FFESTR_firstRECORD)
23904         goto bad_0;             /* :::::::::::::::::::: */
23905       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlRECORD);
23906       if (*p != '\0')
23907         goto bad_i;             /* :::::::::::::::::::: */
23908       break;
23909
23910     default:
23911       goto bad_0;               /* :::::::::::::::::::: */
23912     }
23913
23914   switch (ffelex_token_type (t))
23915     {
23916     case FFELEX_typeCOMMA:
23917     case FFELEX_typeEOS:
23918     case FFELEX_typeSEMICOLON:
23919     case FFELEX_typeCOLONCOLON:
23920       ffesta_confirmed ();      /* Error, but clearly intended. */
23921       goto bad_1;               /* :::::::::::::::::::: */
23922
23923     default:
23924       goto bad_1;               /* :::::::::::::::::::: */
23925
23926     case FFELEX_typeSLASH:
23927       break;
23928     }
23929
23930   ffesta_confirmed ();
23931   if (!ffesta_is_inhibited ())
23932     ffestc_V016_start ();
23933   return (ffelexHandler) ffestb_V0161_;
23934
23935 bad_0:                          /* :::::::::::::::::::: */
23936   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", ffesta_tokens[0]);
23937   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23938
23939 bad_1:                          /* :::::::::::::::::::: */
23940   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
23941   return (ffelexHandler) ffelex_swallow_tokens (t,
23942                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
23943
23944 bad_i:                          /* :::::::::::::::::::: */
23945   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "RECORD", ffesta_tokens[0], i, t);
23946   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23947 }
23948
23949 /* ffestb_V0161_ -- "RECORD" SLASH
23950
23951    return ffestb_V0161_;  // to lexer
23952
23953    Handle NAME.  */
23954
23955 static ffelexHandler
23956 ffestb_V0161_ (ffelexToken t)
23957 {
23958   switch (ffelex_token_type (t))
23959     {
23960     case FFELEX_typeNAME:
23961       if (!ffesta_is_inhibited ())
23962         ffestc_V016_item_structure (t);
23963       return (ffelexHandler) ffestb_V0162_;
23964
23965     default:
23966       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
23967       break;
23968     }
23969
23970   if (!ffesta_is_inhibited ())
23971     ffestc_V016_finish ();
23972   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23973 }
23974
23975 /* ffestb_V0162_ -- "RECORD" SLASH NAME
23976
23977    return ffestb_V0162_;  // to lexer
23978
23979    Handle SLASH.  */
23980
23981 static ffelexHandler
23982 ffestb_V0162_ (ffelexToken t)
23983 {
23984   switch (ffelex_token_type (t))
23985     {
23986     case FFELEX_typeSLASH:
23987       return (ffelexHandler) ffestb_V0163_;
23988
23989     default:
23990       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
23991       break;
23992     }
23993
23994   if (!ffesta_is_inhibited ())
23995     ffestc_V016_finish ();
23996   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23997 }
23998
23999 /* ffestb_V0163_ -- "RECORD" SLASH NAME SLASH
24000
24001    return ffestb_V0163_;  // to lexer
24002
24003    Handle NAME.  */
24004
24005 static ffelexHandler
24006 ffestb_V0163_ (ffelexToken t)
24007 {
24008   switch (ffelex_token_type (t))
24009     {
24010     case FFELEX_typeNAME:
24011       ffesta_tokens[1] = ffelex_token_use (t);
24012       return (ffelexHandler) ffestb_V0164_;
24013
24014     default:
24015       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24016       break;
24017     }
24018
24019   if (!ffesta_is_inhibited ())
24020     ffestc_V016_finish ();
24021   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24022 }
24023
24024 /* ffestb_V0164_ -- "RECORD" ... NAME
24025
24026    return ffestb_V0164_;  // to lexer
24027
24028    Handle OPEN_PAREN.  */
24029
24030 static ffelexHandler
24031 ffestb_V0164_ (ffelexToken t)
24032 {
24033   switch (ffelex_token_type (t))
24034     {
24035     case FFELEX_typeOPEN_PAREN:
24036       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
24037       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_V0165_;
24038       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
24039       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
24040 #ifdef FFECOM_dimensionsMAX
24041       ffestb_subrargs_.dim_list.ndims = 0;
24042 #endif
24043       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
24044       FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
24045
24046     case FFELEX_typeCOMMA:
24047       if (!ffesta_is_inhibited ())
24048         ffestc_V016_item_object (ffesta_tokens[1], NULL);
24049       ffelex_token_kill (ffesta_tokens[1]);
24050       return (ffelexHandler) ffestb_V0166_;
24051
24052     case FFELEX_typeEOS:
24053     case FFELEX_typeSEMICOLON:
24054       if (!ffesta_is_inhibited ())
24055         {
24056           ffestc_V016_item_object (ffesta_tokens[1], NULL);
24057           ffestc_V016_finish ();
24058         }
24059       ffelex_token_kill (ffesta_tokens[1]);
24060       return (ffelexHandler) ffesta_zero (t);
24061
24062     default:
24063       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24064       break;
24065     }
24066
24067   if (!ffesta_is_inhibited ())
24068     ffestc_V016_finish ();
24069   ffelex_token_kill (ffesta_tokens[1]);
24070   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24071 }
24072
24073 /* ffestb_V0165_ -- "RECORD" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
24074
24075    return ffestb_V0165_;  // to lexer
24076
24077    Handle COMMA or EOS/SEMICOLON.  */
24078
24079 static ffelexHandler
24080 ffestb_V0165_ (ffelexToken t)
24081 {
24082   if (!ffestb_subrargs_.dim_list.ok)
24083     goto bad;                   /* :::::::::::::::::::: */
24084
24085   switch (ffelex_token_type (t))
24086     {
24087     case FFELEX_typeCOMMA:
24088       if (!ffesta_is_inhibited ())
24089         ffestc_V016_item_object (ffesta_tokens[1],
24090                                  ffestb_subrargs_.dim_list.dims);
24091       ffelex_token_kill (ffesta_tokens[1]);
24092       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
24093       return (ffelexHandler) ffestb_V0166_;
24094
24095     case FFELEX_typeEOS:
24096     case FFELEX_typeSEMICOLON:
24097       if (!ffesta_is_inhibited ())
24098         {
24099           ffestc_V016_item_object (ffesta_tokens[1],
24100                                    ffestb_subrargs_.dim_list.dims);
24101           ffestc_V016_finish ();
24102         }
24103       ffelex_token_kill (ffesta_tokens[1]);
24104       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
24105       return (ffelexHandler) ffesta_zero (t);
24106
24107     default:
24108       break;
24109     }
24110
24111 bad:                            /* :::::::::::::::::::: */
24112   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24113   if (ffestb_local_.structure.started && !ffesta_is_inhibited ())
24114     ffestc_V016_finish ();
24115   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
24116   ffelex_token_kill (ffesta_tokens[1]);
24117   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24118 }
24119
24120 /* ffestb_V0166_ -- "RECORD" SLASH NAME SLASH NAME [OPEN_PAREN dimlist
24121                     CLOSE_PAREN] COMMA
24122
24123    return ffestb_V0166_;  // to lexer
24124
24125    Handle NAME or SLASH.  */
24126
24127 static ffelexHandler
24128 ffestb_V0166_ (ffelexToken t)
24129 {
24130   switch (ffelex_token_type (t))
24131     {
24132     case FFELEX_typeNAME:
24133       ffesta_tokens[1] = ffelex_token_use (t);
24134       return (ffelexHandler) ffestb_V0164_;
24135
24136     case FFELEX_typeSLASH:
24137       return (ffelexHandler) ffestb_V0161_;
24138
24139     default:
24140       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24141       break;
24142     }
24143
24144   if (!ffesta_is_inhibited ())
24145     ffestc_V016_finish ();
24146   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24147 }
24148
24149 #endif
24150 /* ffestb_V027 -- Parse the VXT PARAMETER statement
24151
24152    return ffestb_V027;  // to lexer
24153
24154    Make sure the statement has a valid form for the VXT PARAMETER statement.
24155    If it does, implement the statement.  */
24156
24157 ffelexHandler
24158 ffestb_V027 (ffelexToken t)
24159 {
24160   char *p;
24161   ffeTokenLength i;
24162
24163   switch (ffelex_token_type (ffesta_tokens[0]))
24164     {
24165     case FFELEX_typeNAME:
24166       if (ffesta_first_kw != FFESTR_firstPARAMETER)
24167         goto bad_0;             /* :::::::::::::::::::: */
24168       switch (ffelex_token_type (t))
24169         {
24170         case FFELEX_typeNAME:
24171           break;
24172
24173         default:
24174           goto bad_1;           /* :::::::::::::::::::: */
24175         }
24176       ffesta_confirmed ();
24177       ffestb_local_.vxtparam.started = TRUE;
24178       if (!ffesta_is_inhibited ())
24179         ffestc_V027_start ();
24180       ffesta_tokens[1] = ffelex_token_use (t);
24181       return (ffelexHandler) ffestb_V0271_;
24182
24183     case FFELEX_typeNAMES:
24184       if (ffesta_first_kw != FFESTR_firstPARAMETER)
24185         goto bad_0;             /* :::::::::::::::::::: */
24186       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlPARAMETER);
24187       switch (ffelex_token_type (t))
24188         {
24189         case FFELEX_typeEQUALS:
24190           break;
24191
24192         default:
24193           goto bad_1;           /* :::::::::::::::::::: */
24194         }
24195       if (!ffesrc_is_name_init (*p))
24196         goto bad_i;             /* :::::::::::::::::::: */
24197       ffestb_local_.vxtparam.started = FALSE;
24198       ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i,
24199                                                        0);
24200       return (ffelexHandler) ffestb_V0271_ (t);
24201
24202     default:
24203       goto bad_0;               /* :::::::::::::::::::: */
24204     }
24205
24206 bad_0:                          /* :::::::::::::::::::: */
24207   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0]);
24208   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24209
24210 bad_1:                          /* :::::::::::::::::::: */
24211   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24212   return (ffelexHandler) ffelex_swallow_tokens (t,
24213                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
24214
24215 bad_i:                          /* :::::::::::::::::::: */
24216   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0], i, t);
24217   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24218 }
24219
24220 /* ffestb_V0271_ -- "PARAMETER" NAME
24221
24222    return ffestb_V0271_;  // to lexer
24223
24224    Handle EQUALS.  */
24225
24226 static ffelexHandler
24227 ffestb_V0271_ (ffelexToken t)
24228 {
24229   switch (ffelex_token_type (t))
24230     {
24231     case FFELEX_typeEQUALS:
24232       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
24233                  FFEEXPR_contextPARAMETER, (ffeexprCallback) ffestb_V0272_);
24234
24235     default:
24236       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24237       break;
24238     }
24239
24240   ffelex_token_kill (ffesta_tokens[1]);
24241   if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
24242     ffestc_V027_finish ();
24243   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24244 }
24245
24246 /* ffestb_V0272_ -- "PARAMETER" NAME EQUALS expr
24247
24248    (ffestb_V0272_)  // to expression handler
24249
24250    Handle COMMA or EOS/SEMICOLON.  */
24251
24252 static ffelexHandler
24253 ffestb_V0272_ (ffelexToken ft, ffebld expr, ffelexToken t)
24254 {
24255   switch (ffelex_token_type (t))
24256     {
24257     case FFELEX_typeEOS:
24258     case FFELEX_typeSEMICOLON:
24259       if (!ffestb_local_.vxtparam.started)
24260         {
24261           if (ffestc_is_let_not_V027 ())
24262             break;              /* Not a valid VXTPARAMETER stmt. */
24263           ffesta_confirmed ();
24264           if (!ffesta_is_inhibited ())
24265             ffestc_V027_start ();
24266           ffestb_local_.vxtparam.started = TRUE;
24267         }
24268       if (expr == NULL)
24269         break;
24270       if (!ffesta_is_inhibited ())
24271         {
24272           ffestc_V027_item (ffesta_tokens[1], expr, ft);
24273           ffestc_V027_finish ();
24274         }
24275       ffelex_token_kill (ffesta_tokens[1]);
24276       return (ffelexHandler) ffesta_zero (t);
24277
24278     case FFELEX_typeCOMMA:
24279       ffesta_confirmed ();
24280       if (!ffestb_local_.vxtparam.started)
24281         {
24282           if (!ffesta_is_inhibited ())
24283             ffestc_V027_start ();
24284           ffestb_local_.vxtparam.started = TRUE;
24285         }
24286       if (expr == NULL)
24287         break;
24288       if (!ffesta_is_inhibited ())
24289         ffestc_V027_item (ffesta_tokens[1], expr, ft);
24290       ffelex_token_kill (ffesta_tokens[1]);
24291       return (ffelexHandler) ffestb_V0273_;
24292
24293     default:
24294       break;
24295     }
24296
24297   ffelex_token_kill (ffesta_tokens[1]);
24298   if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
24299     ffestc_V027_finish ();
24300   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24301   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24302 }
24303
24304 /* ffestb_V0273_ -- "PARAMETER" NAME EQUALS expr COMMA
24305
24306    return ffestb_V0273_;  // to lexer
24307
24308    Handle NAME.  */
24309
24310 static ffelexHandler
24311 ffestb_V0273_ (ffelexToken t)
24312 {
24313   switch (ffelex_token_type (t))
24314     {
24315     case FFELEX_typeNAME:
24316       ffesta_tokens[1] = ffelex_token_use (t);
24317       return (ffelexHandler) ffestb_V0271_;
24318
24319     default:
24320       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24321       break;
24322     }
24323
24324   if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
24325     ffestc_V027_finish ();
24326   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24327 }
24328
24329 /* ffestb_decl_R539 -- Parse the IMPLICIT FUNCTION statement
24330
24331    return ffestb_decl_R539;  // to lexer
24332
24333    Make sure the statement has a valid form for the IMPLICIT
24334    statement.  If it does, implement the statement.  */
24335
24336 ffelexHandler
24337 ffestb_decl_R539 (ffelexToken t)
24338 {
24339   ffeTokenLength i;
24340   char *p;
24341   ffelexToken nt;
24342   ffestrSecond kw;
24343
24344   ffestb_local_.decl.recursive = NULL;
24345
24346   switch (ffelex_token_type (ffesta_tokens[0]))
24347     {
24348     case FFELEX_typeNAME:
24349       if (ffesta_first_kw != FFESTR_firstIMPLICIT)
24350         goto bad_0;             /* :::::::::::::::::::: */
24351       switch (ffelex_token_type (t))
24352         {
24353         case FFELEX_typeEOS:
24354         case FFELEX_typeSEMICOLON:
24355         case FFELEX_typeCOMMA:
24356         case FFELEX_typeCOLONCOLON:
24357           ffesta_confirmed ();  /* Error, but clearly intended. */
24358           goto bad_1;           /* :::::::::::::::::::: */
24359
24360         default:
24361           goto bad_1;           /* :::::::::::::::::::: */
24362
24363         case FFELEX_typeNAME:
24364           break;
24365         }
24366       ffesta_confirmed ();
24367       ffestb_local_.decl.imp_started = FALSE;
24368       switch (ffesta_second_kw)
24369         {
24370         case FFESTR_secondINTEGER:
24371           ffestb_local_.decl.type = FFESTP_typeINTEGER;
24372           return (ffelexHandler) ffestb_decl_R5391_;
24373
24374         case FFESTR_secondBYTE:
24375           ffestb_local_.decl.type = FFESTP_typeBYTE;
24376           return (ffelexHandler) ffestb_decl_R5391_;
24377
24378         case FFESTR_secondWORD:
24379           ffestb_local_.decl.type = FFESTP_typeWORD;
24380           return (ffelexHandler) ffestb_decl_R5391_;
24381
24382         case FFESTR_secondREAL:
24383           ffestb_local_.decl.type = FFESTP_typeREAL;
24384           return (ffelexHandler) ffestb_decl_R5391_;
24385
24386         case FFESTR_secondCOMPLEX:
24387           ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
24388           return (ffelexHandler) ffestb_decl_R5391_;
24389
24390         case FFESTR_secondLOGICAL:
24391           ffestb_local_.decl.type = FFESTP_typeLOGICAL;
24392           return (ffelexHandler) ffestb_decl_R5391_;
24393
24394         case FFESTR_secondCHARACTER:
24395           ffestb_local_.decl.type = FFESTP_typeCHARACTER;
24396           return (ffelexHandler) ffestb_decl_R5391_;
24397
24398         case FFESTR_secondDOUBLE:
24399           return (ffelexHandler) ffestb_decl_R5392_;
24400
24401         case FFESTR_secondDOUBLEPRECISION:
24402           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24403           ffestb_local_.decl.kind = NULL;
24404           ffestb_local_.decl.kindt = NULL;
24405           ffestb_local_.decl.len = NULL;
24406           ffestb_local_.decl.lent = NULL;
24407           return (ffelexHandler) ffestb_decl_R539letters_;
24408
24409         case FFESTR_secondDOUBLECOMPLEX:
24410           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24411           ffestb_local_.decl.kind = NULL;
24412           ffestb_local_.decl.kindt = NULL;
24413           ffestb_local_.decl.len = NULL;
24414           ffestb_local_.decl.lent = NULL;
24415           return (ffelexHandler) ffestb_decl_R539letters_;
24416
24417         case FFESTR_secondNONE:
24418           return (ffelexHandler) ffestb_decl_R5394_;
24419
24420 #if FFESTR_F90
24421         case FFESTR_secondTYPE:
24422           ffestb_local_.decl.type = FFESTP_typeTYPE;
24423           return (ffelexHandler) ffestb_decl_R5393_;
24424 #endif
24425
24426         default:
24427           goto bad_1;           /* :::::::::::::::::::: */
24428         }
24429
24430     case FFELEX_typeNAMES:
24431       if (ffesta_first_kw != FFESTR_firstIMPLICIT)
24432         goto bad_0;             /* :::::::::::::::::::: */
24433       switch (ffelex_token_type (t))
24434         {
24435         case FFELEX_typeCOMMA:
24436         case FFELEX_typeCOLONCOLON:
24437         case FFELEX_typeASTERISK:
24438         case FFELEX_typeSEMICOLON:
24439         case FFELEX_typeEOS:
24440           ffesta_confirmed ();
24441           break;
24442
24443         case FFELEX_typeOPEN_PAREN:
24444           break;
24445
24446         default:
24447           goto bad_1;           /* :::::::::::::::::::: */
24448         }
24449       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlIMPLICIT);
24450       if (!ffesrc_is_name_init (*p))
24451         goto bad_0;             /* :::::::::::::::::::: */
24452       ffestb_local_.decl.imp_started = FALSE;
24453       nt = ffelex_token_name_from_names (ffesta_tokens[0],
24454                                          FFESTR_firstlIMPLICIT, 0);
24455       kw = ffestr_second (nt);
24456       ffelex_token_kill (nt);
24457       switch (kw)
24458         {
24459         case FFESTR_secondINTEGER:
24460           ffestb_local_.decl.type = FFESTP_typeINTEGER;
24461           return (ffelexHandler) ffestb_decl_R5391_ (t);
24462
24463         case FFESTR_secondBYTE:
24464           ffestb_local_.decl.type = FFESTP_typeBYTE;
24465           return (ffelexHandler) ffestb_decl_R5391_ (t);
24466
24467         case FFESTR_secondWORD:
24468           ffestb_local_.decl.type = FFESTP_typeWORD;
24469           return (ffelexHandler) ffestb_decl_R5391_ (t);
24470
24471         case FFESTR_secondREAL:
24472           ffestb_local_.decl.type = FFESTP_typeREAL;
24473           return (ffelexHandler) ffestb_decl_R5391_ (t);
24474
24475         case FFESTR_secondCOMPLEX:
24476           ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
24477           return (ffelexHandler) ffestb_decl_R5391_ (t);
24478
24479         case FFESTR_secondLOGICAL:
24480           ffestb_local_.decl.type = FFESTP_typeLOGICAL;
24481           return (ffelexHandler) ffestb_decl_R5391_ (t);
24482
24483         case FFESTR_secondCHARACTER:
24484           ffestb_local_.decl.type = FFESTP_typeCHARACTER;
24485           return (ffelexHandler) ffestb_decl_R5391_ (t);
24486
24487         case FFESTR_secondDOUBLEPRECISION:
24488           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24489           ffestb_local_.decl.kind = NULL;
24490           ffestb_local_.decl.kindt = NULL;
24491           ffestb_local_.decl.len = NULL;
24492           ffestb_local_.decl.lent = NULL;
24493           return (ffelexHandler) ffestb_decl_R539letters_ (t);
24494
24495         case FFESTR_secondDOUBLECOMPLEX:
24496           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24497           ffestb_local_.decl.kind = NULL;
24498           ffestb_local_.decl.kindt = NULL;
24499           ffestb_local_.decl.len = NULL;
24500           ffestb_local_.decl.lent = NULL;
24501           return (ffelexHandler) ffestb_decl_R539letters_ (t);
24502
24503         case FFESTR_secondNONE:
24504           return (ffelexHandler) ffestb_decl_R5394_ (t);
24505
24506 #if FFESTR_F90
24507         case FFESTR_secondTYPE:
24508           ffestb_local_.decl.type = FFESTP_typeTYPE;
24509           return (ffelexHandler) ffestb_decl_R5393_ (t);
24510 #endif
24511
24512         default:
24513           goto bad_1;           /* :::::::::::::::::::: */
24514         }
24515
24516     default:
24517       goto bad_0;               /* :::::::::::::::::::: */
24518     }
24519
24520 bad_0:                          /* :::::::::::::::::::: */
24521   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", ffesta_tokens[0]);
24522   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24523
24524 bad_1:                          /* :::::::::::::::::::: */
24525   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24526   return (ffelexHandler) ffelex_swallow_tokens (t,
24527                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
24528 }
24529
24530 /* ffestb_decl_R5391_ -- "IMPLICIT" generic-type
24531
24532    return ffestb_decl_R5391_;  // to lexer
24533
24534    Handle ASTERISK or OPEN_PAREN.  */
24535
24536 static ffelexHandler
24537 ffestb_decl_R5391_ (ffelexToken t)
24538 {
24539   switch (ffelex_token_type (t))
24540     {
24541     case FFELEX_typeASTERISK:
24542       ffesta_confirmed ();
24543       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
24544       ffestb_local_.decl.badname = "IMPLICIT";
24545       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
24546         return (ffelexHandler) ffestb_decl_starlen_;
24547       return (ffelexHandler) ffestb_decl_starkind_;
24548
24549     case FFELEX_typeOPEN_PAREN:
24550       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
24551       ffestb_local_.decl.badname = "IMPLICIT";
24552       ffestb_local_.decl.kind = NULL;
24553       ffestb_local_.decl.kindt = NULL;
24554       ffestb_local_.decl.len = NULL;
24555       ffestb_local_.decl.lent = NULL;
24556       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
24557         ffestb_local_.decl.imp_handler
24558           = (ffelexHandler) ffestb_decl_typeparams_;
24559       else
24560         ffestb_local_.decl.imp_handler
24561           = (ffelexHandler) ffestb_decl_kindparam_;
24562       return (ffelexHandler) ffestb_decl_R539maybe_ (t);
24563
24564     default:
24565       break;
24566     }
24567
24568   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24569     ffestc_R539finish ();
24570   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24571   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24572 }
24573
24574 /* ffestb_decl_R5392_ -- "IMPLICIT" "DOUBLE"
24575
24576    return ffestb_decl_R5392_;  // to lexer
24577
24578    Handle NAME.  */
24579
24580 static ffelexHandler
24581 ffestb_decl_R5392_ (ffelexToken t)
24582 {
24583   switch (ffelex_token_type (t))
24584     {
24585     case FFELEX_typeNAME:
24586       switch (ffestr_second (t))
24587         {
24588         case FFESTR_secondPRECISION:
24589           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24590           break;
24591
24592         case FFESTR_secondCOMPLEX:
24593           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24594           break;
24595
24596         default:
24597           goto bad;             /* :::::::::::::::::::: */
24598         }
24599       ffestb_local_.decl.kind = NULL;
24600       ffestb_local_.decl.kindt = NULL;
24601       ffestb_local_.decl.len = NULL;
24602       ffestb_local_.decl.lent = NULL;
24603       return (ffelexHandler) ffestb_decl_R539letters_;
24604
24605     default:
24606       break;
24607     }
24608
24609 bad:                            /* :::::::::::::::::::: */
24610   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24611     ffestc_R539finish ();
24612   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24613   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24614 }
24615
24616 /* ffestb_decl_R5393_ -- "IMPLICIT" "TYPE"
24617
24618    return ffestb_decl_R5393_;  // to lexer
24619
24620    Handle OPEN_PAREN.  */
24621
24622 #if FFESTR_F90
24623 static ffelexHandler
24624 ffestb_decl_R5393_ (ffelexToken t)
24625 {
24626   switch (ffelex_token_type (t))
24627     {
24628     case FFELEX_typeOPEN_PAREN:
24629       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
24630       ffestb_local_.decl.badname = "IMPLICIT";
24631       return (ffelexHandler) ffestb_decl_typetype1_;
24632
24633     default:
24634       break;
24635     }
24636
24637   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24638     ffestc_R539finish ();
24639   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24640   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24641 }
24642
24643 #endif
24644 /* ffestb_decl_R5394_ -- "IMPLICIT" "NONE"
24645
24646    return ffestb_decl_R5394_;  // to lexer
24647
24648    Handle EOS/SEMICOLON.  */
24649
24650 static ffelexHandler
24651 ffestb_decl_R5394_ (ffelexToken t)
24652 {
24653   switch (ffelex_token_type (t))
24654     {
24655     case FFELEX_typeEOS:
24656     case FFELEX_typeSEMICOLON:
24657       ffesta_confirmed ();
24658       if (!ffesta_is_inhibited ())
24659         ffestc_R539 ();         /* IMPLICIT NONE. */
24660       return (ffelexHandler) ffesta_zero (t);
24661
24662     default:
24663       break;
24664     }
24665
24666   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24667   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24668 }
24669
24670 /* ffestb_decl_R5395_ -- "IMPLICIT" implicit-spec-list COMMA
24671
24672    return ffestb_decl_R5395_;  // to lexer
24673
24674    Handle NAME for next type-spec.  */
24675
24676 static ffelexHandler
24677 ffestb_decl_R5395_ (ffelexToken t)
24678 {
24679   switch (ffelex_token_type (t))
24680     {
24681     case FFELEX_typeNAME:
24682       switch (ffestr_second (t))
24683         {
24684         case FFESTR_secondINTEGER:
24685           ffestb_local_.decl.type = FFESTP_typeINTEGER;
24686           return (ffelexHandler) ffestb_decl_R5391_;
24687
24688         case FFESTR_secondBYTE:
24689           ffestb_local_.decl.type = FFESTP_typeBYTE;
24690           return (ffelexHandler) ffestb_decl_R5391_;
24691
24692         case FFESTR_secondWORD:
24693           ffestb_local_.decl.type = FFESTP_typeWORD;
24694           return (ffelexHandler) ffestb_decl_R5391_;
24695
24696         case FFESTR_secondREAL:
24697           ffestb_local_.decl.type = FFESTP_typeREAL;
24698           return (ffelexHandler) ffestb_decl_R5391_;
24699
24700         case FFESTR_secondCOMPLEX:
24701           ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
24702           return (ffelexHandler) ffestb_decl_R5391_;
24703
24704         case FFESTR_secondLOGICAL:
24705           ffestb_local_.decl.type = FFESTP_typeLOGICAL;
24706           return (ffelexHandler) ffestb_decl_R5391_;
24707
24708         case FFESTR_secondCHARACTER:
24709           ffestb_local_.decl.type = FFESTP_typeCHARACTER;
24710           return (ffelexHandler) ffestb_decl_R5391_;
24711
24712         case FFESTR_secondDOUBLE:
24713           return (ffelexHandler) ffestb_decl_R5392_;
24714
24715         case FFESTR_secondDOUBLEPRECISION:
24716           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24717           ffestb_local_.decl.kind = NULL;
24718           ffestb_local_.decl.kindt = NULL;
24719           ffestb_local_.decl.len = NULL;
24720           ffestb_local_.decl.lent = NULL;
24721           return (ffelexHandler) ffestb_decl_R539letters_;
24722
24723         case FFESTR_secondDOUBLECOMPLEX:
24724           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24725           ffestb_local_.decl.kind = NULL;
24726           ffestb_local_.decl.kindt = NULL;
24727           ffestb_local_.decl.len = NULL;
24728           ffestb_local_.decl.lent = NULL;
24729           return (ffelexHandler) ffestb_decl_R539letters_;
24730
24731 #if FFESTR_F90
24732         case FFESTR_secondTYPE:
24733           ffestb_local_.decl.type = FFESTP_typeTYPE;
24734           return (ffelexHandler) ffestb_decl_R5393_;
24735 #endif
24736
24737         default:
24738           break;
24739         }
24740       break;
24741
24742     default:
24743       break;
24744     }
24745
24746   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24747     ffestc_R539finish ();
24748   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24749   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24750 }
24751
24752 /* ffestb_decl_R539letters_ -- "IMPLICIT" type-spec
24753
24754    return ffestb_decl_R539letters_;  // to lexer
24755
24756    Handle OPEN_PAREN.  */
24757
24758 static ffelexHandler
24759 ffestb_decl_R539letters_ (ffelexToken t)
24760 {
24761   ffelex_set_names (FALSE);
24762
24763   switch (ffelex_token_type (t))
24764     {
24765     case FFELEX_typeOPEN_PAREN:
24766       ffestb_local_.decl.imps = ffestt_implist_create ();
24767       return (ffelexHandler) ffestb_decl_R539letters_1_;
24768
24769     default:
24770       break;
24771     }
24772
24773   if (ffestb_local_.decl.kindt != NULL)
24774     ffelex_token_kill (ffestb_local_.decl.kindt);
24775   if (ffestb_local_.decl.lent != NULL)
24776     ffelex_token_kill (ffestb_local_.decl.lent);
24777   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24778     ffestc_R539finish ();
24779   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24780   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24781 }
24782
24783 /* ffestb_decl_R539letters_1_ -- "IMPLICIT" type-spec OPEN_PAREN
24784
24785    return ffestb_decl_R539letters_1_;  // to lexer
24786
24787    Handle NAME.  */
24788
24789 static ffelexHandler
24790 ffestb_decl_R539letters_1_ (ffelexToken t)
24791 {
24792   switch (ffelex_token_type (t))
24793     {
24794     case FFELEX_typeNAME:
24795       if (ffelex_token_length (t) != 1)
24796         break;
24797       ffesta_tokens[1] = ffelex_token_use (t);
24798       return (ffelexHandler) ffestb_decl_R539letters_2_;
24799
24800     default:
24801       break;
24802     }
24803
24804   ffestt_implist_kill (ffestb_local_.decl.imps);
24805   if (ffestb_local_.decl.kindt != NULL)
24806     ffelex_token_kill (ffestb_local_.decl.kindt);
24807   if (ffestb_local_.decl.lent != NULL)
24808     ffelex_token_kill (ffestb_local_.decl.lent);
24809   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24810     ffestc_R539finish ();
24811   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24812   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24813 }
24814
24815 /* ffestb_decl_R539letters_2_ -- "IMPLICIT" type-spec OPEN_PAREN NAME
24816
24817    return ffestb_decl_R539letters_2_;  // to lexer
24818
24819    Handle COMMA or MINUS.  */
24820
24821 static ffelexHandler
24822 ffestb_decl_R539letters_2_ (ffelexToken t)
24823 {
24824   switch (ffelex_token_type (t))
24825     {
24826     case FFELEX_typeCOMMA:
24827       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
24828       return (ffelexHandler) ffestb_decl_R539letters_1_;
24829
24830     case FFELEX_typeCLOSE_PAREN:
24831       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
24832       return (ffelexHandler) ffestb_decl_R539letters_5_;
24833
24834     case FFELEX_typeMINUS:
24835       return (ffelexHandler) ffestb_decl_R539letters_3_;
24836
24837     default:
24838       break;
24839     }
24840
24841   ffelex_token_kill (ffesta_tokens[1]);
24842   ffestt_implist_kill (ffestb_local_.decl.imps);
24843   if (ffestb_local_.decl.kindt != NULL)
24844     ffelex_token_kill (ffestb_local_.decl.kindt);
24845   if (ffestb_local_.decl.lent != NULL)
24846     ffelex_token_kill (ffestb_local_.decl.lent);
24847   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24848     ffestc_R539finish ();
24849   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24850   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24851 }
24852
24853 /* ffestb_decl_R539letters_3_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
24854
24855    return ffestb_decl_R539letters_3_;  // to lexer
24856
24857    Handle NAME.  */
24858
24859 static ffelexHandler
24860 ffestb_decl_R539letters_3_ (ffelexToken t)
24861 {
24862   switch (ffelex_token_type (t))
24863     {
24864     case FFELEX_typeNAME:
24865       if (ffelex_token_length (t) != 1)
24866         break;
24867       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1],
24868                              ffelex_token_use (t));
24869       return (ffelexHandler) ffestb_decl_R539letters_4_;
24870
24871     default:
24872       break;
24873     }
24874
24875   ffelex_token_kill (ffesta_tokens[1]);
24876   ffestt_implist_kill (ffestb_local_.decl.imps);
24877   if (ffestb_local_.decl.kindt != NULL)
24878     ffelex_token_kill (ffestb_local_.decl.kindt);
24879   if (ffestb_local_.decl.lent != NULL)
24880     ffelex_token_kill (ffestb_local_.decl.lent);
24881   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24882     ffestc_R539finish ();
24883   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24884   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24885 }
24886
24887 /* ffestb_decl_R539letters_4_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
24888                                  NAME
24889
24890    return ffestb_decl_R539letters_4_;  // to lexer
24891
24892    Handle COMMA or CLOSE_PAREN.  */
24893
24894 static ffelexHandler
24895 ffestb_decl_R539letters_4_ (ffelexToken t)
24896 {
24897   switch (ffelex_token_type (t))
24898     {
24899     case FFELEX_typeCOMMA:
24900       return (ffelexHandler) ffestb_decl_R539letters_1_;
24901
24902     case FFELEX_typeCLOSE_PAREN:
24903       return (ffelexHandler) ffestb_decl_R539letters_5_;
24904
24905     default:
24906       break;
24907     }
24908
24909   ffestt_implist_kill (ffestb_local_.decl.imps);
24910   if (ffestb_local_.decl.kindt != NULL)
24911     ffelex_token_kill (ffestb_local_.decl.kindt);
24912   if (ffestb_local_.decl.lent != NULL)
24913     ffelex_token_kill (ffestb_local_.decl.lent);
24914   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24915     ffestc_R539finish ();
24916   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24917   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24918 }
24919
24920 /* ffestb_decl_R539letters_5_ -- "IMPLICIT" type-spec OPEN_PAREN
24921                                  letter-spec-list CLOSE_PAREN
24922
24923    return ffestb_decl_R539letters_5_;  // to lexer
24924
24925    Handle COMMA or EOS/SEMICOLON.  */
24926
24927 static ffelexHandler
24928 ffestb_decl_R539letters_5_ (ffelexToken t)
24929 {
24930   switch (ffelex_token_type (t))
24931     {
24932     case FFELEX_typeCOMMA:
24933     case FFELEX_typeEOS:
24934     case FFELEX_typeSEMICOLON:
24935       if (!ffestb_local_.decl.imp_started)
24936         {
24937           ffestb_local_.decl.imp_started = TRUE;
24938           ffesta_confirmed ();
24939           if (!ffesta_is_inhibited ())
24940             ffestc_R539start ();
24941         }
24942       if (!ffesta_is_inhibited ())
24943         ffestc_R539item (ffestb_local_.decl.type, ffestb_local_.decl.kind,
24944                          ffestb_local_.decl.kindt, ffestb_local_.decl.len,
24945                          ffestb_local_.decl.lent, ffestb_local_.decl.imps);
24946       if (ffestb_local_.decl.kindt != NULL)
24947         ffelex_token_kill (ffestb_local_.decl.kindt);
24948       if (ffestb_local_.decl.lent != NULL)
24949         ffelex_token_kill (ffestb_local_.decl.lent);
24950       ffestt_implist_kill (ffestb_local_.decl.imps);
24951       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
24952         return (ffelexHandler) ffestb_decl_R5395_;
24953       if (!ffesta_is_inhibited ())
24954         ffestc_R539finish ();
24955       return (ffelexHandler) ffesta_zero (t);
24956
24957     default:
24958       break;
24959     }
24960
24961   ffestt_implist_kill (ffestb_local_.decl.imps);
24962   if (ffestb_local_.decl.kindt != NULL)
24963     ffelex_token_kill (ffestb_local_.decl.kindt);
24964   if (ffestb_local_.decl.lent != NULL)
24965     ffelex_token_kill (ffestb_local_.decl.lent);
24966   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24967     ffestc_R539finish ();
24968   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24969   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24970 }
24971
24972 /* ffestb_decl_R539maybe_ -- "IMPLICIT" generic-type-spec
24973
24974    return ffestb_decl_R539maybe_;  // to lexer
24975
24976    Handle OPEN_PAREN.  */
24977
24978 static ffelexHandler
24979 ffestb_decl_R539maybe_ (ffelexToken t)
24980 {
24981   assert (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN);
24982   ffestb_local_.decl.imps = ffestt_implist_create ();
24983   ffestb_local_.decl.toklist = ffestt_tokenlist_create ();
24984   ffestb_local_.decl.imp_seen_comma
24985     = (ffestb_local_.decl.type != FFESTP_typeCHARACTER);
24986   return (ffelexHandler) ffestb_decl_R539maybe_1_;
24987 }
24988
24989 /* ffestb_decl_R539maybe_1_ -- "IMPLICIT" generic-type-spec OPEN_PAREN
24990
24991    return ffestb_decl_R539maybe_1_;  // to lexer
24992
24993    Handle NAME.  */
24994
24995 static ffelexHandler
24996 ffestb_decl_R539maybe_1_ (ffelexToken t)
24997 {
24998   ffelexHandler next;
24999
25000   switch (ffelex_token_type (t))
25001     {
25002     case FFELEX_typeNAME:
25003       if (ffelex_token_length (t) != 1)
25004         break;
25005       ffesta_tokens[1] = ffelex_token_use (t);
25006       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25007       return (ffelexHandler) ffestb_decl_R539maybe_2_;
25008
25009     default:
25010       break;
25011     }
25012
25013   ffestt_implist_kill (ffestb_local_.decl.imps);
25014   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25015                             (ffelexHandler) ffestb_local_.decl.imp_handler);
25016   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25017   return (ffelexHandler) (*next) (t);
25018 }
25019
25020 /* ffestb_decl_R539maybe_2_ -- "IMPLICIT" generic-type-spec OPEN_PAREN NAME
25021
25022    return ffestb_decl_R539maybe_2_;  // to lexer
25023
25024    Handle COMMA or MINUS.  */
25025
25026 static ffelexHandler
25027 ffestb_decl_R539maybe_2_ (ffelexToken t)
25028 {
25029   ffelexHandler next;
25030
25031   switch (ffelex_token_type (t))
25032     {
25033     case FFELEX_typeCOMMA:
25034       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
25035       if (ffestb_local_.decl.imp_seen_comma)
25036         {
25037           ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25038           return (ffelexHandler) ffestb_decl_R539letters_1_;
25039         }
25040       ffestb_local_.decl.imp_seen_comma = TRUE;
25041       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25042       return (ffelexHandler) ffestb_decl_R539maybe_1_;
25043
25044     case FFELEX_typeCLOSE_PAREN:
25045       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
25046       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25047       return (ffelexHandler) ffestb_decl_R539maybe_5_;
25048
25049     case FFELEX_typeMINUS:
25050       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25051       return (ffelexHandler) ffestb_decl_R539maybe_3_;
25052
25053     default:
25054       break;
25055     }
25056
25057   ffelex_token_kill (ffesta_tokens[1]);
25058   ffestt_implist_kill (ffestb_local_.decl.imps);
25059   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25060                             (ffelexHandler) ffestb_local_.decl.imp_handler);
25061   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25062   return (ffelexHandler) (*next) (t);
25063 }
25064
25065 /* ffestb_decl_R539maybe_3_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
25066
25067    return ffestb_decl_R539maybe_3_;  // to lexer
25068
25069    Handle NAME.  */
25070
25071 static ffelexHandler
25072 ffestb_decl_R539maybe_3_ (ffelexToken t)
25073 {
25074   ffelexHandler next;
25075
25076   switch (ffelex_token_type (t))
25077     {
25078     case FFELEX_typeNAME:
25079       if (ffelex_token_length (t) != 1)
25080         break;
25081       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1],
25082                              ffelex_token_use (t));
25083       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25084       return (ffelexHandler) ffestb_decl_R539maybe_4_;
25085
25086     default:
25087       break;
25088     }
25089
25090   ffelex_token_kill (ffesta_tokens[1]);
25091   ffestt_implist_kill (ffestb_local_.decl.imps);
25092   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25093                             (ffelexHandler) ffestb_local_.decl.imp_handler);
25094   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25095   return (ffelexHandler) (*next) (t);
25096 }
25097
25098 /* ffestb_decl_R539maybe_4_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
25099                                  NAME
25100
25101    return ffestb_decl_R539maybe_4_;  // to lexer
25102
25103    Handle COMMA or CLOSE_PAREN.  */
25104
25105 static ffelexHandler
25106 ffestb_decl_R539maybe_4_ (ffelexToken t)
25107 {
25108   ffelexHandler next;
25109
25110   switch (ffelex_token_type (t))
25111     {
25112     case FFELEX_typeCOMMA:
25113       if (ffestb_local_.decl.imp_seen_comma)
25114         {
25115           ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25116           return (ffelexHandler) ffestb_decl_R539letters_1_;
25117         }
25118       ffestb_local_.decl.imp_seen_comma = TRUE;
25119       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25120       return (ffelexHandler) ffestb_decl_R539maybe_1_;
25121
25122     case FFELEX_typeCLOSE_PAREN:
25123       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25124       return (ffelexHandler) ffestb_decl_R539maybe_5_;
25125
25126     default:
25127       break;
25128     }
25129
25130   ffestt_implist_kill (ffestb_local_.decl.imps);
25131   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25132                             (ffelexHandler) ffestb_local_.decl.imp_handler);
25133   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25134   return (ffelexHandler) (*next) (t);
25135 }
25136
25137 /* ffestb_decl_R539maybe_5_ -- "IMPLICIT" type-spec OPEN_PAREN
25138                                  letter-spec-list CLOSE_PAREN
25139
25140    return ffestb_decl_R539maybe_5_;  // to lexer
25141
25142    Handle COMMA or EOS/SEMICOLON.  */
25143
25144 static ffelexHandler
25145 ffestb_decl_R539maybe_5_ (ffelexToken t)
25146 {
25147   ffelexHandler next;
25148
25149   switch (ffelex_token_type (t))
25150     {
25151     case FFELEX_typeCOMMA:
25152     case FFELEX_typeEOS:
25153     case FFELEX_typeSEMICOLON:
25154       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25155       if (!ffestb_local_.decl.imp_started)
25156         {
25157           ffestb_local_.decl.imp_started = TRUE;
25158           ffesta_confirmed ();
25159           if (!ffesta_is_inhibited ())
25160             ffestc_R539start ();
25161         }
25162       if (!ffesta_is_inhibited ())
25163         ffestc_R539item (ffestb_local_.decl.type, ffestb_local_.decl.kind,
25164                          ffestb_local_.decl.kindt, ffestb_local_.decl.len,
25165                          ffestb_local_.decl.lent, ffestb_local_.decl.imps);
25166       if (ffestb_local_.decl.kindt != NULL)
25167         ffelex_token_kill (ffestb_local_.decl.kindt);
25168       if (ffestb_local_.decl.lent != NULL)
25169         ffelex_token_kill (ffestb_local_.decl.lent);
25170       ffestt_implist_kill (ffestb_local_.decl.imps);
25171       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
25172         return (ffelexHandler) ffestb_decl_R5395_;
25173       if (!ffesta_is_inhibited ())
25174         ffestc_R539finish ();
25175       return (ffelexHandler) ffesta_zero (t);
25176
25177     case FFELEX_typeOPEN_PAREN:
25178       ffesta_confirmed ();
25179       ffestt_implist_kill (ffestb_local_.decl.imps);
25180       next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25181                             (ffelexHandler) ffestb_local_.decl.imp_handler);
25182       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25183       return (ffelexHandler) (*next) (t);
25184
25185     default:
25186       break;
25187     }
25188
25189   ffestt_implist_kill (ffestb_local_.decl.imps);
25190   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25191   if (ffestb_local_.decl.kindt != NULL)
25192     ffelex_token_kill (ffestb_local_.decl.kindt);
25193   if (ffestb_local_.decl.lent != NULL)
25194     ffelex_token_kill (ffestb_local_.decl.lent);
25195   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
25196     ffestc_R539finish ();
25197   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
25198   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
25199 }