gcc/f/stb.c

   1 /* stb.c -- Implementation File (module.c template V1.0)
   2    Copyright (C) 1995, 1996, 2002 Free Software Foundation, Inc.
   3    Contributed by James Craig Burley.
   4
   5 This file is part of GNU Fortran.
   6
   7 GNU Fortran is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Fortran is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Fortran; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21
  22    Related Modules:
  23       st.c
  24
  25    Description:
  26       Parses the proper form for statements, builds up expression trees for
  27       them, but does not actually implement them.  Uses ffebad (primarily via
  28       ffesta_ffebad_start) to indicate errors in form.  In many cases, an invalid
  29       statement form indicates another possible statement needs to be looked at
  30       by ffest.  In a few cases, a valid statement form might not completely
  31       determine the nature of the statement, as in REALFUNCTIONA(B), which is
  32       a valid form for either the first statement of a function named A taking
  33       an argument named B or for the declaration of a real array named FUNCTIONA
  34       with an adjustable size of B.  A similar (though somewhat easier) choice
  35       must be made for the statement-function-def vs. assignment forms, as in
  36       the case of FOO(A) = A+2.0.
  37
  38       A given parser consists of one or more state handlers, the first of which
  39       is the initial state, and the last of which (for any given input) returns
  40       control to a final state handler (ffesta_zero or ffesta_two, explained
  41       below).  The functions handling the states for a given parser usually have
  42       the same names, differing only in the final number, as in ffestb_foo_
  43       (handles the initial state), ffestb_foo_1_, ffestb_foo_2_ (handle
  44       subsequent states), although liberties sometimes are taken with the "foo"
  45       part either when keywords are clarified into given statements or are
  46       transferred into other possible areas.  (For example, the type-name
  47       states can hop over to _dummy_ functions when the FUNCTION or RECURSIVE
  48       keywords are seen, though this kind of thing is kept to a minimum.)  Only
  49       the names without numbers are exported to the rest of ffest; the others
  50       are local (static).
  51
  52       Each initial state is provided with the first token in ffesta_tokens[0],
  53       which will be killed upon return to the final state (ffesta_zero or
  54       ffelex_swallow_tokens passed through to ffesta_zero), so while it may
  55       be changed to another token, a valid token must be left there to be
  56       killed.  Also, a "convenient" array of tokens are left in
  57       ffesta_tokens[1..FFESTA_tokensMAX].  The initial state of this set of
  58       elements is undefined, thus, if tokens are stored here, they must be
  59       killed before returning to the final state.  Any parser may also use
  60       cross-state local variables by sticking a structure containing storage
  61       for those variables in the local union ffestb_local_ (unless the union
  62       goes on strike).  Furthermore, parsers that handle more than one first or
  63       second tokens (like _varlist_, which handles EXTERNAL, INTENT, INTRINSIC,
  64       OPTIONAL,
  65       PUBLIC, or PRIVATE, and _endxyz_, which handles ENDBLOCK, ENDBLOCKDATA,
  66       ENDDO, ENDIF, and so on) may expect arguments from ffest in the
  67       ffest-wide union ffest_args_, the substructure specific to the parser.
  68
  69       A parser's responsibility is: to call either ffesta_confirmed or
  70       ffest_ffebad_start before returning to the final state; to be the only
  71       parser that can possibly call ffesta_confirmed for a given statement;
  72       to call ffest_ffebad_start immediately upon recognizing a bad token
  73       (specifically one that another statement parser might confirm upon);
  74       to call ffestc functions only after calling ffesta_confirmed and only
  75       when ffesta_is_inhibited returns FALSE; and to call ffesta_is_inhibited
  76       only after calling ffesta_confirmed.  Confirm as early as reasonably
  77       possible, even when only one ffestc function is called for the statement
  78       later on, because early confirmation can enhance the error-reporting
  79       capabilities if a subsequent error is detected and this parser isn't
  80       the first possibility for the statement.
  81
  82       To assist the parser, functions like ffesta_ffebad_1t and _1p_ have
  83       been provided to make use of ffest_ffebad_start fairly easy.
  84
  85    Modifications:
  86 */
  87
  88 /* Include files. */
  89
  90 #include "proj.h"
  91 #include "stb.h"
  92 #include "bad.h"
  93 #include "expr.h"
  94 #include "lex.h"
  95 #include "malloc.h"
  96 #include "src.h"
  97 #include "sta.h"
  98 #include "stc.h"
  99 #include "stp.h"
 100 #include "str.h"
 101
 102 /* Externals defined here. */
 103
 104 struct _ffestb_args_ ffestb_args;
 105
 106 /* Simple definitions and enumerations. */
 107
 108 #define FFESTB_KILL_EASY_ 1     /* 1 for only one _subr_kill_xyz_ fn. */
 109
 110 /* Internal typedefs. */
 111
 112 union ffestb_subrargs_u_
 113   {
 114     struct
 115       {
 116         ffesttTokenList labels; /* Input arg, must not be NULL. */
 117         ffelexHandler handler;  /* Input arg, call me when done. */
 118         bool ok;                /* Output arg, TRUE if list ended in
 119                                    CLOSE_PAREN. */
 120       }
 121     label_list;
 122     struct
 123       {
 124         ffesttDimList dims;     /* Input arg, must not be NULL. */
 125         ffelexHandler handler;  /* Input arg, call me when done. */
 126         mallocPool pool;        /* Pool to allocate into. */
 127         bool ok;                /* Output arg, TRUE if list ended in
 128                                    CLOSE_PAREN. */
 129         ffeexprContext ctx;     /* DIMLIST or DIMLISTCOMMON. */
 130 #ifdef FFECOM_dimensionsMAX
 131         int ndims;              /* For backends that really can't have
 132                                    infinite dims. */
 133 #endif
 134       }
 135     dim_list;
 136     struct
 137       {
 138         ffesttTokenList args;   /* Input arg, must not be NULL. */
 139         ffelexHandler handler;  /* Input arg, call me when done. */
 140         ffelexToken close_paren;/* Output arg if ok, CLOSE_PAREN token. */
 141         bool is_subr;           /* Input arg, TRUE if list in subr-def
 142                                    context. */
 143         bool ok;                /* Output arg, TRUE if list ended in
 144                                    CLOSE_PAREN. */
 145         bool names;             /* Do ffelex_set_names(TRUE) before return. */
 146       }
 147     name_list;
 148   };
 149
 150 union ffestb_local_u_
 151   {
 152     struct
 153       {
 154         ffebld expr;
 155       }
 156     call_stmt;
 157     struct
 158       {
 159         ffebld expr;
 160       }
 161     go_to;
 162     struct
 163       {
 164         ffebld dest;
 165         bool vxtparam;          /* If assignment might really be VXT
 166                                    PARAMETER stmt. */
 167       }
 168     let;
 169     struct
 170       {
 171         ffebld expr;
 172       }
 173     if_stmt;
 174     struct
 175       {
 176         ffebld expr;
 177       }
 178     else_stmt;
 179     struct
 180       {
 181         ffebld expr;
 182       }
 183     dowhile;
 184     struct
 185       {
 186         ffebld var;
 187         ffebld start;
 188         ffebld end;
 189       }
 190     do_stmt;
 191     struct
 192       {
 193         bool is_cblock;
 194       }
 195     R522;
 196     struct
 197       {
 198         ffebld expr;
 199         bool started;
 200       }
 201     parameter;
 202     struct
 203       {
 204         ffesttExprList exprs;
 205         bool started;
 206       }
 207     equivalence;
 208     struct
 209       {
 210         ffebld expr;
 211         bool started;
 212       }
 213     data;
 214     struct
 215       {
 216         ffestrOther kw;
 217       }
 218     varlist;
 219 #if FFESTR_F90
 220     struct
 221       {
 222         ffestrOther kw;
 223       }
 224     type;
 225 #endif
 226     struct
 227       {
 228         ffelexHandler next;
 229       }
 230     construct;
 231     struct
 232       {
 233         ffesttFormatList f;
 234         ffestpFormatType current;       /* What we're currently working on. */
 235         ffelexToken t;          /* Token of what we're currently working on. */
 236         ffesttFormatValue pre;
 237         ffesttFormatValue post;
 238         ffesttFormatValue dot;
 239         ffesttFormatValue exp;
 240         bool sign;              /* _3_, pos/neg; elsewhere, signed/unsigned. */
 241         bool complained;        /* If run-time expr seen in nonexec context. */
 242       }
 243     format;
 244 #if FFESTR_F90
 245     struct
 246       {
 247         bool started;
 248       }
 249     moduleprocedure;
 250 #endif
 251     struct
 252       {
 253         ffebld expr;
 254       }
 255     selectcase;
 256     struct
 257       {
 258         ffesttCaseList cases;
 259       }
 260     case_stmt;
 261 #if FFESTR_F90
 262     struct
 263       {
 264         ffesttExprList exprs;
 265         ffebld expr;
 266       }
 267     heap;
 268 #endif
 269 #if FFESTR_F90
 270     struct
 271       {
 272         ffesttExprList exprs;
 273       }
 274     R624;
 275 #endif
 276 #if FFESTR_F90
 277     struct
 278       {
 279         ffestpDefinedOperator operator;
 280         bool assignment;        /* TRUE for INTERFACE ASSIGNMENT, FALSE for
 281                                    ...OPERATOR. */
 282         bool slash;             /* TRUE if OPEN_ARRAY, FALSE if OPEN_PAREN. */
 283       }
 284     interface;
 285 #endif
 286     struct
 287       {
 288         bool is_cblock;
 289       }
 290     V014;
 291 #if FFESTR_VXT
 292     struct
 293       {
 294         bool started;
 295         ffebld u;
 296         ffebld m;
 297         ffebld n;
 298         ffebld asv;
 299       }
 300     V025;
 301 #endif
 302     struct
 303       {
 304         ffestpBeruIx ix;
 305         bool label;
 306         bool left;
 307         ffeexprContext context;
 308       }
 309     beru;
 310     struct
 311       {
 312         ffestpCloseIx ix;
 313         bool label;
 314         bool left;
 315         ffeexprContext context;
 316       }
 317     close;
 318     struct
 319       {
 320         ffestpDeleteIx ix;
 321         bool label;
 322         bool left;
 323         ffeexprContext context;
 324       }
 325     delete;
 326     struct
 327       {
 328         ffestpDeleteIx ix;
 329         bool label;
 330         bool left;
 331         ffeexprContext context;
 332       }
 333     find;
 334     struct
 335       {
 336         ffestpInquireIx ix;
 337         bool label;
 338         bool left;
 339         ffeexprContext context;
 340         bool may_be_iolength;
 341       }
 342     inquire;
 343     struct
 344       {
 345         ffestpOpenIx ix;
 346         bool label;
 347         bool left;
 348         ffeexprContext context;
 349       }
 350     open;
 351     struct
 352       {
 353         ffestpReadIx ix;
 354         bool label;
 355         bool left;
 356         ffeexprContext context;
 357       }
 358     read;
 359     struct
 360       {
 361         ffestpRewriteIx ix;
 362         bool label;
 363         bool left;
 364         ffeexprContext context;
 365       }
 366     rewrite;
 367     struct
 368       {
 369         ffestpWriteIx ix;
 370         bool label;
 371         bool left;
 372         ffeexprContext context;
 373       }
 374     vxtcode;
 375     struct
 376       {
 377         ffestpWriteIx ix;
 378         bool label;
 379         bool left;
 380         ffeexprContext context;
 381       }
 382     write;
 383 #if FFESTR_F90
 384     struct
 385       {
 386         bool started;
 387       }
 388     structure;
 389 #endif
 390     struct
 391       {
 392         bool started;
 393       }
 394     common;
 395     struct
 396       {
 397         bool started;
 398       }
 399     dimension;
 400     struct
 401       {
 402         bool started;
 403       }
 404     dimlist;
 405     struct
 406       {
 407         const char *badname;
 408         ffestrFirst first_kw;
 409         bool is_subr;
 410       }
 411     dummy;
 412     struct
 413       {
 414         ffebld kind;            /* Kind type parameter, if any. */
 415         ffelexToken kindt;      /* Kind type first token, if any. */
 416         ffebld len;             /* Length type parameter, if any. */
 417         ffelexToken lent;       /* Length type parameter, if any. */
 418         ffelexHandler handler;
 419         ffelexToken recursive;
 420         ffebld expr;
 421         ffesttTokenList toklist;/* For ambiguity resolution. */
 422         ffesttImpList imps;     /* List of IMPLICIT letters. */
 423         ffelexHandler imp_handler;      /* Call if paren list wasn't letters. */
 424         const char *badname;
 425         ffestrOther kw;         /* INTENT(IN/OUT/INOUT). */
 426         ffestpType type;
 427         bool parameter;         /* If PARAMETER attribute seen (governs =expr
 428                                    context). */
 429         bool coloncolon;        /* If COLONCOLON seen (allows =expr). */
 430         bool aster_after;       /* "*" seen after, not before,
 431                                    [RECURSIVE]FUNCTIONxyz. */
 432         bool empty;             /* Ambig function dummy arg list empty so
 433                                    far? */
 434         bool imp_started;       /* Started IMPLICIT statement already. */
 435         bool imp_seen_comma;    /* TRUE if next COMMA within parens means not
 436                                    R541. */
 437       }
 438     decl;
 439     struct
 440       {
 441         bool started;
 442       }
 443     vxtparam;
 444   };                            /* Merge with the one in ffestb later. */
 445
 446 /* Private include files. */
 447
 448
 449 /* Internal structure definitions. */
 450
 451
 452 /* Static objects accessed by functions in this module. */
 453
 454 static union ffestb_subrargs_u_ ffestb_subrargs_;
 455 static union ffestb_local_u_ ffestb_local_;
 456
 457 /* Static functions (internal). */
 458
 459 static void ffestb_subr_ambig_to_ents_ (void);
 460 static ffelexHandler ffestb_subr_ambig_nope_ (ffelexToken t);
 461 static ffelexHandler ffestb_subr_dimlist_ (ffelexToken ft, ffebld expr,
 462                                            ffelexToken t);
 463 static ffelexHandler ffestb_subr_dimlist_1_ (ffelexToken ft, ffebld expr,
 464                                              ffelexToken t);
 465 static ffelexHandler ffestb_subr_dimlist_2_ (ffelexToken ft, ffebld expr,
 466                                              ffelexToken t);
 467 static ffelexHandler ffestb_subr_name_list_ (ffelexToken t);
 468 static ffelexHandler ffestb_subr_name_list_1_ (ffelexToken t);
 469 static void ffestb_subr_R1001_append_p_ (void);
 470 static ffelexHandler ffestb_decl_kindparam_ (ffelexToken t);
 471 static ffelexHandler ffestb_decl_kindparam_1_ (ffelexToken t);
 472 static ffelexHandler ffestb_decl_kindparam_2_ (ffelexToken ft, ffebld expr,
 473                                                ffelexToken t);
 474 static ffelexHandler ffestb_decl_starkind_ (ffelexToken t);
 475 static ffelexHandler ffestb_decl_starlen_ (ffelexToken t);
 476 static ffelexHandler ffestb_decl_starlen_1_ (ffelexToken ft, ffebld expr,
 477                                              ffelexToken t);
 478 static ffelexHandler ffestb_decl_typeparams_ (ffelexToken t);
 479 static ffelexHandler ffestb_decl_typeparams_1_ (ffelexToken t);
 480 static ffelexHandler ffestb_decl_typeparams_2_ (ffelexToken ft, ffebld expr,
 481                                                 ffelexToken t);
 482 static ffelexHandler ffestb_decl_typeparams_3_ (ffelexToken ft, ffebld expr,
 483                                                 ffelexToken t);
 484 #if FFESTR_F90
 485 static ffelexHandler ffestb_decl_typetype1_ (ffelexToken t);
 486 static ffelexHandler ffestb_decl_typetype2_ (ffelexToken t);
 487 #endif
 488 static ffelexHandler ffestb_subr_label_list_ (ffelexToken t);
 489 static ffelexHandler ffestb_subr_label_list_1_ (ffelexToken t);
 490 static ffelexHandler ffestb_do1_ (ffelexToken t);
 491 static ffelexHandler ffestb_do2_ (ffelexToken t);
 492 static ffelexHandler ffestb_do3_ (ffelexToken t);
 493 static ffelexHandler ffestb_do4_ (ffelexToken ft, ffebld expr,
 494                                   ffelexToken t);
 495 static ffelexHandler ffestb_do5_ (ffelexToken t);
 496 static ffelexHandler ffestb_do6_ (ffelexToken ft, ffebld expr,
 497                                   ffelexToken t);
 498 static ffelexHandler ffestb_do7_ (ffelexToken ft, ffebld expr,
 499                                   ffelexToken t);
 500 static ffelexHandler ffestb_do8_ (ffelexToken ft, ffebld expr,
 501                                   ffelexToken t);
 502 static ffelexHandler ffestb_do9_ (ffelexToken ft, ffebld expr,
 503                                   ffelexToken t);
 504 static ffelexHandler ffestb_else1_ (ffelexToken t);
 505 static ffelexHandler ffestb_else2_ (ffelexToken ft, ffebld expr,
 506                                     ffelexToken t);
 507 static ffelexHandler ffestb_else3_ (ffelexToken t);
 508 static ffelexHandler ffestb_else4_ (ffelexToken t);
 509 static ffelexHandler ffestb_else5_ (ffelexToken t);
 510 static ffelexHandler ffestb_end1_ (ffelexToken t);
 511 static ffelexHandler ffestb_end2_ (ffelexToken t);
 512 static ffelexHandler ffestb_end3_ (ffelexToken t);
 513 static ffelexHandler ffestb_goto1_ (ffelexToken t);
 514 static ffelexHandler ffestb_goto2_ (ffelexToken t);
 515 static ffelexHandler ffestb_goto3_ (ffelexToken t);
 516 static ffelexHandler ffestb_goto4_ (ffelexToken ft, ffebld expr,
 517                                     ffelexToken t);
 518 static ffelexHandler ffestb_goto5_ (ffelexToken ft, ffebld expr,
 519                                     ffelexToken t);
 520 static ffelexHandler ffestb_goto6_ (ffelexToken t);
 521 static ffelexHandler ffestb_goto7_ (ffelexToken t);
 522 static ffelexHandler ffestb_halt1_ (ffelexToken ft, ffebld expr,
 523                                     ffelexToken t);
 524 static ffelexHandler ffestb_if1_ (ffelexToken ft, ffebld expr,
 525                                   ffelexToken t);
 526 static ffelexHandler ffestb_if2_ (ffelexToken t);
 527 static ffelexHandler ffestb_if3_ (ffelexToken t);
 528 static ffelexHandler ffestb_let1_ (ffelexToken ft, ffebld expr,
 529                                    ffelexToken t);
 530 static ffelexHandler ffestb_let2_ (ffelexToken ft, ffebld expr,
 531                                    ffelexToken t);
 532 #if FFESTR_F90
 533 static ffelexHandler ffestb_type1_ (ffelexToken t);
 534 static ffelexHandler ffestb_type2_ (ffelexToken t);
 535 static ffelexHandler ffestb_type3_ (ffelexToken t);
 536 static ffelexHandler ffestb_type4_ (ffelexToken t);
 537 #endif
 538 #if FFESTR_F90
 539 static ffelexHandler ffestb_varlist1_ (ffelexToken t);
 540 static ffelexHandler ffestb_varlist2_ (ffelexToken t);
 541 static ffelexHandler ffestb_varlist3_ (ffelexToken t);
 542 static ffelexHandler ffestb_varlist4_ (ffelexToken t);
 543 #endif
 544 static ffelexHandler ffestb_varlist5_ (ffelexToken t);
 545 static ffelexHandler ffestb_varlist6_ (ffelexToken t);
 546 #if FFESTR_F90
 547 static ffelexHandler ffestb_where1_ (ffelexToken ft, ffebld expr,
 548                                      ffelexToken t);
 549 static ffelexHandler ffestb_where2_ (ffelexToken t);
 550 static ffelexHandler ffestb_where3_ (ffelexToken t);
 551 #endif
 552 static ffelexHandler ffestb_R5221_ (ffelexToken t);
 553 static ffelexHandler ffestb_R5222_ (ffelexToken t);
 554 static ffelexHandler ffestb_R5223_ (ffelexToken t);
 555 static ffelexHandler ffestb_R5224_ (ffelexToken t);
 556 static ffelexHandler ffestb_R5281_ (ffelexToken ft, ffebld expr,
 557                                     ffelexToken t);
 558 static ffelexHandler ffestb_R5282_ (ffelexToken ft, ffebld expr,
 559                                     ffelexToken t);
 560 static ffelexHandler ffestb_R5283_ (ffelexToken ft, ffebld expr,
 561                                     ffelexToken t);
 562 static ffelexHandler ffestb_R5284_ (ffelexToken t);
 563 static ffelexHandler ffestb_R5371_ (ffelexToken ft, ffebld expr,
 564                                     ffelexToken t);
 565 static ffelexHandler ffestb_R5372_ (ffelexToken ft, ffebld expr,
 566                                     ffelexToken t);
 567 static ffelexHandler ffestb_R5373_ (ffelexToken t);
 568 static ffelexHandler ffestb_R5421_ (ffelexToken t);
 569 static ffelexHandler ffestb_R5422_ (ffelexToken t);
 570 static ffelexHandler ffestb_R5423_ (ffelexToken t);
 571 static ffelexHandler ffestb_R5424_ (ffelexToken t);
 572 static ffelexHandler ffestb_R5425_ (ffelexToken t);
 573 static ffelexHandler ffestb_R5441_ (ffelexToken ft, ffebld expr,
 574                                     ffelexToken t);
 575 static ffelexHandler ffestb_R5442_ (ffelexToken ft, ffebld expr,
 576                                     ffelexToken t);
 577 static ffelexHandler ffestb_R5443_ (ffelexToken t);
 578 static ffelexHandler ffestb_R5444_ (ffelexToken t);
 579 static ffelexHandler ffestb_R8341_ (ffelexToken t);
 580 static ffelexHandler ffestb_R8351_ (ffelexToken t);
 581 static ffelexHandler ffestb_R8381_ (ffelexToken t);
 582 static ffelexHandler ffestb_R8382_ (ffelexToken t);
 583 static ffelexHandler ffestb_R8383_ (ffelexToken ft, ffebld expr,
 584                                     ffelexToken t);
 585 static ffelexHandler ffestb_R8401_ (ffelexToken ft, ffebld expr,
 586                                     ffelexToken t);
 587 static ffelexHandler ffestb_R8402_ (ffelexToken t);
 588 static ffelexHandler ffestb_R8403_ (ffelexToken t);
 589 static ffelexHandler ffestb_R8404_ (ffelexToken t);
 590 static ffelexHandler ffestb_R8405_ (ffelexToken t);
 591 static ffelexHandler ffestb_R8406_ (ffelexToken t);
 592 static ffelexHandler ffestb_R8407_ (ffelexToken t);
 593 static ffelexHandler ffestb_R11021_ (ffelexToken t);
 594 static ffelexHandler ffestb_R1111_1_ (ffelexToken t);
 595 static ffelexHandler ffestb_R1111_2_ (ffelexToken t);
 596 static ffelexHandler ffestb_R12121_ (ffelexToken ft, ffebld expr,
 597                                      ffelexToken t);
 598 static ffelexHandler ffestb_R12271_ (ffelexToken ft, ffebld expr,
 599                                      ffelexToken t);
 600 static ffelexHandler ffestb_construct1_ (ffelexToken t);
 601 static ffelexHandler ffestb_construct2_ (ffelexToken t);
 602 #if FFESTR_F90
 603 static ffelexHandler ffestb_heap1_ (ffelexToken ft, ffebld expr,
 604                                     ffelexToken t);
 605 static ffelexHandler ffestb_heap2_ (ffelexToken t);
 606 static ffelexHandler ffestb_heap3_ (ffelexToken t);
 607 static ffelexHandler ffestb_heap4_ (ffelexToken ft, ffebld expr,
 608                                     ffelexToken t);
 609 static ffelexHandler ffestb_heap5_ (ffelexToken t);
 610 #endif
 611 #if FFESTR_F90
 612 static ffelexHandler ffestb_module1_ (ffelexToken t);
 613 static ffelexHandler ffestb_module2_ (ffelexToken t);
 614 static ffelexHandler ffestb_module3_ (ffelexToken t);
 615 #endif
 616 static ffelexHandler ffestb_R8091_ (ffelexToken t);
 617 static ffelexHandler ffestb_R8092_ (ffelexToken ft, ffebld expr,
 618                                     ffelexToken t);
 619 static ffelexHandler ffestb_R8093_ (ffelexToken t);
 620 static ffelexHandler ffestb_R8101_ (ffelexToken t);
 621 static ffelexHandler ffestb_R8102_ (ffelexToken t);
 622 static ffelexHandler ffestb_R8103_ (ffelexToken ft, ffebld expr,
 623                                     ffelexToken t);
 624 static ffelexHandler ffestb_R8104_ (ffelexToken ft, ffebld expr,
 625                                     ffelexToken t);
 626 static ffelexHandler ffestb_R10011_ (ffelexToken t);
 627 static ffelexHandler ffestb_R10012_ (ffelexToken t);
 628 static ffelexHandler ffestb_R10013_ (ffelexToken t);
 629 static ffelexHandler ffestb_R10014_ (ffelexToken t);
 630 static ffelexHandler ffestb_R10015_ (ffelexToken t);
 631 static ffelexHandler ffestb_R10016_ (ffelexToken t);
 632 static ffelexHandler ffestb_R10017_ (ffelexToken t);
 633 static ffelexHandler ffestb_R10018_ (ffelexToken t);
 634 static ffelexHandler ffestb_R10019_ (ffelexToken t);
 635 static ffelexHandler ffestb_R100110_ (ffelexToken t);
 636 static ffelexHandler ffestb_R100111_ (ffelexToken t);
 637 static ffelexHandler ffestb_R100112_ (ffelexToken t);
 638 static ffelexHandler ffestb_R100113_ (ffelexToken t);
 639 static ffelexHandler ffestb_R100114_ (ffelexToken t);
 640 static ffelexHandler ffestb_R100115_ (ffelexToken ft, ffebld expr,
 641                                       ffelexToken t);
 642 static ffelexHandler ffestb_R100116_ (ffelexToken ft, ffebld expr,
 643                                       ffelexToken t);
 644 static ffelexHandler ffestb_R100117_ (ffelexToken ft, ffebld expr,
 645                                       ffelexToken t);
 646 static ffelexHandler ffestb_R100118_ (ffelexToken ft, ffebld expr,
 647                                       ffelexToken t);
 648 #if FFESTR_F90
 649 static ffelexHandler ffestb_R11071_ (ffelexToken t);
 650 static ffelexHandler ffestb_R11072_ (ffelexToken t);
 651 static ffelexHandler ffestb_R11073_ (ffelexToken t);
 652 static ffelexHandler ffestb_R11074_ (ffelexToken t);
 653 static ffelexHandler ffestb_R11075_ (ffelexToken t);
 654 static ffelexHandler ffestb_R11076_ (ffelexToken t);
 655 static ffelexHandler ffestb_R11077_ (ffelexToken t);
 656 static ffelexHandler ffestb_R11078_ (ffelexToken t);
 657 static ffelexHandler ffestb_R11079_ (ffelexToken t);
 658 static ffelexHandler ffestb_R110710_ (ffelexToken t);
 659 static ffelexHandler ffestb_R110711_ (ffelexToken t);
 660 static ffelexHandler ffestb_R110712_ (ffelexToken t);
 661 #endif
 662 #if FFESTR_F90
 663 static ffelexHandler ffestb_R12021_ (ffelexToken t);
 664 static ffelexHandler ffestb_R12022_ (ffelexToken t);
 665 static ffelexHandler ffestb_R12023_ (ffelexToken t);
 666 static ffelexHandler ffestb_R12024_ (ffelexToken t);
 667 static ffelexHandler ffestb_R12025_ (ffelexToken t);
 668 static ffelexHandler ffestb_R12026_ (ffelexToken t);
 669 #endif
 670 static ffelexHandler ffestb_S3P41_ (ffelexToken ft, ffebld expr,
 671                                     ffelexToken t);
 672 static ffelexHandler ffestb_V0141_ (ffelexToken t);
 673 static ffelexHandler ffestb_V0142_ (ffelexToken t);
 674 static ffelexHandler ffestb_V0143_ (ffelexToken t);
 675 static ffelexHandler ffestb_V0144_ (ffelexToken t);
 676 #if FFESTR_VXT
 677 static ffelexHandler ffestb_V0251_ (ffelexToken t);
 678 static ffelexHandler ffestb_V0252_ (ffelexToken ft, ffebld expr,
 679                                     ffelexToken t);
 680 static ffelexHandler ffestb_V0253_ (ffelexToken ft, ffebld expr,
 681                                     ffelexToken t);
 682 static ffelexHandler ffestb_V0254_ (ffelexToken ft, ffebld expr,
 683                                     ffelexToken t);
 684 static ffelexHandler ffestb_V0255_ (ffelexToken t);
 685 static ffelexHandler ffestb_V0256_ (ffelexToken t);
 686 static ffelexHandler ffestb_V0257_ (ffelexToken ft, ffebld expr,
 687                                     ffelexToken t);
 688 static ffelexHandler ffestb_V0258_ (ffelexToken t);
 689 #endif
 690 #if FFESTB_KILL_EASY_
 691 static void ffestb_subr_kill_easy_ (ffestpInquireIx max);
 692 #else
 693 static void ffestb_subr_kill_accept_ (void);
 694 static void ffestb_subr_kill_beru_ (void);
 695 static void ffestb_subr_kill_close_ (void);
 696 static void ffestb_subr_kill_delete_ (void);
 697 static void ffestb_subr_kill_find_ (void);      /* Not written yet. */
 698 static void ffestb_subr_kill_inquire_ (void);
 699 static void ffestb_subr_kill_open_ (void);
 700 static void ffestb_subr_kill_print_ (void);
 701 static void ffestb_subr_kill_read_ (void);
 702 static void ffestb_subr_kill_rewrite_ (void);
 703 static void ffestb_subr_kill_type_ (void);
 704 static void ffestb_subr_kill_vxtcode_ (void);   /* Not written yet. */
 705 static void ffestb_subr_kill_write_ (void);
 706 #endif
 707 static ffelexHandler ffestb_beru1_ (ffelexToken ft, ffebld expr,
 708                                     ffelexToken t);
 709 static ffelexHandler ffestb_beru2_ (ffelexToken t);
 710 static ffelexHandler ffestb_beru3_ (ffelexToken t);
 711 static ffelexHandler ffestb_beru4_ (ffelexToken ft, ffebld expr,
 712                                     ffelexToken t);
 713 static ffelexHandler ffestb_beru5_ (ffelexToken t);
 714 static ffelexHandler ffestb_beru6_ (ffelexToken t);
 715 static ffelexHandler ffestb_beru7_ (ffelexToken ft, ffebld expr,
 716                                     ffelexToken t);
 717 static ffelexHandler ffestb_beru8_ (ffelexToken t);
 718 static ffelexHandler ffestb_beru9_ (ffelexToken t);
 719 static ffelexHandler ffestb_beru10_ (ffelexToken t);
 720 #if FFESTR_VXT
 721 static ffelexHandler ffestb_vxtcode1_ (ffelexToken ft, ffebld expr,
 722                                        ffelexToken t);
 723 static ffelexHandler ffestb_vxtcode2_ (ffelexToken ft, ffebld expr,
 724                                        ffelexToken t);
 725 static ffelexHandler ffestb_vxtcode3_ (ffelexToken ft, ffebld expr,
 726                                        ffelexToken t);
 727 static ffelexHandler ffestb_vxtcode4_ (ffelexToken t);
 728 static ffelexHandler ffestb_vxtcode5_ (ffelexToken t);
 729 static ffelexHandler ffestb_vxtcode6_ (ffelexToken ft, ffebld expr,
 730                                        ffelexToken t);
 731 static ffelexHandler ffestb_vxtcode7_ (ffelexToken t);
 732 static ffelexHandler ffestb_vxtcode8_ (ffelexToken t);
 733 static ffelexHandler ffestb_vxtcode9_ (ffelexToken t);
 734 static ffelexHandler ffestb_vxtcode10_ (ffelexToken ft, ffebld expr,
 735                                         ffelexToken t);
 736 #endif
 737 static ffelexHandler ffestb_R9041_ (ffelexToken t);
 738 static ffelexHandler ffestb_R9042_ (ffelexToken t);
 739 static ffelexHandler ffestb_R9043_ (ffelexToken ft, ffebld expr,
 740                                     ffelexToken t);
 741 static ffelexHandler ffestb_R9044_ (ffelexToken t);
 742 static ffelexHandler ffestb_R9045_ (ffelexToken t);
 743 static ffelexHandler ffestb_R9046_ (ffelexToken ft, ffebld expr,
 744                                     ffelexToken t);
 745 static ffelexHandler ffestb_R9047_ (ffelexToken t);
 746 static ffelexHandler ffestb_R9048_ (ffelexToken t);
 747 static ffelexHandler ffestb_R9049_ (ffelexToken t);
 748 static ffelexHandler ffestb_R9071_ (ffelexToken t);
 749 static ffelexHandler ffestb_R9072_ (ffelexToken t);
 750 static ffelexHandler ffestb_R9073_ (ffelexToken ft, ffebld expr,
 751                                     ffelexToken t);
 752 static ffelexHandler ffestb_R9074_ (ffelexToken t);
 753 static ffelexHandler ffestb_R9075_ (ffelexToken t);
 754 static ffelexHandler ffestb_R9076_ (ffelexToken ft, ffebld expr,
 755                                     ffelexToken t);
 756 static ffelexHandler ffestb_R9077_ (ffelexToken t);
 757 static ffelexHandler ffestb_R9078_ (ffelexToken t);
 758 static ffelexHandler ffestb_R9079_ (ffelexToken t);
 759 static ffelexHandler ffestb_R9091_ (ffelexToken ft, ffebld expr,
 760                                     ffelexToken t);
 761 static ffelexHandler ffestb_R9092_ (ffelexToken t);
 762 static ffelexHandler ffestb_R9093_ (ffelexToken t);
 763 static ffelexHandler ffestb_R9094_ (ffelexToken ft, ffebld expr,
 764                                     ffelexToken t);
 765 static ffelexHandler ffestb_R9095_ (ffelexToken t);
 766 static ffelexHandler ffestb_R9096_ (ffelexToken t);
 767 static ffelexHandler ffestb_R9097_ (ffelexToken ft, ffebld expr,
 768                                     ffelexToken t);
 769 static ffelexHandler ffestb_R9098_ (ffelexToken t);
 770 static ffelexHandler ffestb_R9099_ (ffelexToken t);
 771 static ffelexHandler ffestb_R90910_ (ffelexToken ft, ffebld expr,
 772                                      ffelexToken t);
 773 static ffelexHandler ffestb_R90911_ (ffelexToken t);
 774 static ffelexHandler ffestb_R90912_ (ffelexToken t);
 775 static ffelexHandler ffestb_R90913_ (ffelexToken t);
 776 static ffelexHandler ffestb_R90914_ (ffelexToken ft, ffebld expr,
 777                                      ffelexToken t);
 778 static ffelexHandler ffestb_R90915_ (ffelexToken ft, ffebld expr,
 779                                      ffelexToken t);
 780 static ffelexHandler ffestb_R9101_ (ffelexToken t);
 781 static ffelexHandler ffestb_R9102_ (ffelexToken t);
 782 static ffelexHandler ffestb_R9103_ (ffelexToken ft, ffebld expr,
 783                                     ffelexToken t);
 784 static ffelexHandler ffestb_R9104_ (ffelexToken t);
 785 static ffelexHandler ffestb_R9105_ (ffelexToken t);
 786 static ffelexHandler ffestb_R9106_ (ffelexToken ft, ffebld expr,
 787                                     ffelexToken t);
 788 static ffelexHandler ffestb_R9107_ (ffelexToken t);
 789 static ffelexHandler ffestb_R9108_ (ffelexToken t);
 790 static ffelexHandler ffestb_R9109_ (ffelexToken ft, ffebld expr,
 791                                     ffelexToken t);
 792 static ffelexHandler ffestb_R91010_ (ffelexToken t);
 793 static ffelexHandler ffestb_R91011_ (ffelexToken t);
 794 static ffelexHandler ffestb_R91012_ (ffelexToken t);
 795 static ffelexHandler ffestb_R91013_ (ffelexToken ft, ffebld expr,
 796                                      ffelexToken t);
 797 static ffelexHandler ffestb_R91014_ (ffelexToken ft, ffebld expr,
 798                                      ffelexToken t);
 799 static ffelexHandler ffestb_R9111_ (ffelexToken ft, ffebld expr,
 800                                     ffelexToken t);
 801 static ffelexHandler ffestb_R9112_ (ffelexToken ft, ffebld expr,
 802                                     ffelexToken t);
 803 static ffelexHandler ffestb_R9231_ (ffelexToken t);
 804 static ffelexHandler ffestb_R9232_ (ffelexToken t);
 805 static ffelexHandler ffestb_R9233_ (ffelexToken ft, ffebld expr,
 806                                     ffelexToken t);
 807 static ffelexHandler ffestb_R9234_ (ffelexToken t);
 808 static ffelexHandler ffestb_R9235_ (ffelexToken t);
 809 static ffelexHandler ffestb_R9236_ (ffelexToken ft, ffebld expr,
 810                                     ffelexToken t);
 811 static ffelexHandler ffestb_R9237_ (ffelexToken t);
 812 static ffelexHandler ffestb_R9238_ (ffelexToken t);
 813 static ffelexHandler ffestb_R9239_ (ffelexToken t);
 814 static ffelexHandler ffestb_R92310_ (ffelexToken t);
 815 static ffelexHandler ffestb_R92311_ (ffelexToken ft, ffebld expr,
 816                                      ffelexToken t);
 817 #if FFESTR_VXT
 818 static ffelexHandler ffestb_V0181_ (ffelexToken t);
 819 static ffelexHandler ffestb_V0182_ (ffelexToken t);
 820 static ffelexHandler ffestb_V0183_ (ffelexToken ft, ffebld expr,
 821                                     ffelexToken t);
 822 static ffelexHandler ffestb_V0184_ (ffelexToken t);
 823 static ffelexHandler ffestb_V0185_ (ffelexToken t);
 824 static ffelexHandler ffestb_V0186_ (ffelexToken ft, ffebld expr,
 825                                     ffelexToken t);
 826 static ffelexHandler ffestb_V0187_ (ffelexToken t);
 827 static ffelexHandler ffestb_V0188_ (ffelexToken t);
 828 static ffelexHandler ffestb_V0189_ (ffelexToken ft, ffebld expr,
 829                                     ffelexToken t);
 830 static ffelexHandler ffestb_V01810_ (ffelexToken t);
 831 static ffelexHandler ffestb_V01811_ (ffelexToken t);
 832 static ffelexHandler ffestb_V01812_ (ffelexToken t);
 833 static ffelexHandler ffestb_V01813_ (ffelexToken ft, ffebld expr,
 834                                      ffelexToken t);
 835 static ffelexHandler ffestb_V0191_ (ffelexToken ft, ffebld expr,
 836                                     ffelexToken t);
 837 static ffelexHandler ffestb_V0192_ (ffelexToken ft, ffebld expr,
 838                                     ffelexToken t);
 839 #endif
 840 static ffelexHandler ffestb_V0201_ (ffelexToken ft, ffebld expr,
 841                                     ffelexToken t);
 842 static ffelexHandler ffestb_V0202_ (ffelexToken ft, ffebld expr,
 843                                     ffelexToken t);
 844 #if FFESTR_VXT
 845 static ffelexHandler ffestb_V0211_ (ffelexToken t);
 846 static ffelexHandler ffestb_V0212_ (ffelexToken t);
 847 static ffelexHandler ffestb_V0213_ (ffelexToken ft, ffebld expr,
 848                                     ffelexToken t);
 849 static ffelexHandler ffestb_V0214_ (ffelexToken t);
 850 static ffelexHandler ffestb_V0215_ (ffelexToken t);
 851 static ffelexHandler ffestb_V0216_ (ffelexToken ft, ffebld expr,
 852                                     ffelexToken t);
 853 static ffelexHandler ffestb_V0217_ (ffelexToken t);
 854 static ffelexHandler ffestb_V0218_ (ffelexToken t);
 855 static ffelexHandler ffestb_V0219_ (ffelexToken t);
 856 static ffelexHandler ffestb_V0261_ (ffelexToken t);
 857 static ffelexHandler ffestb_V0262_ (ffelexToken t);
 858 static ffelexHandler ffestb_V0263_ (ffelexToken ft, ffebld expr,
 859                                     ffelexToken t);
 860 static ffelexHandler ffestb_V0264_ (ffelexToken t);
 861 static ffelexHandler ffestb_V0265_ (ffelexToken t);
 862 static ffelexHandler ffestb_V0266_ (ffelexToken ft, ffebld expr,
 863                                     ffelexToken t);
 864 static ffelexHandler ffestb_V0267_ (ffelexToken t);
 865 static ffelexHandler ffestb_V0268_ (ffelexToken t);
 866 static ffelexHandler ffestb_V0269_ (ffelexToken t);
 867 #endif
 868 #if FFESTR_F90
 869 static ffelexHandler ffestb_dimlist1_ (ffelexToken t);
 870 static ffelexHandler ffestb_dimlist2_ (ffelexToken t);
 871 static ffelexHandler ffestb_dimlist3_ (ffelexToken t);
 872 static ffelexHandler ffestb_dimlist4_ (ffelexToken t);
 873 #endif
 874 static ffelexHandler ffestb_dummy1_ (ffelexToken t);
 875 static ffelexHandler ffestb_dummy2_ (ffelexToken t);
 876 static ffelexHandler ffestb_R5241_ (ffelexToken t);
 877 static ffelexHandler ffestb_R5242_ (ffelexToken t);
 878 static ffelexHandler ffestb_R5243_ (ffelexToken t);
 879 static ffelexHandler ffestb_R5244_ (ffelexToken t);
 880 static ffelexHandler ffestb_R5471_ (ffelexToken t);
 881 static ffelexHandler ffestb_R5472_ (ffelexToken t);
 882 static ffelexHandler ffestb_R5473_ (ffelexToken t);
 883 static ffelexHandler ffestb_R5474_ (ffelexToken t);
 884 static ffelexHandler ffestb_R5475_ (ffelexToken t);
 885 static ffelexHandler ffestb_R5476_ (ffelexToken t);
 886 static ffelexHandler ffestb_R5477_ (ffelexToken t);
 887 #if FFESTR_F90
 888 static ffelexHandler ffestb_R6241_ (ffelexToken ft, ffebld expr,
 889                                     ffelexToken t);
 890 static ffelexHandler ffestb_R6242_ (ffelexToken t);
 891 #endif
 892 static ffelexHandler ffestb_R12291_ (ffelexToken t);
 893 static ffelexHandler ffestb_R12292_ (ffelexToken ft, ffebld expr,
 894                                      ffelexToken t);
 895 static ffelexHandler ffestb_decl_chartype1_ (ffelexToken t);
 896 #if FFESTR_F90
 897 static ffelexHandler ffestb_decl_recursive1_ (ffelexToken t);
 898 static ffelexHandler ffestb_decl_recursive2_ (ffelexToken t);
 899 static ffelexHandler ffestb_decl_recursive3_ (ffelexToken t);
 900 static ffelexHandler ffestb_decl_recursive4_ (ffelexToken t);
 901 #endif
 902 static ffelexHandler ffestb_decl_attrs_ (ffelexToken t);
 903 static ffelexHandler ffestb_decl_attrs_1_ (ffelexToken t);
 904 static ffelexHandler ffestb_decl_attrs_2_ (ffelexToken t);
 905 #if FFESTR_F90
 906 static ffelexHandler ffestb_decl_attrs_3_ (ffelexToken t);
 907 static ffelexHandler ffestb_decl_attrs_4_ (ffelexToken t);
 908 static ffelexHandler ffestb_decl_attrs_5_ (ffelexToken t);
 909 static ffelexHandler ffestb_decl_attrs_6_ (ffelexToken t);
 910 #endif
 911 static ffelexHandler ffestb_decl_attrs_7_ (ffelexToken t);
 912 static ffelexHandler ffestb_decl_attrsp_ (ffelexToken t);
 913 static ffelexHandler ffestb_decl_ents_ (ffelexToken t);
 914 static ffelexHandler ffestb_decl_ents_1_ (ffelexToken t);
 915 static ffelexHandler ffestb_decl_ents_2_ (ffelexToken t);
 916 static ffelexHandler ffestb_decl_ents_3_ (ffelexToken t);
 917 static ffelexHandler ffestb_decl_ents_4_ (ffelexToken t);
 918 static ffelexHandler ffestb_decl_ents_5_ (ffelexToken t);
 919 static ffelexHandler ffestb_decl_ents_6_ (ffelexToken ft, ffebld expr,
 920                                           ffelexToken t);
 921 static ffelexHandler ffestb_decl_ents_7_ (ffelexToken t);
 922 static ffelexHandler ffestb_decl_ents_8_ (ffelexToken ft, ffebld expr,
 923                                           ffelexToken t);
 924 static ffelexHandler ffestb_decl_ents_9_ (ffelexToken ft, ffebld expr,
 925                                           ffelexToken t);
 926 static ffelexHandler ffestb_decl_ents_10_ (ffelexToken ft, ffebld expr,
 927                                            ffelexToken t);
 928 static ffelexHandler ffestb_decl_ents_11_ (ffelexToken t);
 929 static ffelexHandler ffestb_decl_entsp_ (ffelexToken t);
 930 static ffelexHandler ffestb_decl_entsp_1_ (ffelexToken t);
 931 static ffelexHandler ffestb_decl_entsp_2_ (ffelexToken t);
 932 static ffelexHandler ffestb_decl_entsp_3_ (ffelexToken t);
 933 static ffelexHandler ffestb_decl_entsp_4_ (ffelexToken ft, ffebld expr,
 934                                            ffelexToken t);
 935 static ffelexHandler ffestb_decl_entsp_5_ (ffelexToken t);
 936 static ffelexHandler ffestb_decl_entsp_6_ (ffelexToken t);
 937 static ffelexHandler ffestb_decl_entsp_7_ (ffelexToken t);
 938 static ffelexHandler ffestb_decl_entsp_8_ (ffelexToken t);
 939 #if FFESTR_F90
 940 static ffelexHandler ffestb_decl_func_ (ffelexToken t);
 941 #endif
 942 static ffelexHandler ffestb_decl_funcname_ (ffelexToken t);
 943 static ffelexHandler ffestb_decl_funcname_1_ (ffelexToken t);
 944 static ffelexHandler ffestb_decl_funcname_2_ (ffelexToken t);
 945 static ffelexHandler ffestb_decl_funcname_3_ (ffelexToken ft, ffebld expr,
 946                                               ffelexToken t);
 947 static ffelexHandler ffestb_decl_funcname_4_ (ffelexToken t);
 948 static ffelexHandler ffestb_decl_funcname_5_ (ffelexToken t);
 949 static ffelexHandler ffestb_decl_funcname_6_ (ffelexToken t);
 950 static ffelexHandler ffestb_decl_funcname_7_ (ffelexToken t);
 951 static ffelexHandler ffestb_decl_funcname_8_ (ffelexToken t);
 952 static ffelexHandler ffestb_decl_funcname_9_ (ffelexToken t);
 953 #if FFESTR_VXT
 954 static ffelexHandler ffestb_V0031_ (ffelexToken t);
 955 static ffelexHandler ffestb_V0032_ (ffelexToken t);
 956 static ffelexHandler ffestb_V0033_ (ffelexToken t);
 957 static ffelexHandler ffestb_V0034_ (ffelexToken t);
 958 static ffelexHandler ffestb_V0035_ (ffelexToken t);
 959 static ffelexHandler ffestb_V0036_ (ffelexToken t);
 960 static ffelexHandler ffestb_V0161_ (ffelexToken t);
 961 static ffelexHandler ffestb_V0162_ (ffelexToken t);
 962 static ffelexHandler ffestb_V0163_ (ffelexToken t);
 963 static ffelexHandler ffestb_V0164_ (ffelexToken t);
 964 static ffelexHandler ffestb_V0165_ (ffelexToken t);
 965 static ffelexHandler ffestb_V0166_ (ffelexToken t);
 966 #endif
 967 static ffelexHandler ffestb_V0271_ (ffelexToken t);
 968 static ffelexHandler ffestb_V0272_ (ffelexToken ft, ffebld expr,
 969                                     ffelexToken t);
 970 static ffelexHandler ffestb_V0273_ (ffelexToken t);
 971 static ffelexHandler ffestb_decl_R5391_ (ffelexToken t);
 972 static ffelexHandler ffestb_decl_R5392_ (ffelexToken t);
 973 #if FFESTR_F90
 974 static ffelexHandler ffestb_decl_R5393_ (ffelexToken t);
 975 #endif
 976 static ffelexHandler ffestb_decl_R5394_ (ffelexToken t);
 977 static ffelexHandler ffestb_decl_R5395_ (ffelexToken t);
 978 static ffelexHandler ffestb_decl_R539letters_ (ffelexToken t);
 979 static ffelexHandler ffestb_decl_R539letters_1_ (ffelexToken t);
 980 static ffelexHandler ffestb_decl_R539letters_2_ (ffelexToken t);
 981 static ffelexHandler ffestb_decl_R539letters_3_ (ffelexToken t);
 982 static ffelexHandler ffestb_decl_R539letters_4_ (ffelexToken t);
 983 static ffelexHandler ffestb_decl_R539letters_5_ (ffelexToken t);
 984 static ffelexHandler ffestb_decl_R539maybe_ (ffelexToken t);
 985 static ffelexHandler ffestb_decl_R539maybe_1_ (ffelexToken t);
 986 static ffelexHandler ffestb_decl_R539maybe_2_ (ffelexToken t);
 987 static ffelexHandler ffestb_decl_R539maybe_3_ (ffelexToken t);
 988 static ffelexHandler ffestb_decl_R539maybe_4_ (ffelexToken t);
 989 static ffelexHandler ffestb_decl_R539maybe_5_ (ffelexToken t);
 990
 991 /* Internal macros. */
 992
 993 #if FFESTB_KILL_EASY_
 994 #define ffestb_subr_kill_accept_() \
 995       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_acceptix)
 996 #define ffestb_subr_kill_beru_() \
 997       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_beruix)
 998 #define ffestb_subr_kill_close_() \
 999       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_closeix)
1000 #define ffestb_subr_kill_delete_() \
1001       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_deleteix)
1002 #define ffestb_subr_kill_find_() \
1003       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_findix)
1004 #define ffestb_subr_kill_inquire_() \
1005       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_inquireix)
1006 #define ffestb_subr_kill_open_() \
1007       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_openix)
1008 #define ffestb_subr_kill_print_() \
1009       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_printix)
1010 #define ffestb_subr_kill_read_() \
1011       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_readix)
1012 #define ffestb_subr_kill_rewrite_() \
1013       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_rewriteix)
1014 #define ffestb_subr_kill_type_() \
1015       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_typeix)
1016 #define ffestb_subr_kill_vxtcode_() \
1017       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_vxtcodeix)
1018 #define ffestb_subr_kill_write_() \
1019       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_writeix)
1020 #endif
1021 \f
1022 /* ffestb_subr_ambig_nope_ -- Cleans up and aborts ambig w/o confirming
1023
1024    ffestb_subr_ambig_nope_();
1025
1026    Switch from ambiguity handling in _entsp_ functions to handling entities
1027    in _ents_ (perform housekeeping tasks).  */
1028
1029 static ffelexHandler
1030 ffestb_subr_ambig_nope_ (ffelexToken t)
1031 {
1032   if (ffestb_local_.decl.recursive != NULL)
1033     ffelex_token_kill (ffestb_local_.decl.recursive);
1034   if (ffestb_local_.decl.kindt != NULL)
1035     ffelex_token_kill (ffestb_local_.decl.kindt);
1036   if (ffestb_local_.decl.lent != NULL)
1037     ffelex_token_kill (ffestb_local_.decl.lent);
1038   ffelex_token_kill (ffesta_tokens[1]);
1039   ffelex_token_kill (ffesta_tokens[2]);
1040   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
1041   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
1042   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1043 }
1044
1045 /* ffestb_subr_ambig_to_ents_ -- Switches from ambiguity to entity decl
1046
1047    ffestb_subr_ambig_to_ents_();
1048
1049    Switch from ambiguity handling in _entsp_ functions to handling entities
1050    in _ents_ (perform housekeeping tasks).  */
1051
1052 static void
1053 ffestb_subr_ambig_to_ents_ ()
1054 {
1055   ffelexToken nt;
1056
1057   nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
1058   ffelex_token_kill (ffesta_tokens[1]);
1059   ffelex_token_kill (ffesta_tokens[2]);
1060   ffesta_tokens[1] = nt;
1061   if (ffestb_local_.decl.recursive != NULL)
1062     ffelex_token_kill (ffestb_local_.decl.recursive);
1063   if (!ffestb_local_.decl.aster_after)
1064     {
1065       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
1066         {
1067           if (!ffesta_is_inhibited ())
1068             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1069                           ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
1070                            ffestb_local_.decl.len, ffestb_local_.decl.lent);
1071           if (ffestb_local_.decl.kindt != NULL)
1072             {
1073               ffelex_token_kill (ffestb_local_.decl.kindt);
1074               ffestb_local_.decl.kind = NULL;
1075               ffestb_local_.decl.kindt = NULL;
1076             }
1077           if (ffestb_local_.decl.lent != NULL)
1078             {
1079               ffelex_token_kill (ffestb_local_.decl.lent);
1080               ffestb_local_.decl.len = NULL;
1081               ffestb_local_.decl.lent = NULL;
1082             }
1083         }
1084       else
1085         {
1086           if (!ffesta_is_inhibited ())
1087             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1088                     ffestb_local_.decl.kind, ffestb_local_.decl.kindt, NULL,
1089                                NULL);
1090           if (ffestb_local_.decl.kindt != NULL)
1091             {
1092               ffelex_token_kill (ffestb_local_.decl.kindt);
1093               ffestb_local_.decl.kind = NULL;
1094               ffestb_local_.decl.kindt = NULL;
1095             }
1096         }
1097       return;
1098     }
1099   if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
1100     {
1101       if (!ffesta_is_inhibited ())
1102         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1103              ffestb_local_.decl.kind, ffestb_local_.decl.kindt, NULL, NULL);
1104       if (ffestb_local_.decl.kindt != NULL)
1105         {
1106           ffelex_token_kill (ffestb_local_.decl.kindt);
1107           ffestb_local_.decl.kind = NULL;
1108           ffestb_local_.decl.kindt = NULL;
1109         }
1110     }
1111   else if (!ffesta_is_inhibited ())
1112     ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
1113                        NULL, NULL, NULL, NULL);
1114   /* NAME/NAMES token already in ffesta_tokens[1]. */
1115 }
1116
1117 /* ffestb_subr_dimlist_ -- OPEN_PAREN expr
1118
1119    (ffestb_subr_dimlist_)  // to expression handler
1120
1121    Deal with a dimension list.
1122
1123    19-Dec-90  JCB  1.1
1124       Detect too many dimensions if backend wants it.  */
1125
1126 static ffelexHandler
1127 ffestb_subr_dimlist_ (ffelexToken ft, ffebld expr, ffelexToken t)
1128 {
1129   switch (ffelex_token_type (t))
1130     {
1131     case FFELEX_typeCLOSE_PAREN:
1132       if (expr == NULL)
1133         break;
1134 #ifdef FFECOM_dimensionsMAX
1135       if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
1136         {
1137           ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
1138           ffestb_subrargs_.dim_list.ok = TRUE;  /* Not a parse error, really. */
1139           return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1140         }
1141 #endif
1142       ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, NULL, expr,
1143                              ffelex_token_use (t));
1144       ffestb_subrargs_.dim_list.ok = TRUE;
1145       return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1146
1147     case FFELEX_typeCOMMA:
1148       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1149         break;
1150 #ifdef FFECOM_dimensionsMAX
1151       if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
1152         {
1153           ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
1154           return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1155                                               ffestb_subrargs_.dim_list.ctx,
1156                                   (ffeexprCallback) ffestb_subr_dimlist_2_);
1157         }
1158 #endif
1159       ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, NULL, expr,
1160                              ffelex_token_use (t));
1161       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1162                                           ffestb_subrargs_.dim_list.ctx,
1163                                     (ffeexprCallback) ffestb_subr_dimlist_);
1164
1165     case FFELEX_typeCOLON:
1166       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1167         break;
1168 #ifdef FFECOM_dimensionsMAX
1169       if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
1170         {
1171           ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
1172           return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1173                                               ffestb_subrargs_.dim_list.ctx,
1174                                   (ffeexprCallback) ffestb_subr_dimlist_2_);
1175         }
1176 #endif
1177       ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, expr, NULL,
1178                              ffelex_token_use (t));     /* NULL second expr for
1179                                                            now, just plug in. */
1180       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1181                                           ffestb_subrargs_.dim_list.ctx,
1182                                   (ffeexprCallback) ffestb_subr_dimlist_1_);
1183
1184     default:
1185       break;
1186     }
1187
1188   ffestb_subrargs_.dim_list.ok = FALSE;
1189   return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
1190 }
1191
1192 /* ffestb_subr_dimlist_1_ -- OPEN_PAREN expr COLON expr
1193
1194    (ffestb_subr_dimlist_1_)  // to expression handler
1195
1196    Get the upper bound.  */
1197
1198 static ffelexHandler
1199 ffestb_subr_dimlist_1_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
1200 {
1201   switch (ffelex_token_type (t))
1202     {
1203     case FFELEX_typeCLOSE_PAREN:
1204       ffestb_subrargs_.dim_list.dims->previous->upper = expr;
1205       ffestb_subrargs_.dim_list.ok = TRUE;
1206       return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1207
1208     case FFELEX_typeCOMMA:
1209       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1210         break;
1211       ffestb_subrargs_.dim_list.dims->previous->upper = expr;
1212       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1213       ffestb_subrargs_.dim_list.ctx, (ffeexprCallback) ffestb_subr_dimlist_);
1214
1215     default:
1216       break;
1217     }
1218
1219   ffestb_subrargs_.dim_list.ok = FALSE;
1220   return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
1221 }
1222
1223 /* ffestb_subr_dimlist_2_ -- OPEN_PAREN too-many-dim-exprs
1224
1225    (ffestb_subr_dimlist_2_)  // to expression handler
1226
1227    Get the upper bound.  */
1228
1229 static ffelexHandler
1230 ffestb_subr_dimlist_2_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
1231 {
1232   switch (ffelex_token_type (t))
1233     {
1234     case FFELEX_typeCLOSE_PAREN:
1235       ffestb_subrargs_.dim_list.ok = TRUE;      /* Not a parse error, really. */
1236       return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
1237
1238     case FFELEX_typeCOMMA:
1239     case FFELEX_typeCOLON:
1240       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
1241         break;
1242       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
1243                                           ffestb_subrargs_.dim_list.ctx,
1244                                   (ffeexprCallback) ffestb_subr_dimlist_2_);
1245
1246     default:
1247       break;
1248     }
1249
1250   ffestb_subrargs_.dim_list.ok = FALSE;
1251   return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
1252 }
1253
1254 /* ffestb_subr_name_list_ -- Collect a list of name args and close-paren
1255
1256    return ffestb_subr_name_list_;  // to lexer after seeing OPEN_PAREN
1257
1258    This implements R1224 in the Fortran 90 spec.  The arg list may be
1259    empty, or be a comma-separated list (an optional trailing comma currently
1260    results in a warning but no other effect) of arguments.  For functions,
1261    however, "*" is invalid (we implement dummy-arg-name, rather than R1224
1262    dummy-arg, which itself is either dummy-arg-name or "*").  */
1263
1264 static ffelexHandler
1265 ffestb_subr_name_list_ (ffelexToken t)
1266 {
1267   switch (ffelex_token_type (t))
1268     {
1269     case FFELEX_typeCLOSE_PAREN:
1270       if (ffestt_tokenlist_count (ffestb_subrargs_.name_list.args) != 0)
1271         {                       /* Trailing comma, warn. */
1272           ffebad_start (FFEBAD_TRAILING_COMMA);
1273           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
1274           ffebad_finish ();
1275         }
1276       ffestb_subrargs_.name_list.ok = TRUE;
1277       ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1278       if (ffestb_subrargs_.name_list.names)
1279         ffelex_set_names (TRUE);
1280       return (ffelexHandler) ffestb_subrargs_.name_list.handler;
1281
1282     case FFELEX_typeASTERISK:
1283       if (!ffestb_subrargs_.name_list.is_subr)
1284         break;
1285
1286     case FFELEX_typeNAME:
1287       ffestt_tokenlist_append (ffestb_subrargs_.name_list.args,
1288                                ffelex_token_use (t));
1289       return (ffelexHandler) ffestb_subr_name_list_1_;
1290
1291     default:
1292       break;
1293     }
1294
1295   ffestb_subrargs_.name_list.ok = FALSE;
1296   ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1297   if (ffestb_subrargs_.name_list.names)
1298     ffelex_set_names (TRUE);
1299   return (ffelexHandler) (*ffestb_subrargs_.name_list.handler) (t);
1300 }
1301
1302 /* ffestb_subr_name_list_1_ -- NAME or ASTERISK
1303
1304    return ffestb_subr_name_list_1_;  // to lexer
1305
1306    The next token must be COMMA or CLOSE_PAREN, either way go to original
1307    state, but only after adding the appropriate name list item.  */
1308
1309 static ffelexHandler
1310 ffestb_subr_name_list_1_ (ffelexToken t)
1311 {
1312   switch (ffelex_token_type (t))
1313     {
1314     case FFELEX_typeCOMMA:
1315       return (ffelexHandler) ffestb_subr_name_list_;
1316
1317     case FFELEX_typeCLOSE_PAREN:
1318       ffestb_subrargs_.name_list.ok = TRUE;
1319       ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1320       if (ffestb_subrargs_.name_list.names)
1321         ffelex_set_names (TRUE);
1322       return (ffelexHandler) ffestb_subrargs_.name_list.handler;
1323
1324     default:
1325       ffestb_subrargs_.name_list.ok = FALSE;
1326       ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
1327       if (ffestb_subrargs_.name_list.names)
1328         ffelex_set_names (TRUE);
1329       return (ffelexHandler) (*ffestb_subrargs_.name_list.handler) (t);
1330     }
1331 }
1332
1333 static void
1334 ffestb_subr_R1001_append_p_ (void)
1335 {
1336   ffesttFormatList f;
1337
1338   if (!ffestb_local_.format.pre.present)
1339     {
1340       ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_P_SPEC, ffestb_local_.format.t);
1341       ffelex_token_kill (ffestb_local_.format.t);
1342       return;
1343     }
1344
1345   f = ffestt_formatlist_append (ffestb_local_.format.f);
1346   f->type = FFESTP_formattypeP;
1347   f->t = ffestb_local_.format.t;
1348   f->u.R1010.val = ffestb_local_.format.pre;
1349 }
1350
1351 /* ffestb_decl_kindparam_ -- "type" OPEN_PAREN
1352
1353    return ffestb_decl_kindparam_;  // to lexer
1354
1355    Handle "[KIND=]expr)".  */
1356
1357 static ffelexHandler
1358 ffestb_decl_kindparam_ (ffelexToken t)
1359 {
1360   switch (ffelex_token_type (t))
1361     {
1362     case FFELEX_typeNAME:
1363       ffesta_tokens[1] = ffelex_token_use (t);
1364       return (ffelexHandler) ffestb_decl_kindparam_1_;
1365
1366     default:
1367       return (ffelexHandler) (*((ffelexHandler)
1368                                 ffeexpr_rhs (ffesta_output_pool,
1369                                              FFEEXPR_contextKINDTYPE,
1370                                (ffeexprCallback) ffestb_decl_kindparam_2_)))
1371         (t);
1372     }
1373 }
1374
1375 /* ffestb_decl_kindparam_1_ -- "type" OPEN_PAREN NAME
1376
1377    return ffestb_decl_kindparam_1_;  // to lexer
1378
1379    Handle "[KIND=]expr)".  */
1380
1381 static ffelexHandler
1382 ffestb_decl_kindparam_1_ (ffelexToken t)
1383 {
1384   ffelexHandler next;
1385   ffelexToken nt;
1386
1387   switch (ffelex_token_type (t))
1388     {
1389     case FFELEX_typeEQUALS:
1390       ffesta_confirmed ();
1391       if (ffestr_other (ffesta_tokens[1]) != FFESTR_otherKIND)
1392         break;
1393       ffelex_token_kill (ffesta_tokens[1]);
1394       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1395        FFEEXPR_contextKINDTYPE, (ffeexprCallback) ffestb_decl_kindparam_2_);
1396
1397     default:
1398       nt = ffesta_tokens[1];
1399       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1400       FFEEXPR_contextKINDTYPE, (ffeexprCallback) ffestb_decl_kindparam_2_)))
1401         (nt);
1402       ffelex_token_kill (nt);
1403       return (ffelexHandler) (*next) (t);
1404     }
1405
1406   if (ffestb_local_.decl.recursive != NULL)
1407     ffelex_token_kill (ffestb_local_.decl.recursive);
1408   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1409                      ffestb_local_.decl.badname,
1410                      ffesta_tokens[1]);
1411   ffelex_token_kill (ffesta_tokens[1]);
1412   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1413 }
1414
1415 /* ffestb_decl_kindparam_2_ -- "type" OPEN_PAREN ["KIND="] expr
1416
1417    (ffestb_decl_kindparam_2_)  // to expression handler
1418
1419    Handle "[KIND=]expr)".  */
1420
1421 static ffelexHandler
1422 ffestb_decl_kindparam_2_ (ffelexToken ft, ffebld expr, ffelexToken t)
1423 {
1424   switch (ffelex_token_type (t))
1425     {
1426     case FFELEX_typeCLOSE_PAREN:
1427       ffestb_local_.decl.kind = expr;
1428       ffestb_local_.decl.kindt = ffelex_token_use (ft);
1429       ffestb_local_.decl.len = NULL;
1430       ffestb_local_.decl.lent = NULL;
1431       ffelex_set_names (TRUE);
1432       return (ffelexHandler) ffestb_local_.decl.handler;
1433
1434     default:
1435       break;
1436     }
1437
1438   if (ffestb_local_.decl.recursive != NULL)
1439     ffelex_token_kill (ffestb_local_.decl.recursive);
1440   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1441                     ffestb_local_.decl.badname,
1442                     t);
1443   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1444 }
1445
1446 /* ffestb_decl_starkind_ -- "type" ASTERISK
1447
1448    return ffestb_decl_starkind_;  // to lexer
1449
1450    Handle NUMBER.  */
1451
1452 static ffelexHandler
1453 ffestb_decl_starkind_ (ffelexToken t)
1454 {
1455   switch (ffelex_token_type (t))
1456     {
1457     case FFELEX_typeNUMBER:
1458       ffestb_local_.decl.kindt = ffelex_token_use (t);
1459       ffestb_local_.decl.kind = NULL;
1460       ffestb_local_.decl.len = NULL;
1461       ffestb_local_.decl.lent = NULL;
1462       ffelex_set_names (TRUE);
1463       return (ffelexHandler) ffestb_local_.decl.handler;
1464
1465     default:
1466       break;
1467     }
1468
1469   if (ffestb_local_.decl.recursive != NULL)
1470     ffelex_token_kill (ffestb_local_.decl.recursive);
1471   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1472                     ffestb_local_.decl.badname,
1473                     t);
1474   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1475 }
1476
1477 /* ffestb_decl_starlen_ -- "CHARACTER" ASTERISK
1478
1479    return ffestb_decl_starlen_;  // to lexer
1480
1481    Handle NUMBER.  */
1482
1483 static ffelexHandler
1484 ffestb_decl_starlen_ (ffelexToken t)
1485 {
1486   switch (ffelex_token_type (t))
1487     {
1488     case FFELEX_typeNUMBER:
1489       ffestb_local_.decl.kind = NULL;
1490       ffestb_local_.decl.kindt = NULL;
1491       ffestb_local_.decl.len = NULL;
1492       ffestb_local_.decl.lent = ffelex_token_use (t);
1493       ffelex_set_names (TRUE);
1494       return (ffelexHandler) ffestb_local_.decl.handler;
1495
1496     case FFELEX_typeOPEN_PAREN:
1497       ffestb_local_.decl.kind = NULL;
1498       ffestb_local_.decl.kindt = NULL;
1499       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1500                                           FFEEXPR_contextCHARACTERSIZE,
1501                                   (ffeexprCallback) ffestb_decl_starlen_1_);
1502
1503     default:
1504       break;
1505     }
1506
1507   if (ffestb_local_.decl.recursive != NULL)
1508     ffelex_token_kill (ffestb_local_.decl.recursive);
1509   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1510                     ffestb_local_.decl.badname,
1511                     t);
1512   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1513 }
1514
1515 /* ffestb_decl_starlen_1_ -- "CHARACTER" ASTERISK OPEN_PAREN expr
1516
1517    (ffestb_decl_starlen_1_)  // to expression handler
1518
1519    Handle CLOSE_PAREN.  */
1520
1521 static ffelexHandler
1522 ffestb_decl_starlen_1_ (ffelexToken ft, ffebld expr, ffelexToken t)
1523 {
1524   switch (ffelex_token_type (t))
1525     {
1526     case FFELEX_typeCLOSE_PAREN:
1527       if (expr == NULL)
1528         break;
1529       ffestb_local_.decl.len = expr;
1530       ffestb_local_.decl.lent = ffelex_token_use (ft);
1531       ffelex_set_names (TRUE);
1532       return (ffelexHandler) ffestb_local_.decl.handler;
1533
1534     default:
1535       break;
1536     }
1537
1538   if (ffestb_local_.decl.recursive != NULL)
1539     ffelex_token_kill (ffestb_local_.decl.recursive);
1540   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1541                     ffestb_local_.decl.badname,
1542                     t);
1543   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1544 }
1545
1546 /* ffestb_decl_typeparams_ -- "CHARACTER" OPEN_PAREN
1547
1548    return ffestb_decl_typeparams_;  // to lexer
1549
1550    Handle "[KIND=]expr)".  */
1551
1552 static ffelexHandler
1553 ffestb_decl_typeparams_ (ffelexToken t)
1554 {
1555   switch (ffelex_token_type (t))
1556     {
1557     case FFELEX_typeNAME:
1558       ffesta_tokens[1] = ffelex_token_use (t);
1559       return (ffelexHandler) ffestb_decl_typeparams_1_;
1560
1561     default:
1562       if (ffestb_local_.decl.lent == NULL)
1563         return (ffelexHandler) (*((ffelexHandler)
1564                                   ffeexpr_rhs (ffesta_output_pool,
1565                                                FFEEXPR_contextCHARACTERSIZE,
1566                               (ffeexprCallback) ffestb_decl_typeparams_2_)))
1567           (t);
1568       if (ffestb_local_.decl.kindt != NULL)
1569         break;
1570       return (ffelexHandler) (*((ffelexHandler)
1571                                 ffeexpr_rhs (ffesta_output_pool,
1572                                              FFEEXPR_contextKINDTYPE,
1573                               (ffeexprCallback) ffestb_decl_typeparams_3_)))
1574         (t);
1575     }
1576
1577   if (ffestb_local_.decl.recursive != NULL)
1578     ffelex_token_kill (ffestb_local_.decl.recursive);
1579   if (ffestb_local_.decl.kindt != NULL)
1580     ffelex_token_kill (ffestb_local_.decl.kindt);
1581   if (ffestb_local_.decl.lent != NULL)
1582     ffelex_token_kill (ffestb_local_.decl.lent);
1583   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1584                     ffestb_local_.decl.badname,
1585                     t);
1586   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1587 }
1588
1589 /* ffestb_decl_typeparams_1_ -- "CHARACTER" OPEN_PAREN NAME
1590
1591    return ffestb_decl_typeparams_1_;  // to lexer
1592
1593    Handle "[KIND=]expr)".  */
1594
1595 static ffelexHandler
1596 ffestb_decl_typeparams_1_ (ffelexToken t)
1597 {
1598   ffelexHandler next;
1599   ffelexToken nt;
1600
1601   switch (ffelex_token_type (t))
1602     {
1603     case FFELEX_typeEQUALS:
1604       ffesta_confirmed ();
1605       switch (ffestr_other (ffesta_tokens[1]))
1606         {
1607         case FFESTR_otherLEN:
1608           if (ffestb_local_.decl.lent != NULL)
1609             break;
1610           ffelex_token_kill (ffesta_tokens[1]);
1611           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1612                                               FFEEXPR_contextCHARACTERSIZE,
1613                                (ffeexprCallback) ffestb_decl_typeparams_2_);
1614
1615         case FFESTR_otherKIND:
1616           if (ffestb_local_.decl.kindt != NULL)
1617             break;
1618           ffelex_token_kill (ffesta_tokens[1]);
1619           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1620                                               FFEEXPR_contextKINDTYPE,
1621                                (ffeexprCallback) ffestb_decl_typeparams_3_);
1622
1623         default:
1624           break;
1625         }
1626       break;
1627
1628     default:
1629       nt = ffesta_tokens[1];
1630       if (ffestb_local_.decl.lent == NULL)
1631         next = (ffelexHandler) (*((ffelexHandler)
1632                                   ffeexpr_rhs (ffesta_output_pool,
1633                                                FFEEXPR_contextCHARACTERSIZE,
1634                               (ffeexprCallback) ffestb_decl_typeparams_2_)))
1635           (nt);
1636       else if (ffestb_local_.decl.kindt == NULL)
1637         next = (ffelexHandler) (*((ffelexHandler)
1638                                   ffeexpr_rhs (ffesta_output_pool,
1639                                                FFEEXPR_contextKINDTYPE,
1640                               (ffeexprCallback) ffestb_decl_typeparams_3_)))
1641           (nt);
1642       else
1643         {
1644           ffesta_tokens[1] = nt;
1645           break;
1646         }
1647       ffelex_token_kill (nt);
1648       return (ffelexHandler) (*next) (t);
1649     }
1650
1651   if (ffestb_local_.decl.recursive != NULL)
1652     ffelex_token_kill (ffestb_local_.decl.recursive);
1653   if (ffestb_local_.decl.kindt != NULL)
1654     ffelex_token_kill (ffestb_local_.decl.kindt);
1655   if (ffestb_local_.decl.lent != NULL)
1656     ffelex_token_kill (ffestb_local_.decl.lent);
1657   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1658                     ffestb_local_.decl.badname,
1659                     ffesta_tokens[1]);
1660   ffelex_token_kill (ffesta_tokens[1]);
1661   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1662 }
1663
1664 /* ffestb_decl_typeparams_2_ -- "CHARACTER" OPEN_PAREN ["LEN="] expr
1665
1666    (ffestb_decl_typeparams_2_)  // to expression handler
1667
1668    Handle "[LEN=]expr)".  */
1669
1670 static ffelexHandler
1671 ffestb_decl_typeparams_2_ (ffelexToken ft, ffebld expr, ffelexToken t)
1672 {
1673   switch (ffelex_token_type (t))
1674     {
1675     case FFELEX_typeCLOSE_PAREN:
1676       ffestb_local_.decl.len = expr;
1677       ffestb_local_.decl.lent = ffelex_token_use (ft);
1678       ffelex_set_names (TRUE);
1679       return (ffelexHandler) ffestb_local_.decl.handler;
1680
1681     case FFELEX_typeCOMMA:
1682       ffestb_local_.decl.len = expr;
1683       ffestb_local_.decl.lent = ffelex_token_use (ft);
1684       return (ffelexHandler) ffestb_decl_typeparams_;
1685
1686     default:
1687       break;
1688     }
1689
1690   if (ffestb_local_.decl.recursive != NULL)
1691     ffelex_token_kill (ffestb_local_.decl.recursive);
1692   if (ffestb_local_.decl.kindt != NULL)
1693     ffelex_token_kill (ffestb_local_.decl.kindt);
1694   if (ffestb_local_.decl.lent != NULL)
1695     ffelex_token_kill (ffestb_local_.decl.lent);
1696   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1697                     ffestb_local_.decl.badname,
1698                     t);
1699   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1700 }
1701
1702 /* ffestb_decl_typeparams_3_ -- "CHARACTER" OPEN_PAREN ["KIND="] expr
1703
1704    (ffestb_decl_typeparams_3_)  // to expression handler
1705
1706    Handle "[KIND=]expr)".  */
1707
1708 static ffelexHandler
1709 ffestb_decl_typeparams_3_ (ffelexToken ft, ffebld expr, ffelexToken t)
1710 {
1711   switch (ffelex_token_type (t))
1712     {
1713     case FFELEX_typeCLOSE_PAREN:
1714       ffestb_local_.decl.kind = expr;
1715       ffestb_local_.decl.kindt = ffelex_token_use (ft);
1716       ffelex_set_names (TRUE);
1717       return (ffelexHandler) ffestb_local_.decl.handler;
1718
1719     case FFELEX_typeCOMMA:
1720       ffestb_local_.decl.kind = expr;
1721       ffestb_local_.decl.kindt = ffelex_token_use (ft);
1722       return (ffelexHandler) ffestb_decl_typeparams_;
1723
1724     default:
1725       break;
1726     }
1727
1728   if (ffestb_local_.decl.recursive != NULL)
1729     ffelex_token_kill (ffestb_local_.decl.recursive);
1730   if (ffestb_local_.decl.kindt != NULL)
1731     ffelex_token_kill (ffestb_local_.decl.kindt);
1732   if (ffestb_local_.decl.lent != NULL)
1733     ffelex_token_kill (ffestb_local_.decl.lent);
1734   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1735                     ffestb_local_.decl.badname,
1736                     t);
1737   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1738 }
1739
1740 /* ffestb_decl_typetype1_ -- "TYPE" OPEN_PAREN
1741
1742    return ffestb_decl_typetype1_;  // to lexer
1743
1744    Handle NAME.  */
1745
1746 #if FFESTR_F90
1747 static ffelexHandler
1748 ffestb_decl_typetype1_ (ffelexToken t)
1749 {
1750   switch (ffelex_token_type (t))
1751     {
1752     case FFELEX_typeNAME:
1753       ffestb_local_.decl.kindt = ffelex_token_use (t);
1754       return (ffelexHandler) ffestb_decl_typetype2_;
1755
1756     default:
1757       break;
1758     }
1759
1760   if (ffestb_local_.decl.recursive != NULL)
1761     ffelex_token_kill (ffestb_local_.decl.recursive);
1762   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1763                     ffestb_local_.decl.badname,
1764                     t);
1765   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1766 }
1767
1768 /* ffestb_decl_typetype2_ -- "TYPE" OPEN_PAREN NAME
1769
1770    return ffestb_decl_typetype2_;  // to lexer
1771
1772    Handle CLOSE_PAREN.  */
1773
1774 static ffelexHandler
1775 ffestb_decl_typetype2_ (ffelexToken t)
1776 {
1777   switch (ffelex_token_type (t))
1778     {
1779     case FFELEX_typeCLOSE_PAREN:
1780       ffestb_local_.decl.type = FFESTP_typeTYPE;
1781       ffestb_local_.decl.kind = NULL;
1782       ffestb_local_.decl.len = NULL;
1783       ffestb_local_.decl.lent = NULL;
1784       ffelex_set_names (TRUE);
1785       return (ffelexHandler) ffestb_local_.decl.handler;
1786
1787     default:
1788       break;
1789     }
1790
1791   if (ffestb_local_.decl.recursive != NULL)
1792     ffelex_token_kill (ffestb_local_.decl.recursive);
1793   ffelex_token_kill (ffestb_local_.decl.kindt);
1794   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
1795                     ffestb_local_.decl.badname,
1796                     t);
1797   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
1798 }
1799
1800 #endif
1801 /* ffestb_subr_label_list_ -- Collect a tokenlist of labels and close-paren
1802
1803    return ffestb_subr_label_list_;  // to lexer after seeing OPEN_PAREN
1804
1805    First token must be a NUMBER.  Must be followed by zero or more COMMA
1806    NUMBER pairs.  Must then be followed by a CLOSE_PAREN.  If all ok, put
1807    the NUMBER tokens in a token list and return via the handler for the
1808    token after CLOSE_PAREN.  Else return via
1809    same handler, but with the ok return value set FALSE.  */
1810
1811 static ffelexHandler
1812 ffestb_subr_label_list_ (ffelexToken t)
1813 {
1814   if (ffelex_token_type (t) == FFELEX_typeNUMBER)
1815     {
1816       ffestt_tokenlist_append (ffestb_subrargs_.label_list.labels,
1817                                ffelex_token_use (t));
1818       return (ffelexHandler) ffestb_subr_label_list_1_;
1819     }
1820
1821   ffestb_subrargs_.label_list.ok = FALSE;
1822   return (ffelexHandler) (*ffestb_subrargs_.label_list.handler) (t);
1823 }
1824
1825 /* ffestb_subr_label_list_1_ -- NUMBER
1826
1827    return ffestb_subr_label_list_1_;  // to lexer after seeing NUMBER
1828
1829    The next token must be COMMA, in which case go back to
1830    ffestb_subr_label_list_, or CLOSE_PAREN, in which case set ok to TRUE
1831    and go to the handler.  */
1832
1833 static ffelexHandler
1834 ffestb_subr_label_list_1_ (ffelexToken t)
1835 {
1836   switch (ffelex_token_type (t))
1837     {
1838     case FFELEX_typeCOMMA:
1839       return (ffelexHandler) ffestb_subr_label_list_;
1840
1841     case FFELEX_typeCLOSE_PAREN:
1842       ffestb_subrargs_.label_list.ok = TRUE;
1843       return (ffelexHandler) ffestb_subrargs_.label_list.handler;
1844
1845     default:
1846       ffestb_subrargs_.label_list.ok = FALSE;
1847       return (ffelexHandler) (*ffestb_subrargs_.label_list.handler) (t);
1848     }
1849 }
1850
1851 /* ffestb_do -- Parse the DO statement
1852
1853    return ffestb_do;  // to lexer
1854
1855    Make sure the statement has a valid form for the DO statement.  If it
1856    does, implement the statement.  */
1857
1858 ffelexHandler
1859 ffestb_do (ffelexToken t)
1860 {
1861   ffeTokenLength i;
1862   unsigned const char *p;
1863   ffelexHandler next;
1864   ffelexToken nt;
1865   ffestrSecond kw;
1866
1867   switch (ffelex_token_type (ffesta_tokens[0]))
1868     {
1869     case FFELEX_typeNAME:
1870       if (ffesta_first_kw != FFESTR_firstDO)
1871         goto bad_0;             /* :::::::::::::::::::: */
1872       switch (ffelex_token_type (t))
1873         {
1874         case FFELEX_typeNUMBER:
1875           ffesta_confirmed ();
1876           ffesta_tokens[1] = ffelex_token_use (t);
1877           return (ffelexHandler) ffestb_do1_;
1878
1879         case FFELEX_typeCOMMA:
1880           ffesta_confirmed ();
1881           ffesta_tokens[1] = NULL;
1882           return (ffelexHandler) ffestb_do2_;
1883
1884         case FFELEX_typeNAME:
1885           ffesta_confirmed ();
1886           ffesta_tokens[1] = NULL;
1887           ffesta_tokens[2] = ffelex_token_use (t);
1888           return (ffelexHandler) ffestb_do3_;
1889
1890         case FFELEX_typeEOS:
1891         case FFELEX_typeSEMICOLON:
1892           ffesta_confirmed ();
1893           ffesta_tokens[1] = NULL;
1894           return (ffelexHandler) ffestb_do1_ (t);
1895
1896         case FFELEX_typeCOLONCOLON:
1897           ffesta_confirmed ();  /* Error, but clearly intended. */
1898           goto bad_1;           /* :::::::::::::::::::: */
1899
1900         default:
1901           goto bad_1;           /* :::::::::::::::::::: */
1902         }
1903
1904     case FFELEX_typeNAMES:
1905       if (ffesta_first_kw != FFESTR_firstDO)
1906         goto bad_0;             /* :::::::::::::::::::: */
1907       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDO);
1908       switch (ffelex_token_type (t))
1909         {
1910         case FFELEX_typeCOLONCOLON:
1911           ffesta_confirmed ();  /* Error, but clearly intended. */
1912           goto bad_1;           /* :::::::::::::::::::: */
1913
1914         default:
1915           goto bad_1;           /* :::::::::::::::::::: */
1916
1917         case FFELEX_typeOPEN_PAREN:     /* Must be "DO" label "WHILE". */
1918           if (! ISDIGIT (*p))
1919             goto bad_i;         /* :::::::::::::::::::: */
1920           ffesta_tokens[1] = ffelex_token_number_from_names (ffesta_tokens[0],
1921                                                              i);
1922           p += ffelex_token_length (ffesta_tokens[1]);
1923           i += ffelex_token_length (ffesta_tokens[1]);
1924           if (((*p) != 'W') && ((*p) != 'w'))
1925             goto bad_i1;        /* :::::::::::::::::::: */
1926           nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
1927           kw = ffestr_second (nt);
1928           ffelex_token_kill (nt);
1929           if (kw != FFESTR_secondWHILE)
1930             goto bad_i1;        /* :::::::::::::::::::: */
1931           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
1932                      FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
1933
1934         case FFELEX_typeCOMMA:
1935           ffesta_confirmed ();
1936           if (*p == '\0')
1937             {
1938               ffesta_tokens[1] = NULL;
1939               return (ffelexHandler) ffestb_do2_;
1940             }
1941           if (! ISDIGIT (*p))
1942             goto bad_i;         /* :::::::::::::::::::: */
1943           ffesta_tokens[1] = ffelex_token_number_from_names (ffesta_tokens[0],
1944                                                              i);
1945           p += ffelex_token_length (ffesta_tokens[1]);
1946           i += ffelex_token_length (ffesta_tokens[1]);
1947           if (*p != '\0')
1948             goto bad_i1;        /* :::::::::::::::::::: */
1949           return (ffelexHandler) ffestb_do2_;
1950
1951         case FFELEX_typeEQUALS:
1952           if (ISDIGIT (*p))
1953             {
1954               ffesta_tokens[1]
1955                 = ffelex_token_number_from_names (ffesta_tokens[0], i);
1956               p += ffelex_token_length (ffesta_tokens[1]);
1957               i += ffelex_token_length (ffesta_tokens[1]);
1958             }
1959           else
1960             ffesta_tokens[1] = NULL;
1961           if (!ffesrc_is_name_init (*p))
1962             goto bad_i1;        /* :::::::::::::::::::: */
1963           nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
1964           next = (ffelexHandler) (*((ffelexHandler) ffeexpr_lhs
1965                                     (ffesta_output_pool, FFEEXPR_contextDO,
1966                                      (ffeexprCallback) ffestb_do6_)))
1967             (nt);
1968           ffelex_token_kill (nt);       /* Will get it back in _6_... */
1969           return (ffelexHandler) (*next) (t);
1970
1971         case FFELEX_typeEOS:
1972         case FFELEX_typeSEMICOLON:
1973           ffesta_confirmed ();
1974           if (ISDIGIT (*p))
1975             {
1976               ffesta_tokens[1]
1977                 = ffelex_token_number_from_names (ffesta_tokens[0], i);
1978               p += ffelex_token_length (ffesta_tokens[1]);
1979               i += ffelex_token_length (ffesta_tokens[1]);
1980             }
1981           else
1982             ffesta_tokens[1] = NULL;
1983           if (*p != '\0')
1984             goto bad_i1;        /* :::::::::::::::::::: */
1985           return (ffelexHandler) ffestb_do1_ (t);
1986         }
1987
1988     default:
1989       goto bad_0;               /* :::::::::::::::::::: */
1990     }
1991
1992 bad_0:                          /* :::::::::::::::::::: */
1993   if (ffesta_construct_name != NULL)
1994     {
1995       ffelex_token_kill (ffesta_construct_name);
1996       ffesta_construct_name = NULL;
1997     }
1998   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0]);
1999   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2000
2001 bad_1:                          /* :::::::::::::::::::: */
2002   if (ffesta_construct_name != NULL)
2003     {
2004       ffelex_token_kill (ffesta_construct_name);
2005       ffesta_construct_name = NULL;
2006     }
2007   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2008   return (ffelexHandler) ffelex_swallow_tokens (t,
2009                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
2010
2011 bad_i1:                 /* :::::::::::::::::::: */
2012   if (ffesta_tokens[1])
2013     ffelex_token_kill (ffesta_tokens[1]);
2014
2015 bad_i:                          /* :::::::::::::::::::: */
2016   if (ffesta_construct_name != NULL)
2017     {
2018       ffelex_token_kill (ffesta_construct_name);
2019       ffesta_construct_name = NULL;
2020     }
2021   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0], i, t);
2022   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2023 }
2024
2025 /* ffestb_dowhile -- Parse the DOWHILE statement
2026
2027    return ffestb_dowhile;  // to lexer
2028
2029    Make sure the statement has a valid form for the DOWHILE statement.  If it
2030    does, implement the statement.  */
2031
2032 ffelexHandler
2033 ffestb_dowhile (ffelexToken t)
2034 {
2035   ffeTokenLength i;
2036   const char *p;
2037   ffelexHandler next;
2038   ffelexToken nt;
2039
2040   switch (ffelex_token_type (ffesta_tokens[0]))
2041     {
2042     case FFELEX_typeNAMES:
2043       if (ffesta_first_kw != FFESTR_firstDOWHILE)
2044         goto bad_0;             /* :::::::::::::::::::: */
2045       switch (ffelex_token_type (t))
2046         {
2047         case FFELEX_typeEOS:
2048         case FFELEX_typeSEMICOLON:
2049         case FFELEX_typeCOMMA:
2050         case FFELEX_typeCOLONCOLON:
2051           ffesta_confirmed ();  /* Error, but clearly intended. */
2052           goto bad_1;           /* :::::::::::::::::::: */
2053
2054         default:
2055           goto bad_1;           /* :::::::::::::::::::: */
2056
2057         case FFELEX_typeOPEN_PAREN:
2058           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDOWHILE);
2059           if (*p != '\0')
2060             goto bad_i;         /* :::::::::::::::::::: */
2061           ffesta_tokens[1] = NULL;
2062           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2063                      FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
2064
2065         case FFELEX_typeEQUALS:/* Not really DOWHILE, but DOWHILExyz=.... */
2066           ffesta_tokens[1] = NULL;
2067           nt = ffelex_token_name_from_names (ffesta_tokens[0], FFESTR_firstlDO,
2068                                              0);
2069           next = (ffelexHandler) (*((ffelexHandler) ffeexpr_lhs
2070                                     (ffesta_output_pool, FFEEXPR_contextDO,
2071                                      (ffeexprCallback) ffestb_do6_)))
2072             (nt);
2073           ffelex_token_kill (nt);       /* Will get it back in _6_... */
2074           return (ffelexHandler) (*next) (t);
2075         }
2076
2077     default:
2078       goto bad_0;               /* :::::::::::::::::::: */
2079     }
2080
2081 bad_0:                          /* :::::::::::::::::::: */
2082   if (ffesta_construct_name != NULL)
2083     {
2084       ffelex_token_kill (ffesta_construct_name);
2085       ffesta_construct_name = NULL;
2086     }
2087   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0]);
2088   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2089
2090 bad_1:                          /* :::::::::::::::::::: */
2091   if (ffesta_construct_name != NULL)
2092     {
2093       ffelex_token_kill (ffesta_construct_name);
2094       ffesta_construct_name = NULL;
2095     }
2096   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2097   return (ffelexHandler) ffelex_swallow_tokens (t,
2098                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
2099
2100 bad_i:                          /* :::::::::::::::::::: */
2101   if (ffesta_construct_name != NULL)
2102     {
2103       ffelex_token_kill (ffesta_construct_name);
2104       ffesta_construct_name = NULL;
2105     }
2106   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0], i, t);
2107   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2108 }
2109
2110 /* ffestb_do1_ -- "DO" [label]
2111
2112    return ffestb_do1_;  // to lexer
2113
2114    Make sure the statement has a valid form for the DO statement.  If it
2115    does, implement the statement.  */
2116
2117 static ffelexHandler
2118 ffestb_do1_ (ffelexToken t)
2119 {
2120   switch (ffelex_token_type (t))
2121     {
2122     case FFELEX_typeCOMMA:
2123       ffesta_confirmed ();
2124       return (ffelexHandler) ffestb_do2_;
2125
2126     case FFELEX_typeEOS:
2127     case FFELEX_typeSEMICOLON:
2128       ffesta_confirmed ();
2129       if (!ffesta_is_inhibited ())
2130         {
2131           if (ffesta_tokens[1] != NULL)
2132             ffestc_R819B (ffesta_construct_name, ffesta_tokens[1], NULL,
2133                           NULL);
2134           else
2135             ffestc_R820B (ffesta_construct_name, NULL, NULL);
2136         }
2137       if (ffesta_tokens[1] != NULL)
2138         ffelex_token_kill (ffesta_tokens[1]);
2139       if (ffesta_construct_name != NULL)
2140         {
2141           ffelex_token_kill (ffesta_construct_name);
2142           ffesta_construct_name = NULL;
2143         }
2144       return (ffelexHandler) ffesta_zero (t);
2145
2146     case FFELEX_typeNAME:
2147       return (ffelexHandler) ffestb_do2_ (t);
2148
2149     default:
2150       break;
2151     }
2152
2153   if (ffesta_tokens[1] != NULL)
2154     ffelex_token_kill (ffesta_tokens[1]);
2155   if (ffesta_construct_name != NULL)
2156     {
2157       ffelex_token_kill (ffesta_construct_name);
2158       ffesta_construct_name = NULL;
2159     }
2160   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2161   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2162 }
2163
2164 /* ffestb_do2_ -- "DO" [label] [,]
2165
2166    return ffestb_do2_;  // to lexer
2167
2168    Make sure the statement has a valid form for the DO statement.  If it
2169    does, implement the statement.  */
2170
2171 static ffelexHandler
2172 ffestb_do2_ (ffelexToken t)
2173 {
2174   switch (ffelex_token_type (t))
2175     {
2176     case FFELEX_typeNAME:
2177       ffesta_tokens[2] = ffelex_token_use (t);
2178       return (ffelexHandler) ffestb_do3_;
2179
2180     default:
2181       break;
2182     }
2183
2184   if (ffesta_tokens[1] != NULL)
2185     ffelex_token_kill (ffesta_tokens[1]);
2186   if (ffesta_construct_name != NULL)
2187     {
2188       ffelex_token_kill (ffesta_construct_name);
2189       ffesta_construct_name = NULL;
2190     }
2191   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2192   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2193 }
2194
2195 /* ffestb_do3_ -- "DO" [label] [,] NAME
2196
2197    return ffestb_do3_;  // to lexer
2198
2199    Make sure the statement has a valid form for the DO statement.  If it
2200    does, implement the statement.  */
2201
2202 static ffelexHandler
2203 ffestb_do3_ (ffelexToken t)
2204 {
2205   ffelexHandler next;
2206
2207   switch (ffelex_token_type (t))
2208     {
2209     case FFELEX_typeEQUALS:
2210       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
2211                          FFEEXPR_contextDO, (ffeexprCallback) ffestb_do6_)))
2212         (ffesta_tokens[2]);
2213       ffelex_token_kill (ffesta_tokens[2]);     /* Will get it back in _6_... */
2214       return (ffelexHandler) (*next) (t);
2215
2216     case FFELEX_typeOPEN_PAREN:
2217       if (ffestr_second (ffesta_tokens[2]) != FFESTR_secondWHILE)
2218         {
2219           if (ffesta_tokens[1] != NULL)
2220             ffelex_token_kill (ffesta_tokens[1]);
2221           if (ffesta_construct_name != NULL)
2222             {
2223               ffelex_token_kill (ffesta_construct_name);
2224               ffesta_construct_name = NULL;
2225             }
2226           ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[2]);
2227           ffelex_token_kill (ffesta_tokens[2]);
2228           return (ffelexHandler) ffelex_swallow_tokens (t,
2229                                                (ffelexHandler) ffesta_zero);    /* Invalid token. */
2230         }
2231       ffelex_token_kill (ffesta_tokens[2]);
2232       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2233                      FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
2234
2235     default:
2236       break;
2237     }
2238
2239   ffelex_token_kill (ffesta_tokens[2]);
2240   if (ffesta_tokens[1] != NULL)
2241     ffelex_token_kill (ffesta_tokens[1]);
2242   if (ffesta_construct_name != NULL)
2243     {
2244       ffelex_token_kill (ffesta_construct_name);
2245       ffesta_construct_name = NULL;
2246     }
2247   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2248   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2249 }
2250
2251 /* ffestb_do4_ -- "DO" [label] [,] "WHILE" OPEN_PAREN expr
2252
2253    (ffestb_do4_)  // to expression handler
2254
2255    Make sure the statement has a valid form for the DO statement.  If it
2256    does, implement the statement.  */
2257
2258 static ffelexHandler
2259 ffestb_do4_ (ffelexToken ft, ffebld expr, ffelexToken t)
2260 {
2261   switch (ffelex_token_type (t))
2262     {
2263     case FFELEX_typeCLOSE_PAREN:
2264       if (expr == NULL)
2265         break;
2266       ffesta_tokens[2] = ffelex_token_use (ft);
2267       ffestb_local_.dowhile.expr = expr;
2268       return (ffelexHandler) ffestb_do5_;
2269
2270     default:
2271       break;
2272     }
2273
2274   if (ffesta_tokens[1] != NULL)
2275     ffelex_token_kill (ffesta_tokens[1]);
2276   if (ffesta_construct_name != NULL)
2277     {
2278       ffelex_token_kill (ffesta_construct_name);
2279       ffesta_construct_name = NULL;
2280     }
2281   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2282   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2283 }
2284
2285 /* ffestb_do5_ -- "DO" [label] [,] "WHILE" OPEN_PAREN expr CLOSE_PAREN
2286
2287    return ffestb_do5_;  // to lexer
2288
2289    Make sure the statement has a valid form for the DO statement.  If it
2290    does, implement the statement.  */
2291
2292 static ffelexHandler
2293 ffestb_do5_ (ffelexToken t)
2294 {
2295   switch (ffelex_token_type (t))
2296     {
2297     case FFELEX_typeEOS:
2298     case FFELEX_typeSEMICOLON:
2299       ffesta_confirmed ();
2300       if (!ffesta_is_inhibited ())
2301         {
2302           if (ffesta_tokens[1] != NULL)
2303             ffestc_R819B (ffesta_construct_name, ffesta_tokens[1],
2304                           ffestb_local_.dowhile.expr, ffesta_tokens[2]);
2305           else
2306             ffestc_R820B (ffesta_construct_name, ffestb_local_.dowhile.expr,
2307                           ffesta_tokens[2]);
2308         }
2309       ffelex_token_kill (ffesta_tokens[2]);
2310       if (ffesta_tokens[1] != NULL)
2311         ffelex_token_kill (ffesta_tokens[1]);
2312       if (ffesta_construct_name != NULL)
2313         {
2314           ffelex_token_kill (ffesta_construct_name);
2315           ffesta_construct_name = NULL;
2316         }
2317       return (ffelexHandler) ffesta_zero (t);
2318
2319     default:
2320       break;
2321     }
2322
2323   ffelex_token_kill (ffesta_tokens[2]);
2324   if (ffesta_tokens[1] != NULL)
2325     ffelex_token_kill (ffesta_tokens[1]);
2326   if (ffesta_construct_name != NULL)
2327     {
2328       ffelex_token_kill (ffesta_construct_name);
2329       ffesta_construct_name = NULL;
2330     }
2331   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2332   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2333 }
2334
2335 /* ffestb_do6_ -- "DO" [label] [,] var-expr
2336
2337    (ffestb_do6_)  // to expression handler
2338
2339    Make sure the statement has a valid form for the DO statement.  If it
2340    does, implement the statement.  */
2341
2342 static ffelexHandler
2343 ffestb_do6_ (ffelexToken ft, ffebld expr, ffelexToken t)
2344 {
2345   /* _3_ already ensured that this would be an EQUALS token.  If not, it is a
2346      bug in the FFE. */
2347
2348   assert (ffelex_token_type (t) == FFELEX_typeEQUALS);
2349
2350   ffesta_tokens[2] = ffelex_token_use (ft);
2351   ffestb_local_.do_stmt.var = expr;
2352   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2353                           FFEEXPR_contextDO, (ffeexprCallback) ffestb_do7_);
2354 }
2355
2356 /* ffestb_do7_ -- "DO" [label] [,] var-expr EQUALS expr
2357
2358    (ffestb_do7_)  // to expression handler
2359
2360    Make sure the statement has a valid form for the DO statement.  If it
2361    does, implement the statement.  */
2362
2363 static ffelexHandler
2364 ffestb_do7_ (ffelexToken ft, ffebld expr, ffelexToken t)
2365 {
2366   switch (ffelex_token_type (t))
2367     {
2368     case FFELEX_typeCOMMA:
2369       ffesta_confirmed ();
2370       if (expr == NULL)
2371         break;
2372       ffesta_tokens[3] = ffelex_token_use (ft);
2373       ffestb_local_.do_stmt.start = expr;
2374       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2375                           FFEEXPR_contextDO, (ffeexprCallback) ffestb_do8_);
2376
2377     default:
2378       break;
2379     }
2380
2381   ffelex_token_kill (ffesta_tokens[2]);
2382   if (ffesta_tokens[1] != NULL)
2383     ffelex_token_kill (ffesta_tokens[1]);
2384   if (ffesta_construct_name != NULL)
2385     {
2386       ffelex_token_kill (ffesta_construct_name);
2387       ffesta_construct_name = NULL;
2388     }
2389   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2390   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2391 }
2392
2393 /* ffestb_do8_ -- "DO" [label] [,] var-expr EQUALS expr COMMA expr
2394
2395    (ffestb_do8_)  // to expression handler
2396
2397    Make sure the statement has a valid form for the DO statement.  If it
2398    does, implement the statement.  */
2399
2400 static ffelexHandler
2401 ffestb_do8_ (ffelexToken ft, ffebld expr, ffelexToken t)
2402 {
2403   switch (ffelex_token_type (t))
2404     {
2405     case FFELEX_typeCOMMA:
2406       if (expr == NULL)
2407         break;
2408       ffesta_tokens[4] = ffelex_token_use (ft);
2409       ffestb_local_.do_stmt.end = expr;
2410       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2411                           FFEEXPR_contextDO, (ffeexprCallback) ffestb_do9_);
2412
2413     case FFELEX_typeEOS:
2414     case FFELEX_typeSEMICOLON:
2415       if (expr == NULL)
2416         break;
2417       ffesta_tokens[4] = ffelex_token_use (ft);
2418       ffestb_local_.do_stmt.end = expr;
2419       return (ffelexHandler) ffestb_do9_ (NULL, NULL, t);
2420
2421     default:
2422       break;
2423     }
2424
2425   ffelex_token_kill (ffesta_tokens[3]);
2426   ffelex_token_kill (ffesta_tokens[2]);
2427   if (ffesta_tokens[1] != NULL)
2428     ffelex_token_kill (ffesta_tokens[1]);
2429   if (ffesta_construct_name != NULL)
2430     {
2431       ffelex_token_kill (ffesta_construct_name);
2432       ffesta_construct_name = NULL;
2433     }
2434   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2435   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2436 }
2437
2438 /* ffestb_do9_ -- "DO" [label] [,] var-expr EQUALS expr COMMA expr
2439                   [COMMA expr]
2440
2441    (ffestb_do9_)  // to expression handler
2442
2443    Make sure the statement has a valid form for the DO statement.  If it
2444    does, implement the statement.  */
2445
2446 static ffelexHandler
2447 ffestb_do9_ (ffelexToken ft, ffebld expr, ffelexToken t)
2448 {
2449   switch (ffelex_token_type (t))
2450     {
2451     case FFELEX_typeEOS:
2452     case FFELEX_typeSEMICOLON:
2453       if ((expr == NULL) && (ft != NULL))
2454         break;
2455       if (!ffesta_is_inhibited ())
2456         {
2457           if (ffesta_tokens[1] != NULL)
2458             ffestc_R819A (ffesta_construct_name, ffesta_tokens[1],
2459                           ffestb_local_.do_stmt.var, ffesta_tokens[2],
2460                           ffestb_local_.do_stmt.start, ffesta_tokens[3],
2461                      ffestb_local_.do_stmt.end, ffesta_tokens[4], expr, ft);
2462           else
2463             ffestc_R820A (ffesta_construct_name, ffestb_local_.do_stmt.var,
2464                           ffesta_tokens[2], ffestb_local_.do_stmt.start,
2465                           ffesta_tokens[3], ffestb_local_.do_stmt.end,
2466                           ffesta_tokens[4], expr, ft);
2467         }
2468       ffelex_token_kill (ffesta_tokens[4]);
2469       ffelex_token_kill (ffesta_tokens[3]);
2470       ffelex_token_kill (ffesta_tokens[2]);
2471       if (ffesta_tokens[1] != NULL)
2472         ffelex_token_kill (ffesta_tokens[1]);
2473       if (ffesta_construct_name != NULL)
2474         {
2475           ffelex_token_kill (ffesta_construct_name);
2476           ffesta_construct_name = NULL;
2477         }
2478
2479       return (ffelexHandler) ffesta_zero (t);
2480
2481     default:
2482       break;
2483     }
2484
2485   ffelex_token_kill (ffesta_tokens[4]);
2486   ffelex_token_kill (ffesta_tokens[3]);
2487   ffelex_token_kill (ffesta_tokens[2]);
2488   if (ffesta_tokens[1] != NULL)
2489     ffelex_token_kill (ffesta_tokens[1]);
2490   if (ffesta_construct_name != NULL)
2491     {
2492       ffelex_token_kill (ffesta_construct_name);
2493       ffesta_construct_name = NULL;
2494     }
2495   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
2496   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2497 }
2498
2499 /* ffestb_else -- Parse the ELSE statement
2500
2501    return ffestb_else;  // to lexer
2502
2503    Make sure the statement has a valid form for the ELSE statement.  If it
2504    does, implement the statement.  */
2505
2506 ffelexHandler
2507 ffestb_else (ffelexToken t)
2508 {
2509   ffeTokenLength i;
2510   unsigned const char *p;
2511
2512   switch (ffelex_token_type (ffesta_tokens[0]))
2513     {
2514     case FFELEX_typeNAME:
2515       if (ffesta_first_kw != FFESTR_firstELSE)
2516         goto bad_0;             /* :::::::::::::::::::: */
2517       switch (ffelex_token_type (t))
2518         {
2519         case FFELEX_typeEOS:
2520         case FFELEX_typeSEMICOLON:
2521           ffesta_confirmed ();
2522           ffesta_tokens[1] = NULL;
2523           ffestb_args.elsexyz.second = FFESTR_secondNone;
2524           return (ffelexHandler) ffestb_else1_ (t);
2525
2526         case FFELEX_typeCOMMA:
2527         case FFELEX_typeCOLONCOLON:
2528           ffesta_confirmed ();  /* Error, but clearly intended. */
2529           goto bad_1;           /* :::::::::::::::::::: */
2530
2531         default:
2532           goto bad_1;           /* :::::::::::::::::::: */
2533
2534         case FFELEX_typeNAME:
2535           break;
2536         }
2537
2538       ffesta_confirmed ();
2539       ffestb_args.elsexyz.second = ffesta_second_kw;
2540       ffesta_tokens[1] = ffelex_token_use (t);
2541       return (ffelexHandler) ffestb_else1_;
2542
2543     case FFELEX_typeNAMES:
2544       if (ffesta_first_kw != FFESTR_firstELSE)
2545         goto bad_0;             /* :::::::::::::::::::: */
2546       switch (ffelex_token_type (t))
2547         {
2548         case FFELEX_typeCOMMA:
2549         case FFELEX_typeCOLONCOLON:
2550           ffesta_confirmed ();  /* Error, but clearly intended. */
2551           goto bad_1;           /* :::::::::::::::::::: */
2552
2553         default:
2554           goto bad_1;           /* :::::::::::::::::::: */
2555
2556         case FFELEX_typeEOS:
2557         case FFELEX_typeSEMICOLON:
2558           break;
2559         }
2560       ffesta_confirmed ();
2561       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlELSE)
2562         {
2563           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlELSE);
2564           if (!ffesrc_is_name_init (*p))
2565             goto bad_i;         /* :::::::::::::::::::: */
2566           ffesta_tokens[1]
2567             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
2568         }
2569       else
2570         ffesta_tokens[1] = NULL;
2571       ffestb_args.elsexyz.second = FFESTR_secondNone;
2572       return (ffelexHandler) ffestb_else1_ (t);
2573
2574     default:
2575       goto bad_0;               /* :::::::::::::::::::: */
2576     }
2577
2578 bad_0:                          /* :::::::::::::::::::: */
2579   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0]);
2580   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2581
2582 bad_1:                          /* :::::::::::::::::::: */
2583   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
2584   return (ffelexHandler) ffelex_swallow_tokens (t,
2585                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
2586
2587 bad_i:                          /* :::::::::::::::::::: */
2588   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0], i, t);
2589   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2590 }
2591
2592 /* ffestb_elsexyz -- Parse an ELSEIF/ELSEWHERE statement
2593
2594    return ffestb_elsexyz;  // to lexer
2595
2596    Expects len and second to be set in ffestb_args.elsexyz to the length
2597    of the ELSExyz keyword involved and the corresponding ffestrSecond value.  */
2598
2599 ffelexHandler
2600 ffestb_elsexyz (ffelexToken t)
2601 {
2602   ffeTokenLength i;
2603   const char *p;
2604
2605   switch (ffelex_token_type (ffesta_tokens[0]))
2606     {
2607     case FFELEX_typeNAME:
2608       switch (ffelex_token_type (t))
2609         {
2610         case FFELEX_typeEOS:
2611         case FFELEX_typeSEMICOLON:
2612           if (ffesta_first_kw == FFESTR_firstELSEIF)
2613             goto bad_0;         /* :::::::::::::::::::: */
2614           ffesta_confirmed ();
2615           ffesta_tokens[1] = NULL;
2616           return (ffelexHandler) ffestb_else1_ (t);
2617
2618         case FFELEX_typeNAME:
2619           ffesta_confirmed ();
2620           goto bad_1;           /* :::::::::::::::::::: */
2621
2622         case FFELEX_typeOPEN_PAREN:
2623           if (ffesta_first_kw != FFESTR_firstELSEIF)
2624             goto bad_0;         /* :::::::::::::::::::: */
2625           ffesta_tokens[1] = NULL;
2626           return (ffelexHandler) ffestb_else1_ (t);
2627
2628         case FFELEX_typeCOMMA:
2629         case FFELEX_typeCOLONCOLON:
2630           ffesta_confirmed ();  /* Error, but clearly intended. */
2631           goto bad_1;           /* :::::::::::::::::::: */
2632
2633         default:
2634           goto bad_1;           /* :::::::::::::::::::: */
2635         }
2636
2637     case FFELEX_typeNAMES:
2638       switch (ffelex_token_type (t))
2639         {
2640         case FFELEX_typeCOMMA:
2641         case FFELEX_typeCOLONCOLON:
2642           ffesta_confirmed ();  /* Error, but clearly intended. */
2643           goto bad_1;           /* :::::::::::::::::::: */
2644
2645         default:
2646           goto bad_1;           /* :::::::::::::::::::: */
2647
2648         case FFELEX_typeOPEN_PAREN:
2649           if (ffesta_first_kw != FFESTR_firstELSEIF)
2650             goto bad_1;         /* :::::::::::::::::::: */
2651           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlELSEIF)
2652             {
2653               i = FFESTR_firstlELSEIF;
2654               goto bad_i;       /* :::::::::::::::::::: */
2655             }
2656           ffesta_tokens[1] = NULL;
2657           return (ffelexHandler) ffestb_else1_ (t);
2658
2659         case FFELEX_typeEOS:
2660         case FFELEX_typeSEMICOLON:
2661           break;
2662         }
2663       ffesta_confirmed ();
2664       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlELSE);
2665       ffesta_tokens[1]
2666         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
2667 #if FFESTR_F90
2668       if ((ffestb_args.elsexyz.second == FFESTR_secondWHERE)
2669           && (ffelex_token_length (ffesta_tokens[1]) != FFESTR_secondlWHERE))
2670         ffestb_args.elsexyz.second = FFESTR_secondNone;
2671 #endif
2672       return (ffelexHandler) ffestb_else1_ (t);
2673
2674     default:
2675       goto bad_0;               /* :::::::::::::::::::: */
2676     }
2677
2678 bad_0:                          /* :::::::::::::::::::: */
2679   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0]);
2680   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2681
2682 bad_1:                          /* :::::::::::::::::::: */
2683   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
2684   return (ffelexHandler) ffelex_swallow_tokens (t,
2685                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
2686
2687 bad_i:                          /* :::::::::::::::::::: */
2688   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE IF", ffesta_tokens[0], i, t);
2689   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2690 }
2691
2692 /* ffestb_else1_ -- "ELSE" (NAME)
2693
2694    return ffestb_else1_;  // to lexer
2695
2696    If EOS/SEMICOLON, implement the appropriate statement (keep in mind that
2697    "ELSE WHERE" is ambiguous at the syntactic level).  If OPEN_PAREN, start
2698    expression analysis with callback at _2_.  */
2699
2700 static ffelexHandler
2701 ffestb_else1_ (ffelexToken t)
2702 {
2703   switch (ffelex_token_type (t))
2704     {
2705     case FFELEX_typeOPEN_PAREN:
2706       if (ffestb_args.elsexyz.second == FFESTR_secondIF)
2707         {
2708           if (ffesta_tokens[1] != NULL)
2709             ffelex_token_kill (ffesta_tokens[1]);
2710           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
2711                         FFEEXPR_contextIF, (ffeexprCallback) ffestb_else2_);
2712         }
2713       /* Fall through. */
2714     default:
2715       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
2716       if (ffesta_tokens[1] != NULL)
2717         ffelex_token_kill (ffesta_tokens[1]);
2718       return (ffelexHandler) ffelex_swallow_tokens (t,
2719                                                (ffelexHandler) ffesta_zero);
2720
2721     case FFELEX_typeEOS:
2722     case FFELEX_typeSEMICOLON:
2723       ffesta_confirmed ();
2724       break;
2725
2726     }
2727
2728   switch (ffestb_args.elsexyz.second)
2729     {
2730 #if FFESTR_F90
2731     case FFESTR_secondWHERE:
2732       if (!ffesta_is_inhibited ())
2733         if ((ffesta_first_kw == FFESTR_firstELSEWHERE)
2734             && (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME))
2735           ffestc_R744 ();
2736         else
2737           ffestc_elsewhere (ffesta_tokens[1]);  /* R744 or R805. */
2738       break;
2739 #endif
2740
2741     default:
2742       if (!ffesta_is_inhibited ())
2743         ffestc_R805 (ffesta_tokens[1]);
2744       break;
2745     }
2746
2747   if (ffesta_tokens[1] != NULL)
2748     ffelex_token_kill (ffesta_tokens[1]);
2749   return (ffelexHandler) ffesta_zero (t);
2750 }
2751
2752 /* ffestb_else2_ -- "ELSE" "IF" OPEN_PAREN expr
2753
2754    (ffestb_else2_)  // to expression handler
2755
2756    Make sure the next token is CLOSE_PAREN.  */
2757
2758 static ffelexHandler
2759 ffestb_else2_ (ffelexToken ft, ffebld expr, ffelexToken t)
2760 {
2761   ffestb_local_.else_stmt.expr = expr;
2762
2763   switch (ffelex_token_type (t))
2764     {
2765     case FFELEX_typeCLOSE_PAREN:
2766       if (expr == NULL)
2767         break;
2768       ffesta_tokens[1] = ffelex_token_use (ft);
2769       ffelex_set_names (TRUE);
2770       return (ffelexHandler) ffestb_else3_;
2771
2772     default:
2773       break;
2774     }
2775
2776   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2777   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2778 }
2779
2780 /* ffestb_else3_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN
2781
2782    return ffestb_else3_;  // to lexer
2783
2784    Make sure the next token is "THEN".  */
2785
2786 static ffelexHandler
2787 ffestb_else3_ (ffelexToken t)
2788 {
2789   ffeTokenLength i;
2790   unsigned const char *p;
2791
2792   ffelex_set_names (FALSE);
2793
2794   switch (ffelex_token_type (t))
2795     {
2796     case FFELEX_typeNAME:
2797       ffesta_confirmed ();
2798       if (ffestr_first (t) == FFESTR_firstTHEN)
2799         return (ffelexHandler) ffestb_else4_;
2800       break;
2801
2802     case FFELEX_typeNAMES:
2803       ffesta_confirmed ();
2804       if (ffestr_first (t) != FFESTR_firstTHEN)
2805         break;
2806       if (ffelex_token_length (t) == FFESTR_firstlTHEN)
2807         return (ffelexHandler) ffestb_else4_;
2808       p = ffelex_token_text (t) + (i = FFESTR_firstlTHEN);
2809       if (!ffesrc_is_name_init (*p))
2810         goto bad_i;             /* :::::::::::::::::::: */
2811       ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
2812       return (ffelexHandler) ffestb_else5_;
2813
2814     default:
2815       break;
2816     }
2817
2818   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2819   ffelex_token_kill (ffesta_tokens[1]);
2820   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2821
2822 bad_i:                          /* :::::::::::::::::::: */
2823   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t, i, NULL);
2824   ffelex_token_kill (ffesta_tokens[1]);
2825   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2826 }
2827
2828 /* ffestb_else4_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN "THEN"
2829
2830    return ffestb_else4_;  // to lexer
2831
2832    Handle a NAME or EOS/SEMICOLON, then go to state _5_.  */
2833
2834 static ffelexHandler
2835 ffestb_else4_ (ffelexToken t)
2836 {
2837   ffelex_set_names (FALSE);
2838
2839   switch (ffelex_token_type (t))
2840     {
2841     case FFELEX_typeEOS:
2842     case FFELEX_typeSEMICOLON:
2843       ffesta_tokens[2] = NULL;
2844       return (ffelexHandler) ffestb_else5_ (t);
2845
2846     case FFELEX_typeNAME:
2847       ffesta_tokens[2] = ffelex_token_use (t);
2848       return (ffelexHandler) ffestb_else5_;
2849
2850     default:
2851       break;
2852     }
2853
2854   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2855   ffelex_token_kill (ffesta_tokens[1]);
2856   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2857 }
2858
2859 /* ffestb_else5_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN "THEN"
2860
2861    return ffestb_else5_;  // to lexer
2862
2863    Make sure the next token is EOS or SEMICOLON; implement R804.  */
2864
2865 static ffelexHandler
2866 ffestb_else5_ (ffelexToken t)
2867 {
2868   switch (ffelex_token_type (t))
2869     {
2870     case FFELEX_typeEOS:
2871     case FFELEX_typeSEMICOLON:
2872       if (!ffesta_is_inhibited ())
2873         ffestc_R804 (ffestb_local_.else_stmt.expr, ffesta_tokens[1],
2874                      ffesta_tokens[2]);
2875       ffelex_token_kill (ffesta_tokens[1]);
2876       if (ffesta_tokens[2] != NULL)
2877         ffelex_token_kill (ffesta_tokens[2]);
2878       return (ffelexHandler) ffesta_zero (t);
2879
2880     default:
2881       break;
2882     }
2883
2884   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
2885   ffelex_token_kill (ffesta_tokens[1]);
2886   if (ffesta_tokens[2] != NULL)
2887     ffelex_token_kill (ffesta_tokens[2]);
2888   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2889 }
2890
2891 /* ffestb_end -- Parse the END statement
2892
2893    return ffestb_end;  // to lexer
2894
2895    Make sure the statement has a valid form for the END statement.  If it
2896    does, implement the statement.  */
2897
2898 ffelexHandler
2899 ffestb_end (ffelexToken t)
2900 {
2901   ffeTokenLength i;
2902
2903   switch (ffelex_token_type (ffesta_tokens[0]))
2904     {
2905     case FFELEX_typeNAME:
2906       if (ffesta_first_kw != FFESTR_firstEND)
2907         goto bad_0;             /* :::::::::::::::::::: */
2908       switch (ffelex_token_type (t))
2909         {
2910         case FFELEX_typeEOS:
2911         case FFELEX_typeSEMICOLON:
2912           ffesta_tokens[1] = NULL;
2913           ffestb_args.endxyz.second = FFESTR_secondNone;
2914           return (ffelexHandler) ffestb_end3_ (t);
2915
2916         case FFELEX_typeCOMMA:
2917         case FFELEX_typeCOLONCOLON:
2918           ffesta_confirmed ();  /* Error, but clearly intended. */
2919           goto bad_1;           /* :::::::::::::::::::: */
2920
2921         default:
2922           goto bad_1;           /* :::::::::::::::::::: */
2923
2924         case FFELEX_typeNAME:
2925           break;
2926         }
2927
2928       ffesta_confirmed ();
2929       ffestb_args.endxyz.second = ffesta_second_kw;
2930       switch (ffesta_second_kw)
2931         {
2932         case FFESTR_secondFILE:
2933           ffestb_args.beru.badname = "ENDFILE";
2934           return (ffelexHandler) ffestb_beru;
2935
2936         case FFESTR_secondBLOCK:
2937           return (ffelexHandler) ffestb_end1_;
2938
2939 #if FFESTR_F90
2940         case FFESTR_secondINTERFACE:
2941 #endif
2942 #if FFESTR_VXT
2943         case FFESTR_secondMAP:
2944         case FFESTR_secondSTRUCTURE:
2945         case FFESTR_secondUNION:
2946 #endif
2947 #if FFESTR_F90
2948         case FFESTR_secondWHERE:
2949           ffesta_tokens[1] = NULL;
2950           return (ffelexHandler) ffestb_end3_;
2951 #endif
2952
2953         case FFESTR_secondNone:
2954           goto bad_1;           /* :::::::::::::::::::: */
2955
2956         default:
2957           return (ffelexHandler) ffestb_end2_;
2958         }
2959
2960     case FFELEX_typeNAMES:
2961       if (ffesta_first_kw != FFESTR_firstEND)
2962         goto bad_0;             /* :::::::::::::::::::: */
2963       switch (ffelex_token_type (t))
2964         {
2965         case FFELEX_typeCOMMA:
2966         case FFELEX_typeCOLONCOLON:
2967           ffesta_confirmed ();  /* Error, but clearly intended. */
2968           goto bad_1;           /* :::::::::::::::::::: */
2969
2970         default:
2971           goto bad_1;           /* :::::::::::::::::::: */
2972
2973         case FFELEX_typeEOS:
2974         case FFELEX_typeSEMICOLON:
2975           break;
2976         }
2977       ffesta_confirmed ();
2978       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlEND)
2979         {
2980           i = FFESTR_firstlEND;
2981           goto bad_i;           /* :::::::::::::::::::: */
2982         }
2983       ffesta_tokens[1] = NULL;
2984       ffestb_args.endxyz.second = FFESTR_secondNone;
2985       return (ffelexHandler) ffestb_end3_ (t);
2986
2987     default:
2988       goto bad_0;               /* :::::::::::::::::::: */
2989     }
2990
2991 bad_0:                          /* :::::::::::::::::::: */
2992   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
2993   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
2994
2995 bad_1:                          /* :::::::::::::::::::: */
2996   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
2997   return (ffelexHandler) ffelex_swallow_tokens (t,
2998                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
2999
3000 bad_i:                          /* :::::::::::::::::::: */
3001   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0], i, t);
3002   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3003 }
3004
3005 /* ffestb_endxyz -- Parse an ENDxyz statement
3006
3007    return ffestb_endxyz;  // to lexer
3008
3009    Expects len and second to be set in ffestb_args.endxyz to the length
3010    of the ENDxyz keyword involved and the corresponding ffestrSecond value.  */
3011
3012 ffelexHandler
3013 ffestb_endxyz (ffelexToken t)
3014 {
3015   ffeTokenLength i;
3016   unsigned const char *p;
3017
3018   switch (ffelex_token_type (ffesta_tokens[0]))
3019     {
3020     case FFELEX_typeNAME:
3021       switch (ffelex_token_type (t))
3022         {
3023         case FFELEX_typeEOS:
3024         case FFELEX_typeSEMICOLON:
3025           ffesta_confirmed ();
3026           ffesta_tokens[1] = NULL;
3027           return (ffelexHandler) ffestb_end3_ (t);
3028
3029         case FFELEX_typeNAME:
3030           ffesta_confirmed ();
3031           switch (ffestb_args.endxyz.second)
3032             {
3033 #if FFESTR_F90
3034             case FFESTR_secondINTERFACE:
3035 #endif
3036 #if FFESTR_VXT
3037             case FFESTR_secondMAP:
3038             case FFESTR_secondSTRUCTURE:
3039             case FFESTR_secondUNION:
3040 #endif
3041 #if FFESTR_F90
3042             case FFESTR_secondWHERE:
3043               goto bad_1;       /* :::::::::::::::::::: */
3044 #endif
3045
3046             case FFESTR_secondBLOCK:
3047               if (ffesta_second_kw != FFESTR_secondDATA)
3048                 goto bad_1;     /* :::::::::::::::::::: */
3049               return (ffelexHandler) ffestb_end2_;
3050
3051             default:
3052               return (ffelexHandler) ffestb_end2_ (t);
3053             }
3054
3055         case FFELEX_typeCOMMA:
3056         case FFELEX_typeCOLONCOLON:
3057           ffesta_confirmed ();  /* Error, but clearly intended. */
3058           goto bad_1;           /* :::::::::::::::::::: */
3059
3060         default:
3061           goto bad_1;           /* :::::::::::::::::::: */
3062         }
3063
3064     case FFELEX_typeNAMES:
3065       switch (ffelex_token_type (t))
3066         {
3067         case FFELEX_typeCOMMA:
3068         case FFELEX_typeCOLONCOLON:
3069           ffesta_confirmed ();  /* Error, but clearly intended. */
3070           goto bad_1;           /* :::::::::::::::::::: */
3071
3072         default:
3073           goto bad_1;           /* :::::::::::::::::::: */
3074
3075         case FFELEX_typeEOS:
3076         case FFELEX_typeSEMICOLON:
3077           break;
3078         }
3079       ffesta_confirmed ();
3080       if (ffestb_args.endxyz.second == FFESTR_secondBLOCK)
3081         {
3082           i = FFESTR_firstlEND;
3083           goto bad_i;           /* :::::::::::::::::::: */
3084         }
3085       if (ffelex_token_length (ffesta_tokens[0]) != ffestb_args.endxyz.len)
3086         {
3087           p = ffelex_token_text (ffesta_tokens[0])
3088             + (i = ffestb_args.endxyz.len);
3089           switch (ffestb_args.endxyz.second)
3090             {
3091 #if FFESTR_F90
3092             case FFESTR_secondINTERFACE:
3093 #endif
3094 #if FFESTR_VXT
3095             case FFESTR_secondMAP:
3096             case FFESTR_secondSTRUCTURE:
3097             case FFESTR_secondUNION:
3098 #endif
3099 #if FFESTR_F90
3100             case FFESTR_secondWHERE:
3101               goto bad_i;       /* :::::::::::::::::::: */
3102 #endif
3103
3104             default:
3105               break;
3106             }
3107           if (!ffesrc_is_name_init (*p))
3108             goto bad_i;         /* :::::::::::::::::::: */
3109           ffesta_tokens[1]
3110             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
3111           return (ffelexHandler) ffestb_end3_ (t);
3112         }
3113       ffesta_tokens[1] = NULL;
3114       return (ffelexHandler) ffestb_end3_ (t);
3115
3116     default:
3117       goto bad_0;               /* :::::::::::::::::::: */
3118     }
3119
3120 bad_0:                          /* :::::::::::::::::::: */
3121   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
3122   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3123
3124 bad_1:                          /* :::::::::::::::::::: */
3125   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3126   return (ffelexHandler) ffelex_swallow_tokens (t,
3127                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
3128
3129 bad_i:                          /* :::::::::::::::::::: */
3130   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0], i, t);
3131   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3132 }
3133
3134 /* ffestb_end1_ -- "END" "BLOCK"
3135
3136    return ffestb_end1_;  // to lexer
3137
3138    Make sure the next token is "DATA".  */
3139
3140 static ffelexHandler
3141 ffestb_end1_ (ffelexToken t)
3142 {
3143   if ((ffelex_token_type (t) == FFELEX_typeNAME)
3144       && (ffesrc_strcmp_2c (ffe_case_match (), ffelex_token_text (t), "DATA",
3145                             "data", "Data")
3146           == 0))
3147     {
3148       return (ffelexHandler) ffestb_end2_;
3149     }
3150
3151   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3152   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3153 }
3154
3155 /* ffestb_end2_ -- "END" <unit-kind>
3156
3157    return ffestb_end2_;  // to lexer
3158
3159    Make sure the next token is a NAME or EOS.  */
3160
3161 static ffelexHandler
3162 ffestb_end2_ (ffelexToken t)
3163 {
3164   switch (ffelex_token_type (t))
3165     {
3166     case FFELEX_typeNAME:
3167       ffesta_tokens[1] = ffelex_token_use (t);
3168       return (ffelexHandler) ffestb_end3_;
3169
3170     case FFELEX_typeEOS:
3171     case FFELEX_typeSEMICOLON:
3172       ffesta_tokens[1] = NULL;
3173       return (ffelexHandler) ffestb_end3_ (t);
3174
3175     default:
3176       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3177       return (ffelexHandler) ffelex_swallow_tokens (t,
3178                                                (ffelexHandler) ffesta_zero);
3179     }
3180 }
3181
3182 /* ffestb_end3_ -- "END" <unit-kind> (NAME)
3183
3184    return ffestb_end3_;  // to lexer
3185
3186    Make sure the next token is an EOS, then implement the statement.  */
3187
3188 static ffelexHandler
3189 ffestb_end3_ (ffelexToken t)
3190 {
3191   switch (ffelex_token_type (t))
3192     {
3193     default:
3194       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
3195       if (ffesta_tokens[1] != NULL)
3196         ffelex_token_kill (ffesta_tokens[1]);
3197       return (ffelexHandler) ffelex_swallow_tokens (t,
3198                                                (ffelexHandler) ffesta_zero);
3199
3200     case FFELEX_typeEOS:
3201     case FFELEX_typeSEMICOLON:
3202       ffesta_confirmed ();
3203       if (ffestb_args.endxyz.second == FFESTR_secondNone)
3204         {
3205           if (!ffesta_is_inhibited ())
3206             ffestc_end ();
3207           return (ffelexHandler) ffesta_zero (t);
3208         }
3209       break;
3210     }
3211
3212   switch (ffestb_args.endxyz.second)
3213     {
3214 #if FFESTR_F90
3215     case FFESTR_secondTYPE:
3216       if (!ffesta_is_inhibited ())
3217         ffestc_R425 (ffesta_tokens[1]);
3218       break;
3219 #endif
3220
3221 #if FFESTR_F90
3222     case FFESTR_secondWHERE:
3223       if (!ffesta_is_inhibited ())
3224         ffestc_R745 ();
3225       break;
3226 #endif
3227
3228     case FFESTR_secondIF:
3229       if (!ffesta_is_inhibited ())
3230         ffestc_R806 (ffesta_tokens[1]);
3231       break;
3232
3233     case FFESTR_secondSELECT:
3234       if (!ffesta_is_inhibited ())
3235         ffestc_R811 (ffesta_tokens[1]);
3236       break;
3237
3238     case FFESTR_secondDO:
3239       if (!ffesta_is_inhibited ())
3240         ffestc_R825 (ffesta_tokens[1]);
3241       break;
3242
3243     case FFESTR_secondPROGRAM:
3244       if (!ffesta_is_inhibited ())
3245         ffestc_R1103 (ffesta_tokens[1]);
3246       break;
3247
3248 #if FFESTR_F90
3249     case FFESTR_secondMODULE:
3250       if (!ffesta_is_inhibited ())
3251         ffestc_R1106 (ffesta_tokens[1]);
3252       break;
3253 #endif
3254     case FFESTR_secondBLOCK:
3255     case FFESTR_secondBLOCKDATA:
3256       if (!ffesta_is_inhibited ())
3257         ffestc_R1112 (ffesta_tokens[1]);
3258       break;
3259
3260 #if FFESTR_F90
3261     case FFESTR_secondINTERFACE:
3262       if (!ffesta_is_inhibited ())
3263         ffestc_R1203 ();
3264       break;
3265 #endif
3266
3267     case FFESTR_secondFUNCTION:
3268       if (!ffesta_is_inhibited ())
3269         ffestc_R1221 (ffesta_tokens[1]);
3270       break;
3271
3272     case FFESTR_secondSUBROUTINE:
3273       if (!ffesta_is_inhibited ())
3274         ffestc_R1225 (ffesta_tokens[1]);
3275       break;
3276
3277 #if FFESTR_VXT
3278     case FFESTR_secondSTRUCTURE:
3279       if (!ffesta_is_inhibited ())
3280         ffestc_V004 ();
3281       break;
3282 #endif
3283
3284 #if FFESTR_VXT
3285     case FFESTR_secondUNION:
3286       if (!ffesta_is_inhibited ())
3287         ffestc_V010 ();
3288       break;
3289 #endif
3290
3291 #if FFESTR_VXT
3292     case FFESTR_secondMAP:
3293       if (!ffesta_is_inhibited ())
3294         ffestc_V013 ();
3295       break;
3296 #endif
3297
3298     default:
3299       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
3300       if (ffesta_tokens[1] != NULL)
3301         ffelex_token_kill (ffesta_tokens[1]);
3302       return (ffelexHandler) ffelex_swallow_tokens (t,
3303                                                (ffelexHandler) ffesta_zero);
3304     }
3305
3306   if (ffesta_tokens[1] != NULL)
3307     ffelex_token_kill (ffesta_tokens[1]);
3308   return (ffelexHandler) ffesta_zero (t);
3309 }
3310
3311 /* ffestb_goto -- Parse the GOTO statement
3312
3313    return ffestb_goto;  // to lexer
3314
3315    Make sure the statement has a valid form for the GOTO statement.  If it
3316    does, implement the statement.  */
3317
3318 ffelexHandler
3319 ffestb_goto (ffelexToken t)
3320 {
3321   ffeTokenLength i;
3322   unsigned const char *p;
3323   ffelexHandler next;
3324   ffelexToken nt;
3325
3326   switch (ffelex_token_type (ffesta_tokens[0]))
3327     {
3328     case FFELEX_typeNAME:
3329       switch (ffesta_first_kw)
3330         {
3331         case FFESTR_firstGO:
3332           if ((ffelex_token_type (t) != FFELEX_typeNAME)
3333               || (ffesta_second_kw != FFESTR_secondTO))
3334             goto bad_1;         /* :::::::::::::::::::: */
3335           ffesta_confirmed ();
3336           return (ffelexHandler) ffestb_goto1_;
3337
3338         case FFESTR_firstGOTO:
3339           return (ffelexHandler) ffestb_goto1_ (t);
3340
3341         default:
3342           goto bad_0;           /* :::::::::::::::::::: */
3343         }
3344
3345     case FFELEX_typeNAMES:
3346       if (ffesta_first_kw != FFESTR_firstGOTO)
3347         goto bad_0;             /* :::::::::::::::::::: */
3348       switch (ffelex_token_type (t))
3349         {
3350         case FFELEX_typeCOLONCOLON:
3351           ffesta_confirmed ();  /* Error, but clearly intended. */
3352           goto bad_1;           /* :::::::::::::::::::: */
3353
3354         default:
3355           goto bad_1;           /* :::::::::::::::::::: */
3356
3357         case FFELEX_typeOPEN_PAREN:
3358         case FFELEX_typePERCENT:        /* Since GOTO I%J is apparently valid
3359                                            in '90. */
3360         case FFELEX_typeCOMMA:
3361           break;
3362
3363         case FFELEX_typeEOS:
3364         case FFELEX_typeSEMICOLON:
3365           ffesta_confirmed ();
3366           break;
3367         }
3368       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlGOTO)
3369         {
3370           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlGOTO);
3371           if (ISDIGIT (*p))
3372             {
3373               nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
3374               p += ffelex_token_length (nt);
3375               i += ffelex_token_length (nt);
3376               if (*p != '\0')
3377                 {
3378                   ffelex_token_kill (nt);
3379                   goto bad_i;   /* :::::::::::::::::::: */
3380                 }
3381             }
3382           else if (ffesrc_is_name_init (*p))
3383             {
3384               nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
3385             }
3386           else
3387             goto bad_i;         /* :::::::::::::::::::: */
3388           next = (ffelexHandler) ffestb_goto1_ (nt);
3389           ffelex_token_kill (nt);
3390           return (ffelexHandler) (*next) (t);
3391         }
3392       return (ffelexHandler) ffestb_goto1_ (t);
3393
3394     default:
3395       goto bad_0;               /* :::::::::::::::::::: */
3396     }
3397
3398 bad_0:                          /* :::::::::::::::::::: */
3399   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", ffesta_tokens[0]);
3400   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3401
3402 bad_1:                          /* :::::::::::::::::::: */
3403   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
3404   return (ffelexHandler) ffelex_swallow_tokens (t,
3405                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
3406
3407 bad_i:                          /* :::::::::::::::::::: */
3408   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "GO TO", ffesta_tokens[0], i, t);
3409   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3410 }
3411
3412 /* ffestb_goto1_ -- "GOTO" or "GO" "TO"
3413
3414    return ffestb_goto1_;  // to lexer
3415
3416    Make sure the statement has a valid form for the GOTO statement.  If it
3417    does, implement the statement.  */
3418
3419 static ffelexHandler
3420 ffestb_goto1_ (ffelexToken t)
3421 {
3422   switch (ffelex_token_type (t))
3423     {
3424     case FFELEX_typeNUMBER:
3425       if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
3426         ffesta_confirmed ();
3427       ffesta_tokens[1] = ffelex_token_use (t);
3428       return (ffelexHandler) ffestb_goto2_;
3429
3430     case FFELEX_typeOPEN_PAREN:
3431       ffesta_tokens[1] = ffelex_token_use (t);
3432       ffestb_subrargs_.label_list.labels = ffestt_tokenlist_create ();
3433       ffestb_subrargs_.label_list.handler = (ffelexHandler) ffestb_goto3_;
3434       return (ffelexHandler) ffestb_subr_label_list_;
3435
3436     case FFELEX_typeNAME:
3437       if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
3438         ffesta_confirmed ();
3439       return (ffelexHandler) (*((ffelexHandler)
3440                                 ffeexpr_lhs (ffesta_output_pool,
3441                                              FFEEXPR_contextAGOTO,
3442                                           (ffeexprCallback) ffestb_goto4_)))
3443         (t);
3444
3445     case FFELEX_typeEOS:
3446     case FFELEX_typeSEMICOLON:
3447     case FFELEX_typeCOMMA:
3448     case FFELEX_typeCOLONCOLON:
3449       ffesta_confirmed ();      /* Error, but clearly intended. */
3450       break;
3451
3452     default:
3453       break;
3454     }
3455
3456   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
3457   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3458 }
3459
3460 /* ffestb_goto2_ -- "GO/TO" NUMBER
3461
3462    return ffestb_goto2_;  // to lexer
3463
3464    Make sure the statement has a valid form for the GOTO statement.  If it
3465    does, implement the statement.  */
3466
3467 static ffelexHandler
3468 ffestb_goto2_ (ffelexToken t)
3469 {
3470   switch (ffelex_token_type (t))
3471     {
3472     case FFELEX_typeEOS:
3473     case FFELEX_typeSEMICOLON:
3474       ffesta_confirmed ();
3475       if (!ffesta_is_inhibited ())
3476         ffestc_R836 (ffesta_tokens[1]);
3477       ffelex_token_kill (ffesta_tokens[1]);
3478       return (ffelexHandler) ffesta_zero (t);
3479
3480     default:
3481       break;
3482     }
3483
3484   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
3485   ffelex_token_kill (ffesta_tokens[1]);
3486   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3487 }
3488
3489 /* ffestb_goto3_ -- "GO/TO" OPEN_PAREN label-list CLOSE_PAREN
3490
3491    return ffestb_goto3_;  // to lexer
3492
3493    Make sure the statement has a valid form for the GOTO statement.  If it
3494    does, implement the statement.  */
3495
3496 static ffelexHandler
3497 ffestb_goto3_ (ffelexToken t)
3498 {
3499   if (!ffestb_subrargs_.label_list.ok)
3500     goto bad;                   /* :::::::::::::::::::: */
3501
3502   switch (ffelex_token_type (t))
3503     {
3504     case FFELEX_typeCOMMA:
3505       ffesta_confirmed ();
3506       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextCGOTO,
3507                                           (ffeexprCallback) ffestb_goto5_);
3508
3509     case FFELEX_typeEQUALS:
3510     case FFELEX_typePOINTS:
3511     case FFELEX_typeEOS:
3512     case FFELEX_typeSEMICOLON:
3513       break;
3514
3515     default:
3516       ffesta_confirmed ();
3517       /* Fall through. */
3518     case FFELEX_typeOPEN_PAREN: /* Could still be assignment!! */
3519       return (ffelexHandler) (*((ffelexHandler)
3520                       ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextCGOTO,
3521                                    (ffeexprCallback) ffestb_goto5_)))
3522         (t);
3523     }
3524
3525 bad:                            /* :::::::::::::::::::: */
3526   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "computed-GOTO", t);
3527   ffelex_token_kill (ffesta_tokens[1]);
3528   ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3529   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3530 }
3531
3532 /* ffestb_goto4_ -- "GO/TO" expr
3533
3534    (ffestb_goto4_)  // to expression handler
3535
3536    Make sure the statement has a valid form for the GOTO statement.  If it
3537    does, implement the statement.  */
3538
3539 static ffelexHandler
3540 ffestb_goto4_ (ffelexToken ft, ffebld expr, ffelexToken t)
3541 {
3542   switch (ffelex_token_type (t))
3543     {
3544     case FFELEX_typeCOMMA:
3545       ffesta_confirmed ();
3546       if (expr == NULL)
3547         break;
3548       ffesta_tokens[1] = ffelex_token_use (ft);
3549       ffestb_local_.go_to.expr = expr;
3550       return (ffelexHandler) ffestb_goto6_;
3551
3552     case FFELEX_typeOPEN_PAREN:
3553       if (expr == NULL)
3554         break;
3555       ffesta_tokens[1] = ffelex_token_use (ft);
3556       ffestb_local_.go_to.expr = expr;
3557       return (ffelexHandler) ffestb_goto6_ (t);
3558
3559     case FFELEX_typeEOS:
3560     case FFELEX_typeSEMICOLON:
3561       ffesta_confirmed ();
3562       if (expr == NULL)
3563         break;
3564       if (!ffesta_is_inhibited ())
3565         ffestc_R839 (expr, ft, NULL);
3566       return (ffelexHandler) ffesta_zero (t);
3567
3568     default:
3569       break;
3570     }
3571
3572   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
3573   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3574 }
3575
3576 /* ffestb_goto5_ -- "GO/TO" OPEN_PAREN label-list CLOSE_PAREN (COMMA) expr
3577
3578    (ffestb_goto5_)  // to expression handler
3579
3580    Make sure the statement has a valid form for the GOTO statement.  If it
3581    does, implement the statement.  */
3582
3583 static ffelexHandler
3584 ffestb_goto5_ (ffelexToken ft, ffebld expr, ffelexToken t)
3585 {
3586   switch (ffelex_token_type (t))
3587     {
3588     case FFELEX_typeEOS:
3589     case FFELEX_typeSEMICOLON:
3590       if (expr == NULL)
3591         break;
3592       ffesta_confirmed ();
3593       if (!ffesta_is_inhibited ())
3594         ffestc_R837 (ffestb_subrargs_.label_list.labels, expr, ft);
3595       ffelex_token_kill (ffesta_tokens[1]);
3596       ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3597       return (ffelexHandler) ffesta_zero (t);
3598
3599     default:
3600       break;
3601     }
3602
3603   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "computed-GOTO", t);
3604   ffelex_token_kill (ffesta_tokens[1]);
3605   ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3606   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3607 }
3608
3609 /* ffestb_goto6_ -- "GO/TO" expr (COMMA)
3610
3611    return ffestb_goto6_;  // to lexer
3612
3613    Make sure the statement has a valid form for the GOTO statement.  If it
3614    does, implement the statement.  */
3615
3616 static ffelexHandler
3617 ffestb_goto6_ (ffelexToken t)
3618 {
3619   switch (ffelex_token_type (t))
3620     {
3621     case FFELEX_typeOPEN_PAREN:
3622       ffesta_tokens[2] = ffelex_token_use (t);
3623       ffestb_subrargs_.label_list.labels = ffestt_tokenlist_create ();
3624       ffestb_subrargs_.label_list.handler = (ffelexHandler) ffestb_goto7_;
3625       return (ffelexHandler) ffestb_subr_label_list_;
3626
3627     default:
3628       break;
3629     }
3630
3631   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
3632   ffelex_token_kill (ffesta_tokens[1]);
3633   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3634 }
3635
3636 /* ffestb_goto7_ -- "GO/TO" expr (COMMA) OPEN_PAREN label-list CLOSE_PAREN
3637
3638    return ffestb_goto7_;  // to lexer
3639
3640    Make sure the statement has a valid form for the GOTO statement.  If it
3641    does, implement the statement.  */
3642
3643 static ffelexHandler
3644 ffestb_goto7_ (ffelexToken t)
3645 {
3646   if (!ffestb_subrargs_.label_list.ok)
3647     goto bad;                   /* :::::::::::::::::::: */
3648
3649   switch (ffelex_token_type (t))
3650     {
3651     case FFELEX_typeEOS:
3652     case FFELEX_typeSEMICOLON:
3653       ffesta_confirmed ();
3654       if (!ffesta_is_inhibited ())
3655         ffestc_R839 (ffestb_local_.go_to.expr, ffesta_tokens[1],
3656                      ffestb_subrargs_.label_list.labels);
3657       ffelex_token_kill (ffesta_tokens[1]);
3658       ffelex_token_kill (ffesta_tokens[2]);
3659       ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3660       return (ffelexHandler) ffesta_zero (t);
3661
3662     default:
3663       break;
3664     }
3665
3666 bad:                            /* :::::::::::::::::::: */
3667   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
3668   ffelex_token_kill (ffesta_tokens[1]);
3669   ffelex_token_kill (ffesta_tokens[2]);
3670   ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
3671   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3672 }
3673
3674 /* ffestb_halt -- Parse the STOP/PAUSE statement
3675
3676    return ffestb_halt;  // to lexer
3677
3678    Make sure the statement has a valid form for the STOP/PAUSE statement.  If
3679    it does, implement the statement.  */
3680
3681 ffelexHandler
3682 ffestb_halt (ffelexToken t)
3683 {
3684   ffelexHandler next;
3685
3686   switch (ffelex_token_type (ffesta_tokens[0]))
3687     {
3688     case FFELEX_typeNAME:
3689       switch (ffelex_token_type (t))
3690         {
3691         case FFELEX_typeCOMMA:
3692         case FFELEX_typeCOLONCOLON:
3693           ffesta_confirmed ();  /* Error, but clearly intended. */
3694           goto bad_1;           /* :::::::::::::::::::: */
3695
3696         default:
3697           goto bad_1;           /* :::::::::::::::::::: */
3698
3699         case FFELEX_typeEOS:
3700         case FFELEX_typeSEMICOLON:
3701         case FFELEX_typeNAME:
3702         case FFELEX_typeNUMBER:
3703         case FFELEX_typeAPOSTROPHE:
3704         case FFELEX_typeQUOTE:
3705           ffesta_confirmed ();
3706           break;
3707         }
3708
3709       return (ffelexHandler) (*((ffelexHandler)
3710                                 ffeexpr_rhs (ffesta_output_pool,
3711                                              FFEEXPR_contextSTOP,
3712                                           (ffeexprCallback) ffestb_halt1_)))
3713         (t);
3714
3715     case FFELEX_typeNAMES:
3716       switch (ffelex_token_type (t))
3717         {
3718         default:
3719           goto bad_1;           /* :::::::::::::::::::: */
3720
3721         case FFELEX_typeEOS:
3722         case FFELEX_typeSEMICOLON:
3723         case FFELEX_typeNAME:
3724         case FFELEX_typeNUMBER:
3725         case FFELEX_typeAPOSTROPHE:
3726         case FFELEX_typeQUOTE:
3727           ffesta_confirmed ();
3728           break;
3729         }
3730       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
3731                                           FFEEXPR_contextSTOP,
3732                                           (ffeexprCallback) ffestb_halt1_);
3733       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
3734                                                    ffestb_args.halt.len);
3735       if (next == NULL)
3736         return (ffelexHandler) ffelex_swallow_tokens (t,
3737                                                (ffelexHandler) ffesta_zero);
3738       return (ffelexHandler) (*next) (t);
3739
3740     default:
3741       goto bad_0;               /* :::::::::::::::::::: */
3742     }
3743
3744 bad_0:                          /* :::::::::::::::::::: */
3745   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
3746                      (ffesta_first_kw == FFESTR_firstSTOP)
3747                      ? "STOP" : "PAUSE",
3748                      ffesta_tokens[0]);
3749   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3750
3751 bad_1:                          /* :::::::::::::::::::: */
3752   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
3753                      (ffesta_first_kw == FFESTR_firstSTOP)
3754                      ? "STOP" : "PAUSE",
3755                      t);
3756   return (ffelexHandler) ffelex_swallow_tokens (t,
3757                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
3758 }
3759
3760 /* ffestb_halt1_ -- "STOP/PAUSE" expr
3761
3762    (ffestb_halt1_)  // to expression handler
3763
3764    Make sure the next token is an EOS or SEMICOLON.  */
3765
3766 static ffelexHandler
3767 ffestb_halt1_ (ffelexToken ft, ffebld expr, ffelexToken t)
3768 {
3769   switch (ffelex_token_type (t))
3770     {
3771     case FFELEX_typeEOS:
3772     case FFELEX_typeSEMICOLON:
3773       ffesta_confirmed ();
3774       if (!ffesta_is_inhibited ())
3775         {
3776           if (ffesta_first_kw == FFESTR_firstSTOP)
3777             ffestc_R842 (expr, ft);
3778           else
3779             ffestc_R843 (expr, ft);
3780         }
3781       return (ffelexHandler) ffesta_zero (t);
3782
3783     default:
3784       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
3785                          (ffesta_first_kw == FFESTR_firstSTOP)
3786                          ? "STOP" : "PAUSE",
3787                          t);
3788       break;
3789     }
3790
3791   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3792 }
3793
3794 /* ffestb_if -- Parse an IF statement
3795
3796    return ffestb_if;  // to lexer
3797
3798    Make sure the statement has a valid form for an IF statement.
3799    If it does, implement the statement.  */
3800
3801 ffelexHandler
3802 ffestb_if (ffelexToken t)
3803 {
3804   switch (ffelex_token_type (ffesta_tokens[0]))
3805     {
3806     case FFELEX_typeNAME:
3807       if (ffesta_first_kw != FFESTR_firstIF)
3808         goto bad_0;             /* :::::::::::::::::::: */
3809       break;
3810
3811     case FFELEX_typeNAMES:
3812       if (ffesta_first_kw != FFESTR_firstIF)
3813         goto bad_0;             /* :::::::::::::::::::: */
3814       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlIF)
3815         goto bad_0;             /* :::::::::::::::::::: */
3816       break;
3817
3818     default:
3819       goto bad_0;               /* :::::::::::::::::::: */
3820     }
3821
3822   switch (ffelex_token_type (t))
3823     {
3824     case FFELEX_typeOPEN_PAREN:
3825       break;
3826
3827     case FFELEX_typeEOS:
3828     case FFELEX_typeSEMICOLON:
3829     case FFELEX_typeCOMMA:
3830     case FFELEX_typeCOLONCOLON:
3831       ffesta_confirmed ();      /* Error, but clearly intended. */
3832       goto bad_1;               /* :::::::::::::::::::: */
3833
3834     default:
3835       goto bad_1;               /* :::::::::::::::::::: */
3836     }
3837
3838   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextIF,
3839                                       (ffeexprCallback) ffestb_if1_);
3840
3841 bad_0:                          /* :::::::::::::::::::: */
3842   if (ffesta_construct_name != NULL)
3843     {
3844       ffelex_token_kill (ffesta_construct_name);
3845       ffesta_construct_name = NULL;
3846     }
3847   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", ffesta_tokens[0]);
3848   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3849
3850 bad_1:                          /* :::::::::::::::::::: */
3851   if (ffesta_construct_name != NULL)
3852     {
3853       ffelex_token_kill (ffesta_construct_name);
3854       ffesta_construct_name = NULL;
3855     }
3856   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
3857   return (ffelexHandler) ffelex_swallow_tokens (t,
3858                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
3859 }
3860
3861 /* ffestb_if1_ -- "IF" OPEN_PAREN expr
3862
3863    (ffestb_if1_)  // to expression handler
3864
3865    Make sure the next token is CLOSE_PAREN.  */
3866
3867 static ffelexHandler
3868 ffestb_if1_ (ffelexToken ft, ffebld expr, ffelexToken t)
3869 {
3870   ffestb_local_.if_stmt.expr = expr;
3871
3872   switch (ffelex_token_type (t))
3873     {
3874     case FFELEX_typeCLOSE_PAREN:
3875       if (expr == NULL)
3876         break;
3877       ffesta_tokens[1] = ffelex_token_use (ft);
3878       ffelex_set_names (TRUE);
3879       return (ffelexHandler) ffestb_if2_;
3880
3881     default:
3882       break;
3883     }
3884
3885   if (ffesta_construct_name != NULL)
3886     {
3887       ffelex_token_kill (ffesta_construct_name);
3888       ffesta_construct_name = NULL;
3889     }
3890   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
3891   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3892 }
3893
3894 /* ffestb_if2_ -- "IF" OPEN_PAREN expr CLOSE_PAREN
3895
3896    return ffestb_if2_;  // to lexer
3897
3898    Make sure the next token is NAME.  */
3899
3900 static ffelexHandler
3901 ffestb_if2_ (ffelexToken t)
3902 {
3903   ffelex_set_names (FALSE);
3904
3905   switch (ffelex_token_type (t))
3906     {
3907     case FFELEX_typeNAME:
3908     case FFELEX_typeNAMES:
3909       ffesta_confirmed ();
3910       ffesta_tokens[2] = ffelex_token_use (t);
3911       return (ffelexHandler) ffestb_if3_;
3912
3913     default:
3914       break;
3915     }
3916
3917   ffelex_token_kill (ffesta_tokens[1]);
3918   if ((ffesta_construct_name == NULL)
3919       || (ffelex_token_type (t) != FFELEX_typeNUMBER))
3920     ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
3921   else
3922     ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
3923                        ffesta_construct_name, t);
3924   if (ffesta_construct_name != NULL)
3925     {
3926       ffelex_token_kill (ffesta_construct_name);
3927       ffesta_construct_name = NULL;
3928     }
3929   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3930 }
3931
3932 /* ffestb_if3_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NAME
3933
3934    return ffestb_if3_;  // to lexer
3935
3936    If the next token is EOS or SEMICOLON and the preceding NAME was "THEN",
3937    implement R803.  Else, implement R807 and send the preceding NAME followed
3938    by the current token.  */
3939
3940 static ffelexHandler
3941 ffestb_if3_ (ffelexToken t)
3942 {
3943   ffelexHandler next;
3944
3945   switch (ffelex_token_type (t))
3946     {
3947     case FFELEX_typeEOS:
3948     case FFELEX_typeSEMICOLON:
3949       if (ffestr_first (ffesta_tokens[2]) == FFESTR_firstTHEN)
3950         {
3951           if (!ffesta_is_inhibited ())
3952             ffestc_R803 (ffesta_construct_name, ffestb_local_.if_stmt.expr,
3953                          ffesta_tokens[1]);
3954           ffelex_token_kill (ffesta_tokens[1]);
3955           ffelex_token_kill (ffesta_tokens[2]);
3956           if (ffesta_construct_name != NULL)
3957             {
3958               ffelex_token_kill (ffesta_construct_name);
3959               ffesta_construct_name = NULL;
3960             }
3961           return (ffelexHandler) ffesta_zero (t);
3962         }
3963       break;
3964
3965     default:
3966       break;
3967     }
3968
3969   if (ffesta_construct_name != NULL)
3970     {
3971       if (!ffesta_is_inhibited ())
3972         ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
3973                            ffesta_construct_name, ffesta_tokens[2]);
3974       ffelex_token_kill (ffesta_construct_name);
3975       ffesta_construct_name = NULL;
3976       ffelex_token_kill (ffesta_tokens[1]);
3977       ffelex_token_kill (ffesta_tokens[2]);
3978       return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
3979     }
3980
3981   if (!ffesta_is_inhibited ())
3982     ffestc_R807 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
3983   ffelex_token_kill (ffesta_tokens[1]);
3984   {
3985     ffelexToken my_2 = ffesta_tokens[2];
3986
3987     next = (ffelexHandler) ffesta_two (my_2, t);
3988     ffelex_token_kill (my_2);
3989   }
3990   return (ffelexHandler) next;
3991 }
3992
3993 /* ffestb_where -- Parse a WHERE statement
3994
3995    return ffestb_where;  // to lexer
3996
3997    Make sure the statement has a valid form for a WHERE statement.
3998    If it does, implement the statement.  */
3999
4000 #if FFESTR_F90
4001 ffelexHandler
4002 ffestb_where (ffelexToken t)
4003 {
4004   switch (ffelex_token_type (ffesta_tokens[0]))
4005     {
4006     case FFELEX_typeNAME:
4007       if (ffesta_first_kw != FFESTR_firstWHERE)
4008         goto bad_0;             /* :::::::::::::::::::: */
4009       break;
4010
4011     case FFELEX_typeNAMES:
4012       if (ffesta_first_kw != FFESTR_firstWHERE)
4013         goto bad_0;             /* :::::::::::::::::::: */
4014       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlWHERE)
4015         goto bad_0;             /* :::::::::::::::::::: */
4016       break;
4017
4018     default:
4019       goto bad_0;               /* :::::::::::::::::::: */
4020     }
4021
4022   switch (ffelex_token_type (t))
4023     {
4024     case FFELEX_typeOPEN_PAREN:
4025       break;
4026
4027     case FFELEX_typeEOS:
4028     case FFELEX_typeSEMICOLON:
4029     case FFELEX_typeCOMMA:
4030     case FFELEX_typeCOLONCOLON:
4031       ffesta_confirmed ();      /* Error, but clearly intended. */
4032       goto bad_1;               /* :::::::::::::::::::: */
4033
4034     default:
4035       goto bad_1;               /* :::::::::::::::::::: */
4036     }
4037
4038   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextWHERE,
4039                                       (ffeexprCallback) ffestb_where1_);
4040
4041 bad_0:                          /* :::::::::::::::::::: */
4042   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", ffesta_tokens[0]);
4043   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4044
4045 bad_1:                          /* :::::::::::::::::::: */
4046   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
4047   return (ffelexHandler) ffelex_swallow_tokens (t,
4048                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
4049 }
4050
4051 #endif
4052 /* ffestb_where1_ -- "WHERE" OPEN_PAREN expr
4053
4054    (ffestb_where1_)  // to expression handler
4055
4056    Make sure the next token is CLOSE_PAREN.  */
4057
4058 #if FFESTR_F90
4059 static ffelexHandler
4060 ffestb_where1_ (ffelexToken ft, ffebld expr, ffelexToken t)
4061 {
4062   ffestb_local_.if_stmt.expr = expr;
4063
4064   switch (ffelex_token_type (t))
4065     {
4066     case FFELEX_typeCLOSE_PAREN:
4067       if (expr == NULL)
4068         break;
4069       ffesta_tokens[1] = ffelex_token_use (ft);
4070       ffelex_set_names (TRUE);
4071       return (ffelexHandler) ffestb_where2_;
4072
4073     default:
4074       break;
4075     }
4076
4077   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
4078   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4079 }
4080
4081 #endif
4082 /* ffestb_where2_ -- "WHERE" OPEN_PAREN expr CLOSE_PAREN
4083
4084    return ffestb_where2_;  // to lexer
4085
4086    Make sure the next token is NAME.  */
4087
4088 #if FFESTR_F90
4089 static ffelexHandler
4090 ffestb_where2_ (ffelexToken t)
4091 {
4092   ffelex_set_names (FALSE);
4093
4094   switch (ffelex_token_type (t))
4095     {
4096     case FFELEX_typeNAME:
4097     case FFELEX_typeNAMES:
4098       ffesta_confirmed ();
4099       ffesta_tokens[2] = ffelex_token_use (t);
4100       return (ffelexHandler) ffestb_where3_;
4101
4102     case FFELEX_typeEOS:
4103     case FFELEX_typeSEMICOLON:
4104       ffesta_confirmed ();
4105       if (!ffesta_is_inhibited ())
4106         ffestc_R742 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
4107       ffelex_token_kill (ffesta_tokens[1]);
4108       return (ffelexHandler) ffesta_zero (t);
4109
4110     default:
4111       break;
4112     }
4113
4114   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
4115   ffelex_token_kill (ffesta_tokens[1]);
4116   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4117 }
4118
4119 #endif
4120 /* ffestb_where3_ -- "WHERE" OPEN_PAREN expr CLOSE_PAREN NAME
4121
4122    return ffestb_where3_;  // to lexer
4123
4124    Implement R742.  */
4125
4126 #if FFESTR_F90
4127 static ffelexHandler
4128 ffestb_where3_ (ffelexToken t)
4129 {
4130   ffelexHandler next;
4131   ffelexToken my_2 = ffesta_tokens[2];
4132
4133   if (!ffesta_is_inhibited ())
4134     ffestc_R740 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
4135   ffelex_token_kill (ffesta_tokens[1]);
4136   next = (ffelexHandler) ffesta_two (my_2, t);
4137   ffelex_token_kill (my_2);
4138   return (ffelexHandler) next;
4139 }
4140
4141 #endif
4142 /* ffestb_let -- Parse an assignment statement
4143
4144    return ffestb_let;  // to lexer
4145
4146    Make sure the statement has a valid form for an assignment statement.  If
4147    it does, implement the statement.  */
4148
4149 ffelexHandler
4150 ffestb_let (ffelexToken t)
4151 {
4152   ffelexHandler next;
4153   bool vxtparam;                /* TRUE if it might really be a VXT PARAMETER
4154                                    stmt. */
4155   unsigned const char *p;
4156
4157   switch (ffelex_token_type (ffesta_tokens[0]))
4158     {
4159     case FFELEX_typeNAME:
4160       vxtparam = FALSE;
4161       break;
4162
4163     case FFELEX_typeNAMES:
4164       vxtparam = TRUE;
4165       break;
4166
4167     default:
4168       goto bad_0;               /* :::::::::::::::::::: */
4169     }
4170
4171   switch (ffelex_token_type (t))
4172     {
4173     case FFELEX_typeOPEN_PAREN:
4174     case FFELEX_typePERCENT:
4175     case FFELEX_typePOINTS:
4176       ffestb_local_.let.vxtparam = FALSE;
4177       break;
4178
4179     case FFELEX_typeEQUALS:
4180       if (!vxtparam || (ffesta_first_kw != FFESTR_firstPARAMETER))
4181         {
4182           ffestb_local_.let.vxtparam = FALSE;
4183           break;
4184         }
4185       p = ffelex_token_text (ffesta_tokens[0]) + FFESTR_firstlPARAMETER;
4186       ffestb_local_.let.vxtparam = ffesrc_is_name_init (*p);
4187       break;
4188
4189     default:
4190       goto bad_1;               /* :::::::::::::::::::: */
4191     }
4192
4193   next = (ffelexHandler) (*((ffelexHandler)
4194                             ffeexpr_lhs (ffesta_output_pool,
4195                                          FFEEXPR_contextLET,
4196                                          (ffeexprCallback) ffestb_let1_)))
4197     (ffesta_tokens[0]);
4198   return (ffelexHandler) (*next) (t);
4199
4200 bad_0:                          /* :::::::::::::::::::: */
4201   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", ffesta_tokens[0]);
4202   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4203
4204 bad_1:                          /* :::::::::::::::::::: */
4205   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", t);
4206   return (ffelexHandler) ffelex_swallow_tokens (t,
4207                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
4208 }
4209
4210 /* ffestb_let1_ -- expr
4211
4212    (ffestb_let1_)  // to expression handler
4213
4214    Make sure the next token is EQUALS or POINTS.  */
4215
4216 static ffelexHandler
4217 ffestb_let1_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
4218 {
4219   ffestb_local_.let.dest = expr;
4220
4221   switch (ffelex_token_type (t))
4222     {
4223 #if FFESTR_F90
4224     case FFELEX_typePOINTS:
4225 #endif
4226     case FFELEX_typeEQUALS:
4227       if (expr == NULL)
4228         break;
4229       ffesta_tokens[1] = ffelex_token_use (t);
4230       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
4231                         FFEEXPR_contextLET, (ffeexprCallback) ffestb_let2_);
4232
4233     default:
4234       break;
4235     }
4236
4237   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", t);
4238   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4239 }
4240
4241 /* ffestb_let2_ -- expr EQUALS/POINTS expr
4242
4243    (ffestb_end2_)  // to expression handler
4244
4245    Make sure the next token is EOS or SEMICOLON; implement the statement.  */
4246
4247 static ffelexHandler
4248 ffestb_let2_ (ffelexToken ft, ffebld expr, ffelexToken t)
4249 {
4250   switch (ffelex_token_type (t))
4251     {
4252     case FFELEX_typeEOS:
4253     case FFELEX_typeSEMICOLON:
4254       if (expr == NULL)
4255         break;
4256       if (ffestb_local_.let.vxtparam && !ffestc_is_let_not_V027 ())
4257         break;
4258       ffesta_confirmed ();
4259       if (!ffesta_is_inhibited ())
4260 #if FFESTR_F90
4261         if (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeEQUALS)
4262 #endif
4263           ffestc_let (ffestb_local_.let.dest, expr, ft);
4264 #if FFESTR_F90
4265         else
4266           ffestc_R738 (ffestb_local_.let.dest, expr, ft);
4267 #endif
4268       ffelex_token_kill (ffesta_tokens[1]);
4269       return (ffelexHandler) ffesta_zero (t);
4270
4271     default:
4272       break;
4273     }
4274
4275   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
4276                      (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeEQUALS)
4277                      ? "assignment" : "pointer-assignment",
4278                      t);
4279   ffelex_token_kill (ffesta_tokens[1]);
4280   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4281 }
4282
4283 /* ffestb_type -- Parse the TYPE statement
4284
4285    return ffestb_type;  // to lexer
4286
4287    Make sure the statement has a valid form for the TYPE statement.  If
4288    it does, implement the statement.  */
4289
4290 #if FFESTR_F90
4291 ffelexHandler
4292 ffestb_type (ffelexToken t)
4293 {
4294   ffeTokenLength i;
4295   const char *p;
4296
4297   switch (ffelex_token_type (ffesta_tokens[0]))
4298     {
4299     case FFELEX_typeNAME:
4300       if (ffesta_first_kw != FFESTR_firstTYPE)
4301         goto bad_0;             /* :::::::::::::::::::: */
4302       switch (ffelex_token_type (t))
4303         {
4304         case FFELEX_typeEOS:
4305         case FFELEX_typeSEMICOLON:
4306         case FFELEX_typeCOLONCOLON:
4307           ffesta_confirmed ();  /* Error, but clearly intended. */
4308           goto bad_1;           /* :::::::::::::::::::: */
4309
4310         default:
4311           goto bad_1;           /* :::::::::::::::::::: */
4312
4313         case FFELEX_typeCOMMA:
4314           ffesta_confirmed ();
4315           return (ffelexHandler) ffestb_type1_;
4316
4317         case FFELEX_typeNAME:   /* No confirm here, because ambig w/V020 VXT
4318                                    TYPE. */
4319           ffesta_tokens[1] = NULL;
4320           ffesta_tokens[2] = ffelex_token_use (t);
4321           return (ffelexHandler) ffestb_type4_;
4322         }
4323
4324     case FFELEX_typeNAMES:
4325       if (ffesta_first_kw != FFESTR_firstTYPE)
4326         goto bad_0;             /* :::::::::::::::::::: */
4327       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlTYPE);
4328       switch (ffelex_token_type (t))
4329         {
4330         default:
4331           goto bad_1;           /* :::::::::::::::::::: */
4332
4333         case FFELEX_typeCOMMA:
4334           if (*p != '\0')
4335             goto bad_i;         /* :::::::::::::::::::: */
4336           ffesta_confirmed ();
4337           ffelex_set_names (TRUE);
4338           return (ffelexHandler) ffestb_type1_;
4339
4340         case FFELEX_typeEOS:
4341         case FFELEX_typeSEMICOLON:
4342           break;
4343         }
4344       if (!ffesrc_is_name_init (*p))
4345         goto bad_i;             /* :::::::::::::::::::: */
4346       ffesta_tokens[1] = NULL;
4347       ffesta_tokens[2]
4348         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
4349       return (ffelexHandler) ffestb_type4_ (t);
4350
4351     default:
4352       goto bad_0;               /* :::::::::::::::::::: */
4353     }
4354
4355 bad_0:                          /* :::::::::::::::::::: */
4356   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", ffesta_tokens[0]);
4357   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4358
4359 bad_1:                          /* :::::::::::::::::::: */
4360   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4361   return (ffelexHandler) ffelex_swallow_tokens (t,
4362                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
4363
4364 bad_i:                          /* :::::::::::::::::::: */
4365   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "TYPE", ffesta_tokens[0], i, t);
4366   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4367 }
4368
4369 /* ffestb_type1_ -- "TYPE" COMMA
4370
4371    return ffestb_type1_;  // to lexer
4372
4373    Make sure the next token is a NAME.  */
4374
4375 static ffelexHandler
4376 ffestb_type1_ (ffelexToken t)
4377 {
4378   ffeTokenLength i;
4379   const char *p;
4380
4381   ffelex_set_names (FALSE);
4382
4383   switch (ffelex_token_type (t))
4384     {
4385     case FFELEX_typeNAME:
4386       ffesta_tokens[1] = ffelex_token_use (t);
4387       ffestb_local_.type.kw = ffestr_other (t);
4388       switch (ffestb_local_.varlist.kw)
4389         {
4390         case FFESTR_otherPUBLIC:
4391         case FFESTR_otherPRIVATE:
4392           return (ffelexHandler) ffestb_type2_;
4393
4394         default:
4395           ffelex_token_kill (ffesta_tokens[1]);
4396           break;
4397         }
4398       break;
4399
4400     case FFELEX_typeNAMES:
4401       ffesta_tokens[1] = ffelex_token_use (t);
4402       ffestb_local_.type.kw = ffestr_other (t);
4403       switch (ffestb_local_.varlist.kw)
4404         {
4405         case FFESTR_otherPUBLIC:
4406           p = ffelex_token_text (t) + (i = FFESTR_otherlPUBLIC);
4407           if (*p == '\0')
4408             return (ffelexHandler) ffestb_type2_;
4409           if (!ffesrc_is_name_init (*p))
4410             goto bad_i1;        /* :::::::::::::::::::: */
4411           ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
4412           return (ffelexHandler) ffestb_type4_;
4413
4414         case FFESTR_otherPRIVATE:
4415           p = ffelex_token_text (t) + (i = FFESTR_otherlPRIVATE);
4416           if (*p == '\0')
4417             return (ffelexHandler) ffestb_type2_;
4418           if (!ffesrc_is_name_init (*p))
4419             goto bad_i1;        /* :::::::::::::::::::: */
4420           ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
4421           return (ffelexHandler) ffestb_type4_;
4422
4423         default:
4424           ffelex_token_kill (ffesta_tokens[1]);
4425           break;
4426         }
4427       break;
4428
4429     default:
4430       break;
4431     }
4432
4433   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4434   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4435
4436 bad_i1:                 /* :::::::::::::::::::: */
4437   ffelex_token_kill (ffesta_tokens[1]);
4438   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "TYPE", t, i, NULL);
4439   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4440 }
4441
4442 /* ffestb_type2_ -- "TYPE" COMMA NAME
4443
4444    return ffestb_type2_;  // to lexer
4445
4446    Handle COLONCOLON or NAME.  */
4447
4448 static ffelexHandler
4449 ffestb_type2_ (ffelexToken t)
4450 {
4451   switch (ffelex_token_type (t))
4452     {
4453     case FFELEX_typeCOLONCOLON:
4454       return (ffelexHandler) ffestb_type3_;
4455
4456     case FFELEX_typeNAME:
4457       return (ffelexHandler) ffestb_type3_ (t);
4458
4459     default:
4460       break;
4461     }
4462
4463   if (ffesta_tokens[1] != NULL)
4464     ffelex_token_kill (ffesta_tokens[1]);
4465   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4466   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4467 }
4468
4469 /* ffestb_type3_ -- "TYPE" [COMMA NAME [COLONCOLON]]
4470
4471    return ffestb_type3_;  // to lexer
4472
4473    Make sure the next token is a NAME.  */
4474
4475 static ffelexHandler
4476 ffestb_type3_ (ffelexToken t)
4477 {
4478   switch (ffelex_token_type (t))
4479     {
4480     case FFELEX_typeNAME:
4481       ffesta_tokens[2] = ffelex_token_use (t);
4482       return (ffelexHandler) ffestb_type4_;
4483
4484     default:
4485       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4486       break;
4487     }
4488
4489   if (ffesta_tokens[1] != NULL)
4490     ffelex_token_kill (ffesta_tokens[1]);
4491   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4492 }
4493
4494 /* ffestb_type4_ -- "TYPE" [COMMA NAME [COLONCOLON]] NAME
4495
4496    return ffestb_type4_;  // to lexer
4497
4498    Make sure the next token is an EOS or SEMICOLON.  */
4499
4500 static ffelexHandler
4501 ffestb_type4_ (ffelexToken t)
4502 {
4503   switch (ffelex_token_type (t))
4504     {
4505     case FFELEX_typeEOS:
4506     case FFELEX_typeSEMICOLON:
4507       ffesta_confirmed ();
4508       if (!ffesta_is_inhibited ())
4509         ffestc_R424 (ffesta_tokens[1], ffestb_local_.type.kw,
4510                      ffesta_tokens[2]);
4511       if (ffesta_tokens[1] != NULL)
4512         ffelex_token_kill (ffesta_tokens[1]);
4513       ffelex_token_kill (ffesta_tokens[2]);
4514       return (ffelexHandler) ffesta_zero (t);
4515
4516     default:
4517       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
4518       break;
4519     }
4520
4521   if (ffesta_tokens[1] != NULL)
4522     ffelex_token_kill (ffesta_tokens[1]);
4523   ffelex_token_kill (ffesta_tokens[2]);
4524   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4525 }
4526
4527 #endif
4528 /* ffestb_varlist -- Parse EXTERNAL/INTENT/INTRINSIC/OPTIONAL/PUBLIC/PRIVATE
4529                      statement
4530
4531    return ffestb_varlist;  // to lexer
4532
4533    Make sure the statement has a valid form.  If it
4534    does, implement the statement.  */
4535
4536 ffelexHandler
4537 ffestb_varlist (ffelexToken t)
4538 {
4539   ffeTokenLength i;
4540   unsigned const char *p;
4541   ffelexToken nt;
4542   ffelexHandler next;
4543
4544   switch (ffelex_token_type (ffesta_tokens[0]))
4545     {
4546     case FFELEX_typeNAME:
4547       switch (ffelex_token_type (t))
4548         {
4549         case FFELEX_typeEOS:
4550         case FFELEX_typeSEMICOLON:
4551           ffesta_confirmed ();
4552           switch (ffesta_first_kw)
4553             {
4554 #if FFESTR_F90
4555             case FFESTR_firstPUBLIC:
4556               if (!ffesta_is_inhibited ())
4557                 ffestc_R521A ();
4558               return (ffelexHandler) ffesta_zero (t);
4559
4560             case FFESTR_firstPRIVATE:
4561               if (!ffesta_is_inhibited ())
4562                 ffestc_private ();      /* Either R523A or R521B. */
4563               return (ffelexHandler) ffesta_zero (t);
4564 #endif
4565
4566             default:
4567               goto bad_1;       /* :::::::::::::::::::: */
4568             }
4569
4570         case FFELEX_typeCOMMA:
4571           ffesta_confirmed ();  /* Error, but clearly intended. */
4572           goto bad_1;           /* :::::::::::::::::::: */
4573
4574         case FFELEX_typeCOLONCOLON:
4575           ffesta_confirmed ();
4576           switch (ffesta_first_kw)
4577             {
4578 #if FFESTR_F90
4579             case FFESTR_firstOPTIONAL:
4580               if (!ffesta_is_inhibited ())
4581                 ffestc_R520_start ();
4582               break;
4583
4584             case FFESTR_firstPUBLIC:
4585               if (!ffesta_is_inhibited ())
4586                 ffestc_R521Astart ();
4587               break;
4588
4589             case FFESTR_firstPRIVATE:
4590               if (!ffesta_is_inhibited ())
4591                 ffestc_R521Bstart ();
4592               break;
4593 #endif
4594
4595             default:
4596               ffesta_confirmed ();      /* Error, but clearly intended. */
4597               goto bad_1;       /* :::::::::::::::::::: */
4598             }
4599           return (ffelexHandler) ffestb_varlist5_;
4600
4601         default:
4602           goto bad_1;           /* :::::::::::::::::::: */
4603
4604         case FFELEX_typeOPEN_PAREN:
4605           switch (ffesta_first_kw)
4606             {
4607 #if FFESTR_F90
4608             case FFESTR_firstINTENT:
4609               return (ffelexHandler) ffestb_varlist1_;
4610 #endif
4611
4612             default:
4613               goto bad_1;       /* :::::::::::::::::::: */
4614             }
4615
4616         case FFELEX_typeNAME:
4617           ffesta_confirmed ();
4618           switch (ffesta_first_kw)
4619             {
4620             case FFESTR_firstEXTERNAL:
4621               if (!ffesta_is_inhibited ())
4622                 ffestc_R1207_start ();
4623               break;
4624
4625 #if FFESTR_F90
4626             case FFESTR_firstINTENT:
4627               goto bad_1;       /* :::::::::::::::::::: */
4628 #endif
4629
4630             case FFESTR_firstINTRINSIC:
4631               if (!ffesta_is_inhibited ())
4632                 ffestc_R1208_start ();
4633               break;
4634
4635 #if FFESTR_F90
4636             case FFESTR_firstOPTIONAL:
4637               if (!ffesta_is_inhibited ())
4638                 ffestc_R520_start ();
4639               break;
4640 #endif
4641
4642 #if FFESTR_F90
4643             case FFESTR_firstPUBLIC:
4644               if (!ffesta_is_inhibited ())
4645                 ffestc_R521Astart ();
4646               break;
4647
4648             case FFESTR_firstPRIVATE:
4649               if (!ffesta_is_inhibited ())
4650                 ffestc_R521Bstart ();
4651               break;
4652 #endif
4653
4654             default:
4655               break;
4656             }
4657           return (ffelexHandler) ffestb_varlist5_ (t);
4658         }
4659
4660     case FFELEX_typeNAMES:
4661       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.varlist.len);
4662       switch (ffelex_token_type (t))
4663         {
4664         case FFELEX_typeEOS:
4665         case FFELEX_typeSEMICOLON:
4666           ffesta_confirmed ();
4667           switch (ffesta_first_kw)
4668             {
4669 #if FFESTR_F90
4670             case FFESTR_firstINTENT:
4671               goto bad_1;       /* :::::::::::::::::::: */
4672 #endif
4673
4674             default:
4675               break;
4676             }
4677           if (*p != '\0')
4678             break;
4679           switch (ffesta_first_kw)
4680             {
4681 #if FFESTR_F90
4682             case FFESTR_firstPUBLIC:
4683               if (!ffesta_is_inhibited ())
4684                 ffestc_R521A ();
4685               return (ffelexHandler) ffesta_zero (t);
4686
4687             case FFESTR_firstPRIVATE:
4688               if (!ffesta_is_inhibited ())
4689                 ffestc_private ();      /* Either R423A or R521B. */
4690               return (ffelexHandler) ffesta_zero (t);
4691 #endif
4692
4693             default:
4694               goto bad_1;       /* :::::::::::::::::::: */
4695             }
4696
4697         case FFELEX_typeCOMMA:
4698           ffesta_confirmed ();  /* Error, but clearly intended. */
4699           switch (ffesta_first_kw)
4700             {
4701 #if FFESTR_F90
4702             case FFESTR_firstINTENT:
4703               goto bad_1;       /* :::::::::::::::::::: */
4704 #endif
4705
4706             default:
4707               break;
4708             }
4709           if (*p != '\0')
4710             break;
4711           goto bad_1;           /* :::::::::::::::::::: */
4712
4713         case FFELEX_typeCOLONCOLON:
4714           ffesta_confirmed ();
4715           switch (ffesta_first_kw)
4716             {
4717 #if FFESTR_F90
4718             case FFESTR_firstOPTIONAL:
4719               if (!ffesta_is_inhibited ())
4720                 ffestc_R520_start ();
4721               break;
4722 #endif
4723
4724 #if FFESTR_F90
4725             case FFESTR_firstPUBLIC:
4726               if (!ffesta_is_inhibited ())
4727                 ffestc_R521Astart ();
4728               break;
4729
4730             case FFESTR_firstPRIVATE:
4731               if (!ffesta_is_inhibited ())
4732                 ffestc_R521Bstart ();
4733               break;
4734 #endif
4735
4736             default:
4737               goto bad_1;       /* :::::::::::::::::::: */
4738             }
4739           return (ffelexHandler) ffestb_varlist5_;
4740
4741         case FFELEX_typeOPEN_PAREN:
4742           switch (ffesta_first_kw)
4743             {
4744 #if FFESTR_F90
4745             case FFESTR_firstINTENT:
4746               if (*p != '\0')
4747                 goto bad_1;     /* :::::::::::::::::::: */
4748               return (ffelexHandler) ffestb_varlist1_;
4749 #endif
4750
4751             default:
4752               goto bad_1;       /* :::::::::::::::::::: */
4753             }
4754
4755         case FFELEX_typeNAME:
4756           ffesta_confirmed ();
4757           switch (ffesta_first_kw)
4758             {
4759             case FFESTR_firstEXTERNAL:
4760               if (!ffesta_is_inhibited ())
4761                 ffestc_R1207_start ();
4762               break;
4763
4764 #if FFESTR_F90
4765             case FFESTR_firstINTENT:
4766               goto bad_1;       /* :::::::::::::::::::: */
4767 #endif
4768
4769             case FFESTR_firstINTRINSIC:
4770               if (!ffesta_is_inhibited ())
4771                 ffestc_R1208_start ();
4772               break;
4773
4774 #if FFESTR_F90
4775             case FFESTR_firstOPTIONAL:
4776               if (!ffesta_is_inhibited ())
4777                 ffestc_R520_start ();
4778               break;
4779 #endif
4780
4781 #if FFESTR_F90
4782             case FFESTR_firstPUBLIC:
4783               if (!ffesta_is_inhibited ())
4784                 ffestc_R521Astart ();
4785               break;
4786
4787             case FFESTR_firstPRIVATE:
4788               if (!ffesta_is_inhibited ())
4789                 ffestc_R521Bstart ();
4790               break;
4791 #endif
4792
4793             default:
4794               break;
4795             }
4796           return (ffelexHandler) ffestb_varlist5_ (t);
4797
4798         default:
4799           goto bad_1;           /* :::::::::::::::::::: */
4800         }
4801
4802       /* Here, we have at least one char after the first keyword and t is
4803          COMMA or EOS/SEMICOLON.  Also we know that this form is valid for
4804          only the statements reaching here (specifically, INTENT won't reach
4805          here). */
4806
4807       if (!ffesrc_is_name_init (*p))
4808         goto bad_i;             /* :::::::::::::::::::: */
4809       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
4810       if (!ffesta_is_inhibited ())
4811         {
4812           switch (ffesta_first_kw)
4813             {
4814             case FFESTR_firstEXTERNAL:
4815               ffestc_R1207_start ();
4816               break;
4817
4818             case FFESTR_firstINTRINSIC:
4819               ffestc_R1208_start ();
4820               break;
4821
4822 #if FFESTR_F90
4823             case FFESTR_firstOPTIONAL:
4824               ffestc_R520_start ();
4825               break;
4826 #endif
4827
4828 #if FFESTR_F90
4829             case FFESTR_firstPUBLIC:
4830               ffestc_R521Astart ();
4831               break;
4832
4833             case FFESTR_firstPRIVATE:
4834               ffestc_R521Bstart ();
4835               break;
4836 #endif
4837
4838             default:
4839               assert (FALSE);
4840             }
4841         }
4842       next = (ffelexHandler) ffestb_varlist5_ (nt);
4843       ffelex_token_kill (nt);
4844       return (ffelexHandler) (*next) (t);
4845
4846     default:
4847       goto bad_0;               /* :::::::::::::::::::: */
4848     }
4849
4850 bad_0:                          /* :::::::::::::::::::: */
4851   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, ffesta_tokens[0]);
4852   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4853
4854 bad_1:                          /* :::::::::::::::::::: */
4855   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4856   return (ffelexHandler) ffelex_swallow_tokens (t,
4857                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
4858
4859 bad_i:                          /* :::::::::::::::::::: */
4860   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, ffesta_tokens[0], i, t);
4861   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4862 }
4863
4864 /* ffestb_varlist1_ -- "INTENT" OPEN_PAREN
4865
4866    return ffestb_varlist1_;  // to lexer
4867
4868    Handle NAME.  */
4869
4870 #if FFESTR_F90
4871 static ffelexHandler
4872 ffestb_varlist1_ (ffelexToken t)
4873 {
4874   switch (ffelex_token_type (t))
4875     {
4876     case FFELEX_typeNAME:
4877       ffesta_tokens[1] = ffelex_token_use (t);
4878       ffestb_local_.varlist.kw = ffestr_other (t);
4879       switch (ffestb_local_.varlist.kw)
4880         {
4881         case FFESTR_otherIN:
4882           return (ffelexHandler) ffestb_varlist2_;
4883
4884         case FFESTR_otherINOUT:
4885           return (ffelexHandler) ffestb_varlist3_;
4886
4887         case FFESTR_otherOUT:
4888           return (ffelexHandler) ffestb_varlist3_;
4889
4890         default:
4891           ffelex_token_kill (ffesta_tokens[1]);
4892           break;
4893         }
4894       break;
4895
4896     default:
4897       break;
4898     }
4899
4900   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4901   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4902 }
4903
4904 /* ffestb_varlist2_ -- "INTENT" OPEN_PAREN "IN"
4905
4906    return ffestb_varlist2_;  // to lexer
4907
4908    Handle NAME.  */
4909
4910 static ffelexHandler
4911 ffestb_varlist2_ (ffelexToken t)
4912 {
4913   switch (ffelex_token_type (t))
4914     {
4915     case FFELEX_typeNAME:
4916       switch (ffestr_other (t))
4917         {
4918         case FFESTR_otherOUT:
4919           ffestb_local_.varlist.kw = FFESTR_otherINOUT;
4920           return (ffelexHandler) ffestb_varlist3_;
4921
4922         default:
4923           break;
4924         }
4925       break;
4926
4927     case FFELEX_typeCLOSE_PAREN:
4928       return (ffelexHandler) ffestb_varlist4_;
4929
4930     default:
4931       break;
4932     }
4933
4934   ffelex_token_kill (ffesta_tokens[1]);
4935   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4936   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4937 }
4938
4939 /* ffestb_varlist3_ -- "INTENT" OPEN_PAREN NAME ["OUT"]
4940
4941    return ffestb_varlist3_;  // to lexer
4942
4943    Handle CLOSE_PAREN.  */
4944
4945 static ffelexHandler
4946 ffestb_varlist3_ (ffelexToken t)
4947 {
4948   switch (ffelex_token_type (t))
4949     {
4950     case FFELEX_typeCLOSE_PAREN:
4951       return (ffelexHandler) ffestb_varlist4_;
4952
4953     default:
4954       break;
4955     }
4956
4957   ffelex_token_kill (ffesta_tokens[1]);
4958   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4959   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4960 }
4961
4962 /* ffestb_varlist4_ -- "INTENT" OPEN_PAREN NAME ["OUT"] CLOSE_PAREN
4963
4964    return ffestb_varlist4_;  // to lexer
4965
4966    Handle COLONCOLON or NAME.  */
4967
4968 static ffelexHandler
4969 ffestb_varlist4_ (ffelexToken t)
4970 {
4971   switch (ffelex_token_type (t))
4972     {
4973     case FFELEX_typeCOLONCOLON:
4974       ffesta_confirmed ();
4975       if (!ffesta_is_inhibited ())
4976         ffestc_R519_start (ffesta_tokens[1], ffestb_local_.varlist.kw);
4977       ffelex_token_kill (ffesta_tokens[1]);
4978       return (ffelexHandler) ffestb_varlist5_;
4979
4980     case FFELEX_typeNAME:
4981       ffesta_confirmed ();
4982       if (!ffesta_is_inhibited ())
4983         ffestc_R519_start (ffesta_tokens[1], ffestb_local_.varlist.kw);
4984       ffelex_token_kill (ffesta_tokens[1]);
4985       return (ffelexHandler) ffestb_varlist5_ (t);
4986
4987     default:
4988       break;
4989     }
4990
4991   ffelex_token_kill (ffesta_tokens[1]);
4992   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
4993   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
4994 }
4995
4996 #endif
4997 /* ffestb_varlist5_ -- Handles the list of variable names
4998
4999    return ffestb_varlist5_;  // to lexer
5000
5001    Handle NAME.  */
5002
5003 static ffelexHandler
5004 ffestb_varlist5_ (ffelexToken t)
5005 {
5006   switch (ffelex_token_type (t))
5007     {
5008     case FFELEX_typeNAME:
5009       ffesta_tokens[1] = ffelex_token_use (t);
5010       return (ffelexHandler) ffestb_varlist6_;
5011
5012     default:
5013       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
5014       break;
5015     }
5016
5017   if (!ffesta_is_inhibited ())
5018     {
5019       switch (ffesta_first_kw)
5020         {
5021         case FFESTR_firstEXTERNAL:
5022           ffestc_R1207_finish ();
5023           break;
5024
5025 #if FFESTR_F90
5026         case FFESTR_firstINTENT:
5027           ffestc_R519_finish ();
5028           break;
5029 #endif
5030
5031         case FFESTR_firstINTRINSIC:
5032           ffestc_R1208_finish ();
5033           break;
5034
5035 #if FFESTR_F90
5036         case FFESTR_firstOPTIONAL:
5037           ffestc_R520_finish ();
5038           break;
5039 #endif
5040
5041 #if FFESTR_F90
5042         case FFESTR_firstPUBLIC:
5043           ffestc_R521Afinish ();
5044           break;
5045
5046         case FFESTR_firstPRIVATE:
5047           ffestc_R521Bfinish ();
5048           break;
5049 #endif
5050
5051         default:
5052           assert (FALSE);
5053         }
5054     }
5055   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5056 }
5057
5058 /* ffestb_varlist6_ -- (whatever) NAME
5059
5060    return ffestb_varlist6_;  // to lexer
5061
5062    Handle COMMA or EOS/SEMICOLON.  */
5063
5064 static ffelexHandler
5065 ffestb_varlist6_ (ffelexToken t)
5066 {
5067   switch (ffelex_token_type (t))
5068     {
5069     case FFELEX_typeCOMMA:
5070       if (!ffesta_is_inhibited ())
5071         {
5072           switch (ffesta_first_kw)
5073             {
5074             case FFESTR_firstEXTERNAL:
5075               ffestc_R1207_item (ffesta_tokens[1]);
5076               break;
5077
5078 #if FFESTR_F90
5079             case FFESTR_firstINTENT:
5080               ffestc_R519_item (ffesta_tokens[1]);
5081               break;
5082 #endif
5083
5084             case FFESTR_firstINTRINSIC:
5085               ffestc_R1208_item (ffesta_tokens[1]);
5086               break;
5087
5088 #if FFESTR_F90
5089             case FFESTR_firstOPTIONAL:
5090               ffestc_R520_item (ffesta_tokens[1]);
5091               break;
5092 #endif
5093
5094 #if FFESTR_F90
5095             case FFESTR_firstPUBLIC:
5096               ffestc_R521Aitem (ffesta_tokens[1]);
5097               break;
5098
5099             case FFESTR_firstPRIVATE:
5100               ffestc_R521Bitem (ffesta_tokens[1]);
5101               break;
5102 #endif
5103
5104             default:
5105               assert (FALSE);
5106             }
5107         }
5108       ffelex_token_kill (ffesta_tokens[1]);
5109       return (ffelexHandler) ffestb_varlist5_;
5110
5111     case FFELEX_typeEOS:
5112     case FFELEX_typeSEMICOLON:
5113       if (!ffesta_is_inhibited ())
5114         {
5115           switch (ffesta_first_kw)
5116             {
5117             case FFESTR_firstEXTERNAL:
5118               ffestc_R1207_item (ffesta_tokens[1]);
5119               ffestc_R1207_finish ();
5120               break;
5121
5122 #if FFESTR_F90
5123             case FFESTR_firstINTENT:
5124               ffestc_R519_item (ffesta_tokens[1]);
5125               ffestc_R519_finish ();
5126               break;
5127 #endif
5128
5129             case FFESTR_firstINTRINSIC:
5130               ffestc_R1208_item (ffesta_tokens[1]);
5131               ffestc_R1208_finish ();
5132               break;
5133
5134 #if FFESTR_F90
5135             case FFESTR_firstOPTIONAL:
5136               ffestc_R520_item (ffesta_tokens[1]);
5137               ffestc_R520_finish ();
5138               break;
5139 #endif
5140
5141 #if FFESTR_F90
5142             case FFESTR_firstPUBLIC:
5143               ffestc_R521Aitem (ffesta_tokens[1]);
5144               ffestc_R521Afinish ();
5145               break;
5146
5147             case FFESTR_firstPRIVATE:
5148               ffestc_R521Bitem (ffesta_tokens[1]);
5149               ffestc_R521Bfinish ();
5150               break;
5151 #endif
5152
5153             default:
5154               assert (FALSE);
5155             }
5156         }
5157       ffelex_token_kill (ffesta_tokens[1]);
5158       return (ffelexHandler) ffesta_zero (t);
5159
5160     default:
5161       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
5162       break;
5163     }
5164
5165   if (!ffesta_is_inhibited ())
5166     {
5167       switch (ffesta_first_kw)
5168         {
5169         case FFESTR_firstEXTERNAL:
5170           ffestc_R1207_finish ();
5171           break;
5172
5173 #if FFESTR_F90
5174         case FFESTR_firstINTENT:
5175           ffestc_R519_finish ();
5176           break;
5177 #endif
5178
5179         case FFESTR_firstINTRINSIC:
5180           ffestc_R1208_finish ();
5181           break;
5182
5183 #if FFESTR_F90
5184         case FFESTR_firstOPTIONAL:
5185           ffestc_R520_finish ();
5186           break;
5187 #endif
5188
5189 #if FFESTR_F90
5190         case FFESTR_firstPUBLIC:
5191           ffestc_R521Afinish ();
5192           break;
5193
5194         case FFESTR_firstPRIVATE:
5195           ffestc_R521Bfinish ();
5196           break;
5197 #endif
5198
5199         default:
5200           assert (FALSE);
5201         }
5202     }
5203   ffelex_token_kill (ffesta_tokens[1]);
5204   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5205 }
5206
5207 /* ffestb_R423B -- Parse the SEQUENCE statement
5208
5209    return ffestb_R423B;  // to lexer
5210
5211    Make sure the statement has a valid form for the SEQUENCE statement.  If
5212    it does, implement the statement.  */
5213
5214 #if FFESTR_F90
5215 ffelexHandler
5216 ffestb_R423B (ffelexToken t)
5217 {
5218   const char *p;
5219   ffeTokenLength i;
5220
5221   switch (ffelex_token_type (ffesta_tokens[0]))
5222     {
5223     case FFELEX_typeNAME:
5224       if (ffesta_first_kw != FFESTR_firstSEQUENCE)
5225         goto bad_0;             /* :::::::::::::::::::: */
5226       break;
5227
5228     case FFELEX_typeNAMES:
5229       if (ffesta_first_kw != FFESTR_firstSEQUENCE)
5230         goto bad_0;             /* :::::::::::::::::::: */
5231       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlSEQUENCE)
5232         {
5233           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSEQUENCE);
5234           goto bad_i;           /* :::::::::::::::::::: */
5235         }
5236       break;
5237
5238     default:
5239       goto bad_0;               /* :::::::::::::::::::: */
5240     }
5241
5242   switch (ffelex_token_type (t))
5243     {
5244     case FFELEX_typeEOS:
5245     case FFELEX_typeSEMICOLON:
5246       ffesta_confirmed ();
5247       if (!ffesta_is_inhibited ())
5248         ffestc_R423B ();
5249       return (ffelexHandler) ffesta_zero (t);
5250
5251     case FFELEX_typeCOMMA:
5252     case FFELEX_typeCOLONCOLON:
5253       ffesta_confirmed ();      /* Error, but clearly intended. */
5254       goto bad_1;               /* :::::::::::::::::::: */
5255
5256     default:
5257       goto bad_1;               /* :::::::::::::::::::: */
5258     }
5259
5260 bad_0:                          /* :::::::::::::::::::: */
5261   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", ffesta_tokens[0]);
5262   return (ffelexHandler) ffelex_swallow_tokens (t,
5263                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
5264
5265 bad_1:                          /* :::::::::::::::::::: */
5266   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", t);
5267   return (ffelexHandler) ffelex_swallow_tokens (t,
5268                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
5269
5270 bad_i:                          /* :::::::::::::::::::: */
5271   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", ffesta_tokens[0], i, t);
5272   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5273 }
5274
5275 #endif
5276 /* ffestb_R522 -- Parse the SAVE statement
5277
5278    return ffestb_R522;  // to lexer
5279
5280    Make sure the statement has a valid form for the SAVE statement.  If it
5281    does, implement the statement.  */
5282
5283 ffelexHandler
5284 ffestb_R522 (ffelexToken t)
5285 {
5286   ffeTokenLength i;
5287   unsigned const char *p;
5288   ffelexToken nt;
5289   ffelexHandler next;
5290
5291   switch (ffelex_token_type (ffesta_tokens[0]))
5292     {
5293     case FFELEX_typeNAME:
5294       if (ffesta_first_kw != FFESTR_firstSAVE)
5295         goto bad_0;             /* :::::::::::::::::::: */
5296       switch (ffelex_token_type (t))
5297         {
5298         case FFELEX_typeCOMMA:
5299           ffesta_confirmed ();  /* Error, but clearly intended. */
5300           goto bad_1;           /* :::::::::::::::::::: */
5301
5302         default:
5303           goto bad_1;           /* :::::::::::::::::::: */
5304
5305         case FFELEX_typeEOS:
5306         case FFELEX_typeSEMICOLON:
5307           ffesta_confirmed ();
5308           if (!ffesta_is_inhibited ())
5309             ffestc_R522 ();
5310           return (ffelexHandler) ffesta_zero (t);
5311
5312         case FFELEX_typeNAME:
5313         case FFELEX_typeSLASH:
5314           ffesta_confirmed ();
5315           if (!ffesta_is_inhibited ())
5316             ffestc_R522start ();
5317           return (ffelexHandler) ffestb_R5221_ (t);
5318
5319         case FFELEX_typeCOLONCOLON:
5320           ffesta_confirmed ();
5321           if (!ffesta_is_inhibited ())
5322             ffestc_R522start ();
5323           return (ffelexHandler) ffestb_R5221_;
5324         }
5325
5326     case FFELEX_typeNAMES:
5327       if (ffesta_first_kw != FFESTR_firstSAVE)
5328         goto bad_0;             /* :::::::::::::::::::: */
5329       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSAVE);
5330       switch (ffelex_token_type (t))
5331         {
5332         default:
5333           goto bad_1;           /* :::::::::::::::::::: */
5334
5335         case FFELEX_typeCOMMA:
5336           ffesta_confirmed ();
5337           break;
5338
5339         case FFELEX_typeEOS:
5340         case FFELEX_typeSEMICOLON:
5341           ffesta_confirmed ();
5342           if (*p != '\0')
5343             break;
5344           if (!ffesta_is_inhibited ())
5345             ffestc_R522 ();
5346           return (ffelexHandler) ffesta_zero (t);
5347
5348         case FFELEX_typeSLASH:
5349           ffesta_confirmed ();
5350           if (*p != '\0')
5351             goto bad_i;         /* :::::::::::::::::::: */
5352           if (!ffesta_is_inhibited ())
5353             ffestc_R522start ();
5354           return (ffelexHandler) ffestb_R5221_ (t);
5355
5356         case FFELEX_typeCOLONCOLON:
5357           ffesta_confirmed ();
5358           if (*p != '\0')
5359             goto bad_i;         /* :::::::::::::::::::: */
5360           if (!ffesta_is_inhibited ())
5361             ffestc_R522start ();
5362           return (ffelexHandler) ffestb_R5221_;
5363         }
5364
5365       /* Here, we have at least one char after "SAVE" and t is COMMA or
5366          EOS/SEMICOLON. */
5367
5368       if (!ffesrc_is_name_init (*p))
5369         goto bad_i;             /* :::::::::::::::::::: */
5370       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
5371       if (!ffesta_is_inhibited ())
5372         ffestc_R522start ();
5373       next = (ffelexHandler) ffestb_R5221_ (nt);
5374       ffelex_token_kill (nt);
5375       return (ffelexHandler) (*next) (t);
5376
5377     default:
5378       goto bad_0;               /* :::::::::::::::::::: */
5379     }
5380
5381 bad_0:                          /* :::::::::::::::::::: */
5382   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", ffesta_tokens[0]);
5383   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5384
5385 bad_1:                          /* :::::::::::::::::::: */
5386   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5387   return (ffelexHandler) ffelex_swallow_tokens (t,
5388                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
5389
5390 bad_i:                          /* :::::::::::::::::::: */
5391   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SAVE", ffesta_tokens[0], i, t);
5392   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5393 }
5394
5395 /* ffestb_R5221_ -- "SAVE" [COLONCOLON]
5396
5397    return ffestb_R5221_;  // to lexer
5398
5399    Handle NAME or SLASH.  */
5400
5401 static ffelexHandler
5402 ffestb_R5221_ (ffelexToken t)
5403 {
5404   switch (ffelex_token_type (t))
5405     {
5406     case FFELEX_typeNAME:
5407       ffestb_local_.R522.is_cblock = FALSE;
5408       ffesta_tokens[1] = ffelex_token_use (t);
5409       return (ffelexHandler) ffestb_R5224_;
5410
5411     case FFELEX_typeSLASH:
5412       ffestb_local_.R522.is_cblock = TRUE;
5413       return (ffelexHandler) ffestb_R5222_;
5414
5415     default:
5416       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5417       break;
5418     }
5419
5420   if (!ffesta_is_inhibited ())
5421     ffestc_R522finish ();
5422   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5423 }
5424
5425 /* ffestb_R5222_ -- "SAVE" [COLONCOLON] SLASH
5426
5427    return ffestb_R5222_;  // to lexer
5428
5429    Handle NAME.  */
5430
5431 static ffelexHandler
5432 ffestb_R5222_ (ffelexToken t)
5433 {
5434   switch (ffelex_token_type (t))
5435     {
5436     case FFELEX_typeNAME:
5437       ffesta_tokens[1] = ffelex_token_use (t);
5438       return (ffelexHandler) ffestb_R5223_;
5439
5440     default:
5441       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5442       break;
5443     }
5444
5445   if (!ffesta_is_inhibited ())
5446     ffestc_R522finish ();
5447   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5448 }
5449
5450 /* ffestb_R5223_ -- "SAVE" [COLONCOLON] SLASH NAME
5451
5452    return ffestb_R5223_;  // to lexer
5453
5454    Handle SLASH.  */
5455
5456 static ffelexHandler
5457 ffestb_R5223_ (ffelexToken t)
5458 {
5459   switch (ffelex_token_type (t))
5460     {
5461     case FFELEX_typeSLASH:
5462       return (ffelexHandler) ffestb_R5224_;
5463
5464     default:
5465       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5466       break;
5467     }
5468
5469   if (!ffesta_is_inhibited ())
5470     ffestc_R522finish ();
5471   ffelex_token_kill (ffesta_tokens[1]);
5472   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5473 }
5474
5475 /* ffestb_R5224_ -- "SAVE" [COLONCOLON] R523
5476
5477    return ffestb_R5224_;  // to lexer
5478
5479    Handle COMMA or EOS/SEMICOLON.  */
5480
5481 static ffelexHandler
5482 ffestb_R5224_ (ffelexToken t)
5483 {
5484   switch (ffelex_token_type (t))
5485     {
5486     case FFELEX_typeCOMMA:
5487       if (!ffesta_is_inhibited ())
5488         {
5489           if (ffestb_local_.R522.is_cblock)
5490             ffestc_R522item_cblock (ffesta_tokens[1]);
5491           else
5492             ffestc_R522item_object (ffesta_tokens[1]);
5493         }
5494       ffelex_token_kill (ffesta_tokens[1]);
5495       return (ffelexHandler) ffestb_R5221_;
5496
5497     case FFELEX_typeEOS:
5498     case FFELEX_typeSEMICOLON:
5499       if (!ffesta_is_inhibited ())
5500         {
5501           if (ffestb_local_.R522.is_cblock)
5502             ffestc_R522item_cblock (ffesta_tokens[1]);
5503           else
5504             ffestc_R522item_object (ffesta_tokens[1]);
5505           ffestc_R522finish ();
5506         }
5507       ffelex_token_kill (ffesta_tokens[1]);
5508       return (ffelexHandler) ffesta_zero (t);
5509
5510     default:
5511       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
5512       break;
5513     }
5514
5515   if (!ffesta_is_inhibited ())
5516     ffestc_R522finish ();
5517   ffelex_token_kill (ffesta_tokens[1]);
5518   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5519 }
5520
5521 /* ffestb_R528 -- Parse the DATA statement
5522
5523    return ffestb_R528;  // to lexer
5524
5525    Make sure the statement has a valid form for the DATA statement.  If it
5526    does, implement the statement.  */
5527
5528 ffelexHandler
5529 ffestb_R528 (ffelexToken t)
5530 {
5531   unsigned const char *p;
5532   ffeTokenLength i;
5533   ffelexToken nt;
5534   ffelexHandler next;
5535
5536   switch (ffelex_token_type (ffesta_tokens[0]))
5537     {
5538     case FFELEX_typeNAME:
5539       if (ffesta_first_kw != FFESTR_firstDATA)
5540         goto bad_0;             /* :::::::::::::::::::: */
5541       switch (ffelex_token_type (t))
5542         {
5543         case FFELEX_typeCOMMA:
5544         case FFELEX_typeEOS:
5545         case FFELEX_typeSEMICOLON:
5546         case FFELEX_typeSLASH:
5547         case FFELEX_typeCOLONCOLON:
5548           ffesta_confirmed ();  /* Error, but clearly intended. */
5549           goto bad_1;           /* :::::::::::::::::::: */
5550
5551         default:
5552           goto bad_1;           /* :::::::::::::::::::: */
5553
5554         case FFELEX_typeNAME:
5555           ffesta_confirmed ();
5556           break;
5557
5558         case FFELEX_typeOPEN_PAREN:
5559           break;
5560         }
5561       ffestb_local_.data.started = FALSE;
5562       return (ffelexHandler) (*((ffelexHandler)
5563                                 ffeexpr_lhs (ffesta_output_pool,
5564                                              FFEEXPR_contextDATA,
5565                                           (ffeexprCallback) ffestb_R5281_)))
5566         (t);
5567
5568     case FFELEX_typeNAMES:
5569       if (ffesta_first_kw != FFESTR_firstDATA)
5570         goto bad_0;             /* :::::::::::::::::::: */
5571       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDATA);
5572       switch (ffelex_token_type (t))
5573         {
5574         case FFELEX_typeEOS:
5575         case FFELEX_typeSEMICOLON:
5576         case FFELEX_typeCOLONCOLON:
5577           ffesta_confirmed ();  /* Error, but clearly intended. */
5578           goto bad_1;           /* :::::::::::::::::::: */
5579
5580         default:
5581           goto bad_1;           /* :::::::::::::::::::: */
5582
5583         case FFELEX_typeOPEN_PAREN:
5584           if (*p == '\0')
5585             {
5586               ffestb_local_.data.started = FALSE;
5587               return (ffelexHandler) (*((ffelexHandler)
5588                                         ffeexpr_lhs (ffesta_output_pool,
5589                                                      FFEEXPR_contextDATA,
5590                                                      (ffeexprCallback)
5591                                                      ffestb_R5281_)))
5592                 (t);
5593             }
5594           break;
5595
5596         case FFELEX_typeCOMMA:
5597         case FFELEX_typeSLASH:
5598           ffesta_confirmed ();
5599           break;
5600         }
5601       if (!ffesrc_is_name_init (*p))
5602         goto bad_i;             /* :::::::::::::::::::: */
5603       ffestb_local_.data.started = FALSE;
5604       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
5605       next = (ffelexHandler) (*((ffelexHandler)
5606                                 ffeexpr_lhs (ffesta_output_pool,
5607                                              FFEEXPR_contextDATA,
5608                                           (ffeexprCallback) ffestb_R5281_)))
5609         (nt);
5610       ffelex_token_kill (nt);
5611       return (ffelexHandler) (*next) (t);
5612
5613     default:
5614       goto bad_0;               /* :::::::::::::::::::: */
5615     }
5616
5617 bad_0:                          /* :::::::::::::::::::: */
5618   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", ffesta_tokens[0]);
5619   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5620
5621 bad_1:                          /* :::::::::::::::::::: */
5622   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5623   return (ffelexHandler) ffelex_swallow_tokens (t,
5624                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
5625
5626 bad_i:                          /* :::::::::::::::::::: */
5627   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DATA", ffesta_tokens[0], i, t);
5628   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5629 }
5630
5631 /* ffestb_R5281_ -- "DATA" expr-list
5632
5633    (ffestb_R5281_)  // to expression handler
5634
5635    Handle COMMA or SLASH.  */
5636
5637 static ffelexHandler
5638 ffestb_R5281_ (ffelexToken ft, ffebld expr, ffelexToken t)
5639 {
5640   switch (ffelex_token_type (t))
5641     {
5642     case FFELEX_typeCOMMA:
5643       ffesta_confirmed ();
5644       if (expr == NULL)
5645         break;
5646       if (!ffesta_is_inhibited ())
5647         {
5648           if (!ffestb_local_.data.started)
5649             {
5650               ffestc_R528_start ();
5651               ffestb_local_.data.started = TRUE;
5652             }
5653           ffestc_R528_item_object (expr, ft);
5654         }
5655       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5656                                           FFEEXPR_contextDATA,
5657                                           (ffeexprCallback) ffestb_R5281_);
5658
5659     case FFELEX_typeSLASH:
5660       ffesta_confirmed ();
5661       if (expr == NULL)
5662         break;
5663       if (!ffesta_is_inhibited ())
5664         {
5665           if (!ffestb_local_.data.started)
5666             {
5667               ffestc_R528_start ();
5668               ffestb_local_.data.started = TRUE;
5669             }
5670           ffestc_R528_item_object (expr, ft);
5671           ffestc_R528_item_startvals ();
5672         }
5673       return (ffelexHandler) ffeexpr_rhs
5674         (ffesta_output_pool, FFEEXPR_contextDATA,
5675          (ffeexprCallback) ffestb_R5282_);
5676
5677     default:
5678       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5679       break;
5680     }
5681
5682   if (ffestb_local_.data.started && !ffesta_is_inhibited ())
5683     ffestc_R528_finish ();
5684   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5685 }
5686
5687 /* ffestb_R5282_ -- "DATA" expr-list SLASH expr-list
5688
5689    (ffestb_R5282_)  // to expression handler
5690
5691    Handle ASTERISK, COMMA, or SLASH.  */
5692
5693 static ffelexHandler
5694 ffestb_R5282_ (ffelexToken ft, ffebld expr, ffelexToken t)
5695 {
5696   switch (ffelex_token_type (t))
5697     {
5698     case FFELEX_typeCOMMA:
5699       if (expr == NULL)
5700         break;
5701       if (!ffesta_is_inhibited ())
5702         ffestc_R528_item_value (NULL, NULL, expr, ft);
5703       return (ffelexHandler) ffeexpr_rhs
5704         (ffesta_output_pool, FFEEXPR_contextDATA,
5705          (ffeexprCallback) ffestb_R5282_);
5706
5707     case FFELEX_typeASTERISK:
5708       if (expr == NULL)
5709         break;
5710       ffestb_local_.data.expr = ffeexpr_convert (expr, ft, t,
5711                                                  FFEINFO_basictypeINTEGER,
5712                                                  FFEINFO_kindtypeINTEGER1,
5713                                                  0,
5714                                                  FFETARGET_charactersizeNONE,
5715                                                  FFEEXPR_contextLET);
5716       ffesta_tokens[1] = ffelex_token_use (ft);
5717       return (ffelexHandler) ffeexpr_rhs
5718         (ffesta_output_pool, FFEEXPR_contextDATA,
5719          (ffeexprCallback) ffestb_R5283_);
5720
5721     case FFELEX_typeSLASH:
5722       if (expr == NULL)
5723         break;
5724       if (!ffesta_is_inhibited ())
5725         {
5726           ffestc_R528_item_value (NULL, NULL, expr, ft);
5727           ffestc_R528_item_endvals (t);
5728         }
5729       return (ffelexHandler) ffestb_R5284_;
5730
5731     default:
5732       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5733       break;
5734     }
5735
5736   if (!ffesta_is_inhibited ())
5737     {
5738       ffestc_R528_item_endvals (t);
5739       ffestc_R528_finish ();
5740     }
5741   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5742 }
5743
5744 /* ffestb_R5283_ -- "DATA" expr-list SLASH expr ASTERISK expr
5745
5746    (ffestb_R5283_)  // to expression handler
5747
5748    Handle COMMA or SLASH.  */
5749
5750 static ffelexHandler
5751 ffestb_R5283_ (ffelexToken ft, ffebld expr, ffelexToken t)
5752 {
5753   switch (ffelex_token_type (t))
5754     {
5755     case FFELEX_typeCOMMA:
5756       if (expr == NULL)
5757         break;
5758       if (!ffesta_is_inhibited ())
5759         ffestc_R528_item_value (ffestb_local_.data.expr, ffesta_tokens[1],
5760                                 expr, ft);
5761       ffelex_token_kill (ffesta_tokens[1]);
5762       return (ffelexHandler) ffeexpr_rhs
5763         (ffesta_output_pool, FFEEXPR_contextDATA,
5764          (ffeexprCallback) ffestb_R5282_);
5765
5766     case FFELEX_typeSLASH:
5767       if (expr == NULL)
5768         break;
5769       if (!ffesta_is_inhibited ())
5770         {
5771           ffestc_R528_item_value (ffestb_local_.data.expr, ffesta_tokens[1],
5772                                   expr, ft);
5773           ffestc_R528_item_endvals (t);
5774         }
5775       ffelex_token_kill (ffesta_tokens[1]);
5776       return (ffelexHandler) ffestb_R5284_;
5777
5778     default:
5779       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5780       break;
5781     }
5782
5783   if (!ffesta_is_inhibited ())
5784     {
5785       ffestc_R528_item_endvals (t);
5786       ffestc_R528_finish ();
5787     }
5788   ffelex_token_kill (ffesta_tokens[1]);
5789   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5790 }
5791
5792 /* ffestb_R5284_ -- "DATA" expr-list SLASH expr-list SLASH
5793
5794    return ffestb_R5284_;  // to lexer
5795
5796    Handle [COMMA] NAME or EOS/SEMICOLON.  */
5797
5798 static ffelexHandler
5799 ffestb_R5284_ (ffelexToken t)
5800 {
5801   switch (ffelex_token_type (t))
5802     {
5803     case FFELEX_typeCOMMA:
5804       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5805                                           FFEEXPR_contextDATA,
5806                                           (ffeexprCallback) ffestb_R5281_);
5807
5808     case FFELEX_typeNAME:
5809     case FFELEX_typeOPEN_PAREN:
5810       return (ffelexHandler) (*((ffelexHandler)
5811                                 ffeexpr_lhs (ffesta_output_pool,
5812                                              FFEEXPR_contextDATA,
5813                                           (ffeexprCallback) ffestb_R5281_)))
5814         (t);
5815
5816     case FFELEX_typeEOS:
5817     case FFELEX_typeSEMICOLON:
5818       if (!ffesta_is_inhibited ())
5819         ffestc_R528_finish ();
5820       return (ffelexHandler) ffesta_zero (t);
5821
5822     default:
5823       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
5824       break;
5825     }
5826
5827   if (!ffesta_is_inhibited ())
5828     ffestc_R528_finish ();
5829   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5830 }
5831
5832 /* ffestb_R537 -- Parse a PARAMETER statement
5833
5834    return ffestb_R537;  // to lexer
5835
5836    Make sure the statement has a valid form for an PARAMETER statement.
5837    If it does, implement the statement.  */
5838
5839 ffelexHandler
5840 ffestb_R537 (ffelexToken t)
5841 {
5842   switch (ffelex_token_type (ffesta_tokens[0]))
5843     {
5844     case FFELEX_typeNAME:
5845       if (ffesta_first_kw != FFESTR_firstPARAMETER)
5846         goto bad_0;             /* :::::::::::::::::::: */
5847       break;
5848
5849     case FFELEX_typeNAMES:
5850       if (ffesta_first_kw != FFESTR_firstPARAMETER)
5851         goto bad_0;             /* :::::::::::::::::::: */
5852       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlPARAMETER)
5853         goto bad_0;             /* :::::::::::::::::::: */
5854       break;
5855
5856     default:
5857       goto bad_0;               /* :::::::::::::::::::: */
5858     }
5859
5860   switch (ffelex_token_type (t))
5861     {
5862     case FFELEX_typeOPEN_PAREN:
5863       break;
5864
5865     case FFELEX_typeEOS:
5866     case FFELEX_typeSEMICOLON:
5867     case FFELEX_typeCOMMA:
5868     case FFELEX_typeCOLONCOLON:
5869       ffesta_confirmed ();      /* Error, but clearly intended. */
5870       goto bad_1;               /* :::::::::::::::::::: */
5871
5872     default:
5873       goto bad_1;               /* :::::::::::::::::::: */
5874     }
5875
5876   ffestb_local_.parameter.started = FALSE;
5877   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5878                                       FFEEXPR_contextPARAMETER,
5879                                       (ffeexprCallback) ffestb_R5371_);
5880
5881 bad_0:                          /* :::::::::::::::::::: */
5882   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0]);
5883   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5884
5885 bad_1:                          /* :::::::::::::::::::: */
5886   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
5887   return (ffelexHandler) ffelex_swallow_tokens (t,
5888                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
5889 }
5890
5891 /* ffestb_R5371_ -- "PARAMETER" OPEN_PAREN expr
5892
5893    (ffestb_R5371_)  // to expression handler
5894
5895    Make sure the next token is EQUALS.  */
5896
5897 static ffelexHandler
5898 ffestb_R5371_ (ffelexToken ft, ffebld expr, ffelexToken t)
5899 {
5900   ffestb_local_.parameter.expr = expr;
5901
5902   switch (ffelex_token_type (t))
5903     {
5904     case FFELEX_typeEQUALS:
5905       ffesta_confirmed ();
5906       if (expr == NULL)
5907         break;
5908       ffesta_tokens[1] = ffelex_token_use (ft);
5909       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
5910                  FFEEXPR_contextPARAMETER, (ffeexprCallback) ffestb_R5372_);
5911
5912     default:
5913       break;
5914     }
5915
5916   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
5917   if (ffestb_local_.parameter.started)
5918     ffestc_R537_finish ();
5919   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5920 }
5921
5922 /* ffestb_R5372_ -- "PARAMETER" OPEN_PAREN expr EQUALS expr
5923
5924    (ffestb_R5372_)  // to expression handler
5925
5926    Make sure the next token is COMMA or CLOSE_PAREN.  */
5927
5928 static ffelexHandler
5929 ffestb_R5372_ (ffelexToken ft, ffebld expr, ffelexToken t)
5930 {
5931   switch (ffelex_token_type (t))
5932     {
5933     case FFELEX_typeCOMMA:
5934       if (expr == NULL)
5935         break;
5936       if (!ffesta_is_inhibited ())
5937         {
5938           if (!ffestb_local_.parameter.started)
5939             {
5940               ffestc_R537_start ();
5941               ffestb_local_.parameter.started = TRUE;
5942             }
5943           ffestc_R537_item (ffestb_local_.parameter.expr, ffesta_tokens[1],
5944                             expr, ft);
5945         }
5946       ffelex_token_kill (ffesta_tokens[1]);
5947       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
5948                                           FFEEXPR_contextPARAMETER,
5949                                           (ffeexprCallback) ffestb_R5371_);
5950
5951     case FFELEX_typeCLOSE_PAREN:
5952       if (expr == NULL)
5953         break;
5954       if (!ffesta_is_inhibited ())
5955         {
5956           if (!ffestb_local_.parameter.started)
5957             {
5958               ffestc_R537_start ();
5959               ffestb_local_.parameter.started = TRUE;
5960             }
5961           ffestc_R537_item (ffestb_local_.parameter.expr, ffesta_tokens[1],
5962                             expr, ft);
5963           ffestc_R537_finish ();
5964         }
5965       ffelex_token_kill (ffesta_tokens[1]);
5966       return (ffelexHandler) ffestb_R5373_;
5967
5968     default:
5969       break;
5970     }
5971
5972   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
5973   if (ffestb_local_.parameter.started)
5974     ffestc_R537_finish ();
5975   ffelex_token_kill (ffesta_tokens[1]);
5976   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
5977 }
5978
5979 /* ffestb_R5373_ -- "PARAMETER" OPEN_PAREN expr EQUALS expr CLOSE_PAREN
5980
5981    return ffestb_R5373_;  // to lexer
5982
5983    Make sure the next token is EOS or SEMICOLON, or generate an error.  All
5984    cleanup has already been done, by the way.  */
5985
5986 static ffelexHandler
5987 ffestb_R5373_ (ffelexToken t)
5988 {
5989   switch (ffelex_token_type (t))
5990     {
5991     case FFELEX_typeEOS:
5992     case FFELEX_typeSEMICOLON:
5993       return (ffelexHandler) ffesta_zero (t);
5994
5995     default:
5996       break;
5997     }
5998
5999   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
6000   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6001 }
6002
6003 /* ffestb_R542 -- Parse the NAMELIST statement
6004
6005    return ffestb_R542;  // to lexer
6006
6007    Make sure the statement has a valid form for the NAMELIST statement.  If it
6008    does, implement the statement.  */
6009
6010 ffelexHandler
6011 ffestb_R542 (ffelexToken t)
6012 {
6013   const char *p;
6014   ffeTokenLength i;
6015
6016   switch (ffelex_token_type (ffesta_tokens[0]))
6017     {
6018     case FFELEX_typeNAME:
6019       if (ffesta_first_kw != FFESTR_firstNAMELIST)
6020         goto bad_0;             /* :::::::::::::::::::: */
6021       break;
6022
6023     case FFELEX_typeNAMES:
6024       if (ffesta_first_kw != FFESTR_firstNAMELIST)
6025         goto bad_0;             /* :::::::::::::::::::: */
6026       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlNAMELIST);
6027       if (*p != '\0')
6028         goto bad_i;             /* :::::::::::::::::::: */
6029       break;
6030
6031     default:
6032       goto bad_0;               /* :::::::::::::::::::: */
6033     }
6034
6035   switch (ffelex_token_type (t))
6036     {
6037     case FFELEX_typeCOMMA:
6038     case FFELEX_typeEOS:
6039     case FFELEX_typeSEMICOLON:
6040     case FFELEX_typeCOLONCOLON:
6041       ffesta_confirmed ();      /* Error, but clearly intended. */
6042       goto bad_1;               /* :::::::::::::::::::: */
6043
6044     default:
6045       goto bad_1;               /* :::::::::::::::::::: */
6046
6047     case FFELEX_typeSLASH:
6048       break;
6049     }
6050
6051   ffesta_confirmed ();
6052   if (!ffesta_is_inhibited ())
6053     ffestc_R542_start ();
6054   return (ffelexHandler) ffestb_R5421_;
6055
6056 bad_0:                          /* :::::::::::::::::::: */
6057   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", ffesta_tokens[0]);
6058   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6059
6060 bad_1:                          /* :::::::::::::::::::: */
6061   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6062   return (ffelexHandler) ffelex_swallow_tokens (t,
6063                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6064
6065 bad_i:                          /* :::::::::::::::::::: */
6066   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "NAMELIST", ffesta_tokens[0], i, t);
6067   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6068 }
6069
6070 /* ffestb_R5421_ -- "NAMELIST" SLASH
6071
6072    return ffestb_R5421_;  // to lexer
6073
6074    Handle NAME.  */
6075
6076 static ffelexHandler
6077 ffestb_R5421_ (ffelexToken t)
6078 {
6079   switch (ffelex_token_type (t))
6080     {
6081     case FFELEX_typeNAME:
6082       if (!ffesta_is_inhibited ())
6083         ffestc_R542_item_nlist (t);
6084       return (ffelexHandler) ffestb_R5422_;
6085
6086     default:
6087       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6088       break;
6089     }
6090
6091   if (!ffesta_is_inhibited ())
6092     ffestc_R542_finish ();
6093   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6094 }
6095
6096 /* ffestb_R5422_ -- "NAMELIST" SLASH NAME
6097
6098    return ffestb_R5422_;  // to lexer
6099
6100    Handle SLASH.  */
6101
6102 static ffelexHandler
6103 ffestb_R5422_ (ffelexToken t)
6104 {
6105   switch (ffelex_token_type (t))
6106     {
6107     case FFELEX_typeSLASH:
6108       return (ffelexHandler) ffestb_R5423_;
6109
6110     default:
6111       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6112       break;
6113     }
6114
6115   if (!ffesta_is_inhibited ())
6116     ffestc_R542_finish ();
6117   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6118 }
6119
6120 /* ffestb_R5423_ -- "NAMELIST" SLASH NAME SLASH
6121
6122    return ffestb_R5423_;  // to lexer
6123
6124    Handle NAME.  */
6125
6126 static ffelexHandler
6127 ffestb_R5423_ (ffelexToken t)
6128 {
6129   switch (ffelex_token_type (t))
6130     {
6131     case FFELEX_typeNAME:
6132       if (!ffesta_is_inhibited ())
6133         ffestc_R542_item_nitem (t);
6134       return (ffelexHandler) ffestb_R5424_;
6135
6136     default:
6137       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6138       break;
6139     }
6140
6141   if (!ffesta_is_inhibited ())
6142     ffestc_R542_finish ();
6143   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6144 }
6145
6146 /* ffestb_R5424_ -- "NAMELIST" SLASH NAME SLASH NAME
6147
6148    return ffestb_R5424_;  // to lexer
6149
6150    Handle COMMA, EOS/SEMICOLON, or SLASH.  */
6151
6152 static ffelexHandler
6153 ffestb_R5424_ (ffelexToken t)
6154 {
6155   switch (ffelex_token_type (t))
6156     {
6157     case FFELEX_typeCOMMA:
6158       return (ffelexHandler) ffestb_R5425_;
6159
6160     case FFELEX_typeEOS:
6161     case FFELEX_typeSEMICOLON:
6162       if (!ffesta_is_inhibited ())
6163         ffestc_R542_finish ();
6164       return (ffelexHandler) ffesta_zero (t);
6165
6166     case FFELEX_typeSLASH:
6167       return (ffelexHandler) ffestb_R5421_;
6168
6169     default:
6170       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6171       break;
6172     }
6173
6174   if (!ffesta_is_inhibited ())
6175     ffestc_R542_finish ();
6176   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6177 }
6178
6179 /* ffestb_R5425_ -- "NAMELIST" SLASH NAME SLASH NAME COMMA
6180
6181    return ffestb_R5425_;  // to lexer
6182
6183    Handle NAME or SLASH.  */
6184
6185 static ffelexHandler
6186 ffestb_R5425_ (ffelexToken t)
6187 {
6188   switch (ffelex_token_type (t))
6189     {
6190     case FFELEX_typeNAME:
6191       if (!ffesta_is_inhibited ())
6192         ffestc_R542_item_nitem (t);
6193       return (ffelexHandler) ffestb_R5424_;
6194
6195     case FFELEX_typeSLASH:
6196       return (ffelexHandler) ffestb_R5421_;
6197
6198     default:
6199       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
6200       break;
6201     }
6202
6203   if (!ffesta_is_inhibited ())
6204     ffestc_R542_finish ();
6205   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6206 }
6207
6208 /* ffestb_R544 -- Parse an EQUIVALENCE statement
6209
6210    return ffestb_R544;  // to lexer
6211
6212    Make sure the statement has a valid form for an EQUIVALENCE statement.
6213    If it does, implement the statement.  */
6214
6215 ffelexHandler
6216 ffestb_R544 (ffelexToken t)
6217 {
6218   switch (ffelex_token_type (ffesta_tokens[0]))
6219     {
6220     case FFELEX_typeNAME:
6221       if (ffesta_first_kw != FFESTR_firstEQUIVALENCE)
6222         goto bad_0;             /* :::::::::::::::::::: */
6223       break;
6224
6225     case FFELEX_typeNAMES:
6226       if (ffesta_first_kw != FFESTR_firstEQUIVALENCE)
6227         goto bad_0;             /* :::::::::::::::::::: */
6228       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlEQUIVALENCE)
6229         goto bad_0;             /* :::::::::::::::::::: */
6230       break;
6231
6232     default:
6233       goto bad_0;               /* :::::::::::::::::::: */
6234     }
6235
6236   switch (ffelex_token_type (t))
6237     {
6238     case FFELEX_typeOPEN_PAREN:
6239       break;
6240
6241     case FFELEX_typeEOS:
6242     case FFELEX_typeSEMICOLON:
6243     case FFELEX_typeCOMMA:
6244     case FFELEX_typeCOLONCOLON:
6245       ffesta_confirmed ();      /* Error, but clearly intended. */
6246       goto bad_1;               /* :::::::::::::::::::: */
6247
6248     default:
6249       goto bad_1;               /* :::::::::::::::::::: */
6250     }
6251
6252   ffestb_local_.equivalence.started = FALSE;
6253   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6254                                       FFEEXPR_contextEQUIVALENCE,
6255                                       (ffeexprCallback) ffestb_R5441_);
6256
6257 bad_0:                          /* :::::::::::::::::::: */
6258   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", ffesta_tokens[0]);
6259   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6260
6261 bad_1:                          /* :::::::::::::::::::: */
6262   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6263   return (ffelexHandler) ffelex_swallow_tokens (t,
6264                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6265 }
6266
6267 /* ffestb_R5441_ -- "EQUIVALENCE" OPEN_PAREN expr
6268
6269    (ffestb_R5441_)  // to expression handler
6270
6271    Make sure the next token is COMMA.  */
6272
6273 static ffelexHandler
6274 ffestb_R5441_ (ffelexToken ft, ffebld expr, ffelexToken t)
6275 {
6276   switch (ffelex_token_type (t))
6277     {
6278     case FFELEX_typeCOMMA:
6279       if (expr == NULL)
6280         break;
6281       ffestb_local_.equivalence.exprs = ffestt_exprlist_create ();
6282       ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
6283                               ffelex_token_use (ft));
6284       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6285                                           FFEEXPR_contextEQUIVALENCE,
6286                                           (ffeexprCallback) ffestb_R5442_);
6287
6288     default:
6289       break;
6290     }
6291
6292   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6293   if (ffestb_local_.equivalence.started)
6294     ffestc_R544_finish ();
6295   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6296 }
6297
6298 /* ffestb_R5442_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr
6299
6300    (ffestb_R5442_)  // to expression handler
6301
6302    Make sure the next token is COMMA or CLOSE_PAREN.  For COMMA, we just
6303    append the expression to our list and continue; for CLOSE_PAREN, we
6304    append the expression and move to _3_.  */
6305
6306 static ffelexHandler
6307 ffestb_R5442_ (ffelexToken ft, ffebld expr, ffelexToken t)
6308 {
6309   switch (ffelex_token_type (t))
6310     {
6311     case FFELEX_typeCOMMA:
6312       if (expr == NULL)
6313         break;
6314       ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
6315                               ffelex_token_use (ft));
6316       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6317                                           FFEEXPR_contextEQUIVALENCE,
6318                                           (ffeexprCallback) ffestb_R5442_);
6319
6320     case FFELEX_typeCLOSE_PAREN:
6321       if (expr == NULL)
6322         break;
6323       ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
6324                               ffelex_token_use (ft));
6325       return (ffelexHandler) ffestb_R5443_;
6326
6327     default:
6328       break;
6329     }
6330
6331   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6332   if (ffestb_local_.equivalence.started)
6333     ffestc_R544_finish ();
6334   ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6335   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6336 }
6337
6338 /* ffestb_R5443_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr CLOSE_PAREN
6339
6340    return ffestb_R5443_;  // to lexer
6341
6342    Make sure the next token is COMMA or EOS/SEMICOLON.  */
6343
6344 static ffelexHandler
6345 ffestb_R5443_ (ffelexToken t)
6346 {
6347   switch (ffelex_token_type (t))
6348     {
6349     case FFELEX_typeCOMMA:
6350       ffesta_confirmed ();
6351       if (!ffesta_is_inhibited ())
6352         {
6353           if (!ffestb_local_.equivalence.started)
6354             {
6355               ffestc_R544_start ();
6356               ffestb_local_.equivalence.started = TRUE;
6357             }
6358           ffestc_R544_item (ffestb_local_.equivalence.exprs);
6359         }
6360       ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6361       return (ffelexHandler) ffestb_R5444_;
6362
6363     case FFELEX_typeEOS:
6364     case FFELEX_typeSEMICOLON:
6365       ffesta_confirmed ();
6366       if (!ffesta_is_inhibited ())
6367         {
6368           if (!ffestb_local_.equivalence.started)
6369             {
6370               ffestc_R544_start ();
6371               ffestb_local_.equivalence.started = TRUE;
6372             }
6373           ffestc_R544_item (ffestb_local_.equivalence.exprs);
6374           ffestc_R544_finish ();
6375         }
6376       ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6377       return (ffelexHandler) ffesta_zero (t);
6378
6379     default:
6380       break;
6381     }
6382
6383   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6384   if (ffestb_local_.equivalence.started)
6385     ffestc_R544_finish ();
6386   ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
6387   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6388 }
6389
6390 /* ffestb_R5444_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr CLOSE_PAREN COMMA
6391
6392    return ffestb_R5444_;  // to lexer
6393
6394    Make sure the next token is OPEN_PAREN, or generate an error.  */
6395
6396 static ffelexHandler
6397 ffestb_R5444_ (ffelexToken t)
6398 {
6399   switch (ffelex_token_type (t))
6400     {
6401     case FFELEX_typeOPEN_PAREN:
6402       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
6403                                           FFEEXPR_contextEQUIVALENCE,
6404                                           (ffeexprCallback) ffestb_R5441_);
6405
6406     default:
6407       break;
6408     }
6409
6410   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
6411   if (ffestb_local_.equivalence.started)
6412     ffestc_R544_finish ();
6413   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6414 }
6415
6416 /* ffestb_R834 -- Parse the CYCLE statement
6417
6418    return ffestb_R834;  // to lexer
6419
6420    Make sure the statement has a valid form for the CYCLE statement.  If
6421    it does, implement the statement.  */
6422
6423 ffelexHandler
6424 ffestb_R834 (ffelexToken t)
6425 {
6426   ffeTokenLength i;
6427   unsigned const char *p;
6428
6429   switch (ffelex_token_type (ffesta_tokens[0]))
6430     {
6431     case FFELEX_typeNAME:
6432       if (ffesta_first_kw != FFESTR_firstCYCLE)
6433         goto bad_0;             /* :::::::::::::::::::: */
6434       switch (ffelex_token_type (t))
6435         {
6436         case FFELEX_typeCOMMA:
6437         case FFELEX_typeCOLONCOLON:
6438           ffesta_confirmed ();  /* Error, but clearly intended. */
6439           goto bad_1;           /* :::::::::::::::::::: */
6440
6441         default:
6442           goto bad_1;           /* :::::::::::::::::::: */
6443
6444         case FFELEX_typeNAME:
6445           ffesta_confirmed ();
6446           ffesta_tokens[1] = ffelex_token_use (t);
6447           return (ffelexHandler) ffestb_R8341_;
6448
6449         case FFELEX_typeEOS:
6450         case FFELEX_typeSEMICOLON:
6451           ffesta_confirmed ();
6452           ffesta_tokens[1] = NULL;
6453           return (ffelexHandler) ffestb_R8341_ (t);
6454         }
6455
6456     case FFELEX_typeNAMES:
6457       if (ffesta_first_kw != FFESTR_firstCYCLE)
6458         goto bad_0;             /* :::::::::::::::::::: */
6459       switch (ffelex_token_type (t))
6460         {
6461         default:
6462           goto bad_1;           /* :::::::::::::::::::: */
6463
6464         case FFELEX_typeEOS:
6465         case FFELEX_typeSEMICOLON:
6466           break;
6467         }
6468       ffesta_confirmed ();
6469       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCYCLE);
6470       if (*p == '\0')
6471         {
6472           ffesta_tokens[1] = NULL;
6473         }
6474       else
6475         {
6476           if (!ffesrc_is_name_init (*p))
6477             goto bad_i;         /* :::::::::::::::::::: */
6478           ffesta_tokens[1]
6479             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
6480         }
6481       return (ffelexHandler) ffestb_R8341_ (t);
6482
6483     default:
6484       goto bad_0;               /* :::::::::::::::::::: */
6485     }
6486
6487 bad_0:                          /* :::::::::::::::::::: */
6488   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", ffesta_tokens[0]);
6489   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6490
6491 bad_1:                          /* :::::::::::::::::::: */
6492   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", t);
6493   return (ffelexHandler) ffelex_swallow_tokens (t,
6494                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6495
6496 bad_i:                          /* :::::::::::::::::::: */
6497   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CYCLE", ffesta_tokens[0], i, t);
6498   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6499 }
6500
6501 /* ffestb_R8341_ -- "CYCLE" [NAME]
6502
6503    return ffestb_R8341_;  // to lexer
6504
6505    Make sure the next token is an EOS or SEMICOLON.  */
6506
6507 static ffelexHandler
6508 ffestb_R8341_ (ffelexToken t)
6509 {
6510   switch (ffelex_token_type (t))
6511     {
6512     case FFELEX_typeEOS:
6513     case FFELEX_typeSEMICOLON:
6514       ffesta_confirmed ();
6515       if (!ffesta_is_inhibited ())
6516         ffestc_R834 (ffesta_tokens[1]);
6517       if (ffesta_tokens[1] != NULL)
6518         ffelex_token_kill (ffesta_tokens[1]);
6519       return (ffelexHandler) ffesta_zero (t);
6520
6521     default:
6522       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", t);
6523       break;
6524     }
6525
6526   if (ffesta_tokens[1] != NULL)
6527     ffelex_token_kill (ffesta_tokens[1]);
6528   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6529 }
6530
6531 /* ffestb_R835 -- Parse the EXIT statement
6532
6533    return ffestb_R835;  // to lexer
6534
6535    Make sure the statement has a valid form for the EXIT statement.  If
6536    it does, implement the statement.  */
6537
6538 ffelexHandler
6539 ffestb_R835 (ffelexToken t)
6540 {
6541   ffeTokenLength i;
6542   unsigned const char *p;
6543
6544   switch (ffelex_token_type (ffesta_tokens[0]))
6545     {
6546     case FFELEX_typeNAME:
6547       if (ffesta_first_kw != FFESTR_firstEXIT)
6548         goto bad_0;             /* :::::::::::::::::::: */
6549       switch (ffelex_token_type (t))
6550         {
6551         case FFELEX_typeCOMMA:
6552         case FFELEX_typeCOLONCOLON:
6553           ffesta_confirmed ();  /* Error, but clearly intended. */
6554           goto bad_1;           /* :::::::::::::::::::: */
6555
6556         default:
6557           goto bad_1;           /* :::::::::::::::::::: */
6558
6559         case FFELEX_typeNAME:
6560           ffesta_confirmed ();
6561           ffesta_tokens[1] = ffelex_token_use (t);
6562           return (ffelexHandler) ffestb_R8351_;
6563
6564         case FFELEX_typeEOS:
6565         case FFELEX_typeSEMICOLON:
6566           ffesta_confirmed ();
6567           ffesta_tokens[1] = NULL;
6568           return (ffelexHandler) ffestb_R8351_ (t);
6569         }
6570
6571     case FFELEX_typeNAMES:
6572       if (ffesta_first_kw != FFESTR_firstEXIT)
6573         goto bad_0;             /* :::::::::::::::::::: */
6574       switch (ffelex_token_type (t))
6575         {
6576         default:
6577           goto bad_1;           /* :::::::::::::::::::: */
6578
6579         case FFELEX_typeEOS:
6580         case FFELEX_typeSEMICOLON:
6581           break;
6582         }
6583       ffesta_confirmed ();
6584       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlEXIT);
6585       if (*p == '\0')
6586         {
6587           ffesta_tokens[1] = NULL;
6588         }
6589       else
6590         {
6591           if (!ffesrc_is_name_init (*p))
6592             goto bad_i;         /* :::::::::::::::::::: */
6593           ffesta_tokens[1]
6594             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
6595         }
6596       return (ffelexHandler) ffestb_R8351_ (t);
6597
6598     default:
6599       goto bad_0;               /* :::::::::::::::::::: */
6600     }
6601
6602 bad_0:                          /* :::::::::::::::::::: */
6603   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", ffesta_tokens[0]);
6604   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6605
6606 bad_1:                          /* :::::::::::::::::::: */
6607   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", t);
6608   return (ffelexHandler) ffelex_swallow_tokens (t,
6609                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6610
6611 bad_i:                          /* :::::::::::::::::::: */
6612   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "EXIT", ffesta_tokens[0], i, t);
6613   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6614 }
6615
6616 /* ffestb_R8351_ -- "EXIT" [NAME]
6617
6618    return ffestb_R8351_;  // to lexer
6619
6620    Make sure the next token is an EOS or SEMICOLON.  */
6621
6622 static ffelexHandler
6623 ffestb_R8351_ (ffelexToken t)
6624 {
6625   switch (ffelex_token_type (t))
6626     {
6627     case FFELEX_typeEOS:
6628     case FFELEX_typeSEMICOLON:
6629       ffesta_confirmed ();
6630       if (!ffesta_is_inhibited ())
6631         ffestc_R835 (ffesta_tokens[1]);
6632       if (ffesta_tokens[1] != NULL)
6633         ffelex_token_kill (ffesta_tokens[1]);
6634       return (ffelexHandler) ffesta_zero (t);
6635
6636     default:
6637       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", t);
6638       break;
6639     }
6640
6641   if (ffesta_tokens[1] != NULL)
6642     ffelex_token_kill (ffesta_tokens[1]);
6643   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6644 }
6645
6646 /* ffestb_R838 -- Parse the ASSIGN statement
6647
6648    return ffestb_R838;  // to lexer
6649
6650    Make sure the statement has a valid form for the ASSIGN statement.  If it
6651    does, implement the statement.  */
6652
6653 ffelexHandler
6654 ffestb_R838 (ffelexToken t)
6655 {
6656   unsigned const char *p;
6657   ffeTokenLength i;
6658   ffelexHandler next;
6659   ffelexToken et;               /* First token in target. */
6660
6661   switch (ffelex_token_type (ffesta_tokens[0]))
6662     {
6663     case FFELEX_typeNAME:
6664       if (ffesta_first_kw != FFESTR_firstASSIGN)
6665         goto bad_0;             /* :::::::::::::::::::: */
6666       switch (ffelex_token_type (t))
6667         {
6668         case FFELEX_typeEOS:
6669         case FFELEX_typeSEMICOLON:
6670         case FFELEX_typeCOMMA:
6671         case FFELEX_typeCOLONCOLON:
6672           ffesta_confirmed ();  /* Error, but clearly intended. */
6673           goto bad_1;           /* :::::::::::::::::::: */
6674
6675         default:
6676           goto bad_1;           /* :::::::::::::::::::: */
6677
6678         case FFELEX_typeNUMBER:
6679           break;
6680         }
6681       ffesta_tokens[1] = ffelex_token_use (t);
6682       ffesta_confirmed ();
6683       return (ffelexHandler) ffestb_R8381_;
6684
6685     case FFELEX_typeNAMES:
6686       if (ffesta_first_kw != FFESTR_firstASSIGN)
6687         goto bad_0;             /* :::::::::::::::::::: */
6688
6689       switch (ffelex_token_type (t))
6690         {
6691         case FFELEX_typeEOS:
6692         case FFELEX_typeSEMICOLON:
6693           ffesta_confirmed ();
6694           /* Fall through. */
6695         case FFELEX_typePERCENT:
6696         case FFELEX_typeOPEN_PAREN:
6697           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlASSIGN);
6698           if (! ISDIGIT (*p))
6699             goto bad_i;         /* :::::::::::::::::::: */
6700           ffesta_tokens[1]
6701             = ffelex_token_number_from_names (ffesta_tokens[0], i);
6702           p += ffelex_token_length (ffesta_tokens[1]);  /* Skip to "TO". */
6703           i += ffelex_token_length (ffesta_tokens[1]);
6704           if (!ffesrc_char_match_init (*p, 'T', 't')    /* "TO". */
6705               || (++i, !ffesrc_char_match_noninit (*++p, 'O', 'o')))
6706             {
6707             bad_i_1:            /* :::::::::::::::::::: */
6708               ffelex_token_kill (ffesta_tokens[1]);
6709               goto bad_i;       /* :::::::::::::::::::: */
6710             }
6711           ++p, ++i;
6712           if (!ffesrc_is_name_init (*p))
6713             goto bad_i_1;       /* :::::::::::::::::::: */
6714           et = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
6715           next = (ffelexHandler)
6716             (*((ffelexHandler)
6717                ffeexpr_lhs (ffesta_output_pool,
6718                             FFEEXPR_contextASSIGN,
6719                             (ffeexprCallback)
6720                             ffestb_R8383_)))
6721             (et);
6722           ffelex_token_kill (et);
6723           return (ffelexHandler) (*next) (t);
6724
6725         case FFELEX_typeCOMMA:
6726         case FFELEX_typeCOLONCOLON:
6727           ffesta_confirmed ();  /* Error, but clearly intended. */
6728           goto bad_1;           /* :::::::::::::::::::: */
6729
6730         default:
6731           goto bad_1;           /* :::::::::::::::::::: */
6732         }
6733
6734     default:
6735       goto bad_0;               /* :::::::::::::::::::: */
6736     }
6737
6738 bad_0:                          /* :::::::::::::::::::: */
6739   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", ffesta_tokens[0]);
6740   return (ffelexHandler) ffelex_swallow_tokens (t,
6741                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
6742
6743 bad_1:                          /* :::::::::::::::::::: */
6744   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6745   return (ffelexHandler) ffelex_swallow_tokens (t,
6746                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6747
6748 bad_i:                          /* :::::::::::::::::::: */
6749   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ASSIGN", ffesta_tokens[0], i, t);
6750   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6751 }
6752
6753 /* ffestb_R8381_ -- "ASSIGN" NUMBER
6754
6755    return ffestb_R8381_;  // to lexer
6756
6757    Make sure the next token is "TO".  */
6758
6759 static ffelexHandler
6760 ffestb_R8381_ (ffelexToken t)
6761 {
6762   if ((ffelex_token_type (t) == FFELEX_typeNAME)
6763   && (ffesrc_strcmp_2c (ffe_case_match (), ffelex_token_text (t), "TO", "to",
6764                         "To") == 0))
6765     {
6766       return (ffelexHandler) ffestb_R8382_;
6767     }
6768
6769   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6770   if (ffelex_token_type (t) == FFELEX_typeNAME)
6771     return (ffelexHandler) ffestb_R8382_ (t);   /* Maybe user forgot "TO". */
6772
6773   ffelex_token_kill (ffesta_tokens[1]);
6774   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6775 }
6776
6777 /* ffestb_R8382_ -- "ASSIGN" NUMBER ("TO")
6778
6779    return ffestb_R8382_;  // to lexer
6780
6781    Make sure the next token is a name, then pass it along to the expression
6782    evaluator as an LHS expression.  The callback function is _3_.  */
6783
6784 static ffelexHandler
6785 ffestb_R8382_ (ffelexToken t)
6786 {
6787   if (ffelex_token_type (t) == FFELEX_typeNAME)
6788     {
6789       return (ffelexHandler)
6790       (*((ffelexHandler)
6791          ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextASSIGN,
6792                       (ffeexprCallback) ffestb_R8383_)))
6793       (t);
6794     }
6795
6796   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6797   ffelex_token_kill (ffesta_tokens[1]);
6798   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6799 }
6800
6801 /* ffestb_R8383_ -- "ASSIGN" NUMBER ("TO") expression
6802
6803    (ffestb_R8383_)  // to expression handler
6804
6805    Make sure the next token is an EOS or SEMICOLON.  */
6806
6807 static ffelexHandler
6808 ffestb_R8383_ (ffelexToken ft, ffebld expr, ffelexToken t)
6809 {
6810   switch (ffelex_token_type (t))
6811     {
6812     case FFELEX_typeEOS:
6813     case FFELEX_typeSEMICOLON:
6814       ffesta_confirmed ();
6815       if (expr == NULL)
6816         break;
6817       if (!ffesta_is_inhibited ())
6818         ffestc_R838 (ffesta_tokens[1], expr, ft);
6819       ffelex_token_kill (ffesta_tokens[1]);
6820       return (ffelexHandler) ffesta_zero (t);
6821
6822     default:
6823       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
6824       break;
6825     }
6826
6827   ffelex_token_kill (ffesta_tokens[1]);
6828   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6829 }
6830
6831 /* ffestb_R840 -- Parse an arithmetic-IF statement
6832
6833    return ffestb_R840;  // to lexer
6834
6835    Make sure the statement has a valid form for an arithmetic-IF statement.
6836    If it does, implement the statement.  */
6837
6838 ffelexHandler
6839 ffestb_R840 (ffelexToken t)
6840 {
6841   switch (ffelex_token_type (ffesta_tokens[0]))
6842     {
6843     case FFELEX_typeNAME:
6844       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlIF)
6845         goto bad_0;             /* :::::::::::::::::::: */
6846       if (ffesta_first_kw != FFESTR_firstIF)
6847         goto bad_0;             /* :::::::::::::::::::: */
6848       break;
6849
6850     case FFELEX_typeNAMES:
6851       if (ffesta_first_kw != FFESTR_firstIF)
6852         goto bad_0;             /* :::::::::::::::::::: */
6853       break;
6854
6855     default:
6856       goto bad_0;               /* :::::::::::::::::::: */
6857     }
6858
6859   switch (ffelex_token_type (t))
6860     {
6861     case FFELEX_typeOPEN_PAREN:
6862       break;
6863
6864     default:
6865       goto bad_1;               /* :::::::::::::::::::: */
6866     }
6867
6868   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextARITHIF,
6869                                       (ffeexprCallback) ffestb_R8401_);
6870
6871 bad_0:                          /* :::::::::::::::::::: */
6872   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", ffesta_tokens[0]);
6873   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6874
6875 bad_1:                          /* :::::::::::::::::::: */
6876   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6877   return (ffelexHandler) ffelex_swallow_tokens (t,
6878                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
6879 }
6880
6881 /* ffestb_R8401_ -- "IF" OPEN_PAREN expr
6882
6883    (ffestb_R8401_)  // to expression handler
6884
6885    Make sure the next token is CLOSE_PAREN.  */
6886
6887 static ffelexHandler
6888 ffestb_R8401_ (ffelexToken ft, ffebld expr, ffelexToken t)
6889 {
6890   ffestb_local_.if_stmt.expr = expr;
6891
6892   switch (ffelex_token_type (t))
6893     {
6894     case FFELEX_typeCLOSE_PAREN:
6895       if (expr == NULL)
6896         break;
6897       ffesta_tokens[1] = ffelex_token_use (ft);
6898       ffelex_set_names (TRUE);  /* In case it's a logical IF instead. */
6899       return (ffelexHandler) ffestb_R8402_;
6900
6901     default:
6902       break;
6903     }
6904
6905   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6906   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6907 }
6908
6909 /* ffestb_R8402_ -- "IF" OPEN_PAREN expr CLOSE_PAREN
6910
6911    return ffestb_R8402_;  // to lexer
6912
6913    Make sure the next token is NUMBER.  */
6914
6915 static ffelexHandler
6916 ffestb_R8402_ (ffelexToken t)
6917 {
6918   ffelex_set_names (FALSE);
6919
6920   switch (ffelex_token_type (t))
6921     {
6922     case FFELEX_typeNUMBER:
6923       ffesta_confirmed ();
6924       ffesta_tokens[2] = ffelex_token_use (t);
6925       return (ffelexHandler) ffestb_R8403_;
6926
6927     default:
6928       break;
6929     }
6930
6931   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6932   ffelex_token_kill (ffesta_tokens[1]);
6933   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6934 }
6935
6936 /* ffestb_R8403_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER
6937
6938    return ffestb_R8403_;  // to lexer
6939
6940    Make sure the next token is COMMA.  */
6941
6942 static ffelexHandler
6943 ffestb_R8403_ (ffelexToken t)
6944 {
6945   switch (ffelex_token_type (t))
6946     {
6947     case FFELEX_typeCOMMA:
6948       return (ffelexHandler) ffestb_R8404_;
6949
6950     default:
6951       break;
6952     }
6953
6954   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6955   ffelex_token_kill (ffesta_tokens[1]);
6956   ffelex_token_kill (ffesta_tokens[2]);
6957   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6958 }
6959
6960 /* ffestb_R8404_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA
6961
6962    return ffestb_R8404_;  // to lexer
6963
6964    Make sure the next token is NUMBER.  */
6965
6966 static ffelexHandler
6967 ffestb_R8404_ (ffelexToken t)
6968 {
6969   switch (ffelex_token_type (t))
6970     {
6971     case FFELEX_typeNUMBER:
6972       ffesta_tokens[3] = ffelex_token_use (t);
6973       return (ffelexHandler) ffestb_R8405_;
6974
6975     default:
6976       break;
6977     }
6978
6979   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
6980   ffelex_token_kill (ffesta_tokens[1]);
6981   ffelex_token_kill (ffesta_tokens[2]);
6982   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
6983 }
6984
6985 /* ffestb_R8405_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER
6986
6987    return ffestb_R8405_;  // to lexer
6988
6989    Make sure the next token is COMMA.  */
6990
6991 static ffelexHandler
6992 ffestb_R8405_ (ffelexToken t)
6993 {
6994   switch (ffelex_token_type (t))
6995     {
6996     case FFELEX_typeCOMMA:
6997       return (ffelexHandler) ffestb_R8406_;
6998
6999     default:
7000       break;
7001     }
7002
7003   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
7004   ffelex_token_kill (ffesta_tokens[1]);
7005   ffelex_token_kill (ffesta_tokens[2]);
7006   ffelex_token_kill (ffesta_tokens[3]);
7007   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7008 }
7009
7010 /* ffestb_R8406_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER COMMA
7011
7012    return ffestb_R8406_;  // to lexer
7013
7014    Make sure the next token is NUMBER.  */
7015
7016 static ffelexHandler
7017 ffestb_R8406_ (ffelexToken t)
7018 {
7019   switch (ffelex_token_type (t))
7020     {
7021     case FFELEX_typeNUMBER:
7022       ffesta_tokens[4] = ffelex_token_use (t);
7023       return (ffelexHandler) ffestb_R8407_;
7024
7025     default:
7026       break;
7027     }
7028
7029   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
7030   ffelex_token_kill (ffesta_tokens[1]);
7031   ffelex_token_kill (ffesta_tokens[2]);
7032   ffelex_token_kill (ffesta_tokens[3]);
7033   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7034 }
7035
7036 /* ffestb_R8407_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER COMMA
7037                     NUMBER
7038
7039    return ffestb_R8407_;  // to lexer
7040
7041    Make sure the next token is EOS or SEMICOLON.  */
7042
7043 static ffelexHandler
7044 ffestb_R8407_ (ffelexToken t)
7045 {
7046   switch (ffelex_token_type (t))
7047     {
7048     case FFELEX_typeEOS:
7049     case FFELEX_typeSEMICOLON:
7050       if (!ffesta_is_inhibited ())
7051         ffestc_R840 (ffestb_local_.if_stmt.expr, ffesta_tokens[1],
7052                      ffesta_tokens[2], ffesta_tokens[3], ffesta_tokens[4]);
7053       ffelex_token_kill (ffesta_tokens[1]);
7054       ffelex_token_kill (ffesta_tokens[2]);
7055       ffelex_token_kill (ffesta_tokens[3]);
7056       ffelex_token_kill (ffesta_tokens[4]);
7057       return (ffelexHandler) ffesta_zero (t);
7058
7059     default:
7060       break;
7061     }
7062
7063   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
7064   ffelex_token_kill (ffesta_tokens[1]);
7065   ffelex_token_kill (ffesta_tokens[2]);
7066   ffelex_token_kill (ffesta_tokens[3]);
7067   ffelex_token_kill (ffesta_tokens[4]);
7068   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7069 }
7070
7071 /* ffestb_R841 -- Parse the CONTINUE statement
7072
7073    return ffestb_R841;  // to lexer
7074
7075    Make sure the statement has a valid form for the CONTINUE statement.  If
7076    it does, implement the statement.  */
7077
7078 ffelexHandler
7079 ffestb_R841 (ffelexToken t)
7080 {
7081   const char *p;
7082   ffeTokenLength i;
7083
7084   switch (ffelex_token_type (ffesta_tokens[0]))
7085     {
7086     case FFELEX_typeNAME:
7087       if (ffesta_first_kw != FFESTR_firstCONTINUE)
7088         goto bad_0;             /* :::::::::::::::::::: */
7089       break;
7090
7091     case FFELEX_typeNAMES:
7092       if (ffesta_first_kw != FFESTR_firstCONTINUE)
7093         goto bad_0;             /* :::::::::::::::::::: */
7094       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCONTINUE)
7095         {
7096           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCONTINUE);
7097           goto bad_i;           /* :::::::::::::::::::: */
7098         }
7099       break;
7100
7101     default:
7102       goto bad_0;               /* :::::::::::::::::::: */
7103     }
7104
7105   switch (ffelex_token_type (t))
7106     {
7107     case FFELEX_typeEOS:
7108     case FFELEX_typeSEMICOLON:
7109       ffesta_confirmed ();
7110       if (!ffesta_is_inhibited ())
7111         ffestc_R841 ();
7112       return (ffelexHandler) ffesta_zero (t);
7113
7114     case FFELEX_typeCOMMA:
7115     case FFELEX_typeCOLONCOLON:
7116       ffesta_confirmed ();      /* Error, but clearly intended. */
7117       goto bad_1;               /* :::::::::::::::::::: */
7118
7119     default:
7120       goto bad_1;               /* :::::::::::::::::::: */
7121     }
7122
7123 bad_0:                          /* :::::::::::::::::::: */
7124   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTINUE", ffesta_tokens[0]);
7125   return (ffelexHandler) ffelex_swallow_tokens (t,
7126                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
7127
7128 bad_1:                          /* :::::::::::::::::::: */
7129   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTINUE", t);
7130   return (ffelexHandler) ffelex_swallow_tokens (t,
7131                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7132
7133 bad_i:                          /* :::::::::::::::::::: */
7134   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CONTINUE", ffesta_tokens[0], i, t);
7135   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7136 }
7137
7138 /* ffestb_R1102 -- Parse the PROGRAM statement
7139
7140    return ffestb_R1102;  // to lexer
7141
7142    Make sure the statement has a valid form for the PROGRAM statement.  If it
7143    does, implement the statement.  */
7144
7145 ffelexHandler
7146 ffestb_R1102 (ffelexToken t)
7147 {
7148   ffeTokenLength i;
7149   unsigned const char *p;
7150
7151   switch (ffelex_token_type (ffesta_tokens[0]))
7152     {
7153     case FFELEX_typeNAME:
7154       if (ffesta_first_kw != FFESTR_firstPROGRAM)
7155         goto bad_0;             /* :::::::::::::::::::: */
7156       switch (ffelex_token_type (t))
7157         {
7158         case FFELEX_typeEOS:
7159         case FFELEX_typeSEMICOLON:
7160         case FFELEX_typeCOMMA:
7161         case FFELEX_typeCOLONCOLON:
7162           ffesta_confirmed ();  /* Error, but clearly intended. */
7163           goto bad_1;           /* :::::::::::::::::::: */
7164
7165         default:
7166           goto bad_1;           /* :::::::::::::::::::: */
7167
7168         case FFELEX_typeNAME:
7169           break;
7170         }
7171
7172       ffesta_confirmed ();
7173       ffesta_tokens[1] = ffelex_token_use (t);
7174       return (ffelexHandler) ffestb_R11021_;
7175
7176     case FFELEX_typeNAMES:
7177       if (ffesta_first_kw != FFESTR_firstPROGRAM)
7178         goto bad_0;             /* :::::::::::::::::::: */
7179       switch (ffelex_token_type (t))
7180         {
7181         case FFELEX_typeCOMMA:
7182         case FFELEX_typeCOLONCOLON:
7183           ffesta_confirmed ();  /* Error, but clearly intended. */
7184           goto bad_1;           /* :::::::::::::::::::: */
7185
7186         default:
7187           goto bad_1;           /* :::::::::::::::::::: */
7188
7189         case FFELEX_typeEOS:
7190         case FFELEX_typeSEMICOLON:
7191           break;
7192         }
7193       ffesta_confirmed ();
7194       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlPROGRAM);
7195       if (!ffesrc_is_name_init (*p))
7196         goto bad_i;             /* :::::::::::::::::::: */
7197       ffesta_tokens[1]
7198         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
7199       return (ffelexHandler) ffestb_R11021_ (t);
7200
7201     default:
7202       goto bad_0;               /* :::::::::::::::::::: */
7203     }
7204
7205 bad_0:                          /* :::::::::::::::::::: */
7206   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", ffesta_tokens[0]);
7207   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7208
7209 bad_1:                          /* :::::::::::::::::::: */
7210   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", t);
7211   return (ffelexHandler) ffelex_swallow_tokens (t,
7212                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7213
7214 bad_i:                          /* :::::::::::::::::::: */
7215   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "PROGRAM", ffesta_tokens[0], i, t);
7216   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7217 }
7218
7219 /* ffestb_R11021_ -- "PROGRAM" NAME
7220
7221    return ffestb_R11021_;  // to lexer
7222
7223    Make sure the next token is an EOS or SEMICOLON.  */
7224
7225 static ffelexHandler
7226 ffestb_R11021_ (ffelexToken t)
7227 {
7228   switch (ffelex_token_type (t))
7229     {
7230     case FFELEX_typeEOS:
7231     case FFELEX_typeSEMICOLON:
7232       ffesta_confirmed ();
7233       if (!ffesta_is_inhibited ())
7234         ffestc_R1102 (ffesta_tokens[1]);
7235       ffelex_token_kill (ffesta_tokens[1]);
7236       return (ffelexHandler) ffesta_zero (t);
7237
7238     default:
7239       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", t);
7240       break;
7241     }
7242
7243   ffelex_token_kill (ffesta_tokens[1]);
7244   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7245 }
7246
7247 /* ffestb_block -- Parse the BLOCK DATA statement
7248
7249    return ffestb_block;  // to lexer
7250
7251    Make sure the statement has a valid form for the BLOCK DATA statement.  If
7252    it does, implement the statement.  */
7253
7254 ffelexHandler
7255 ffestb_block (ffelexToken t)
7256 {
7257   switch (ffelex_token_type (ffesta_tokens[0]))
7258     {
7259     case FFELEX_typeNAME:
7260       if (ffesta_first_kw != FFESTR_firstBLOCK)
7261         goto bad_0;             /* :::::::::::::::::::: */
7262       switch (ffelex_token_type (t))
7263         {
7264         default:
7265           goto bad_1;           /* :::::::::::::::::::: */
7266
7267         case FFELEX_typeNAME:
7268           if (ffesta_second_kw != FFESTR_secondDATA)
7269             goto bad_1;         /* :::::::::::::::::::: */
7270           break;
7271         }
7272
7273       ffesta_confirmed ();
7274       return (ffelexHandler) ffestb_R1111_1_;
7275
7276     default:
7277       goto bad_0;               /* :::::::::::::::::::: */
7278     }
7279
7280 bad_0:                          /* :::::::::::::::::::: */
7281   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0]);
7282   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7283
7284 bad_1:                          /* :::::::::::::::::::: */
7285   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7286   return (ffelexHandler) ffelex_swallow_tokens (t,
7287                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7288 }
7289
7290 /* ffestb_blockdata -- Parse the BLOCKDATA statement
7291
7292    return ffestb_blockdata;  // to lexer
7293
7294    Make sure the statement has a valid form for the BLOCKDATA statement.  If
7295    it does, implement the statement.  */
7296
7297 ffelexHandler
7298 ffestb_blockdata (ffelexToken t)
7299 {
7300   ffeTokenLength i;
7301   unsigned const char *p;
7302
7303   switch (ffelex_token_type (ffesta_tokens[0]))
7304     {
7305     case FFELEX_typeNAME:
7306       if (ffesta_first_kw != FFESTR_firstBLOCKDATA)
7307         goto bad_0;             /* :::::::::::::::::::: */
7308       switch (ffelex_token_type (t))
7309         {
7310         case FFELEX_typeCOMMA:
7311         case FFELEX_typeCOLONCOLON:
7312           ffesta_confirmed ();  /* Error, but clearly intended. */
7313           goto bad_1;           /* :::::::::::::::::::: */
7314
7315         default:
7316           goto bad_1;           /* :::::::::::::::::::: */
7317
7318         case FFELEX_typeNAME:
7319           ffesta_confirmed ();
7320           ffesta_tokens[1] = ffelex_token_use (t);
7321           return (ffelexHandler) ffestb_R1111_2_;
7322
7323         case FFELEX_typeEOS:
7324         case FFELEX_typeSEMICOLON:
7325           ffesta_confirmed ();
7326           ffesta_tokens[1] = NULL;
7327           return (ffelexHandler) ffestb_R1111_2_ (t);
7328         }
7329
7330     case FFELEX_typeNAMES:
7331       if (ffesta_first_kw != FFESTR_firstBLOCKDATA)
7332         goto bad_0;             /* :::::::::::::::::::: */
7333       switch (ffelex_token_type (t))
7334         {
7335         default:
7336           goto bad_1;           /* :::::::::::::::::::: */
7337
7338         case FFELEX_typeEOS:
7339         case FFELEX_typeSEMICOLON:
7340           break;
7341         }
7342       ffesta_confirmed ();
7343       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlBLOCKDATA);
7344       if (*p == '\0')
7345         {
7346           ffesta_tokens[1] = NULL;
7347         }
7348       else
7349         {
7350           if (!ffesrc_is_name_init (*p))
7351             goto bad_i;         /* :::::::::::::::::::: */
7352           ffesta_tokens[1]
7353             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
7354         }
7355       return (ffelexHandler) ffestb_R1111_2_ (t);
7356
7357     default:
7358       goto bad_0;               /* :::::::::::::::::::: */
7359     }
7360
7361 bad_0:                          /* :::::::::::::::::::: */
7362   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0]);
7363   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7364
7365 bad_1:                          /* :::::::::::::::::::: */
7366   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7367   return (ffelexHandler) ffelex_swallow_tokens (t,
7368                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7369
7370 bad_i:                          /* :::::::::::::::::::: */
7371   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0], i, t);
7372   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7373 }
7374
7375 /* ffestb_R1111_1_ -- "BLOCK" "DATA"
7376
7377    return ffestb_R1111_1_;  // to lexer
7378
7379    Make sure the next token is a NAME, EOS, or SEMICOLON token.  */
7380
7381 static ffelexHandler
7382 ffestb_R1111_1_ (ffelexToken t)
7383 {
7384   switch (ffelex_token_type (t))
7385     {
7386     case FFELEX_typeNAME:
7387       ffesta_tokens[1] = ffelex_token_use (t);
7388       return (ffelexHandler) ffestb_R1111_2_;
7389
7390     case FFELEX_typeEOS:
7391     case FFELEX_typeSEMICOLON:
7392       ffesta_tokens[1] = NULL;
7393       return (ffelexHandler) ffestb_R1111_2_ (t);
7394
7395     default:
7396       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7397       break;
7398     }
7399
7400   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7401 }
7402
7403 /* ffestb_R1111_2_ -- "BLOCK/DATA" NAME
7404
7405    return ffestb_R1111_2_;  // to lexer
7406
7407    Make sure the next token is an EOS or SEMICOLON.  */
7408
7409 static ffelexHandler
7410 ffestb_R1111_2_ (ffelexToken t)
7411 {
7412   switch (ffelex_token_type (t))
7413     {
7414     case FFELEX_typeEOS:
7415     case FFELEX_typeSEMICOLON:
7416       ffesta_confirmed ();
7417       if (!ffesta_is_inhibited ())
7418         ffestc_R1111 (ffesta_tokens[1]);
7419       if (ffesta_tokens[1] != NULL)
7420         ffelex_token_kill (ffesta_tokens[1]);
7421       return (ffelexHandler) ffesta_zero (t);
7422
7423     default:
7424       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
7425       break;
7426     }
7427
7428   if (ffesta_tokens[1] != NULL)
7429     ffelex_token_kill (ffesta_tokens[1]);
7430   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7431 }
7432
7433 /* ffestb_R1212 -- Parse the CALL statement
7434
7435    return ffestb_R1212;  // to lexer
7436
7437    Make sure the statement has a valid form for the CALL statement.  If it
7438    does, implement the statement.  */
7439
7440 ffelexHandler
7441 ffestb_R1212 (ffelexToken t)
7442 {
7443   ffeTokenLength i;
7444   unsigned const char *p;
7445   ffelexHandler next;
7446   ffelexToken nt;
7447
7448   switch (ffelex_token_type (ffesta_tokens[0]))
7449     {
7450     case FFELEX_typeNAME:
7451       if (ffesta_first_kw != FFESTR_firstCALL)
7452         goto bad_0;             /* :::::::::::::::::::: */
7453       switch (ffelex_token_type (t))
7454         {
7455         case FFELEX_typeEOS:
7456         case FFELEX_typeSEMICOLON:
7457         case FFELEX_typeCOMMA:
7458         case FFELEX_typeCOLONCOLON:
7459           ffesta_confirmed ();  /* Error, but clearly intended. */
7460           goto bad_1;           /* :::::::::::::::::::: */
7461
7462         default:
7463           goto bad_1;           /* :::::::::::::::::::: */
7464
7465         case FFELEX_typeNAME:
7466           break;
7467         }
7468       ffesta_confirmed ();
7469       return (ffelexHandler)
7470         (*((ffelexHandler)
7471            ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextSUBROUTINEREF,
7472                         (ffeexprCallback) ffestb_R12121_)))
7473         (t);
7474
7475     case FFELEX_typeNAMES:
7476       if (ffesta_first_kw != FFESTR_firstCALL)
7477         goto bad_0;             /* :::::::::::::::::::: */
7478       switch (ffelex_token_type (t))
7479         {
7480         case FFELEX_typeCOLONCOLON:
7481         case FFELEX_typeCOMMA:
7482           ffesta_confirmed ();  /* Error, but clearly intended. */
7483           goto bad_1;           /* :::::::::::::::::::: */
7484
7485         default:
7486           goto bad_1;           /* :::::::::::::::::::: */
7487
7488         case FFELEX_typeOPEN_PAREN:
7489           break;
7490
7491         case FFELEX_typeEOS:
7492         case FFELEX_typeSEMICOLON:
7493           ffesta_confirmed ();
7494           break;
7495         }
7496       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCALL);
7497       if (!ffesrc_is_name_init (*p))
7498         goto bad_i;             /* :::::::::::::::::::: */
7499       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
7500       next = (ffelexHandler)
7501         (*((ffelexHandler)
7502            ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextSUBROUTINEREF,
7503                         (ffeexprCallback) ffestb_R12121_)))
7504         (nt);
7505       ffelex_token_kill (nt);
7506       return (ffelexHandler) (*next) (t);
7507
7508     default:
7509       goto bad_0;               /* :::::::::::::::::::: */
7510     }
7511
7512 bad_0:                          /* :::::::::::::::::::: */
7513   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", ffesta_tokens[0]);
7514   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7515
7516 bad_1:                          /* :::::::::::::::::::: */
7517   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", t);
7518   return (ffelexHandler) ffelex_swallow_tokens (t,
7519                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7520
7521 bad_i:                          /* :::::::::::::::::::: */
7522   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CALL", ffesta_tokens[0], i, t);
7523   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7524 }
7525
7526 /* ffestb_R12121_ -- "CALL" expr
7527
7528    (ffestb_R12121_)  // to expression handler
7529
7530    Make sure the statement has a valid form for the CALL statement.  If it
7531    does, implement the statement.  */
7532
7533 static ffelexHandler
7534 ffestb_R12121_ (ffelexToken ft, ffebld expr, ffelexToken t)
7535 {
7536   switch (ffelex_token_type (t))
7537     {
7538     case FFELEX_typeEOS:
7539     case FFELEX_typeSEMICOLON:
7540       ffesta_confirmed ();
7541       if (expr == NULL)
7542         break;
7543       if (!ffesta_is_inhibited ())
7544         ffestc_R1212 (expr, ft);
7545       return (ffelexHandler) ffesta_zero (t);
7546
7547     default:
7548       break;
7549     }
7550
7551   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", t);
7552   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7553 }
7554
7555 /* ffestb_R1227 -- Parse the RETURN statement
7556
7557    return ffestb_R1227;  // to lexer
7558
7559    Make sure the statement has a valid form for the RETURN statement.  If it
7560    does, implement the statement.  */
7561
7562 ffelexHandler
7563 ffestb_R1227 (ffelexToken t)
7564 {
7565   ffelexHandler next;
7566
7567   switch (ffelex_token_type (ffesta_tokens[0]))
7568     {
7569     case FFELEX_typeNAME:
7570       if (ffesta_first_kw != FFESTR_firstRETURN)
7571         goto bad_0;             /* :::::::::::::::::::: */
7572       switch (ffelex_token_type (t))
7573         {
7574         case FFELEX_typeCOMMA:
7575         case FFELEX_typeCOLONCOLON:
7576           ffesta_confirmed ();  /* Error, but clearly intended. */
7577           goto bad_1;           /* :::::::::::::::::::: */
7578
7579         case FFELEX_typeEQUALS:
7580         case FFELEX_typePOINTS:
7581         case FFELEX_typeCOLON:
7582           goto bad_1;           /* :::::::::::::::::::: */
7583
7584         case FFELEX_typeEOS:
7585         case FFELEX_typeSEMICOLON:
7586         case FFELEX_typeNAME:
7587         case FFELEX_typeNUMBER:
7588           ffesta_confirmed ();
7589           break;
7590
7591         default:
7592           break;
7593         }
7594
7595       return (ffelexHandler) (*((ffelexHandler)
7596                      ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextRETURN,
7597                                   (ffeexprCallback) ffestb_R12271_)))
7598         (t);
7599
7600     case FFELEX_typeNAMES:
7601       if (ffesta_first_kw != FFESTR_firstRETURN)
7602         goto bad_0;             /* :::::::::::::::::::: */
7603       switch (ffelex_token_type (t))
7604         {
7605         case FFELEX_typeCOMMA:
7606         case FFELEX_typeCOLONCOLON:
7607           ffesta_confirmed ();  /* Error, but clearly intended. */
7608           goto bad_1;           /* :::::::::::::::::::: */
7609
7610         case FFELEX_typeEQUALS:
7611         case FFELEX_typePOINTS:
7612         case FFELEX_typeCOLON:
7613           goto bad_1;           /* :::::::::::::::::::: */
7614
7615         case FFELEX_typeEOS:
7616         case FFELEX_typeSEMICOLON:
7617           ffesta_confirmed ();
7618           break;
7619
7620         default:
7621           break;
7622         }
7623       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
7624                    FFEEXPR_contextRETURN, (ffeexprCallback) ffestb_R12271_);
7625       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
7626                                                    FFESTR_firstlRETURN);
7627       if (next == NULL)
7628         return (ffelexHandler) ffelex_swallow_tokens (t,
7629                                                (ffelexHandler) ffesta_zero);
7630       return (ffelexHandler) (*next) (t);
7631
7632     default:
7633       goto bad_0;               /* :::::::::::::::::::: */
7634     }
7635
7636 bad_0:                          /* :::::::::::::::::::: */
7637   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", ffesta_tokens[0]);
7638   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7639
7640 bad_1:                          /* :::::::::::::::::::: */
7641   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", t);
7642   return (ffelexHandler) ffelex_swallow_tokens (t,
7643                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7644 }
7645
7646 /* ffestb_R12271_ -- "RETURN" expr
7647
7648    (ffestb_R12271_)  // to expression handler
7649
7650    Make sure the next token is an EOS or SEMICOLON.  */
7651
7652 static ffelexHandler
7653 ffestb_R12271_ (ffelexToken ft, ffebld expr, ffelexToken t)
7654 {
7655   switch (ffelex_token_type (t))
7656     {
7657     case FFELEX_typeEOS:
7658     case FFELEX_typeSEMICOLON:
7659       ffesta_confirmed ();
7660       if (!ffesta_is_inhibited ())
7661         ffestc_R1227 (expr, ft);
7662       return (ffelexHandler) ffesta_zero (t);
7663
7664     default:
7665       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", t);
7666       break;
7667     }
7668
7669   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7670 }
7671
7672 /* ffestb_R1228 -- Parse the CONTAINS statement
7673
7674    return ffestb_R1228;  // to lexer
7675
7676    Make sure the statement has a valid form for the CONTAINS statement.  If
7677    it does, implement the statement.  */
7678
7679 #if FFESTR_F90
7680 ffelexHandler
7681 ffestb_R1228 (ffelexToken t)
7682 {
7683   const char *p;
7684   ffeTokenLength i;
7685
7686   switch (ffelex_token_type (ffesta_tokens[0]))
7687     {
7688     case FFELEX_typeNAME:
7689       if (ffesta_first_kw != FFESTR_firstCONTAINS)
7690         goto bad_0;             /* :::::::::::::::::::: */
7691       break;
7692
7693     case FFELEX_typeNAMES:
7694       if (ffesta_first_kw != FFESTR_firstCONTAINS)
7695         goto bad_0;             /* :::::::::::::::::::: */
7696       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCONTAINS)
7697         {
7698           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCONTAINS);
7699           goto bad_i;           /* :::::::::::::::::::: */
7700         }
7701       break;
7702
7703     default:
7704       goto bad_0;               /* :::::::::::::::::::: */
7705     }
7706
7707   switch (ffelex_token_type (t))
7708     {
7709     case FFELEX_typeEOS:
7710     case FFELEX_typeSEMICOLON:
7711       ffesta_confirmed ();
7712       if (!ffesta_is_inhibited ())
7713         ffestc_R1228 ();
7714       return (ffelexHandler) ffesta_zero (t);
7715
7716     case FFELEX_typeCOMMA:
7717     case FFELEX_typeCOLONCOLON:
7718       ffesta_confirmed ();      /* Error, but clearly intended. */
7719       goto bad_1;               /* :::::::::::::::::::: */
7720
7721     default:
7722       goto bad_1;               /* :::::::::::::::::::: */
7723     }
7724
7725 bad_0:                          /* :::::::::::::::::::: */
7726   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTAINS", ffesta_tokens[0]);
7727   return (ffelexHandler) ffelex_swallow_tokens (t,
7728                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
7729
7730 bad_1:                          /* :::::::::::::::::::: */
7731   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTAINS", t);
7732   return (ffelexHandler) ffelex_swallow_tokens (t,
7733                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7734
7735 bad_i:                          /* :::::::::::::::::::: */
7736   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CONTAINS", ffesta_tokens[0], i, t);
7737   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7738 }
7739
7740 #endif
7741 /* ffestb_V009 -- Parse the UNION statement
7742
7743    return ffestb_V009;  // to lexer
7744
7745    Make sure the statement has a valid form for the UNION statement.  If
7746    it does, implement the statement.  */
7747
7748 #if FFESTR_VXT
7749 ffelexHandler
7750 ffestb_V009 (ffelexToken t)
7751 {
7752   const char *p;
7753   ffeTokenLength i;
7754
7755   switch (ffelex_token_type (ffesta_tokens[0]))
7756     {
7757     case FFELEX_typeNAME:
7758       if (ffesta_first_kw != FFESTR_firstUNION)
7759         goto bad_0;             /* :::::::::::::::::::: */
7760       break;
7761
7762     case FFELEX_typeNAMES:
7763       if (ffesta_first_kw != FFESTR_firstUNION)
7764         goto bad_0;             /* :::::::::::::::::::: */
7765       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlUNION)
7766         {
7767           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlUNION);
7768           goto bad_i;           /* :::::::::::::::::::: */
7769         }
7770       break;
7771
7772     default:
7773       goto bad_0;               /* :::::::::::::::::::: */
7774     }
7775
7776   switch (ffelex_token_type (t))
7777     {
7778     case FFELEX_typeEOS:
7779     case FFELEX_typeSEMICOLON:
7780       ffesta_confirmed ();
7781       if (!ffesta_is_inhibited ())
7782         ffestc_V009 ();
7783       return (ffelexHandler) ffesta_zero (t);
7784
7785     case FFELEX_typeCOMMA:
7786     case FFELEX_typeCOLONCOLON:
7787       ffesta_confirmed ();      /* Error, but clearly intended. */
7788       goto bad_1;               /* :::::::::::::::::::: */
7789
7790     default:
7791       goto bad_1;               /* :::::::::::::::::::: */
7792     }
7793
7794 bad_0:                          /* :::::::::::::::::::: */
7795   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "UNION", ffesta_tokens[0]);
7796   return (ffelexHandler) ffelex_swallow_tokens (t,
7797                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
7798
7799 bad_1:                          /* :::::::::::::::::::: */
7800   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "UNION", t);
7801   return (ffelexHandler) ffelex_swallow_tokens (t,
7802                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7803
7804 bad_i:                          /* :::::::::::::::::::: */
7805   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "UNION", ffesta_tokens[0], i, t);
7806   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7807 }
7808
7809 #endif
7810 /* ffestb_construct -- Parse a construct name
7811
7812    return ffestb_construct;  // to lexer
7813
7814    Make sure the statement can have a construct name (if-then-stmt, do-stmt,
7815    select-case-stmt).  */
7816
7817 ffelexHandler
7818 ffestb_construct (ffelexToken t UNUSED)
7819 {
7820   /* This handler gets invoked only when token 0 is NAME/NAMES and token 1 is
7821      COLON. */
7822
7823   ffesta_confirmed ();
7824   ffelex_set_names (TRUE);
7825   return (ffelexHandler) ffestb_construct1_;
7826 }
7827
7828 /* ffestb_construct1_ -- NAME COLON
7829
7830    return ffestb_construct1_;  // to lexer
7831
7832    Make sure we've got a NAME that is DO, DOWHILE, IF, SELECT, or SELECTCASE.  */
7833
7834 static ffelexHandler
7835 ffestb_construct1_ (ffelexToken t)
7836 {
7837   ffelex_set_names (FALSE);
7838
7839   switch (ffelex_token_type (t))
7840     {
7841     case FFELEX_typeNAME:
7842       ffesta_first_kw = ffestr_first (t);
7843       switch (ffesta_first_kw)
7844         {
7845         case FFESTR_firstIF:
7846           ffestb_local_.construct.next = (ffelexHandler) ffestb_if;
7847           break;
7848
7849         case FFESTR_firstDO:
7850           ffestb_local_.construct.next = (ffelexHandler) ffestb_do;
7851           break;
7852
7853         case FFESTR_firstDOWHILE:
7854           ffestb_local_.construct.next = (ffelexHandler) ffestb_dowhile;
7855           break;
7856
7857         case FFESTR_firstSELECT:
7858         case FFESTR_firstSELECTCASE:
7859           ffestb_local_.construct.next = (ffelexHandler) ffestb_R809;
7860           break;
7861
7862         default:
7863           goto bad;             /* :::::::::::::::::::: */
7864         }
7865       ffesta_construct_name = ffesta_tokens[0];
7866       ffesta_tokens[0] = ffelex_token_use (t);
7867       return (ffelexHandler) ffestb_construct2_;
7868
7869     case FFELEX_typeNAMES:
7870       ffesta_first_kw = ffestr_first (t);
7871       switch (ffesta_first_kw)
7872         {
7873         case FFESTR_firstIF:
7874           if (ffelex_token_length (t) != FFESTR_firstlIF)
7875             goto bad;           /* :::::::::::::::::::: */
7876           ffestb_local_.construct.next = (ffelexHandler) ffestb_if;
7877           break;
7878
7879         case FFESTR_firstDO:
7880           ffestb_local_.construct.next = (ffelexHandler) ffestb_do;
7881           break;
7882
7883         case FFESTR_firstDOWHILE:
7884           if (ffelex_token_length (t) != FFESTR_firstlDOWHILE)
7885             goto bad;           /* :::::::::::::::::::: */
7886           ffestb_local_.construct.next = (ffelexHandler) ffestb_dowhile;
7887           break;
7888
7889         case FFESTR_firstSELECTCASE:
7890           if (ffelex_token_length (t) != FFESTR_firstlSELECTCASE)
7891             goto bad;           /* :::::::::::::::::::: */
7892           ffestb_local_.construct.next = (ffelexHandler) ffestb_R809;
7893           break;
7894
7895         default:
7896           goto bad;             /* :::::::::::::::::::: */
7897         }
7898       ffesta_construct_name = ffesta_tokens[0];
7899       ffesta_tokens[0] = ffelex_token_use (t);
7900       return (ffelexHandler) ffestb_construct2_;
7901
7902     default:
7903       break;
7904     }
7905
7906 bad:                            /* :::::::::::::::::::: */
7907   ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
7908                      ffesta_tokens[0], t);
7909   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7910 }
7911
7912 /* ffestb_construct2_ -- NAME COLON "DO/DOWHILE/IF/SELECT/SELECTCASE"
7913
7914    return ffestb_construct2_;  // to lexer
7915
7916    This extra step is needed to set ffesta_second_kw if the second token
7917    (here) is a NAME, so DO and SELECT can continue to expect it.  */
7918
7919 static ffelexHandler
7920 ffestb_construct2_ (ffelexToken t)
7921 {
7922   if (ffelex_token_type (t) == FFELEX_typeNAME)
7923     ffesta_second_kw = ffestr_second (t);
7924   return (ffelexHandler) (*ffestb_local_.construct.next) (t);
7925 }
7926
7927 /* ffestb_heap -- Parse an ALLOCATE/DEALLOCATE statement
7928
7929    return ffestb_heap;  // to lexer
7930
7931    Make sure the statement has a valid form for an ALLOCATE/DEALLOCATE
7932    statement.  If it does, implement the statement.  */
7933
7934 #if FFESTR_F90
7935 ffelexHandler
7936 ffestb_heap (ffelexToken t)
7937 {
7938   switch (ffelex_token_type (ffesta_tokens[0]))
7939     {
7940     case FFELEX_typeNAME:
7941       break;
7942
7943     case FFELEX_typeNAMES:
7944       if (ffelex_token_length (ffesta_tokens[0]) != ffestb_args.heap.len)
7945         goto bad_0;             /* :::::::::::::::::::: */
7946       break;
7947
7948     default:
7949       goto bad_0;               /* :::::::::::::::::::: */
7950     }
7951
7952   switch (ffelex_token_type (t))
7953     {
7954     case FFELEX_typeOPEN_PAREN:
7955       break;
7956
7957     case FFELEX_typeEOS:
7958     case FFELEX_typeSEMICOLON:
7959     case FFELEX_typeCOMMA:
7960     case FFELEX_typeCOLONCOLON:
7961       ffesta_confirmed ();      /* Error, but clearly intended. */
7962       goto bad_1;               /* :::::::::::::::::::: */
7963
7964     default:
7965       goto bad_1;               /* :::::::::::::::::::: */
7966     }
7967
7968   ffestb_local_.heap.exprs = ffestt_exprlist_create ();
7969   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
7970                                       ffestb_args.heap.ctx,
7971                                       (ffeexprCallback) ffestb_heap1_);
7972
7973 bad_0:                          /* :::::::::::::::::::: */
7974   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, ffesta_tokens[0]);
7975   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
7976
7977 bad_1:                          /* :::::::::::::::::::: */
7978   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
7979   return (ffelexHandler) ffelex_swallow_tokens (t,
7980                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
7981 }
7982
7983 /* ffestb_heap1_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr
7984
7985    (ffestb_heap1_)  // to expression handler
7986
7987    Make sure the next token is COMMA.  */
7988
7989 static ffelexHandler
7990 ffestb_heap1_ (ffelexToken ft, ffebld expr, ffelexToken t)
7991 {
7992   switch (ffelex_token_type (t))
7993     {
7994     case FFELEX_typeCOMMA:
7995       if (expr == NULL)
7996         break;
7997       ffestt_exprlist_append (ffestb_local_.heap.exprs, expr,
7998                               ffelex_token_use (t));
7999       return (ffelexHandler) ffestb_heap2_;
8000
8001     case FFELEX_typeCLOSE_PAREN:
8002       if (expr == NULL)
8003         break;
8004       ffestt_exprlist_append (ffestb_local_.heap.exprs, expr,
8005                               ffelex_token_use (t));
8006       ffesta_tokens[1] = NULL;
8007       ffestb_local_.heap.expr = NULL;
8008       return (ffelexHandler) ffestb_heap5_;
8009
8010     default:
8011       break;
8012     }
8013
8014   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8015   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8016   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8017 }
8018
8019 /* ffestb_heap2_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr COMMA
8020
8021    return ffestb_heap2_;  // to lexer
8022
8023    Make sure the next token is NAME.  */
8024
8025 static ffelexHandler
8026 ffestb_heap2_ (ffelexToken t)
8027 {
8028   switch (ffelex_token_type (t))
8029     {
8030     case FFELEX_typeNAME:
8031       ffesta_tokens[1] = ffelex_token_use (t);
8032       return (ffelexHandler) ffestb_heap3_;
8033
8034     default:
8035       break;
8036     }
8037
8038   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8039   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8040   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8041 }
8042
8043 /* ffestb_heap3_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr COMMA NAME
8044
8045    return ffestb_heap3_;  // to lexer
8046
8047    If token is EQUALS, make sure NAME was "STAT" and handle STAT variable;
8048    else pass NAME and token to expression handler.  */
8049
8050 static ffelexHandler
8051 ffestb_heap3_ (ffelexToken t)
8052 {
8053   ffelexHandler next;
8054
8055   switch (ffelex_token_type (t))
8056     {
8057     case FFELEX_typeEQUALS:
8058       ffesta_confirmed ();
8059       if (ffestr_other (ffesta_tokens[1]) != FFESTR_otherSTAT)
8060         break;
8061       ffelex_token_kill (ffesta_tokens[1]);
8062       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
8063                                           FFEEXPR_contextHEAPSTAT,
8064                                           (ffeexprCallback) ffestb_heap4_);
8065
8066     default:
8067       next = (ffelexHandler)
8068         (*((ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
8069                                         ffestb_args.heap.ctx,
8070                                         (ffeexprCallback) ffestb_heap1_)))
8071         (ffesta_tokens[1]);
8072       ffelex_token_kill (ffesta_tokens[1]);
8073       return (ffelexHandler) (*next) (t);
8074     }
8075
8076   ffelex_token_kill (ffesta_tokens[1]);
8077   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8078   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8079   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8080 }
8081
8082 /* ffestb_heap4_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN ... COMMA "STAT" EQUALS
8083                     expr
8084
8085    (ffestb_heap4_)  // to expression handler
8086
8087    Make sure the next token is CLOSE_PAREN.  */
8088
8089 static ffelexHandler
8090 ffestb_heap4_ (ffelexToken ft, ffebld expr, ffelexToken t)
8091 {
8092   switch (ffelex_token_type (t))
8093     {
8094     case FFELEX_typeCLOSE_PAREN:
8095       if (expr == NULL)
8096         break;
8097       ffesta_tokens[1] = ffelex_token_use (ft);
8098       ffestb_local_.heap.expr = expr;
8099       return (ffelexHandler) ffestb_heap5_;
8100
8101     default:
8102       break;
8103     }
8104
8105   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8106   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8107   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8108 }
8109
8110 /* ffestb_heap5_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN ... CLOSE_PAREN
8111
8112    return ffestb_heap5_;  // to lexer
8113
8114    Make sure the next token is EOS/SEMICOLON.  */
8115
8116 static ffelexHandler
8117 ffestb_heap5_ (ffelexToken t)
8118 {
8119   switch (ffelex_token_type (t))
8120     {
8121     case FFELEX_typeEOS:
8122     case FFELEX_typeSEMICOLON:
8123       ffesta_confirmed ();
8124       if (!ffesta_is_inhibited ())
8125         if (ffesta_first_kw == FFESTR_firstALLOCATE)
8126           ffestc_R620 (ffestb_local_.heap.exprs, ffestb_local_.heap.expr,
8127                        ffesta_tokens[1]);
8128         else
8129           ffestc_R625 (ffestb_local_.heap.exprs, ffestb_local_.heap.expr,
8130                        ffesta_tokens[1]);
8131       ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8132       if (ffesta_tokens[1] != NULL)
8133         ffelex_token_kill (ffesta_tokens[1]);
8134       return (ffelexHandler) ffesta_zero (t);
8135
8136     default:
8137       break;
8138     }
8139
8140   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
8141   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
8142   if (ffesta_tokens[1] != NULL)
8143     ffelex_token_kill (ffesta_tokens[1]);
8144   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8145 }
8146
8147 #endif
8148 /* ffestb_module -- Parse the MODULEPROCEDURE statement
8149
8150    return ffestb_module;  // to lexer
8151
8152    Make sure the statement has a valid form for the MODULEPROCEDURE statement.
8153    If it does, implement the statement.
8154
8155    31-May-90  JCB  1.1
8156       Confirm NAME==MODULE followed by standard four invalid tokens, so we
8157       get decent message if somebody forgets that MODULE requires a name.  */
8158
8159 #if FFESTR_F90
8160 ffelexHandler
8161 ffestb_module (ffelexToken t)
8162 {
8163   ffeTokenLength i;
8164   const char *p;
8165   ffelexToken nt;
8166   ffelexToken mt;               /* Name in MODULE PROCEDUREname, i.e.
8167                                    includes "PROCEDURE". */
8168
8169   switch (ffelex_token_type (ffesta_tokens[0]))
8170     {
8171     case FFELEX_typeNAME:
8172       if (ffesta_first_kw != FFESTR_firstMODULE)
8173         goto bad_0;             /* :::::::::::::::::::: */
8174       switch (ffelex_token_type (t))
8175         {
8176         case FFELEX_typeNAME:
8177           break;
8178
8179         case FFELEX_typeCOLONCOLON:
8180         case FFELEX_typeCOMMA:
8181         case FFELEX_typeEOS:
8182         case FFELEX_typeSEMICOLON:
8183           ffesta_confirmed ();
8184           goto bad_1m;          /* :::::::::::::::::::: */
8185
8186         default:
8187           goto bad_1m;          /* :::::::::::::::::::: */
8188         }
8189
8190       ffesta_confirmed ();
8191       if (ffesta_second_kw != FFESTR_secondPROCEDURE)
8192         {
8193           ffesta_tokens[1] = ffelex_token_use (t);
8194           return (ffelexHandler) ffestb_module3_;
8195         }
8196       ffestb_local_.moduleprocedure.started = FALSE;
8197       ffesta_tokens[1] = ffelex_token_use (t);
8198       return (ffelexHandler) ffestb_module1_;
8199
8200     case FFELEX_typeNAMES:
8201       p = ffelex_token_text (ffesta_tokens[0])
8202         + (i = FFESTR_firstlMODULEPROCEDURE);
8203       if ((ffesta_first_kw == FFESTR_firstMODULE)
8204           || ((ffesta_first_kw == FFESTR_firstMODULEPROCEDURE)
8205               && !ffesrc_is_name_init (*p)))
8206         {                       /* Definitely not "MODULE PROCEDURE name". */
8207           switch (ffelex_token_type (t))
8208             {
8209             case FFELEX_typeCOMMA:
8210             case FFELEX_typeCOLONCOLON:
8211               ffesta_confirmed ();      /* Error, but clearly intended. */
8212               goto bad_1m;      /* :::::::::::::::::::: */
8213
8214             default:
8215               goto bad_1m;      /* :::::::::::::::::::: */
8216
8217             case FFELEX_typeEOS:
8218             case FFELEX_typeSEMICOLON:
8219               ffesta_confirmed ();
8220               break;
8221             }
8222           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlMODULE);
8223           if (!ffesrc_is_name_init (*p))
8224             goto bad_im;        /* :::::::::::::::::::: */
8225           nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
8226           if (!ffesta_is_inhibited ())
8227             ffestc_R1105 (nt);
8228           ffelex_token_kill (nt);
8229           return (ffelexHandler) ffesta_zero (t);
8230         }
8231
8232       /* Here we know that we're indeed looking at a MODULEPROCEDURE
8233          statement rather than MODULE and that the character following
8234          MODULEPROCEDURE in the NAMES token is a valid first character for a
8235          NAME.  This means that unless the second token is COMMA, we have an
8236          ambiguous statement that can be read either as MODULE PROCEDURE name
8237          or MODULE PROCEDUREname, the former being an R1205, the latter an
8238          R1105. */
8239
8240       if (ffesta_first_kw != FFESTR_firstMODULEPROCEDURE)
8241         goto bad_0;             /* :::::::::::::::::::: */
8242       switch (ffelex_token_type (t))
8243         {
8244         case FFELEX_typeCOLONCOLON:
8245           ffesta_confirmed ();  /* Error, but clearly intended. */
8246           goto bad_1;           /* :::::::::::::::::::: */
8247
8248         default:
8249           goto bad_1;           /* :::::::::::::::::::: */
8250
8251         case FFELEX_typeCOMMA:  /* Aha, clearly not MODULE PROCEDUREname. */
8252           ffesta_confirmed ();
8253           ffestb_local_.moduleprocedure.started = FALSE;
8254           ffesta_tokens[1]
8255             = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
8256           return (ffelexHandler) ffestb_module2_ (t);
8257
8258         case FFELEX_typeEOS:    /* MODULE PROCEDURE name or MODULE
8259                                    PROCEDUREname. */
8260         case FFELEX_typeSEMICOLON:
8261           ffesta_confirmed ();
8262           break;
8263         }
8264       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
8265       mt = ffelex_token_name_from_names (ffesta_tokens[0], FFESTR_firstlMODULE,
8266                                          0);
8267       if (!ffesta_is_inhibited ())
8268         ffestc_module (mt, nt); /* Implement ambiguous statement. */
8269       ffelex_token_kill (nt);
8270       ffelex_token_kill (mt);
8271       return (ffelexHandler) ffesta_zero (t);
8272
8273     default:
8274       goto bad_0;               /* :::::::::::::::::::: */
8275     }
8276
8277 bad_0:                          /* :::::::::::::::::::: */
8278   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", ffesta_tokens[0]);
8279   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8280
8281 bad_1:                          /* :::::::::::::::::::: */
8282   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
8283   return (ffelexHandler) ffelex_swallow_tokens (t,
8284                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
8285
8286 bad_1m:                 /* :::::::::::::::::::: */
8287   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE", t);
8288   return (ffelexHandler) ffelex_swallow_tokens (t,
8289                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
8290
8291 bad_im:                 /* :::::::::::::::::::: */
8292   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "MODULE", ffesta_tokens[0], i, t);
8293   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8294 }
8295
8296 /* ffestb_module1_ -- "MODULEPROCEDURE" or "MODULE" "PROCEDURE"
8297
8298    return ffestb_module1_;  // to lexer
8299
8300    Make sure the statement has a valid form for the MODULEPROCEDURE statement.  If it
8301    does, implement the statement.  */
8302
8303 static ffelexHandler
8304 ffestb_module1_ (ffelexToken t)
8305 {
8306   switch (ffelex_token_type (t))
8307     {
8308     case FFELEX_typeNAME:
8309       if (!ffestb_local_.moduleprocedure.started
8310           && (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME))
8311         {
8312           ffesta_confirmed ();
8313           ffelex_token_kill (ffesta_tokens[1]);
8314         }
8315       ffesta_tokens[1] = ffelex_token_use (t);
8316       return (ffelexHandler) ffestb_module2_;
8317
8318     case FFELEX_typeEOS:
8319     case FFELEX_typeSEMICOLON:
8320       if (ffestb_local_.moduleprocedure.started)
8321         break;                  /* Error if we've already seen NAME COMMA. */
8322       ffesta_confirmed ();
8323       if (!ffesta_is_inhibited ())
8324         ffestc_R1105 (ffesta_tokens[1]);
8325       ffelex_token_kill (ffesta_tokens[1]);
8326       return (ffelexHandler) ffesta_zero (t);
8327
8328     case FFELEX_typeCOMMA:
8329     case FFELEX_typeCOLONCOLON:
8330       ffesta_confirmed ();      /* Error, but clearly intended. */
8331       break;
8332
8333     default:
8334       break;
8335     }
8336
8337   if (ffestb_local_.moduleprocedure.started && !ffesta_is_inhibited ())
8338     ffestc_R1205_finish ();
8339   else if (!ffestb_local_.moduleprocedure.started)
8340     ffelex_token_kill (ffesta_tokens[1]);
8341   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
8342   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8343 }
8344
8345 /* ffestb_module2_ -- "MODULE/PROCEDURE" NAME
8346
8347    return ffestb_module2_;  // to lexer
8348
8349    Make sure the statement has a valid form for the MODULEPROCEDURE statement.  If it
8350    does, implement the statement.  */
8351
8352 static ffelexHandler
8353 ffestb_module2_ (ffelexToken t)
8354 {
8355   switch (ffelex_token_type (t))
8356     {
8357     case FFELEX_typeEOS:
8358     case FFELEX_typeSEMICOLON:
8359       if (!ffestb_local_.moduleprocedure.started)
8360         {
8361           ffesta_confirmed ();
8362           if (!ffesta_is_inhibited ())
8363             ffestc_R1205_start ();
8364         }
8365       if (!ffesta_is_inhibited ())
8366         {
8367           ffestc_R1205_item (ffesta_tokens[1]);
8368           ffestc_R1205_finish ();
8369         }
8370       ffelex_token_kill (ffesta_tokens[1]);
8371       return (ffelexHandler) ffesta_zero (t);
8372
8373     case FFELEX_typeCOMMA:
8374       if (!ffestb_local_.moduleprocedure.started)
8375         {
8376           ffestb_local_.moduleprocedure.started = TRUE;
8377           ffesta_confirmed ();
8378           if (!ffesta_is_inhibited ())
8379             ffestc_R1205_start ();
8380         }
8381       if (!ffesta_is_inhibited ())
8382         ffestc_R1205_item (ffesta_tokens[1]);
8383       ffelex_token_kill (ffesta_tokens[1]);
8384       return (ffelexHandler) ffestb_module1_;
8385
8386     default:
8387       break;
8388     }
8389
8390   if (ffestb_local_.moduleprocedure.started && !ffesta_is_inhibited ())
8391     ffestc_R1205_finish ();
8392   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
8393   ffelex_token_kill (ffesta_tokens[1]);
8394   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8395 }
8396
8397 /* ffestb_module3_ -- "MODULE" NAME
8398
8399    return ffestb_module3_;  // to lexer
8400
8401    Make sure the statement has a valid form for the MODULE statement.  If it
8402    does, implement the statement.  */
8403
8404 static ffelexHandler
8405 ffestb_module3_ (ffelexToken t)
8406 {
8407   switch (ffelex_token_type (t))
8408     {
8409     case FFELEX_typeEOS:
8410     case FFELEX_typeSEMICOLON:
8411       if (!ffesta_is_inhibited ())
8412         ffestc_R1105 (ffesta_tokens[1]);
8413       ffelex_token_kill (ffesta_tokens[1]);
8414       return (ffelexHandler) ffesta_zero (t);
8415
8416     default:
8417       break;
8418     }
8419
8420   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE", t);
8421   ffelex_token_kill (ffesta_tokens[1]);
8422   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8423 }
8424
8425 #endif
8426 /* ffestb_R809 -- Parse the SELECTCASE statement
8427
8428    return ffestb_R809;  // to lexer
8429
8430    Make sure the statement has a valid form for the SELECTCASE statement.
8431    If it does, implement the statement.  */
8432
8433 ffelexHandler
8434 ffestb_R809 (ffelexToken t)
8435 {
8436   ffeTokenLength i;
8437   const char *p;
8438
8439   switch (ffelex_token_type (ffesta_tokens[0]))
8440     {
8441     case FFELEX_typeNAME:
8442       switch (ffesta_first_kw)
8443         {
8444         case FFESTR_firstSELECT:
8445           if ((ffelex_token_type (t) != FFELEX_typeNAME)
8446               || (ffesta_second_kw != FFESTR_secondCASE))
8447             goto bad_1;         /* :::::::::::::::::::: */
8448           ffesta_confirmed ();
8449           return (ffelexHandler) ffestb_R8091_;
8450
8451         case FFESTR_firstSELECTCASE:
8452           return (ffelexHandler) ffestb_R8091_ (t);
8453
8454         default:
8455           goto bad_0;           /* :::::::::::::::::::: */
8456         }
8457
8458     case FFELEX_typeNAMES:
8459       if (ffesta_first_kw != FFESTR_firstSELECTCASE)
8460         goto bad_0;             /* :::::::::::::::::::: */
8461       switch (ffelex_token_type (t))
8462         {
8463         case FFELEX_typeCOMMA:
8464         case FFELEX_typeEOS:
8465         case FFELEX_typeSEMICOLON:
8466         case FFELEX_typeCOLONCOLON:
8467           ffesta_confirmed ();  /* Error, but clearly intended. */
8468           goto bad_1;           /* :::::::::::::::::::: */
8469
8470         default:
8471           goto bad_1;           /* :::::::::::::::::::: */
8472
8473         case FFELEX_typeOPEN_PAREN:
8474           break;
8475         }
8476       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSELECTCASE);
8477       if (*p != '\0')
8478         goto bad_i;             /* :::::::::::::::::::: */
8479       return (ffelexHandler) ffestb_R8091_ (t);
8480
8481     default:
8482       goto bad_0;               /* :::::::::::::::::::: */
8483     }
8484
8485 bad_0:                          /* :::::::::::::::::::: */
8486   if (ffesta_construct_name != NULL)
8487     {
8488       ffelex_token_kill (ffesta_construct_name);
8489       ffesta_construct_name = NULL;
8490     }
8491   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", ffesta_tokens[0]);
8492   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8493
8494 bad_1:                          /* :::::::::::::::::::: */
8495   if (ffesta_construct_name != NULL)
8496     {
8497       ffelex_token_kill (ffesta_construct_name);
8498       ffesta_construct_name = NULL;
8499     }
8500   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8501   return (ffelexHandler) ffelex_swallow_tokens (t,
8502                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
8503
8504 bad_i:                          /* :::::::::::::::::::: */
8505   if (ffesta_construct_name != NULL)
8506     {
8507       ffelex_token_kill (ffesta_construct_name);
8508       ffesta_construct_name = NULL;
8509     }
8510   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", ffesta_tokens[0], i, t);
8511   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8512 }
8513
8514 /* ffestb_R8091_ -- "SELECTCASE" or "SELECT" "CASE"
8515
8516    return ffestb_R8091_;  // to lexer
8517
8518    Make sure the statement has a valid form for the SELECTCASE statement.  If it
8519    does, implement the statement.  */
8520
8521 static ffelexHandler
8522 ffestb_R8091_ (ffelexToken t)
8523 {
8524   switch (ffelex_token_type (t))
8525     {
8526     case FFELEX_typeOPEN_PAREN:
8527       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8528                 FFEEXPR_contextSELECTCASE, (ffeexprCallback) ffestb_R8092_);
8529
8530     case FFELEX_typeEOS:
8531     case FFELEX_typeSEMICOLON:
8532     case FFELEX_typeCOMMA:
8533     case FFELEX_typeCOLONCOLON:
8534       ffesta_confirmed ();      /* Error, but clearly intended. */
8535       break;
8536
8537     default:
8538       break;
8539     }
8540
8541   if (ffesta_construct_name != NULL)
8542     {
8543       ffelex_token_kill (ffesta_construct_name);
8544       ffesta_construct_name = NULL;
8545     }
8546   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8547   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8548 }
8549
8550 /* ffestb_R8092_ -- "SELECT/CASE" OPEN_PAREN expr
8551
8552    (ffestb_R8092_)  // to expression handler
8553
8554    Make sure the statement has a valid form for the SELECTCASE statement.  If it
8555    does, implement the statement.  */
8556
8557 static ffelexHandler
8558 ffestb_R8092_ (ffelexToken ft, ffebld expr, ffelexToken t)
8559 {
8560   switch (ffelex_token_type (t))
8561     {
8562     case FFELEX_typeCLOSE_PAREN:
8563       if (expr == NULL)
8564         break;
8565       ffesta_tokens[1] = ffelex_token_use (ft);
8566       ffestb_local_.selectcase.expr = expr;
8567       return (ffelexHandler) ffestb_R8093_;
8568
8569     default:
8570       break;
8571     }
8572
8573   if (ffesta_construct_name != NULL)
8574     {
8575       ffelex_token_kill (ffesta_construct_name);
8576       ffesta_construct_name = NULL;
8577     }
8578   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8579   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8580 }
8581
8582 /* ffestb_R8093_ -- "SELECT/CASE" OPEN_PAREN expr CLOSE_PAREN
8583
8584    return ffestb_R8093_;  // to lexer
8585
8586    Make sure the statement has a valid form for the SELECTCASE statement.  If it
8587    does, implement the statement.  */
8588
8589 static ffelexHandler
8590 ffestb_R8093_ (ffelexToken t)
8591 {
8592   switch (ffelex_token_type (t))
8593     {
8594     case FFELEX_typeEOS:
8595     case FFELEX_typeSEMICOLON:
8596       ffesta_confirmed ();
8597       if (!ffesta_is_inhibited ())
8598         ffestc_R809 (ffesta_construct_name, ffestb_local_.selectcase.expr,
8599                      ffesta_tokens[1]);
8600       ffelex_token_kill (ffesta_tokens[1]);
8601       if (ffesta_construct_name != NULL)
8602         {
8603           ffelex_token_kill (ffesta_construct_name);
8604           ffesta_construct_name = NULL;
8605         }
8606       return ffesta_zero (t);
8607
8608     case FFELEX_typeCOMMA:
8609     case FFELEX_typeCOLONCOLON:
8610       ffesta_confirmed ();      /* Error, but clearly intended. */
8611       break;
8612
8613     default:
8614       break;
8615     }
8616
8617   ffelex_token_kill (ffesta_tokens[1]);
8618   if (ffesta_construct_name != NULL)
8619     {
8620       ffelex_token_kill (ffesta_construct_name);
8621       ffesta_construct_name = NULL;
8622     }
8623   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
8624   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8625 }
8626
8627 /* ffestb_R810 -- Parse the CASE statement
8628
8629    return ffestb_R810;  // to lexer
8630
8631    Make sure the statement has a valid form for the CASE statement.
8632    If it does, implement the statement.  */
8633
8634 ffelexHandler
8635 ffestb_R810 (ffelexToken t)
8636 {
8637   ffeTokenLength i;
8638   unsigned const char *p;
8639
8640   switch (ffelex_token_type (ffesta_tokens[0]))
8641     {
8642     case FFELEX_typeNAME:
8643       if (ffesta_first_kw != FFESTR_firstCASE)
8644         goto bad_0;             /* :::::::::::::::::::: */
8645       switch (ffelex_token_type (t))
8646         {
8647         case FFELEX_typeCOMMA:
8648         case FFELEX_typeEOS:
8649         case FFELEX_typeSEMICOLON:
8650         case FFELEX_typeCOLONCOLON:
8651           ffesta_confirmed ();  /* Error, but clearly intended. */
8652           goto bad_1;           /* :::::::::::::::::::: */
8653
8654         default:
8655           goto bad_1;           /* :::::::::::::::::::: */
8656
8657         case FFELEX_typeNAME:
8658           ffesta_confirmed ();
8659           if (ffesta_second_kw != FFESTR_secondDEFAULT)
8660             goto bad_1;         /* :::::::::::::::::::: */
8661           ffestb_local_.case_stmt.cases = NULL;
8662           return (ffelexHandler) ffestb_R8101_;
8663
8664         case FFELEX_typeOPEN_PAREN:
8665           ffestb_local_.case_stmt.cases = ffestt_caselist_create ();
8666           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8667                       FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8668         }
8669
8670     case FFELEX_typeNAMES:
8671       switch (ffesta_first_kw)
8672         {
8673         case FFESTR_firstCASEDEFAULT:
8674           switch (ffelex_token_type (t))
8675             {
8676             case FFELEX_typeCOMMA:
8677             case FFELEX_typeCOLONCOLON:
8678               ffesta_confirmed ();      /* Error, but clearly intended. */
8679               goto bad_1;       /* :::::::::::::::::::: */
8680
8681             default:
8682               goto bad_1;       /* :::::::::::::::::::: */
8683
8684             case FFELEX_typeEOS:
8685             case FFELEX_typeSEMICOLON:
8686               ffesta_confirmed ();
8687               break;
8688             }
8689           ffestb_local_.case_stmt.cases = NULL;
8690           p = ffelex_token_text (ffesta_tokens[0])
8691             + (i = FFESTR_firstlCASEDEFAULT);
8692           if (*p == '\0')
8693             return (ffelexHandler) ffestb_R8101_ (t);
8694           if (!ffesrc_is_name_init (*p))
8695             goto bad_i;         /* :::::::::::::::::::: */
8696           ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i,
8697                                                            0);
8698           return (ffelexHandler) ffestb_R8102_ (t);
8699
8700         case FFESTR_firstCASE:
8701           break;
8702
8703         default:
8704           goto bad_0;           /* :::::::::::::::::::: */
8705         }
8706
8707       switch (ffelex_token_type (t))
8708         {
8709         case FFELEX_typeCOMMA:
8710         case FFELEX_typeEOS:
8711         case FFELEX_typeSEMICOLON:
8712         case FFELEX_typeCOLONCOLON:
8713           ffesta_confirmed ();  /* Error, but clearly intended. */
8714           goto bad_1;           /* :::::::::::::::::::: */
8715
8716         default:
8717           goto bad_1;           /* :::::::::::::::::::: */
8718
8719         case FFELEX_typeOPEN_PAREN:
8720           break;
8721         }
8722       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCASE);
8723       if (*p != '\0')
8724         goto bad_i;             /* :::::::::::::::::::: */
8725       ffestb_local_.case_stmt.cases = ffestt_caselist_create ();
8726       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8727                       FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8728
8729     default:
8730       goto bad_0;               /* :::::::::::::::::::: */
8731     }
8732
8733 bad_0:                          /* :::::::::::::::::::: */
8734   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", ffesta_tokens[0]);
8735   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8736
8737 bad_1:                          /* :::::::::::::::::::: */
8738   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8739   return (ffelexHandler) ffelex_swallow_tokens (t,
8740                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
8741
8742 bad_i:                          /* :::::::::::::::::::: */
8743   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CASE", ffesta_tokens[0], i, t);
8744   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8745 }
8746
8747 /* ffestb_R8101_ -- "CASE" case-selector
8748
8749    return ffestb_R8101_;  // to lexer
8750
8751    Make sure the statement has a valid form for the CASE statement.  If it
8752    does, implement the statement.  */
8753
8754 static ffelexHandler
8755 ffestb_R8101_ (ffelexToken t)
8756 {
8757   switch (ffelex_token_type (t))
8758     {
8759     case FFELEX_typeNAME:
8760       ffesta_tokens[1] = ffelex_token_use (t);
8761       return (ffelexHandler) ffestb_R8102_;
8762
8763     case FFELEX_typeEOS:
8764     case FFELEX_typeSEMICOLON:
8765       ffesta_tokens[1] = NULL;
8766       return (ffelexHandler) ffestb_R8102_ (t);
8767
8768     case FFELEX_typeCOMMA:
8769     case FFELEX_typeCOLONCOLON:
8770       ffesta_confirmed ();      /* Error, but clearly intended. */
8771       break;
8772
8773     default:
8774       break;
8775     }
8776
8777   if (ffestb_local_.case_stmt.cases != NULL)
8778     ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8779   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8780   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8781 }
8782
8783 /* ffestb_R8102_ -- "CASE" case-selector [NAME]
8784
8785    return ffestb_R8102_;  // to lexer
8786
8787    Make sure the statement has a valid form for the CASE statement.  If it
8788    does, implement the statement.  */
8789
8790 static ffelexHandler
8791 ffestb_R8102_ (ffelexToken t)
8792 {
8793   switch (ffelex_token_type (t))
8794     {
8795     case FFELEX_typeEOS:
8796     case FFELEX_typeSEMICOLON:
8797       ffesta_confirmed ();
8798       if (!ffesta_is_inhibited ())
8799         ffestc_R810 (ffestb_local_.case_stmt.cases, ffesta_tokens[1]);
8800       if (ffestb_local_.case_stmt.cases != NULL)
8801         ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8802       if (ffesta_tokens[1] != NULL)
8803         ffelex_token_kill (ffesta_tokens[1]);
8804       return (ffelexHandler) ffesta_zero (t);
8805
8806     case FFELEX_typeCOMMA:
8807     case FFELEX_typeCOLONCOLON:
8808       ffesta_confirmed ();      /* Error, but clearly intended. */
8809       break;
8810
8811     default:
8812       break;
8813     }
8814
8815   if (ffestb_local_.case_stmt.cases != NULL)
8816     ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8817   if (ffesta_tokens[1] != NULL)
8818     ffelex_token_kill (ffesta_tokens[1]);
8819   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8820   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8821 }
8822
8823 /* ffestb_R8103_ -- "CASE" OPEN_PAREN expr
8824
8825    (ffestb_R8103_)  // to expression handler
8826
8827    Make sure the statement has a valid form for the CASE statement.  If it
8828    does, implement the statement.  */
8829
8830 static ffelexHandler
8831 ffestb_R8103_ (ffelexToken ft, ffebld expr, ffelexToken t)
8832 {
8833   switch (ffelex_token_type (t))
8834     {
8835     case FFELEX_typeCLOSE_PAREN:
8836       ffestt_caselist_append (ffestb_local_.case_stmt.cases, FALSE, expr, NULL,
8837                               ffelex_token_use (ft));
8838       return (ffelexHandler) ffestb_R8101_;
8839
8840     case FFELEX_typeCOMMA:
8841       ffestt_caselist_append (ffestb_local_.case_stmt.cases, FALSE, expr, NULL,
8842                               ffelex_token_use (ft));
8843       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8844                       FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8845
8846     case FFELEX_typeCOLON:
8847       ffestt_caselist_append (ffestb_local_.case_stmt.cases, TRUE, expr, NULL,
8848                               ffelex_token_use (ft));   /* NULL second expr for
8849                                                            now, just plug in. */
8850       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8851                       FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8104_);
8852
8853     default:
8854       break;
8855     }
8856
8857   ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8858   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8859   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8860 }
8861
8862 /* ffestb_R8104_ -- "CASE" OPEN_PAREN expr COLON expr
8863
8864    (ffestb_R8104_)  // to expression handler
8865
8866    Make sure the statement has a valid form for the CASE statement.  If it
8867    does, implement the statement.  */
8868
8869 static ffelexHandler
8870 ffestb_R8104_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
8871 {
8872   switch (ffelex_token_type (t))
8873     {
8874     case FFELEX_typeCLOSE_PAREN:
8875       ffestb_local_.case_stmt.cases->previous->expr2 = expr;
8876       return (ffelexHandler) ffestb_R8101_;
8877
8878     case FFELEX_typeCOMMA:
8879       ffestb_local_.case_stmt.cases->previous->expr2 = expr;
8880       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
8881                       FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
8882
8883     default:
8884       break;
8885     }
8886
8887   ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
8888   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
8889   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8890 }
8891
8892 /* ffestb_R1001 -- Parse a FORMAT statement
8893
8894    return ffestb_R1001;  // to lexer
8895
8896    Make sure the statement has a valid form for an FORMAT statement.
8897    If it does, implement the statement.  */
8898
8899 ffelexHandler
8900 ffestb_R1001 (ffelexToken t)
8901 {
8902   ffesttFormatList f;
8903
8904   switch (ffelex_token_type (ffesta_tokens[0]))
8905     {
8906     case FFELEX_typeNAME:
8907       if (ffesta_first_kw != FFESTR_firstFORMAT)
8908         goto bad_0;             /* :::::::::::::::::::: */
8909       break;
8910
8911     case FFELEX_typeNAMES:
8912       if (ffesta_first_kw != FFESTR_firstFORMAT)
8913         goto bad_0;             /* :::::::::::::::::::: */
8914       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlFORMAT)
8915         goto bad_0;             /* :::::::::::::::::::: */
8916       break;
8917
8918     default:
8919       goto bad_0;               /* :::::::::::::::::::: */
8920     }
8921
8922   switch (ffelex_token_type (t))
8923     {
8924     case FFELEX_typeOPEN_PAREN:
8925       ffestb_local_.format.complained = FALSE;
8926       ffestb_local_.format.f = NULL;    /* No parent yet. */
8927       ffestb_local_.format.f = ffestt_formatlist_create (NULL,
8928                                                       ffelex_token_use (t));
8929       ffelex_set_names_pure (TRUE);     /* Have even free-form lexer give us
8930                                            NAMES. */
8931       return (ffelexHandler) ffestb_R10011_;
8932
8933     case FFELEX_typeOPEN_ARRAY:/* "(/". */
8934       ffesta_confirmed ();
8935       ffestb_local_.format.complained = FALSE;
8936       ffestb_local_.format.f = ffestt_formatlist_create (NULL,
8937                                                       ffelex_token_use (t));
8938       f = ffestt_formatlist_append (ffestb_local_.format.f);
8939       f->type = FFESTP_formattypeSLASH;
8940       f->t = ffelex_token_use (t);
8941       f->u.R1010.val.present = FALSE;
8942       f->u.R1010.val.rtexpr = FALSE;
8943       f->u.R1010.val.t = NULL;
8944       f->u.R1010.val.u.unsigned_val = 1;
8945       ffelex_set_names_pure (TRUE);     /* Have even free-form lexer give us
8946                                            NAMES. */
8947       return (ffelexHandler) ffestb_R100112_;
8948
8949     case FFELEX_typeEOS:
8950     case FFELEX_typeSEMICOLON:
8951     case FFELEX_typeCOMMA:
8952     case FFELEX_typeCOLONCOLON:
8953       ffesta_confirmed ();      /* Error, but clearly intended. */
8954       goto bad_1;               /* :::::::::::::::::::: */
8955
8956     default:
8957       goto bad_1;               /* :::::::::::::::::::: */
8958     }
8959
8960 bad_0:                          /* :::::::::::::::::::: */
8961   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", ffesta_tokens[0]);
8962   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
8963
8964 bad_1:                          /* :::::::::::::::::::: */
8965   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
8966   return (ffelexHandler) ffelex_swallow_tokens (t,
8967                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
8968 }
8969
8970 /* ffestb_R10011_ -- "FORMAT" OPEN_PAREN expr
8971
8972    return ffestb_R10011_;  // to lexer
8973
8974    For CLOSE_PAREN, wrap up the format list and if it is the top-level one,
8975    exit.  For anything else, pass it to _2_.  */
8976
8977 static ffelexHandler
8978 ffestb_R10011_ (ffelexToken t)
8979 {
8980   ffesttFormatList f;
8981
8982   switch (ffelex_token_type (t))
8983     {
8984     case FFELEX_typeCLOSE_PAREN:
8985       break;
8986
8987     default:
8988       return (ffelexHandler) ffestb_R10012_ (t);
8989     }
8990
8991   /* If we have a format we're working on, continue working on it. */
8992
8993   f = ffestb_local_.format.f->u.root.parent;
8994
8995   if (f != NULL)
8996     {
8997       ffestb_local_.format.f = f->next;
8998       return (ffelexHandler) ffestb_R100111_;
8999     }
9000
9001   return (ffelexHandler) ffestb_R100114_;
9002 }
9003
9004 /* ffestb_R10012_ -- "FORMAT" OPEN_PAREN [format-item-list]
9005
9006    return ffestb_R10012_;  // to lexer
9007
9008    The initial state for a format-item.  Here, just handle the initial
9009    number, sign for number, or run-time expression.  Also handle spurious
9010    comma, close-paren (indicating spurious comma), close-array (like
9011    close-paren but preceded by slash), and quoted strings.  */
9012
9013 static ffelexHandler
9014 ffestb_R10012_ (ffelexToken t)
9015 {
9016   unsigned long unsigned_val;
9017   ffesttFormatList f;
9018
9019   switch (ffelex_token_type (t))
9020     {
9021     case FFELEX_typeOPEN_ANGLE:
9022       ffesta_confirmed ();
9023       ffestb_local_.format.pre.t = ffelex_token_use (t);
9024       ffelex_set_names_pure (FALSE);
9025       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
9026         {
9027           ffestb_local_.format.complained = TRUE;
9028           ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
9029           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9030           ffebad_finish ();
9031         }
9032       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
9033                   FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100115_);
9034
9035     case FFELEX_typeNUMBER:
9036       ffestb_local_.format.sign = FALSE;        /* No sign present. */
9037       ffestb_local_.format.pre.present = TRUE;
9038       ffestb_local_.format.pre.rtexpr = FALSE;
9039       ffestb_local_.format.pre.t = ffelex_token_use (t);
9040       ffestb_local_.format.pre.u.unsigned_val = unsigned_val
9041         = strtoul (ffelex_token_text (t), NULL, 10);
9042       ffelex_set_expecting_hollerith (unsigned_val, '\0',
9043                                       ffelex_token_where_line (t),
9044                                       ffelex_token_where_column (t));
9045       return (ffelexHandler) ffestb_R10014_;
9046
9047     case FFELEX_typePLUS:
9048       ffestb_local_.format.sign = TRUE; /* Positive. */
9049       ffestb_local_.format.pre.t = ffelex_token_use (t);
9050       return (ffelexHandler) ffestb_R10013_;
9051
9052     case FFELEX_typeMINUS:
9053       ffestb_local_.format.sign = FALSE;        /* Negative. */
9054       ffestb_local_.format.pre.t = ffelex_token_use (t);
9055       return (ffelexHandler) ffestb_R10013_;
9056
9057     case FFELEX_typeCOLON:
9058     case FFELEX_typeCOLONCOLON:/* "::". */
9059     case FFELEX_typeSLASH:
9060     case FFELEX_typeCONCAT:     /* "//". */
9061     case FFELEX_typeNAMES:
9062     case FFELEX_typeDOLLAR:
9063     case FFELEX_typeOPEN_PAREN:
9064     case FFELEX_typeOPEN_ARRAY:/* "(/". */
9065       ffestb_local_.format.sign = FALSE;        /* No sign present. */
9066       ffestb_local_.format.pre.present = FALSE;
9067       ffestb_local_.format.pre.rtexpr = FALSE;
9068       ffestb_local_.format.pre.t = NULL;
9069       ffestb_local_.format.pre.u.unsigned_val = 1;
9070       return (ffelexHandler) ffestb_R10014_ (t);
9071
9072     case FFELEX_typeCOMMA:
9073       ffebad_start (FFEBAD_FORMAT_EXTRA_COMMA);
9074       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9075       ffebad_finish ();
9076       return (ffelexHandler) ffestb_R10012_;
9077
9078     case FFELEX_typeCLOSE_PAREN:
9079       ffebad_start (FFEBAD_FORMAT_EXTRA_COMMA);
9080       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9081       ffebad_finish ();
9082       f = ffestb_local_.format.f->u.root.parent;
9083       if (f == NULL)
9084         return (ffelexHandler) ffestb_R100114_;
9085       ffestb_local_.format.f = f->next;
9086       return (ffelexHandler) ffestb_R100111_;
9087
9088     case FFELEX_typeCLOSE_ARRAY:        /* "/)". */
9089       f = ffestt_formatlist_append (ffestb_local_.format.f);
9090       f->type = FFESTP_formattypeSLASH;
9091       f->t = ffelex_token_use (t);
9092       f->u.R1010.val.present = FALSE;
9093       f->u.R1010.val.rtexpr = FALSE;
9094       f->u.R1010.val.t = NULL;
9095       f->u.R1010.val.u.unsigned_val = 1;
9096       f = ffestb_local_.format.f->u.root.parent;
9097       if (f == NULL)
9098         return (ffelexHandler) ffestb_R100114_;
9099       ffestb_local_.format.f = f->next;
9100       return (ffelexHandler) ffestb_R100111_;
9101
9102     case FFELEX_typeEOS:
9103     case FFELEX_typeSEMICOLON:
9104       ffesta_confirmed ();
9105       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
9106       for (f = ffestb_local_.format.f;
9107            f->u.root.parent != NULL;
9108            f = f->u.root.parent->next)
9109         ;
9110       ffestb_local_.format.f = f;
9111       return (ffelexHandler) ffestb_R100114_ (t);
9112
9113     case FFELEX_typeQUOTE:
9114       if (ffe_is_vxt ())
9115         break;                  /* Error, probably something like FORMAT("17)
9116                                    = X. */
9117       ffelex_set_expecting_hollerith (-1, '\"',
9118                                       ffelex_token_where_line (t),
9119                                       ffelex_token_where_column (t));   /* Don't have to unset
9120                                                                            this one. */
9121       return (ffelexHandler) ffestb_R100113_;
9122
9123     case FFELEX_typeAPOSTROPHE:
9124 #if 0                           /* No apparent need for this, and not killed
9125                                    anywhere. */
9126       ffesta_tokens[1] = ffelex_token_use (t);
9127 #endif
9128       ffelex_set_expecting_hollerith (-1, '\'',
9129                                       ffelex_token_where_line (t),
9130                                       ffelex_token_where_column (t));   /* Don't have to unset
9131                                                                            this one. */
9132       return (ffelexHandler) ffestb_R100113_;
9133
9134     default:
9135       break;
9136     }
9137
9138   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
9139   ffestt_formatlist_kill (ffestb_local_.format.f);
9140   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
9141 }
9142
9143 /* ffestb_R10013_ -- "FORMAT" OPEN_PAREN [format-item-list] PLUS/MINUS
9144
9145    return ffestb_R10013_;  // to lexer
9146
9147    Expect a NUMBER or complain about and then ignore the PLUS/MINUS.  */
9148
9149 static ffelexHandler
9150 ffestb_R10013_ (ffelexToken t)
9151 {
9152   unsigned long unsigned_val;
9153
9154   switch (ffelex_token_type (t))
9155     {
9156     case FFELEX_typeNUMBER:
9157       ffestb_local_.format.pre.present = TRUE;
9158       ffestb_local_.format.pre.rtexpr = FALSE;
9159       unsigned_val = strtoul (ffelex_token_text (t), NULL, 10);
9160       ffestb_local_.format.pre.u.signed_val = ffestb_local_.format.sign
9161         ? unsigned_val : -unsigned_val;
9162       ffestb_local_.format.sign = TRUE; /* Sign present. */
9163       return (ffelexHandler) ffestb_R10014_;
9164
9165     default:
9166       ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9167       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9168                    ffelex_token_where_column (ffestb_local_.format.pre.t));
9169       ffebad_finish ();
9170       ffelex_token_kill (ffestb_local_.format.pre.t);
9171       return (ffelexHandler) ffestb_R10012_ (t);
9172     }
9173 }
9174
9175 /* ffestb_R10014_ -- "FORMAT" OPEN_PAREN [format-item-list] [[+/-] NUMBER]
9176
9177    return ffestb_R10014_;  // to lexer
9178
9179    Here is where we expect to see the actual NAMES, COLON, SLASH, OPEN_PAREN,
9180    OPEN_ARRAY, COLONCOLON, CONCAT, DOLLAR, or HOLLERITH that identifies what
9181    kind of format-item we're dealing with.  But if we see a NUMBER instead, it
9182    means free-form spaces number like "5 6 X", so scale the current number
9183    accordingly and reenter this state.  (I really wouldn't be surprised if
9184    they change this spacing rule in the F90 spec so that you can't embed
9185    spaces within numbers or within keywords like BN in a free-source-form
9186    program.)  */
9187
9188 static ffelexHandler
9189 ffestb_R10014_ (ffelexToken t)
9190 {
9191   ffesttFormatList f;
9192   ffeTokenLength i;
9193   const char *p;
9194   ffestrFormat kw;
9195
9196   ffelex_set_expecting_hollerith (0, '\0',
9197                                   ffewhere_line_unknown (),
9198                                   ffewhere_column_unknown ());
9199
9200   switch (ffelex_token_type (t))
9201     {
9202     case FFELEX_typeHOLLERITH:
9203       f = ffestt_formatlist_append (ffestb_local_.format.f);
9204       f->type = FFESTP_formattypeR1016;
9205       f->t = ffelex_token_use (t);
9206       ffelex_token_kill (ffestb_local_.format.pre.t);   /* It WAS present! */
9207       return (ffelexHandler) ffestb_R100111_;
9208
9209     case FFELEX_typeNUMBER:
9210       assert (ffestb_local_.format.pre.present);
9211       ffesta_confirmed ();
9212       if (ffestb_local_.format.pre.rtexpr)
9213         {
9214           ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
9215           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9216           ffebad_finish ();
9217           return (ffelexHandler) ffestb_R10014_;
9218         }
9219       if (ffestb_local_.format.sign)
9220         {
9221           for (i = ffelex_token_length (t) + 1; i > 0; --i)
9222             ffestb_local_.format.pre.u.signed_val *= 10;
9223           ffestb_local_.format.pre.u.signed_val += strtoul (ffelex_token_text (t),
9224                                                             NULL, 10);
9225         }
9226       else
9227         {
9228           for (i = ffelex_token_length (t) + 1; i > 0; --i)
9229             ffestb_local_.format.pre.u.unsigned_val *= 10;
9230           ffestb_local_.format.pre.u.unsigned_val += strtoul (ffelex_token_text (t),
9231                                                               NULL, 10);
9232           ffelex_set_expecting_hollerith (ffestb_local_.format.pre.u.unsigned_val,
9233                                           '\0',
9234                                           ffelex_token_where_line (t),
9235                                           ffelex_token_where_column (t));
9236         }
9237       return (ffelexHandler) ffestb_R10014_;
9238
9239     case FFELEX_typeCOLONCOLON: /* "::". */
9240       if (ffestb_local_.format.pre.present)
9241         {
9242           ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_COLON_SPEC,
9243                             ffestb_local_.format.pre.t);
9244           ffelex_token_kill (ffestb_local_.format.pre.t);
9245           ffestb_local_.format.pre.present = FALSE;
9246         }
9247       else
9248         {
9249           f = ffestt_formatlist_append (ffestb_local_.format.f);
9250           f->type = FFESTP_formattypeCOLON;
9251           f->t = ffelex_token_use (t);
9252           f->u.R1010.val.present = FALSE;
9253           f->u.R1010.val.rtexpr = FALSE;
9254           f->u.R1010.val.t = NULL;
9255           f->u.R1010.val.u.unsigned_val = 1;
9256         }
9257       f = ffestt_formatlist_append (ffestb_local_.format.f);
9258       f->type = FFESTP_formattypeCOLON;
9259       f->t = ffelex_token_use (t);
9260       f->u.R1010.val.present = FALSE;
9261       f->u.R1010.val.rtexpr = FALSE;
9262       f->u.R1010.val.t = NULL;
9263       f->u.R1010.val.u.unsigned_val = 1;
9264       return (ffelexHandler) ffestb_R100112_;
9265
9266     case FFELEX_typeCOLON:
9267       if (ffestb_local_.format.pre.present)
9268         {
9269           ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_COLON_SPEC,
9270                             ffestb_local_.format.pre.t);
9271           ffelex_token_kill (ffestb_local_.format.pre.t);
9272           return (ffelexHandler) ffestb_R100112_;
9273         }
9274       f = ffestt_formatlist_append (ffestb_local_.format.f);
9275       f->type = FFESTP_formattypeCOLON;
9276       f->t = ffelex_token_use (t);
9277       f->u.R1010.val.present = FALSE;
9278       f->u.R1010.val.rtexpr = FALSE;
9279       f->u.R1010.val.t = NULL;
9280       f->u.R1010.val.u.unsigned_val = 1;
9281       return (ffelexHandler) ffestb_R100112_;
9282
9283     case FFELEX_typeCONCAT:     /* "//". */
9284       if (ffestb_local_.format.sign)
9285         {
9286           ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9287           ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9288                     ffelex_token_where_column (ffestb_local_.format.pre.t));
9289           ffebad_finish ();
9290           ffestb_local_.format.pre.u.unsigned_val
9291             = (ffestb_local_.format.pre.u.signed_val < 0)
9292             ? -ffestb_local_.format.pre.u.signed_val
9293             : ffestb_local_.format.pre.u.signed_val;
9294         }
9295       f = ffestt_formatlist_append (ffestb_local_.format.f);
9296       f->type = FFESTP_formattypeSLASH;
9297       f->t = ffelex_token_use (t);
9298       f->u.R1010.val = ffestb_local_.format.pre;
9299       ffestb_local_.format.pre.present = FALSE;
9300       ffestb_local_.format.pre.rtexpr = FALSE;
9301       ffestb_local_.format.pre.t = NULL;
9302       ffestb_local_.format.pre.u.unsigned_val = 1;
9303       f = ffestt_formatlist_append (ffestb_local_.format.f);
9304       f->type = FFESTP_formattypeSLASH;
9305       f->t = ffelex_token_use (t);
9306       f->u.R1010.val = ffestb_local_.format.pre;
9307       return (ffelexHandler) ffestb_R100112_;
9308
9309     case FFELEX_typeSLASH:
9310       if (ffestb_local_.format.sign)
9311         {
9312           ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9313           ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9314                     ffelex_token_where_column (ffestb_local_.format.pre.t));
9315           ffebad_finish ();
9316           ffestb_local_.format.pre.u.unsigned_val
9317             = (ffestb_local_.format.pre.u.signed_val < 0)
9318             ? -ffestb_local_.format.pre.u.signed_val
9319             : ffestb_local_.format.pre.u.signed_val;
9320         }
9321       f = ffestt_formatlist_append (ffestb_local_.format.f);
9322       f->type = FFESTP_formattypeSLASH;
9323       f->t = ffelex_token_use (t);
9324       f->u.R1010.val = ffestb_local_.format.pre;
9325       return (ffelexHandler) ffestb_R100112_;
9326
9327     case FFELEX_typeOPEN_PAREN:
9328       if (ffestb_local_.format.sign)
9329         {
9330           ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9331           ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9332                     ffelex_token_where_column (ffestb_local_.format.pre.t));
9333           ffebad_finish ();
9334           ffestb_local_.format.pre.u.unsigned_val
9335             = (ffestb_local_.format.pre.u.signed_val < 0)
9336             ? -ffestb_local_.format.pre.u.signed_val
9337             : ffestb_local_.format.pre.u.signed_val;
9338         }
9339       f = ffestt_formatlist_append (ffestb_local_.format.f);
9340       f->type = FFESTP_formattypeFORMAT;
9341       f->t = ffelex_token_use (t);
9342       f->u.R1003D.R1004 = ffestb_local_.format.pre;
9343       f->u.R1003D.format = ffestb_local_.format.f
9344         = ffestt_formatlist_create (f, ffelex_token_use (t));
9345       return (ffelexHandler) ffestb_R10011_;
9346
9347     case FFELEX_typeOPEN_ARRAY:/* "(/". */
9348       if (ffestb_local_.format.sign)
9349         {
9350           ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
9351           ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9352                     ffelex_token_where_column (ffestb_local_.format.pre.t));
9353           ffebad_finish ();
9354           ffestb_local_.format.pre.u.unsigned_val
9355             = (ffestb_local_.format.pre.u.signed_val < 0)
9356             ? -ffestb_local_.format.pre.u.signed_val
9357             : ffestb_local_.format.pre.u.signed_val;
9358         }
9359       f = ffestt_formatlist_append (ffestb_local_.format.f);
9360       f->type = FFESTP_formattypeFORMAT;
9361       f->t = ffelex_token_use (t);
9362       f->u.R1003D.R1004 = ffestb_local_.format.pre;
9363       f->u.R1003D.format = ffestb_local_.format.f
9364         = ffestt_formatlist_create (f, ffelex_token_use (t));
9365       f = ffestt_formatlist_append (ffestb_local_.format.f);
9366       f->type = FFESTP_formattypeSLASH;
9367       f->t = ffelex_token_use (t);
9368       f->u.R1010.val.present = FALSE;
9369       f->u.R1010.val.rtexpr = FALSE;
9370       f->u.R1010.val.t = NULL;
9371       f->u.R1010.val.u.unsigned_val = 1;
9372       return (ffelexHandler) ffestb_R100112_;
9373
9374     case FFELEX_typeCLOSE_ARRAY:        /* "/)". */
9375       f = ffestt_formatlist_append (ffestb_local_.format.f);
9376       f->type = FFESTP_formattypeSLASH;
9377       f->t = ffelex_token_use (t);
9378       f->u.R1010.val = ffestb_local_.format.pre;
9379       f = ffestb_local_.format.f->u.root.parent;
9380       if (f == NULL)
9381         return (ffelexHandler) ffestb_R100114_;
9382       ffestb_local_.format.f = f->next;
9383       return (ffelexHandler) ffestb_R100111_;
9384
9385     case FFELEX_typeQUOTE:
9386       if (ffe_is_vxt ())
9387         break;                  /* A totally bad character in a VXT FORMAT. */
9388       ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
9389       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9390                    ffelex_token_where_column (ffestb_local_.format.pre.t));
9391       ffebad_finish ();
9392       ffelex_token_kill (ffestb_local_.format.pre.t);
9393       ffesta_confirmed ();
9394 #if 0                           /* No apparent need for this, and not killed
9395                                    anywhere. */
9396       ffesta_tokens[1] = ffelex_token_use (t);
9397 #endif
9398       ffelex_set_expecting_hollerith (-1, '\"',
9399                                       ffelex_token_where_line (t),
9400                                       ffelex_token_where_column (t));   /* Don't have to unset
9401                                                                            this one. */
9402       return (ffelexHandler) ffestb_R100113_;
9403
9404     case FFELEX_typeAPOSTROPHE:
9405       ffesta_confirmed ();
9406       ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
9407       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
9408                    ffelex_token_where_column (ffestb_local_.format.pre.t));
9409       ffebad_finish ();
9410       ffelex_token_kill (ffestb_local_.format.pre.t);
9411 #if 0                           /* No apparent need for this, and not killed
9412                                    anywhere. */
9413       ffesta_tokens[1] = ffelex_token_use (t);
9414 #endif
9415       ffelex_set_expecting_hollerith (-1, '\'', ffelex_token_where_line (t),
9416                                       ffelex_token_where_column (t));   /* Don't have to unset
9417                                                                            this one. */
9418       return (ffelexHandler) ffestb_R100113_;
9419
9420     case FFELEX_typeEOS:
9421     case FFELEX_typeSEMICOLON:
9422       ffesta_confirmed ();
9423       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
9424       for (f = ffestb_local_.format.f;
9425            f->u.root.parent != NULL;
9426            f = f->u.root.parent->next)
9427         ;
9428       ffestb_local_.format.f = f;
9429       ffelex_token_kill (ffestb_local_.format.pre.t);
9430       return (ffelexHandler) ffestb_R100114_ (t);
9431
9432     case FFELEX_typeDOLLAR:
9433       ffestb_local_.format.t = ffelex_token_use (t);
9434       if (ffestb_local_.format.pre.present)
9435         ffesta_confirmed ();    /* Number preceding this invalid elsewhere. */
9436       ffestb_local_.format.current = FFESTP_formattypeDOLLAR;
9437       return (ffelexHandler) ffestb_R10015_;
9438
9439     case FFELEX_typeNAMES:
9440       kw = ffestr_format (t);
9441       ffestb_local_.format.t = ffelex_token_use (t);
9442       switch (kw)
9443         {
9444         case FFESTR_formatI:
9445           if (ffestb_local_.format.pre.present)
9446             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9447           ffestb_local_.format.current = FFESTP_formattypeI;
9448           i = FFESTR_formatlI;
9449           break;
9450
9451         case FFESTR_formatB:
9452           if (ffestb_local_.format.pre.present)
9453             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9454           ffestb_local_.format.current = FFESTP_formattypeB;
9455           i = FFESTR_formatlB;
9456           break;
9457
9458         case FFESTR_formatO:
9459           if (ffestb_local_.format.pre.present)
9460             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9461           ffestb_local_.format.current = FFESTP_formattypeO;
9462           i = FFESTR_formatlO;
9463           break;
9464
9465         case FFESTR_formatZ:
9466           if (ffestb_local_.format.pre.present)
9467             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9468           ffestb_local_.format.current = FFESTP_formattypeZ;
9469           i = FFESTR_formatlZ;
9470           break;
9471
9472         case FFESTR_formatF:
9473           if (ffestb_local_.format.pre.present)
9474             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9475           ffestb_local_.format.current = FFESTP_formattypeF;
9476           i = FFESTR_formatlF;
9477           break;
9478
9479         case FFESTR_formatE:
9480           ffestb_local_.format.current = FFESTP_formattypeE;
9481           i = FFESTR_formatlE;
9482           break;
9483
9484         case FFESTR_formatEN:
9485           if (ffestb_local_.format.pre.present)
9486             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9487           ffestb_local_.format.current = FFESTP_formattypeEN;
9488           i = FFESTR_formatlEN;
9489           break;
9490
9491         case FFESTR_formatG:
9492           if (ffestb_local_.format.pre.present)
9493             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9494           ffestb_local_.format.current = FFESTP_formattypeG;
9495           i = FFESTR_formatlG;
9496           break;
9497
9498         case FFESTR_formatL:
9499           if (ffestb_local_.format.pre.present)
9500             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9501           ffestb_local_.format.current = FFESTP_formattypeL;
9502           i = FFESTR_formatlL;
9503           break;
9504
9505         case FFESTR_formatA:
9506           if (ffestb_local_.format.pre.present)
9507             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9508           ffestb_local_.format.current = FFESTP_formattypeA;
9509           i = FFESTR_formatlA;
9510           break;
9511
9512         case FFESTR_formatD:
9513           ffestb_local_.format.current = FFESTP_formattypeD;
9514           i = FFESTR_formatlD;
9515           break;
9516
9517         case FFESTR_formatQ:
9518           ffestb_local_.format.current = FFESTP_formattypeQ;
9519           i = FFESTR_formatlQ;
9520           break;
9521
9522         case FFESTR_formatDOLLAR:
9523           if (ffestb_local_.format.pre.present)
9524             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9525           ffestb_local_.format.current = FFESTP_formattypeDOLLAR;
9526           i = FFESTR_formatlDOLLAR;
9527           break;
9528
9529         case FFESTR_formatP:
9530           if (ffestb_local_.format.pre.present)
9531             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9532           ffestb_local_.format.current = FFESTP_formattypeP;
9533           i = FFESTR_formatlP;
9534           break;
9535
9536         case FFESTR_formatT:
9537           if (ffestb_local_.format.pre.present)
9538             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9539           ffestb_local_.format.current = FFESTP_formattypeT;
9540           i = FFESTR_formatlT;
9541           break;
9542
9543         case FFESTR_formatTL:
9544           if (ffestb_local_.format.pre.present)
9545             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9546           ffestb_local_.format.current = FFESTP_formattypeTL;
9547           i = FFESTR_formatlTL;
9548           break;
9549
9550         case FFESTR_formatTR:
9551           if (ffestb_local_.format.pre.present)
9552             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9553           ffestb_local_.format.current = FFESTP_formattypeTR;
9554           i = FFESTR_formatlTR;
9555           break;
9556
9557         case FFESTR_formatX:
9558           if (ffestb_local_.format.pre.present)
9559             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9560           ffestb_local_.format.current = FFESTP_formattypeX;
9561           i = FFESTR_formatlX;
9562           break;
9563
9564         case FFESTR_formatS:
9565           if (ffestb_local_.format.pre.present)
9566             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9567           ffestb_local_.format.current = FFESTP_formattypeS;
9568           i = FFESTR_formatlS;
9569           break;
9570
9571         case FFESTR_formatSP:
9572           if (ffestb_local_.format.pre.present)
9573             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9574           ffestb_local_.format.current = FFESTP_formattypeSP;
9575           i = FFESTR_formatlSP;
9576           break;
9577
9578         case FFESTR_formatSS:
9579           if (ffestb_local_.format.pre.present)
9580             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9581           ffestb_local_.format.current = FFESTP_formattypeSS;
9582           i = FFESTR_formatlSS;
9583           break;
9584
9585         case FFESTR_formatBN:
9586           if (ffestb_local_.format.pre.present)
9587             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9588           ffestb_local_.format.current = FFESTP_formattypeBN;
9589           i = FFESTR_formatlBN;
9590           break;
9591
9592         case FFESTR_formatBZ:
9593           if (ffestb_local_.format.pre.present)
9594             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9595           ffestb_local_.format.current = FFESTP_formattypeBZ;
9596           i = FFESTR_formatlBZ;
9597           break;
9598
9599         case FFESTR_formatH:    /* Error, either "H" or "<expr>H". */
9600           if (ffestb_local_.format.pre.present)
9601             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9602           ffestb_local_.format.current = FFESTP_formattypeH;
9603           i = FFESTR_formatlH;
9604           break;
9605
9606         case FFESTR_formatPD:
9607           if (ffestb_local_.format.pre.present)
9608             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9609           ffestb_subr_R1001_append_p_ ();
9610           ffestb_local_.format.t = ffelex_token_name_from_names (t,
9611                                                         FFESTR_formatlP, 1);
9612           ffestb_local_.format.sign = FALSE;
9613           ffestb_local_.format.pre.present = FALSE;
9614           ffestb_local_.format.pre.rtexpr = FALSE;
9615           ffestb_local_.format.pre.t = NULL;
9616           ffestb_local_.format.pre.u.unsigned_val = 1;
9617           ffestb_local_.format.current = FFESTP_formattypeD;
9618           i = FFESTR_formatlPD;
9619           break;
9620
9621         case FFESTR_formatPE:
9622           if (ffestb_local_.format.pre.present)
9623             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9624           ffestb_subr_R1001_append_p_ ();
9625           ffestb_local_.format.t = ffelex_token_name_from_names (t,
9626                                                         FFESTR_formatlP, 1);
9627           ffestb_local_.format.sign = FALSE;
9628           ffestb_local_.format.pre.present = FALSE;
9629           ffestb_local_.format.pre.rtexpr = FALSE;
9630           ffestb_local_.format.pre.t = NULL;
9631           ffestb_local_.format.pre.u.unsigned_val = 1;
9632           ffestb_local_.format.current = FFESTP_formattypeE;
9633           i = FFESTR_formatlPE;
9634           break;
9635
9636         case FFESTR_formatPEN:
9637           if (ffestb_local_.format.pre.present)
9638             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9639           ffestb_subr_R1001_append_p_ ();
9640           ffestb_local_.format.t = ffelex_token_name_from_names (t,
9641                                                         FFESTR_formatlP, 1);
9642           ffestb_local_.format.sign = FALSE;
9643           ffestb_local_.format.pre.present = FALSE;
9644           ffestb_local_.format.pre.rtexpr = FALSE;
9645           ffestb_local_.format.pre.t = NULL;
9646           ffestb_local_.format.pre.u.unsigned_val = 1;
9647           ffestb_local_.format.current = FFESTP_formattypeEN;
9648           i = FFESTR_formatlPEN;
9649           break;
9650
9651         case FFESTR_formatPF:
9652           if (ffestb_local_.format.pre.present)
9653             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9654           ffestb_subr_R1001_append_p_ ();
9655           ffestb_local_.format.t = ffelex_token_name_from_names (t,
9656                                                         FFESTR_formatlP, 1);
9657           ffestb_local_.format.sign = FALSE;
9658           ffestb_local_.format.pre.present = FALSE;
9659           ffestb_local_.format.pre.rtexpr = FALSE;
9660           ffestb_local_.format.pre.t = NULL;
9661           ffestb_local_.format.pre.u.unsigned_val = 1;
9662           ffestb_local_.format.current = FFESTP_formattypeF;
9663           i = FFESTR_formatlPF;
9664           break;
9665
9666         case FFESTR_formatPG:
9667           if (ffestb_local_.format.pre.present)
9668             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9669           ffestb_subr_R1001_append_p_ ();
9670           ffestb_local_.format.t = ffelex_token_name_from_names (t,
9671                                                         FFESTR_formatlP, 1);
9672           ffestb_local_.format.sign = FALSE;
9673           ffestb_local_.format.pre.present = FALSE;
9674           ffestb_local_.format.pre.rtexpr = FALSE;
9675           ffestb_local_.format.pre.t = NULL;
9676           ffestb_local_.format.pre.u.unsigned_val = 1;
9677           ffestb_local_.format.current = FFESTP_formattypeG;
9678           i = FFESTR_formatlPG;
9679           break;
9680
9681         default:
9682           if (ffestb_local_.format.pre.present)
9683             ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
9684           ffestb_local_.format.current = FFESTP_formattypeNone;
9685           p = strpbrk (ffelex_token_text (t), "0123456789");
9686           if (p == NULL)
9687             i = ffelex_token_length (t);
9688           else
9689             i = p - ffelex_token_text (t);
9690           break;
9691         }
9692       p = ffelex_token_text (t) + i;
9693       if (*p == '\0')
9694         return (ffelexHandler) ffestb_R10015_;
9695       if (! ISDIGIT (*p))
9696         {
9697           if (ffestb_local_.format.current == FFESTP_formattypeH)
9698             p = strpbrk (p, "0123456789");
9699           else
9700             {
9701               p = NULL;
9702               ffestb_local_.format.current = FFESTP_formattypeNone;
9703             }
9704           if (p == NULL)
9705             return (ffelexHandler) ffestb_R10015_;
9706           i = p - ffelex_token_text (t);        /* Collect digits. */
9707         }
9708       ffestb_local_.format.post.present = TRUE;
9709       ffestb_local_.format.post.rtexpr = FALSE;
9710       ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
9711       ffestb_local_.format.post.u.unsigned_val
9712         = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
9713       p += ffelex_token_length (ffestb_local_.format.post.t);
9714       i += ffelex_token_length (ffestb_local_.format.post.t);
9715       if (*p == '\0')
9716         return (ffelexHandler) ffestb_R10016_;
9717       if ((kw != FFESTR_formatP) ||
9718           !ffelex_is_firstnamechar ((unsigned char)*p))
9719         {
9720           if (ffestb_local_.format.current != FFESTP_formattypeH)
9721             ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
9722           return (ffelexHandler) ffestb_R10016_;
9723         }
9724
9725       /* Here we have [number]P[number][text].  Treat as
9726          [number]P,[number][text]. */
9727
9728       ffestb_subr_R1001_append_p_ ();
9729       t = ffestb_local_.format.t = ffelex_token_names_from_names (t, i, 0);
9730       ffestb_local_.format.sign = FALSE;
9731       ffestb_local_.format.pre = ffestb_local_.format.post;
9732       kw = ffestr_format (t);
9733       switch (kw)
9734         {                       /* Only a few possibilities here. */
9735         case FFESTR_formatD:
9736           ffestb_local_.format.current = FFESTP_formattypeD;
9737           i = FFESTR_formatlD;
9738           break;
9739
9740         case FFESTR_formatE:
9741           ffestb_local_.format.current = FFESTP_formattypeE;
9742           i = FFESTR_formatlE;
9743           break;
9744
9745         case FFESTR_formatEN:
9746           ffestb_local_.format.current = FFESTP_formattypeEN;
9747           i = FFESTR_formatlEN;
9748           break;
9749
9750         case FFESTR_formatF:
9751           ffestb_local_.format.current = FFESTP_formattypeF;
9752           i = FFESTR_formatlF;
9753           break;
9754
9755         case FFESTR_formatG:
9756           ffestb_local_.format.current = FFESTP_formattypeG;
9757           i = FFESTR_formatlG;
9758           break;
9759
9760         default:
9761           ffebad_start (FFEBAD_FORMAT_P_NOCOMMA);
9762           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9763           ffebad_finish ();
9764           ffestb_local_.format.current = FFESTP_formattypeNone;
9765           p = strpbrk (ffelex_token_text (t), "0123456789");
9766           if (p == NULL)
9767             i = ffelex_token_length (t);
9768           else
9769             i = p - ffelex_token_text (t);
9770         }
9771       p = ffelex_token_text (t) + i;
9772       if (*p == '\0')
9773         return (ffelexHandler) ffestb_R10015_;
9774       if (! ISDIGIT (*p))
9775         {
9776           ffestb_local_.format.current = FFESTP_formattypeNone;
9777           p = strpbrk (p, "0123456789");
9778           if (p == NULL)
9779             return (ffelexHandler) ffestb_R10015_;
9780           i = p - ffelex_token_text (t);        /* Collect digits anyway. */
9781         }
9782       ffestb_local_.format.post.present = TRUE;
9783       ffestb_local_.format.post.rtexpr = FALSE;
9784       ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
9785       ffestb_local_.format.post.u.unsigned_val
9786         = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
9787       p += ffelex_token_length (ffestb_local_.format.post.t);
9788       i += ffelex_token_length (ffestb_local_.format.post.t);
9789       if (*p == '\0')
9790         return (ffelexHandler) ffestb_R10016_;
9791       ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
9792       return (ffelexHandler) ffestb_R10016_;
9793
9794     default:
9795       break;
9796     }
9797
9798   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
9799   if (ffestb_local_.format.pre.present)
9800     ffelex_token_kill (ffestb_local_.format.pre.t);
9801   ffestt_formatlist_kill (ffestb_local_.format.f);
9802   return (ffelexHandler) ffelex_swallow_tokens (t,
9803                                                 (ffelexHandler) ffesta_zero);
9804 }
9805
9806 /* ffestb_R10015_ -- [[+/-] NUMBER] NAMES
9807
9808    return ffestb_R10015_;  // to lexer
9809
9810    Here we've gotten at least the initial mnemonic for the edit descriptor.
9811    We expect either a NUMBER, for the post-mnemonic value, a NAMES, for
9812    further clarification (in free-form only, sigh) of the mnemonic, or
9813    anything else.  In all cases we go to _6_, with the difference that for
9814    NUMBER and NAMES we send the next token rather than the current token.  */
9815
9816 static ffelexHandler
9817 ffestb_R10015_ (ffelexToken t)
9818 {
9819   bool split_pea;               /* New NAMES requires splitting kP from new
9820                                    edit desc. */
9821   ffestrFormat kw;
9822   const char *p;
9823   ffeTokenLength i;
9824
9825   switch (ffelex_token_type (t))
9826     {
9827     case FFELEX_typeOPEN_ANGLE:
9828       ffesta_confirmed ();
9829       ffestb_local_.format.post.t = ffelex_token_use (t);
9830       ffelex_set_names_pure (FALSE);
9831       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
9832         {
9833           ffestb_local_.format.complained = TRUE;
9834           ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
9835           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
9836           ffebad_finish ();
9837         }
9838       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
9839                   FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100116_);
9840
9841     case FFELEX_typeNUMBER:
9842       ffestb_local_.format.post.present = TRUE;
9843       ffestb_local_.format.post.rtexpr = FALSE;
9844       ffestb_local_.format.post.t = ffelex_token_use (t);
9845       ffestb_local_.format.post.u.unsigned_val
9846         = strtoul (ffelex_token_text (t), NULL, 10);
9847       return (ffelexHandler) ffestb_R10016_;
9848
9849     case FFELEX_typeNAMES:
9850       ffesta_confirmed ();      /* NAMES " " NAMES invalid elsewhere in
9851                                    free-form. */
9852       kw = ffestr_format (t);
9853       switch (ffestb_local_.format.current)
9854         {
9855         case FFESTP_formattypeP:
9856           split_pea = TRUE;
9857           break;
9858
9859         case FFESTP_formattypeH:        /* An error, maintain this indicator. */
9860           kw = FFESTR_formatNone;
9861           split_pea = FALSE;
9862           break;
9863
9864         default:
9865           split_pea = FALSE;
9866           break;
9867         }
9868
9869       switch (kw)
9870         {
9871         case FFESTR_formatF:
9872           switch (ffestb_local_.format.current)
9873             {
9874             case FFESTP_formattypeP:
9875               ffestb_local_.format.current = FFESTP_formattypeF;
9876               break;
9877
9878             default:
9879               ffestb_local_.format.current = FFESTP_formattypeNone;
9880               break;
9881             }
9882           i = FFESTR_formatlF;
9883           break;
9884
9885         case FFESTR_formatE:
9886           switch (ffestb_local_.format.current)
9887             {
9888             case FFESTP_formattypeP:
9889               ffestb_local_.format.current = FFESTP_formattypeE;
9890               break;
9891
9892             default:
9893               ffestb_local_.format.current = FFESTP_formattypeNone;
9894               break;
9895             }
9896           i = FFESTR_formatlE;
9897           break;
9898
9899         case FFESTR_formatEN:
9900           switch (ffestb_local_.format.current)
9901             {
9902             case FFESTP_formattypeP:
9903               ffestb_local_.format.current = FFESTP_formattypeEN;
9904               break;
9905
9906             default:
9907               ffestb_local_.format.current = FFESTP_formattypeNone;
9908               break;
9909             }
9910           i = FFESTR_formatlEN;
9911           break;
9912
9913         case FFESTR_formatG:
9914           switch (ffestb_local_.format.current)
9915             {
9916             case FFESTP_formattypeP:
9917               ffestb_local_.format.current = FFESTP_formattypeG;
9918               break;
9919
9920             default:
9921               ffestb_local_.format.current = FFESTP_formattypeNone;
9922               break;
9923             }
9924           i = FFESTR_formatlG;
9925           break;
9926
9927         case FFESTR_formatL:
9928           switch (ffestb_local_.format.current)
9929             {
9930             case FFESTP_formattypeT:
9931               ffestb_local_.format.current = FFESTP_formattypeTL;
9932               break;
9933
9934             default:
9935               ffestb_local_.format.current = FFESTP_formattypeNone;
9936               break;
9937             }
9938           i = FFESTR_formatlL;
9939           break;
9940
9941         case FFESTR_formatD:
9942           switch (ffestb_local_.format.current)
9943             {
9944             case FFESTP_formattypeP:
9945               ffestb_local_.format.current = FFESTP_formattypeD;
9946               break;
9947
9948             default:
9949               ffestb_local_.format.current = FFESTP_formattypeNone;
9950               break;
9951             }
9952           i = FFESTR_formatlD;
9953           break;
9954
9955         case FFESTR_formatS:
9956           switch (ffestb_local_.format.current)
9957             {
9958             case FFESTP_formattypeS:
9959               ffestb_local_.format.current = FFESTP_formattypeSS;
9960               break;
9961
9962             default:
9963               ffestb_local_.format.current = FFESTP_formattypeNone;
9964               break;
9965             }
9966           i = FFESTR_formatlS;
9967           break;
9968
9969         case FFESTR_formatP:
9970           switch (ffestb_local_.format.current)
9971             {
9972             case FFESTP_formattypeS:
9973               ffestb_local_.format.current = FFESTP_formattypeSP;
9974               break;
9975
9976             default:
9977               ffestb_local_.format.current = FFESTP_formattypeNone;
9978               break;
9979             }
9980           i = FFESTR_formatlP;
9981           break;
9982
9983         case FFESTR_formatR:
9984           switch (ffestb_local_.format.current)
9985             {
9986             case FFESTP_formattypeT:
9987               ffestb_local_.format.current = FFESTP_formattypeTR;
9988               break;
9989
9990             default:
9991               ffestb_local_.format.current = FFESTP_formattypeNone;
9992               break;
9993             }
9994           i = FFESTR_formatlR;
9995           break;
9996
9997         case FFESTR_formatZ:
9998           switch (ffestb_local_.format.current)
9999             {
10000             case FFESTP_formattypeB:
10001               ffestb_local_.format.current = FFESTP_formattypeBZ;
10002               break;
10003
10004             default:
10005               ffestb_local_.format.current = FFESTP_formattypeNone;
10006               break;
10007             }
10008           i = FFESTR_formatlZ;
10009           break;
10010
10011         case FFESTR_formatN:
10012           switch (ffestb_local_.format.current)
10013             {
10014             case FFESTP_formattypeE:
10015               ffestb_local_.format.current = FFESTP_formattypeEN;
10016               break;
10017
10018             case FFESTP_formattypeB:
10019               ffestb_local_.format.current = FFESTP_formattypeBN;
10020               break;
10021
10022             default:
10023               ffestb_local_.format.current = FFESTP_formattypeNone;
10024               break;
10025             }
10026           i = FFESTR_formatlN;
10027           break;
10028
10029         default:
10030           if (ffestb_local_.format.current != FFESTP_formattypeH)
10031             ffestb_local_.format.current = FFESTP_formattypeNone;
10032           split_pea = FALSE;    /* Go ahead and let the P be in the party. */
10033           p = strpbrk (ffelex_token_text (t), "0123456789");
10034           if (p == NULL)
10035             i = ffelex_token_length (t);
10036           else
10037             i = p - ffelex_token_text (t);
10038         }
10039
10040       if (split_pea)
10041         {
10042           ffestb_subr_R1001_append_p_ ();
10043           ffestb_local_.format.t = ffelex_token_use (t);
10044           ffestb_local_.format.sign = FALSE;
10045           ffestb_local_.format.pre.present = FALSE;
10046           ffestb_local_.format.pre.rtexpr = FALSE;
10047           ffestb_local_.format.pre.t = NULL;
10048           ffestb_local_.format.pre.u.unsigned_val = 1;
10049         }
10050
10051       p = ffelex_token_text (t) + i;
10052       if (*p == '\0')
10053         return (ffelexHandler) ffestb_R10015_;
10054       if (! ISDIGIT (*p))
10055         {
10056           ffestb_local_.format.current = FFESTP_formattypeNone;
10057           p = strpbrk (p, "0123456789");
10058           if (p == NULL)
10059             return (ffelexHandler) ffestb_R10015_;
10060           i = p - ffelex_token_text (t);        /* Collect digits anyway. */
10061         }
10062       ffestb_local_.format.post.present = TRUE;
10063       ffestb_local_.format.post.rtexpr = FALSE;
10064       ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
10065       ffestb_local_.format.post.u.unsigned_val
10066         = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
10067       p += ffelex_token_length (ffestb_local_.format.post.t);
10068       i += ffelex_token_length (ffestb_local_.format.post.t);
10069       if (*p == '\0')
10070         return (ffelexHandler) ffestb_R10016_;
10071       ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
10072       return (ffelexHandler) ffestb_R10016_;
10073
10074     default:
10075       ffestb_local_.format.post.present = FALSE;
10076       ffestb_local_.format.post.rtexpr = FALSE;
10077       ffestb_local_.format.post.t = NULL;
10078       ffestb_local_.format.post.u.unsigned_val = 1;
10079       return (ffelexHandler) ffestb_R10016_ (t);
10080     }
10081 }
10082
10083 /* ffestb_R10016_ -- [[+/-] NUMBER] NAMES NUMBER
10084
10085    return ffestb_R10016_;  // to lexer
10086
10087    Expect a PERIOD here.  Maybe find a NUMBER to append to the current
10088    number, in which case return to this state.  Maybe find a NAMES to switch
10089    from a kP descriptor to a new descriptor (else the NAMES is spurious),
10090    in which case generator the P item and go to state _4_.  Anything
10091    else, pass token on to state _8_.  */
10092
10093 static ffelexHandler
10094 ffestb_R10016_ (ffelexToken t)
10095 {
10096   ffeTokenLength i;
10097
10098   switch (ffelex_token_type (t))
10099     {
10100     case FFELEX_typePERIOD:
10101       return (ffelexHandler) ffestb_R10017_;
10102
10103     case FFELEX_typeNUMBER:
10104       assert (ffestb_local_.format.post.present);
10105       ffesta_confirmed ();
10106       if (ffestb_local_.format.post.rtexpr)
10107         {
10108           ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
10109           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10110           ffebad_finish ();
10111           return (ffelexHandler) ffestb_R10016_;
10112         }
10113       for (i = ffelex_token_length (t) + 1; i > 0; --i)
10114         ffestb_local_.format.post.u.unsigned_val *= 10;
10115       ffestb_local_.format.post.u.unsigned_val += strtoul (ffelex_token_text (t),
10116                                                            NULL, 10);
10117       return (ffelexHandler) ffestb_R10016_;
10118
10119     case FFELEX_typeNAMES:
10120       ffesta_confirmed ();      /* NUMBER " " NAMES invalid elsewhere. */
10121       if (ffestb_local_.format.current != FFESTP_formattypeP)
10122         {
10123           ffesta_ffebad_1t (FFEBAD_FORMAT_TEXT_IN_NUMBER, t);
10124           return (ffelexHandler) ffestb_R10016_;
10125         }
10126       ffestb_subr_R1001_append_p_ ();
10127       ffestb_local_.format.sign = FALSE;
10128       ffestb_local_.format.pre = ffestb_local_.format.post;
10129       return (ffelexHandler) ffestb_R10014_ (t);
10130
10131     default:
10132       ffestb_local_.format.dot.present = FALSE;
10133       ffestb_local_.format.dot.rtexpr = FALSE;
10134       ffestb_local_.format.dot.t = NULL;
10135       ffestb_local_.format.dot.u.unsigned_val = 1;
10136       return (ffelexHandler) ffestb_R10018_ (t);
10137     }
10138 }
10139
10140 /* ffestb_R10017_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD
10141
10142    return ffestb_R10017_;  // to lexer
10143
10144    Here we've gotten the period following the edit descriptor.
10145    We expect either a NUMBER, for the dot value, or something else, which
10146    probably means we're not even close to being in a real FORMAT statement.  */
10147
10148 static ffelexHandler
10149 ffestb_R10017_ (ffelexToken t)
10150 {
10151   switch (ffelex_token_type (t))
10152     {
10153     case FFELEX_typeOPEN_ANGLE:
10154       ffestb_local_.format.dot.t = ffelex_token_use (t);
10155       ffelex_set_names_pure (FALSE);
10156       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
10157         {
10158           ffestb_local_.format.complained = TRUE;
10159           ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
10160           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10161           ffebad_finish ();
10162         }
10163       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
10164                   FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100117_);
10165
10166     case FFELEX_typeNUMBER:
10167       ffestb_local_.format.dot.present = TRUE;
10168       ffestb_local_.format.dot.rtexpr = FALSE;
10169       ffestb_local_.format.dot.t = ffelex_token_use (t);
10170       ffestb_local_.format.dot.u.unsigned_val
10171         = strtoul (ffelex_token_text (t), NULL, 10);
10172       return (ffelexHandler) ffestb_R10018_;
10173
10174     default:
10175       ffelex_token_kill (ffestb_local_.format.t);
10176       if (ffestb_local_.format.pre.present)
10177         ffelex_token_kill (ffestb_local_.format.pre.t);
10178       if (ffestb_local_.format.post.present)
10179         ffelex_token_kill (ffestb_local_.format.post.t);
10180       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_DOT, t);
10181       ffestt_formatlist_kill (ffestb_local_.format.f);
10182       return (ffelexHandler) ffelex_swallow_tokens (t,
10183                                                (ffelexHandler) ffesta_zero);
10184     }
10185 }
10186
10187 /* ffestb_R10018_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD NUMBER
10188
10189    return ffestb_R10018_;  // to lexer
10190
10191    Expect a NAMES here, which must begin with "E" to be valid.  Maybe find a
10192    NUMBER to append to the current number, in which case return to this state.
10193    Anything else, pass token on to state _10_.  */
10194
10195 static ffelexHandler
10196 ffestb_R10018_ (ffelexToken t)
10197 {
10198   ffeTokenLength i;
10199   const char *p;
10200
10201   switch (ffelex_token_type (t))
10202     {
10203     case FFELEX_typeNUMBER:
10204       assert (ffestb_local_.format.dot.present);
10205       ffesta_confirmed ();
10206       if (ffestb_local_.format.dot.rtexpr)
10207         {
10208           ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
10209           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10210           ffebad_finish ();
10211           return (ffelexHandler) ffestb_R10018_;
10212         }
10213       for (i = ffelex_token_length (t) + 1; i > 0; --i)
10214         ffestb_local_.format.dot.u.unsigned_val *= 10;
10215       ffestb_local_.format.dot.u.unsigned_val += strtoul (ffelex_token_text (t),
10216                                                           NULL, 10);
10217       return (ffelexHandler) ffestb_R10018_;
10218
10219     case FFELEX_typeNAMES:
10220       if (!ffesrc_char_match_init (*(p = ffelex_token_text (t)), 'E', 'e'))
10221         {
10222           ffesta_ffebad_1t (FFEBAD_FORMAT_TEXT_IN_NUMBER, t);
10223           return (ffelexHandler) ffestb_R10018_;
10224         }
10225       if (*++p == '\0')
10226         return (ffelexHandler) ffestb_R10019_;  /* Go get NUMBER. */
10227       i = 1;
10228       if (! ISDIGIT (*p))
10229         {
10230           ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, 1, NULL);
10231           return (ffelexHandler) ffestb_R10018_;
10232         }
10233       ffestb_local_.format.exp.present = TRUE;
10234       ffestb_local_.format.exp.rtexpr = FALSE;
10235       ffestb_local_.format.exp.t = ffelex_token_number_from_names (t, i);
10236       ffestb_local_.format.exp.u.unsigned_val
10237         = strtoul (ffelex_token_text (ffestb_local_.format.exp.t), NULL, 10);
10238       p += ffelex_token_length (ffestb_local_.format.exp.t);
10239       i += ffelex_token_length (ffestb_local_.format.exp.t);
10240       if (*p == '\0')
10241         return (ffelexHandler) ffestb_R100110_;
10242       ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
10243       return (ffelexHandler) ffestb_R100110_;
10244
10245     default:
10246       ffestb_local_.format.exp.present = FALSE;
10247       ffestb_local_.format.exp.rtexpr = FALSE;
10248       ffestb_local_.format.exp.t = NULL;
10249       ffestb_local_.format.exp.u.unsigned_val = 1;
10250       return (ffelexHandler) ffestb_R100110_ (t);
10251     }
10252 }
10253
10254 /* ffestb_R10019_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD NUMBER "E"
10255
10256    return ffestb_R10019_;  // to lexer
10257
10258    Here we've gotten the "E" following the edit descriptor.
10259    We expect either a NUMBER, for the exponent value, or something else.  */
10260
10261 static ffelexHandler
10262 ffestb_R10019_ (ffelexToken t)
10263 {
10264   switch (ffelex_token_type (t))
10265     {
10266     case FFELEX_typeOPEN_ANGLE:
10267       ffestb_local_.format.exp.t = ffelex_token_use (t);
10268       ffelex_set_names_pure (FALSE);
10269       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
10270         {
10271           ffestb_local_.format.complained = TRUE;
10272           ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
10273           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10274           ffebad_finish ();
10275         }
10276       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
10277                   FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100118_);
10278
10279     case FFELEX_typeNUMBER:
10280       ffestb_local_.format.exp.present = TRUE;
10281       ffestb_local_.format.exp.rtexpr = FALSE;
10282       ffestb_local_.format.exp.t = ffelex_token_use (t);
10283       ffestb_local_.format.exp.u.unsigned_val
10284         = strtoul (ffelex_token_text (t), NULL, 10);
10285       return (ffelexHandler) ffestb_R100110_;
10286
10287     default:
10288       ffelex_token_kill (ffestb_local_.format.t);
10289       if (ffestb_local_.format.pre.present)
10290         ffelex_token_kill (ffestb_local_.format.pre.t);
10291       if (ffestb_local_.format.post.present)
10292         ffelex_token_kill (ffestb_local_.format.post.t);
10293       if (ffestb_local_.format.dot.present)
10294         ffelex_token_kill (ffestb_local_.format.dot.t);
10295       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_EXP, t);
10296       ffestt_formatlist_kill (ffestb_local_.format.f);
10297       return (ffelexHandler) ffelex_swallow_tokens (t,
10298                                                (ffelexHandler) ffesta_zero);
10299     }
10300 }
10301
10302 /* ffestb_R100110_ -- [[+/-] NUMBER] NAMES NUMBER [PERIOD NUMBER ["E" NUMBER]]
10303
10304    return ffestb_R100110_;  // to lexer
10305
10306    Maybe find a NUMBER to append to the current number, in which case return
10307    to this state.  Anything else, handle current descriptor, then pass token
10308    on to state _10_.  */
10309
10310 static ffelexHandler
10311 ffestb_R100110_ (ffelexToken t)
10312 {
10313   ffeTokenLength i;
10314   enum expect
10315     {
10316       required,
10317       optional,
10318       disallowed
10319     };
10320   ffebad err;
10321   enum expect pre;
10322   enum expect post;
10323   enum expect dot;
10324   enum expect exp;
10325   bool R1005;
10326   ffesttFormatList f;
10327
10328   switch (ffelex_token_type (t))
10329     {
10330     case FFELEX_typeNUMBER:
10331       assert (ffestb_local_.format.exp.present);
10332       ffesta_confirmed ();
10333       if (ffestb_local_.format.exp.rtexpr)
10334         {
10335           ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
10336           ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
10337           ffebad_finish ();
10338           return (ffelexHandler) ffestb_R100110_;
10339         }
10340       for (i = ffelex_token_length (t) + 1; i > 0; --i)
10341         ffestb_local_.format.exp.u.unsigned_val *= 10;
10342       ffestb_local_.format.exp.u.unsigned_val += strtoul (ffelex_token_text (t),
10343                                                           NULL, 10);
10344       return (ffelexHandler) ffestb_R100110_;
10345
10346     default:
10347       if (ffestb_local_.format.sign
10348           && (ffestb_local_.format.current != FFESTP_formattypeP)
10349           && (ffestb_local_.format.current != FFESTP_formattypeH))
10350         {
10351           ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
10352           ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
10353                     ffelex_token_where_column (ffestb_local_.format.pre.t));
10354           ffebad_finish ();
10355           ffestb_local_.format.pre.u.unsigned_val
10356             = (ffestb_local_.format.pre.u.signed_val < 0)
10357             ? -ffestb_local_.format.pre.u.signed_val
10358             : ffestb_local_.format.pre.u.signed_val;
10359         }
10360       switch (ffestb_local_.format.current)
10361         {
10362         case FFESTP_formattypeI:
10363           err = FFEBAD_FORMAT_BAD_I_SPEC;
10364           pre = optional;
10365           post = required;
10366           dot = optional;
10367           exp = disallowed;
10368           R1005 = TRUE;
10369           break;
10370
10371         case FFESTP_formattypeB:
10372           err = FFEBAD_FORMAT_BAD_B_SPEC;
10373           pre = optional;
10374           post = required;
10375           dot = optional;
10376           exp = disallowed;
10377           R1005 = TRUE;
10378           break;
10379
10380         case FFESTP_formattypeO:
10381           err = FFEBAD_FORMAT_BAD_O_SPEC;
10382           pre = optional;
10383           post = required;
10384           dot = optional;
10385           exp = disallowed;
10386           R1005 = TRUE;
10387           break;
10388
10389         case FFESTP_formattypeZ:
10390           err = FFEBAD_FORMAT_BAD_Z_SPEC;
10391           pre = optional;
10392           post = required;
10393           dot = optional;
10394           exp = disallowed;
10395           R1005 = TRUE;
10396           break;
10397
10398         case FFESTP_formattypeF:
10399           err = FFEBAD_FORMAT_BAD_F_SPEC;
10400           pre = optional;
10401           post = required;
10402           dot = required;
10403           exp = disallowed;
10404           R1005 = TRUE;
10405           break;
10406
10407         case FFESTP_formattypeE:
10408           err = FFEBAD_FORMAT_BAD_E_SPEC;
10409           pre = optional;
10410           post = required;
10411           dot = required;
10412           exp = optional;
10413           R1005 = TRUE;
10414           break;
10415
10416         case FFESTP_formattypeEN:
10417           err = FFEBAD_FORMAT_BAD_EN_SPEC;
10418           pre = optional;
10419           post = required;
10420           dot = required;
10421           exp = optional;
10422           R1005 = TRUE;
10423           break;
10424
10425         case FFESTP_formattypeG:
10426           err = FFEBAD_FORMAT_BAD_G_SPEC;
10427           pre = optional;
10428           post = required;
10429           dot = required;
10430           exp = optional;
10431           R1005 = TRUE;
10432           break;
10433
10434         case FFESTP_formattypeL:
10435           err = FFEBAD_FORMAT_BAD_L_SPEC;
10436           pre = optional;
10437           post = required;
10438           dot = disallowed;
10439           exp = disallowed;
10440           R1005 = TRUE;
10441           break;
10442
10443         case FFESTP_formattypeA:
10444           err = FFEBAD_FORMAT_BAD_A_SPEC;
10445           pre = optional;
10446           post = optional;
10447           dot = disallowed;
10448           exp = disallowed;
10449           R1005 = TRUE;
10450           break;
10451
10452         case FFESTP_formattypeD:
10453           err = FFEBAD_FORMAT_BAD_D_SPEC;
10454           pre = optional;
10455           post = required;
10456           dot = required;
10457           exp = disallowed;
10458           R1005 = TRUE;
10459           break;
10460
10461         case FFESTP_formattypeQ:
10462           err = FFEBAD_FORMAT_BAD_Q_SPEC;
10463           pre = disallowed;
10464           post = disallowed;
10465           dot = disallowed;
10466           exp = disallowed;
10467           R1005 = FALSE;
10468           break;
10469
10470         case FFESTP_formattypeDOLLAR:
10471           err = FFEBAD_FORMAT_BAD_DOLLAR_SPEC;
10472           pre = disallowed;
10473           post = disallowed;
10474           dot = disallowed;
10475           exp = disallowed;
10476           R1005 = FALSE;
10477           break;
10478
10479         case FFESTP_formattypeP:
10480           err = FFEBAD_FORMAT_BAD_P_SPEC;
10481           pre = required;
10482           post = disallowed;
10483           dot = disallowed;
10484           exp = disallowed;
10485           R1005 = FALSE;
10486           break;
10487
10488         case FFESTP_formattypeT:
10489           err = FFEBAD_FORMAT_BAD_T_SPEC;
10490           pre = disallowed;
10491           post = required;
10492           dot = disallowed;
10493           exp = disallowed;
10494           R1005 = FALSE;
10495           break;
10496
10497         case FFESTP_formattypeTL:
10498           err = FFEBAD_FORMAT_BAD_TL_SPEC;
10499           pre = disallowed;
10500           post = required;
10501           dot = disallowed;
10502           exp = disallowed;
10503           R1005 = FALSE;
10504           break;
10505
10506         case FFESTP_formattypeTR:
10507           err = FFEBAD_FORMAT_BAD_TR_SPEC;
10508           pre = disallowed;
10509           post = required;
10510           dot = disallowed;
10511           exp = disallowed;
10512           R1005 = FALSE;
10513           break;
10514
10515         case FFESTP_formattypeX:
10516           err = FFEBAD_FORMAT_BAD_X_SPEC;
10517           pre = ffe_is_pedantic() ? required : optional;
10518           post = disallowed;
10519           dot = disallowed;
10520           exp = disallowed;
10521           R1005 = FALSE;
10522           break;
10523
10524         case FFESTP_formattypeS:
10525           err = FFEBAD_FORMAT_BAD_S_SPEC;
10526           pre = disallowed;
10527           post = disallowed;
10528           dot = disallowed;
10529           exp = disallowed;
10530           R1005 = FALSE;
10531           break;
10532
10533         case FFESTP_formattypeSP:
10534           err = FFEBAD_FORMAT_BAD_SP_SPEC;
10535           pre = disallowed;
10536           post = disallowed;
10537           dot = disallowed;
10538           exp = disallowed;
10539           R1005 = FALSE;
10540           break;
10541
10542         case FFESTP_formattypeSS:
10543           err = FFEBAD_FORMAT_BAD_SS_SPEC;
10544           pre = disallowed;
10545           post = disallowed;
10546           dot = disallowed;
10547           exp = disallowed;
10548           R1005 = FALSE;
10549           break;
10550
10551         case FFESTP_formattypeBN:
10552           err = FFEBAD_FORMAT_BAD_BN_SPEC;
10553           pre = disallowed;
10554           post = disallowed;
10555           dot = disallowed;
10556           exp = disallowed;
10557           R1005 = FALSE;
10558           break;
10559
10560         case FFESTP_formattypeBZ:
10561           err = FFEBAD_FORMAT_BAD_BZ_SPEC;
10562           pre = disallowed;
10563           post = disallowed;
10564           dot = disallowed;
10565           exp = disallowed;
10566           R1005 = FALSE;
10567           break;
10568
10569         case FFESTP_formattypeH:        /* Definitely an error, make sure of
10570                                            it. */
10571           err = FFEBAD_FORMAT_BAD_H_SPEC;
10572           pre = ffestb_local_.format.pre.present ? disallowed : required;
10573           post = disallowed;
10574           dot = disallowed;
10575           exp = disallowed;
10576           R1005 = FALSE;
10577           break;
10578
10579         case FFESTP_formattypeNone:
10580           ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_SPEC,
10581                             ffestb_local_.format.t);
10582
10583         clean_up_to_11_:        /* :::::::::::::::::::: */
10584
10585           ffelex_token_kill (ffestb_local_.format.t);
10586           if (ffestb_local_.format.pre.present)
10587             ffelex_token_kill (ffestb_local_.format.pre.t);
10588           if (ffestb_local_.format.post.present)
10589             ffelex_token_kill (ffestb_local_.format.post.t);
10590           if (ffestb_local_.format.dot.present)
10591             ffelex_token_kill (ffestb_local_.format.dot.t);
10592           if (ffestb_local_.format.exp.present)
10593             ffelex_token_kill (ffestb_local_.format.exp.t);
10594           return (ffelexHandler) ffestb_R100111_ (t);
10595
10596         default:
10597           assert ("bad format item" == NULL);
10598           err = FFEBAD_FORMAT_BAD_H_SPEC;
10599           pre = disallowed;
10600           post = disallowed;
10601           dot = disallowed;
10602           exp = disallowed;
10603           R1005 = FALSE;
10604           break;
10605         }
10606       if (((pre == disallowed) && ffestb_local_.format.pre.present)
10607           || ((pre == required) && !ffestb_local_.format.pre.present))
10608         {
10609           ffesta_ffebad_1t (err, (pre == required)
10610                      ? ffestb_local_.format.t : ffestb_local_.format.pre.t);
10611           goto clean_up_to_11_; /* :::::::::::::::::::: */
10612         }
10613       if (((post == disallowed) && ffestb_local_.format.post.present)
10614           || ((post == required) && !ffestb_local_.format.post.present))
10615         {
10616           ffesta_ffebad_1t (err, (post == required)
10617                     ? ffestb_local_.format.t : ffestb_local_.format.post.t);
10618           goto clean_up_to_11_; /* :::::::::::::::::::: */
10619         }
10620       if (((dot == disallowed) && ffestb_local_.format.dot.present)
10621           || ((dot == required) && !ffestb_local_.format.dot.present))
10622         {
10623           ffesta_ffebad_1t (err, (dot == required)
10624                      ? ffestb_local_.format.t : ffestb_local_.format.dot.t);
10625           goto clean_up_to_11_; /* :::::::::::::::::::: */
10626         }
10627       if (((exp == disallowed) && ffestb_local_.format.exp.present)
10628           || ((exp == required) && !ffestb_local_.format.exp.present))
10629         {
10630           ffesta_ffebad_1t (err, (exp == required)
10631                      ? ffestb_local_.format.t : ffestb_local_.format.exp.t);
10632           goto clean_up_to_11_; /* :::::::::::::::::::: */
10633         }
10634       f = ffestt_formatlist_append (ffestb_local_.format.f);
10635       f->type = ffestb_local_.format.current;
10636       f->t = ffestb_local_.format.t;
10637       if (R1005)
10638         {
10639           f->u.R1005.R1004 = ffestb_local_.format.pre;
10640           f->u.R1005.R1006 = ffestb_local_.format.post;
10641           f->u.R1005.R1007_or_R1008 = ffestb_local_.format.dot;
10642           f->u.R1005.R1009 = ffestb_local_.format.exp;
10643         }
10644       else
10645         /* Must be R1010. */
10646         {
10647           if (pre == disallowed)
10648             f->u.R1010.val = ffestb_local_.format.post;
10649           else
10650             f->u.R1010.val = ffestb_local_.format.pre;
10651         }
10652       return (ffelexHandler) ffestb_R100111_ (t);
10653     }
10654 }
10655
10656 /* ffestb_R100111_ -- edit-descriptor
10657
10658    return ffestb_R100111_;  // to lexer
10659
10660    Expect a COMMA, CLOSE_PAREN, CLOSE_ARRAY, COLON, COLONCOLON, SLASH, or
10661    CONCAT, or complain about missing comma.  */
10662
10663 static ffelexHandler
10664 ffestb_R100111_ (ffelexToken t)
10665 {
10666   ffesttFormatList f;
10667
10668   switch (ffelex_token_type (t))
10669     {
10670     case FFELEX_typeCOMMA:
10671       return (ffelexHandler) ffestb_R10012_;
10672
10673     case FFELEX_typeCOLON:
10674     case FFELEX_typeCOLONCOLON:
10675     case FFELEX_typeSLASH:
10676     case FFELEX_typeCONCAT:
10677       return (ffelexHandler) ffestb_R10012_ (t);
10678
10679     case FFELEX_typeCLOSE_PAREN:
10680       f = ffestb_local_.format.f->u.root.parent;
10681       if (f == NULL)
10682         return (ffelexHandler) ffestb_R100114_;
10683       ffestb_local_.format.f = f->next;
10684       return (ffelexHandler) ffestb_R100111_;
10685
10686     case FFELEX_typeCLOSE_ARRAY:        /* "/)". */
10687       f = ffestt_formatlist_append (ffestb_local_.format.f);
10688       f->type = FFESTP_formattypeSLASH;
10689       f->t = ffelex_token_use (t);
10690       f->u.R1010.val.present = FALSE;
10691       f->u.R1010.val.rtexpr = FALSE;
10692       f->u.R1010.val.t = NULL;
10693       f->u.R1010.val.u.unsigned_val = 1;
10694       f = ffestb_local_.format.f->u.root.parent;
10695       if (f == NULL)
10696         return (ffelexHandler) ffestb_R100114_;
10697       ffestb_local_.format.f = f->next;
10698       return (ffelexHandler) ffestb_R100111_;
10699
10700     case FFELEX_typeOPEN_ANGLE:
10701     case FFELEX_typeDOLLAR:
10702     case FFELEX_typeNUMBER:
10703     case FFELEX_typeOPEN_PAREN:
10704     case FFELEX_typeOPEN_ARRAY:
10705     case FFELEX_typeQUOTE:
10706     case FFELEX_typeAPOSTROPHE:
10707     case FFELEX_typeNAMES:
10708       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_COMMA, t);
10709       return (ffelexHandler) ffestb_R10012_ (t);
10710
10711     case FFELEX_typeEOS:
10712     case FFELEX_typeSEMICOLON:
10713       ffesta_confirmed ();
10714       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
10715       for (f = ffestb_local_.format.f;
10716            f->u.root.parent != NULL;
10717            f = f->u.root.parent->next)
10718         ;
10719       ffestb_local_.format.f = f;
10720       return (ffelexHandler) ffestb_R100114_ (t);
10721
10722     default:
10723       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10724       ffestt_formatlist_kill (ffestb_local_.format.f);
10725       return (ffelexHandler) ffelex_swallow_tokens (t,
10726                                                (ffelexHandler) ffesta_zero);
10727     }
10728 }
10729
10730 /* ffestb_R100112_ -- COLON, COLONCOLON, SLASH, OPEN_ARRAY, or CONCAT
10731
10732    return ffestb_R100112_;  // to lexer
10733
10734    Like _11_ except the COMMA is optional.  */
10735
10736 static ffelexHandler
10737 ffestb_R100112_ (ffelexToken t)
10738 {
10739   ffesttFormatList f;
10740
10741   switch (ffelex_token_type (t))
10742     {
10743     case FFELEX_typeCOMMA:
10744       return (ffelexHandler) ffestb_R10012_;
10745
10746     case FFELEX_typeCOLON:
10747     case FFELEX_typeCOLONCOLON:
10748     case FFELEX_typeSLASH:
10749     case FFELEX_typeCONCAT:
10750     case FFELEX_typeOPEN_ANGLE:
10751     case FFELEX_typeNAMES:
10752     case FFELEX_typeDOLLAR:
10753     case FFELEX_typeNUMBER:
10754     case FFELEX_typeOPEN_PAREN:
10755     case FFELEX_typeOPEN_ARRAY:
10756     case FFELEX_typeQUOTE:
10757     case FFELEX_typeAPOSTROPHE:
10758     case FFELEX_typePLUS:
10759     case FFELEX_typeMINUS:
10760       return (ffelexHandler) ffestb_R10012_ (t);
10761
10762     case FFELEX_typeCLOSE_PAREN:
10763       f = ffestb_local_.format.f->u.root.parent;
10764       if (f == NULL)
10765         return (ffelexHandler) ffestb_R100114_;
10766       ffestb_local_.format.f = f->next;
10767       return (ffelexHandler) ffestb_R100111_;
10768
10769     case FFELEX_typeCLOSE_ARRAY:        /* "/)". */
10770       f = ffestt_formatlist_append (ffestb_local_.format.f);
10771       f->type = FFESTP_formattypeSLASH;
10772       f->t = ffelex_token_use (t);
10773       f->u.R1010.val.present = FALSE;
10774       f->u.R1010.val.rtexpr = FALSE;
10775       f->u.R1010.val.t = NULL;
10776       f->u.R1010.val.u.unsigned_val = 1;
10777       f = ffestb_local_.format.f->u.root.parent;
10778       if (f == NULL)
10779         return (ffelexHandler) ffestb_R100114_;
10780       ffestb_local_.format.f = f->next;
10781       return (ffelexHandler) ffestb_R100111_;
10782
10783     case FFELEX_typeEOS:
10784     case FFELEX_typeSEMICOLON:
10785       ffesta_confirmed ();
10786       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
10787       for (f = ffestb_local_.format.f;
10788            f->u.root.parent != NULL;
10789            f = f->u.root.parent->next)
10790         ;
10791       ffestb_local_.format.f = f;
10792       return (ffelexHandler) ffestb_R100114_ (t);
10793
10794     default:
10795       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10796       ffestt_formatlist_kill (ffestb_local_.format.f);
10797       return (ffelexHandler) ffelex_swallow_tokens (t,
10798                                                (ffelexHandler) ffesta_zero);
10799     }
10800 }
10801
10802 /* ffestb_R100113_ -- Handle CHARACTER token.
10803
10804    return ffestb_R100113_;  // to lexer
10805
10806    Append the format item to the list, go to _11_.  */
10807
10808 static ffelexHandler
10809 ffestb_R100113_ (ffelexToken t)
10810 {
10811   ffesttFormatList f;
10812
10813   assert (ffelex_token_type (t) == FFELEX_typeCHARACTER);
10814
10815   if (ffe_is_pedantic_not_90 () && (ffelex_token_length (t) == 0))
10816     {
10817       ffebad_start (FFEBAD_NULL_CHAR_CONST);
10818       ffebad_here (0, ffelex_token_where_line (t),
10819                    ffelex_token_where_column (t));
10820       ffebad_finish ();
10821     }
10822
10823   f = ffestt_formatlist_append (ffestb_local_.format.f);
10824   f->type = FFESTP_formattypeR1016;
10825   f->t = ffelex_token_use (t);
10826   return (ffelexHandler) ffestb_R100111_;
10827 }
10828
10829 /* ffestb_R100114_ -- "FORMAT" OPEN_PAREN format-item-list CLOSE_PAREN
10830
10831    return ffestb_R100114_;  // to lexer
10832
10833    Handle EOS/SEMICOLON or something else.  */
10834
10835 static ffelexHandler
10836 ffestb_R100114_ (ffelexToken t)
10837 {
10838   ffelex_set_names_pure (FALSE);
10839
10840   switch (ffelex_token_type (t))
10841     {
10842     case FFELEX_typeEOS:
10843     case FFELEX_typeSEMICOLON:
10844       ffesta_confirmed ();
10845       if (!ffesta_is_inhibited () && !ffestb_local_.format.complained)
10846         ffestc_R1001 (ffestb_local_.format.f);
10847       ffestt_formatlist_kill (ffestb_local_.format.f);
10848       return (ffelexHandler) ffesta_zero (t);
10849
10850     default:
10851       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10852       ffestt_formatlist_kill (ffestb_local_.format.f);
10853       return (ffelexHandler) ffelex_swallow_tokens (t,
10854                                                (ffelexHandler) ffesta_zero);
10855     }
10856 }
10857
10858 /* ffestb_R100115_ -- OPEN_ANGLE expr
10859
10860    (ffestb_R100115_)  // to expression handler
10861
10862    Handle expression prior to the edit descriptor.  */
10863
10864 static ffelexHandler
10865 ffestb_R100115_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10866 {
10867   switch (ffelex_token_type (t))
10868     {
10869     case FFELEX_typeCLOSE_ANGLE:
10870       ffestb_local_.format.pre.present = TRUE;
10871       ffestb_local_.format.pre.rtexpr = TRUE;
10872       ffestb_local_.format.pre.u.expr = expr;
10873       ffelex_set_names_pure (TRUE);
10874       return (ffelexHandler) ffestb_R10014_;
10875
10876     default:
10877       ffelex_token_kill (ffestb_local_.format.pre.t);
10878       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10879       ffestt_formatlist_kill (ffestb_local_.format.f);
10880       return (ffelexHandler) ffelex_swallow_tokens (t,
10881                                                (ffelexHandler) ffesta_zero);
10882     }
10883 }
10884
10885 /* ffestb_R100116_ -- "[n]X" OPEN_ANGLE expr
10886
10887    (ffestb_R100116_)  // to expression handler
10888
10889    Handle expression after the edit descriptor.  */
10890
10891 static ffelexHandler
10892 ffestb_R100116_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10893 {
10894   switch (ffelex_token_type (t))
10895     {
10896     case FFELEX_typeCLOSE_ANGLE:
10897       ffestb_local_.format.post.present = TRUE;
10898       ffestb_local_.format.post.rtexpr = TRUE;
10899       ffestb_local_.format.post.u.expr = expr;
10900       ffelex_set_names_pure (TRUE);
10901       return (ffelexHandler) ffestb_R10016_;
10902
10903     default:
10904       ffelex_token_kill (ffestb_local_.format.t);
10905       ffelex_token_kill (ffestb_local_.format.post.t);
10906       if (ffestb_local_.format.pre.present)
10907         ffelex_token_kill (ffestb_local_.format.pre.t);
10908       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10909       ffestt_formatlist_kill (ffestb_local_.format.f);
10910       return (ffelexHandler) ffelex_swallow_tokens (t,
10911                                                (ffelexHandler) ffesta_zero);
10912     }
10913 }
10914
10915 /* ffestb_R100117_ -- "[n]X[n]." OPEN_ANGLE expr
10916
10917    (ffestb_R100117_)  // to expression handler
10918
10919    Handle expression after the PERIOD.  */
10920
10921 static ffelexHandler
10922 ffestb_R100117_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10923 {
10924   switch (ffelex_token_type (t))
10925     {
10926     case FFELEX_typeCLOSE_ANGLE:
10927       ffestb_local_.format.dot.present = TRUE;
10928       ffestb_local_.format.dot.rtexpr = TRUE;
10929       ffestb_local_.format.dot.u.expr = expr;
10930       ffelex_set_names_pure (TRUE);
10931       return (ffelexHandler) ffestb_R10018_;
10932
10933     default:
10934       ffelex_token_kill (ffestb_local_.format.t);
10935       ffelex_token_kill (ffestb_local_.format.dot.t);
10936       if (ffestb_local_.format.pre.present)
10937         ffelex_token_kill (ffestb_local_.format.pre.t);
10938       if (ffestb_local_.format.post.present)
10939         ffelex_token_kill (ffestb_local_.format.post.t);
10940       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10941       ffestt_formatlist_kill (ffestb_local_.format.f);
10942       return (ffelexHandler) ffelex_swallow_tokens (t,
10943                                                (ffelexHandler) ffesta_zero);
10944     }
10945 }
10946
10947 /* ffestb_R100118_ -- "[n]X[n].[n]E" OPEN_ANGLE expr
10948
10949    (ffestb_R100118_)  // to expression handler
10950
10951    Handle expression after the "E".  */
10952
10953 static ffelexHandler
10954 ffestb_R100118_ (ffelexToken ft UNUSED, ffebld expr, ffelexToken t)
10955 {
10956   switch (ffelex_token_type (t))
10957     {
10958     case FFELEX_typeCLOSE_ANGLE:
10959       ffestb_local_.format.exp.present = TRUE;
10960       ffestb_local_.format.exp.rtexpr = TRUE;
10961       ffestb_local_.format.exp.u.expr = expr;
10962       ffelex_set_names_pure (TRUE);
10963       return (ffelexHandler) ffestb_R100110_;
10964
10965     default:
10966       ffelex_token_kill (ffestb_local_.format.t);
10967       ffelex_token_kill (ffestb_local_.format.exp.t);
10968       if (ffestb_local_.format.pre.present)
10969         ffelex_token_kill (ffestb_local_.format.pre.t);
10970       if (ffestb_local_.format.post.present)
10971         ffelex_token_kill (ffestb_local_.format.post.t);
10972       if (ffestb_local_.format.dot.present)
10973         ffelex_token_kill (ffestb_local_.format.dot.t);
10974       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
10975       ffestt_formatlist_kill (ffestb_local_.format.f);
10976       return (ffelexHandler) ffelex_swallow_tokens (t,
10977                                                (ffelexHandler) ffesta_zero);
10978     }
10979 }
10980
10981 /* ffestb_R1107 -- Parse the USE statement
10982
10983    return ffestb_R1107;  // to lexer
10984
10985    Make sure the statement has a valid form for the USE statement.
10986    If it does, implement the statement.  */
10987
10988 #if FFESTR_F90
10989 ffelexHandler
10990 ffestb_R1107 (ffelexToken t)
10991 {
10992   ffeTokenLength i;
10993   const char *p;
10994
10995   switch (ffelex_token_type (ffesta_tokens[0]))
10996     {
10997     case FFELEX_typeNAME:
10998       if (ffesta_first_kw != FFESTR_firstUSE)
10999         goto bad_0;             /* :::::::::::::::::::: */
11000       switch (ffelex_token_type (t))
11001         {
11002         case FFELEX_typeNAME:
11003           break;
11004
11005         case FFELEX_typeEOS:
11006         case FFELEX_typeSEMICOLON:
11007         case FFELEX_typeCOMMA:
11008         case FFELEX_typeCOLONCOLON:
11009           ffesta_confirmed ();  /* Error, but clearly intended. */
11010           goto bad_1;           /* :::::::::::::::::::: */
11011
11012         default:
11013           goto bad_0;           /* :::::::::::::::::::: */
11014         }
11015       ffesta_confirmed ();
11016       ffesta_tokens[1] = ffelex_token_use (t);
11017       return (ffelexHandler) ffestb_R11071_;
11018
11019     case FFELEX_typeNAMES:
11020       if (ffesta_first_kw != FFESTR_firstUSE)
11021         goto bad_0;             /* :::::::::::::::::::: */
11022       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlUSE);
11023       if (!ffesrc_is_name_init (*p))
11024         goto bad_i;             /* :::::::::::::::::::: */
11025       switch (ffelex_token_type (t))
11026         {
11027         case FFELEX_typeCOLONCOLON:
11028           ffesta_confirmed ();  /* Error, but clearly intended. */
11029           goto bad_1;           /* :::::::::::::::::::: */
11030
11031         default:
11032           goto bad_1;           /* :::::::::::::::::::: */
11033
11034         case FFELEX_typeCOMMA:
11035         case FFELEX_typeEOS:
11036         case FFELEX_typeSEMICOLON:
11037           break;
11038         }
11039       ffesta_confirmed ();
11040       ffesta_tokens[1]
11041         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
11042       return (ffelexHandler) ffestb_R11071_ (t);
11043
11044     default:
11045       goto bad_0;               /* :::::::::::::::::::: */
11046     }
11047
11048 bad_0:                          /* :::::::::::::::::::: */
11049   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", ffesta_tokens[0]);
11050   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11051
11052 bad_1:                          /* :::::::::::::::::::: */
11053   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11054   return (ffelexHandler) ffelex_swallow_tokens (t,
11055                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
11056
11057 bad_i:                          /* :::::::::::::::::::: */
11058   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "USE", ffesta_tokens[0], i, t);
11059   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11060 }
11061
11062 /* ffestb_R11071_ -- "USE" NAME
11063
11064    return ffestb_R11071_;  // to lexer
11065
11066    Make sure the statement has a valid form for the USE statement.  If it
11067    does, implement the statement.  */
11068
11069 static ffelexHandler
11070 ffestb_R11071_ (ffelexToken t)
11071 {
11072   switch (ffelex_token_type (t))
11073     {
11074     case FFELEX_typeEOS:
11075     case FFELEX_typeSEMICOLON:
11076       if (!ffesta_is_inhibited ())
11077         {
11078           ffestc_R1107_start (ffesta_tokens[1], FALSE);
11079           ffestc_R1107_finish ();
11080         }
11081       ffelex_token_kill (ffesta_tokens[1]);
11082       return (ffelexHandler) ffesta_zero (t);
11083
11084     case FFELEX_typeCOMMA:
11085       return (ffelexHandler) ffestb_R11072_;
11086
11087     default:
11088       break;
11089     }
11090
11091   ffelex_token_kill (ffesta_tokens[1]);
11092   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11093   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11094 }
11095
11096 /* ffestb_R11072_ -- "USE" NAME COMMA
11097
11098    return ffestb_R11072_;  // to lexer
11099
11100    Make sure the statement has a valid form for the USE statement.  If it
11101    does, implement the statement.  */
11102
11103 static ffelexHandler
11104 ffestb_R11072_ (ffelexToken t)
11105 {
11106   switch (ffelex_token_type (t))
11107     {
11108     case FFELEX_typeNAME:
11109       ffesta_tokens[2] = ffelex_token_use (t);
11110       return (ffelexHandler) ffestb_R11073_;
11111
11112     default:
11113       break;
11114     }
11115
11116   ffelex_token_kill (ffesta_tokens[1]);
11117   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11118   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11119 }
11120
11121 /* ffestb_R11073_ -- "USE" NAME COMMA NAME
11122
11123    return ffestb_R11073_;  // to lexer
11124
11125    Make sure the statement has a valid form for the USE statement.  If it
11126    does, implement the statement.  */
11127
11128 static ffelexHandler
11129 ffestb_R11073_ (ffelexToken t)
11130 {
11131   switch (ffelex_token_type (t))
11132     {
11133     case FFELEX_typeCOLON:
11134       if (ffestr_other (ffesta_tokens[2]) != FFESTR_otherONLY)
11135         break;
11136       if (!ffesta_is_inhibited ())
11137         ffestc_R1107_start (ffesta_tokens[1], TRUE);
11138       ffelex_token_kill (ffesta_tokens[1]);
11139       ffelex_token_kill (ffesta_tokens[2]);
11140       return (ffelexHandler) ffestb_R11074_;
11141
11142     case FFELEX_typePOINTS:
11143       if (!ffesta_is_inhibited ())
11144         ffestc_R1107_start (ffesta_tokens[1], FALSE);
11145       ffelex_token_kill (ffesta_tokens[1]);
11146       ffesta_tokens[1] = ffesta_tokens[2];
11147       return (ffelexHandler) ffestb_R110711_;
11148
11149     default:
11150       break;
11151     }
11152
11153   ffelex_token_kill (ffesta_tokens[1]);
11154   ffelex_token_kill (ffesta_tokens[2]);
11155   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11156   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11157 }
11158
11159 /* ffestb_R11074_ -- "USE" NAME COMMA "ONLY" COLON
11160
11161    return ffestb_R11074_;  // to lexer
11162
11163    Make sure the statement has a valid form for the USE statement.  If it
11164    does, implement the statement.  */
11165
11166 static ffelexHandler
11167 ffestb_R11074_ (ffelexToken t)
11168 {
11169   switch (ffelex_token_type (t))
11170     {
11171     case FFELEX_typeNAME:
11172       ffesta_tokens[1] = ffelex_token_use (t);
11173       return (ffelexHandler) ffestb_R11075_;
11174
11175     case FFELEX_typeEOS:
11176     case FFELEX_typeSEMICOLON:
11177       if (!ffesta_is_inhibited ())
11178         ffestc_R1107_finish ();
11179       return (ffelexHandler) ffesta_zero (t);
11180
11181     default:
11182       break;
11183     }
11184
11185   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11186   ffestc_R1107_finish ();
11187   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11188 }
11189
11190 /* ffestb_R11075_ -- "USE" NAME COMMA "ONLY" COLON NAME
11191
11192    return ffestb_R11075_;  // to lexer
11193
11194    Make sure the statement has a valid form for the USE statement.  If it
11195    does, implement the statement.  */
11196
11197 static ffelexHandler
11198 ffestb_R11075_ (ffelexToken t)
11199 {
11200   switch (ffelex_token_type (t))
11201     {
11202     case FFELEX_typeEOS:
11203     case FFELEX_typeSEMICOLON:
11204       if (!ffesta_is_inhibited ())
11205         {
11206           ffestc_R1107_item (NULL, ffesta_tokens[1]);
11207           ffestc_R1107_finish ();
11208         }
11209       ffelex_token_kill (ffesta_tokens[1]);
11210       return (ffelexHandler) ffesta_zero (t);
11211
11212     case FFELEX_typeCOMMA:
11213       if (!ffesta_is_inhibited ())
11214         ffestc_R1107_item (NULL, ffesta_tokens[1]);
11215       ffelex_token_kill (ffesta_tokens[1]);
11216       return (ffelexHandler) ffestb_R11078_;
11217
11218     case FFELEX_typePOINTS:
11219       return (ffelexHandler) ffestb_R11076_;
11220
11221     default:
11222       break;
11223     }
11224
11225   ffelex_token_kill (ffesta_tokens[1]);
11226   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11227   ffestc_R1107_finish ();
11228   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11229 }
11230
11231 /* ffestb_R11076_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS
11232
11233    return ffestb_R11076_;  // to lexer
11234
11235    Make sure the statement has a valid form for the USE statement.  If it
11236    does, implement the statement.  */
11237
11238 static ffelexHandler
11239 ffestb_R11076_ (ffelexToken t)
11240 {
11241   switch (ffelex_token_type (t))
11242     {
11243     case FFELEX_typeNAME:
11244       if (!ffesta_is_inhibited ())
11245         ffestc_R1107_item (ffesta_tokens[1], t);
11246       ffelex_token_kill (ffesta_tokens[1]);
11247       return (ffelexHandler) ffestb_R11077_;
11248
11249     default:
11250       break;
11251     }
11252
11253   ffelex_token_kill (ffesta_tokens[1]);
11254   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11255   ffestc_R1107_finish ();
11256   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11257 }
11258
11259 /* ffestb_R11077_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS NAME
11260
11261    return ffestb_R11077_;  // to lexer
11262
11263    Make sure the statement has a valid form for the USE statement.  If it
11264    does, implement the statement.  */
11265
11266 static ffelexHandler
11267 ffestb_R11077_ (ffelexToken t)
11268 {
11269   switch (ffelex_token_type (t))
11270     {
11271     case FFELEX_typeEOS:
11272     case FFELEX_typeSEMICOLON:
11273       if (!ffesta_is_inhibited ())
11274         ffestc_R1107_finish ();
11275       return (ffelexHandler) ffesta_zero (t);
11276
11277     case FFELEX_typeCOMMA:
11278       return (ffelexHandler) ffestb_R11078_;
11279
11280     default:
11281       break;
11282     }
11283
11284   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11285   ffestc_R1107_finish ();
11286   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11287 }
11288
11289 /* ffestb_R11078_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS NAME COMMA
11290
11291    return ffestb_R11078_;  // to lexer
11292
11293    Make sure the statement has a valid form for the USE statement.  If it
11294    does, implement the statement.  */
11295
11296 static ffelexHandler
11297 ffestb_R11078_ (ffelexToken t)
11298 {
11299   switch (ffelex_token_type (t))
11300     {
11301     case FFELEX_typeNAME:
11302       ffesta_tokens[1] = ffelex_token_use (t);
11303       return (ffelexHandler) ffestb_R11075_;
11304
11305     default:
11306       break;
11307     }
11308
11309   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11310   ffestc_R1107_finish ();
11311   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11312 }
11313
11314 /* ffestb_R11079_ -- "USE" NAME COMMA
11315
11316    return ffestb_R11079_;  // to lexer
11317
11318    Make sure the statement has a valid form for the USE statement.  If it
11319    does, implement the statement.  */
11320
11321 static ffelexHandler
11322 ffestb_R11079_ (ffelexToken t)
11323 {
11324   switch (ffelex_token_type (t))
11325     {
11326     case FFELEX_typeNAME:
11327       ffesta_tokens[1] = ffelex_token_use (t);
11328       return (ffelexHandler) ffestb_R110710_;
11329
11330     default:
11331       break;
11332     }
11333
11334   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11335   ffestc_R1107_finish ();
11336   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11337 }
11338
11339 /* ffestb_R110710_ -- "USE" NAME COMMA NAME
11340
11341    return ffestb_R110710_;  // to lexer
11342
11343    Make sure the statement has a valid form for the USE statement.  If it
11344    does, implement the statement.  */
11345
11346 static ffelexHandler
11347 ffestb_R110710_ (ffelexToken t)
11348 {
11349   switch (ffelex_token_type (t))
11350     {
11351     case FFELEX_typePOINTS:
11352       return (ffelexHandler) ffestb_R110711_;
11353
11354     default:
11355       break;
11356     }
11357
11358   ffelex_token_kill (ffesta_tokens[1]);
11359   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11360   ffestc_R1107_finish ();
11361   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11362 }
11363
11364 /* ffestb_R110711_ -- "USE" NAME COMMA NAME POINTS
11365
11366    return ffestb_R110711_;  // to lexer
11367
11368    Make sure the statement has a valid form for the USE statement.  If it
11369    does, implement the statement.  */
11370
11371 static ffelexHandler
11372 ffestb_R110711_ (ffelexToken t)
11373 {
11374   switch (ffelex_token_type (t))
11375     {
11376     case FFELEX_typeNAME:
11377       if (!ffesta_is_inhibited ())
11378         ffestc_R1107_item (ffesta_tokens[1], t);
11379       ffelex_token_kill (ffesta_tokens[1]);
11380       return (ffelexHandler) ffestb_R110712_;
11381
11382     default:
11383       break;
11384     }
11385
11386   ffelex_token_kill (ffesta_tokens[1]);
11387   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11388   ffestc_R1107_finish ();
11389   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11390 }
11391
11392 /* ffestb_R110712_ -- "USE" NAME COMMA NAME POINTS NAME
11393
11394    return ffestb_R110712_;  // to lexer
11395
11396    Make sure the statement has a valid form for the USE statement.  If it
11397    does, implement the statement.  */
11398
11399 static ffelexHandler
11400 ffestb_R110712_ (ffelexToken t)
11401 {
11402   switch (ffelex_token_type (t))
11403     {
11404     case FFELEX_typeEOS:
11405     case FFELEX_typeSEMICOLON:
11406       if (!ffesta_is_inhibited ())
11407         ffestc_R1107_finish ();
11408       return (ffelexHandler) ffesta_zero (t);
11409
11410     case FFELEX_typeCOMMA:
11411       return (ffelexHandler) ffestb_R11079_;
11412
11413     default:
11414       break;
11415     }
11416
11417   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
11418   ffestc_R1107_finish ();
11419   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11420 }
11421
11422 #endif
11423 /* ffestb_R1202 -- Parse the INTERFACE statement
11424
11425    return ffestb_R1202;  // to lexer
11426
11427    Make sure the statement has a valid form for the INTERFACE statement.
11428    If it does, implement the statement.
11429
11430    15-May-90  JCB  1.1
11431       Allow INTERFACE by itself; missed this
11432       valid form when originally doing syntactic analysis code.  */
11433
11434 #if FFESTR_F90
11435 ffelexHandler
11436 ffestb_R1202 (ffelexToken t)
11437 {
11438   ffeTokenLength i;
11439   const char *p;
11440
11441   switch (ffelex_token_type (ffesta_tokens[0]))
11442     {
11443     case FFELEX_typeNAME:
11444       if (ffesta_first_kw != FFESTR_firstINTERFACE)
11445         goto bad_0;             /* :::::::::::::::::::: */
11446       switch (ffelex_token_type (t))
11447         {
11448         case FFELEX_typeNAME:
11449           break;
11450
11451         case FFELEX_typeEOS:
11452         case FFELEX_typeSEMICOLON:
11453           ffesta_confirmed ();
11454           if (!ffesta_is_inhibited ())
11455             ffestc_R1202 (FFESTP_definedoperatorNone, NULL);
11456           return (ffelexHandler) ffesta_zero (t);
11457
11458         case FFELEX_typeCOMMA:
11459         case FFELEX_typeCOLONCOLON:
11460           ffesta_confirmed ();  /* Error, but clearly intended. */
11461           goto bad_1;           /* :::::::::::::::::::: */
11462
11463         default:
11464           goto bad_1;           /* :::::::::::::::::::: */
11465         }
11466
11467       ffesta_confirmed ();
11468       switch (ffesta_second_kw)
11469         {
11470         case FFESTR_secondOPERATOR:
11471           ffestb_local_.interface.operator = FFESTP_definedoperatorOPERATOR;
11472           break;
11473
11474         case FFESTR_secondASSIGNMENT:
11475           ffestb_local_.interface.operator = FFESTP_definedoperatorASSIGNMENT;
11476           break;
11477
11478         default:
11479           ffestb_local_.interface.operator = FFESTP_definedoperatorNone;
11480           break;
11481         }
11482       ffesta_tokens[1] = ffelex_token_use (t);
11483       return (ffelexHandler) ffestb_R12021_;
11484
11485     case FFELEX_typeNAMES:
11486       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlINTERFACE);
11487       switch (ffesta_first_kw)
11488         {
11489         case FFESTR_firstINTERFACEOPERATOR:
11490           if (*(ffelex_token_text (ffesta_tokens[0])
11491                 + FFESTR_firstlINTERFACEOPERATOR) == '\0')
11492             ffestb_local_.interface.operator
11493               = FFESTP_definedoperatorOPERATOR;
11494           break;
11495
11496         case FFESTR_firstINTERFACEASSGNMNT:
11497           if (*(ffelex_token_text (ffesta_tokens[0])
11498                 + FFESTR_firstlINTERFACEASSGNMNT) == '\0')
11499             ffestb_local_.interface.operator
11500               = FFESTP_definedoperatorASSIGNMENT;
11501           break;
11502
11503         case FFESTR_firstINTERFACE:
11504           ffestb_local_.interface.operator = FFESTP_definedoperatorNone;
11505           break;
11506
11507         default:
11508           goto bad_0;           /* :::::::::::::::::::: */
11509         }
11510       switch (ffelex_token_type (t))
11511         {
11512         case FFELEX_typeCOMMA:
11513         case FFELEX_typeCOLONCOLON:
11514           ffesta_confirmed ();  /* Error, but clearly intended. */
11515           goto bad_1;           /* :::::::::::::::::::: */
11516
11517         default:
11518           goto bad_1;           /* :::::::::::::::::::: */
11519
11520         case FFELEX_typeOPEN_PAREN:
11521         case FFELEX_typeOPEN_ARRAY:     /* Sigh. */
11522           break;
11523
11524         case FFELEX_typeEOS:
11525         case FFELEX_typeSEMICOLON:
11526           ffesta_confirmed ();
11527           if (*p == '\0')
11528             {
11529               if (!ffesta_is_inhibited ())
11530                 ffestc_R1202 (FFESTP_definedoperatorNone, NULL);
11531               return (ffelexHandler) ffesta_zero (t);
11532             }
11533           break;
11534         }
11535       if (!ffesrc_is_name_init (*p))
11536         goto bad_i;             /* :::::::::::::::::::: */
11537       ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
11538       return (ffelexHandler) ffestb_R12021_ (t);
11539
11540     default:
11541       goto bad_0;               /* :::::::::::::::::::: */
11542     }
11543
11544 bad_0:                          /* :::::::::::::::::::: */
11545   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", ffesta_tokens[0]);
11546   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11547
11548 bad_1:                          /* :::::::::::::::::::: */
11549   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11550   return (ffelexHandler) ffelex_swallow_tokens (t,
11551                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
11552
11553 bad_i:                          /* :::::::::::::::::::: */
11554   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "INTERFACE", ffesta_tokens[0], i, t);
11555   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11556 }
11557
11558 /* ffestb_R12021_ -- "INTERFACE" NAME
11559
11560    return ffestb_R12021_;  // to lexer
11561
11562    Make sure the statement has a valid form for the INTERFACE statement.  If
11563    it does, implement the statement.  */
11564
11565 static ffelexHandler
11566 ffestb_R12021_ (ffelexToken t)
11567 {
11568   ffestb_local_.interface.slash = TRUE; /* Slash follows open paren. */
11569
11570   switch (ffelex_token_type (t))
11571     {
11572     case FFELEX_typeEOS:
11573     case FFELEX_typeSEMICOLON:
11574       if (!ffesta_is_inhibited ())
11575         ffestc_R1202 (FFESTP_definedoperatorNone, ffesta_tokens[1]);
11576       ffelex_token_kill (ffesta_tokens[1]);
11577       return (ffelexHandler) ffesta_zero (t);
11578
11579     case FFELEX_typeOPEN_PAREN:
11580       ffestb_local_.interface.slash = FALSE;    /* Slash doesn't follow. */
11581       /* Fall through. */
11582     case FFELEX_typeOPEN_ARRAY:
11583       switch (ffestb_local_.interface.operator)
11584         {
11585         case FFESTP_definedoperatorNone:
11586           break;
11587
11588         case FFESTP_definedoperatorOPERATOR:
11589           ffestb_local_.interface.assignment = FALSE;
11590           return (ffelexHandler) ffestb_R12022_;
11591
11592         case FFESTP_definedoperatorASSIGNMENT:
11593           ffestb_local_.interface.assignment = TRUE;
11594           return (ffelexHandler) ffestb_R12022_;
11595
11596         default:
11597           assert (FALSE);
11598         }
11599       break;
11600
11601     case FFELEX_typeCOMMA:
11602     case FFELEX_typeCOLONCOLON:
11603       ffesta_confirmed ();      /* Error, but clearly intended. */
11604       break;
11605
11606     default:
11607       break;
11608     }
11609
11610   ffelex_token_kill (ffesta_tokens[1]);
11611   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11612   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11613 }
11614
11615 /* ffestb_R12022_ -- "INTERFACE" "OPERATOR/ASSIGNMENT" OPEN_PAREN
11616
11617    return ffestb_R12022_;  // to lexer
11618
11619    Make sure the statement has a valid form for the INTERFACE statement.  If
11620    it does, implement the statement.  */
11621
11622 static ffelexHandler
11623 ffestb_R12022_ (ffelexToken t)
11624 {
11625   ffesta_tokens[2] = ffelex_token_use (t);
11626
11627   switch (ffelex_token_type (t))
11628     {
11629     case FFELEX_typePERIOD:
11630       if (ffestb_local_.interface.slash)
11631         break;
11632       return (ffelexHandler) ffestb_R12023_;
11633
11634     case FFELEX_typePOWER:
11635       if (ffestb_local_.interface.slash)
11636         break;
11637       ffestb_local_.interface.operator = FFESTP_definedoperatorPOWER;
11638       return (ffelexHandler) ffestb_R12025_;
11639
11640     case FFELEX_typeASTERISK:
11641       if (ffestb_local_.interface.slash)
11642         break;
11643       ffestb_local_.interface.operator = FFESTP_definedoperatorMULT;
11644       return (ffelexHandler) ffestb_R12025_;
11645
11646     case FFELEX_typePLUS:
11647       if (ffestb_local_.interface.slash)
11648         break;
11649       ffestb_local_.interface.operator = FFESTP_definedoperatorADD;
11650       return (ffelexHandler) ffestb_R12025_;
11651
11652     case FFELEX_typeCONCAT:
11653       if (ffestb_local_.interface.slash)
11654         break;
11655       ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
11656       return (ffelexHandler) ffestb_R12025_;
11657
11658     case FFELEX_typeSLASH:
11659       if (ffestb_local_.interface.slash)
11660         {
11661           ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
11662           return (ffelexHandler) ffestb_R12025_;
11663         }
11664       ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
11665       return (ffelexHandler) ffestb_R12025_;
11666
11667     case FFELEX_typeMINUS:
11668       if (ffestb_local_.interface.slash)
11669         break;
11670       ffestb_local_.interface.operator = FFESTP_definedoperatorSUBTRACT;
11671       return (ffelexHandler) ffestb_R12025_;
11672
11673     case FFELEX_typeREL_EQ:
11674       if (ffestb_local_.interface.slash)
11675         break;
11676       ffestb_local_.interface.operator = FFESTP_definedoperatorEQ;
11677       return (ffelexHandler) ffestb_R12025_;
11678
11679     case FFELEX_typeREL_NE:
11680       if (ffestb_local_.interface.slash)
11681         break;
11682       ffestb_local_.interface.operator = FFESTP_definedoperatorNE;
11683       return (ffelexHandler) ffestb_R12025_;
11684
11685     case FFELEX_typeOPEN_ANGLE:
11686       if (ffestb_local_.interface.slash)
11687         break;
11688       ffestb_local_.interface.operator = FFESTP_definedoperatorLT;
11689       return (ffelexHandler) ffestb_R12025_;
11690
11691     case FFELEX_typeREL_LE:
11692       if (ffestb_local_.interface.slash)
11693         break;
11694       ffestb_local_.interface.operator = FFESTP_definedoperatorLE;
11695       return (ffelexHandler) ffestb_R12025_;
11696
11697     case FFELEX_typeCLOSE_ANGLE:
11698       if (ffestb_local_.interface.slash)
11699         break;
11700       ffestb_local_.interface.operator = FFESTP_definedoperatorGT;
11701       return (ffelexHandler) ffestb_R12025_;
11702
11703     case FFELEX_typeREL_GE:
11704       if (ffestb_local_.interface.slash)
11705         break;
11706       ffestb_local_.interface.operator = FFESTP_definedoperatorGE;
11707       return (ffelexHandler) ffestb_R12025_;
11708
11709     case FFELEX_typeEQUALS:
11710       if (ffestb_local_.interface.slash)
11711         {
11712           ffestb_local_.interface.operator = FFESTP_definedoperatorNE;
11713           return (ffelexHandler) ffestb_R12025_;
11714         }
11715       ffestb_local_.interface.operator = FFESTP_definedoperatorASSIGNMENT;
11716       return (ffelexHandler) ffestb_R12025_;
11717
11718     case FFELEX_typeCLOSE_ARRAY:
11719       if (!ffestb_local_.interface.slash)
11720         {
11721           ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
11722           return (ffelexHandler) ffestb_R12026_;
11723         }
11724       ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
11725       return (ffelexHandler) ffestb_R12026_;
11726
11727     case FFELEX_typeCLOSE_PAREN:
11728       if (!ffestb_local_.interface.slash)
11729         break;
11730       ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
11731       return (ffelexHandler) ffestb_R12026_;
11732
11733     default:
11734       break;
11735     }
11736
11737   ffelex_token_kill (ffesta_tokens[1]);
11738   ffelex_token_kill (ffesta_tokens[2]);
11739   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11740   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11741 }
11742
11743 /* ffestb_R12023_ -- "INTERFACE" NAME OPEN_PAREN PERIOD
11744
11745    return ffestb_R12023_;  // to lexer
11746
11747    Make sure the statement has a valid form for the INTERFACE statement.  If
11748    it does, implement the statement.  */
11749
11750 static ffelexHandler
11751 ffestb_R12023_ (ffelexToken t)
11752 {
11753   switch (ffelex_token_type (t))
11754     {
11755     case FFELEX_typeNAME:
11756       ffelex_token_kill (ffesta_tokens[2]);
11757       ffesta_tokens[2] = ffelex_token_use (t);
11758       return (ffelexHandler) ffestb_R12024_;
11759
11760     default:
11761       break;
11762     }
11763
11764   ffelex_token_kill (ffesta_tokens[1]);
11765   ffelex_token_kill (ffesta_tokens[2]);
11766   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11767   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11768 }
11769
11770 /* ffestb_R12024_ -- "INTERFACE" NAME OPEN_PAREN PERIOD NAME
11771
11772    return ffestb_R12024_;  // to lexer
11773
11774    Make sure the statement has a valid form for the INTERFACE statement.  If
11775    it does, implement the statement.  */
11776
11777 static ffelexHandler
11778 ffestb_R12024_ (ffelexToken t)
11779 {
11780   switch (ffelex_token_type (t))
11781     {
11782     case FFELEX_typePERIOD:
11783       return (ffelexHandler) ffestb_R12025_;
11784
11785     default:
11786       break;
11787     }
11788
11789   ffelex_token_kill (ffesta_tokens[1]);
11790   ffelex_token_kill (ffesta_tokens[2]);
11791   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11792   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11793 }
11794
11795 /* ffestb_R12025_ -- "INTERFACE" NAME OPEN_PAREN operator
11796
11797    return ffestb_R12025_;  // to lexer
11798
11799    Make sure the statement has a valid form for the INTERFACE statement.  If
11800    it does, implement the statement.  */
11801
11802 static ffelexHandler
11803 ffestb_R12025_ (ffelexToken t)
11804 {
11805   switch (ffelex_token_type (t))
11806     {
11807     case FFELEX_typeCLOSE_PAREN:
11808       return (ffelexHandler) ffestb_R12026_;
11809
11810     default:
11811       break;
11812     }
11813
11814   ffelex_token_kill (ffesta_tokens[1]);
11815   ffelex_token_kill (ffesta_tokens[2]);
11816   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11817   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11818 }
11819
11820 /* ffestb_R12026_ -- "INTERFACE" NAME OPEN_PAREN operator CLOSE_PAREN
11821
11822    return ffestb_R12026_;  // to lexer
11823
11824    Make sure the statement has a valid form for the INTERFACE statement.  If
11825    it does, implement the statement.  */
11826
11827 static ffelexHandler
11828 ffestb_R12026_ (ffelexToken t)
11829 {
11830   const char *p;
11831
11832   switch (ffelex_token_type (t))
11833     {
11834     case FFELEX_typeEOS:
11835     case FFELEX_typeSEMICOLON:
11836       ffesta_confirmed ();
11837       if (ffestb_local_.interface.assignment
11838           && (ffestb_local_.interface.operator
11839               != FFESTP_definedoperatorASSIGNMENT))
11840         {
11841           ffebad_start (FFEBAD_INTERFACE_ASSIGNMENT);
11842           ffebad_here (0, ffelex_token_where_line (ffesta_tokens[1]),
11843                        ffelex_token_where_column (ffesta_tokens[1]));
11844           ffebad_here (1, ffelex_token_where_line (ffesta_tokens[2]),
11845                        ffelex_token_where_column (ffesta_tokens[2]));
11846           ffebad_finish ();
11847         }
11848       switch (ffelex_token_type (ffesta_tokens[2]))
11849         {
11850         case FFELEX_typeNAME:
11851           switch (ffestr_other (ffesta_tokens[2]))
11852             {
11853             case FFESTR_otherNOT:
11854               if (!ffesta_is_inhibited ())
11855                 ffestc_R1202 (FFESTP_definedoperatorNOT, NULL);
11856               break;
11857
11858             case FFESTR_otherAND:
11859               if (!ffesta_is_inhibited ())
11860                 ffestc_R1202 (FFESTP_definedoperatorAND, NULL);
11861               break;
11862
11863             case FFESTR_otherOR:
11864               if (!ffesta_is_inhibited ())
11865                 ffestc_R1202 (FFESTP_definedoperatorOR, NULL);
11866               break;
11867
11868             case FFESTR_otherEQV:
11869               if (!ffesta_is_inhibited ())
11870                 ffestc_R1202 (FFESTP_definedoperatorEQV, NULL);
11871               break;
11872
11873             case FFESTR_otherNEQV:
11874               if (!ffesta_is_inhibited ())
11875                 ffestc_R1202 (FFESTP_definedoperatorNEQV, NULL);
11876               break;
11877
11878             case FFESTR_otherEQ:
11879               if (!ffesta_is_inhibited ())
11880                 ffestc_R1202 (FFESTP_definedoperatorEQ, NULL);
11881               break;
11882
11883             case FFESTR_otherNE:
11884               if (!ffesta_is_inhibited ())
11885                 ffestc_R1202 (FFESTP_definedoperatorNE, NULL);
11886               break;
11887
11888             case FFESTR_otherLT:
11889               if (!ffesta_is_inhibited ())
11890                 ffestc_R1202 (FFESTP_definedoperatorLT, NULL);
11891               break;
11892
11893             case FFESTR_otherLE:
11894               if (!ffesta_is_inhibited ())
11895                 ffestc_R1202 (FFESTP_definedoperatorLE, NULL);
11896               break;
11897
11898             case FFESTR_otherGT:
11899               if (!ffesta_is_inhibited ())
11900                 ffestc_R1202 (FFESTP_definedoperatorGT, NULL);
11901               break;
11902
11903             case FFESTR_otherGE:
11904               if (!ffesta_is_inhibited ())
11905                 ffestc_R1202 (FFESTP_definedoperatorGE, NULL);
11906               break;
11907
11908             default:
11909               for (p = ffelex_token_text (ffesta_tokens[2]); *p != '\0'; ++p)
11910                 {
11911                   if (! ISALPHA (*p))
11912                     {
11913                       ffelex_token_kill (ffesta_tokens[1]);
11914                       ffelex_token_kill (ffesta_tokens[2]);
11915                       ffesta_ffebad_1t (FFEBAD_INTERFACE_NONLETTER,
11916                                         ffesta_tokens[2]);
11917                       return (ffelexHandler) ffelex_swallow_tokens (t,
11918                                                (ffelexHandler) ffesta_zero);
11919                     }
11920                 }
11921               if (!ffesta_is_inhibited ())
11922                 ffestc_R1202 (FFESTP_definedoperatorOPERATOR,
11923                               ffesta_tokens[2]);
11924             }
11925           break;
11926
11927         case FFELEX_typeEQUALS:
11928           if (!ffestb_local_.interface.assignment
11929               && (ffestb_local_.interface.operator
11930                   == FFESTP_definedoperatorASSIGNMENT))
11931             {
11932               ffebad_start (FFEBAD_INTERFACE_OPERATOR);
11933               ffebad_here (0, ffelex_token_where_line (ffesta_tokens[1]),
11934                            ffelex_token_where_column (ffesta_tokens[1]));
11935               ffebad_here (1, ffelex_token_where_line (ffesta_tokens[2]),
11936                            ffelex_token_where_column (ffesta_tokens[2]));
11937               ffebad_finish ();
11938             }
11939           if (!ffesta_is_inhibited ())
11940             ffestc_R1202 (ffestb_local_.interface.operator, NULL);
11941           break;
11942
11943         default:
11944           if (!ffesta_is_inhibited ())
11945             ffestc_R1202 (ffestb_local_.interface.operator, NULL);
11946         }
11947       ffelex_token_kill (ffesta_tokens[1]);
11948       ffelex_token_kill (ffesta_tokens[2]);
11949       return (ffelexHandler) ffesta_zero (t);
11950
11951     default:
11952       break;
11953     }
11954
11955   ffelex_token_kill (ffesta_tokens[1]);
11956   ffelex_token_kill (ffesta_tokens[2]);
11957   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
11958   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
11959 }
11960
11961 #endif
11962 /* ffestb_S3P4 -- Parse the INCLUDE line
11963
11964    return ffestb_S3P4;  // to lexer
11965
11966    Make sure the statement has a valid form for the INCLUDE line.  If it
11967    does, implement the statement.  */
11968
11969 ffelexHandler
11970 ffestb_S3P4 (ffelexToken t)
11971 {
11972   ffeTokenLength i;
11973   const char *p;
11974   ffelexHandler next;
11975   ffelexToken nt;
11976   ffelexToken ut;
11977
11978   switch (ffelex_token_type (ffesta_tokens[0]))
11979     {
11980     case FFELEX_typeNAME:
11981       if (ffesta_first_kw != FFESTR_firstINCLUDE)
11982         goto bad_0;             /* :::::::::::::::::::: */
11983       switch (ffelex_token_type (t))
11984         {
11985         case FFELEX_typeNUMBER:
11986         case FFELEX_typeAPOSTROPHE:
11987         case FFELEX_typeQUOTE:
11988           break;
11989
11990         default:
11991           goto bad_1;           /* :::::::::::::::::::: */
11992         }
11993       ffesta_confirmed ();
11994       return (ffelexHandler) (*((ffelexHandler)
11995                     ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextINCLUDE,
11996                                  (ffeexprCallback) ffestb_S3P41_)))
11997         (t);
11998
11999     case FFELEX_typeNAMES:
12000       if (ffesta_first_kw != FFESTR_firstINCLUDE)
12001         goto bad_0;             /* :::::::::::::::::::: */
12002       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlINCLUDE);
12003       switch (ffelex_token_type (t))
12004         {
12005         default:
12006           goto bad_1;           /* :::::::::::::::::::: */
12007
12008         case FFELEX_typeAPOSTROPHE:
12009         case FFELEX_typeQUOTE:
12010           break;
12011         }
12012       ffesta_confirmed ();
12013       if (*p == '\0')
12014         return (ffelexHandler) (*((ffelexHandler)
12015                     ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextINCLUDE,
12016                                  (ffeexprCallback) ffestb_S3P41_)))
12017           (t);
12018       if (! ISDIGIT (*p))
12019         goto bad_i;             /* :::::::::::::::::::: */
12020       nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
12021       p += ffelex_token_length (nt);
12022       i += ffelex_token_length (nt);
12023       if ((*p != '_') || (++i, *++p != '\0'))
12024         {
12025           ffelex_token_kill (nt);
12026           goto bad_i;           /* :::::::::::::::::::: */
12027         }
12028       ut = ffelex_token_uscore_from_names (ffesta_tokens[0], i - 1);
12029       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs
12030                                 (ffesta_output_pool, FFEEXPR_contextINCLUDE,
12031                                  (ffeexprCallback) ffestb_S3P41_)))
12032         (nt);
12033       ffelex_token_kill (nt);
12034       next = (ffelexHandler) (*next) (ut);
12035       ffelex_token_kill (ut);
12036       return (ffelexHandler) (*next) (t);
12037
12038     default:
12039       goto bad_0;               /* :::::::::::::::::::: */
12040     }
12041
12042 bad_0:                          /* :::::::::::::::::::: */
12043   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", ffesta_tokens[0]);
12044   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12045
12046 bad_1:                          /* :::::::::::::::::::: */
12047   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", t);
12048   return (ffelexHandler) ffelex_swallow_tokens (t,
12049                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
12050
12051 bad_i:                          /* :::::::::::::::::::: */
12052   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "INCLUDE", ffesta_tokens[0], i, t);
12053   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12054 }
12055
12056 /* ffestb_S3P41_ -- "INCLUDE" [NUMBER "_"] expr
12057
12058    (ffestb_S3P41_)  // to expression handler
12059
12060    Make sure the next token is an EOS, but not a SEMICOLON.  */
12061
12062 static ffelexHandler
12063 ffestb_S3P41_ (ffelexToken ft, ffebld expr, ffelexToken t)
12064 {
12065   switch (ffelex_token_type (t))
12066     {
12067     case FFELEX_typeEOS:
12068     case FFELEX_typeSEMICOLON:
12069       if (expr == NULL)
12070         break;
12071       if (!ffesta_is_inhibited ())
12072         {
12073           if (ffe_is_pedantic ()
12074               && ((ffelex_token_type (t) == FFELEX_typeSEMICOLON)
12075                   || ffesta_line_has_semicolons))
12076             {
12077               /* xgettext:no-c-format */
12078               ffebad_start_msg ("INCLUDE at %0 not the only statement on the source line", FFEBAD_severityWARNING);
12079               ffebad_here (0, ffelex_token_where_line (ffesta_tokens[0]),
12080                            ffelex_token_where_column (ffesta_tokens[0]));
12081               ffebad_finish ();
12082             }
12083           ffestc_S3P4 (expr, ft);
12084         }
12085       return (ffelexHandler) ffesta_zero (t);
12086
12087     default:
12088       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", t);
12089       break;
12090     }
12091
12092   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12093 }
12094
12095 /* ffestb_V012 -- Parse the MAP statement
12096
12097    return ffestb_V012;  // to lexer
12098
12099    Make sure the statement has a valid form for the MAP statement.  If
12100    it does, implement the statement.  */
12101
12102 #if FFESTR_VXT
12103 ffelexHandler
12104 ffestb_V012 (ffelexToken t)
12105 {
12106   const char *p;
12107   ffeTokenLength i;
12108
12109   switch (ffelex_token_type (ffesta_tokens[0]))
12110     {
12111     case FFELEX_typeNAME:
12112       if (ffesta_first_kw != FFESTR_firstMAP)
12113         goto bad_0;             /* :::::::::::::::::::: */
12114       break;
12115
12116     case FFELEX_typeNAMES:
12117       if (ffesta_first_kw != FFESTR_firstMAP)
12118         goto bad_0;             /* :::::::::::::::::::: */
12119       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlMAP)
12120         {
12121           p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlMAP);
12122           goto bad_i;           /* :::::::::::::::::::: */
12123         }
12124       break;
12125
12126     default:
12127       goto bad_0;               /* :::::::::::::::::::: */
12128     }
12129
12130   switch (ffelex_token_type (t))
12131     {
12132     case FFELEX_typeEOS:
12133     case FFELEX_typeSEMICOLON:
12134       ffesta_confirmed ();
12135       if (!ffesta_is_inhibited ())
12136         ffestc_V012 ();
12137       return (ffelexHandler) ffesta_zero (t);
12138
12139     case FFELEX_typeCOMMA:
12140     case FFELEX_typeCOLONCOLON:
12141       ffesta_confirmed ();      /* Error, but clearly intended. */
12142       goto bad_1;               /* :::::::::::::::::::: */
12143
12144     default:
12145       goto bad_1;               /* :::::::::::::::::::: */
12146     }
12147
12148 bad_0:                          /* :::::::::::::::::::: */
12149   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MAP", ffesta_tokens[0]);
12150   return (ffelexHandler) ffelex_swallow_tokens (t,
12151                                                 (ffelexHandler) ffesta_zero);   /* Invalid first token. */
12152
12153 bad_1:                          /* :::::::::::::::::::: */
12154   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MAP", t);
12155   return (ffelexHandler) ffelex_swallow_tokens (t,
12156                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
12157
12158 bad_i:                          /* :::::::::::::::::::: */
12159   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "MAP", ffesta_tokens[0], i, t);
12160   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12161 }
12162
12163 #endif
12164 /* ffestb_V014 -- Parse the VOLATILE statement
12165
12166    return ffestb_V014;  // to lexer
12167
12168    Make sure the statement has a valid form for the VOLATILE statement.  If it
12169    does, implement the statement.  */
12170
12171 ffelexHandler
12172 ffestb_V014 (ffelexToken t)
12173 {
12174   ffeTokenLength i;
12175   unsigned const char *p;
12176   ffelexToken nt;
12177   ffelexHandler next;
12178
12179   switch (ffelex_token_type (ffesta_tokens[0]))
12180     {
12181     case FFELEX_typeNAME:
12182       if (ffesta_first_kw != FFESTR_firstVOLATILE)
12183         goto bad_0;             /* :::::::::::::::::::: */
12184       switch (ffelex_token_type (t))
12185         {
12186         case FFELEX_typeEOS:
12187         case FFELEX_typeSEMICOLON:
12188         case FFELEX_typeCOMMA:
12189           ffesta_confirmed ();  /* Error, but clearly intended. */
12190           goto bad_1;           /* :::::::::::::::::::: */
12191
12192         default:
12193           goto bad_1;           /* :::::::::::::::::::: */
12194
12195         case FFELEX_typeNAME:
12196         case FFELEX_typeSLASH:
12197           ffesta_confirmed ();
12198           if (!ffesta_is_inhibited ())
12199             ffestc_V014_start ();
12200           return (ffelexHandler) ffestb_V0141_ (t);
12201
12202         case FFELEX_typeCOLONCOLON:
12203           ffesta_confirmed ();
12204           if (!ffesta_is_inhibited ())
12205             ffestc_V014_start ();
12206           return (ffelexHandler) ffestb_V0141_;
12207         }
12208
12209     case FFELEX_typeNAMES:
12210       if (ffesta_first_kw != FFESTR_firstVOLATILE)
12211         goto bad_0;             /* :::::::::::::::::::: */
12212       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlVOLATILE);
12213       switch (ffelex_token_type (t))
12214         {
12215         default:
12216           goto bad_1;           /* :::::::::::::::::::: */
12217
12218         case FFELEX_typeCOMMA:
12219         case FFELEX_typeEOS:
12220         case FFELEX_typeSEMICOLON:
12221           ffesta_confirmed ();
12222           break;
12223
12224         case FFELEX_typeSLASH:
12225           ffesta_confirmed ();
12226           if (*p != '\0')
12227             goto bad_i;         /* :::::::::::::::::::: */
12228           if (!ffesta_is_inhibited ())
12229             ffestc_V014_start ();
12230           return (ffelexHandler) ffestb_V0141_ (t);
12231
12232         case FFELEX_typeCOLONCOLON:
12233           ffesta_confirmed ();
12234           if (*p != '\0')
12235             goto bad_i;         /* :::::::::::::::::::: */
12236           if (!ffesta_is_inhibited ())
12237             ffestc_V014_start ();
12238           return (ffelexHandler) ffestb_V0141_;
12239         }
12240
12241       /* Here, we have at least one char after "VOLATILE" and t is COMMA or
12242          EOS/SEMICOLON. */
12243
12244       if (!ffesrc_is_name_init (*p))
12245         goto bad_i;             /* :::::::::::::::::::: */
12246       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
12247       if (!ffesta_is_inhibited ())
12248         ffestc_V014_start ();
12249       next = (ffelexHandler) ffestb_V0141_ (nt);
12250       ffelex_token_kill (nt);
12251       return (ffelexHandler) (*next) (t);
12252
12253     default:
12254       goto bad_0;               /* :::::::::::::::::::: */
12255     }
12256
12257 bad_0:                          /* :::::::::::::::::::: */
12258   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", ffesta_tokens[0]);
12259   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12260
12261 bad_1:                          /* :::::::::::::::::::: */
12262   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12263   return (ffelexHandler) ffelex_swallow_tokens (t,
12264                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
12265
12266 bad_i:                          /* :::::::::::::::::::: */
12267   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "VOLATILE", ffesta_tokens[0], i, t);
12268   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12269 }
12270
12271 /* ffestb_V0141_ -- "VOLATILE" [COLONCOLON]
12272
12273    return ffestb_V0141_;  // to lexer
12274
12275    Handle NAME or SLASH.  */
12276
12277 static ffelexHandler
12278 ffestb_V0141_ (ffelexToken t)
12279 {
12280   switch (ffelex_token_type (t))
12281     {
12282     case FFELEX_typeNAME:
12283       ffestb_local_.V014.is_cblock = FALSE;
12284       ffesta_tokens[1] = ffelex_token_use (t);
12285       return (ffelexHandler) ffestb_V0144_;
12286
12287     case FFELEX_typeSLASH:
12288       ffestb_local_.V014.is_cblock = TRUE;
12289       return (ffelexHandler) ffestb_V0142_;
12290
12291     default:
12292       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12293       break;
12294     }
12295
12296   if (!ffesta_is_inhibited ())
12297     ffestc_V014_finish ();
12298   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12299 }
12300
12301 /* ffestb_V0142_ -- "VOLATILE" [COLONCOLON] SLASH
12302
12303    return ffestb_V0142_;  // to lexer
12304
12305    Handle NAME.  */
12306
12307 static ffelexHandler
12308 ffestb_V0142_ (ffelexToken t)
12309 {
12310   switch (ffelex_token_type (t))
12311     {
12312     case FFELEX_typeNAME:
12313       ffesta_tokens[1] = ffelex_token_use (t);
12314       return (ffelexHandler) ffestb_V0143_;
12315
12316     default:
12317       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12318       break;
12319     }
12320
12321   if (!ffesta_is_inhibited ())
12322     ffestc_V014_finish ();
12323   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12324 }
12325
12326 /* ffestb_V0143_ -- "VOLATILE" [COLONCOLON] SLASH NAME
12327
12328    return ffestb_V0143_;  // to lexer
12329
12330    Handle SLASH.  */
12331
12332 static ffelexHandler
12333 ffestb_V0143_ (ffelexToken t)
12334 {
12335   switch (ffelex_token_type (t))
12336     {
12337     case FFELEX_typeSLASH:
12338       return (ffelexHandler) ffestb_V0144_;
12339
12340     default:
12341       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12342       break;
12343     }
12344
12345   if (!ffesta_is_inhibited ())
12346     ffestc_V014_finish ();
12347   ffelex_token_kill (ffesta_tokens[1]);
12348   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12349 }
12350
12351 /* ffestb_V0144_ -- "VOLATILE" [COLONCOLON] R523
12352
12353    return ffestb_V0144_;  // to lexer
12354
12355    Handle COMMA or EOS/SEMICOLON.  */
12356
12357 static ffelexHandler
12358 ffestb_V0144_ (ffelexToken t)
12359 {
12360   switch (ffelex_token_type (t))
12361     {
12362     case FFELEX_typeCOMMA:
12363       if (!ffesta_is_inhibited ())
12364         {
12365           if (ffestb_local_.V014.is_cblock)
12366             ffestc_V014_item_cblock (ffesta_tokens[1]);
12367           else
12368             ffestc_V014_item_object (ffesta_tokens[1]);
12369         }
12370       ffelex_token_kill (ffesta_tokens[1]);
12371       return (ffelexHandler) ffestb_V0141_;
12372
12373     case FFELEX_typeEOS:
12374     case FFELEX_typeSEMICOLON:
12375       if (!ffesta_is_inhibited ())
12376         {
12377           if (ffestb_local_.V014.is_cblock)
12378             ffestc_V014_item_cblock (ffesta_tokens[1]);
12379           else
12380             ffestc_V014_item_object (ffesta_tokens[1]);
12381           ffestc_V014_finish ();
12382         }
12383       ffelex_token_kill (ffesta_tokens[1]);
12384       return (ffelexHandler) ffesta_zero (t);
12385
12386     default:
12387       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
12388       break;
12389     }
12390
12391   if (!ffesta_is_inhibited ())
12392     ffestc_V014_finish ();
12393   ffelex_token_kill (ffesta_tokens[1]);
12394   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12395 }
12396
12397 /* ffestb_V025 -- Parse the DEFINEFILE statement
12398
12399    return ffestb_V025;  // to lexer
12400
12401    Make sure the statement has a valid form for the DEFINEFILE statement.
12402    If it does, implement the statement.  */
12403
12404 #if FFESTR_VXT
12405 ffelexHandler
12406 ffestb_V025 (ffelexToken t)
12407 {
12408   ffeTokenLength i;
12409   const char *p;
12410   ffelexToken nt;
12411   ffelexHandler next;
12412
12413   ffestb_local_.V025.started = FALSE;
12414   switch (ffelex_token_type (ffesta_tokens[0]))
12415     {
12416     case FFELEX_typeNAME:
12417       switch (ffesta_first_kw)
12418         {
12419         case FFESTR_firstDEFINE:
12420           if ((ffelex_token_type (t) != FFELEX_typeNAME)
12421               || (ffesta_second_kw != FFESTR_secondFILE))
12422             goto bad_1;         /* :::::::::::::::::::: */
12423           ffesta_confirmed ();
12424           return (ffelexHandler) ffestb_V0251_;
12425
12426         case FFESTR_firstDEFINEFILE:
12427           return (ffelexHandler) ffestb_V0251_ (t);
12428
12429         default:
12430           goto bad_0;           /* :::::::::::::::::::: */
12431         }
12432
12433     case FFELEX_typeNAMES:
12434       if (ffesta_first_kw != FFESTR_firstDEFINEFILE)
12435         goto bad_0;             /* :::::::::::::::::::: */
12436       switch (ffelex_token_type (t))
12437         {
12438         case FFELEX_typeCOMMA:
12439         case FFELEX_typeEOS:
12440         case FFELEX_typeSEMICOLON:
12441         case FFELEX_typeCOLONCOLON:
12442           ffesta_confirmed ();  /* Error, but clearly intended. */
12443           goto bad_1;           /* :::::::::::::::::::: */
12444
12445         default:
12446           goto bad_1;           /* :::::::::::::::::::: */
12447
12448         case FFELEX_typeOPEN_PAREN:
12449           break;
12450         }
12451       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDEFINEFILE);
12452       if (ISDIGIT (*p))
12453         nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
12454       else if (ffesrc_is_name_init (*p))
12455         nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
12456       else
12457         goto bad_i;             /* :::::::::::::::::::: */
12458       next = (ffelexHandler) ffestb_V0251_ (nt);
12459       ffelex_token_kill (nt);
12460       return (ffelexHandler) (*next) (t);
12461
12462     default:
12463       goto bad_0;               /* :::::::::::::::::::: */
12464     }
12465
12466 bad_0:                          /* :::::::::::::::::::: */
12467   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", ffesta_tokens[0]);
12468   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12469
12470 bad_1:                          /* :::::::::::::::::::: */
12471   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12472   return (ffelexHandler) ffelex_swallow_tokens (t,
12473                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
12474
12475 bad_i:                          /* :::::::::::::::::::: */
12476   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", ffesta_tokens[0], i, t);
12477   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12478 }
12479
12480 /* ffestb_V0251_ -- "DEFINEFILE" or "DEFINE" "FILE"
12481
12482    return ffestb_V0251_;  // to lexer
12483
12484    Make sure the statement has a valid form for the DEFINEFILE statement.  If it
12485    does, implement the statement.  */
12486
12487 static ffelexHandler
12488 ffestb_V0251_ (ffelexToken t)
12489 {
12490   switch (ffelex_token_type (t))
12491     {
12492     case FFELEX_typeNAME:
12493     case FFELEX_typeNUMBER:
12494       if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
12495         ffesta_confirmed ();
12496       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12497               FFEEXPR_contextFILEUNIT_DF, (ffeexprCallback) ffestb_V0252_)))
12498         (t);
12499
12500     case FFELEX_typeEOS:
12501     case FFELEX_typeSEMICOLON:
12502     case FFELEX_typeCOMMA:
12503     case FFELEX_typeCOLONCOLON:
12504       ffesta_confirmed ();      /* Error, but clearly intended. */
12505       break;
12506
12507     default:
12508       break;
12509     }
12510
12511   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12512   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12513 }
12514
12515 /* ffestb_V0252_ -- "DEFINEFILE" expr
12516
12517    (ffestb_V0252_)  // to expression handler
12518
12519    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12520    it does, implement the statement.  */
12521
12522 static ffelexHandler
12523 ffestb_V0252_ (ffelexToken ft, ffebld expr, ffelexToken t)
12524 {
12525   switch (ffelex_token_type (t))
12526     {
12527     case FFELEX_typeOPEN_PAREN:
12528       ffestb_local_.V025.u = expr;
12529       ffesta_tokens[1] = ffelex_token_use (ft);
12530       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12531                    FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0253_);
12532
12533     default:
12534       break;
12535     }
12536
12537   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12538   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12539 }
12540
12541 /* ffestb_V0253_ -- "DEFINEFILE" expr OPEN_PAREN expr
12542
12543    (ffestb_V0253_)  // to expression handler
12544
12545    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12546    it does, implement the statement.  */
12547
12548 static ffelexHandler
12549 ffestb_V0253_ (ffelexToken ft, ffebld expr, ffelexToken t)
12550 {
12551   switch (ffelex_token_type (t))
12552     {
12553     case FFELEX_typeCOMMA:
12554       ffestb_local_.V025.m = expr;
12555       ffesta_tokens[2] = ffelex_token_use (ft);
12556       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12557                    FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0254_);
12558
12559     default:
12560       break;
12561     }
12562
12563   ffelex_token_kill (ffesta_tokens[1]);
12564   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12565   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12566 }
12567
12568 /* ffestb_V0254_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr
12569
12570    (ffestb_V0254_)  // to expression handler
12571
12572    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12573    it does, implement the statement.  */
12574
12575 static ffelexHandler
12576 ffestb_V0254_ (ffelexToken ft, ffebld expr, ffelexToken t)
12577 {
12578   switch (ffelex_token_type (t))
12579     {
12580     case FFELEX_typeCOMMA:
12581       ffestb_local_.V025.n = expr;
12582       ffesta_tokens[3] = ffelex_token_use (ft);
12583       return (ffelexHandler) ffestb_V0255_;
12584
12585     default:
12586       break;
12587     }
12588
12589   ffelex_token_kill (ffesta_tokens[1]);
12590   ffelex_token_kill (ffesta_tokens[2]);
12591   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12592   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12593 }
12594
12595 /* ffestb_V0255_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA
12596
12597    return ffestb_V0255_;  // to lexer
12598
12599    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12600    it does, implement the statement.  */
12601
12602 static ffelexHandler
12603 ffestb_V0255_ (ffelexToken t)
12604 {
12605   const char *p;
12606
12607   switch (ffelex_token_type (t))
12608     {
12609     case FFELEX_typeNAME:
12610       p = ffelex_token_text (t);
12611       if (!ffesrc_char_match_init (*p, 'U', 'u') || (*++p != '\0'))
12612         break;
12613       return (ffelexHandler) ffestb_V0256_;
12614
12615     default:
12616       break;
12617     }
12618
12619   ffelex_token_kill (ffesta_tokens[1]);
12620   ffelex_token_kill (ffesta_tokens[2]);
12621   ffelex_token_kill (ffesta_tokens[3]);
12622   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12623   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12624 }
12625
12626 /* ffestb_V0256_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
12627
12628    return ffestb_V0256_;  // to lexer
12629
12630    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12631    it does, implement the statement.  */
12632
12633 static ffelexHandler
12634 ffestb_V0256_ (ffelexToken t)
12635 {
12636   switch (ffelex_token_type (t))
12637     {
12638     case FFELEX_typeCOMMA:
12639       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
12640                                           FFEEXPR_contextFILEASSOC,
12641                                           (ffeexprCallback) ffestb_V0257_);
12642
12643     default:
12644       break;
12645     }
12646
12647   ffelex_token_kill (ffesta_tokens[1]);
12648   ffelex_token_kill (ffesta_tokens[2]);
12649   ffelex_token_kill (ffesta_tokens[3]);
12650   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12651   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12652 }
12653
12654 /* ffestb_V0257_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
12655                     COMMA expr
12656
12657    (ffestb_V0257_)  // to expression handler
12658
12659    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12660    it does, implement the statement.  */
12661
12662 static ffelexHandler
12663 ffestb_V0257_ (ffelexToken ft, ffebld expr, ffelexToken t)
12664 {
12665   switch (ffelex_token_type (t))
12666     {
12667     case FFELEX_typeCLOSE_PAREN:
12668       ffestb_local_.V025.asv = expr;
12669       ffesta_tokens[4] = ffelex_token_use (ft);
12670       return (ffelexHandler) ffestb_V0258_;
12671
12672     default:
12673       break;
12674     }
12675
12676   ffelex_token_kill (ffesta_tokens[1]);
12677   ffelex_token_kill (ffesta_tokens[2]);
12678   ffelex_token_kill (ffesta_tokens[3]);
12679   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12680   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12681 }
12682
12683 /* ffestb_V0258_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
12684                     COMMA expr CLOSE_PAREN
12685
12686    return ffestb_V0258_;  // to lexer
12687
12688    Make sure the statement has a valid form for the DEFINEFILE statement.  If
12689    it does, implement the statement.  */
12690
12691 static ffelexHandler
12692 ffestb_V0258_ (ffelexToken t)
12693 {
12694   switch (ffelex_token_type (t))
12695     {
12696     case FFELEX_typeCOMMA:
12697     case FFELEX_typeEOS:
12698     case FFELEX_typeSEMICOLON:
12699       if (!ffestb_local_.V025.started)
12700         {
12701           ffesta_confirmed ();
12702           if (!ffesta_is_inhibited ())
12703             ffestc_V025_start ();
12704           ffestb_local_.V025.started = TRUE;
12705         }
12706       if (!ffesta_is_inhibited ())
12707         ffestc_V025_item (ffestb_local_.V025.u, ffesta_tokens[1],
12708                           ffestb_local_.V025.m, ffesta_tokens[2],
12709                           ffestb_local_.V025.n, ffesta_tokens[3],
12710                           ffestb_local_.V025.asv, ffesta_tokens[4]);
12711       ffelex_token_kill (ffesta_tokens[1]);
12712       ffelex_token_kill (ffesta_tokens[2]);
12713       ffelex_token_kill (ffesta_tokens[3]);
12714       ffelex_token_kill (ffesta_tokens[4]);
12715       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
12716         return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
12717                FFEEXPR_contextFILEUNIT_DF, (ffeexprCallback) ffestb_V0252_);
12718       if (!ffesta_is_inhibited ())
12719         ffestc_V025_finish ();
12720       return (ffelexHandler) ffesta_zero (t);
12721
12722     default:
12723       break;
12724     }
12725
12726   ffelex_token_kill (ffesta_tokens[1]);
12727   ffelex_token_kill (ffesta_tokens[2]);
12728   ffelex_token_kill (ffesta_tokens[3]);
12729   ffelex_token_kill (ffesta_tokens[4]);
12730   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
12731   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
12732 }
12733
12734 #endif
12735 /* ffestb_subr_kill_easy_ -- Kill I/O statement data structure
12736
12737    ffestb_subr_kill_easy_();
12738
12739    Kills all tokens in the I/O data structure.  Assumes that they are
12740    overlaid with each other (union) in ffest_private.h and the typing
12741    and structure references assume (though not necessarily dangerous if
12742    FALSE) that INQUIRE has the most file elements.  */
12743
12744 #if FFESTB_KILL_EASY_
12745 static void
12746 ffestb_subr_kill_easy_ (ffestpInquireIx max)
12747 {
12748   ffestpInquireIx ix;
12749
12750   for (ix = 0; ix < max; ++ix)
12751     {
12752       if (ffestp_file.inquire.inquire_spec[ix].kw_or_val_present)
12753         {
12754           if (ffestp_file.inquire.inquire_spec[ix].kw_present)
12755             ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].kw);
12756           if (ffestp_file.inquire.inquire_spec[ix].value_present)
12757             ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].value);
12758         }
12759     }
12760 }
12761
12762 #endif
12763 /* ffestb_subr_kill_accept_ -- Kill ACCEPT statement data structure
12764
12765    ffestb_subr_kill_accept_();
12766
12767    Kills all tokens in the ACCEPT data structure.  */
12768
12769 #if !FFESTB_KILL_EASY_
12770 static void
12771 ffestb_subr_kill_accept_ ()
12772 {
12773   ffestpAcceptIx ix;
12774
12775   for (ix = 0; ix < FFESTP_acceptix; ++ix)
12776     {
12777       if (ffestp_file.accept.accept_spec[ix].kw_or_val_present)
12778         {
12779           if (ffestp_file.accept.accept_spec[ix].kw_present)
12780             ffelex_token_kill (ffestp_file.accept.accept_spec[ix].kw);
12781           if (ffestp_file.accept.accept_spec[ix].value_present)
12782             ffelex_token_kill (ffestp_file.accept.accept_spec[ix].value);
12783         }
12784     }
12785 }
12786
12787 #endif
12788 /* ffestb_subr_kill_beru_ -- Kill BACKSPACE/ENDFILE/REWIND/UNLOCK statement
12789                             data structure
12790
12791    ffestb_subr_kill_beru_();
12792
12793    Kills all tokens in the BACKSPACE/ENDFILE/REWIND/UNLOCK data structure.  */
12794
12795 #if !FFESTB_KILL_EASY_
12796 static void
12797 ffestb_subr_kill_beru_ ()
12798 {
12799   ffestpBeruIx ix;
12800
12801   for (ix = 0; ix < FFESTP_beruix; ++ix)
12802     {
12803       if (ffestp_file.beru.beru_spec[ix].kw_or_val_present)
12804         {
12805           if (ffestp_file.beru.beru_spec[ix].kw_present)
12806             ffelex_token_kill (ffestp_file.beru.beru_spec[ix].kw);
12807           if (ffestp_file.beru.beru_spec[ix].value_present)
12808             ffelex_token_kill (ffestp_file.beru.beru_spec[ix].value);
12809         }
12810     }
12811 }
12812
12813 #endif
12814 /* ffestb_subr_kill_close_ -- Kill CLOSE statement data structure
12815
12816    ffestb_subr_kill_close_();
12817
12818    Kills all tokens in the CLOSE data structure.  */
12819
12820 #if !FFESTB_KILL_EASY_
12821 static void
12822 ffestb_subr_kill_close_ ()
12823 {
12824   ffestpCloseIx ix;
12825
12826   for (ix = 0; ix < FFESTP_closeix; ++ix)
12827     {
12828       if (ffestp_file.close.close_spec[ix].kw_or_val_present)
12829         {
12830           if (ffestp_file.close.close_spec[ix].kw_present)
12831             ffelex_token_kill (ffestp_file.close.close_spec[ix].kw);
12832           if (ffestp_file.close.close_spec[ix].value_present)
12833             ffelex_token_kill (ffestp_file.close.close_spec[ix].value);
12834         }
12835     }
12836 }
12837
12838 #endif
12839 /* ffestb_subr_kill_delete_ -- Kill DELETE statement data structure
12840
12841    ffestb_subr_kill_delete_();
12842
12843    Kills all tokens in the DELETE data structure.  */
12844
12845 #if !FFESTB_KILL_EASY_
12846 static void
12847 ffestb_subr_kill_delete_ ()
12848 {
12849   ffestpDeleteIx ix;
12850
12851   for (ix = 0; ix < FFESTP_deleteix; ++ix)
12852     {
12853       if (ffestp_file.delete.delete_spec[ix].kw_or_val_present)
12854         {
12855           if (ffestp_file.delete.delete_spec[ix].kw_present)
12856             ffelex_token_kill (ffestp_file.delete.delete_spec[ix].kw);
12857           if (ffestp_file.delete.delete_spec[ix].value_present)
12858             ffelex_token_kill (ffestp_file.delete.delete_spec[ix].value);
12859         }
12860     }
12861 }
12862
12863 #endif
12864 /* ffestb_subr_kill_inquire_ -- Kill INQUIRE statement data structure
12865
12866    ffestb_subr_kill_inquire_();
12867
12868    Kills all tokens in the INQUIRE data structure.  */
12869
12870 #if !FFESTB_KILL_EASY_
12871 static void
12872 ffestb_subr_kill_inquire_ ()
12873 {
12874   ffestpInquireIx ix;
12875
12876   for (ix = 0; ix < FFESTP_inquireix; ++ix)
12877     {
12878       if (ffestp_file.inquire.inquire_spec[ix].kw_or_val_present)
12879         {
12880           if (ffestp_file.inquire.inquire_spec[ix].kw_present)
12881             ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].kw);
12882           if (ffestp_file.inquire.inquire_spec[ix].value_present)
12883             ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].value);
12884         }
12885     }
12886 }
12887
12888 #endif
12889 /* ffestb_subr_kill_open_ -- Kill OPEN statement data structure
12890
12891    ffestb_subr_kill_open_();
12892
12893    Kills all tokens in the OPEN data structure.  */
12894
12895 #if !FFESTB_KILL_EASY_
12896 static void
12897 ffestb_subr_kill_open_ ()
12898 {
12899   ffestpOpenIx ix;
12900
12901   for (ix = 0; ix < FFESTP_openix; ++ix)
12902     {
12903       if (ffestp_file.open.open_spec[ix].kw_or_val_present)
12904         {
12905           if (ffestp_file.open.open_spec[ix].kw_present)
12906             ffelex_token_kill (ffestp_file.open.open_spec[ix].kw);
12907           if (ffestp_file.open.open_spec[ix].value_present)
12908             ffelex_token_kill (ffestp_file.open.open_spec[ix].value);
12909         }
12910     }
12911 }
12912
12913 #endif
12914 /* ffestb_subr_kill_print_ -- Kill PRINT statement data structure
12915
12916    ffestb_subr_kill_print_();
12917
12918    Kills all tokens in the PRINT data structure.  */
12919
12920 #if !FFESTB_KILL_EASY_
12921 static void
12922 ffestb_subr_kill_print_ ()
12923 {
12924   ffestpPrintIx ix;
12925
12926   for (ix = 0; ix < FFESTP_printix; ++ix)
12927     {
12928       if (ffestp_file.print.print_spec[ix].kw_or_val_present)
12929         {
12930           if (ffestp_file.print.print_spec[ix].kw_present)
12931             ffelex_token_kill (ffestp_file.print.print_spec[ix].kw);
12932           if (ffestp_file.print.print_spec[ix].value_present)
12933             ffelex_token_kill (ffestp_file.print.print_spec[ix].value);
12934         }
12935     }
12936 }
12937
12938 #endif
12939 /* ffestb_subr_kill_read_ -- Kill READ statement data structure
12940
12941    ffestb_subr_kill_read_();
12942
12943    Kills all tokens in the READ data structure.  */
12944
12945 #if !FFESTB_KILL_EASY_
12946 static void
12947 ffestb_subr_kill_read_ ()
12948 {
12949   ffestpReadIx ix;
12950
12951   for (ix = 0; ix < FFESTP_readix; ++ix)
12952     {
12953       if (ffestp_file.read.read_spec[ix].kw_or_val_present)
12954         {
12955           if (ffestp_file.read.read_spec[ix].kw_present)
12956             ffelex_token_kill (ffestp_file.read.read_spec[ix].kw);
12957           if (ffestp_file.read.read_spec[ix].value_present)
12958             ffelex_token_kill (ffestp_file.read.read_spec[ix].value);
12959         }
12960     }
12961 }
12962
12963 #endif
12964 /* ffestb_subr_kill_rewrite_ -- Kill REWRITE statement data structure
12965
12966    ffestb_subr_kill_rewrite_();
12967
12968    Kills all tokens in the REWRITE data structure.  */
12969
12970 #if !FFESTB_KILL_EASY_
12971 static void
12972 ffestb_subr_kill_rewrite_ ()
12973 {
12974   ffestpRewriteIx ix;
12975
12976   for (ix = 0; ix < FFESTP_rewriteix; ++ix)
12977     {
12978       if (ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present)
12979         {
12980           if (ffestp_file.rewrite.rewrite_spec[ix].kw_present)
12981             ffelex_token_kill (ffestp_file.rewrite.rewrite_spec[ix].kw);
12982           if (ffestp_file.rewrite.rewrite_spec[ix].value_present)
12983             ffelex_token_kill (ffestp_file.rewrite.rewrite_spec[ix].value);
12984         }
12985     }
12986 }
12987
12988 #endif
12989 /* ffestb_subr_kill_type_ -- Kill TYPE statement data structure
12990
12991    ffestb_subr_kill_type_();
12992
12993    Kills all tokens in the TYPE data structure.  */
12994
12995 #if !FFESTB_KILL_EASY_
12996 static void
12997 ffestb_subr_kill_type_ ()
12998 {
12999   ffestpTypeIx ix;
13000
13001   for (ix = 0; ix < FFESTP_typeix; ++ix)
13002     {
13003       if (ffestp_file.type.type_spec[ix].kw_or_val_present)
13004         {
13005           if (ffestp_file.type.type_spec[ix].kw_present)
13006             ffelex_token_kill (ffestp_file.type.type_spec[ix].kw);
13007           if (ffestp_file.type.type_spec[ix].value_present)
13008             ffelex_token_kill (ffestp_file.type.type_spec[ix].value);
13009         }
13010     }
13011 }
13012
13013 #endif
13014 /* ffestb_subr_kill_write_ -- Kill WRITE statement data structure
13015
13016    ffestb_subr_kill_write_();
13017
13018    Kills all tokens in the WRITE data structure.  */
13019
13020 #if !FFESTB_KILL_EASY_
13021 static void
13022 ffestb_subr_kill_write_ ()
13023 {
13024   ffestpWriteIx ix;
13025
13026   for (ix = 0; ix < FFESTP_writeix; ++ix)
13027     {
13028       if (ffestp_file.write.write_spec[ix].kw_or_val_present)
13029         {
13030           if (ffestp_file.write.write_spec[ix].kw_present)
13031             ffelex_token_kill (ffestp_file.write.write_spec[ix].kw);
13032           if (ffestp_file.write.write_spec[ix].value_present)
13033             ffelex_token_kill (ffestp_file.write.write_spec[ix].value);
13034         }
13035     }
13036 }
13037
13038 #endif
13039 /* ffestb_beru -- Parse the BACKSPACE/ENDFILE/REWIND/UNLOCK statement
13040
13041    return ffestb_beru;  // to lexer
13042
13043    Make sure the statement has a valid form for the BACKSPACE/ENDFILE/REWIND/
13044    UNLOCK statement.  If it does, implement the statement.  */
13045
13046 ffelexHandler
13047 ffestb_beru (ffelexToken t)
13048 {
13049   ffelexHandler next;
13050   ffestpBeruIx ix;
13051
13052   switch (ffelex_token_type (ffesta_tokens[0]))
13053     {
13054     case FFELEX_typeNAME:
13055       switch (ffelex_token_type (t))
13056         {
13057         case FFELEX_typeCOMMA:
13058         case FFELEX_typeCOLONCOLON:
13059         case FFELEX_typeEOS:
13060         case FFELEX_typeSEMICOLON:
13061           ffesta_confirmed ();  /* Error, but clearly intended. */
13062           goto bad_1;           /* :::::::::::::::::::: */
13063
13064         case FFELEX_typeEQUALS:
13065         case FFELEX_typePOINTS:
13066         case FFELEX_typeCOLON:
13067           goto bad_1;           /* :::::::::::::::::::: */
13068
13069         case FFELEX_typeNAME:
13070         case FFELEX_typeNUMBER:
13071           ffesta_confirmed ();
13072           break;
13073
13074         case FFELEX_typeOPEN_PAREN:
13075           for (ix = 0; ix < FFESTP_beruix; ++ix)
13076             ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13077           ffesta_tokens[1] = ffelex_token_use (t);
13078           return (ffelexHandler) ffestb_beru2_;
13079
13080         default:
13081           break;
13082         }
13083
13084       for (ix = 0; ix < FFESTP_beruix; ++ix)
13085         ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13086       return (ffelexHandler) (*((ffelexHandler)
13087                                 ffeexpr_rhs (ffesta_output_pool,
13088                                              FFEEXPR_contextFILENUM,
13089                                           (ffeexprCallback) ffestb_beru1_)))
13090         (t);
13091
13092     case FFELEX_typeNAMES:
13093       switch (ffelex_token_type (t))
13094         {
13095         case FFELEX_typeCOMMA:
13096         case FFELEX_typeCOLONCOLON:
13097           ffesta_confirmed ();  /* Error, but clearly intended. */
13098           goto bad_1;           /* :::::::::::::::::::: */
13099
13100         case FFELEX_typeEQUALS:
13101         case FFELEX_typePOINTS:
13102         case FFELEX_typeCOLON:
13103           goto bad_1;           /* :::::::::::::::::::: */
13104
13105         case FFELEX_typeEOS:
13106         case FFELEX_typeSEMICOLON:
13107           ffesta_confirmed ();
13108           break;
13109
13110         case FFELEX_typeOPEN_PAREN:
13111           if (ffelex_token_length (ffesta_tokens[0])
13112               != ffestb_args.beru.len)
13113             break;
13114
13115           for (ix = 0; ix < FFESTP_beruix; ++ix)
13116             ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13117           ffesta_tokens[1] = ffelex_token_use (t);
13118           return (ffelexHandler) ffestb_beru2_;
13119
13120         default:
13121           break;
13122         }
13123       for (ix = 0; ix < FFESTP_beruix; ++ix)
13124         ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
13125       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13126                    FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_beru1_);
13127       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
13128                                                    ffestb_args.beru.len);
13129       if (next == NULL)
13130         return (ffelexHandler) ffelex_swallow_tokens (t,
13131                                                (ffelexHandler) ffesta_zero);
13132       return (ffelexHandler) (*next) (t);
13133
13134     default:
13135       goto bad_0;               /* :::::::::::::::::::: */
13136     }
13137
13138 bad_0:                          /* :::::::::::::::::::: */
13139   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, ffesta_tokens[0]);
13140   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13141
13142 bad_1:                          /* :::::::::::::::::::: */
13143   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13144   return (ffelexHandler) ffelex_swallow_tokens (t,
13145                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
13146 }
13147
13148 /* ffestb_beru1_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" expr
13149
13150    (ffestb_beru1_)  // to expression handler
13151
13152    Make sure the next token is an EOS or SEMICOLON.  */
13153
13154 static ffelexHandler
13155 ffestb_beru1_ (ffelexToken ft, ffebld expr, ffelexToken t)
13156 {
13157   switch (ffelex_token_type (t))
13158     {
13159     case FFELEX_typeEOS:
13160     case FFELEX_typeSEMICOLON:
13161       if (expr == NULL)
13162         break;
13163       ffesta_confirmed ();
13164       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_or_val_present
13165         = TRUE;
13166       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_present = FALSE;
13167       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_present = TRUE;
13168       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_is_label
13169         = FALSE;
13170       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value
13171         = ffelex_token_use (ft);
13172       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].u.expr = expr;
13173       if (!ffesta_is_inhibited ())
13174         {
13175           switch (ffesta_first_kw)
13176             {
13177             case FFESTR_firstBACKSPACE:
13178               ffestc_R919 ();
13179               break;
13180
13181             case FFESTR_firstENDFILE:
13182             case FFESTR_firstEND:
13183               ffestc_R920 ();
13184               break;
13185
13186             case FFESTR_firstREWIND:
13187               ffestc_R921 ();
13188               break;
13189
13190 #if FFESTR_VXT
13191             case FFESTR_firstUNLOCK:
13192               ffestc_V022 ();
13193               break;
13194 #endif
13195
13196             default:
13197               assert (FALSE);
13198             }
13199         }
13200       ffestb_subr_kill_beru_ ();
13201       return (ffelexHandler) ffesta_zero (t);
13202
13203     default:
13204       break;
13205     }
13206
13207   ffestb_subr_kill_beru_ ();
13208   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13209   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13210 }
13211
13212 /* ffestb_beru2_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN
13213
13214    return ffestb_beru2_;  // to lexer
13215
13216    Handle expr construct (not NAME=expr construct) here.  */
13217
13218 static ffelexHandler
13219 ffestb_beru2_ (ffelexToken t)
13220 {
13221   ffelexToken nt;
13222   ffelexHandler next;
13223
13224   switch (ffelex_token_type (t))
13225     {
13226     case FFELEX_typeNAME:
13227       ffesta_tokens[2] = ffelex_token_use (t);
13228       return (ffelexHandler) ffestb_beru3_;
13229
13230     default:
13231       nt = ffesta_tokens[1];
13232       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13233              FFEEXPR_contextFILENUMAMBIG, (ffeexprCallback) ffestb_beru4_)))
13234         (nt);
13235       ffelex_token_kill (nt);
13236       return (ffelexHandler) (*next) (t);
13237     }
13238 }
13239
13240 /* ffestb_beru3_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN NAME
13241
13242    return ffestb_beru3_;  // to lexer
13243
13244    If EQUALS here, go to states that handle it.  Else, send NAME and this
13245    token thru expression handler.  */
13246
13247 static ffelexHandler
13248 ffestb_beru3_ (ffelexToken t)
13249 {
13250   ffelexHandler next;
13251   ffelexToken nt;
13252   ffelexToken ot;
13253
13254   switch (ffelex_token_type (t))
13255     {
13256     case FFELEX_typeEQUALS:
13257       ffelex_token_kill (ffesta_tokens[1]);
13258       nt = ffesta_tokens[2];
13259       next = (ffelexHandler) ffestb_beru5_ (nt);
13260       ffelex_token_kill (nt);
13261       return (ffelexHandler) (*next) (t);
13262
13263     default:
13264       nt = ffesta_tokens[1];
13265       ot = ffesta_tokens[2];
13266       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13267              FFEEXPR_contextFILENUMAMBIG, (ffeexprCallback) ffestb_beru4_)))
13268         (nt);
13269       ffelex_token_kill (nt);
13270       next = (ffelexHandler) (*next) (ot);
13271       ffelex_token_kill (ot);
13272       return (ffelexHandler) (*next) (t);
13273     }
13274 }
13275
13276 /* ffestb_beru4_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN expr [CLOSE_PAREN]
13277
13278    (ffestb_beru4_)  // to expression handler
13279
13280    Handle COMMA or EOS/SEMICOLON here.
13281
13282    15-Feb-91  JCB  1.2
13283       Now using new mechanism whereby expr comes back as opITEM if the
13284       expr is considered part (or all) of an I/O control list (and should
13285       be stripped of its outer opITEM node) or not if it is considered
13286       a plain unit number that happens to have been enclosed in parens.
13287    26-Mar-90  JCB  1.1
13288       No longer expecting close-paren here because of constructs like
13289       BACKSPACE (5)+2, so now expecting either COMMA because it was a
13290       construct like BACKSPACE (5+2,... or EOS/SEMICOLON because it is like
13291       the former construct.  Ah, the vagaries of Fortran.  */
13292
13293 static ffelexHandler
13294 ffestb_beru4_ (ffelexToken ft, ffebld expr, ffelexToken t)
13295 {
13296   bool inlist;
13297
13298   switch (ffelex_token_type (t))
13299     {
13300     case FFELEX_typeCOMMA:
13301     case FFELEX_typeEOS:
13302     case FFELEX_typeSEMICOLON:
13303     case FFELEX_typeCLOSE_PAREN:
13304       if (expr == NULL)
13305         break;
13306       if (ffebld_op (expr) == FFEBLD_opITEM)
13307         {
13308           inlist = TRUE;
13309           expr = ffebld_head (expr);
13310         }
13311       else
13312         inlist = FALSE;
13313       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_or_val_present
13314         = TRUE;
13315       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_present = FALSE;
13316       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_present = TRUE;
13317       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_is_label
13318         = FALSE;
13319       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value
13320         = ffelex_token_use (ft);
13321       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].u.expr = expr;
13322       if (inlist)
13323         return (ffelexHandler) ffestb_beru9_ (t);
13324       return (ffelexHandler) ffestb_beru10_ (t);
13325
13326     default:
13327       break;
13328     }
13329
13330   ffestb_subr_kill_beru_ ();
13331   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13332   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13333 }
13334
13335 /* ffestb_beru5_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN [external-file-unit
13336                     COMMA]
13337
13338    return ffestb_beru5_;  // to lexer
13339
13340    Handle expr construct (not NAME=expr construct) here.  */
13341
13342 static ffelexHandler
13343 ffestb_beru5_ (ffelexToken t)
13344 {
13345   ffestrGenio kw;
13346
13347   ffestb_local_.beru.label = FALSE;
13348
13349   switch (ffelex_token_type (t))
13350     {
13351     case FFELEX_typeNAME:
13352       kw = ffestr_genio (t);
13353       switch (kw)
13354         {
13355         case FFESTR_genioERR:
13356           ffestb_local_.beru.ix = FFESTP_beruixERR;
13357           ffestb_local_.beru.label = TRUE;
13358           break;
13359
13360         case FFESTR_genioIOSTAT:
13361           ffestb_local_.beru.ix = FFESTP_beruixIOSTAT;
13362           ffestb_local_.beru.left = TRUE;
13363           ffestb_local_.beru.context = FFEEXPR_contextFILEINT;
13364           break;
13365
13366         case FFESTR_genioUNIT:
13367           ffestb_local_.beru.ix = FFESTP_beruixUNIT;
13368           ffestb_local_.beru.left = FALSE;
13369           ffestb_local_.beru.context = FFEEXPR_contextFILENUM;
13370           break;
13371
13372         default:
13373           goto bad;             /* :::::::::::::::::::: */
13374         }
13375       if (ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13376           .kw_or_val_present)
13377         break;                  /* Can't specify a keyword twice! */
13378       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13379         .kw_or_val_present = TRUE;
13380       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13381         .kw_present = TRUE;
13382       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
13383         .value_present = FALSE;
13384       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value_is_label
13385         = ffestb_local_.beru.label;
13386       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].kw
13387         = ffelex_token_use (t);
13388       return (ffelexHandler) ffestb_beru6_;
13389
13390     default:
13391       break;
13392     }
13393
13394 bad:                            /* :::::::::::::::::::: */
13395   ffestb_subr_kill_beru_ ();
13396   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13397   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13398 }
13399
13400 /* ffestb_beru6_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN [external-file-unit
13401                     COMMA] NAME
13402
13403    return ffestb_beru6_;  // to lexer
13404
13405    Make sure EQUALS here, send next token to expression handler.  */
13406
13407 static ffelexHandler
13408 ffestb_beru6_ (ffelexToken t)
13409 {
13410
13411   switch (ffelex_token_type (t))
13412     {
13413     case FFELEX_typeEQUALS:
13414       ffesta_confirmed ();
13415       if (ffestb_local_.beru.label)
13416         return (ffelexHandler) ffestb_beru8_;
13417       if (ffestb_local_.beru.left)
13418         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13419                                             ffestb_local_.beru.context,
13420                                             (ffeexprCallback) ffestb_beru7_);
13421       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13422                                           ffestb_local_.beru.context,
13423                                           (ffeexprCallback) ffestb_beru7_);
13424
13425     default:
13426       break;
13427     }
13428
13429   ffestb_subr_kill_beru_ ();
13430   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13431   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13432 }
13433
13434 /* ffestb_beru7_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS expr
13435
13436    (ffestb_beru7_)  // to expression handler
13437
13438    Handle COMMA or CLOSE_PAREN here.  */
13439
13440 static ffelexHandler
13441 ffestb_beru7_ (ffelexToken ft, ffebld expr, ffelexToken t)
13442 {
13443   switch (ffelex_token_type (t))
13444     {
13445     case FFELEX_typeCOMMA:
13446     case FFELEX_typeCLOSE_PAREN:
13447       if (expr == NULL)
13448         break;
13449       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value_present
13450         = TRUE;
13451       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value
13452         = ffelex_token_use (ft);
13453       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].u.expr = expr;
13454       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
13455         return (ffelexHandler) ffestb_beru5_;
13456       return (ffelexHandler) ffestb_beru10_;
13457
13458     default:
13459       break;
13460     }
13461
13462   ffestb_subr_kill_beru_ ();
13463   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13464   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13465 }
13466
13467 /* ffestb_beru8_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS
13468
13469    return ffestb_beru8_;  // to lexer
13470
13471    Handle NUMBER for label here.  */
13472
13473 static ffelexHandler
13474 ffestb_beru8_ (ffelexToken t)
13475 {
13476   switch (ffelex_token_type (t))
13477     {
13478     case FFELEX_typeNUMBER:
13479       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value_present
13480         = TRUE;
13481       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value
13482         = ffelex_token_use (t);
13483       return (ffelexHandler) ffestb_beru9_;
13484
13485     default:
13486       break;
13487     }
13488
13489   ffestb_subr_kill_beru_ ();
13490   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13491   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13492 }
13493
13494 /* ffestb_beru9_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS
13495                    NUMBER
13496
13497    return ffestb_beru9_;  // to lexer
13498
13499    Handle COMMA or CLOSE_PAREN here.  */
13500
13501 static ffelexHandler
13502 ffestb_beru9_ (ffelexToken t)
13503 {
13504   switch (ffelex_token_type (t))
13505     {
13506     case FFELEX_typeCOMMA:
13507       return (ffelexHandler) ffestb_beru5_;
13508
13509     case FFELEX_typeCLOSE_PAREN:
13510       return (ffelexHandler) ffestb_beru10_;
13511
13512     default:
13513       break;
13514     }
13515
13516   ffestb_subr_kill_beru_ ();
13517   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13518   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13519 }
13520
13521 /* ffestb_beru10_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... CLOSE_PAREN
13522
13523    return ffestb_beru10_;  // to lexer
13524
13525    Handle EOS or SEMICOLON here.  */
13526
13527 static ffelexHandler
13528 ffestb_beru10_ (ffelexToken t)
13529 {
13530   switch (ffelex_token_type (t))
13531     {
13532     case FFELEX_typeEOS:
13533     case FFELEX_typeSEMICOLON:
13534       ffesta_confirmed ();
13535       if (!ffesta_is_inhibited ())
13536         {
13537           switch (ffesta_first_kw)
13538             {
13539             case FFESTR_firstBACKSPACE:
13540               ffestc_R919 ();
13541               break;
13542
13543             case FFESTR_firstENDFILE:
13544             case FFESTR_firstEND:
13545               ffestc_R920 ();
13546               break;
13547
13548             case FFESTR_firstREWIND:
13549               ffestc_R921 ();
13550               break;
13551
13552 #if FFESTR_VXT
13553             case FFESTR_firstUNLOCK:
13554               ffestc_V022 ();
13555               break;
13556 #endif
13557
13558             default:
13559               assert (FALSE);
13560             }
13561         }
13562       ffestb_subr_kill_beru_ ();
13563       return (ffelexHandler) ffesta_zero (t);
13564
13565     default:
13566       break;
13567     }
13568
13569   ffestb_subr_kill_beru_ ();
13570   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
13571   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13572 }
13573
13574 /* ffestb_vxtcode -- Parse the VXT DECODE/ENCODE statement
13575
13576    return ffestb_vxtcode;  // to lexer
13577
13578    Make sure the statement has a valid form for the VXT DECODE/ENCODE
13579    statement.  If it does, implement the statement.  */
13580
13581 #if FFESTR_VXT
13582 ffelexHandler
13583 ffestb_vxtcode (ffelexToken t)
13584 {
13585   ffestpVxtcodeIx ix;
13586
13587   switch (ffelex_token_type (ffesta_tokens[0]))
13588     {
13589     case FFELEX_typeNAME:
13590       switch (ffelex_token_type (t))
13591         {
13592         case FFELEX_typeCOMMA:
13593         case FFELEX_typeCOLONCOLON:
13594         case FFELEX_typeEOS:
13595         case FFELEX_typeSEMICOLON:
13596         case FFELEX_typeNAME:
13597         case FFELEX_typeNUMBER:
13598           ffesta_confirmed ();  /* Error, but clearly intended. */
13599           goto bad_1;           /* :::::::::::::::::::: */
13600
13601         default:
13602           goto bad_1;           /* :::::::::::::::::::: */
13603
13604         case FFELEX_typeOPEN_PAREN:
13605           for (ix = 0; ix < FFESTP_vxtcodeix; ++ix)
13606             ffestp_file.vxtcode.vxtcode_spec[ix].kw_or_val_present = FALSE;
13607           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13608                 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_vxtcode1_);
13609         }
13610
13611     case FFELEX_typeNAMES:
13612       switch (ffelex_token_type (t))
13613         {
13614         case FFELEX_typeEOS:
13615         case FFELEX_typeSEMICOLON:
13616         case FFELEX_typeCOMMA:
13617         case FFELEX_typeCOLONCOLON:
13618           ffesta_confirmed ();  /* Error, but clearly intended. */
13619           goto bad_1;           /* :::::::::::::::::::: */
13620
13621         default:
13622           goto bad_1;           /* :::::::::::::::::::: */
13623
13624         case FFELEX_typeOPEN_PAREN:
13625           if (ffelex_token_length (ffesta_tokens[0])
13626               != ffestb_args.vxtcode.len)
13627             goto bad_0;         /* :::::::::::::::::::: */
13628
13629           for (ix = 0; ix < FFESTP_vxtcodeix; ++ix)
13630             ffestp_file.vxtcode.vxtcode_spec[ix].kw_or_val_present = FALSE;
13631           return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13632                 FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_vxtcode1_);
13633         }
13634
13635     default:
13636       goto bad_0;               /* :::::::::::::::::::: */
13637     }
13638
13639 bad_0:                          /* :::::::::::::::::::: */
13640   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, ffesta_tokens[0]);
13641   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13642
13643 bad_1:                          /* :::::::::::::::::::: */
13644   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13645   return (ffelexHandler) ffelex_swallow_tokens (t,
13646                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
13647 }
13648
13649 /* ffestb_vxtcode1_ -- "VXTCODE" OPEN_PAREN expr
13650
13651    (ffestb_vxtcode1_)  // to expression handler
13652
13653    Handle COMMA here.  */
13654
13655 static ffelexHandler
13656 ffestb_vxtcode1_ (ffelexToken ft, ffebld expr, ffelexToken t)
13657 {
13658   switch (ffelex_token_type (t))
13659     {
13660     case FFELEX_typeCOMMA:
13661       if (expr == NULL)
13662         break;
13663       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].kw_or_val_present
13664         = TRUE;
13665       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].kw_present = FALSE;
13666       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value_present = TRUE;
13667       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value_is_label
13668         = FALSE;
13669       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value
13670         = ffelex_token_use (ft);
13671       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].u.expr = expr;
13672       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13673              FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_vxtcode2_);
13674
13675     default:
13676       break;
13677     }
13678
13679   ffestb_subr_kill_vxtcode_ ();
13680   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13681   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13682 }
13683
13684 /* ffestb_vxtcode2_ -- "VXTCODE" OPEN_PAREN expr COMMA expr
13685
13686    (ffestb_vxtcode2_)  // to expression handler
13687
13688    Handle COMMA here.  */
13689
13690 static ffelexHandler
13691 ffestb_vxtcode2_ (ffelexToken ft, ffebld expr, ffelexToken t)
13692 {
13693   switch (ffelex_token_type (t))
13694     {
13695     case FFELEX_typeCOMMA:
13696       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].kw_or_val_present
13697         = TRUE;
13698       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].kw_present = FALSE;
13699       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value_present = TRUE;
13700       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value_is_label
13701         = (expr == NULL);
13702       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value
13703         = ffelex_token_use (ft);
13704       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].u.expr = expr;
13705       if (ffesta_first_kw == FFESTR_firstENCODE)
13706         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13707                                             FFEEXPR_contextFILEVXTCODE,
13708                                         (ffeexprCallback) ffestb_vxtcode3_);
13709       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13710                                           FFEEXPR_contextFILEVXTCODE,
13711                                         (ffeexprCallback) ffestb_vxtcode3_);
13712
13713     default:
13714       break;
13715     }
13716
13717   ffestb_subr_kill_vxtcode_ ();
13718   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13719   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13720 }
13721
13722 /* ffestb_vxtcode3_ -- "VXTCODE" OPEN_PAREN expr COMMA expr COMMA expr
13723
13724    (ffestb_vxtcode3_)  // to expression handler
13725
13726    Handle COMMA or CLOSE_PAREN here.  */
13727
13728 static ffelexHandler
13729 ffestb_vxtcode3_ (ffelexToken ft, ffebld expr, ffelexToken t)
13730 {
13731   switch (ffelex_token_type (t))
13732     {
13733     case FFELEX_typeCOMMA:
13734     case FFELEX_typeCLOSE_PAREN:
13735       if (expr == NULL)
13736         break;
13737       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].kw_or_val_present
13738         = TRUE;
13739       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].kw_present = FALSE;
13740       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value_present = TRUE;
13741       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value_is_label
13742         = FALSE;
13743       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value
13744         = ffelex_token_use (ft);
13745       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].u.expr = expr;
13746       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
13747         return (ffelexHandler) ffestb_vxtcode4_;
13748       return (ffelexHandler) ffestb_vxtcode9_;
13749
13750     default:
13751       break;
13752     }
13753
13754   ffestb_subr_kill_vxtcode_ ();
13755   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13756   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13757 }
13758
13759 /* ffestb_vxtcode4_ -- "VXTCODE" OPEN_PAREN ...
13760
13761    return ffestb_vxtcode4_;  // to lexer
13762
13763    Handle NAME=expr construct here.  */
13764
13765 static ffelexHandler
13766 ffestb_vxtcode4_ (ffelexToken t)
13767 {
13768   ffestrGenio kw;
13769
13770   ffestb_local_.vxtcode.label = FALSE;
13771
13772   switch (ffelex_token_type (t))
13773     {
13774     case FFELEX_typeNAME:
13775       kw = ffestr_genio (t);
13776       switch (kw)
13777         {
13778         case FFESTR_genioERR:
13779           ffestb_local_.vxtcode.ix = FFESTP_vxtcodeixERR;
13780           ffestb_local_.vxtcode.label = TRUE;
13781           break;
13782
13783         case FFESTR_genioIOSTAT:
13784           ffestb_local_.vxtcode.ix = FFESTP_vxtcodeixIOSTAT;
13785           ffestb_local_.vxtcode.left = TRUE;
13786           ffestb_local_.vxtcode.context = FFEEXPR_contextFILEINT;
13787           break;
13788
13789         default:
13790           goto bad;             /* :::::::::::::::::::: */
13791         }
13792       if (ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13793           .kw_or_val_present)
13794         break;                  /* Can't specify a keyword twice! */
13795       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13796         .kw_or_val_present = TRUE;
13797       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13798         .kw_present = TRUE;
13799       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
13800         .value_present = FALSE;
13801       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value_is_label
13802         = ffestb_local_.vxtcode.label;
13803       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].kw
13804         = ffelex_token_use (t);
13805       return (ffelexHandler) ffestb_vxtcode5_;
13806
13807     default:
13808       break;
13809     }
13810
13811 bad:                            /* :::::::::::::::::::: */
13812   ffestb_subr_kill_vxtcode_ ();
13813   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13814   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13815 }
13816
13817 /* ffestb_vxtcode5_ -- "VXTCODE" OPEN_PAREN [external-file-unit COMMA [format
13818                    COMMA]] NAME
13819
13820    return ffestb_vxtcode5_;  // to lexer
13821
13822    Make sure EQUALS here, send next token to expression handler.  */
13823
13824 static ffelexHandler
13825 ffestb_vxtcode5_ (ffelexToken t)
13826 {
13827   switch (ffelex_token_type (t))
13828     {
13829     case FFELEX_typeEQUALS:
13830       ffesta_confirmed ();
13831       if (ffestb_local_.vxtcode.label)
13832         return (ffelexHandler) ffestb_vxtcode7_;
13833       if (ffestb_local_.vxtcode.left)
13834         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13835                                             ffestb_local_.vxtcode.context,
13836                                         (ffeexprCallback) ffestb_vxtcode6_);
13837       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13838                                           ffestb_local_.vxtcode.context,
13839                                         (ffeexprCallback) ffestb_vxtcode6_);
13840
13841     default:
13842       break;
13843     }
13844
13845   ffestb_subr_kill_vxtcode_ ();
13846   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13847   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13848 }
13849
13850 /* ffestb_vxtcode6_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS expr
13851
13852    (ffestb_vxtcode6_)  // to expression handler
13853
13854    Handle COMMA or CLOSE_PAREN here.  */
13855
13856 static ffelexHandler
13857 ffestb_vxtcode6_ (ffelexToken ft, ffebld expr, ffelexToken t)
13858 {
13859   switch (ffelex_token_type (t))
13860     {
13861     case FFELEX_typeCOMMA:
13862     case FFELEX_typeCLOSE_PAREN:
13863       if (expr == NULL)
13864         break;
13865       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value_present
13866         = TRUE;
13867       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value
13868         = ffelex_token_use (ft);
13869       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].u.expr = expr;
13870       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
13871         return (ffelexHandler) ffestb_vxtcode4_;
13872       return (ffelexHandler) ffestb_vxtcode9_;
13873
13874     default:
13875       break;
13876     }
13877
13878   ffestb_subr_kill_vxtcode_ ();
13879   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13880   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13881 }
13882
13883 /* ffestb_vxtcode7_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS
13884
13885    return ffestb_vxtcode7_;  // to lexer
13886
13887    Handle NUMBER for label here.  */
13888
13889 static ffelexHandler
13890 ffestb_vxtcode7_ (ffelexToken t)
13891 {
13892   switch (ffelex_token_type (t))
13893     {
13894     case FFELEX_typeNUMBER:
13895       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value_present
13896         = TRUE;
13897       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value
13898         = ffelex_token_use (t);
13899       return (ffelexHandler) ffestb_vxtcode8_;
13900
13901     default:
13902       break;
13903     }
13904
13905   ffestb_subr_kill_vxtcode_ ();
13906   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13907   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13908 }
13909
13910 /* ffestb_vxtcode8_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS NUMBER
13911
13912    return ffestb_vxtcode8_;  // to lexer
13913
13914    Handle COMMA or CLOSE_PAREN here.  */
13915
13916 static ffelexHandler
13917 ffestb_vxtcode8_ (ffelexToken t)
13918 {
13919   switch (ffelex_token_type (t))
13920     {
13921     case FFELEX_typeCOMMA:
13922       return (ffelexHandler) ffestb_vxtcode4_;
13923
13924     case FFELEX_typeCLOSE_PAREN:
13925       return (ffelexHandler) ffestb_vxtcode9_;
13926
13927     default:
13928       break;
13929     }
13930
13931   ffestb_subr_kill_vxtcode_ ();
13932   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
13933   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
13934 }
13935
13936 /* ffestb_vxtcode9_ -- "VXTCODE" OPEN_PAREN ... CLOSE_PAREN
13937
13938    return ffestb_vxtcode9_;  // to lexer
13939
13940    Handle EOS or SEMICOLON here.
13941
13942    07-Jun-90  JCB  1.1
13943       Context for ENCODE/DECODE expressions is now IOLISTDF instead of IOLIST
13944       since they apply to internal files.  */
13945
13946 static ffelexHandler
13947 ffestb_vxtcode9_ (ffelexToken t)
13948 {
13949   ffelexHandler next;
13950
13951   switch (ffelex_token_type (t))
13952     {
13953     case FFELEX_typeEOS:
13954     case FFELEX_typeSEMICOLON:
13955       ffesta_confirmed ();
13956       if (!ffesta_is_inhibited ())
13957         {
13958           if (ffesta_first_kw == FFESTR_firstENCODE)
13959             {
13960               ffestc_V023_start ();
13961               ffestc_V023_finish ();
13962             }
13963           else
13964             {
13965               ffestc_V024_start ();
13966               ffestc_V024_finish ();
13967             }
13968         }
13969       ffestb_subr_kill_vxtcode_ ();
13970       return (ffelexHandler) ffesta_zero (t);
13971
13972     case FFELEX_typeNAME:
13973     case FFELEX_typeOPEN_PAREN:
13974     case FFELEX_typeCOMMA:
13975       ffesta_confirmed ();
13976       if (!ffesta_is_inhibited ())
13977         if (ffesta_first_kw == FFESTR_firstENCODE)
13978           ffestc_V023_start ();
13979         else
13980           ffestc_V024_start ();
13981       ffestb_subr_kill_vxtcode_ ();
13982       if (ffesta_first_kw == FFESTR_firstDECODE)
13983         next = (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
13984                                             FFEEXPR_contextIOLISTDF,
13985                                        (ffeexprCallback) ffestb_vxtcode10_);
13986       else
13987         next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
13988                                             FFEEXPR_contextIOLISTDF,
13989                                        (ffeexprCallback) ffestb_vxtcode10_);
13990
13991       /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
13992          (f2c provides this extension, as do other compilers, supposedly.) */
13993
13994       if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
13995         return next;
13996
13997       return (ffelexHandler) (*next) (t);
13998
13999     default:
14000       break;
14001     }
14002
14003   ffestb_subr_kill_vxtcode_ ();
14004   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
14005   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14006 }
14007
14008 /* ffestb_vxtcode10_ -- "VXTCODE(...)" expr
14009
14010    (ffestb_vxtcode10_)  // to expression handler
14011
14012    Handle COMMA or EOS/SEMICOLON here.
14013
14014    07-Jun-90  JCB  1.1
14015       Context for ENCODE/DECODE expressions is now IOLISTDF instead of IOLIST
14016       since they apply to internal files.  */
14017
14018 static ffelexHandler
14019 ffestb_vxtcode10_ (ffelexToken ft, ffebld expr, ffelexToken t)
14020 {
14021   switch (ffelex_token_type (t))
14022     {
14023     case FFELEX_typeCOMMA:
14024       if (expr == NULL)
14025         break;
14026       if (!ffesta_is_inhibited ())
14027         if (ffesta_first_kw == FFESTR_firstENCODE)
14028           ffestc_V023_item (expr, ft);
14029         else
14030           ffestc_V024_item (expr, ft);
14031       if (ffesta_first_kw == FFESTR_firstDECODE)
14032         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
14033                                             FFEEXPR_contextIOLISTDF,
14034                                        (ffeexprCallback) ffestb_vxtcode10_);
14035       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14036                                           FFEEXPR_contextIOLISTDF,
14037                                        (ffeexprCallback) ffestb_vxtcode10_);
14038
14039     case FFELEX_typeEOS:
14040     case FFELEX_typeSEMICOLON:
14041       if (expr == NULL)
14042         break;
14043       if (!ffesta_is_inhibited ())
14044         {
14045           if (ffesta_first_kw == FFESTR_firstENCODE)
14046             {
14047               ffestc_V023_item (expr, ft);
14048               ffestc_V023_finish ();
14049             }
14050           else
14051             {
14052               ffestc_V024_item (expr, ft);
14053               ffestc_V024_finish ();
14054             }
14055         }
14056       return (ffelexHandler) ffesta_zero (t);
14057
14058     default:
14059       break;
14060     }
14061
14062   if (!ffesta_is_inhibited ())
14063     if (ffesta_first_kw == FFESTR_firstENCODE)
14064       ffestc_V023_finish ();
14065     else
14066       ffestc_V024_finish ();
14067   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
14068   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14069 }
14070
14071 #endif
14072 /* ffestb_R904 -- Parse an OPEN statement
14073
14074    return ffestb_R904;  // to lexer
14075
14076    Make sure the statement has a valid form for an OPEN statement.
14077    If it does, implement the statement.  */
14078
14079 ffelexHandler
14080 ffestb_R904 (ffelexToken t)
14081 {
14082   ffestpOpenIx ix;
14083
14084   switch (ffelex_token_type (ffesta_tokens[0]))
14085     {
14086     case FFELEX_typeNAME:
14087       if (ffesta_first_kw != FFESTR_firstOPEN)
14088         goto bad_0;             /* :::::::::::::::::::: */
14089       break;
14090
14091     case FFELEX_typeNAMES:
14092       if (ffesta_first_kw != FFESTR_firstOPEN)
14093         goto bad_0;             /* :::::::::::::::::::: */
14094       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlOPEN)
14095         goto bad_0;             /* :::::::::::::::::::: */
14096       break;
14097
14098     default:
14099       goto bad_0;               /* :::::::::::::::::::: */
14100     }
14101
14102   switch (ffelex_token_type (t))
14103     {
14104     case FFELEX_typeOPEN_PAREN:
14105       break;
14106
14107     case FFELEX_typeEOS:
14108     case FFELEX_typeSEMICOLON:
14109     case FFELEX_typeCOMMA:
14110     case FFELEX_typeCOLONCOLON:
14111       ffesta_confirmed ();      /* Error, but clearly intended. */
14112       goto bad_1;               /* :::::::::::::::::::: */
14113
14114     default:
14115       goto bad_1;               /* :::::::::::::::::::: */
14116     }
14117
14118   for (ix = 0; ix < FFESTP_openix; ++ix)
14119     ffestp_file.open.open_spec[ix].kw_or_val_present = FALSE;
14120
14121   return (ffelexHandler) ffestb_R9041_;
14122
14123 bad_0:                          /* :::::::::::::::::::: */
14124   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", ffesta_tokens[0]);
14125   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14126
14127 bad_1:                          /* :::::::::::::::::::: */
14128   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14129   return (ffelexHandler) ffelex_swallow_tokens (t,
14130                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
14131 }
14132
14133 /* ffestb_R9041_ -- "OPEN" OPEN_PAREN
14134
14135    return ffestb_R9041_;  // to lexer
14136
14137    Handle expr construct (not NAME=expr construct) here.  */
14138
14139 static ffelexHandler
14140 ffestb_R9041_ (ffelexToken t)
14141 {
14142   switch (ffelex_token_type (t))
14143     {
14144     case FFELEX_typeNAME:
14145       ffesta_tokens[1] = ffelex_token_use (t);
14146       return (ffelexHandler) ffestb_R9042_;
14147
14148     default:
14149       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14150                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9043_)))
14151         (t);
14152     }
14153 }
14154
14155 /* ffestb_R9042_ -- "OPEN" OPEN_PAREN NAME
14156
14157    return ffestb_R9042_;  // to lexer
14158
14159    If EQUALS here, go to states that handle it.  Else, send NAME and this
14160    token thru expression handler.  */
14161
14162 static ffelexHandler
14163 ffestb_R9042_ (ffelexToken t)
14164 {
14165   ffelexHandler next;
14166   ffelexToken nt;
14167
14168   switch (ffelex_token_type (t))
14169     {
14170     case FFELEX_typeEQUALS:
14171       nt = ffesta_tokens[1];
14172       next = (ffelexHandler) ffestb_R9044_ (nt);
14173       ffelex_token_kill (nt);
14174       return (ffelexHandler) (*next) (t);
14175
14176     default:
14177       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14178                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9043_)))
14179         (ffesta_tokens[1]);
14180       ffelex_token_kill (ffesta_tokens[1]);
14181       return (ffelexHandler) (*next) (t);
14182     }
14183 }
14184
14185 /* ffestb_R9043_ -- "OPEN" OPEN_PAREN expr
14186
14187    (ffestb_R9043_)  // to expression handler
14188
14189    Handle COMMA or CLOSE_PAREN here.  */
14190
14191 static ffelexHandler
14192 ffestb_R9043_ (ffelexToken ft, ffebld expr, ffelexToken t)
14193 {
14194   switch (ffelex_token_type (t))
14195     {
14196     case FFELEX_typeCOMMA:
14197     case FFELEX_typeCLOSE_PAREN:
14198       if (expr == NULL)
14199         break;
14200       ffestp_file.open.open_spec[FFESTP_openixUNIT].kw_or_val_present
14201         = TRUE;
14202       ffestp_file.open.open_spec[FFESTP_openixUNIT].kw_present = FALSE;
14203       ffestp_file.open.open_spec[FFESTP_openixUNIT].value_present = TRUE;
14204       ffestp_file.open.open_spec[FFESTP_openixUNIT].value_is_label
14205         = FALSE;
14206       ffestp_file.open.open_spec[FFESTP_openixUNIT].value
14207         = ffelex_token_use (ft);
14208       ffestp_file.open.open_spec[FFESTP_openixUNIT].u.expr = expr;
14209       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14210         return (ffelexHandler) ffestb_R9044_;
14211       return (ffelexHandler) ffestb_R9049_;
14212
14213     default:
14214       break;
14215     }
14216
14217   ffestb_subr_kill_open_ ();
14218   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14219   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14220 }
14221
14222 /* ffestb_R9044_ -- "OPEN" OPEN_PAREN [external-file-unit COMMA]
14223
14224    return ffestb_R9044_;  // to lexer
14225
14226    Handle expr construct (not NAME=expr construct) here.  */
14227
14228 static ffelexHandler
14229 ffestb_R9044_ (ffelexToken t)
14230 {
14231   ffestrOpen kw;
14232
14233   ffestb_local_.open.label = FALSE;
14234
14235   switch (ffelex_token_type (t))
14236     {
14237     case FFELEX_typeNAME:
14238       kw = ffestr_open (t);
14239       switch (kw)
14240         {
14241         case FFESTR_openACCESS:
14242           ffestb_local_.open.ix = FFESTP_openixACCESS;
14243           ffestb_local_.open.left = FALSE;
14244           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14245           break;
14246
14247         case FFESTR_openACTION:
14248           ffestb_local_.open.ix = FFESTP_openixACTION;
14249           ffestb_local_.open.left = FALSE;
14250           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14251           break;
14252
14253         case FFESTR_openASSOCIATEVARIABLE:
14254           ffestb_local_.open.ix = FFESTP_openixASSOCIATEVARIABLE;
14255           ffestb_local_.open.left = TRUE;
14256           ffestb_local_.open.context = FFEEXPR_contextFILEASSOC;
14257           break;
14258
14259         case FFESTR_openBLANK:
14260           ffestb_local_.open.ix = FFESTP_openixBLANK;
14261           ffestb_local_.open.left = FALSE;
14262           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14263           break;
14264
14265         case FFESTR_openBLOCKSIZE:
14266           ffestb_local_.open.ix = FFESTP_openixBLOCKSIZE;
14267           ffestb_local_.open.left = FALSE;
14268           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14269           break;
14270
14271         case FFESTR_openBUFFERCOUNT:
14272           ffestb_local_.open.ix = FFESTP_openixBUFFERCOUNT;
14273           ffestb_local_.open.left = FALSE;
14274           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14275           break;
14276
14277         case FFESTR_openCARRIAGECONTROL:
14278           ffestb_local_.open.ix = FFESTP_openixCARRIAGECONTROL;
14279           ffestb_local_.open.left = FALSE;
14280           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14281           break;
14282
14283         case FFESTR_openDEFAULTFILE:
14284           ffestb_local_.open.ix = FFESTP_openixDEFAULTFILE;
14285           ffestb_local_.open.left = FALSE;
14286           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14287           break;
14288
14289         case FFESTR_openDELIM:
14290           ffestb_local_.open.ix = FFESTP_openixDELIM;
14291           ffestb_local_.open.left = FALSE;
14292           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14293           break;
14294
14295         case FFESTR_openDISP:
14296         case FFESTR_openDISPOSE:
14297           ffestb_local_.open.ix = FFESTP_openixDISPOSE;
14298           ffestb_local_.open.left = FALSE;
14299           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14300           break;
14301
14302         case FFESTR_openERR:
14303           ffestb_local_.open.ix = FFESTP_openixERR;
14304           ffestb_local_.open.label = TRUE;
14305           break;
14306
14307         case FFESTR_openEXTENDSIZE:
14308           ffestb_local_.open.ix = FFESTP_openixEXTENDSIZE;
14309           ffestb_local_.open.left = FALSE;
14310           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14311           break;
14312
14313         case FFESTR_openFILE:
14314         case FFESTR_openNAME:
14315           ffestb_local_.open.ix = FFESTP_openixFILE;
14316           ffestb_local_.open.left = FALSE;
14317           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14318           break;
14319
14320         case FFESTR_openFORM:
14321           ffestb_local_.open.ix = FFESTP_openixFORM;
14322           ffestb_local_.open.left = FALSE;
14323           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14324           break;
14325
14326         case FFESTR_openINITIALSIZE:
14327           ffestb_local_.open.ix = FFESTP_openixINITIALSIZE;
14328           ffestb_local_.open.left = FALSE;
14329           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14330           break;
14331
14332         case FFESTR_openIOSTAT:
14333           ffestb_local_.open.ix = FFESTP_openixIOSTAT;
14334           ffestb_local_.open.left = TRUE;
14335           ffestb_local_.open.context = FFEEXPR_contextFILEINT;
14336           break;
14337
14338 #if 0                           /* Haven't added support for expression
14339                                    context yet (though easy). */
14340         case FFESTR_openKEY:
14341           ffestb_local_.open.ix = FFESTP_openixKEY;
14342           ffestb_local_.open.left = FALSE;
14343           ffestb_local_.open.context = FFEEXPR_contextFILEKEY;
14344           break;
14345 #endif
14346
14347         case FFESTR_openMAXREC:
14348           ffestb_local_.open.ix = FFESTP_openixMAXREC;
14349           ffestb_local_.open.left = FALSE;
14350           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14351           break;
14352
14353         case FFESTR_openNOSPANBLOCKS:
14354           if (ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14355               .kw_or_val_present)
14356             goto bad;           /* :::::::::::::::::::: */
14357           ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14358             .kw_or_val_present = TRUE;
14359           ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14360             .kw_present = TRUE;
14361           ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
14362             .value_present = FALSE;
14363           ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS].kw
14364             = ffelex_token_use (t);
14365           return (ffelexHandler) ffestb_R9048_;
14366
14367         case FFESTR_openORGANIZATION:
14368           ffestb_local_.open.ix = FFESTP_openixORGANIZATION;
14369           ffestb_local_.open.left = FALSE;
14370           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14371           break;
14372
14373         case FFESTR_openPAD:
14374           ffestb_local_.open.ix = FFESTP_openixPAD;
14375           ffestb_local_.open.left = FALSE;
14376           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14377           break;
14378
14379         case FFESTR_openPOSITION:
14380           ffestb_local_.open.ix = FFESTP_openixPOSITION;
14381           ffestb_local_.open.left = FALSE;
14382           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14383           break;
14384
14385         case FFESTR_openREADONLY:
14386           if (ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14387               .kw_or_val_present)
14388             goto bad;           /* :::::::::::::::::::: */
14389           ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14390             .kw_or_val_present = TRUE;
14391           ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14392             .kw_present = TRUE;
14393           ffestp_file.open.open_spec[FFESTP_openixREADONLY]
14394             .value_present = FALSE;
14395           ffestp_file.open.open_spec[FFESTP_openixREADONLY].kw
14396             = ffelex_token_use (t);
14397           return (ffelexHandler) ffestb_R9048_;
14398
14399         case FFESTR_openRECL:
14400         case FFESTR_openRECORDSIZE:
14401           ffestb_local_.open.ix = FFESTP_openixRECL;
14402           ffestb_local_.open.left = FALSE;
14403           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14404           break;
14405
14406         case FFESTR_openRECORDTYPE:
14407           ffestb_local_.open.ix = FFESTP_openixRECORDTYPE;
14408           ffestb_local_.open.left = FALSE;
14409           ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
14410           break;
14411
14412         case FFESTR_openSHARED:
14413           if (ffestp_file.open.open_spec[FFESTP_openixSHARED]
14414               .kw_or_val_present)
14415             goto bad;           /* :::::::::::::::::::: */
14416           ffestp_file.open.open_spec[FFESTP_openixSHARED]
14417             .kw_or_val_present = TRUE;
14418           ffestp_file.open.open_spec[FFESTP_openixSHARED]
14419             .kw_present = TRUE;
14420           ffestp_file.open.open_spec[FFESTP_openixSHARED]
14421             .value_present = FALSE;
14422           ffestp_file.open.open_spec[FFESTP_openixSHARED].kw
14423             = ffelex_token_use (t);
14424           return (ffelexHandler) ffestb_R9048_;
14425
14426         case FFESTR_openSTATUS:
14427         case FFESTR_openTYPE:
14428           ffestb_local_.open.ix = FFESTP_openixSTATUS;
14429           ffestb_local_.open.left = FALSE;
14430           ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
14431           break;
14432
14433         case FFESTR_openUNIT:
14434           ffestb_local_.open.ix = FFESTP_openixUNIT;
14435           ffestb_local_.open.left = FALSE;
14436           ffestb_local_.open.context = FFEEXPR_contextFILENUM;
14437           break;
14438
14439         case FFESTR_openUSEROPEN:
14440           ffestb_local_.open.ix = FFESTP_openixUSEROPEN;
14441           ffestb_local_.open.left = TRUE;
14442           ffestb_local_.open.context = FFEEXPR_contextFILEEXTFUNC;
14443           break;
14444
14445         default:
14446           goto bad;             /* :::::::::::::::::::: */
14447         }
14448       if (ffestp_file.open.open_spec[ffestb_local_.open.ix]
14449           .kw_or_val_present)
14450         break;                  /* Can't specify a keyword twice! */
14451       ffestp_file.open.open_spec[ffestb_local_.open.ix]
14452         .kw_or_val_present = TRUE;
14453       ffestp_file.open.open_spec[ffestb_local_.open.ix]
14454         .kw_present = TRUE;
14455       ffestp_file.open.open_spec[ffestb_local_.open.ix]
14456         .value_present = FALSE;
14457       ffestp_file.open.open_spec[ffestb_local_.open.ix].value_is_label
14458         = ffestb_local_.open.label;
14459       ffestp_file.open.open_spec[ffestb_local_.open.ix].kw
14460         = ffelex_token_use (t);
14461       return (ffelexHandler) ffestb_R9045_;
14462
14463     default:
14464       break;
14465     }
14466
14467 bad:                            /* :::::::::::::::::::: */
14468   ffestb_subr_kill_open_ ();
14469   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14470   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14471 }
14472
14473 /* ffestb_R9045_ -- "OPEN" OPEN_PAREN [external-file-unit COMMA] NAME
14474
14475    return ffestb_R9045_;  // to lexer
14476
14477    Make sure EQUALS here, send next token to expression handler.  */
14478
14479 static ffelexHandler
14480 ffestb_R9045_ (ffelexToken t)
14481 {
14482   switch (ffelex_token_type (t))
14483     {
14484     case FFELEX_typeEQUALS:
14485       ffesta_confirmed ();
14486       if (ffestb_local_.open.label)
14487         return (ffelexHandler) ffestb_R9047_;
14488       if (ffestb_local_.open.left)
14489         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
14490                                             ffestb_local_.open.context,
14491                                             (ffeexprCallback) ffestb_R9046_);
14492       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14493                                           ffestb_local_.open.context,
14494                                           (ffeexprCallback) ffestb_R9046_);
14495
14496     default:
14497       break;
14498     }
14499
14500   ffestb_subr_kill_open_ ();
14501   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14502   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14503 }
14504
14505 /* ffestb_R9046_ -- "OPEN" OPEN_PAREN ... NAME EQUALS expr
14506
14507    (ffestb_R9046_)  // to expression handler
14508
14509    Handle COMMA or CLOSE_PAREN here.  */
14510
14511 static ffelexHandler
14512 ffestb_R9046_ (ffelexToken ft, ffebld expr, ffelexToken t)
14513 {
14514   switch (ffelex_token_type (t))
14515     {
14516     case FFELEX_typeCOMMA:
14517     case FFELEX_typeCLOSE_PAREN:
14518       if (expr == NULL)
14519         break;
14520       ffestp_file.open.open_spec[ffestb_local_.open.ix].value_present
14521         = TRUE;
14522       ffestp_file.open.open_spec[ffestb_local_.open.ix].value
14523         = ffelex_token_use (ft);
14524       ffestp_file.open.open_spec[ffestb_local_.open.ix].u.expr = expr;
14525       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14526         return (ffelexHandler) ffestb_R9044_;
14527       return (ffelexHandler) ffestb_R9049_;
14528
14529     default:
14530       break;
14531     }
14532
14533   ffestb_subr_kill_open_ ();
14534   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14535   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14536 }
14537
14538 /* ffestb_R9047_ -- "OPEN" OPEN_PAREN ... NAME EQUALS
14539
14540    return ffestb_R9047_;  // to lexer
14541
14542    Handle NUMBER for label here.  */
14543
14544 static ffelexHandler
14545 ffestb_R9047_ (ffelexToken t)
14546 {
14547   switch (ffelex_token_type (t))
14548     {
14549     case FFELEX_typeNUMBER:
14550       ffestp_file.open.open_spec[ffestb_local_.open.ix].value_present
14551         = TRUE;
14552       ffestp_file.open.open_spec[ffestb_local_.open.ix].value
14553         = ffelex_token_use (t);
14554       return (ffelexHandler) ffestb_R9048_;
14555
14556     default:
14557       break;
14558     }
14559
14560   ffestb_subr_kill_open_ ();
14561   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14562   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14563 }
14564
14565 /* ffestb_R9048_ -- "OPEN" OPEN_PAREN ... NAME EQUALS NUMBER
14566
14567    return ffestb_R9048_;  // to lexer
14568
14569    Handle COMMA or CLOSE_PAREN here.  */
14570
14571 static ffelexHandler
14572 ffestb_R9048_ (ffelexToken t)
14573 {
14574   switch (ffelex_token_type (t))
14575     {
14576     case FFELEX_typeCOMMA:
14577       return (ffelexHandler) ffestb_R9044_;
14578
14579     case FFELEX_typeCLOSE_PAREN:
14580       return (ffelexHandler) ffestb_R9049_;
14581
14582     default:
14583       break;
14584     }
14585
14586   ffestb_subr_kill_open_ ();
14587   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14588   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14589 }
14590
14591 /* ffestb_R9049_ -- "OPEN" OPEN_PAREN ... CLOSE_PAREN
14592
14593    return ffestb_R9049_;  // to lexer
14594
14595    Handle EOS or SEMICOLON here.  */
14596
14597 static ffelexHandler
14598 ffestb_R9049_ (ffelexToken t)
14599 {
14600   switch (ffelex_token_type (t))
14601     {
14602     case FFELEX_typeEOS:
14603     case FFELEX_typeSEMICOLON:
14604       ffesta_confirmed ();
14605       if (!ffesta_is_inhibited ())
14606         ffestc_R904 ();
14607       ffestb_subr_kill_open_ ();
14608       return (ffelexHandler) ffesta_zero (t);
14609
14610     default:
14611       break;
14612     }
14613
14614   ffestb_subr_kill_open_ ();
14615   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
14616   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14617 }
14618
14619 /* ffestb_R907 -- Parse a CLOSE statement
14620
14621    return ffestb_R907;  // to lexer
14622
14623    Make sure the statement has a valid form for a CLOSE statement.
14624    If it does, implement the statement.  */
14625
14626 ffelexHandler
14627 ffestb_R907 (ffelexToken t)
14628 {
14629   ffestpCloseIx ix;
14630
14631   switch (ffelex_token_type (ffesta_tokens[0]))
14632     {
14633     case FFELEX_typeNAME:
14634       if (ffesta_first_kw != FFESTR_firstCLOSE)
14635         goto bad_0;             /* :::::::::::::::::::: */
14636       break;
14637
14638     case FFELEX_typeNAMES:
14639       if (ffesta_first_kw != FFESTR_firstCLOSE)
14640         goto bad_0;             /* :::::::::::::::::::: */
14641       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCLOSE)
14642         goto bad_0;             /* :::::::::::::::::::: */
14643       break;
14644
14645     default:
14646       goto bad_0;               /* :::::::::::::::::::: */
14647     }
14648
14649   switch (ffelex_token_type (t))
14650     {
14651     case FFELEX_typeOPEN_PAREN:
14652       break;
14653
14654     case FFELEX_typeEOS:
14655     case FFELEX_typeSEMICOLON:
14656     case FFELEX_typeCOMMA:
14657     case FFELEX_typeCOLONCOLON:
14658       ffesta_confirmed ();      /* Error, but clearly intended. */
14659       goto bad_1;               /* :::::::::::::::::::: */
14660
14661     default:
14662       goto bad_1;               /* :::::::::::::::::::: */
14663     }
14664
14665   for (ix = 0; ix < FFESTP_closeix; ++ix)
14666     ffestp_file.close.close_spec[ix].kw_or_val_present = FALSE;
14667
14668   return (ffelexHandler) ffestb_R9071_;
14669
14670 bad_0:                          /* :::::::::::::::::::: */
14671   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", ffesta_tokens[0]);
14672   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14673
14674 bad_1:                          /* :::::::::::::::::::: */
14675   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14676   return (ffelexHandler) ffelex_swallow_tokens (t,
14677                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
14678 }
14679
14680 /* ffestb_R9071_ -- "CLOSE" OPEN_PAREN
14681
14682    return ffestb_R9071_;  // to lexer
14683
14684    Handle expr construct (not NAME=expr construct) here.  */
14685
14686 static ffelexHandler
14687 ffestb_R9071_ (ffelexToken t)
14688 {
14689   switch (ffelex_token_type (t))
14690     {
14691     case FFELEX_typeNAME:
14692       ffesta_tokens[1] = ffelex_token_use (t);
14693       return (ffelexHandler) ffestb_R9072_;
14694
14695     default:
14696       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14697                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9073_)))
14698         (t);
14699     }
14700 }
14701
14702 /* ffestb_R9072_ -- "CLOSE" OPEN_PAREN NAME
14703
14704    return ffestb_R9072_;  // to lexer
14705
14706    If EQUALS here, go to states that handle it.  Else, send NAME and this
14707    token thru expression handler.  */
14708
14709 static ffelexHandler
14710 ffestb_R9072_ (ffelexToken t)
14711 {
14712   ffelexHandler next;
14713   ffelexToken nt;
14714
14715   switch (ffelex_token_type (t))
14716     {
14717     case FFELEX_typeEQUALS:
14718       nt = ffesta_tokens[1];
14719       next = (ffelexHandler) ffestb_R9074_ (nt);
14720       ffelex_token_kill (nt);
14721       return (ffelexHandler) (*next) (t);
14722
14723     default:
14724       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14725                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9073_)))
14726         (ffesta_tokens[1]);
14727       ffelex_token_kill (ffesta_tokens[1]);
14728       return (ffelexHandler) (*next) (t);
14729     }
14730 }
14731
14732 /* ffestb_R9073_ -- "CLOSE" OPEN_PAREN expr
14733
14734    (ffestb_R9073_)  // to expression handler
14735
14736    Handle COMMA or CLOSE_PAREN here.  */
14737
14738 static ffelexHandler
14739 ffestb_R9073_ (ffelexToken ft, ffebld expr, ffelexToken t)
14740 {
14741   switch (ffelex_token_type (t))
14742     {
14743     case FFELEX_typeCOMMA:
14744     case FFELEX_typeCLOSE_PAREN:
14745       if (expr == NULL)
14746         break;
14747       ffestp_file.close.close_spec[FFESTP_closeixUNIT].kw_or_val_present
14748         = TRUE;
14749       ffestp_file.close.close_spec[FFESTP_closeixUNIT].kw_present = FALSE;
14750       ffestp_file.close.close_spec[FFESTP_closeixUNIT].value_present = TRUE;
14751       ffestp_file.close.close_spec[FFESTP_closeixUNIT].value_is_label
14752         = FALSE;
14753       ffestp_file.close.close_spec[FFESTP_closeixUNIT].value
14754         = ffelex_token_use (ft);
14755       ffestp_file.close.close_spec[FFESTP_closeixUNIT].u.expr = expr;
14756       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14757         return (ffelexHandler) ffestb_R9074_;
14758       return (ffelexHandler) ffestb_R9079_;
14759
14760     default:
14761       break;
14762     }
14763
14764   ffestb_subr_kill_close_ ();
14765   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14766   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14767 }
14768
14769 /* ffestb_R9074_ -- "CLOSE" OPEN_PAREN [external-file-unit COMMA]
14770
14771    return ffestb_R9074_;  // to lexer
14772
14773    Handle expr construct (not NAME=expr construct) here.  */
14774
14775 static ffelexHandler
14776 ffestb_R9074_ (ffelexToken t)
14777 {
14778   ffestrGenio kw;
14779
14780   ffestb_local_.close.label = FALSE;
14781
14782   switch (ffelex_token_type (t))
14783     {
14784     case FFELEX_typeNAME:
14785       kw = ffestr_genio (t);
14786       switch (kw)
14787         {
14788         case FFESTR_genioERR:
14789           ffestb_local_.close.ix = FFESTP_closeixERR;
14790           ffestb_local_.close.label = TRUE;
14791           break;
14792
14793         case FFESTR_genioIOSTAT:
14794           ffestb_local_.close.ix = FFESTP_closeixIOSTAT;
14795           ffestb_local_.close.left = TRUE;
14796           ffestb_local_.close.context = FFEEXPR_contextFILEINT;
14797           break;
14798
14799         case FFESTR_genioSTATUS:
14800         case FFESTR_genioDISP:
14801         case FFESTR_genioDISPOSE:
14802           ffestb_local_.close.ix = FFESTP_closeixSTATUS;
14803           ffestb_local_.close.left = FALSE;
14804           ffestb_local_.close.context = FFEEXPR_contextFILEDFCHAR;
14805           break;
14806
14807         case FFESTR_genioUNIT:
14808           ffestb_local_.close.ix = FFESTP_closeixUNIT;
14809           ffestb_local_.close.left = FALSE;
14810           ffestb_local_.close.context = FFEEXPR_contextFILENUM;
14811           break;
14812
14813         default:
14814           goto bad;             /* :::::::::::::::::::: */
14815         }
14816       if (ffestp_file.close.close_spec[ffestb_local_.close.ix]
14817           .kw_or_val_present)
14818         break;                  /* Can't specify a keyword twice! */
14819       ffestp_file.close.close_spec[ffestb_local_.close.ix]
14820         .kw_or_val_present = TRUE;
14821       ffestp_file.close.close_spec[ffestb_local_.close.ix]
14822         .kw_present = TRUE;
14823       ffestp_file.close.close_spec[ffestb_local_.close.ix]
14824         .value_present = FALSE;
14825       ffestp_file.close.close_spec[ffestb_local_.close.ix].value_is_label
14826         = ffestb_local_.close.label;
14827       ffestp_file.close.close_spec[ffestb_local_.close.ix].kw
14828         = ffelex_token_use (t);
14829       return (ffelexHandler) ffestb_R9075_;
14830
14831     default:
14832       break;
14833     }
14834
14835 bad:                            /* :::::::::::::::::::: */
14836   ffestb_subr_kill_close_ ();
14837   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14838   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14839 }
14840
14841 /* ffestb_R9075_ -- "CLOSE" OPEN_PAREN [external-file-unit COMMA] NAME
14842
14843    return ffestb_R9075_;  // to lexer
14844
14845    Make sure EQUALS here, send next token to expression handler.  */
14846
14847 static ffelexHandler
14848 ffestb_R9075_ (ffelexToken t)
14849 {
14850   switch (ffelex_token_type (t))
14851     {
14852     case FFELEX_typeEQUALS:
14853       ffesta_confirmed ();
14854       if (ffestb_local_.close.label)
14855         return (ffelexHandler) ffestb_R9077_;
14856       if (ffestb_local_.close.left)
14857         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
14858                                             ffestb_local_.close.context,
14859                                             (ffeexprCallback) ffestb_R9076_);
14860       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
14861                                           ffestb_local_.close.context,
14862                                           (ffeexprCallback) ffestb_R9076_);
14863
14864     default:
14865       break;
14866     }
14867
14868   ffestb_subr_kill_close_ ();
14869   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14870   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14871 }
14872
14873 /* ffestb_R9076_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS expr
14874
14875    (ffestb_R9076_)  // to expression handler
14876
14877    Handle COMMA or CLOSE_PAREN here.  */
14878
14879 static ffelexHandler
14880 ffestb_R9076_ (ffelexToken ft, ffebld expr, ffelexToken t)
14881 {
14882   switch (ffelex_token_type (t))
14883     {
14884     case FFELEX_typeCOMMA:
14885     case FFELEX_typeCLOSE_PAREN:
14886       if (expr == NULL)
14887         break;
14888       ffestp_file.close.close_spec[ffestb_local_.close.ix].value_present
14889         = TRUE;
14890       ffestp_file.close.close_spec[ffestb_local_.close.ix].value
14891         = ffelex_token_use (ft);
14892       ffestp_file.close.close_spec[ffestb_local_.close.ix].u.expr = expr;
14893       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
14894         return (ffelexHandler) ffestb_R9074_;
14895       return (ffelexHandler) ffestb_R9079_;
14896
14897     default:
14898       break;
14899     }
14900
14901   ffestb_subr_kill_close_ ();
14902   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14903   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14904 }
14905
14906 /* ffestb_R9077_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS
14907
14908    return ffestb_R9077_;  // to lexer
14909
14910    Handle NUMBER for label here.  */
14911
14912 static ffelexHandler
14913 ffestb_R9077_ (ffelexToken t)
14914 {
14915   switch (ffelex_token_type (t))
14916     {
14917     case FFELEX_typeNUMBER:
14918       ffestp_file.close.close_spec[ffestb_local_.close.ix].value_present
14919         = TRUE;
14920       ffestp_file.close.close_spec[ffestb_local_.close.ix].value
14921         = ffelex_token_use (t);
14922       return (ffelexHandler) ffestb_R9078_;
14923
14924     default:
14925       break;
14926     }
14927
14928   ffestb_subr_kill_close_ ();
14929   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14930   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14931 }
14932
14933 /* ffestb_R9078_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS NUMBER
14934
14935    return ffestb_R9078_;  // to lexer
14936
14937    Handle COMMA or CLOSE_PAREN here.  */
14938
14939 static ffelexHandler
14940 ffestb_R9078_ (ffelexToken t)
14941 {
14942   switch (ffelex_token_type (t))
14943     {
14944     case FFELEX_typeCOMMA:
14945       return (ffelexHandler) ffestb_R9074_;
14946
14947     case FFELEX_typeCLOSE_PAREN:
14948       return (ffelexHandler) ffestb_R9079_;
14949
14950     default:
14951       break;
14952     }
14953
14954   ffestb_subr_kill_close_ ();
14955   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14956   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14957 }
14958
14959 /* ffestb_R9079_ -- "CLOSE" OPEN_PAREN ... CLOSE_PAREN
14960
14961    return ffestb_R9079_;  // to lexer
14962
14963    Handle EOS or SEMICOLON here.  */
14964
14965 static ffelexHandler
14966 ffestb_R9079_ (ffelexToken t)
14967 {
14968   switch (ffelex_token_type (t))
14969     {
14970     case FFELEX_typeEOS:
14971     case FFELEX_typeSEMICOLON:
14972       ffesta_confirmed ();
14973       if (!ffesta_is_inhibited ())
14974         ffestc_R907 ();
14975       ffestb_subr_kill_close_ ();
14976       return (ffelexHandler) ffesta_zero (t);
14977
14978     default:
14979       break;
14980     }
14981
14982   ffestb_subr_kill_close_ ();
14983   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
14984   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
14985 }
14986
14987 /* ffestb_R909 -- Parse the READ statement
14988
14989    return ffestb_R909;  // to lexer
14990
14991    Make sure the statement has a valid form for the READ
14992    statement.  If it does, implement the statement.  */
14993
14994 ffelexHandler
14995 ffestb_R909 (ffelexToken t)
14996 {
14997   ffelexHandler next;
14998   ffestpReadIx ix;
14999
15000   switch (ffelex_token_type (ffesta_tokens[0]))
15001     {
15002     case FFELEX_typeNAME:
15003       if (ffesta_first_kw != FFESTR_firstREAD)
15004         goto bad_0;             /* :::::::::::::::::::: */
15005       switch (ffelex_token_type (t))
15006         {
15007         case FFELEX_typeCOMMA:
15008         case FFELEX_typeCOLONCOLON:
15009         case FFELEX_typeEOS:
15010         case FFELEX_typeSEMICOLON:
15011           ffesta_confirmed ();  /* Error, but clearly intended. */
15012           goto bad_1;           /* :::::::::::::::::::: */
15013
15014         case FFELEX_typeEQUALS:
15015         case FFELEX_typePOINTS:
15016         case FFELEX_typeCOLON:
15017           goto bad_1;           /* :::::::::::::::::::: */
15018
15019         case FFELEX_typeNAME:
15020         case FFELEX_typeNUMBER:
15021           ffesta_confirmed ();
15022           break;
15023
15024         case FFELEX_typeOPEN_PAREN:
15025           for (ix = 0; ix < FFESTP_readix; ++ix)
15026             ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15027           ffesta_tokens[1] = ffelex_token_use (t);
15028           return (ffelexHandler) ffestb_R9092_;
15029
15030         default:
15031           break;
15032         }
15033
15034       for (ix = 0; ix < FFESTP_readix; ++ix)
15035         ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15036       return (ffelexHandler) (*((ffelexHandler)
15037                                 ffeexpr_rhs (ffesta_output_pool,
15038             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9091_)))
15039         (t);
15040
15041     case FFELEX_typeNAMES:
15042       if (ffesta_first_kw != FFESTR_firstREAD)
15043         goto bad_0;             /* :::::::::::::::::::: */
15044       switch (ffelex_token_type (t))
15045         {
15046         case FFELEX_typeEOS:
15047         case FFELEX_typeSEMICOLON:
15048         case FFELEX_typeCOMMA:
15049           ffesta_confirmed ();
15050           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREAD)
15051             break;
15052           goto bad_1;           /* :::::::::::::::::::: */
15053
15054         case FFELEX_typeCOLONCOLON:
15055           ffesta_confirmed ();  /* Error, but clearly intended. */
15056           goto bad_1;           /* :::::::::::::::::::: */
15057
15058         case FFELEX_typeEQUALS:
15059         case FFELEX_typePOINTS:
15060         case FFELEX_typeCOLON:
15061           goto bad_1;           /* :::::::::::::::::::: */
15062
15063         case FFELEX_typeOPEN_PAREN:
15064           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREAD)
15065             break;
15066
15067           for (ix = 0; ix < FFESTP_readix; ++ix)
15068             ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15069           ffesta_tokens[1] = ffelex_token_use (t);
15070           return (ffelexHandler) ffestb_R9092_;
15071
15072         default:
15073           break;
15074         }
15075       for (ix = 0; ix < FFESTP_readix; ++ix)
15076         ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
15077       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15078              FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9091_);
15079       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
15080                                                    FFESTR_firstlREAD);
15081       if (next == NULL)
15082         return (ffelexHandler) ffelex_swallow_tokens (t,
15083                                                (ffelexHandler) ffesta_zero);
15084       return (ffelexHandler) (*next) (t);
15085
15086     default:
15087       goto bad_0;               /* :::::::::::::::::::: */
15088     }
15089
15090 bad_0:                          /* :::::::::::::::::::: */
15091   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", ffesta_tokens[0]);
15092   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15093
15094 bad_1:                          /* :::::::::::::::::::: */
15095   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15096   return (ffelexHandler) ffelex_swallow_tokens (t,
15097                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
15098 }
15099
15100 /* ffestb_R9091_ -- "READ" expr
15101
15102    (ffestb_R9091_)  // to expression handler
15103
15104    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
15105
15106 static ffelexHandler
15107 ffestb_R9091_ (ffelexToken ft, ffebld expr, ffelexToken t)
15108 {
15109   switch (ffelex_token_type (t))
15110     {
15111     case FFELEX_typeEOS:
15112     case FFELEX_typeSEMICOLON:
15113     case FFELEX_typeCOMMA:
15114       ffesta_confirmed ();
15115       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
15116         = TRUE;
15117       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
15118       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
15119       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
15120         = (expr == NULL);
15121       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
15122         = ffelex_token_use (ft);
15123       ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
15124       if (!ffesta_is_inhibited ())
15125         ffestc_R909_start (TRUE);
15126       ffestb_subr_kill_read_ ();
15127       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15128         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
15129                                             ffestc_context_iolist (),
15130                                           (ffeexprCallback) ffestb_R90915_);
15131       if (!ffesta_is_inhibited ())
15132         ffestc_R909_finish ();
15133       return (ffelexHandler) ffesta_zero (t);
15134
15135     default:
15136       break;
15137     }
15138
15139   ffestb_subr_kill_read_ ();
15140   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15141   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15142 }
15143
15144 /* ffestb_R9092_ -- "READ" OPEN_PAREN
15145
15146    return ffestb_R9092_;  // to lexer
15147
15148    Handle expr construct (not NAME=expr construct) here.  */
15149
15150 static ffelexHandler
15151 ffestb_R9092_ (ffelexToken t)
15152 {
15153   ffelexToken nt;
15154   ffelexHandler next;
15155
15156   switch (ffelex_token_type (t))
15157     {
15158     case FFELEX_typeNAME:
15159       ffesta_tokens[2] = ffelex_token_use (t);
15160       return (ffelexHandler) ffestb_R9093_;
15161
15162     default:
15163       nt = ffesta_tokens[1];
15164       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15165             FFEEXPR_contextFILEUNITAMBIG, (ffeexprCallback) ffestb_R9094_)))
15166         (nt);
15167       ffelex_token_kill (nt);
15168       return (ffelexHandler) (*next) (t);
15169     }
15170 }
15171
15172 /* ffestb_R9093_ -- "READ" OPEN_PAREN NAME
15173
15174    return ffestb_R9093_;  // to lexer
15175
15176    If EQUALS here, go to states that handle it.  Else, send NAME and this
15177    token thru expression handler.  */
15178
15179 static ffelexHandler
15180 ffestb_R9093_ (ffelexToken t)
15181 {
15182   ffelexHandler next;
15183   ffelexToken nt;
15184   ffelexToken ot;
15185
15186   switch (ffelex_token_type (t))
15187     {
15188     case FFELEX_typeEQUALS:
15189       ffelex_token_kill (ffesta_tokens[1]);
15190       nt = ffesta_tokens[2];
15191       next = (ffelexHandler) ffestb_R9098_ (nt);
15192       ffelex_token_kill (nt);
15193       return (ffelexHandler) (*next) (t);
15194
15195     default:
15196       nt = ffesta_tokens[1];
15197       ot = ffesta_tokens[2];
15198       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15199             FFEEXPR_contextFILEUNITAMBIG, (ffeexprCallback) ffestb_R9094_)))
15200         (nt);
15201       ffelex_token_kill (nt);
15202       next = (ffelexHandler) (*next) (ot);
15203       ffelex_token_kill (ot);
15204       return (ffelexHandler) (*next) (t);
15205     }
15206 }
15207
15208 /* ffestb_R9094_ -- "READ" OPEN_PAREN expr [CLOSE_PAREN]
15209
15210    (ffestb_R9094_)  // to expression handler
15211
15212    Handle COMMA or EOS/SEMICOLON here.
15213
15214    15-Feb-91  JCB  1.1
15215       Use new ffeexpr mechanism whereby the expr is encased in an opITEM if
15216       ffeexpr decided it was an item in a control list (hence a unit
15217       specifier), or a format specifier otherwise.  */
15218
15219 static ffelexHandler
15220 ffestb_R9094_ (ffelexToken ft, ffebld expr, ffelexToken t)
15221 {
15222   if (expr == NULL)
15223     goto bad;                   /* :::::::::::::::::::: */
15224
15225   if (ffebld_op (expr) != FFEBLD_opITEM)
15226     {
15227       switch (ffelex_token_type (t))
15228         {
15229         case FFELEX_typeCOMMA:
15230         case FFELEX_typeEOS:
15231         case FFELEX_typeSEMICOLON:
15232           ffesta_confirmed ();
15233           ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
15234             = TRUE;
15235           ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
15236           ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
15237           ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
15238             = FALSE;
15239           ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
15240             = ffelex_token_use (ft);
15241           ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
15242           if (!ffesta_is_inhibited ())
15243             ffestc_R909_start (TRUE);
15244           ffestb_subr_kill_read_ ();
15245           if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15246             return (ffelexHandler)
15247               ffeexpr_lhs (ffesta_output_pool,
15248                            ffestc_context_iolist (),
15249                            (ffeexprCallback) ffestb_R90915_);
15250           if (!ffesta_is_inhibited ())
15251             ffestc_R909_finish ();
15252           return (ffelexHandler) ffesta_zero (t);
15253
15254         default:
15255           goto bad;             /* :::::::::::::::::::: */
15256         }
15257     }
15258
15259   expr = ffebld_head (expr);
15260
15261   if (expr == NULL)
15262     goto bad;                   /* :::::::::::::::::::: */
15263
15264   switch (ffelex_token_type (t))
15265     {
15266     case FFELEX_typeCOMMA:
15267     case FFELEX_typeCLOSE_PAREN:
15268       ffestp_file.read.read_spec[FFESTP_readixUNIT].kw_or_val_present
15269         = TRUE;
15270       ffestp_file.read.read_spec[FFESTP_readixUNIT].kw_present = FALSE;
15271       ffestp_file.read.read_spec[FFESTP_readixUNIT].value_present = TRUE;
15272       ffestp_file.read.read_spec[FFESTP_readixUNIT].value_is_label
15273         = FALSE;
15274       ffestp_file.read.read_spec[FFESTP_readixUNIT].value
15275         = ffelex_token_use (ft);
15276       ffestp_file.read.read_spec[FFESTP_readixUNIT].u.expr = expr;
15277       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15278         return (ffelexHandler) ffestb_R9095_;
15279       return (ffelexHandler) ffestb_R90913_;
15280
15281     default:
15282       break;
15283     }
15284
15285 bad:                            /* :::::::::::::::::::: */
15286   ffestb_subr_kill_read_ ();
15287   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15288   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15289 }
15290
15291 /* ffestb_R9095_ -- "READ" OPEN_PAREN expr COMMA
15292
15293    return ffestb_R9095_;  // to lexer
15294
15295    Handle expr construct (not NAME=expr construct) here.  */
15296
15297 static ffelexHandler
15298 ffestb_R9095_ (ffelexToken t)
15299 {
15300   switch (ffelex_token_type (t))
15301     {
15302     case FFELEX_typeNAME:
15303       ffesta_tokens[1] = ffelex_token_use (t);
15304       return (ffelexHandler) ffestb_R9096_;
15305
15306     default:
15307       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15308             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9097_)))
15309         (t);
15310     }
15311 }
15312
15313 /* ffestb_R9096_ -- "READ" OPEN_PAREN expr COMMA NAME
15314
15315    return ffestb_R9096_;  // to lexer
15316
15317    If EQUALS here, go to states that handle it.  Else, send NAME and this
15318    token thru expression handler.  */
15319
15320 static ffelexHandler
15321 ffestb_R9096_ (ffelexToken t)
15322 {
15323   ffelexHandler next;
15324   ffelexToken nt;
15325
15326   switch (ffelex_token_type (t))
15327     {
15328     case FFELEX_typeEQUALS:
15329       nt = ffesta_tokens[1];
15330       next = (ffelexHandler) ffestb_R9098_ (nt);
15331       ffelex_token_kill (nt);
15332       return (ffelexHandler) (*next) (t);
15333
15334     default:
15335       nt = ffesta_tokens[1];
15336       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15337             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9097_)))
15338         (nt);
15339       ffelex_token_kill (nt);
15340       return (ffelexHandler) (*next) (t);
15341     }
15342 }
15343
15344 /* ffestb_R9097_ -- "READ" OPEN_PAREN expr COMMA expr
15345
15346    (ffestb_R9097_)  // to expression handler
15347
15348    Handle COMMA or CLOSE_PAREN here.  */
15349
15350 static ffelexHandler
15351 ffestb_R9097_ (ffelexToken ft, ffebld expr, ffelexToken t)
15352 {
15353   switch (ffelex_token_type (t))
15354     {
15355     case FFELEX_typeCOMMA:
15356     case FFELEX_typeCLOSE_PAREN:
15357       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
15358         = TRUE;
15359       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
15360       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
15361       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
15362         = (expr == NULL);
15363       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
15364         = ffelex_token_use (ft);
15365       ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
15366       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15367         return (ffelexHandler) ffestb_R9098_;
15368       return (ffelexHandler) ffestb_R90913_;
15369
15370     default:
15371       break;
15372     }
15373
15374   ffestb_subr_kill_read_ ();
15375   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15376   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15377 }
15378
15379 /* ffestb_R9098_ -- "READ" OPEN_PAREN [external-file-unit COMMA [format
15380                    COMMA]]
15381
15382    return ffestb_R9098_;  // to lexer
15383
15384    Handle expr construct (not NAME=expr construct) here.  */
15385
15386 static ffelexHandler
15387 ffestb_R9098_ (ffelexToken t)
15388 {
15389   ffestrGenio kw;
15390
15391   ffestb_local_.read.label = FALSE;
15392
15393   switch (ffelex_token_type (t))
15394     {
15395     case FFELEX_typeNAME:
15396       kw = ffestr_genio (t);
15397       switch (kw)
15398         {
15399         case FFESTR_genioADVANCE:
15400           ffestb_local_.read.ix = FFESTP_readixADVANCE;
15401           ffestb_local_.read.left = FALSE;
15402           ffestb_local_.read.context = FFEEXPR_contextFILEDFCHAR;
15403           break;
15404
15405         case FFESTR_genioEOR:
15406           ffestb_local_.read.ix = FFESTP_readixEOR;
15407           ffestb_local_.read.label = TRUE;
15408           break;
15409
15410         case FFESTR_genioERR:
15411           ffestb_local_.read.ix = FFESTP_readixERR;
15412           ffestb_local_.read.label = TRUE;
15413           break;
15414
15415         case FFESTR_genioEND:
15416           ffestb_local_.read.ix = FFESTP_readixEND;
15417           ffestb_local_.read.label = TRUE;
15418           break;
15419
15420         case FFESTR_genioFMT:
15421           ffestb_local_.read.ix = FFESTP_readixFORMAT;
15422           ffestb_local_.read.left = FALSE;
15423           ffestb_local_.read.context = FFEEXPR_contextFILEFORMAT;
15424           break;
15425
15426         case FFESTR_genioIOSTAT:
15427           ffestb_local_.read.ix = FFESTP_readixIOSTAT;
15428           ffestb_local_.read.left = TRUE;
15429           ffestb_local_.read.context = FFEEXPR_contextFILEINT;
15430           break;
15431
15432         case FFESTR_genioKEY:
15433         case FFESTR_genioKEYEQ:
15434           ffestb_local_.read.ix = FFESTP_readixKEYEQ;
15435           ffestb_local_.read.left = FALSE;
15436           ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
15437           break;
15438
15439         case FFESTR_genioKEYGE:
15440           ffestb_local_.read.ix = FFESTP_readixKEYGE;
15441           ffestb_local_.read.left = FALSE;
15442           ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
15443           break;
15444
15445         case FFESTR_genioKEYGT:
15446           ffestb_local_.read.ix = FFESTP_readixKEYGT;
15447           ffestb_local_.read.left = FALSE;
15448           ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
15449           break;
15450
15451         case FFESTR_genioKEYID:
15452           ffestb_local_.read.ix = FFESTP_readixKEYID;
15453           ffestb_local_.read.left = FALSE;
15454           ffestb_local_.read.context = FFEEXPR_contextFILENUM;
15455           break;
15456
15457         case FFESTR_genioNML:
15458           ffestb_local_.read.ix = FFESTP_readixFORMAT;
15459           ffestb_local_.read.left = TRUE;
15460           ffestb_local_.read.context = FFEEXPR_contextFILENAMELIST;
15461           break;
15462
15463         case FFESTR_genioNULLS:
15464           ffestb_local_.read.ix = FFESTP_readixNULLS;
15465           ffestb_local_.read.left = TRUE;
15466           ffestb_local_.read.context = FFEEXPR_contextFILEINT;
15467           break;
15468
15469         case FFESTR_genioREC:
15470           ffestb_local_.read.ix = FFESTP_readixREC;
15471           ffestb_local_.read.left = FALSE;
15472           ffestb_local_.read.context = FFEEXPR_contextFILENUM;
15473           break;
15474
15475         case FFESTR_genioSIZE:
15476           ffestb_local_.read.ix = FFESTP_readixSIZE;
15477           ffestb_local_.read.left = TRUE;
15478           ffestb_local_.read.context = FFEEXPR_contextFILEINT;
15479           break;
15480
15481         case FFESTR_genioUNIT:
15482           ffestb_local_.read.ix = FFESTP_readixUNIT;
15483           ffestb_local_.read.left = FALSE;
15484           ffestb_local_.read.context = FFEEXPR_contextFILEUNIT;
15485           break;
15486
15487         default:
15488           goto bad;             /* :::::::::::::::::::: */
15489         }
15490       if (ffestp_file.read.read_spec[ffestb_local_.read.ix]
15491           .kw_or_val_present)
15492         break;                  /* Can't specify a keyword twice! */
15493       ffestp_file.read.read_spec[ffestb_local_.read.ix]
15494         .kw_or_val_present = TRUE;
15495       ffestp_file.read.read_spec[ffestb_local_.read.ix]
15496         .kw_present = TRUE;
15497       ffestp_file.read.read_spec[ffestb_local_.read.ix]
15498         .value_present = FALSE;
15499       ffestp_file.read.read_spec[ffestb_local_.read.ix].value_is_label
15500         = ffestb_local_.read.label;
15501       ffestp_file.read.read_spec[ffestb_local_.read.ix].kw
15502         = ffelex_token_use (t);
15503       return (ffelexHandler) ffestb_R9099_;
15504
15505     default:
15506       break;
15507     }
15508
15509 bad:                            /* :::::::::::::::::::: */
15510   ffestb_subr_kill_read_ ();
15511   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15512   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15513 }
15514
15515 /* ffestb_R9099_ -- "READ" OPEN_PAREN [external-file-unit COMMA [format
15516                    COMMA]] NAME
15517
15518    return ffestb_R9099_;  // to lexer
15519
15520    Make sure EQUALS here, send next token to expression handler.  */
15521
15522 static ffelexHandler
15523 ffestb_R9099_ (ffelexToken t)
15524 {
15525   switch (ffelex_token_type (t))
15526     {
15527     case FFELEX_typeEQUALS:
15528       ffesta_confirmed ();
15529       if (ffestb_local_.read.label)
15530         return (ffelexHandler) ffestb_R90911_;
15531       if (ffestb_local_.read.left)
15532         return (ffelexHandler)
15533           ffeexpr_lhs (ffesta_output_pool,
15534                        ffestb_local_.read.context,
15535                        (ffeexprCallback) ffestb_R90910_);
15536       return (ffelexHandler)
15537         ffeexpr_rhs (ffesta_output_pool,
15538                      ffestb_local_.read.context,
15539                      (ffeexprCallback) ffestb_R90910_);
15540
15541     default:
15542       break;
15543     }
15544
15545   ffestb_subr_kill_read_ ();
15546   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15547   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15548 }
15549
15550 /* ffestb_R90910_ -- "READ" OPEN_PAREN ... NAME EQUALS expr
15551
15552    (ffestb_R90910_)  // to expression handler
15553
15554    Handle COMMA or CLOSE_PAREN here.  */
15555
15556 static ffelexHandler
15557 ffestb_R90910_ (ffelexToken ft, ffebld expr, ffelexToken t)
15558 {
15559   switch (ffelex_token_type (t))
15560     {
15561     case FFELEX_typeCOMMA:
15562     case FFELEX_typeCLOSE_PAREN:
15563       if (expr == NULL)
15564         {
15565           if (ffestb_local_.read.context == FFEEXPR_contextFILEFORMAT)
15566             ffestp_file.read.read_spec[ffestb_local_.read.ix]
15567               .value_is_label = TRUE;
15568           else
15569             break;
15570         }
15571       ffestp_file.read.read_spec[ffestb_local_.read.ix].value_present
15572         = TRUE;
15573       ffestp_file.read.read_spec[ffestb_local_.read.ix].value
15574         = ffelex_token_use (ft);
15575       ffestp_file.read.read_spec[ffestb_local_.read.ix].u.expr = expr;
15576       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15577         return (ffelexHandler) ffestb_R9098_;
15578       return (ffelexHandler) ffestb_R90913_;
15579
15580     default:
15581       break;
15582     }
15583
15584   ffestb_subr_kill_read_ ();
15585   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15586   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15587 }
15588
15589 /* ffestb_R90911_ -- "READ" OPEN_PAREN ... NAME EQUALS
15590
15591    return ffestb_R90911_;  // to lexer
15592
15593    Handle NUMBER for label here.  */
15594
15595 static ffelexHandler
15596 ffestb_R90911_ (ffelexToken t)
15597 {
15598   switch (ffelex_token_type (t))
15599     {
15600     case FFELEX_typeNUMBER:
15601       ffestp_file.read.read_spec[ffestb_local_.read.ix].value_present
15602         = TRUE;
15603       ffestp_file.read.read_spec[ffestb_local_.read.ix].value
15604         = ffelex_token_use (t);
15605       return (ffelexHandler) ffestb_R90912_;
15606
15607     default:
15608       break;
15609     }
15610
15611   ffestb_subr_kill_read_ ();
15612   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15613   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15614 }
15615
15616 /* ffestb_R90912_ -- "READ" OPEN_PAREN ... NAME EQUALS NUMBER
15617
15618    return ffestb_R90912_;  // to lexer
15619
15620    Handle COMMA or CLOSE_PAREN here.  */
15621
15622 static ffelexHandler
15623 ffestb_R90912_ (ffelexToken t)
15624 {
15625   switch (ffelex_token_type (t))
15626     {
15627     case FFELEX_typeCOMMA:
15628       return (ffelexHandler) ffestb_R9098_;
15629
15630     case FFELEX_typeCLOSE_PAREN:
15631       return (ffelexHandler) ffestb_R90913_;
15632
15633     default:
15634       break;
15635     }
15636
15637   ffestb_subr_kill_read_ ();
15638   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15639   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15640 }
15641
15642 /* ffestb_R90913_ -- "READ" OPEN_PAREN ... CLOSE_PAREN
15643
15644    return ffestb_R90913_;  // to lexer
15645
15646    Handle EOS or SEMICOLON here.
15647
15648    15-Feb-91  JCB  1.1
15649       Fix to allow implied-DO construct here (OPEN_PAREN) -- actually,
15650       don't presume knowledge of what an initial token in an lhs context
15651       is going to be, let ffeexpr_lhs handle that as much as possible.  */
15652
15653 static ffelexHandler
15654 ffestb_R90913_ (ffelexToken t)
15655 {
15656   switch (ffelex_token_type (t))
15657     {
15658     case FFELEX_typeEOS:
15659     case FFELEX_typeSEMICOLON:
15660       ffesta_confirmed ();
15661       if (!ffesta_is_inhibited ())
15662         {
15663           ffestc_R909_start (FALSE);
15664           ffestc_R909_finish ();
15665         }
15666       ffestb_subr_kill_read_ ();
15667       return (ffelexHandler) ffesta_zero (t);
15668
15669     default:
15670       ffesta_confirmed ();
15671       /* Fall through. */
15672     case FFELEX_typeOPEN_PAREN: /* Could still be assignment!! */
15673       break;
15674     }
15675
15676   /* If token isn't NAME or OPEN_PAREN, ffeexpr_lhs will ultimately whine
15677      about it, so leave it up to that code. */
15678
15679   /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.  (f2c
15680      provides this extension, as do other compilers, supposedly.) */
15681
15682   if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
15683     return (ffelexHandler)
15684       ffeexpr_lhs (ffesta_output_pool,
15685                    ffestc_context_iolist (),
15686                    (ffeexprCallback) ffestb_R90914_);
15687
15688   return (ffelexHandler) (*((ffelexHandler)
15689                             ffeexpr_lhs (ffesta_output_pool,
15690                                          ffestc_context_iolist (),
15691                                          (ffeexprCallback) ffestb_R90914_)))
15692     (t);
15693 }
15694
15695 /* ffestb_R90914_ -- "READ(...)" expr
15696
15697    (ffestb_R90914_)  // to expression handler
15698
15699    Handle COMMA or EOS/SEMICOLON here.  */
15700
15701 static ffelexHandler
15702 ffestb_R90914_ (ffelexToken ft, ffebld expr, ffelexToken t)
15703 {
15704   switch (ffelex_token_type (t))
15705     {
15706     case FFELEX_typeCOMMA:
15707       if (expr == NULL)
15708         break;
15709
15710       ffesta_confirmed ();
15711       if (!ffesta_is_inhibited ())
15712         ffestc_R909_start (FALSE);
15713       ffestb_subr_kill_read_ ();
15714
15715       if (!ffesta_is_inhibited ())
15716         ffestc_R909_item (expr, ft);
15717       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
15718                                           ffestc_context_iolist (),
15719                                           (ffeexprCallback) ffestb_R90915_);
15720
15721     case FFELEX_typeEOS:
15722     case FFELEX_typeSEMICOLON:
15723       if (expr == NULL)
15724         break;
15725
15726       ffesta_confirmed ();
15727       if (!ffesta_is_inhibited ())
15728         ffestc_R909_start (FALSE);
15729       ffestb_subr_kill_read_ ();
15730
15731       if (!ffesta_is_inhibited ())
15732         {
15733           ffestc_R909_item (expr, ft);
15734           ffestc_R909_finish ();
15735         }
15736       return (ffelexHandler) ffesta_zero (t);
15737
15738     default:
15739       break;
15740     }
15741
15742   ffestb_subr_kill_read_ ();
15743   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15744   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15745 }
15746
15747 /* ffestb_R90915_ -- "READ(...)" expr COMMA expr
15748
15749    (ffestb_R90915_)  // to expression handler
15750
15751    Handle COMMA or EOS/SEMICOLON here.  */
15752
15753 static ffelexHandler
15754 ffestb_R90915_ (ffelexToken ft, ffebld expr, ffelexToken t)
15755 {
15756   switch (ffelex_token_type (t))
15757     {
15758     case FFELEX_typeCOMMA:
15759       if (expr == NULL)
15760         break;
15761       if (!ffesta_is_inhibited ())
15762         ffestc_R909_item (expr, ft);
15763       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
15764                                           ffestc_context_iolist (),
15765                                           (ffeexprCallback) ffestb_R90915_);
15766
15767     case FFELEX_typeEOS:
15768     case FFELEX_typeSEMICOLON:
15769       if (expr == NULL)
15770         break;
15771       if (!ffesta_is_inhibited ())
15772         {
15773           ffestc_R909_item (expr, ft);
15774           ffestc_R909_finish ();
15775         }
15776       return (ffelexHandler) ffesta_zero (t);
15777
15778     default:
15779       break;
15780     }
15781
15782   if (!ffesta_is_inhibited ())
15783     ffestc_R909_finish ();
15784   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
15785   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15786 }
15787
15788 /* ffestb_R910 -- Parse the WRITE statement
15789
15790    return ffestb_R910;  // to lexer
15791
15792    Make sure the statement has a valid form for the WRITE
15793    statement.  If it does, implement the statement.  */
15794
15795 ffelexHandler
15796 ffestb_R910 (ffelexToken t)
15797 {
15798   ffestpWriteIx ix;
15799
15800   switch (ffelex_token_type (ffesta_tokens[0]))
15801     {
15802     case FFELEX_typeNAME:
15803       if (ffesta_first_kw != FFESTR_firstWRITE)
15804         goto bad_0;             /* :::::::::::::::::::: */
15805       switch (ffelex_token_type (t))
15806         {
15807         case FFELEX_typeCOMMA:
15808         case FFELEX_typeCOLONCOLON:
15809         case FFELEX_typeEOS:
15810         case FFELEX_typeSEMICOLON:
15811         case FFELEX_typeNAME:
15812         case FFELEX_typeNUMBER:
15813           ffesta_confirmed ();  /* Error, but clearly intended. */
15814           goto bad_1;           /* :::::::::::::::::::: */
15815
15816         default:
15817           goto bad_1;           /* :::::::::::::::::::: */
15818
15819         case FFELEX_typeOPEN_PAREN:
15820           for (ix = 0; ix < FFESTP_writeix; ++ix)
15821             ffestp_file.write.write_spec[ix].kw_or_val_present = FALSE;
15822           return (ffelexHandler) ffestb_R9101_;
15823         }
15824
15825     case FFELEX_typeNAMES:
15826       if (ffesta_first_kw != FFESTR_firstWRITE)
15827         goto bad_0;             /* :::::::::::::::::::: */
15828       switch (ffelex_token_type (t))
15829         {
15830         case FFELEX_typeEOS:
15831         case FFELEX_typeSEMICOLON:
15832         case FFELEX_typeCOMMA:
15833         case FFELEX_typeCOLONCOLON:
15834           ffesta_confirmed ();  /* Error, but clearly intended. */
15835           goto bad_1;           /* :::::::::::::::::::: */
15836
15837         default:
15838           goto bad_1;           /* :::::::::::::::::::: */
15839
15840         case FFELEX_typeOPEN_PAREN:
15841           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlWRITE)
15842             goto bad_0;         /* :::::::::::::::::::: */
15843
15844           for (ix = 0; ix < FFESTP_writeix; ++ix)
15845             ffestp_file.write.write_spec[ix].kw_or_val_present = FALSE;
15846           return (ffelexHandler) ffestb_R9101_;
15847         }
15848
15849     default:
15850       goto bad_0;               /* :::::::::::::::::::: */
15851     }
15852
15853 bad_0:                          /* :::::::::::::::::::: */
15854   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", ffesta_tokens[0]);
15855   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15856
15857 bad_1:                          /* :::::::::::::::::::: */
15858   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
15859   return (ffelexHandler) ffelex_swallow_tokens (t,
15860                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
15861 }
15862
15863 /* ffestb_R9101_ -- "WRITE" OPEN_PAREN
15864
15865    return ffestb_R9101_;  // to lexer
15866
15867    Handle expr construct (not NAME=expr construct) here.  */
15868
15869 static ffelexHandler
15870 ffestb_R9101_ (ffelexToken t)
15871 {
15872   switch (ffelex_token_type (t))
15873     {
15874     case FFELEX_typeNAME:
15875       ffesta_tokens[1] = ffelex_token_use (t);
15876       return (ffelexHandler) ffestb_R9102_;
15877
15878     default:
15879       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15880                  FFEEXPR_contextFILEUNIT, (ffeexprCallback) ffestb_R9103_)))
15881         (t);
15882     }
15883 }
15884
15885 /* ffestb_R9102_ -- "WRITE" OPEN_PAREN NAME
15886
15887    return ffestb_R9102_;  // to lexer
15888
15889    If EQUALS here, go to states that handle it.  Else, send NAME and this
15890    token thru expression handler.  */
15891
15892 static ffelexHandler
15893 ffestb_R9102_ (ffelexToken t)
15894 {
15895   ffelexHandler next;
15896   ffelexToken nt;
15897
15898   switch (ffelex_token_type (t))
15899     {
15900     case FFELEX_typeEQUALS:
15901       nt = ffesta_tokens[1];
15902       next = (ffelexHandler) ffestb_R9107_ (nt);
15903       ffelex_token_kill (nt);
15904       return (ffelexHandler) (*next) (t);
15905
15906     default:
15907       nt = ffesta_tokens[1];
15908       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15909                  FFEEXPR_contextFILEUNIT, (ffeexprCallback) ffestb_R9103_)))
15910         (nt);
15911       ffelex_token_kill (nt);
15912       return (ffelexHandler) (*next) (t);
15913     }
15914 }
15915
15916 /* ffestb_R9103_ -- "WRITE" OPEN_PAREN expr [CLOSE_PAREN]
15917
15918    (ffestb_R9103_)  // to expression handler
15919
15920    Handle COMMA or EOS/SEMICOLON here.  */
15921
15922 static ffelexHandler
15923 ffestb_R9103_ (ffelexToken ft, ffebld expr, ffelexToken t)
15924 {
15925   switch (ffelex_token_type (t))
15926     {
15927     case FFELEX_typeCOMMA:
15928     case FFELEX_typeCLOSE_PAREN:
15929       if (expr == NULL)
15930         break;
15931       ffestp_file.write.write_spec[FFESTP_writeixUNIT].kw_or_val_present
15932         = TRUE;
15933       ffestp_file.write.write_spec[FFESTP_writeixUNIT].kw_present = FALSE;
15934       ffestp_file.write.write_spec[FFESTP_writeixUNIT].value_present = TRUE;
15935       ffestp_file.write.write_spec[FFESTP_writeixUNIT].value_is_label
15936         = FALSE;
15937       ffestp_file.write.write_spec[FFESTP_writeixUNIT].value
15938         = ffelex_token_use (ft);
15939       ffestp_file.write.write_spec[FFESTP_writeixUNIT].u.expr = expr;
15940       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
15941         return (ffelexHandler) ffestb_R9104_;
15942       return (ffelexHandler) ffestb_R91012_;
15943
15944     default:
15945       break;
15946     }
15947
15948   ffestb_subr_kill_write_ ();
15949   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
15950   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
15951 }
15952
15953 /* ffestb_R9104_ -- "WRITE" OPEN_PAREN expr COMMA
15954
15955    return ffestb_R9104_;  // to lexer
15956
15957    Handle expr construct (not NAME=expr construct) here.  */
15958
15959 static ffelexHandler
15960 ffestb_R9104_ (ffelexToken t)
15961 {
15962   switch (ffelex_token_type (t))
15963     {
15964     case FFELEX_typeNAME:
15965       ffesta_tokens[1] = ffelex_token_use (t);
15966       return (ffelexHandler) ffestb_R9105_;
15967
15968     default:
15969       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15970             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9106_)))
15971         (t);
15972     }
15973 }
15974
15975 /* ffestb_R9105_ -- "WRITE" OPEN_PAREN expr COMMA NAME
15976
15977    return ffestb_R9105_;  // to lexer
15978
15979    If EQUALS here, go to states that handle it.  Else, send NAME and this
15980    token thru expression handler.  */
15981
15982 static ffelexHandler
15983 ffestb_R9105_ (ffelexToken t)
15984 {
15985   ffelexHandler next;
15986   ffelexToken nt;
15987
15988   switch (ffelex_token_type (t))
15989     {
15990     case FFELEX_typeEQUALS:
15991       nt = ffesta_tokens[1];
15992       next = (ffelexHandler) ffestb_R9107_ (nt);
15993       ffelex_token_kill (nt);
15994       return (ffelexHandler) (*next) (t);
15995
15996     default:
15997       nt = ffesta_tokens[1];
15998       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
15999             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9106_)))
16000         (nt);
16001       ffelex_token_kill (nt);
16002       return (ffelexHandler) (*next) (t);
16003     }
16004 }
16005
16006 /* ffestb_R9106_ -- "WRITE" OPEN_PAREN expr COMMA expr
16007
16008    (ffestb_R9106_)  // to expression handler
16009
16010    Handle COMMA or CLOSE_PAREN here.  */
16011
16012 static ffelexHandler
16013 ffestb_R9106_ (ffelexToken ft, ffebld expr, ffelexToken t)
16014 {
16015   switch (ffelex_token_type (t))
16016     {
16017     case FFELEX_typeCOMMA:
16018     case FFELEX_typeCLOSE_PAREN:
16019       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].kw_or_val_present
16020         = TRUE;
16021       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].kw_present = FALSE;
16022       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value_present = TRUE;
16023       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value_is_label
16024         = (expr == NULL);
16025       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value
16026         = ffelex_token_use (ft);
16027       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].u.expr = expr;
16028       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16029         return (ffelexHandler) ffestb_R9107_;
16030       return (ffelexHandler) ffestb_R91012_;
16031
16032     default:
16033       break;
16034     }
16035
16036   ffestb_subr_kill_write_ ();
16037   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16038   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16039 }
16040
16041 /* ffestb_R9107_ -- "WRITE" OPEN_PAREN [external-file-unit COMMA [format
16042                    COMMA]]
16043
16044    return ffestb_R9107_;  // to lexer
16045
16046    Handle expr construct (not NAME=expr construct) here.  */
16047
16048 static ffelexHandler
16049 ffestb_R9107_ (ffelexToken t)
16050 {
16051   ffestrGenio kw;
16052
16053   ffestb_local_.write.label = FALSE;
16054
16055   switch (ffelex_token_type (t))
16056     {
16057     case FFELEX_typeNAME:
16058       kw = ffestr_genio (t);
16059       switch (kw)
16060         {
16061         case FFESTR_genioADVANCE:
16062           ffestb_local_.write.ix = FFESTP_writeixADVANCE;
16063           ffestb_local_.write.left = FALSE;
16064           ffestb_local_.write.context = FFEEXPR_contextFILEDFCHAR;
16065           break;
16066
16067         case FFESTR_genioEOR:
16068           ffestb_local_.write.ix = FFESTP_writeixEOR;
16069           ffestb_local_.write.label = TRUE;
16070           break;
16071
16072         case FFESTR_genioERR:
16073           ffestb_local_.write.ix = FFESTP_writeixERR;
16074           ffestb_local_.write.label = TRUE;
16075           break;
16076
16077         case FFESTR_genioFMT:
16078           ffestb_local_.write.ix = FFESTP_writeixFORMAT;
16079           ffestb_local_.write.left = FALSE;
16080           ffestb_local_.write.context = FFEEXPR_contextFILEFORMAT;
16081           break;
16082
16083         case FFESTR_genioIOSTAT:
16084           ffestb_local_.write.ix = FFESTP_writeixIOSTAT;
16085           ffestb_local_.write.left = TRUE;
16086           ffestb_local_.write.context = FFEEXPR_contextFILEINT;
16087           break;
16088
16089         case FFESTR_genioNML:
16090           ffestb_local_.write.ix = FFESTP_writeixFORMAT;
16091           ffestb_local_.write.left = TRUE;
16092           ffestb_local_.write.context = FFEEXPR_contextFILENAMELIST;
16093           break;
16094
16095         case FFESTR_genioREC:
16096           ffestb_local_.write.ix = FFESTP_writeixREC;
16097           ffestb_local_.write.left = FALSE;
16098           ffestb_local_.write.context = FFEEXPR_contextFILENUM;
16099           break;
16100
16101         case FFESTR_genioUNIT:
16102           ffestb_local_.write.ix = FFESTP_writeixUNIT;
16103           ffestb_local_.write.left = FALSE;
16104           ffestb_local_.write.context = FFEEXPR_contextFILEUNIT;
16105           break;
16106
16107         default:
16108           goto bad;             /* :::::::::::::::::::: */
16109         }
16110       if (ffestp_file.write.write_spec[ffestb_local_.write.ix]
16111           .kw_or_val_present)
16112         break;                  /* Can't specify a keyword twice! */
16113       ffestp_file.write.write_spec[ffestb_local_.write.ix]
16114         .kw_or_val_present = TRUE;
16115       ffestp_file.write.write_spec[ffestb_local_.write.ix]
16116         .kw_present = TRUE;
16117       ffestp_file.write.write_spec[ffestb_local_.write.ix]
16118         .value_present = FALSE;
16119       ffestp_file.write.write_spec[ffestb_local_.write.ix].value_is_label
16120         = ffestb_local_.write.label;
16121       ffestp_file.write.write_spec[ffestb_local_.write.ix].kw
16122         = ffelex_token_use (t);
16123       return (ffelexHandler) ffestb_R9108_;
16124
16125     default:
16126       break;
16127     }
16128
16129 bad:                            /* :::::::::::::::::::: */
16130   ffestb_subr_kill_write_ ();
16131   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16132   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16133 }
16134
16135 /* ffestb_R9108_ -- "WRITE" OPEN_PAREN [external-file-unit COMMA [format
16136                    COMMA]] NAME
16137
16138    return ffestb_R9108_;  // to lexer
16139
16140    Make sure EQUALS here, send next token to expression handler.  */
16141
16142 static ffelexHandler
16143 ffestb_R9108_ (ffelexToken t)
16144 {
16145   switch (ffelex_token_type (t))
16146     {
16147     case FFELEX_typeEQUALS:
16148       ffesta_confirmed ();
16149       if (ffestb_local_.write.label)
16150         return (ffelexHandler) ffestb_R91010_;
16151       if (ffestb_local_.write.left)
16152         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
16153                                             ffestb_local_.write.context,
16154                                             (ffeexprCallback) ffestb_R9109_);
16155       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16156                                           ffestb_local_.write.context,
16157                                           (ffeexprCallback) ffestb_R9109_);
16158
16159     default:
16160       break;
16161     }
16162
16163   ffestb_subr_kill_write_ ();
16164   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16165   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16166 }
16167
16168 /* ffestb_R9109_ -- "WRITE" OPEN_PAREN ... NAME EQUALS expr
16169
16170    (ffestb_R9109_)  // to expression handler
16171
16172    Handle COMMA or CLOSE_PAREN here.  */
16173
16174 static ffelexHandler
16175 ffestb_R9109_ (ffelexToken ft, ffebld expr, ffelexToken t)
16176 {
16177   switch (ffelex_token_type (t))
16178     {
16179     case FFELEX_typeCOMMA:
16180     case FFELEX_typeCLOSE_PAREN:
16181       if (expr == NULL)
16182         {
16183           if (ffestb_local_.write.context == FFEEXPR_contextFILEFORMAT)
16184             ffestp_file.write.write_spec[ffestb_local_.write.ix]
16185               .value_is_label = TRUE;
16186           else
16187             break;
16188         }
16189       ffestp_file.write.write_spec[ffestb_local_.write.ix].value_present
16190         = TRUE;
16191       ffestp_file.write.write_spec[ffestb_local_.write.ix].value
16192         = ffelex_token_use (ft);
16193       ffestp_file.write.write_spec[ffestb_local_.write.ix].u.expr = expr;
16194       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16195         return (ffelexHandler) ffestb_R9107_;
16196       return (ffelexHandler) ffestb_R91012_;
16197
16198     default:
16199       break;
16200     }
16201
16202   ffestb_subr_kill_write_ ();
16203   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16204   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16205 }
16206
16207 /* ffestb_R91010_ -- "WRITE" OPEN_PAREN ... NAME EQUALS
16208
16209    return ffestb_R91010_;  // to lexer
16210
16211    Handle NUMBER for label here.  */
16212
16213 static ffelexHandler
16214 ffestb_R91010_ (ffelexToken t)
16215 {
16216   switch (ffelex_token_type (t))
16217     {
16218     case FFELEX_typeNUMBER:
16219       ffestp_file.write.write_spec[ffestb_local_.write.ix].value_present
16220         = TRUE;
16221       ffestp_file.write.write_spec[ffestb_local_.write.ix].value
16222         = ffelex_token_use (t);
16223       return (ffelexHandler) ffestb_R91011_;
16224
16225     default:
16226       break;
16227     }
16228
16229   ffestb_subr_kill_write_ ();
16230   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16231   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16232 }
16233
16234 /* ffestb_R91011_ -- "WRITE" OPEN_PAREN ... NAME EQUALS NUMBER
16235
16236    return ffestb_R91011_;  // to lexer
16237
16238    Handle COMMA or CLOSE_PAREN here.  */
16239
16240 static ffelexHandler
16241 ffestb_R91011_ (ffelexToken t)
16242 {
16243   switch (ffelex_token_type (t))
16244     {
16245     case FFELEX_typeCOMMA:
16246       return (ffelexHandler) ffestb_R9107_;
16247
16248     case FFELEX_typeCLOSE_PAREN:
16249       return (ffelexHandler) ffestb_R91012_;
16250
16251     default:
16252       break;
16253     }
16254
16255   ffestb_subr_kill_write_ ();
16256   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16257   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16258 }
16259
16260 /* ffestb_R91012_ -- "WRITE" OPEN_PAREN ... CLOSE_PAREN
16261
16262    return ffestb_R91012_;  // to lexer
16263
16264    Handle EOS or SEMICOLON here.  */
16265
16266 static ffelexHandler
16267 ffestb_R91012_ (ffelexToken t)
16268 {
16269   switch (ffelex_token_type (t))
16270     {
16271     case FFELEX_typeEOS:
16272     case FFELEX_typeSEMICOLON:
16273       ffesta_confirmed ();
16274       if (!ffesta_is_inhibited ())
16275         {
16276           ffestc_R910_start ();
16277           ffestc_R910_finish ();
16278         }
16279       ffestb_subr_kill_write_ ();
16280       return (ffelexHandler) ffesta_zero (t);
16281
16282     default:
16283       ffesta_confirmed ();
16284       /* Fall through. */
16285     case FFELEX_typeOPEN_PAREN: /* Could still be assignment!! */
16286
16287       /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
16288          (f2c provides this extension, as do other compilers, supposedly.) */
16289
16290       if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
16291         return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16292                 ffestc_context_iolist (), (ffeexprCallback) ffestb_R91013_);
16293
16294       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16295                ffestc_context_iolist (), (ffeexprCallback) ffestb_R91013_)))
16296         (t);
16297
16298     case FFELEX_typeEQUALS:
16299     case FFELEX_typePOINTS:
16300       break;
16301     }
16302
16303   ffestb_subr_kill_write_ ();
16304   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16305   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16306 }
16307
16308 /* ffestb_R91013_ -- "WRITE(...)" expr
16309
16310    (ffestb_R91013_)  // to expression handler
16311
16312    Handle COMMA or EOS/SEMICOLON here.  */
16313
16314 static ffelexHandler
16315 ffestb_R91013_ (ffelexToken ft, ffebld expr, ffelexToken t)
16316 {
16317   switch (ffelex_token_type (t))
16318     {
16319     case FFELEX_typeCOMMA:
16320       if (expr == NULL)
16321         break;
16322
16323       ffesta_confirmed ();
16324       if (!ffesta_is_inhibited ())
16325         ffestc_R910_start ();
16326       ffestb_subr_kill_write_ ();
16327
16328       if (!ffesta_is_inhibited ())
16329         ffestc_R910_item (expr, ft);
16330       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16331                 ffestc_context_iolist (), (ffeexprCallback) ffestb_R91014_);
16332
16333     case FFELEX_typeEOS:
16334     case FFELEX_typeSEMICOLON:
16335       if (expr == NULL)
16336         break;
16337
16338       ffesta_confirmed ();
16339       if (!ffesta_is_inhibited ())
16340         ffestc_R910_start ();
16341       ffestb_subr_kill_write_ ();
16342
16343       if (!ffesta_is_inhibited ())
16344         {
16345           ffestc_R910_item (expr, ft);
16346           ffestc_R910_finish ();
16347         }
16348       return (ffelexHandler) ffesta_zero (t);
16349
16350     default:
16351       break;
16352     }
16353
16354   ffestb_subr_kill_write_ ();
16355   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16356   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16357 }
16358
16359 /* ffestb_R91014_ -- "WRITE(...)" expr COMMA expr
16360
16361    (ffestb_R91014_)  // to expression handler
16362
16363    Handle COMMA or EOS/SEMICOLON here.  */
16364
16365 static ffelexHandler
16366 ffestb_R91014_ (ffelexToken ft, ffebld expr, ffelexToken t)
16367 {
16368   switch (ffelex_token_type (t))
16369     {
16370     case FFELEX_typeCOMMA:
16371       if (expr == NULL)
16372         break;
16373       if (!ffesta_is_inhibited ())
16374         ffestc_R910_item (expr, ft);
16375       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16376                 ffestc_context_iolist (), (ffeexprCallback) ffestb_R91014_);
16377
16378     case FFELEX_typeEOS:
16379     case FFELEX_typeSEMICOLON:
16380       if (expr == NULL)
16381         break;
16382       if (!ffesta_is_inhibited ())
16383         {
16384           ffestc_R910_item (expr, ft);
16385           ffestc_R910_finish ();
16386         }
16387       return (ffelexHandler) ffesta_zero (t);
16388
16389     default:
16390       break;
16391     }
16392
16393   if (!ffesta_is_inhibited ())
16394     ffestc_R910_finish ();
16395   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
16396   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16397 }
16398
16399 /* ffestb_R911 -- Parse the PRINT statement
16400
16401    return ffestb_R911;  // to lexer
16402
16403    Make sure the statement has a valid form for the PRINT
16404    statement.  If it does, implement the statement.  */
16405
16406 ffelexHandler
16407 ffestb_R911 (ffelexToken t)
16408 {
16409   ffelexHandler next;
16410   ffestpPrintIx ix;
16411
16412   switch (ffelex_token_type (ffesta_tokens[0]))
16413     {
16414     case FFELEX_typeNAME:
16415       if (ffesta_first_kw != FFESTR_firstPRINT)
16416         goto bad_0;             /* :::::::::::::::::::: */
16417       switch (ffelex_token_type (t))
16418         {
16419         case FFELEX_typeCOMMA:
16420         case FFELEX_typeCOLONCOLON:
16421         case FFELEX_typeEOS:
16422         case FFELEX_typeSEMICOLON:
16423           ffesta_confirmed ();  /* Error, but clearly intended. */
16424           goto bad_1;           /* :::::::::::::::::::: */
16425
16426         case FFELEX_typeEQUALS:
16427         case FFELEX_typePOINTS:
16428         case FFELEX_typeCOLON:
16429           goto bad_1;           /* :::::::::::::::::::: */
16430
16431         case FFELEX_typeNAME:
16432         case FFELEX_typeNUMBER:
16433           ffesta_confirmed ();
16434           break;
16435
16436         default:
16437           break;
16438         }
16439
16440       for (ix = 0; ix < FFESTP_printix; ++ix)
16441         ffestp_file.print.print_spec[ix].kw_or_val_present = FALSE;
16442       return (ffelexHandler) (*((ffelexHandler)
16443                                 ffeexpr_rhs (ffesta_output_pool,
16444             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9111_)))
16445         (t);
16446
16447     case FFELEX_typeNAMES:
16448       if (ffesta_first_kw != FFESTR_firstPRINT)
16449         goto bad_0;             /* :::::::::::::::::::: */
16450       switch (ffelex_token_type (t))
16451         {
16452         case FFELEX_typeEOS:
16453         case FFELEX_typeSEMICOLON:
16454         case FFELEX_typeCOMMA:
16455           ffesta_confirmed ();
16456           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlPRINT)
16457             break;
16458           goto bad_1;           /* :::::::::::::::::::: */
16459
16460         case FFELEX_typeCOLONCOLON:
16461           ffesta_confirmed ();  /* Error, but clearly intended. */
16462           goto bad_1;           /* :::::::::::::::::::: */
16463
16464         case FFELEX_typeEQUALS:
16465         case FFELEX_typePOINTS:
16466         case FFELEX_typeCOLON:
16467           goto bad_1;           /* :::::::::::::::::::: */
16468
16469         default:
16470           break;
16471         }
16472       for (ix = 0; ix < FFESTP_printix; ++ix)
16473         ffestp_file.print.print_spec[ix].kw_or_val_present = FALSE;
16474       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16475              FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9111_);
16476       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
16477                                                    FFESTR_firstlPRINT);
16478       if (next == NULL)
16479         return (ffelexHandler) ffelex_swallow_tokens (t,
16480                                                (ffelexHandler) ffesta_zero);
16481       return (ffelexHandler) (*next) (t);
16482
16483     default:
16484       goto bad_0;               /* :::::::::::::::::::: */
16485     }
16486
16487 bad_0:                          /* :::::::::::::::::::: */
16488   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", ffesta_tokens[0]);
16489   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16490
16491 bad_1:                          /* :::::::::::::::::::: */
16492   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
16493   return (ffelexHandler) ffelex_swallow_tokens (t,
16494                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
16495 }
16496
16497 /* ffestb_R9111_ -- "PRINT" expr
16498
16499    (ffestb_R9111_)  // to expression handler
16500
16501    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
16502
16503 static ffelexHandler
16504 ffestb_R9111_ (ffelexToken ft, ffebld expr, ffelexToken t)
16505 {
16506   switch (ffelex_token_type (t))
16507     {
16508     case FFELEX_typeEOS:
16509     case FFELEX_typeSEMICOLON:
16510     case FFELEX_typeCOMMA:
16511       ffesta_confirmed ();
16512       ffestp_file.print.print_spec[FFESTP_printixFORMAT].kw_or_val_present
16513         = TRUE;
16514       ffestp_file.print.print_spec[FFESTP_printixFORMAT].kw_present = FALSE;
16515       ffestp_file.print.print_spec[FFESTP_printixFORMAT].value_present = TRUE;
16516       ffestp_file.print.print_spec[FFESTP_printixFORMAT].value_is_label
16517         = (expr == NULL);
16518       ffestp_file.print.print_spec[FFESTP_printixFORMAT].value
16519         = ffelex_token_use (ft);
16520       ffestp_file.print.print_spec[FFESTP_printixFORMAT].u.expr = expr;
16521       if (!ffesta_is_inhibited ())
16522         ffestc_R911_start ();
16523       ffestb_subr_kill_print_ ();
16524       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16525         return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16526                     FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R9112_);
16527       if (!ffesta_is_inhibited ())
16528         ffestc_R911_finish ();
16529       return (ffelexHandler) ffesta_zero (t);
16530
16531     default:
16532       break;
16533     }
16534
16535   ffestb_subr_kill_print_ ();
16536   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
16537   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16538 }
16539
16540 /* ffestb_R9112_ -- "PRINT" expr COMMA expr
16541
16542    (ffestb_R9112_)  // to expression handler
16543
16544    Handle COMMA or EOS/SEMICOLON here.  */
16545
16546 static ffelexHandler
16547 ffestb_R9112_ (ffelexToken ft, ffebld expr, ffelexToken t)
16548 {
16549   switch (ffelex_token_type (t))
16550     {
16551     case FFELEX_typeCOMMA:
16552       if (expr == NULL)
16553         break;
16554       if (!ffesta_is_inhibited ())
16555         ffestc_R911_item (expr, ft);
16556       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16557                     FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R9112_);
16558
16559     case FFELEX_typeEOS:
16560     case FFELEX_typeSEMICOLON:
16561       if (expr == NULL)
16562         break;
16563       if (!ffesta_is_inhibited ())
16564         {
16565           ffestc_R911_item (expr, ft);
16566           ffestc_R911_finish ();
16567         }
16568       return (ffelexHandler) ffesta_zero (t);
16569
16570     default:
16571       break;
16572     }
16573
16574   if (!ffesta_is_inhibited ())
16575     ffestc_R911_finish ();
16576   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
16577   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16578 }
16579
16580 /* ffestb_R923 -- Parse an INQUIRE statement
16581
16582    return ffestb_R923;  // to lexer
16583
16584    Make sure the statement has a valid form for an INQUIRE statement.
16585    If it does, implement the statement.  */
16586
16587 ffelexHandler
16588 ffestb_R923 (ffelexToken t)
16589 {
16590   ffestpInquireIx ix;
16591
16592   switch (ffelex_token_type (ffesta_tokens[0]))
16593     {
16594     case FFELEX_typeNAME:
16595       if (ffesta_first_kw != FFESTR_firstINQUIRE)
16596         goto bad_0;             /* :::::::::::::::::::: */
16597       break;
16598
16599     case FFELEX_typeNAMES:
16600       if (ffesta_first_kw != FFESTR_firstINQUIRE)
16601         goto bad_0;             /* :::::::::::::::::::: */
16602       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlINQUIRE)
16603         goto bad_0;             /* :::::::::::::::::::: */
16604       break;
16605
16606     default:
16607       goto bad_0;               /* :::::::::::::::::::: */
16608     }
16609
16610   switch (ffelex_token_type (t))
16611     {
16612     case FFELEX_typeOPEN_PAREN:
16613       break;
16614
16615     case FFELEX_typeEOS:
16616     case FFELEX_typeSEMICOLON:
16617     case FFELEX_typeCOMMA:
16618     case FFELEX_typeCOLONCOLON:
16619       ffesta_confirmed ();      /* Error, but clearly intended. */
16620       goto bad_1;               /* :::::::::::::::::::: */
16621
16622     default:
16623       goto bad_1;               /* :::::::::::::::::::: */
16624     }
16625
16626   for (ix = 0; ix < FFESTP_inquireix; ++ix)
16627     ffestp_file.inquire.inquire_spec[ix].kw_or_val_present = FALSE;
16628
16629   ffestb_local_.inquire.may_be_iolength = TRUE;
16630   return (ffelexHandler) ffestb_R9231_;
16631
16632 bad_0:                          /* :::::::::::::::::::: */
16633   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", ffesta_tokens[0]);
16634   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16635
16636 bad_1:                          /* :::::::::::::::::::: */
16637   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16638   return (ffelexHandler) ffelex_swallow_tokens (t,
16639                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
16640 }
16641
16642 /* ffestb_R9231_ -- "INQUIRE" OPEN_PAREN
16643
16644    return ffestb_R9231_;  // to lexer
16645
16646    Handle expr construct (not NAME=expr construct) here.  */
16647
16648 static ffelexHandler
16649 ffestb_R9231_ (ffelexToken t)
16650 {
16651   switch (ffelex_token_type (t))
16652     {
16653     case FFELEX_typeNAME:
16654       ffesta_tokens[1] = ffelex_token_use (t);
16655       return (ffelexHandler) ffestb_R9232_;
16656
16657     default:
16658       ffestb_local_.inquire.may_be_iolength = FALSE;
16659       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16660                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9233_)))
16661         (t);
16662     }
16663 }
16664
16665 /* ffestb_R9232_ -- "INQUIRE" OPEN_PAREN NAME
16666
16667    return ffestb_R9232_;  // to lexer
16668
16669    If EQUALS here, go to states that handle it.  Else, send NAME and this
16670    token thru expression handler.  */
16671
16672 static ffelexHandler
16673 ffestb_R9232_ (ffelexToken t)
16674 {
16675   ffelexHandler next;
16676   ffelexToken nt;
16677
16678   switch (ffelex_token_type (t))
16679     {
16680     case FFELEX_typeEQUALS:
16681       nt = ffesta_tokens[1];
16682       next = (ffelexHandler) ffestb_R9234_ (nt);
16683       ffelex_token_kill (nt);
16684       return (ffelexHandler) (*next) (t);
16685
16686     default:
16687       ffestb_local_.inquire.may_be_iolength = FALSE;
16688       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16689                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9233_)))
16690         (ffesta_tokens[1]);
16691       ffelex_token_kill (ffesta_tokens[1]);
16692       return (ffelexHandler) (*next) (t);
16693     }
16694 }
16695
16696 /* ffestb_R9233_ -- "INQUIRE" OPEN_PAREN expr
16697
16698    (ffestb_R9233_)  // to expression handler
16699
16700    Handle COMMA or CLOSE_PAREN here.  */
16701
16702 static ffelexHandler
16703 ffestb_R9233_ (ffelexToken ft, ffebld expr, ffelexToken t)
16704 {
16705   switch (ffelex_token_type (t))
16706     {
16707     case FFELEX_typeCOMMA:
16708     case FFELEX_typeCLOSE_PAREN:
16709       if (expr == NULL)
16710         break;
16711       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].kw_or_val_present
16712         = TRUE;
16713       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].kw_present = FALSE;
16714       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value_present = TRUE;
16715       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value_is_label
16716         = FALSE;
16717       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value
16718         = ffelex_token_use (ft);
16719       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].u.expr = expr;
16720       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
16721         return (ffelexHandler) ffestb_R9234_;
16722       return (ffelexHandler) ffestb_R9239_;
16723
16724     default:
16725       break;
16726     }
16727
16728   ffestb_subr_kill_inquire_ ();
16729   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16730   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16731 }
16732
16733 /* ffestb_R9234_ -- "INQUIRE" OPEN_PAREN [external-file-unit COMMA]
16734
16735    return ffestb_R9234_;  // to lexer
16736
16737    Handle expr construct (not NAME=expr construct) here.  */
16738
16739 static ffelexHandler
16740 ffestb_R9234_ (ffelexToken t)
16741 {
16742   ffestrInquire kw;
16743
16744   ffestb_local_.inquire.label = FALSE;
16745
16746   switch (ffelex_token_type (t))
16747     {
16748     case FFELEX_typeNAME:
16749       kw = ffestr_inquire (t);
16750       if (kw != FFESTR_inquireIOLENGTH)
16751         ffestb_local_.inquire.may_be_iolength = FALSE;
16752       switch (kw)
16753         {
16754         case FFESTR_inquireACCESS:
16755           ffestb_local_.inquire.ix = FFESTP_inquireixACCESS;
16756           ffestb_local_.inquire.left = TRUE;
16757           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16758           break;
16759
16760         case FFESTR_inquireACTION:
16761           ffestb_local_.inquire.ix = FFESTP_inquireixACTION;
16762           ffestb_local_.inquire.left = TRUE;
16763           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16764           break;
16765
16766         case FFESTR_inquireBLANK:
16767           ffestb_local_.inquire.ix = FFESTP_inquireixBLANK;
16768           ffestb_local_.inquire.left = TRUE;
16769           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16770           break;
16771
16772         case FFESTR_inquireCARRIAGECONTROL:
16773           ffestb_local_.inquire.ix = FFESTP_inquireixCARRIAGECONTROL;
16774           ffestb_local_.inquire.left = TRUE;
16775           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16776           break;
16777
16778         case FFESTR_inquireDEFAULTFILE:
16779           ffestb_local_.inquire.ix = FFESTP_inquireixDEFAULTFILE;
16780           ffestb_local_.inquire.left = FALSE;
16781           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16782           break;
16783
16784         case FFESTR_inquireDELIM:
16785           ffestb_local_.inquire.ix = FFESTP_inquireixDELIM;
16786           ffestb_local_.inquire.left = TRUE;
16787           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16788           break;
16789
16790         case FFESTR_inquireDIRECT:
16791           ffestb_local_.inquire.ix = FFESTP_inquireixDIRECT;
16792           ffestb_local_.inquire.left = TRUE;
16793           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16794           break;
16795
16796         case FFESTR_inquireERR:
16797           ffestb_local_.inquire.ix = FFESTP_inquireixERR;
16798           ffestb_local_.inquire.label = TRUE;
16799           break;
16800
16801         case FFESTR_inquireEXIST:
16802           ffestb_local_.inquire.ix = FFESTP_inquireixEXIST;
16803           ffestb_local_.inquire.left = TRUE;
16804           ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
16805           break;
16806
16807         case FFESTR_inquireFILE:
16808           ffestb_local_.inquire.ix = FFESTP_inquireixFILE;
16809           ffestb_local_.inquire.left = FALSE;
16810           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16811           break;
16812
16813         case FFESTR_inquireFORM:
16814           ffestb_local_.inquire.ix = FFESTP_inquireixFORM;
16815           ffestb_local_.inquire.left = TRUE;
16816           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16817           break;
16818
16819         case FFESTR_inquireFORMATTED:
16820           ffestb_local_.inquire.ix = FFESTP_inquireixFORMATTED;
16821           ffestb_local_.inquire.left = TRUE;
16822           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16823           break;
16824
16825         case FFESTR_inquireIOLENGTH:
16826           if (!ffestb_local_.inquire.may_be_iolength)
16827             goto bad;           /* :::::::::::::::::::: */
16828           ffestb_local_.inquire.ix = FFESTP_inquireixIOLENGTH;
16829           ffestb_local_.inquire.left = TRUE;
16830           ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16831           break;
16832
16833         case FFESTR_inquireIOSTAT:
16834           ffestb_local_.inquire.ix = FFESTP_inquireixIOSTAT;
16835           ffestb_local_.inquire.left = TRUE;
16836           ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16837           break;
16838
16839         case FFESTR_inquireKEYED:
16840           ffestb_local_.inquire.ix = FFESTP_inquireixKEYED;
16841           ffestb_local_.inquire.left = TRUE;
16842           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16843           break;
16844
16845         case FFESTR_inquireNAME:
16846           ffestb_local_.inquire.ix = FFESTP_inquireixNAME;
16847           ffestb_local_.inquire.left = TRUE;
16848           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16849           break;
16850
16851         case FFESTR_inquireNAMED:
16852           ffestb_local_.inquire.ix = FFESTP_inquireixNAMED;
16853           ffestb_local_.inquire.left = TRUE;
16854           ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
16855           break;
16856
16857         case FFESTR_inquireNEXTREC:
16858           ffestb_local_.inquire.ix = FFESTP_inquireixNEXTREC;
16859           ffestb_local_.inquire.left = TRUE;
16860           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFINT;
16861           break;
16862
16863         case FFESTR_inquireNUMBER:
16864           ffestb_local_.inquire.ix = FFESTP_inquireixNUMBER;
16865           ffestb_local_.inquire.left = TRUE;
16866           ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16867           break;
16868
16869         case FFESTR_inquireOPENED:
16870           ffestb_local_.inquire.ix = FFESTP_inquireixOPENED;
16871           ffestb_local_.inquire.left = TRUE;
16872           ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
16873           break;
16874
16875         case FFESTR_inquireORGANIZATION:
16876           ffestb_local_.inquire.ix = FFESTP_inquireixORGANIZATION;
16877           ffestb_local_.inquire.left = TRUE;
16878           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16879           break;
16880
16881         case FFESTR_inquirePAD:
16882           ffestb_local_.inquire.ix = FFESTP_inquireixPAD;
16883           ffestb_local_.inquire.left = TRUE;
16884           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16885           break;
16886
16887         case FFESTR_inquirePOSITION:
16888           ffestb_local_.inquire.ix = FFESTP_inquireixPOSITION;
16889           ffestb_local_.inquire.left = TRUE;
16890           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16891           break;
16892
16893         case FFESTR_inquireREAD:
16894           ffestb_local_.inquire.ix = FFESTP_inquireixREAD;
16895           ffestb_local_.inquire.left = TRUE;
16896           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16897           break;
16898
16899         case FFESTR_inquireREADWRITE:
16900           ffestb_local_.inquire.ix = FFESTP_inquireixREADWRITE;
16901           ffestb_local_.inquire.left = TRUE;
16902           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16903           break;
16904
16905         case FFESTR_inquireRECL:
16906           ffestb_local_.inquire.ix = FFESTP_inquireixRECL;
16907           ffestb_local_.inquire.left = TRUE;
16908           ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
16909           break;
16910
16911         case FFESTR_inquireRECORDTYPE:
16912           ffestb_local_.inquire.ix = FFESTP_inquireixRECORDTYPE;
16913           ffestb_local_.inquire.left = TRUE;
16914           ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
16915           break;
16916
16917         case FFESTR_inquireSEQUENTIAL:
16918           ffestb_local_.inquire.ix = FFESTP_inquireixSEQUENTIAL;
16919           ffestb_local_.inquire.left = TRUE;
16920           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16921           break;
16922
16923         case FFESTR_inquireUNFORMATTED:
16924           ffestb_local_.inquire.ix = FFESTP_inquireixUNFORMATTED;
16925           ffestb_local_.inquire.left = TRUE;
16926           ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
16927           break;
16928
16929         case FFESTR_inquireUNIT:
16930           ffestb_local_.inquire.ix = FFESTP_inquireixUNIT;
16931           ffestb_local_.inquire.left = FALSE;
16932           ffestb_local_.inquire.context = FFEEXPR_contextFILENUM;
16933           break;
16934
16935         default:
16936           goto bad;             /* :::::::::::::::::::: */
16937         }
16938       if (ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16939           .kw_or_val_present)
16940         break;                  /* Can't specify a keyword twice! */
16941       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16942         .kw_or_val_present = TRUE;
16943       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16944         .kw_present = TRUE;
16945       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
16946         .value_present = FALSE;
16947       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_is_label
16948         = ffestb_local_.inquire.label;
16949       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].kw
16950         = ffelex_token_use (t);
16951       return (ffelexHandler) ffestb_R9235_;
16952
16953     default:
16954       break;
16955     }
16956
16957 bad:                            /* :::::::::::::::::::: */
16958   ffestb_subr_kill_inquire_ ();
16959   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16960   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16961 }
16962
16963 /* ffestb_R9235_ -- "INQUIRE" OPEN_PAREN [external-file-unit COMMA] NAME
16964
16965    return ffestb_R9235_;  // to lexer
16966
16967    Make sure EQUALS here, send next token to expression handler.  */
16968
16969 static ffelexHandler
16970 ffestb_R9235_ (ffelexToken t)
16971 {
16972   switch (ffelex_token_type (t))
16973     {
16974     case FFELEX_typeEQUALS:
16975       ffesta_confirmed ();
16976       if (ffestb_local_.inquire.label)
16977         return (ffelexHandler) ffestb_R9237_;
16978       if (ffestb_local_.inquire.left)
16979         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
16980                                             ffestb_local_.inquire.context,
16981                                             (ffeexprCallback) ffestb_R9236_);
16982       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
16983                                           ffestb_local_.inquire.context,
16984                                           (ffeexprCallback) ffestb_R9236_);
16985
16986     default:
16987       break;
16988     }
16989
16990   ffestb_subr_kill_inquire_ ();
16991   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
16992   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
16993 }
16994
16995 /* ffestb_R9236_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS expr
16996
16997    (ffestb_R9236_)  // to expression handler
16998
16999    Handle COMMA or CLOSE_PAREN here.  */
17000
17001 static ffelexHandler
17002 ffestb_R9236_ (ffelexToken ft, ffebld expr, ffelexToken t)
17003 {
17004   switch (ffelex_token_type (t))
17005     {
17006     case FFELEX_typeCOMMA:
17007       if (ffestb_local_.inquire.ix == FFESTP_inquireixIOLENGTH)
17008         break;                  /* IOLENGTH=expr must be followed by
17009                                    CLOSE_PAREN. */
17010       /* Fall through. */
17011     case FFELEX_typeCLOSE_PAREN:
17012       if (expr == NULL)
17013         break;
17014       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_present
17015         = TRUE;
17016       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value
17017         = ffelex_token_use (ft);
17018       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].u.expr = expr;
17019       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17020         return (ffelexHandler) ffestb_R9234_;
17021       if (ffestb_local_.inquire.ix == FFESTP_inquireixIOLENGTH)
17022         return (ffelexHandler) ffestb_R92310_;
17023       return (ffelexHandler) ffestb_R9239_;
17024
17025     default:
17026       break;
17027     }
17028
17029   ffestb_subr_kill_inquire_ ();
17030   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17031   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17032 }
17033
17034 /* ffestb_R9237_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS
17035
17036    return ffestb_R9237_;  // to lexer
17037
17038    Handle NUMBER for label here.  */
17039
17040 static ffelexHandler
17041 ffestb_R9237_ (ffelexToken t)
17042 {
17043   switch (ffelex_token_type (t))
17044     {
17045     case FFELEX_typeNUMBER:
17046       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_present
17047         = TRUE;
17048       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value
17049         = ffelex_token_use (t);
17050       return (ffelexHandler) ffestb_R9238_;
17051
17052     default:
17053       break;
17054     }
17055
17056   ffestb_subr_kill_inquire_ ();
17057   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17058   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17059 }
17060
17061 /* ffestb_R9238_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS NUMBER
17062
17063    return ffestb_R9238_;  // to lexer
17064
17065    Handle COMMA or CLOSE_PAREN here.  */
17066
17067 static ffelexHandler
17068 ffestb_R9238_ (ffelexToken t)
17069 {
17070   switch (ffelex_token_type (t))
17071     {
17072     case FFELEX_typeCOMMA:
17073       return (ffelexHandler) ffestb_R9234_;
17074
17075     case FFELEX_typeCLOSE_PAREN:
17076       return (ffelexHandler) ffestb_R9239_;
17077
17078     default:
17079       break;
17080     }
17081
17082   ffestb_subr_kill_inquire_ ();
17083   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17084   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17085 }
17086
17087 /* ffestb_R9239_ -- "INQUIRE" OPEN_PAREN ... CLOSE_PAREN
17088
17089    return ffestb_R9239_;  // to lexer
17090
17091    Handle EOS or SEMICOLON here.  */
17092
17093 static ffelexHandler
17094 ffestb_R9239_ (ffelexToken t)
17095 {
17096   switch (ffelex_token_type (t))
17097     {
17098     case FFELEX_typeEOS:
17099     case FFELEX_typeSEMICOLON:
17100       ffesta_confirmed ();
17101       if (!ffesta_is_inhibited ())
17102         ffestc_R923A ();
17103       ffestb_subr_kill_inquire_ ();
17104       return (ffelexHandler) ffesta_zero (t);
17105
17106     default:
17107       break;
17108     }
17109
17110   ffestb_subr_kill_inquire_ ();
17111   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17112   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17113 }
17114
17115 /* ffestb_R92310_ -- "INQUIRE(IOLENGTH=expr)"
17116
17117    return ffestb_R92310_;  // to lexer
17118
17119    Make sure EOS or SEMICOLON not here; begin R923B processing and expect
17120    output IO list.  */
17121
17122 static ffelexHandler
17123 ffestb_R92310_ (ffelexToken t)
17124 {
17125   switch (ffelex_token_type (t))
17126     {
17127     case FFELEX_typeEOS:
17128     case FFELEX_typeSEMICOLON:
17129       break;
17130
17131     default:
17132       ffesta_confirmed ();
17133       if (!ffesta_is_inhibited ())
17134         ffestc_R923B_start ();
17135       ffestb_subr_kill_inquire_ ();
17136       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17137                   FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R92311_)))
17138         (t);
17139     }
17140
17141   ffestb_subr_kill_inquire_ ();
17142   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17143   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17144 }
17145
17146 /* ffestb_R92311_ -- "INQUIRE(IOLENGTH=expr)" expr
17147
17148    (ffestb_R92311_)  // to expression handler
17149
17150    Handle COMMA or EOS/SEMICOLON here.  */
17151
17152 static ffelexHandler
17153 ffestb_R92311_ (ffelexToken ft, ffebld expr, ffelexToken t)
17154 {
17155   switch (ffelex_token_type (t))
17156     {
17157     case FFELEX_typeCOMMA:
17158       if (expr == NULL)
17159         break;
17160       if (!ffesta_is_inhibited ())
17161         ffestc_R923B_item (expr, ft);
17162       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17163                    FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R92311_);
17164
17165     case FFELEX_typeEOS:
17166     case FFELEX_typeSEMICOLON:
17167       if (expr == NULL)
17168         break;
17169       if (!ffesta_is_inhibited ())
17170         {
17171           ffestc_R923B_item (expr, ft);
17172           ffestc_R923B_finish ();
17173         }
17174       return (ffelexHandler) ffesta_zero (t);
17175
17176     default:
17177       break;
17178     }
17179
17180   if (!ffesta_is_inhibited ())
17181     ffestc_R923B_finish ();
17182   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
17183   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17184 }
17185
17186 /* ffestb_V018 -- Parse the REWRITE statement
17187
17188    return ffestb_V018;  // to lexer
17189
17190    Make sure the statement has a valid form for the REWRITE
17191    statement.  If it does, implement the statement.  */
17192
17193 #if FFESTR_VXT
17194 ffelexHandler
17195 ffestb_V018 (ffelexToken t)
17196 {
17197   ffestpRewriteIx ix;
17198
17199   switch (ffelex_token_type (ffesta_tokens[0]))
17200     {
17201     case FFELEX_typeNAME:
17202       if (ffesta_first_kw != FFESTR_firstREWRITE)
17203         goto bad_0;             /* :::::::::::::::::::: */
17204       switch (ffelex_token_type (t))
17205         {
17206         case FFELEX_typeCOMMA:
17207         case FFELEX_typeCOLONCOLON:
17208         case FFELEX_typeEOS:
17209         case FFELEX_typeSEMICOLON:
17210         case FFELEX_typeNAME:
17211         case FFELEX_typeNUMBER:
17212           ffesta_confirmed ();  /* Error, but clearly intended. */
17213           goto bad_1;           /* :::::::::::::::::::: */
17214
17215         default:
17216           goto bad_1;           /* :::::::::::::::::::: */
17217
17218         case FFELEX_typeOPEN_PAREN:
17219           for (ix = 0; ix < FFESTP_rewriteix; ++ix)
17220             ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present = FALSE;
17221           return (ffelexHandler) ffestb_V0181_;
17222         }
17223
17224     case FFELEX_typeNAMES:
17225       if (ffesta_first_kw != FFESTR_firstREWRITE)
17226         goto bad_0;             /* :::::::::::::::::::: */
17227       switch (ffelex_token_type (t))
17228         {
17229         case FFELEX_typeEOS:
17230         case FFELEX_typeSEMICOLON:
17231         case FFELEX_typeCOMMA:
17232         case FFELEX_typeCOLONCOLON:
17233           ffesta_confirmed ();  /* Error, but clearly intended. */
17234           goto bad_1;           /* :::::::::::::::::::: */
17235
17236         default:
17237           goto bad_1;           /* :::::::::::::::::::: */
17238
17239         case FFELEX_typeOPEN_PAREN:
17240           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREWRITE)
17241             goto bad_0;         /* :::::::::::::::::::: */
17242
17243           for (ix = 0; ix < FFESTP_rewriteix; ++ix)
17244             ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present = FALSE;
17245           return (ffelexHandler) ffestb_V0181_;
17246         }
17247
17248     default:
17249       goto bad_0;               /* :::::::::::::::::::: */
17250     }
17251
17252 bad_0:                          /* :::::::::::::::::::: */
17253   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", ffesta_tokens[0]);
17254   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17255
17256 bad_1:                          /* :::::::::::::::::::: */
17257   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17258   return (ffelexHandler) ffelex_swallow_tokens (t,
17259                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
17260 }
17261
17262 /* ffestb_V0181_ -- "REWRITE" OPEN_PAREN
17263
17264    return ffestb_V0181_;  // to lexer
17265
17266    Handle expr construct (not NAME=expr construct) here.  */
17267
17268 static ffelexHandler
17269 ffestb_V0181_ (ffelexToken t)
17270 {
17271   switch (ffelex_token_type (t))
17272     {
17273     case FFELEX_typeNAME:
17274       ffesta_tokens[1] = ffelex_token_use (t);
17275       return (ffelexHandler) ffestb_V0182_;
17276
17277     default:
17278       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17279                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0183_)))
17280         (t);
17281     }
17282 }
17283
17284 /* ffestb_V0182_ -- "REWRITE" OPEN_PAREN NAME
17285
17286    return ffestb_V0182_;  // to lexer
17287
17288    If EQUALS here, go to states that handle it.  Else, send NAME and this
17289    token thru expression handler.  */
17290
17291 static ffelexHandler
17292 ffestb_V0182_ (ffelexToken t)
17293 {
17294   ffelexHandler next;
17295   ffelexToken nt;
17296
17297   switch (ffelex_token_type (t))
17298     {
17299     case FFELEX_typeEQUALS:
17300       nt = ffesta_tokens[1];
17301       next = (ffelexHandler) ffestb_V0187_ (nt);
17302       ffelex_token_kill (nt);
17303       return (ffelexHandler) (*next) (t);
17304
17305     default:
17306       nt = ffesta_tokens[1];
17307       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17308                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0183_)))
17309         (nt);
17310       ffelex_token_kill (nt);
17311       return (ffelexHandler) (*next) (t);
17312     }
17313 }
17314
17315 /* ffestb_V0183_ -- "REWRITE" OPEN_PAREN expr [CLOSE_PAREN]
17316
17317    (ffestb_V0183_)  // to expression handler
17318
17319    Handle COMMA or EOS/SEMICOLON here.  */
17320
17321 static ffelexHandler
17322 ffestb_V0183_ (ffelexToken ft, ffebld expr, ffelexToken t)
17323 {
17324   switch (ffelex_token_type (t))
17325     {
17326     case FFELEX_typeCOMMA:
17327     case FFELEX_typeCLOSE_PAREN:
17328       if (expr == NULL)
17329         break;
17330       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].kw_or_val_present
17331         = TRUE;
17332       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].kw_present = FALSE;
17333       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value_present = TRUE;
17334       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value_is_label
17335         = FALSE;
17336       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value
17337         = ffelex_token_use (ft);
17338       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].u.expr = expr;
17339       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17340         return (ffelexHandler) ffestb_V0184_;
17341       return (ffelexHandler) ffestb_V01812_;
17342
17343     default:
17344       break;
17345     }
17346
17347   ffestb_subr_kill_rewrite_ ();
17348   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17349   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17350 }
17351
17352 /* ffestb_V0184_ -- "REWRITE" OPEN_PAREN expr COMMA
17353
17354    return ffestb_V0184_;  // to lexer
17355
17356    Handle expr construct (not NAME=expr construct) here.  */
17357
17358 static ffelexHandler
17359 ffestb_V0184_ (ffelexToken t)
17360 {
17361   switch (ffelex_token_type (t))
17362     {
17363     case FFELEX_typeNAME:
17364       ffesta_tokens[1] = ffelex_token_use (t);
17365       return (ffelexHandler) ffestb_V0185_;
17366
17367     default:
17368       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17369                FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_V0186_)))
17370         (t);
17371     }
17372 }
17373
17374 /* ffestb_V0185_ -- "REWRITE" OPEN_PAREN expr COMMA NAME
17375
17376    return ffestb_V0185_;  // to lexer
17377
17378    If EQUALS here, go to states that handle it.  Else, send NAME and this
17379    token thru expression handler.  */
17380
17381 static ffelexHandler
17382 ffestb_V0185_ (ffelexToken t)
17383 {
17384   ffelexHandler next;
17385   ffelexToken nt;
17386
17387   switch (ffelex_token_type (t))
17388     {
17389     case FFELEX_typeEQUALS:
17390       nt = ffesta_tokens[1];
17391       next = (ffelexHandler) ffestb_V0187_ (nt);
17392       ffelex_token_kill (nt);
17393       return (ffelexHandler) (*next) (t);
17394
17395     default:
17396       nt = ffesta_tokens[1];
17397       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17398                FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_V0186_)))
17399         (nt);
17400       ffelex_token_kill (nt);
17401       return (ffelexHandler) (*next) (t);
17402     }
17403 }
17404
17405 /* ffestb_V0186_ -- "REWRITE" OPEN_PAREN expr COMMA expr
17406
17407    (ffestb_V0186_)  // to expression handler
17408
17409    Handle COMMA or CLOSE_PAREN here.  */
17410
17411 static ffelexHandler
17412 ffestb_V0186_ (ffelexToken ft, ffebld expr, ffelexToken t)
17413 {
17414   switch (ffelex_token_type (t))
17415     {
17416     case FFELEX_typeCOMMA:
17417     case FFELEX_typeCLOSE_PAREN:
17418       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].kw_or_val_present
17419         = TRUE;
17420       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].kw_present = FALSE;
17421       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value_present = TRUE;
17422       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value_is_label
17423         = (expr == NULL);
17424       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value
17425         = ffelex_token_use (ft);
17426       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].u.expr = expr;
17427       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17428         return (ffelexHandler) ffestb_V0187_;
17429       return (ffelexHandler) ffestb_V01812_;
17430
17431     default:
17432       break;
17433     }
17434
17435   ffestb_subr_kill_rewrite_ ();
17436   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17437   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17438 }
17439
17440 /* ffestb_V0187_ -- "REWRITE" OPEN_PAREN [external-file-unit COMMA [format
17441                    COMMA]]
17442
17443    return ffestb_V0187_;  // to lexer
17444
17445    Handle expr construct (not NAME=expr construct) here.  */
17446
17447 static ffelexHandler
17448 ffestb_V0187_ (ffelexToken t)
17449 {
17450   ffestrGenio kw;
17451
17452   ffestb_local_.rewrite.label = FALSE;
17453
17454   switch (ffelex_token_type (t))
17455     {
17456     case FFELEX_typeNAME:
17457       kw = ffestr_genio (t);
17458       switch (kw)
17459         {
17460         case FFESTR_genioERR:
17461           ffestb_local_.rewrite.ix = FFESTP_rewriteixERR;
17462           ffestb_local_.rewrite.label = TRUE;
17463           break;
17464
17465         case FFESTR_genioFMT:
17466           ffestb_local_.rewrite.ix = FFESTP_rewriteixFMT;
17467           ffestb_local_.rewrite.left = FALSE;
17468           ffestb_local_.rewrite.context = FFEEXPR_contextFILEFORMAT;
17469           break;
17470
17471         case FFESTR_genioIOSTAT:
17472           ffestb_local_.rewrite.ix = FFESTP_rewriteixIOSTAT;
17473           ffestb_local_.rewrite.left = TRUE;
17474           ffestb_local_.rewrite.context = FFEEXPR_contextFILEINT;
17475           break;
17476
17477         case FFESTR_genioUNIT:
17478           ffestb_local_.rewrite.ix = FFESTP_rewriteixUNIT;
17479           ffestb_local_.rewrite.left = FALSE;
17480           ffestb_local_.rewrite.context = FFEEXPR_contextFILENUM;
17481           break;
17482
17483         default:
17484           goto bad;             /* :::::::::::::::::::: */
17485         }
17486       if (ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17487           .kw_or_val_present)
17488         break;                  /* Can't specify a keyword twice! */
17489       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17490         .kw_or_val_present = TRUE;
17491       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17492         .kw_present = TRUE;
17493       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17494         .value_present = FALSE;
17495       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_is_label
17496         = ffestb_local_.rewrite.label;
17497       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].kw
17498         = ffelex_token_use (t);
17499       return (ffelexHandler) ffestb_V0188_;
17500
17501     default:
17502       break;
17503     }
17504
17505 bad:                            /* :::::::::::::::::::: */
17506   ffestb_subr_kill_rewrite_ ();
17507   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17508   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17509 }
17510
17511 /* ffestb_V0188_ -- "REWRITE" OPEN_PAREN [external-file-unit COMMA [format
17512                    COMMA]] NAME
17513
17514    return ffestb_V0188_;  // to lexer
17515
17516    Make sure EQUALS here, send next token to expression handler.  */
17517
17518 static ffelexHandler
17519 ffestb_V0188_ (ffelexToken t)
17520 {
17521   switch (ffelex_token_type (t))
17522     {
17523     case FFELEX_typeEQUALS:
17524       ffesta_confirmed ();
17525       if (ffestb_local_.rewrite.label)
17526         return (ffelexHandler) ffestb_V01810_;
17527       if (ffestb_local_.rewrite.left)
17528         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
17529                                             ffestb_local_.rewrite.context,
17530                                             (ffeexprCallback) ffestb_V0189_);
17531       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17532                                           ffestb_local_.rewrite.context,
17533                                           (ffeexprCallback) ffestb_V0189_);
17534
17535     default:
17536       break;
17537     }
17538
17539   ffestb_subr_kill_rewrite_ ();
17540   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17541   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17542 }
17543
17544 /* ffestb_V0189_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS expr
17545
17546    (ffestb_V0189_)  // to expression handler
17547
17548    Handle COMMA or CLOSE_PAREN here.  */
17549
17550 static ffelexHandler
17551 ffestb_V0189_ (ffelexToken ft, ffebld expr, ffelexToken t)
17552 {
17553   switch (ffelex_token_type (t))
17554     {
17555     case FFELEX_typeCOMMA:
17556     case FFELEX_typeCLOSE_PAREN:
17557       if (expr == NULL)
17558         if (ffestb_local_.rewrite.context == FFEEXPR_contextFILEFORMAT)
17559           ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
17560             .value_is_label = TRUE;
17561         else
17562           break;
17563       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_present
17564         = TRUE;
17565       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value
17566         = ffelex_token_use (ft);
17567       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].u.expr = expr;
17568       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17569         return (ffelexHandler) ffestb_V0187_;
17570       return (ffelexHandler) ffestb_V01812_;
17571
17572     default:
17573       break;
17574     }
17575
17576   ffestb_subr_kill_rewrite_ ();
17577   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17578   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17579 }
17580
17581 /* ffestb_V01810_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS
17582
17583    return ffestb_V01810_;  // to lexer
17584
17585    Handle NUMBER for label here.  */
17586
17587 static ffelexHandler
17588 ffestb_V01810_ (ffelexToken t)
17589 {
17590   switch (ffelex_token_type (t))
17591     {
17592     case FFELEX_typeNUMBER:
17593       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_present
17594         = TRUE;
17595       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value
17596         = ffelex_token_use (t);
17597       return (ffelexHandler) ffestb_V01811_;
17598
17599     default:
17600       break;
17601     }
17602
17603   ffestb_subr_kill_rewrite_ ();
17604   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17605   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17606 }
17607
17608 /* ffestb_V01811_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS NUMBER
17609
17610    return ffestb_V01811_;  // to lexer
17611
17612    Handle COMMA or CLOSE_PAREN here.  */
17613
17614 static ffelexHandler
17615 ffestb_V01811_ (ffelexToken t)
17616 {
17617   switch (ffelex_token_type (t))
17618     {
17619     case FFELEX_typeCOMMA:
17620       return (ffelexHandler) ffestb_V0187_;
17621
17622     case FFELEX_typeCLOSE_PAREN:
17623       return (ffelexHandler) ffestb_V01812_;
17624
17625     default:
17626       break;
17627     }
17628
17629   ffestb_subr_kill_rewrite_ ();
17630   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17631   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17632 }
17633
17634 /* ffestb_V01812_ -- "REWRITE" OPEN_PAREN ... CLOSE_PAREN
17635
17636    return ffestb_V01812_;  // to lexer
17637
17638    Handle EOS or SEMICOLON here.  */
17639
17640 static ffelexHandler
17641 ffestb_V01812_ (ffelexToken t)
17642 {
17643   switch (ffelex_token_type (t))
17644     {
17645     case FFELEX_typeEOS:
17646     case FFELEX_typeSEMICOLON:
17647       ffesta_confirmed ();
17648       if (!ffesta_is_inhibited ())
17649         {
17650           ffestc_V018_start ();
17651           ffestc_V018_finish ();
17652         }
17653       ffestb_subr_kill_rewrite_ ();
17654       return (ffelexHandler) ffesta_zero (t);
17655
17656     case FFELEX_typeNAME:
17657     case FFELEX_typeOPEN_PAREN:
17658     case FFELEX_typeCOMMA:
17659       ffesta_confirmed ();
17660       if (!ffesta_is_inhibited ())
17661         ffestc_V018_start ();
17662       ffestb_subr_kill_rewrite_ ();
17663
17664       /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
17665          (f2c provides this extension, as do other compilers, supposedly.) */
17666
17667       if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
17668         return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17669                    FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_);
17670
17671       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17672                   FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_)))
17673         (t);
17674
17675     default:
17676       break;
17677     }
17678
17679   ffestb_subr_kill_rewrite_ ();
17680   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17681   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17682 }
17683
17684 /* ffestb_V01813_ -- "REWRITE(...)" expr
17685
17686    (ffestb_V01813_)  // to expression handler
17687
17688    Handle COMMA or EOS/SEMICOLON here.  */
17689
17690 static ffelexHandler
17691 ffestb_V01813_ (ffelexToken ft, ffebld expr, ffelexToken t)
17692 {
17693   switch (ffelex_token_type (t))
17694     {
17695     case FFELEX_typeCOMMA:
17696       if (expr == NULL)
17697         break;
17698       if (!ffesta_is_inhibited ())
17699         ffestc_V018_item (expr, ft);
17700       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17701                    FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_);
17702
17703     case FFELEX_typeEOS:
17704     case FFELEX_typeSEMICOLON:
17705       if (expr == NULL)
17706         break;
17707       if (!ffesta_is_inhibited ())
17708         {
17709           ffestc_V018_item (expr, ft);
17710           ffestc_V018_finish ();
17711         }
17712       return (ffelexHandler) ffesta_zero (t);
17713
17714     default:
17715       break;
17716     }
17717
17718   if (!ffesta_is_inhibited ())
17719     ffestc_V018_finish ();
17720   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
17721   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17722 }
17723
17724 /* ffestb_V019 -- Parse the ACCEPT statement
17725
17726    return ffestb_V019;  // to lexer
17727
17728    Make sure the statement has a valid form for the ACCEPT
17729    statement.  If it does, implement the statement.  */
17730
17731 ffelexHandler
17732 ffestb_V019 (ffelexToken t)
17733 {
17734   ffelexHandler next;
17735   ffestpAcceptIx ix;
17736
17737   switch (ffelex_token_type (ffesta_tokens[0]))
17738     {
17739     case FFELEX_typeNAME:
17740       if (ffesta_first_kw != FFESTR_firstACCEPT)
17741         goto bad_0;             /* :::::::::::::::::::: */
17742       switch (ffelex_token_type (t))
17743         {
17744         case FFELEX_typeCOMMA:
17745         case FFELEX_typeCOLONCOLON:
17746         case FFELEX_typeEOS:
17747         case FFELEX_typeSEMICOLON:
17748           ffesta_confirmed ();  /* Error, but clearly intended. */
17749           goto bad_1;           /* :::::::::::::::::::: */
17750
17751         case FFELEX_typeEQUALS:
17752         case FFELEX_typePOINTS:
17753         case FFELEX_typeCOLON:
17754           goto bad_1;           /* :::::::::::::::::::: */
17755
17756         case FFELEX_typeNAME:
17757         case FFELEX_typeNUMBER:
17758           ffesta_confirmed ();
17759           break;
17760
17761         default:
17762           break;
17763         }
17764
17765       for (ix = 0; ix < FFESTP_acceptix; ++ix)
17766         ffestp_file.accept.accept_spec[ix].kw_or_val_present = FALSE;
17767       return (ffelexHandler) (*((ffelexHandler)
17768                                 ffeexpr_rhs (ffesta_output_pool,
17769             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0191_)))
17770         (t);
17771
17772     case FFELEX_typeNAMES:
17773       if (ffesta_first_kw != FFESTR_firstACCEPT)
17774         goto bad_0;             /* :::::::::::::::::::: */
17775       switch (ffelex_token_type (t))
17776         {
17777         case FFELEX_typeEOS:
17778         case FFELEX_typeSEMICOLON:
17779         case FFELEX_typeCOMMA:
17780           ffesta_confirmed ();
17781           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlACCEPT)
17782             break;
17783           goto bad_1;           /* :::::::::::::::::::: */
17784
17785         case FFELEX_typeCOLONCOLON:
17786           ffesta_confirmed ();  /* Error, but clearly intended. */
17787           goto bad_1;           /* :::::::::::::::::::: */
17788
17789         case FFELEX_typeEQUALS:
17790         case FFELEX_typePOINTS:
17791         case FFELEX_typeCOLON:
17792           goto bad_1;           /* :::::::::::::::::::: */
17793
17794         default:
17795           break;
17796         }
17797       for (ix = 0; ix < FFESTP_acceptix; ++ix)
17798         ffestp_file.accept.accept_spec[ix].kw_or_val_present = FALSE;
17799       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17800              FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0191_);
17801       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
17802                                                    FFESTR_firstlACCEPT);
17803       if (next == NULL)
17804         return (ffelexHandler) ffelex_swallow_tokens (t,
17805                                                (ffelexHandler) ffesta_zero);
17806       return (ffelexHandler) (*next) (t);
17807
17808     default:
17809       goto bad_0;               /* :::::::::::::::::::: */
17810     }
17811
17812 bad_0:                          /* :::::::::::::::::::: */
17813   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", ffesta_tokens[0]);
17814   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17815
17816 bad_1:                          /* :::::::::::::::::::: */
17817   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
17818   return (ffelexHandler) ffelex_swallow_tokens (t,
17819                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
17820 }
17821
17822 /* ffestb_V0191_ -- "ACCEPT" expr
17823
17824    (ffestb_V0191_)  // to expression handler
17825
17826    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
17827
17828 static ffelexHandler
17829 ffestb_V0191_ (ffelexToken ft, ffebld expr, ffelexToken t)
17830 {
17831   switch (ffelex_token_type (t))
17832     {
17833     case FFELEX_typeEOS:
17834     case FFELEX_typeSEMICOLON:
17835     case FFELEX_typeCOMMA:
17836       ffesta_confirmed ();
17837       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].kw_or_val_present
17838         = TRUE;
17839       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].kw_present = FALSE;
17840       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value_present = TRUE;
17841       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value_is_label
17842         = (expr == NULL);
17843       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value
17844         = ffelex_token_use (ft);
17845       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].u.expr = expr;
17846       if (!ffesta_is_inhibited ())
17847         ffestc_V019_start ();
17848       ffestb_subr_kill_accept_ ();
17849       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
17850         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
17851                                             FFEEXPR_contextIOLIST,
17852                                             (ffeexprCallback) ffestb_V0192_);
17853       if (!ffesta_is_inhibited ())
17854         ffestc_V019_finish ();
17855       return (ffelexHandler) ffesta_zero (t);
17856
17857     default:
17858       break;
17859     }
17860
17861   ffestb_subr_kill_accept_ ();
17862   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
17863   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17864 }
17865
17866 /* ffestb_V0192_ -- "ACCEPT" expr COMMA expr
17867
17868    (ffestb_V0192_)  // to expression handler
17869
17870    Handle COMMA or EOS/SEMICOLON here.  */
17871
17872 static ffelexHandler
17873 ffestb_V0192_ (ffelexToken ft, ffebld expr, ffelexToken t)
17874 {
17875   switch (ffelex_token_type (t))
17876     {
17877     case FFELEX_typeCOMMA:
17878       if (expr == NULL)
17879         break;
17880       if (!ffesta_is_inhibited ())
17881         ffestc_V019_item (expr, ft);
17882       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
17883                                           FFEEXPR_contextIOLIST,
17884                                           (ffeexprCallback) ffestb_V0192_);
17885
17886     case FFELEX_typeEOS:
17887     case FFELEX_typeSEMICOLON:
17888       if (expr == NULL)
17889         break;
17890       if (!ffesta_is_inhibited ())
17891         {
17892           ffestc_V019_item (expr, ft);
17893           ffestc_V019_finish ();
17894         }
17895       return (ffelexHandler) ffesta_zero (t);
17896
17897     default:
17898       break;
17899     }
17900
17901   if (!ffesta_is_inhibited ())
17902     ffestc_V019_finish ();
17903   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
17904   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
17905 }
17906
17907 #endif
17908 /* ffestb_V020 -- Parse the TYPE statement
17909
17910    return ffestb_V020;  // to lexer
17911
17912    Make sure the statement has a valid form for the TYPE
17913    statement.  If it does, implement the statement.  */
17914
17915 ffelexHandler
17916 ffestb_V020 (ffelexToken t)
17917 {
17918   ffeTokenLength i;
17919   const char *p;
17920   ffelexHandler next;
17921   ffestpTypeIx ix;
17922
17923   switch (ffelex_token_type (ffesta_tokens[0]))
17924     {
17925     case FFELEX_typeNAME:
17926       if (ffesta_first_kw != FFESTR_firstTYPE)
17927         goto bad_0;             /* :::::::::::::::::::: */
17928       switch (ffelex_token_type (t))
17929         {
17930         case FFELEX_typeCOLONCOLON:
17931         case FFELEX_typeEOS:
17932         case FFELEX_typeSEMICOLON:
17933           ffesta_confirmed ();  /* Error, but clearly intended. */
17934           goto bad_1;           /* :::::::::::::::::::: */
17935
17936         case FFELEX_typeEQUALS:
17937         case FFELEX_typePOINTS:
17938         case FFELEX_typeCOLON:
17939         case FFELEX_typeCOMMA:  /* Because "TYPE,PUBLIC::A" is ambiguous with
17940                                    '90. */
17941           goto bad_1;           /* :::::::::::::::::::: */
17942
17943         case FFELEX_typeNUMBER:
17944           ffesta_confirmed ();
17945           break;
17946
17947         case FFELEX_typeNAME:   /* Because TYPE A is ambiguous with '90. */
17948         default:
17949           break;
17950         }
17951
17952       for (ix = 0; ix < FFESTP_typeix; ++ix)
17953         ffestp_file.type.type_spec[ix].kw_or_val_present = FALSE;
17954       return (ffelexHandler) (*((ffelexHandler)
17955                                 ffeexpr_rhs (ffesta_output_pool,
17956             FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0201_)))
17957         (t);
17958
17959     case FFELEX_typeNAMES:
17960       if (ffesta_first_kw != FFESTR_firstTYPE)
17961         goto bad_0;             /* :::::::::::::::::::: */
17962       switch (ffelex_token_type (t))
17963         {
17964         case FFELEX_typeEOS:
17965         case FFELEX_typeSEMICOLON:
17966         case FFELEX_typeCOMMA:
17967           if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlTYPE)
17968             break;
17969           goto bad_1;           /* :::::::::::::::::::: */
17970
17971         case FFELEX_typeCOLONCOLON:
17972           ffesta_confirmed ();  /* Error, but clearly intended. */
17973           goto bad_1;           /* :::::::::::::::::::: */
17974
17975         case FFELEX_typeOPEN_PAREN:
17976           if (ffelex_token_length (ffesta_tokens[0]) == FFESTR_firstlTYPE)
17977             break;              /* Else might be assignment/stmtfuncdef. */
17978           goto bad_1;           /* :::::::::::::::::::: */
17979
17980         case FFELEX_typeEQUALS:
17981         case FFELEX_typePOINTS:
17982         case FFELEX_typeCOLON:
17983           goto bad_1;           /* :::::::::::::::::::: */
17984
17985         default:
17986           break;
17987         }
17988       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlTYPE);
17989       if (ISDIGIT (*p))
17990         ffesta_confirmed ();    /* Else might be '90 TYPE statement. */
17991       for (ix = 0; ix < FFESTP_typeix; ++ix)
17992         ffestp_file.type.type_spec[ix].kw_or_val_present = FALSE;
17993       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
17994              FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0201_);
17995       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
17996                                                    FFESTR_firstlTYPE);
17997       if (next == NULL)
17998         return (ffelexHandler) ffelex_swallow_tokens (t,
17999                                                (ffelexHandler) ffesta_zero);
18000       return (ffelexHandler) (*next) (t);
18001
18002     default:
18003       goto bad_0;               /* :::::::::::::::::::: */
18004     }
18005
18006 bad_0:                          /* :::::::::::::::::::: */
18007   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", ffesta_tokens[0]);
18008   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18009
18010 bad_1:                          /* :::::::::::::::::::: */
18011   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
18012   return (ffelexHandler) ffelex_swallow_tokens (t,
18013                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
18014 }
18015
18016 /* ffestb_V0201_ -- "TYPE" expr
18017
18018    (ffestb_V0201_)  // to expression handler
18019
18020    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
18021
18022 static ffelexHandler
18023 ffestb_V0201_ (ffelexToken ft, ffebld expr, ffelexToken t)
18024 {
18025   bool comma = TRUE;
18026
18027   switch (ffelex_token_type (t))
18028     {
18029     case FFELEX_typeEOS:
18030     case FFELEX_typeSEMICOLON:
18031       if (!ffe_is_vxt () && (expr != NULL)
18032           && (ffebld_op (expr) == FFEBLD_opSYMTER))
18033         break;
18034       comma = FALSE;
18035       /* Fall through. */
18036     case FFELEX_typeCOMMA:
18037       if (!ffe_is_vxt () && comma && (expr != NULL)
18038           && (ffebld_op (expr) == FFEBLD_opPAREN)
18039           && (ffebld_op (ffebld_left (expr)) == FFEBLD_opSYMTER))
18040         break;
18041       ffesta_confirmed ();
18042       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].kw_or_val_present
18043         = TRUE;
18044       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].kw_present = FALSE;
18045       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value_present = TRUE;
18046       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value_is_label
18047         = (expr == NULL);
18048       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value
18049         = ffelex_token_use (ft);
18050       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].u.expr = expr;
18051       if (!ffesta_is_inhibited ())
18052         ffestc_V020_start ();
18053       ffestb_subr_kill_type_ ();
18054       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18055         return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18056                     FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V0202_);
18057       if (!ffesta_is_inhibited ())
18058         ffestc_V020_finish ();
18059       return (ffelexHandler) ffesta_zero (t);
18060
18061     default:
18062       break;
18063     }
18064
18065   ffestb_subr_kill_type_ ();
18066   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
18067   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18068 }
18069
18070 /* ffestb_V0202_ -- "TYPE" expr COMMA expr
18071
18072    (ffestb_V0202_)  // to expression handler
18073
18074    Handle COMMA or EOS/SEMICOLON here.  */
18075
18076 static ffelexHandler
18077 ffestb_V0202_ (ffelexToken ft, ffebld expr, ffelexToken t)
18078 {
18079   switch (ffelex_token_type (t))
18080     {
18081     case FFELEX_typeCOMMA:
18082       if (expr == NULL)
18083         break;
18084       if (!ffesta_is_inhibited ())
18085         ffestc_V020_item (expr, ft);
18086       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18087                     FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V0202_);
18088
18089     case FFELEX_typeEOS:
18090     case FFELEX_typeSEMICOLON:
18091       if (expr == NULL)
18092         break;
18093       if (!ffesta_is_inhibited ())
18094         {
18095           ffestc_V020_item (expr, ft);
18096           ffestc_V020_finish ();
18097         }
18098       return (ffelexHandler) ffesta_zero (t);
18099
18100     default:
18101       break;
18102     }
18103
18104   if (!ffesta_is_inhibited ())
18105     ffestc_V020_finish ();
18106   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
18107   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18108 }
18109
18110 /* ffestb_V021 -- Parse a DELETE statement
18111
18112    return ffestb_V021;  // to lexer
18113
18114    Make sure the statement has a valid form for a DELETE statement.
18115    If it does, implement the statement.  */
18116
18117 #if FFESTR_VXT
18118 ffelexHandler
18119 ffestb_V021 (ffelexToken t)
18120 {
18121   ffestpDeleteIx ix;
18122
18123   switch (ffelex_token_type (ffesta_tokens[0]))
18124     {
18125     case FFELEX_typeNAME:
18126       if (ffesta_first_kw != FFESTR_firstDELETE)
18127         goto bad_0;             /* :::::::::::::::::::: */
18128       break;
18129
18130     case FFELEX_typeNAMES:
18131       if (ffesta_first_kw != FFESTR_firstDELETE)
18132         goto bad_0;             /* :::::::::::::::::::: */
18133       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlDELETE)
18134         goto bad_0;             /* :::::::::::::::::::: */
18135       break;
18136
18137     default:
18138       goto bad_0;               /* :::::::::::::::::::: */
18139     }
18140
18141   switch (ffelex_token_type (t))
18142     {
18143     case FFELEX_typeOPEN_PAREN:
18144       break;
18145
18146     case FFELEX_typeEOS:
18147     case FFELEX_typeSEMICOLON:
18148     case FFELEX_typeCOMMA:
18149     case FFELEX_typeCOLONCOLON:
18150       ffesta_confirmed ();      /* Error, but clearly intended. */
18151       goto bad_1;               /* :::::::::::::::::::: */
18152
18153     default:
18154       goto bad_1;               /* :::::::::::::::::::: */
18155     }
18156
18157   for (ix = 0; ix < FFESTP_deleteix; ++ix)
18158     ffestp_file.delete.delete_spec[ix].kw_or_val_present = FALSE;
18159
18160   return (ffelexHandler) ffestb_V0211_;
18161
18162 bad_0:                          /* :::::::::::::::::::: */
18163   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", ffesta_tokens[0]);
18164   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18165
18166 bad_1:                          /* :::::::::::::::::::: */
18167   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18168   return (ffelexHandler) ffelex_swallow_tokens (t,
18169                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
18170 }
18171
18172 /* ffestb_V0211_ -- "DELETE" OPEN_PAREN
18173
18174    return ffestb_V0211_;  // to lexer
18175
18176    Handle expr construct (not NAME=expr construct) here.  */
18177
18178 static ffelexHandler
18179 ffestb_V0211_ (ffelexToken t)
18180 {
18181   switch (ffelex_token_type (t))
18182     {
18183     case FFELEX_typeNAME:
18184       ffesta_tokens[1] = ffelex_token_use (t);
18185       return (ffelexHandler) ffestb_V0212_;
18186
18187     default:
18188       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18189                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0213_)))
18190         (t);
18191     }
18192 }
18193
18194 /* ffestb_V0212_ -- "DELETE" OPEN_PAREN NAME
18195
18196    return ffestb_V0212_;  // to lexer
18197
18198    If EQUALS here, go to states that handle it.  Else, send NAME and this
18199    token thru expression handler.  */
18200
18201 static ffelexHandler
18202 ffestb_V0212_ (ffelexToken t)
18203 {
18204   ffelexHandler next;
18205   ffelexToken nt;
18206
18207   switch (ffelex_token_type (t))
18208     {
18209     case FFELEX_typeEQUALS:
18210       nt = ffesta_tokens[1];
18211       next = (ffelexHandler) ffestb_V0214_ (nt);
18212       ffelex_token_kill (nt);
18213       return (ffelexHandler) (*next) (t);
18214
18215     default:
18216       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18217                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0213_)))
18218         (ffesta_tokens[1]);
18219       ffelex_token_kill (ffesta_tokens[1]);
18220       return (ffelexHandler) (*next) (t);
18221     }
18222 }
18223
18224 /* ffestb_V0213_ -- "DELETE" OPEN_PAREN expr
18225
18226    (ffestb_V0213_)  // to expression handler
18227
18228    Handle COMMA or DELETE_PAREN here.  */
18229
18230 static ffelexHandler
18231 ffestb_V0213_ (ffelexToken ft, ffebld expr, ffelexToken t)
18232 {
18233   switch (ffelex_token_type (t))
18234     {
18235     case FFELEX_typeCOMMA:
18236     case FFELEX_typeCLOSE_PAREN:
18237       if (expr == NULL)
18238         break;
18239       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].kw_or_val_present
18240         = TRUE;
18241       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].kw_present = FALSE;
18242       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value_present = TRUE;
18243       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value_is_label
18244         = FALSE;
18245       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value
18246         = ffelex_token_use (ft);
18247       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].u.expr = expr;
18248       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18249         return (ffelexHandler) ffestb_V0214_;
18250       return (ffelexHandler) ffestb_V0219_;
18251
18252     default:
18253       break;
18254     }
18255
18256   ffestb_subr_kill_delete_ ();
18257   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18258   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18259 }
18260
18261 /* ffestb_V0214_ -- "DELETE" OPEN_PAREN [external-file-unit COMMA]
18262
18263    return ffestb_V0214_;  // to lexer
18264
18265    Handle expr construct (not NAME=expr construct) here.  */
18266
18267 static ffelexHandler
18268 ffestb_V0214_ (ffelexToken t)
18269 {
18270   ffestrGenio kw;
18271
18272   ffestb_local_.delete.label = FALSE;
18273
18274   switch (ffelex_token_type (t))
18275     {
18276     case FFELEX_typeNAME:
18277       kw = ffestr_genio (t);
18278       switch (kw)
18279         {
18280         case FFESTR_genioERR:
18281           ffestb_local_.delete.ix = FFESTP_deleteixERR;
18282           ffestb_local_.delete.label = TRUE;
18283           break;
18284
18285         case FFESTR_genioIOSTAT:
18286           ffestb_local_.delete.ix = FFESTP_deleteixIOSTAT;
18287           ffestb_local_.delete.left = TRUE;
18288           ffestb_local_.delete.context = FFEEXPR_contextFILEINT;
18289           break;
18290
18291         case FFESTR_genioREC:
18292           ffestb_local_.delete.ix = FFESTP_deleteixREC;
18293           ffestb_local_.delete.left = FALSE;
18294           ffestb_local_.delete.context = FFEEXPR_contextFILENUM;
18295           break;
18296
18297         case FFESTR_genioUNIT:
18298           ffestb_local_.delete.ix = FFESTP_deleteixUNIT;
18299           ffestb_local_.delete.left = FALSE;
18300           ffestb_local_.delete.context = FFEEXPR_contextFILENUM;
18301           break;
18302
18303         default:
18304           goto bad;             /* :::::::::::::::::::: */
18305         }
18306       if (ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18307           .kw_or_val_present)
18308         break;                  /* Can't specify a keyword twice! */
18309       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18310         .kw_or_val_present = TRUE;
18311       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18312         .kw_present = TRUE;
18313       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
18314         .value_present = FALSE;
18315       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_is_label
18316         = ffestb_local_.delete.label;
18317       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].kw
18318         = ffelex_token_use (t);
18319       return (ffelexHandler) ffestb_V0215_;
18320
18321     default:
18322       break;
18323     }
18324
18325 bad:                            /* :::::::::::::::::::: */
18326   ffestb_subr_kill_delete_ ();
18327   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18328   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18329 }
18330
18331 /* ffestb_V0215_ -- "DELETE" OPEN_PAREN [external-file-unit COMMA] NAME
18332
18333    return ffestb_V0215_;  // to lexer
18334
18335    Make sure EQUALS here, send next token to expression handler.  */
18336
18337 static ffelexHandler
18338 ffestb_V0215_ (ffelexToken t)
18339 {
18340   switch (ffelex_token_type (t))
18341     {
18342     case FFELEX_typeEQUALS:
18343       ffesta_confirmed ();
18344       if (ffestb_local_.delete.label)
18345         return (ffelexHandler) ffestb_V0217_;
18346       if (ffestb_local_.delete.left)
18347         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
18348                                             ffestb_local_.delete.context,
18349                                             (ffeexprCallback) ffestb_V0216_);
18350       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18351              ffestb_local_.delete.context, (ffeexprCallback) ffestb_V0216_);
18352
18353     default:
18354       break;
18355     }
18356
18357   ffestb_subr_kill_delete_ ();
18358   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18359   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18360 }
18361
18362 /* ffestb_V0216_ -- "DELETE" OPEN_PAREN ... NAME EQUALS expr
18363
18364    (ffestb_V0216_)  // to expression handler
18365
18366    Handle COMMA or CLOSE_PAREN here.  */
18367
18368 static ffelexHandler
18369 ffestb_V0216_ (ffelexToken ft, ffebld expr, ffelexToken t)
18370 {
18371   switch (ffelex_token_type (t))
18372     {
18373     case FFELEX_typeCOMMA:
18374     case FFELEX_typeCLOSE_PAREN:
18375       if (expr == NULL)
18376         break;
18377       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_present
18378         = TRUE;
18379       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value
18380         = ffelex_token_use (ft);
18381       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].u.expr = expr;
18382       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18383         return (ffelexHandler) ffestb_V0214_;
18384       return (ffelexHandler) ffestb_V0219_;
18385
18386     default:
18387       break;
18388     }
18389
18390   ffestb_subr_kill_delete_ ();
18391   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18392   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18393 }
18394
18395 /* ffestb_V0217_ -- "DELETE" OPEN_PAREN ... NAME EQUALS
18396
18397    return ffestb_V0217_;  // to lexer
18398
18399    Handle NUMBER for label here.  */
18400
18401 static ffelexHandler
18402 ffestb_V0217_ (ffelexToken t)
18403 {
18404   switch (ffelex_token_type (t))
18405     {
18406     case FFELEX_typeNUMBER:
18407       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_present
18408         = TRUE;
18409       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value
18410         = ffelex_token_use (t);
18411       return (ffelexHandler) ffestb_V0218_;
18412
18413     default:
18414       break;
18415     }
18416
18417   ffestb_subr_kill_delete_ ();
18418   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18419   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18420 }
18421
18422 /* ffestb_V0218_ -- "DELETE" OPEN_PAREN ... NAME EQUALS NUMBER
18423
18424    return ffestb_V0218_;  // to lexer
18425
18426    Handle COMMA or CLOSE_PAREN here.  */
18427
18428 static ffelexHandler
18429 ffestb_V0218_ (ffelexToken t)
18430 {
18431   switch (ffelex_token_type (t))
18432     {
18433     case FFELEX_typeCOMMA:
18434       return (ffelexHandler) ffestb_V0214_;
18435
18436     case FFELEX_typeCLOSE_PAREN:
18437       return (ffelexHandler) ffestb_V0219_;
18438
18439     default:
18440       break;
18441     }
18442
18443   ffestb_subr_kill_delete_ ();
18444   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18445   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18446 }
18447
18448 /* ffestb_V0219_ -- "DELETE" OPEN_PAREN ... CLOSE_PAREN
18449
18450    return ffestb_V0219_;  // to lexer
18451
18452    Handle EOS or SEMICOLON here.  */
18453
18454 static ffelexHandler
18455 ffestb_V0219_ (ffelexToken t)
18456 {
18457   switch (ffelex_token_type (t))
18458     {
18459     case FFELEX_typeEOS:
18460     case FFELEX_typeSEMICOLON:
18461       ffesta_confirmed ();
18462       if (!ffesta_is_inhibited ())
18463         ffestc_V021 ();
18464       ffestb_subr_kill_delete_ ();
18465       return (ffelexHandler) ffesta_zero (t);
18466
18467     default:
18468       break;
18469     }
18470
18471   ffestb_subr_kill_delete_ ();
18472   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
18473   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18474 }
18475
18476 /* ffestb_V026 -- Parse a FIND statement
18477
18478    return ffestb_V026;  // to lexer
18479
18480    Make sure the statement has a valid form for a FIND statement.
18481    If it does, implement the statement.  */
18482
18483 ffelexHandler
18484 ffestb_V026 (ffelexToken t)
18485 {
18486   ffestpFindIx ix;
18487
18488   switch (ffelex_token_type (ffesta_tokens[0]))
18489     {
18490     case FFELEX_typeNAME:
18491       if (ffesta_first_kw != FFESTR_firstFIND)
18492         goto bad_0;             /* :::::::::::::::::::: */
18493       break;
18494
18495     case FFELEX_typeNAMES:
18496       if (ffesta_first_kw != FFESTR_firstFIND)
18497         goto bad_0;             /* :::::::::::::::::::: */
18498       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlFIND)
18499         goto bad_0;             /* :::::::::::::::::::: */
18500       break;
18501
18502     default:
18503       goto bad_0;               /* :::::::::::::::::::: */
18504     }
18505
18506   switch (ffelex_token_type (t))
18507     {
18508     case FFELEX_typeOPEN_PAREN:
18509       break;
18510
18511     case FFELEX_typeEOS:
18512     case FFELEX_typeSEMICOLON:
18513     case FFELEX_typeCOMMA:
18514     case FFELEX_typeCOLONCOLON:
18515       ffesta_confirmed ();      /* Error, but clearly intended. */
18516       goto bad_1;               /* :::::::::::::::::::: */
18517
18518     default:
18519       goto bad_1;               /* :::::::::::::::::::: */
18520     }
18521
18522   for (ix = 0; ix < FFESTP_findix; ++ix)
18523     ffestp_file.find.find_spec[ix].kw_or_val_present = FALSE;
18524
18525   return (ffelexHandler) ffestb_V0261_;
18526
18527 bad_0:                          /* :::::::::::::::::::: */
18528   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", ffesta_tokens[0]);
18529   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18530
18531 bad_1:                          /* :::::::::::::::::::: */
18532   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18533   return (ffelexHandler) ffelex_swallow_tokens (t,
18534                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
18535 }
18536
18537 /* ffestb_V0261_ -- "FIND" OPEN_PAREN
18538
18539    return ffestb_V0261_;  // to lexer
18540
18541    Handle expr construct (not NAME=expr construct) here.  */
18542
18543 static ffelexHandler
18544 ffestb_V0261_ (ffelexToken t)
18545 {
18546   switch (ffelex_token_type (t))
18547     {
18548     case FFELEX_typeNAME:
18549       ffesta_tokens[1] = ffelex_token_use (t);
18550       return (ffelexHandler) ffestb_V0262_;
18551
18552     default:
18553       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18554                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0263_)))
18555         (t);
18556     }
18557 }
18558
18559 /* ffestb_V0262_ -- "FIND" OPEN_PAREN NAME
18560
18561    return ffestb_V0262_;  // to lexer
18562
18563    If EQUALS here, go to states that handle it.  Else, send NAME and this
18564    token thru expression handler.  */
18565
18566 static ffelexHandler
18567 ffestb_V0262_ (ffelexToken t)
18568 {
18569   ffelexHandler next;
18570   ffelexToken nt;
18571
18572   switch (ffelex_token_type (t))
18573     {
18574     case FFELEX_typeEQUALS:
18575       nt = ffesta_tokens[1];
18576       next = (ffelexHandler) ffestb_V0264_ (nt);
18577       ffelex_token_kill (nt);
18578       return (ffelexHandler) (*next) (t);
18579
18580     default:
18581       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18582                   FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0263_)))
18583         (ffesta_tokens[1]);
18584       ffelex_token_kill (ffesta_tokens[1]);
18585       return (ffelexHandler) (*next) (t);
18586     }
18587 }
18588
18589 /* ffestb_V0263_ -- "FIND" OPEN_PAREN expr
18590
18591    (ffestb_V0263_)  // to expression handler
18592
18593    Handle COMMA or FIND_PAREN here.  */
18594
18595 static ffelexHandler
18596 ffestb_V0263_ (ffelexToken ft, ffebld expr, ffelexToken t)
18597 {
18598   switch (ffelex_token_type (t))
18599     {
18600     case FFELEX_typeCOMMA:
18601     case FFELEX_typeCLOSE_PAREN:
18602       if (expr == NULL)
18603         break;
18604       ffestp_file.find.find_spec[FFESTP_findixUNIT].kw_or_val_present
18605         = TRUE;
18606       ffestp_file.find.find_spec[FFESTP_findixUNIT].kw_present = FALSE;
18607       ffestp_file.find.find_spec[FFESTP_findixUNIT].value_present = TRUE;
18608       ffestp_file.find.find_spec[FFESTP_findixUNIT].value_is_label
18609         = FALSE;
18610       ffestp_file.find.find_spec[FFESTP_findixUNIT].value
18611         = ffelex_token_use (ft);
18612       ffestp_file.find.find_spec[FFESTP_findixUNIT].u.expr = expr;
18613       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18614         return (ffelexHandler) ffestb_V0264_;
18615       return (ffelexHandler) ffestb_V0269_;
18616
18617     default:
18618       break;
18619     }
18620
18621   ffestb_subr_kill_find_ ();
18622   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18623   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18624 }
18625
18626 /* ffestb_V0264_ -- "FIND" OPEN_PAREN [external-file-unit COMMA]
18627
18628    return ffestb_V0264_;  // to lexer
18629
18630    Handle expr construct (not NAME=expr construct) here.  */
18631
18632 static ffelexHandler
18633 ffestb_V0264_ (ffelexToken t)
18634 {
18635   ffestrGenio kw;
18636
18637   ffestb_local_.find.label = FALSE;
18638
18639   switch (ffelex_token_type (t))
18640     {
18641     case FFELEX_typeNAME:
18642       kw = ffestr_genio (t);
18643       switch (kw)
18644         {
18645         case FFESTR_genioERR:
18646           ffestb_local_.find.ix = FFESTP_findixERR;
18647           ffestb_local_.find.label = TRUE;
18648           break;
18649
18650         case FFESTR_genioIOSTAT:
18651           ffestb_local_.find.ix = FFESTP_findixIOSTAT;
18652           ffestb_local_.find.left = TRUE;
18653           ffestb_local_.find.context = FFEEXPR_contextFILEINT;
18654           break;
18655
18656         case FFESTR_genioREC:
18657           ffestb_local_.find.ix = FFESTP_findixREC;
18658           ffestb_local_.find.left = FALSE;
18659           ffestb_local_.find.context = FFEEXPR_contextFILENUM;
18660           break;
18661
18662         case FFESTR_genioUNIT:
18663           ffestb_local_.find.ix = FFESTP_findixUNIT;
18664           ffestb_local_.find.left = FALSE;
18665           ffestb_local_.find.context = FFEEXPR_contextFILENUM;
18666           break;
18667
18668         default:
18669           goto bad;             /* :::::::::::::::::::: */
18670         }
18671       if (ffestp_file.find.find_spec[ffestb_local_.find.ix]
18672           .kw_or_val_present)
18673         break;                  /* Can't specify a keyword twice! */
18674       ffestp_file.find.find_spec[ffestb_local_.find.ix]
18675         .kw_or_val_present = TRUE;
18676       ffestp_file.find.find_spec[ffestb_local_.find.ix]
18677         .kw_present = TRUE;
18678       ffestp_file.find.find_spec[ffestb_local_.find.ix]
18679         .value_present = FALSE;
18680       ffestp_file.find.find_spec[ffestb_local_.find.ix].value_is_label
18681         = ffestb_local_.find.label;
18682       ffestp_file.find.find_spec[ffestb_local_.find.ix].kw
18683         = ffelex_token_use (t);
18684       return (ffelexHandler) ffestb_V0265_;
18685
18686     default:
18687       break;
18688     }
18689
18690 bad:                            /* :::::::::::::::::::: */
18691   ffestb_subr_kill_find_ ();
18692   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18693   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18694 }
18695
18696 /* ffestb_V0265_ -- "FIND" OPEN_PAREN [external-file-unit COMMA] NAME
18697
18698    return ffestb_V0265_;  // to lexer
18699
18700    Make sure EQUALS here, send next token to expression handler.  */
18701
18702 static ffelexHandler
18703 ffestb_V0265_ (ffelexToken t)
18704 {
18705   switch (ffelex_token_type (t))
18706     {
18707     case FFELEX_typeEQUALS:
18708       ffesta_confirmed ();
18709       if (ffestb_local_.find.label)
18710         return (ffelexHandler) ffestb_V0267_;
18711       if (ffestb_local_.find.left)
18712         return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
18713                                             ffestb_local_.find.context,
18714                                             (ffeexprCallback) ffestb_V0266_);
18715       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
18716                                           ffestb_local_.find.context,
18717                                           (ffeexprCallback) ffestb_V0266_);
18718
18719     default:
18720       break;
18721     }
18722
18723   ffestb_subr_kill_find_ ();
18724   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18725   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18726 }
18727
18728 /* ffestb_V0266_ -- "FIND" OPEN_PAREN ... NAME EQUALS expr
18729
18730    (ffestb_V0266_)  // to expression handler
18731
18732    Handle COMMA or CLOSE_PAREN here.  */
18733
18734 static ffelexHandler
18735 ffestb_V0266_ (ffelexToken ft, ffebld expr, ffelexToken t)
18736 {
18737   switch (ffelex_token_type (t))
18738     {
18739     case FFELEX_typeCOMMA:
18740     case FFELEX_typeCLOSE_PAREN:
18741       if (expr == NULL)
18742         break;
18743       ffestp_file.find.find_spec[ffestb_local_.find.ix].value_present
18744         = TRUE;
18745       ffestp_file.find.find_spec[ffestb_local_.find.ix].value
18746         = ffelex_token_use (ft);
18747       ffestp_file.find.find_spec[ffestb_local_.find.ix].u.expr = expr;
18748       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
18749         return (ffelexHandler) ffestb_V0264_;
18750       return (ffelexHandler) ffestb_V0269_;
18751
18752     default:
18753       break;
18754     }
18755
18756   ffestb_subr_kill_find_ ();
18757   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18758   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18759 }
18760
18761 /* ffestb_V0267_ -- "FIND" OPEN_PAREN ... NAME EQUALS
18762
18763    return ffestb_V0267_;  // to lexer
18764
18765    Handle NUMBER for label here.  */
18766
18767 static ffelexHandler
18768 ffestb_V0267_ (ffelexToken t)
18769 {
18770   switch (ffelex_token_type (t))
18771     {
18772     case FFELEX_typeNUMBER:
18773       ffestp_file.find.find_spec[ffestb_local_.find.ix].value_present
18774         = TRUE;
18775       ffestp_file.find.find_spec[ffestb_local_.find.ix].value
18776         = ffelex_token_use (t);
18777       return (ffelexHandler) ffestb_V0268_;
18778
18779     default:
18780       break;
18781     }
18782
18783   ffestb_subr_kill_find_ ();
18784   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18785   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18786 }
18787
18788 /* ffestb_V0268_ -- "FIND" OPEN_PAREN ... NAME EQUALS NUMBER
18789
18790    return ffestb_V0268_;  // to lexer
18791
18792    Handle COMMA or CLOSE_PAREN here.  */
18793
18794 static ffelexHandler
18795 ffestb_V0268_ (ffelexToken t)
18796 {
18797   switch (ffelex_token_type (t))
18798     {
18799     case FFELEX_typeCOMMA:
18800       return (ffelexHandler) ffestb_V0264_;
18801
18802     case FFELEX_typeCLOSE_PAREN:
18803       return (ffelexHandler) ffestb_V0269_;
18804
18805     default:
18806       break;
18807     }
18808
18809   ffestb_subr_kill_find_ ();
18810   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18811   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18812 }
18813
18814 /* ffestb_V0269_ -- "FIND" OPEN_PAREN ... CLOSE_PAREN
18815
18816    return ffestb_V0269_;  // to lexer
18817
18818    Handle EOS or SEMICOLON here.  */
18819
18820 static ffelexHandler
18821 ffestb_V0269_ (ffelexToken t)
18822 {
18823   switch (ffelex_token_type (t))
18824     {
18825     case FFELEX_typeEOS:
18826     case FFELEX_typeSEMICOLON:
18827       ffesta_confirmed ();
18828       if (!ffesta_is_inhibited ())
18829         ffestc_V026 ();
18830       ffestb_subr_kill_find_ ();
18831       return (ffelexHandler) ffesta_zero (t);
18832
18833     default:
18834       break;
18835     }
18836
18837   ffestb_subr_kill_find_ ();
18838   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
18839   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
18840 }
18841
18842 #endif
18843 /* ffestb_dimlist -- Parse the ALLOCATABLE/POINTER/TARGET statement
18844
18845    return ffestb_dimlist;  // to lexer
18846
18847    Make sure the statement has a valid form for the ALLOCATABLE/POINTER/
18848    TARGET statement.  If it does, implement the statement.  */
18849
18850 #if FFESTR_F90
18851 ffelexHandler
18852 ffestb_dimlist (ffelexToken t)
18853 {
18854   ffeTokenLength i;
18855   const char *p;
18856   ffelexToken nt;
18857   ffelexHandler next;
18858
18859   switch (ffelex_token_type (ffesta_tokens[0]))
18860     {
18861     case FFELEX_typeNAME:
18862       switch (ffelex_token_type (t))
18863         {
18864         case FFELEX_typeCOMMA:
18865         case FFELEX_typeEOS:
18866         case FFELEX_typeSEMICOLON:
18867           ffesta_confirmed ();  /* Error, but clearly intended. */
18868           goto bad_1;           /* :::::::::::::::::::: */
18869
18870         default:
18871           goto bad_1;           /* :::::::::::::::::::: */
18872
18873         case FFELEX_typeCOLONCOLON:
18874           ffesta_confirmed ();
18875           if (!ffesta_is_inhibited ())
18876             {
18877               switch (ffesta_first_kw)
18878                 {
18879                 case FFESTR_firstALLOCATABLE:
18880                   ffestc_R525_start ();
18881                   break;
18882
18883                 case FFESTR_firstPOINTER:
18884                   ffestc_R526_start ();
18885                   break;
18886
18887                 case FFESTR_firstTARGET:
18888                   ffestc_R527_start ();
18889                   break;
18890
18891                 default:
18892                   assert (FALSE);
18893                 }
18894             }
18895           ffestb_local_.dimlist.started = TRUE;
18896           return (ffelexHandler) ffestb_dimlist1_;
18897
18898         case FFELEX_typeNAME:
18899           ffesta_confirmed ();
18900           if (!ffesta_is_inhibited ())
18901             {
18902               switch (ffesta_first_kw)
18903                 {
18904                 case FFESTR_firstALLOCATABLE:
18905                   ffestc_R525_start ();
18906                   break;
18907
18908                 case FFESTR_firstPOINTER:
18909                   ffestc_R526_start ();
18910                   break;
18911
18912                 case FFESTR_firstTARGET:
18913                   ffestc_R527_start ();
18914                   break;
18915
18916                 default:
18917                   assert (FALSE);
18918                 }
18919             }
18920           ffestb_local_.dimlist.started = TRUE;
18921           return (ffelexHandler) ffestb_dimlist1_ (t);
18922         }
18923
18924     case FFELEX_typeNAMES:
18925       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.dimlist.len);
18926       switch (ffelex_token_type (t))
18927         {
18928         default:
18929           goto bad_1;           /* :::::::::::::::::::: */
18930
18931         case FFELEX_typeEOS:
18932         case FFELEX_typeSEMICOLON:
18933         case FFELEX_typeCOMMA:
18934           ffesta_confirmed ();
18935           if (!ffesrc_is_name_init (*p))
18936             goto bad_i;         /* :::::::::::::::::::: */
18937           nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
18938           if (!ffesta_is_inhibited ())
18939             {
18940               switch (ffesta_first_kw)
18941                 {
18942                 case FFESTR_firstALLOCATABLE:
18943                   ffestc_R525_start ();
18944                   break;
18945
18946                 case FFESTR_firstPOINTER:
18947                   ffestc_R526_start ();
18948                   break;
18949
18950                 case FFESTR_firstTARGET:
18951                   ffestc_R527_start ();
18952                   break;
18953
18954                 default:
18955                   assert (FALSE);
18956                 }
18957             }
18958           ffestb_local_.dimlist.started = TRUE;
18959           next = (ffelexHandler) ffestb_dimlist1_ (nt);
18960           ffelex_token_kill (nt);
18961           return (ffelexHandler) (*next) (t);
18962
18963         case FFELEX_typeCOLONCOLON:
18964           ffesta_confirmed ();
18965           if (*p != '\0')
18966             goto bad_i;         /* :::::::::::::::::::: */
18967           if (!ffesta_is_inhibited ())
18968             {
18969               switch (ffesta_first_kw)
18970                 {
18971                 case FFESTR_firstALLOCATABLE:
18972                   ffestc_R525_start ();
18973                   break;
18974
18975                 case FFESTR_firstPOINTER:
18976                   ffestc_R526_start ();
18977                   break;
18978
18979                 case FFESTR_firstTARGET:
18980                   ffestc_R527_start ();
18981                   break;
18982
18983                 default:
18984                   assert (FALSE);
18985                 }
18986             }
18987           ffestb_local_.dimlist.started = TRUE;
18988           return (ffelexHandler) ffestb_dimlist1_;
18989
18990         case FFELEX_typeOPEN_PAREN:
18991           if (!ffesrc_is_name_init (*p))
18992             goto bad_i;         /* :::::::::::::::::::: */
18993           nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
18994           ffestb_local_.dimlist.started = FALSE;
18995           next = (ffelexHandler) ffestb_dimlist1_ (nt);
18996           ffelex_token_kill (nt);
18997           return (ffelexHandler) (*next) (t);
18998         }
18999
19000     default:
19001       goto bad_0;               /* :::::::::::::::::::: */
19002     }
19003
19004 bad_0:                          /* :::::::::::::::::::: */
19005   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, ffesta_tokens[0]);
19006   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19007
19008 bad_1:                          /* :::::::::::::::::::: */
19009   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19010   return (ffelexHandler) ffelex_swallow_tokens (t,
19011                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
19012
19013 bad_i:                          /* :::::::::::::::::::: */
19014   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, ffesta_tokens[0], i, t);
19015   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19016 }
19017
19018 /* ffestb_dimlist1_ -- "ALLOCATABLE/POINTER/TARGET" [COLONCOLON]
19019
19020    return ffestb_dimlist1_;  // to lexer
19021
19022    Handle NAME.  */
19023
19024 static ffelexHandler
19025 ffestb_dimlist1_ (ffelexToken t)
19026 {
19027   switch (ffelex_token_type (t))
19028     {
19029     case FFELEX_typeNAME:
19030       ffesta_tokens[1] = ffelex_token_use (t);
19031       return (ffelexHandler) ffestb_dimlist2_;
19032
19033     default:
19034       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19035       break;
19036     }
19037
19038   if (!ffesta_is_inhibited ())
19039     {
19040       switch (ffesta_first_kw)
19041         {
19042         case FFESTR_firstALLOCATABLE:
19043           ffestc_R525_finish ();
19044           break;
19045
19046         case FFESTR_firstPOINTER:
19047           ffestc_R526_finish ();
19048           break;
19049
19050         case FFESTR_firstTARGET:
19051           ffestc_R527_finish ();
19052           break;
19053
19054         default:
19055           assert (FALSE);
19056         }
19057     }
19058   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19059 }
19060
19061 /* ffestb_dimlist2_ -- "ALLOCATABLE/POINTER/TARGET" ... NAME
19062
19063    return ffestb_dimlist2_;  // to lexer
19064
19065    Handle OPEN_PAREN.  */
19066
19067 static ffelexHandler
19068 ffestb_dimlist2_ (ffelexToken t)
19069 {
19070   switch (ffelex_token_type (t))
19071     {
19072     case FFELEX_typeOPEN_PAREN:
19073       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
19074       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_dimlist3_;
19075       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
19076       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLIST;
19077 #ifdef FFECOM_dimensionsMAX
19078       ffestb_subrargs_.dim_list.ndims = 0;
19079 #endif
19080       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
19081             FFEEXPR_contextDIMLIST, (ffeexprCallback) ffestb_subr_dimlist_);
19082
19083     case FFELEX_typeCOMMA:
19084       ffesta_confirmed ();
19085       if (!ffesta_is_inhibited ())
19086         {
19087           if (!ffestb_local_.dimlist.started)
19088             {
19089               switch (ffesta_first_kw)
19090                 {
19091                 case FFESTR_firstALLOCATABLE:
19092                   ffestc_R525_start ();
19093                   break;
19094
19095                 case FFESTR_firstPOINTER:
19096                   ffestc_R526_start ();
19097                   break;
19098
19099                 case FFESTR_firstTARGET:
19100                   ffestc_R527_start ();
19101                   break;
19102
19103                 default:
19104                   assert (FALSE);
19105                 }
19106               ffestb_local_.dimlist.started = TRUE;
19107             }
19108           switch (ffesta_first_kw)
19109             {
19110             case FFESTR_firstALLOCATABLE:
19111               ffestc_R525_item (ffesta_tokens[1], NULL);
19112               break;
19113
19114             case FFESTR_firstPOINTER:
19115               ffestc_R526_item (ffesta_tokens[1], NULL);
19116               break;
19117
19118             case FFESTR_firstTARGET:
19119               ffestc_R527_item (ffesta_tokens[1], NULL);
19120               break;
19121
19122             default:
19123               assert (FALSE);
19124             }
19125         }
19126       ffelex_token_kill (ffesta_tokens[1]);
19127       return (ffelexHandler) ffestb_dimlist4_;
19128
19129     case FFELEX_typeEOS:
19130     case FFELEX_typeSEMICOLON:
19131       ffesta_confirmed ();
19132       if (!ffesta_is_inhibited ())
19133         {
19134           if (!ffestb_local_.dimlist.started)
19135             {
19136               switch (ffesta_first_kw)
19137                 {
19138                 case FFESTR_firstALLOCATABLE:
19139                   ffestc_R525_start ();
19140                   break;
19141
19142                 case FFESTR_firstPOINTER:
19143                   ffestc_R526_start ();
19144                   break;
19145
19146                 case FFESTR_firstTARGET:
19147                   ffestc_R527_start ();
19148                   break;
19149
19150                 default:
19151                   assert (FALSE);
19152                 }
19153             }
19154           switch (ffesta_first_kw)
19155             {
19156             case FFESTR_firstALLOCATABLE:
19157               ffestc_R525_item (ffesta_tokens[1], NULL);
19158               ffestc_R525_finish ();
19159               break;
19160
19161             case FFESTR_firstPOINTER:
19162               ffestc_R526_item (ffesta_tokens[1], NULL);
19163               ffestc_R526_finish ();
19164               break;
19165
19166             case FFESTR_firstTARGET:
19167               ffestc_R527_item (ffesta_tokens[1], NULL);
19168               ffestc_R527_finish ();
19169               break;
19170
19171             default:
19172               assert (FALSE);
19173             }
19174         }
19175       ffelex_token_kill (ffesta_tokens[1]);
19176       return (ffelexHandler) ffesta_zero (t);
19177
19178     default:
19179       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19180       break;
19181     }
19182
19183   if (!ffesta_is_inhibited ())
19184     {
19185       switch (ffesta_first_kw)
19186         {
19187         case FFESTR_firstALLOCATABLE:
19188           ffestc_R525_finish ();
19189           break;
19190
19191         case FFESTR_firstPOINTER:
19192           ffestc_R526_finish ();
19193           break;
19194
19195         case FFESTR_firstTARGET:
19196           ffestc_R527_finish ();
19197           break;
19198
19199         default:
19200           assert (FALSE);
19201         }
19202     }
19203   ffelex_token_kill (ffesta_tokens[1]);
19204   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19205 }
19206
19207 /* ffestb_dimlist3_ -- "ALLOCATABLE/POINTER/TARGET" ... NAME OPEN_PAREN
19208                        dimlist CLOSE_PAREN
19209
19210    return ffestb_dimlist3_;  // to lexer
19211
19212    Handle COMMA or EOS/SEMICOLON.  */
19213
19214 static ffelexHandler
19215 ffestb_dimlist3_ (ffelexToken t)
19216 {
19217   if (!ffestb_subrargs_.dim_list.ok)
19218     goto bad;                   /* :::::::::::::::::::: */
19219
19220   switch (ffelex_token_type (t))
19221     {
19222     case FFELEX_typeCOMMA:
19223       ffesta_confirmed ();
19224       if (!ffesta_is_inhibited ())
19225         {
19226           if (!ffestb_local_.dimlist.started)
19227             {
19228               switch (ffesta_first_kw)
19229                 {
19230                 case FFESTR_firstALLOCATABLE:
19231                   ffestc_R525_start ();
19232                   break;
19233
19234                 case FFESTR_firstPOINTER:
19235                   ffestc_R526_start ();
19236                   break;
19237
19238                 case FFESTR_firstTARGET:
19239                   ffestc_R527_start ();
19240                   break;
19241
19242                 default:
19243                   assert (FALSE);
19244                 }
19245               ffestb_local_.dimlist.started = TRUE;
19246             }
19247           switch (ffesta_first_kw)
19248             {
19249             case FFESTR_firstALLOCATABLE:
19250               ffestc_R525_item (ffesta_tokens[1],
19251                                 ffestb_subrargs_.dim_list.dims);
19252               break;
19253
19254             case FFESTR_firstPOINTER:
19255               ffestc_R526_item (ffesta_tokens[1],
19256                                 ffestb_subrargs_.dim_list.dims);
19257               break;
19258
19259             case FFESTR_firstTARGET:
19260               ffestc_R527_item (ffesta_tokens[1],
19261                                 ffestb_subrargs_.dim_list.dims);
19262               break;
19263
19264             default:
19265               assert (FALSE);
19266             }
19267         }
19268       ffelex_token_kill (ffesta_tokens[1]);
19269       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19270       return (ffelexHandler) ffestb_dimlist4_;
19271
19272     case FFELEX_typeEOS:
19273     case FFELEX_typeSEMICOLON:
19274       ffesta_confirmed ();
19275       if (!ffesta_is_inhibited ())
19276         {
19277           if (!ffestb_local_.dimlist.started)
19278             {
19279               switch (ffesta_first_kw)
19280                 {
19281                 case FFESTR_firstALLOCATABLE:
19282                   ffestc_R525_start ();
19283                   break;
19284
19285                 case FFESTR_firstPOINTER:
19286                   ffestc_R526_start ();
19287                   break;
19288
19289                 case FFESTR_firstTARGET:
19290                   ffestc_R527_start ();
19291                   break;
19292
19293                 default:
19294                   assert (FALSE);
19295                 }
19296             }
19297           switch (ffesta_first_kw)
19298             {
19299             case FFESTR_firstALLOCATABLE:
19300               ffestc_R525_item (ffesta_tokens[1],
19301                                 ffestb_subrargs_.dim_list.dims);
19302               ffestc_R525_finish ();
19303               break;
19304
19305             case FFESTR_firstPOINTER:
19306               ffestc_R526_item (ffesta_tokens[1],
19307                                 ffestb_subrargs_.dim_list.dims);
19308               ffestc_R526_finish ();
19309               break;
19310
19311             case FFESTR_firstTARGET:
19312               ffestc_R527_item (ffesta_tokens[1],
19313                                 ffestb_subrargs_.dim_list.dims);
19314               ffestc_R527_finish ();
19315               break;
19316
19317             default:
19318               assert (FALSE);
19319             }
19320         }
19321       ffelex_token_kill (ffesta_tokens[1]);
19322       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19323       return (ffelexHandler) ffesta_zero (t);
19324
19325     default:
19326       break;
19327     }
19328
19329 bad:                            /* :::::::::::::::::::: */
19330   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19331   if (ffestb_local_.dimlist.started && !ffesta_is_inhibited ())
19332     {
19333       switch (ffesta_first_kw)
19334         {
19335         case FFESTR_firstALLOCATABLE:
19336           ffestc_R525_finish ();
19337           break;
19338
19339         case FFESTR_firstPOINTER:
19340           ffestc_R526_finish ();
19341           break;
19342
19343         case FFESTR_firstTARGET:
19344           ffestc_R527_finish ();
19345           break;
19346
19347         default:
19348           assert (FALSE);
19349         }
19350     }
19351   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19352   ffelex_token_kill (ffesta_tokens[1]);
19353   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19354 }
19355
19356 /* ffestb_dimlist4_ -- "ALLOCATABLE/POINTER/TARGET" ... COMMA
19357
19358    return ffestb_dimlist4_;  // to lexer
19359
19360    Make sure we don't have EOS or SEMICOLON.  */
19361
19362 static ffelexHandler
19363 ffestb_dimlist4_ (ffelexToken t)
19364 {
19365   switch (ffelex_token_type (t))
19366     {
19367     case FFELEX_typeEOS:
19368     case FFELEX_typeSEMICOLON:
19369       if (!ffesta_is_inhibited ())
19370         {
19371           switch (ffesta_first_kw)
19372             {
19373             case FFESTR_firstALLOCATABLE:
19374               ffestc_R525_finish ();
19375               break;
19376
19377             case FFESTR_firstPOINTER:
19378               ffestc_R526_finish ();
19379               break;
19380
19381             case FFESTR_firstTARGET:
19382               ffestc_R527_finish ();
19383               break;
19384
19385             default:
19386               assert (FALSE);
19387             }
19388         }
19389       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
19390       return (ffelexHandler) ffesta_zero (t);
19391
19392     default:
19393       return (ffelexHandler) ffestb_dimlist1_ (t);
19394     }
19395 }
19396
19397 #endif
19398 /* ffestb_dummy -- Parse an ENTRY/FUNCTION/SUBROUTINE statement
19399
19400    return ffestb_dummy;  // to lexer
19401
19402    Make sure the statement has a valid form for an ENTRY/FUNCTION/SUBROUTINE
19403    statement.  If it does, implement the statement.  */
19404
19405 ffelexHandler
19406 ffestb_dummy (ffelexToken t)
19407 {
19408   ffeTokenLength i;
19409   unsigned const char *p;
19410
19411   switch (ffelex_token_type (ffesta_tokens[0]))
19412     {
19413     case FFELEX_typeNAME:
19414       switch (ffelex_token_type (t))
19415         {
19416         case FFELEX_typeEOS:
19417         case FFELEX_typeSEMICOLON:
19418         case FFELEX_typeCOMMA:
19419         case FFELEX_typeCOLONCOLON:
19420           ffesta_confirmed ();  /* Error, but clearly intended. */
19421           goto bad_1;           /* :::::::::::::::::::: */
19422
19423         default:
19424           goto bad_1;           /* :::::::::::::::::::: */
19425
19426         case FFELEX_typeNAME:
19427           break;
19428         }
19429
19430       ffesta_confirmed ();
19431       ffesta_tokens[1] = ffelex_token_use (t);
19432       ffestb_local_.decl.recursive = NULL;
19433       ffestb_local_.dummy.badname = ffestb_args.dummy.badname;
19434       ffestb_local_.dummy.is_subr = ffestb_args.dummy.is_subr;
19435       ffestb_local_.dummy.first_kw = ffesta_first_kw;
19436       return (ffelexHandler) ffestb_dummy1_;
19437
19438     case FFELEX_typeNAMES:
19439       switch (ffelex_token_type (t))
19440         {
19441         case FFELEX_typeCOMMA:
19442         case FFELEX_typeCOLONCOLON:
19443           ffesta_confirmed ();  /* Error, but clearly intended. */
19444           goto bad_1;           /* :::::::::::::::::::: */
19445
19446         default:
19447           goto bad_1;           /* :::::::::::::::::::: */
19448
19449         case FFELEX_typeEOS:
19450         case FFELEX_typeSEMICOLON:
19451           ffesta_confirmed ();
19452           break;
19453
19454         case FFELEX_typeOPEN_PAREN:
19455           break;
19456         }
19457       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.dummy.len);
19458       if (!ffesrc_is_name_init (*p))
19459         goto bad_i;             /* :::::::::::::::::::: */
19460       ffesta_tokens[1]
19461         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
19462       ffestb_local_.decl.recursive = NULL;
19463       ffestb_local_.dummy.badname = ffestb_args.dummy.badname;
19464       ffestb_local_.dummy.is_subr = ffestb_args.dummy.is_subr;
19465       ffestb_local_.dummy.first_kw = ffesta_first_kw;
19466       return (ffelexHandler) ffestb_dummy1_ (t);
19467
19468     default:
19469       goto bad_0;               /* :::::::::::::::::::: */
19470     }
19471
19472 bad_0:                          /* :::::::::::::::::::: */
19473   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, ffesta_tokens[0]);
19474   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19475
19476 bad_1:                          /* :::::::::::::::::::: */
19477   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, t);
19478   return (ffelexHandler) ffelex_swallow_tokens (t,
19479                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
19480
19481 bad_i:                          /* :::::::::::::::::::: */
19482   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, ffesta_tokens[0], i, t);
19483   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19484 }
19485
19486 /* ffestb_dummy1_ -- "ENTRY/FUNCTION/SUBROUTINE" NAME
19487
19488    return ffestb_dummy1_;  // to lexer
19489
19490    Make sure the next token is an EOS, SEMICOLON, or OPEN_PAREN.  In the
19491    former case, just implement a null arg list, else get the arg list and
19492    then implement.  */
19493
19494 static ffelexHandler
19495 ffestb_dummy1_ (ffelexToken t)
19496 {
19497   switch (ffelex_token_type (t))
19498     {
19499     case FFELEX_typeEOS:
19500     case FFELEX_typeSEMICOLON:
19501       if (ffestb_local_.dummy.first_kw == FFESTR_firstFUNCTION)
19502         {
19503           ffesta_confirmed ();  /* Later, not if typename w/o RECURSIVE. */
19504           break;                /* Produce an error message, need that open
19505                                    paren. */
19506         }
19507       ffesta_confirmed ();
19508       if (!ffesta_is_inhibited ())
19509         {                       /* Pretend as though we got a truly NULL
19510                                    list. */
19511           ffestb_subrargs_.name_list.args = NULL;
19512           ffestb_subrargs_.name_list.ok = TRUE;
19513           ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
19514           return (ffelexHandler) ffestb_dummy2_ (t);
19515         }
19516       if (ffestb_local_.decl.recursive != NULL)
19517         ffelex_token_kill (ffestb_local_.decl.recursive);
19518       ffelex_token_kill (ffesta_tokens[1]);
19519       return (ffelexHandler) ffesta_zero (t);
19520
19521     case FFELEX_typeOPEN_PAREN:
19522       ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
19523       ffestb_subrargs_.name_list.handler = (ffelexHandler) ffestb_dummy2_;
19524       ffestb_subrargs_.name_list.is_subr = ffestb_local_.dummy.is_subr;
19525       ffestb_subrargs_.name_list.names = FALSE;
19526       return (ffelexHandler) ffestb_subr_name_list_;
19527
19528     default:
19529       break;
19530     }
19531
19532   if (ffestb_local_.decl.recursive != NULL)
19533     ffelex_token_kill (ffestb_local_.decl.recursive);
19534   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_local_.dummy.badname, t);
19535   ffelex_token_kill (ffesta_tokens[1]);
19536   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19537 }
19538
19539 /* ffestb_dummy2_ -- <dummy-keyword> NAME OPEN_PAREN arg-list CLOSE_PAREN
19540
19541    return ffestb_dummy2_;  // to lexer
19542
19543    Make sure the statement has a valid form for a dummy-def statement.  If it
19544    does, implement the statement.  */
19545
19546 static ffelexHandler
19547 ffestb_dummy2_ (ffelexToken t)
19548 {
19549   if (!ffestb_subrargs_.name_list.ok)
19550     goto bad;                   /* :::::::::::::::::::: */
19551
19552   switch (ffelex_token_type (t))
19553     {
19554     case FFELEX_typeEOS:
19555     case FFELEX_typeSEMICOLON:
19556       ffesta_confirmed ();
19557       if (!ffesta_is_inhibited ())
19558         {
19559           switch (ffestb_local_.dummy.first_kw)
19560             {
19561             case FFESTR_firstFUNCTION:
19562               ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
19563                     ffestb_subrargs_.name_list.close_paren, FFESTP_typeNone,
19564                 NULL, NULL, NULL, NULL, ffestb_local_.decl.recursive, NULL);
19565               break;
19566
19567             case FFESTR_firstSUBROUTINE:
19568               ffestc_R1223 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
19569                             ffestb_subrargs_.name_list.close_paren,
19570                             ffestb_local_.decl.recursive);
19571               break;
19572
19573             case FFESTR_firstENTRY:
19574               ffestc_R1226 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
19575                             ffestb_subrargs_.name_list.close_paren);
19576               break;
19577
19578             default:
19579               assert (FALSE);
19580             }
19581         }
19582       ffelex_token_kill (ffesta_tokens[1]);
19583       if (ffestb_local_.decl.recursive != NULL)
19584         ffelex_token_kill (ffestb_local_.decl.recursive);
19585       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
19586       if (ffestb_subrargs_.name_list.args != NULL)
19587         ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
19588       return (ffelexHandler) ffesta_zero (t);
19589
19590     case FFELEX_typeNAME:
19591       ffesta_confirmed ();
19592       if ((ffestb_local_.dummy.first_kw != FFESTR_firstFUNCTION)
19593           || (ffestr_other (t) != FFESTR_otherRESULT))
19594         break;
19595       ffestb_local_.decl.type = FFESTP_typeNone;
19596       ffestb_local_.decl.kind = NULL;
19597       ffestb_local_.decl.kindt = NULL;
19598       ffestb_local_.decl.len = NULL;
19599       ffestb_local_.decl.lent = NULL;
19600       return (ffelexHandler) ffestb_decl_funcname_6_;
19601
19602     default:
19603       break;
19604     }
19605
19606 bad:                            /* :::::::::::::::::::: */
19607   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_local_.dummy.badname, t);
19608   ffelex_token_kill (ffesta_tokens[1]);
19609   if (ffestb_local_.decl.recursive != NULL)
19610     ffelex_token_kill (ffestb_local_.decl.recursive);
19611   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
19612   if (ffestb_subrargs_.name_list.args != NULL)
19613     ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
19614   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19615 }
19616
19617 /* ffestb_R524 -- Parse the DIMENSION statement
19618
19619    return ffestb_R524;  // to lexer
19620
19621    Make sure the statement has a valid form for the DIMENSION statement.  If
19622    it does, implement the statement.  */
19623
19624 ffelexHandler
19625 ffestb_R524 (ffelexToken t)
19626 {
19627   ffeTokenLength i;
19628   unsigned const char *p;
19629   ffelexToken nt;
19630   ffelexHandler next;
19631
19632   switch (ffelex_token_type (ffesta_tokens[0]))
19633     {
19634     case FFELEX_typeNAME:
19635       switch (ffelex_token_type (t))
19636         {
19637         case FFELEX_typeCOMMA:
19638         case FFELEX_typeCOLONCOLON:
19639         case FFELEX_typeEOS:
19640         case FFELEX_typeSEMICOLON:
19641           ffesta_confirmed ();  /* Error, but clearly intended. */
19642           goto bad_1;           /* :::::::::::::::::::: */
19643
19644         default:
19645           goto bad_1;           /* :::::::::::::::::::: */
19646
19647         case FFELEX_typeNAME:
19648           ffesta_confirmed ();
19649           if (!ffesta_is_inhibited ())
19650             ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
19651           ffestb_local_.dimension.started = TRUE;
19652           return (ffelexHandler) ffestb_R5241_ (t);
19653         }
19654
19655     case FFELEX_typeNAMES:
19656       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.R524.len);
19657       switch (ffelex_token_type (t))
19658         {
19659         default:
19660           goto bad_1;           /* :::::::::::::::::::: */
19661
19662         case FFELEX_typeEOS:
19663         case FFELEX_typeSEMICOLON:
19664         case FFELEX_typeCOMMA:
19665         case FFELEX_typeCOLONCOLON:
19666           ffesta_confirmed ();
19667           goto bad_1;           /* :::::::::::::::::::: */
19668
19669         case FFELEX_typeOPEN_PAREN:
19670           break;
19671         }
19672
19673       /* Here, we have at least one char after "DIMENSION" and t is
19674          OPEN_PAREN. */
19675
19676       if (!ffesrc_is_name_init (*p))
19677         goto bad_i;             /* :::::::::::::::::::: */
19678       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
19679       ffestb_local_.dimension.started = FALSE;
19680       next = (ffelexHandler) ffestb_R5241_ (nt);
19681       ffelex_token_kill (nt);
19682       return (ffelexHandler) (*next) (t);
19683
19684     default:
19685       goto bad_0;               /* :::::::::::::::::::: */
19686     }
19687
19688 bad_0:                          /* :::::::::::::::::::: */
19689   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, ffesta_tokens[0]);
19690   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19691
19692 bad_1:                          /* :::::::::::::::::::: */
19693   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19694   return (ffelexHandler) ffelex_swallow_tokens (t,
19695                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
19696
19697 bad_i:                          /* :::::::::::::::::::: */
19698   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, ffesta_tokens[0], i, t);
19699   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19700 }
19701
19702 /* ffestb_R5241_ -- "DIMENSION"
19703
19704    return ffestb_R5241_;  // to lexer
19705
19706    Handle NAME.  */
19707
19708 static ffelexHandler
19709 ffestb_R5241_ (ffelexToken t)
19710 {
19711   switch (ffelex_token_type (t))
19712     {
19713     case FFELEX_typeNAME:
19714       ffesta_tokens[1] = ffelex_token_use (t);
19715       return (ffelexHandler) ffestb_R5242_;
19716
19717     default:
19718       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19719       break;
19720     }
19721
19722   if (!ffesta_is_inhibited ())
19723     ffestc_R524_finish ();
19724   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19725 }
19726
19727 /* ffestb_R5242_ -- "DIMENSION" ... NAME
19728
19729    return ffestb_R5242_;  // to lexer
19730
19731    Handle OPEN_PAREN.  */
19732
19733 static ffelexHandler
19734 ffestb_R5242_ (ffelexToken t)
19735 {
19736   switch (ffelex_token_type (t))
19737     {
19738     case FFELEX_typeOPEN_PAREN:
19739       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
19740       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_R5243_;
19741       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
19742       ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
19743         ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
19744 #ifdef FFECOM_dimensionsMAX
19745       ffestb_subrargs_.dim_list.ndims = 0;
19746 #endif
19747       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
19748                                           ffestb_subrargs_.dim_list.ctx,
19749                                     (ffeexprCallback) ffestb_subr_dimlist_);
19750
19751     default:
19752       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19753       break;
19754     }
19755
19756   if (!ffesta_is_inhibited ())
19757     ffestc_R524_finish ();
19758   ffelex_token_kill (ffesta_tokens[1]);
19759   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19760 }
19761
19762 /* ffestb_R5243_ -- "DIMENSION" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
19763
19764    return ffestb_R5243_;  // to lexer
19765
19766    Handle COMMA or EOS/SEMICOLON.  */
19767
19768 static ffelexHandler
19769 ffestb_R5243_ (ffelexToken t)
19770 {
19771   if (!ffestb_subrargs_.dim_list.ok)
19772     goto bad;                   /* :::::::::::::::::::: */
19773
19774   switch (ffelex_token_type (t))
19775     {
19776     case FFELEX_typeCOMMA:
19777       ffesta_confirmed ();
19778       if (!ffesta_is_inhibited ())
19779         {
19780           if (!ffestb_local_.dimension.started)
19781             {
19782               ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
19783               ffestb_local_.dimension.started = TRUE;
19784             }
19785           ffestc_R524_item (ffesta_tokens[1],
19786                             ffestb_subrargs_.dim_list.dims);
19787         }
19788       ffelex_token_kill (ffesta_tokens[1]);
19789       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19790       return (ffelexHandler) ffestb_R5244_;
19791
19792     case FFELEX_typeEOS:
19793     case FFELEX_typeSEMICOLON:
19794       ffesta_confirmed ();
19795       if (!ffesta_is_inhibited ())
19796         {
19797           if (!ffestb_local_.dimension.started)
19798             {
19799               ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
19800               ffestb_local_.dimension.started = TRUE;
19801             }
19802           ffestc_R524_item (ffesta_tokens[1],
19803                             ffestb_subrargs_.dim_list.dims);
19804           ffestc_R524_finish ();
19805         }
19806       ffelex_token_kill (ffesta_tokens[1]);
19807       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19808       return (ffelexHandler) ffesta_zero (t);
19809
19810     default:
19811       break;
19812     }
19813
19814 bad:                            /* :::::::::::::::::::: */
19815   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19816   if (ffestb_local_.dimension.started && !ffesta_is_inhibited ())
19817     ffestc_R524_finish ();
19818   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
19819   ffelex_token_kill (ffesta_tokens[1]);
19820   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19821 }
19822
19823 /* ffestb_R5244_ -- "DIMENSION" ... COMMA
19824
19825    return ffestb_R5244_;  // to lexer
19826
19827    Make sure we don't have EOS or SEMICOLON.  */
19828
19829 static ffelexHandler
19830 ffestb_R5244_ (ffelexToken t)
19831 {
19832   switch (ffelex_token_type (t))
19833     {
19834     case FFELEX_typeEOS:
19835     case FFELEX_typeSEMICOLON:
19836       if (!ffesta_is_inhibited ())
19837         ffestc_R524_finish ();
19838       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
19839       return (ffelexHandler) ffesta_zero (t);
19840
19841     default:
19842       return (ffelexHandler) ffestb_R5241_ (t);
19843     }
19844 }
19845
19846 /* ffestb_R547 -- Parse the COMMON statement
19847
19848    return ffestb_R547;  // to lexer
19849
19850    Make sure the statement has a valid form for the COMMON statement.  If it
19851    does, implement the statement.  */
19852
19853 ffelexHandler
19854 ffestb_R547 (ffelexToken t)
19855 {
19856   ffeTokenLength i;
19857   unsigned const char *p;
19858   ffelexToken nt;
19859   ffelexHandler next;
19860
19861   switch (ffelex_token_type (ffesta_tokens[0]))
19862     {
19863     case FFELEX_typeNAME:
19864       if (ffesta_first_kw != FFESTR_firstCOMMON)
19865         goto bad_0;             /* :::::::::::::::::::: */
19866       switch (ffelex_token_type (t))
19867         {
19868         case FFELEX_typeCOMMA:
19869         case FFELEX_typeCOLONCOLON:
19870         case FFELEX_typeEOS:
19871         case FFELEX_typeSEMICOLON:
19872           ffesta_confirmed ();  /* Error, but clearly intended. */
19873           goto bad_1;           /* :::::::::::::::::::: */
19874
19875         default:
19876           goto bad_1;           /* :::::::::::::::::::: */
19877
19878         case FFELEX_typeNAME:
19879         case FFELEX_typeSLASH:
19880         case FFELEX_typeCONCAT:
19881           ffesta_confirmed ();
19882           if (!ffesta_is_inhibited ())
19883             ffestc_R547_start ();
19884           ffestb_local_.common.started = TRUE;
19885           return (ffelexHandler) ffestb_R5471_ (t);
19886         }
19887
19888     case FFELEX_typeNAMES:
19889       if (ffesta_first_kw != FFESTR_firstCOMMON)
19890         goto bad_0;             /* :::::::::::::::::::: */
19891       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCOMMON);
19892       switch (ffelex_token_type (t))
19893         {
19894         default:
19895           goto bad_1;           /* :::::::::::::::::::: */
19896
19897         case FFELEX_typeEOS:
19898         case FFELEX_typeSEMICOLON:
19899         case FFELEX_typeCOMMA:
19900         case FFELEX_typeCOLONCOLON:
19901           ffesta_confirmed ();
19902           break;
19903
19904         case FFELEX_typeSLASH:
19905         case FFELEX_typeCONCAT:
19906           ffesta_confirmed ();
19907           if (*p != '\0')
19908             break;
19909           if (!ffesta_is_inhibited ())
19910             ffestc_R547_start ();
19911           ffestb_local_.common.started = TRUE;
19912           return (ffelexHandler) ffestb_R5471_ (t);
19913
19914         case FFELEX_typeOPEN_PAREN:
19915           break;
19916         }
19917
19918       /* Here, we have at least one char after "COMMON" and t is COMMA,
19919          EOS/SEMICOLON, OPEN_PAREN, SLASH, or CONCAT. */
19920
19921       if (!ffesrc_is_name_init (*p))
19922         goto bad_i;             /* :::::::::::::::::::: */
19923       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
19924       if (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN)
19925         ffestb_local_.common.started = FALSE;
19926       else
19927         {
19928           if (!ffesta_is_inhibited ())
19929             ffestc_R547_start ();
19930           ffestb_local_.common.started = TRUE;
19931         }
19932       next = (ffelexHandler) ffestb_R5471_ (nt);
19933       ffelex_token_kill (nt);
19934       return (ffelexHandler) (*next) (t);
19935
19936     default:
19937       goto bad_0;               /* :::::::::::::::::::: */
19938     }
19939
19940 bad_0:                          /* :::::::::::::::::::: */
19941   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", ffesta_tokens[0]);
19942   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19943
19944 bad_1:                          /* :::::::::::::::::::: */
19945   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
19946   return (ffelexHandler) ffelex_swallow_tokens (t,
19947                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
19948
19949 bad_i:                          /* :::::::::::::::::::: */
19950   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "COMMON", ffesta_tokens[0], i, t);
19951   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19952 }
19953
19954 /* ffestb_R5471_ -- "COMMON"
19955
19956    return ffestb_R5471_;  // to lexer
19957
19958    Handle NAME, SLASH, or CONCAT.  */
19959
19960 static ffelexHandler
19961 ffestb_R5471_ (ffelexToken t)
19962 {
19963   switch (ffelex_token_type (t))
19964     {
19965     case FFELEX_typeNAME:
19966       return (ffelexHandler) ffestb_R5474_ (t);
19967
19968     case FFELEX_typeSLASH:
19969       return (ffelexHandler) ffestb_R5472_;
19970
19971     case FFELEX_typeCONCAT:
19972       if (!ffesta_is_inhibited ())
19973         ffestc_R547_item_cblock (NULL);
19974       return (ffelexHandler) ffestb_R5474_;
19975
19976     default:
19977       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
19978       break;
19979     }
19980
19981   if (!ffesta_is_inhibited ())
19982     ffestc_R547_finish ();
19983   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
19984 }
19985
19986 /* ffestb_R5472_ -- "COMMON" SLASH
19987
19988    return ffestb_R5472_;  // to lexer
19989
19990    Handle NAME.  */
19991
19992 static ffelexHandler
19993 ffestb_R5472_ (ffelexToken t)
19994 {
19995   switch (ffelex_token_type (t))
19996     {
19997     case FFELEX_typeNAME:
19998       ffesta_tokens[1] = ffelex_token_use (t);
19999       return (ffelexHandler) ffestb_R5473_;
20000
20001     case FFELEX_typeSLASH:
20002       if (!ffesta_is_inhibited ())
20003         ffestc_R547_item_cblock (NULL);
20004       return (ffelexHandler) ffestb_R5474_;
20005
20006     default:
20007       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20008       break;
20009     }
20010
20011   if (!ffesta_is_inhibited ())
20012     ffestc_R547_finish ();
20013   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20014 }
20015
20016 /* ffestb_R5473_ -- "COMMON" SLASH NAME
20017
20018    return ffestb_R5473_;  // to lexer
20019
20020    Handle SLASH.  */
20021
20022 static ffelexHandler
20023 ffestb_R5473_ (ffelexToken t)
20024 {
20025   switch (ffelex_token_type (t))
20026     {
20027     case FFELEX_typeSLASH:
20028       if (!ffesta_is_inhibited ())
20029         ffestc_R547_item_cblock (ffesta_tokens[1]);
20030       ffelex_token_kill (ffesta_tokens[1]);
20031       return (ffelexHandler) ffestb_R5474_;
20032
20033     default:
20034       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20035       break;
20036     }
20037
20038   if (!ffesta_is_inhibited ())
20039     ffestc_R547_finish ();
20040   ffelex_token_kill (ffesta_tokens[1]);
20041   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20042 }
20043
20044 /* ffestb_R5474_ -- "COMMON" [SLASH NAME SLASH] or "COMMON" CONCAT
20045
20046    return ffestb_R5474_;  // to lexer
20047
20048    Handle NAME.  */
20049
20050 static ffelexHandler
20051 ffestb_R5474_ (ffelexToken t)
20052 {
20053   switch (ffelex_token_type (t))
20054     {
20055     case FFELEX_typeNAME:
20056       ffesta_tokens[1] = ffelex_token_use (t);
20057       return (ffelexHandler) ffestb_R5475_;
20058
20059     default:
20060       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20061       break;
20062     }
20063
20064   if (!ffesta_is_inhibited ())
20065     ffestc_R547_finish ();
20066   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20067 }
20068
20069 /* ffestb_R5475_ -- "COMMON" ... NAME
20070
20071    return ffestb_R5475_;  // to lexer
20072
20073    Handle OPEN_PAREN.  */
20074
20075 static ffelexHandler
20076 ffestb_R5475_ (ffelexToken t)
20077 {
20078   switch (ffelex_token_type (t))
20079     {
20080     case FFELEX_typeOPEN_PAREN:
20081       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
20082       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_R5476_;
20083       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
20084       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
20085 #ifdef FFECOM_dimensionsMAX
20086       ffestb_subrargs_.dim_list.ndims = 0;
20087 #endif
20088       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
20089       FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
20090
20091     case FFELEX_typeCOMMA:
20092       if (!ffesta_is_inhibited ())
20093         ffestc_R547_item_object (ffesta_tokens[1], NULL);
20094       ffelex_token_kill (ffesta_tokens[1]);
20095       return (ffelexHandler) ffestb_R5477_;
20096
20097     case FFELEX_typeSLASH:
20098     case FFELEX_typeCONCAT:
20099       if (!ffesta_is_inhibited ())
20100         ffestc_R547_item_object (ffesta_tokens[1], NULL);
20101       ffelex_token_kill (ffesta_tokens[1]);
20102       return (ffelexHandler) ffestb_R5471_ (t);
20103
20104     case FFELEX_typeEOS:
20105     case FFELEX_typeSEMICOLON:
20106       if (!ffesta_is_inhibited ())
20107         {
20108           ffestc_R547_item_object (ffesta_tokens[1], NULL);
20109           ffestc_R547_finish ();
20110         }
20111       ffelex_token_kill (ffesta_tokens[1]);
20112       return (ffelexHandler) ffesta_zero (t);
20113
20114     default:
20115       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20116       break;
20117     }
20118
20119   if (!ffesta_is_inhibited ())
20120     ffestc_R547_finish ();
20121   ffelex_token_kill (ffesta_tokens[1]);
20122   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20123 }
20124
20125 /* ffestb_R5476_ -- "COMMON" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
20126
20127    return ffestb_R5476_;  // to lexer
20128
20129    Handle COMMA, SLASH, CONCAT, EOS/SEMICOLON.  */
20130
20131 static ffelexHandler
20132 ffestb_R5476_ (ffelexToken t)
20133 {
20134   if (!ffestb_subrargs_.dim_list.ok)
20135     goto bad;                   /* :::::::::::::::::::: */
20136
20137   switch (ffelex_token_type (t))
20138     {
20139     case FFELEX_typeCOMMA:
20140       ffesta_confirmed ();
20141       if (!ffesta_is_inhibited ())
20142         {
20143           if (!ffestb_local_.common.started)
20144             {
20145               ffestc_R547_start ();
20146               ffestb_local_.common.started = TRUE;
20147             }
20148           ffestc_R547_item_object (ffesta_tokens[1],
20149                                    ffestb_subrargs_.dim_list.dims);
20150         }
20151       ffelex_token_kill (ffesta_tokens[1]);
20152       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20153       return (ffelexHandler) ffestb_R5477_;
20154
20155     case FFELEX_typeSLASH:
20156     case FFELEX_typeCONCAT:
20157       ffesta_confirmed ();
20158       if (!ffesta_is_inhibited ())
20159         {
20160           if (!ffestb_local_.common.started)
20161             {
20162               ffestc_R547_start ();
20163               ffestb_local_.common.started = TRUE;
20164             }
20165           ffestc_R547_item_object (ffesta_tokens[1],
20166                                    ffestb_subrargs_.dim_list.dims);
20167         }
20168       ffelex_token_kill (ffesta_tokens[1]);
20169       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20170       return (ffelexHandler) ffestb_R5471_ (t);
20171
20172     case FFELEX_typeEOS:
20173     case FFELEX_typeSEMICOLON:
20174       ffesta_confirmed ();
20175       if (!ffesta_is_inhibited ())
20176         {
20177           if (!ffestb_local_.common.started)
20178             ffestc_R547_start ();
20179           ffestc_R547_item_object (ffesta_tokens[1],
20180                                    ffestb_subrargs_.dim_list.dims);
20181           ffestc_R547_finish ();
20182         }
20183       ffelex_token_kill (ffesta_tokens[1]);
20184       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20185       return (ffelexHandler) ffesta_zero (t);
20186
20187     default:
20188       break;
20189     }
20190
20191 bad:                            /* :::::::::::::::::::: */
20192   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20193   if (ffestb_local_.common.started && !ffesta_is_inhibited ())
20194     ffestc_R547_finish ();
20195   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
20196   ffelex_token_kill (ffesta_tokens[1]);
20197   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20198 }
20199
20200 /* ffestb_R5477_ -- "COMMON" ... COMMA
20201
20202    return ffestb_R5477_;  // to lexer
20203
20204    Make sure we don't have EOS or SEMICOLON.  */
20205
20206 static ffelexHandler
20207 ffestb_R5477_ (ffelexToken t)
20208 {
20209   switch (ffelex_token_type (t))
20210     {
20211     case FFELEX_typeEOS:
20212     case FFELEX_typeSEMICOLON:
20213       if (!ffesta_is_inhibited ())
20214         ffestc_R547_finish ();
20215       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
20216       return (ffelexHandler) ffesta_zero (t);
20217
20218     default:
20219       return (ffelexHandler) ffestb_R5471_ (t);
20220     }
20221 }
20222
20223 /* ffestb_R624 -- Parse a NULLIFY statement
20224
20225    return ffestb_R624;  // to lexer
20226
20227    Make sure the statement has a valid form for a NULLIFY
20228    statement.  If it does, implement the statement.
20229
20230    31-May-90  JCB  2.0
20231       Rewrite to produce a list of expressions rather than just names; this
20232       eases semantic checking, putting it in expression handling where that
20233       kind of thing gets done anyway, and makes it easier to support more
20234       flexible extensions to Fortran 90 like NULLIFY(FOO%BAR).  */
20235
20236 #if FFESTR_F90
20237 ffelexHandler
20238 ffestb_R624 (ffelexToken t)
20239 {
20240   switch (ffelex_token_type (ffesta_tokens[0]))
20241     {
20242     case FFELEX_typeNAME:
20243       if (ffesta_first_kw != FFESTR_firstNULLIFY)
20244         goto bad_0;             /* :::::::::::::::::::: */
20245       break;
20246
20247     case FFELEX_typeNAMES:
20248       if (ffesta_first_kw != FFESTR_firstNULLIFY)
20249         goto bad_0;             /* :::::::::::::::::::: */
20250       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlNULLIFY)
20251         goto bad_0;             /* :::::::::::::::::::: */
20252       break;
20253
20254     default:
20255       goto bad_0;               /* :::::::::::::::::::: */
20256     }
20257
20258   switch (ffelex_token_type (t))
20259     {
20260     case FFELEX_typeOPEN_PAREN:
20261       break;
20262
20263     case FFELEX_typeEOS:
20264     case FFELEX_typeSEMICOLON:
20265     case FFELEX_typeCOMMA:
20266     case FFELEX_typeCOLONCOLON:
20267     case FFELEX_typeNAME:
20268       ffesta_confirmed ();      /* Error, but clearly intended. */
20269       goto bad_1;               /* :::::::::::::::::::: */
20270
20271     default:
20272       goto bad_1;               /* :::::::::::::::::::: */
20273     }
20274
20275   ffestb_local_.R624.exprs = ffestt_exprlist_create ();
20276   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
20277                                       FFEEXPR_contextNULLIFY,
20278                                       (ffeexprCallback) ffestb_R6241_);
20279
20280 bad_0:                          /* :::::::::::::::::::: */
20281   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", ffesta_tokens[0]);
20282   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20283
20284 bad_1:                          /* :::::::::::::::::::: */
20285   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
20286   return (ffelexHandler) ffelex_swallow_tokens (t,
20287                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
20288 }
20289
20290 /* ffestb_R6241_ -- "NULLIFY" OPEN_PAREN expr
20291
20292    return ffestb_R6241_;  // to lexer
20293
20294    Make sure the statement has a valid form for a NULLIFY statement.  If it
20295    does, implement the statement.
20296
20297    31-May-90  JCB  2.0
20298       Rewrite to produce a list of expressions rather than just names; this
20299       eases semantic checking, putting it in expression handling where that
20300       kind of thing gets done anyway, and makes it easier to support more
20301       flexible extensions to Fortran 90 like NULLIFY(FOO%BAR).  */
20302
20303 static ffelexHandler
20304 ffestb_R6241_ (ffelexToken ft, ffebld expr, ffelexToken t)
20305 {
20306   switch (ffelex_token_type (t))
20307     {
20308     case FFELEX_typeCLOSE_PAREN:
20309       if (expr == NULL)
20310         break;
20311       ffestt_exprlist_append (ffestb_local_.R624.exprs, expr,
20312                               ffelex_token_use (t));
20313       return (ffelexHandler) ffestb_R6242_;
20314
20315     case FFELEX_typeCOMMA:
20316       if (expr == NULL)
20317         break;
20318       ffestt_exprlist_append (ffestb_local_.R624.exprs, expr,
20319                               ffelex_token_use (t));
20320       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
20321                                           FFEEXPR_contextNULLIFY,
20322                                           (ffeexprCallback) ffestb_R6241_);
20323
20324     default:
20325       break;
20326     }
20327
20328   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
20329   ffestt_exprlist_kill (ffestb_local_.R624.exprs);
20330   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20331 }
20332
20333 /* ffestb_R6242_ -- "NULLIFY" OPEN_PAREN expr-list CLOSE_PAREN
20334
20335    return ffestb_R6242_;  // to lexer
20336
20337    Make sure the statement has a valid form for a NULLIFY statement.  If it
20338    does, implement the statement.  */
20339
20340 static ffelexHandler
20341 ffestb_R6242_ (ffelexToken t)
20342 {
20343   switch (ffelex_token_type (t))
20344     {
20345     case FFELEX_typeEOS:
20346     case FFELEX_typeSEMICOLON:
20347       ffesta_confirmed ();
20348       if (!ffesta_is_inhibited ())
20349         ffestc_R624 (ffestb_local_.R624.exprs);
20350       ffestt_exprlist_kill (ffestb_local_.R624.exprs);
20351       return (ffelexHandler) ffesta_zero (t);
20352
20353     default:
20354       break;
20355     }
20356
20357   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
20358   ffestt_exprlist_kill (ffestb_local_.R624.exprs);
20359   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20360 }
20361
20362 #endif
20363 /* ffestb_R1229 -- Parse a STMTFUNCTION statement
20364
20365    return ffestb_R1229;  // to lexer
20366
20367    Make sure the statement has a valid form for a STMTFUNCTION
20368    statement.  If it does, implement the statement.  */
20369
20370 ffelexHandler
20371 ffestb_R1229 (ffelexToken t)
20372 {
20373   switch (ffelex_token_type (ffesta_tokens[0]))
20374     {
20375     case FFELEX_typeNAME:
20376     case FFELEX_typeNAMES:
20377       break;
20378
20379     default:
20380       goto bad_0;               /* :::::::::::::::::::: */
20381     }
20382
20383   switch (ffelex_token_type (t))
20384     {
20385     case FFELEX_typeOPEN_PAREN:
20386       break;
20387
20388     case FFELEX_typeEOS:
20389     case FFELEX_typeSEMICOLON:
20390     case FFELEX_typeCOMMA:
20391     case FFELEX_typeCOLONCOLON:
20392     case FFELEX_typeNAME:
20393       ffesta_confirmed ();      /* Error, but clearly intended. */
20394       goto bad_1;               /* :::::::::::::::::::: */
20395
20396     default:
20397       goto bad_1;               /* :::::::::::::::::::: */
20398     }
20399
20400   ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
20401   ffestb_subrargs_.name_list.handler = (ffelexHandler) ffestb_R12291_;
20402   ffestb_subrargs_.name_list.is_subr = FALSE;   /* No "*" items in list! */
20403   ffestb_subrargs_.name_list.names = TRUE;      /* In case "IF(FOO)CALL
20404                                                    FOO...". */
20405   return (ffelexHandler) ffestb_subr_name_list_;
20406
20407 bad_0:                          /* :::::::::::::::::::: */
20408 bad_1:                          /* :::::::::::::::::::: */
20409   ffesta_ffebad_2t (FFEBAD_UNREC_STMT, ffesta_tokens[0], t);
20410   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20411 }
20412
20413 /* ffestb_R12291_ -- "STMTFUNCTION" OPEN_PAREN dummy-name-list CLOSE_PAREN
20414
20415    return ffestb_R12291_;  // to lexer
20416
20417    Make sure the statement has a valid form for a STMTFUNCTION statement.  If
20418    it does, implement the statement.  */
20419
20420 static ffelexHandler
20421 ffestb_R12291_ (ffelexToken t)
20422 {
20423   ffelex_set_names (FALSE);
20424
20425   if (!ffestb_subrargs_.name_list.ok)
20426     goto bad;                   /* :::::::::::::::::::: */
20427
20428   switch (ffelex_token_type (t))
20429     {
20430     case FFELEX_typeEQUALS:
20431       ffesta_confirmed ();
20432       if (!ffesta_is_inhibited ())
20433         ffestc_R1229_start (ffesta_tokens[0],
20434                             ffestb_subrargs_.name_list.args,
20435                             ffestb_subrargs_.name_list.close_paren);
20436       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
20437       ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
20438       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
20439                  FFEEXPR_contextSFUNCDEF, (ffeexprCallback) ffestb_R12292_);
20440
20441     default:
20442       break;
20443     }
20444
20445 bad:                            /* :::::::::::::::::::: */
20446   ffesta_ffebad_2t (FFEBAD_UNREC_STMT, ffesta_tokens[0], t);
20447   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
20448   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
20449   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20450 }
20451
20452 /* ffestb_R12292_ -- "STMTFUNCTION" OPEN_PAREN dummy-name-list CLOSE_PAREN
20453                      EQUALS expr
20454
20455    (ffestb_R12292_)  // to expression handler
20456
20457    Make sure the statement has a valid form for a STMTFUNCTION statement.  If
20458    it does, implement the statement.  */
20459
20460 static ffelexHandler
20461 ffestb_R12292_ (ffelexToken ft, ffebld expr, ffelexToken t)
20462 {
20463   if (expr == NULL)
20464     goto bad;                   /* :::::::::::::::::::: */
20465
20466   switch (ffelex_token_type (t))
20467     {
20468     case FFELEX_typeEOS:
20469     case FFELEX_typeSEMICOLON:
20470       if (!ffesta_is_inhibited ())
20471         ffestc_R1229_finish (expr, ft);
20472       return (ffelexHandler) ffesta_zero (t);
20473
20474     default:
20475       break;
20476     }
20477
20478 bad:                            /* :::::::::::::::::::: */
20479   ffestc_R1229_finish (NULL, NULL);
20480   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "statement-function-definition", t);
20481   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20482 }
20483
20484 /* ffestb_decl_chartype -- Parse the CHARACTER statement
20485
20486    return ffestb_decl_chartype;  // to lexer
20487
20488    Make sure the statement has a valid form for the CHARACTER statement.  If
20489    it does, implement the statement.  */
20490
20491 ffelexHandler
20492 ffestb_decl_chartype (ffelexToken t)
20493 {
20494   ffeTokenLength i;
20495   unsigned const char *p;
20496
20497   ffestb_local_.decl.type = FFESTP_typeCHARACTER;
20498   ffestb_local_.decl.recursive = NULL;
20499   ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20500   ffestb_local_.decl.coloncolon = FALSE;        /* No COLONCOLON seen. */
20501
20502   switch (ffelex_token_type (ffesta_tokens[0]))
20503     {
20504     case FFELEX_typeNAME:
20505       if (ffesta_first_kw != FFESTR_firstCHRCTR)
20506         goto bad_0;             /* :::::::::::::::::::: */
20507       switch (ffelex_token_type (t))
20508         {
20509         case FFELEX_typeEOS:
20510         case FFELEX_typeSEMICOLON:
20511           ffesta_confirmed ();  /* Error, but clearly intended. */
20512           goto bad_1;           /* :::::::::::::::::::: */
20513
20514         default:
20515           goto bad_1;           /* :::::::::::::::::::: */
20516
20517         case FFELEX_typeCOMMA:
20518           ffesta_confirmed ();
20519           if (!ffesta_is_inhibited ())
20520             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20521                                NULL, NULL, NULL, NULL);
20522           return (ffelexHandler) ffestb_decl_attrs_;
20523
20524         case FFELEX_typeCOLONCOLON:
20525           ffestb_local_.decl.coloncolon = TRUE;
20526           ffesta_confirmed ();
20527           if (!ffesta_is_inhibited ())
20528             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20529                                NULL, NULL, NULL, NULL);
20530           return (ffelexHandler) ffestb_decl_ents_;
20531
20532         case FFELEX_typeASTERISK:
20533           ffesta_confirmed ();
20534           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_chartype1_;
20535           ffestb_local_.decl.badname = "TYPEDECL";
20536           return (ffelexHandler) ffestb_decl_starlen_;
20537
20538         case FFELEX_typeOPEN_PAREN:
20539           ffestb_local_.decl.kind = NULL;
20540           ffestb_local_.decl.kindt = NULL;
20541           ffestb_local_.decl.len = NULL;
20542           ffestb_local_.decl.lent = NULL;
20543           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20544           ffestb_local_.decl.badname = "_TYPEDECL";
20545           return (ffelexHandler) ffestb_decl_typeparams_;
20546
20547         case FFELEX_typeNAME:
20548           ffesta_confirmed ();
20549           ffestb_local_.decl.kind = NULL;
20550           ffestb_local_.decl.kindt = NULL;
20551           ffestb_local_.decl.len = NULL;
20552           ffestb_local_.decl.lent = NULL;
20553           return (ffelexHandler) ffestb_decl_entsp_ (t);
20554         }
20555
20556     case FFELEX_typeNAMES:
20557       if (ffesta_first_kw != FFESTR_firstCHRCTR)
20558         goto bad_0;             /* :::::::::::::::::::: */
20559       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCHRCTR);
20560       switch (ffelex_token_type (t))
20561         {
20562         default:
20563           goto bad_1;           /* :::::::::::::::::::: */
20564
20565         case FFELEX_typeEOS:
20566         case FFELEX_typeSEMICOLON:
20567           ffesta_confirmed ();
20568           break;
20569
20570         case FFELEX_typeCOMMA:
20571           ffesta_confirmed ();
20572           if (*p != '\0')
20573             break;
20574           if (!ffesta_is_inhibited ())
20575             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20576                                NULL, NULL, NULL, NULL);
20577           return (ffelexHandler) ffestb_decl_attrs_;
20578
20579         case FFELEX_typeCOLONCOLON:
20580           ffestb_local_.decl.coloncolon = TRUE;
20581           ffesta_confirmed ();
20582           if (*p != '\0')
20583             goto bad_i;         /* :::::::::::::::::::: */
20584           if (!ffesta_is_inhibited ())
20585             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20586                                NULL, NULL, NULL, NULL);
20587           return (ffelexHandler) ffestb_decl_ents_;
20588
20589         case FFELEX_typeASTERISK:
20590           ffesta_confirmed ();
20591           if (*p != '\0')
20592             break;
20593           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_chartype1_;
20594           ffestb_local_.decl.badname = "TYPEDECL";
20595           return (ffelexHandler) ffestb_decl_starlen_;
20596
20597         case FFELEX_typeSLASH:
20598           ffesta_confirmed ();
20599           if (*p != '\0')
20600             break;
20601           goto bad_1;           /* :::::::::::::::::::: */
20602
20603         case FFELEX_typeOPEN_PAREN:
20604           if (*p != '\0')
20605             break;
20606           ffestb_local_.decl.kind = NULL;
20607           ffestb_local_.decl.kindt = NULL;
20608           ffestb_local_.decl.len = NULL;
20609           ffestb_local_.decl.lent = NULL;
20610           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20611           ffestb_local_.decl.badname = "TYPEDECL";
20612           return (ffelexHandler) ffestb_decl_typeparams_;
20613         }
20614       if (!ffesrc_is_name_init (*p))
20615         goto bad_i;             /* :::::::::::::::::::: */
20616       ffestb_local_.decl.kind = NULL;
20617       ffestb_local_.decl.kindt = NULL;
20618       ffestb_local_.decl.len = NULL;
20619       ffestb_local_.decl.lent = NULL;
20620       ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
20621       return (ffelexHandler) ffestb_decl_entsp_2_ (t);
20622
20623     default:
20624       goto bad_0;               /* :::::::::::::::::::: */
20625     }
20626
20627 bad_0:                          /* :::::::::::::::::::: */
20628   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20629   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20630
20631 bad_1:                          /* :::::::::::::::::::: */
20632   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20633   return (ffelexHandler) ffelex_swallow_tokens (t,
20634                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
20635
20636 bad_i:                          /* :::::::::::::::::::: */
20637   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
20638   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20639 }
20640
20641 /* ffestb_decl_chartype1_ -- "CHARACTER" ASTERISK char-length
20642
20643    return ffestb_decl_chartype1_;  // to lexer
20644
20645    Handle COMMA, COLONCOLON, or anything else.  */
20646
20647 static ffelexHandler
20648 ffestb_decl_chartype1_ (ffelexToken t)
20649 {
20650   ffelex_set_names (FALSE);
20651
20652   switch (ffelex_token_type (t))
20653     {
20654     case FFELEX_typeCOLONCOLON:
20655       ffestb_local_.decl.coloncolon = TRUE;
20656       /* Fall through. */
20657     case FFELEX_typeCOMMA:
20658       ffesta_confirmed ();
20659       if (!ffesta_is_inhibited ())
20660         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20661                NULL, NULL, ffestb_local_.decl.len, ffestb_local_.decl.lent);
20662       if (ffestb_local_.decl.lent != NULL)
20663         ffelex_token_kill (ffestb_local_.decl.lent);
20664       return (ffelexHandler) ffestb_decl_ents_;
20665
20666     default:
20667       return (ffelexHandler) ffestb_decl_entsp_ (t);
20668     }
20669 }
20670
20671 /* ffestb_decl_dbltype -- Parse the DOUBLEPRECISION/DOUBLECOMPLEX statement
20672
20673    return ffestb_decl_dbltype;  // to lexer
20674
20675    Make sure the statement has a valid form for the DOUBLEPRECISION/
20676    DOUBLECOMPLEX statement.  If it does, implement the statement.  */
20677
20678 ffelexHandler
20679 ffestb_decl_dbltype (ffelexToken t)
20680 {
20681   ffeTokenLength i;
20682   unsigned const char *p;
20683
20684   ffestb_local_.decl.type = ffestb_args.decl.type;
20685   ffestb_local_.decl.recursive = NULL;
20686   ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20687   ffestb_local_.decl.coloncolon = FALSE;        /* No COLONCOLON seen. */
20688
20689   switch (ffelex_token_type (ffesta_tokens[0]))
20690     {
20691     case FFELEX_typeNAME:
20692       switch (ffelex_token_type (t))
20693         {
20694         case FFELEX_typeEOS:
20695         case FFELEX_typeSEMICOLON:
20696           ffesta_confirmed ();  /* Error, but clearly intended. */
20697           goto bad_1;           /* :::::::::::::::::::: */
20698
20699         default:
20700           goto bad_1;           /* :::::::::::::::::::: */
20701
20702         case FFELEX_typeCOMMA:
20703           ffesta_confirmed ();
20704           if (!ffesta_is_inhibited ())
20705             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20706                                NULL, NULL, NULL, NULL);
20707           return (ffelexHandler) ffestb_decl_attrs_;
20708
20709         case FFELEX_typeCOLONCOLON:
20710           ffestb_local_.decl.coloncolon = TRUE;
20711           ffesta_confirmed ();
20712           if (!ffesta_is_inhibited ())
20713             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20714                                NULL, NULL, NULL, NULL);
20715           return (ffelexHandler) ffestb_decl_ents_;
20716
20717         case FFELEX_typeNAME:
20718           ffesta_confirmed ();
20719           ffestb_local_.decl.kind = NULL;
20720           ffestb_local_.decl.kindt = NULL;
20721           ffestb_local_.decl.len = NULL;
20722           ffestb_local_.decl.lent = NULL;
20723           return (ffelexHandler) ffestb_decl_entsp_ (t);
20724         }
20725
20726     case FFELEX_typeNAMES:
20727       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.decl.len);
20728       switch (ffelex_token_type (t))
20729         {
20730         default:
20731           goto bad_1;           /* :::::::::::::::::::: */
20732
20733         case FFELEX_typeEOS:
20734         case FFELEX_typeSEMICOLON:
20735           ffesta_confirmed ();
20736           break;
20737
20738         case FFELEX_typeCOMMA:
20739           ffesta_confirmed ();
20740           if (*p != '\0')
20741             break;
20742           if (!ffesta_is_inhibited ())
20743             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20744                                NULL, NULL, NULL, NULL);
20745           return (ffelexHandler) ffestb_decl_attrs_;
20746
20747         case FFELEX_typeCOLONCOLON:
20748           ffestb_local_.decl.coloncolon = TRUE;
20749           ffesta_confirmed ();
20750           if (*p != '\0')
20751             goto bad_i;         /* :::::::::::::::::::: */
20752           if (!ffesta_is_inhibited ())
20753             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20754                                NULL, NULL, NULL, NULL);
20755           return (ffelexHandler) ffestb_decl_ents_;
20756
20757         case FFELEX_typeSLASH:
20758           ffesta_confirmed ();
20759           if (*p != '\0')
20760             break;
20761           goto bad_1;           /* :::::::::::::::::::: */
20762
20763         case FFELEX_typeOPEN_PAREN:
20764           if (*p != '\0')
20765             break;
20766           goto bad_1;           /* :::::::::::::::::::: */
20767         }
20768       if (!ffesrc_is_name_init (*p))
20769         goto bad_i;             /* :::::::::::::::::::: */
20770       ffestb_local_.decl.kind = NULL;
20771       ffestb_local_.decl.kindt = NULL;
20772       ffestb_local_.decl.len = NULL;
20773       ffestb_local_.decl.lent = NULL;
20774       ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
20775       return (ffelexHandler) ffestb_decl_entsp_2_ (t);
20776
20777     default:
20778       goto bad_0;               /* :::::::::::::::::::: */
20779     }
20780
20781 bad_0:                          /* :::::::::::::::::::: */
20782   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20783   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20784
20785 bad_1:                          /* :::::::::::::::::::: */
20786   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20787   return (ffelexHandler) ffelex_swallow_tokens (t,
20788                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
20789
20790 bad_i:                          /* :::::::::::::::::::: */
20791   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
20792   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20793 }
20794
20795 /* ffestb_decl_double -- Parse the DOUBLE PRECISION/DOUBLE COMPLEX statement
20796
20797    return ffestb_decl_double;  // to lexer
20798
20799    Make sure the statement has a valid form for the DOUBLE PRECISION/
20800    DOUBLE COMPLEX statement.  If it does, implement the statement.  */
20801
20802 ffelexHandler
20803 ffestb_decl_double (ffelexToken t)
20804 {
20805   ffestb_local_.decl.recursive = NULL;
20806   ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20807   ffestb_local_.decl.coloncolon = FALSE;        /* No COLONCOLON seen. */
20808
20809   switch (ffelex_token_type (ffesta_tokens[0]))
20810     {
20811     case FFELEX_typeNAME:
20812       if (ffesta_first_kw != FFESTR_firstDBL)
20813         goto bad_0;             /* :::::::::::::::::::: */
20814       switch (ffelex_token_type (t))
20815         {
20816         case FFELEX_typeEOS:
20817         case FFELEX_typeSEMICOLON:
20818         case FFELEX_typeCOMMA:
20819         case FFELEX_typeCOLONCOLON:
20820           ffesta_confirmed ();  /* Error, but clearly intended. */
20821           goto bad_1;           /* :::::::::::::::::::: */
20822
20823         default:
20824           goto bad_1;           /* :::::::::::::::::::: */
20825
20826         case FFELEX_typeNAME:
20827           ffesta_confirmed ();
20828           switch (ffestr_second (t))
20829             {
20830             case FFESTR_secondCOMPLEX:
20831               ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
20832               break;
20833
20834             case FFESTR_secondPRECISION:
20835               ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
20836               break;
20837
20838             default:
20839               goto bad_1;       /* :::::::::::::::::::: */
20840             }
20841           ffestb_local_.decl.kind = NULL;
20842           ffestb_local_.decl.kindt = NULL;
20843           ffestb_local_.decl.len = NULL;
20844           ffestb_local_.decl.lent = NULL;
20845           return (ffelexHandler) ffestb_decl_attrsp_;
20846         }
20847
20848     default:
20849       goto bad_0;               /* :::::::::::::::::::: */
20850     }
20851
20852 bad_0:                          /* :::::::::::::::::::: */
20853   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20854   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20855
20856 bad_1:                          /* :::::::::::::::::::: */
20857   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20858   return (ffelexHandler) ffelex_swallow_tokens (t,
20859                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
20860 }
20861
20862 /* ffestb_decl_gentype -- Parse the INTEGER/REAL/COMPLEX/LOGICAL statement
20863
20864    return ffestb_decl_gentype;  // to lexer
20865
20866    Make sure the statement has a valid form for the INTEGER/REAL/COMPLEX/
20867    LOGICAL statement.  If it does, implement the statement.  */
20868
20869 ffelexHandler
20870 ffestb_decl_gentype (ffelexToken t)
20871 {
20872   ffeTokenLength i;
20873   unsigned const char *p;
20874
20875   ffestb_local_.decl.type = ffestb_args.decl.type;
20876   ffestb_local_.decl.recursive = NULL;
20877   ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
20878   ffestb_local_.decl.coloncolon = FALSE;        /* No COLONCOLON seen. */
20879
20880   switch (ffelex_token_type (ffesta_tokens[0]))
20881     {
20882     case FFELEX_typeNAME:
20883       switch (ffelex_token_type (t))
20884         {
20885         case FFELEX_typeEOS:
20886         case FFELEX_typeSEMICOLON:
20887           ffesta_confirmed ();  /* Error, but clearly intended. */
20888           goto bad_1;           /* :::::::::::::::::::: */
20889
20890         default:
20891           goto bad_1;           /* :::::::::::::::::::: */
20892
20893         case FFELEX_typeCOMMA:
20894           ffesta_confirmed ();
20895           if (!ffesta_is_inhibited ())
20896             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20897                                NULL, NULL, NULL, NULL);
20898           return (ffelexHandler) ffestb_decl_attrs_;
20899
20900         case FFELEX_typeCOLONCOLON:
20901           ffestb_local_.decl.coloncolon = TRUE;
20902           ffesta_confirmed ();
20903           if (!ffesta_is_inhibited ())
20904             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20905                                NULL, NULL, NULL, NULL);
20906           return (ffelexHandler) ffestb_decl_ents_;
20907
20908         case FFELEX_typeASTERISK:
20909           ffesta_confirmed ();
20910           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20911           ffestb_local_.decl.badname = "TYPEDECL";
20912           return (ffelexHandler) ffestb_decl_starkind_;
20913
20914         case FFELEX_typeOPEN_PAREN:
20915           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20916           ffestb_local_.decl.badname = "TYPEDECL";
20917           return (ffelexHandler) ffestb_decl_kindparam_;
20918
20919         case FFELEX_typeNAME:
20920           ffesta_confirmed ();
20921           ffestb_local_.decl.kind = NULL;
20922           ffestb_local_.decl.kindt = NULL;
20923           ffestb_local_.decl.len = NULL;
20924           ffestb_local_.decl.lent = NULL;
20925           return (ffelexHandler) ffestb_decl_entsp_ (t);
20926         }
20927
20928     case FFELEX_typeNAMES:
20929       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.decl.len);
20930       switch (ffelex_token_type (t))
20931         {
20932         default:
20933           goto bad_1;           /* :::::::::::::::::::: */
20934
20935         case FFELEX_typeEOS:
20936         case FFELEX_typeSEMICOLON:
20937           ffesta_confirmed ();
20938           break;
20939
20940         case FFELEX_typeCOMMA:
20941           ffesta_confirmed ();
20942           if (*p != '\0')
20943             break;
20944           if (!ffesta_is_inhibited ())
20945             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20946                                NULL, NULL, NULL, NULL);
20947           return (ffelexHandler) ffestb_decl_attrs_;
20948
20949         case FFELEX_typeCOLONCOLON:
20950           ffestb_local_.decl.coloncolon = TRUE;
20951           ffesta_confirmed ();
20952           if (*p != '\0')
20953             goto bad_i;         /* :::::::::::::::::::: */
20954           if (!ffesta_is_inhibited ())
20955             ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
20956                                NULL, NULL, NULL, NULL);
20957           return (ffelexHandler) ffestb_decl_ents_;
20958
20959         case FFELEX_typeSLASH:
20960           ffesta_confirmed ();
20961           if (*p != '\0')
20962             break;
20963           goto bad_1;           /* :::::::::::::::::::: */
20964
20965         case FFELEX_typeASTERISK:
20966           ffesta_confirmed ();
20967           if (*p != '\0')
20968             break;
20969           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20970           ffestb_local_.decl.badname = "TYPEDECL";
20971           return (ffelexHandler) ffestb_decl_starkind_;
20972
20973         case FFELEX_typeOPEN_PAREN:
20974           if (*p != '\0')
20975             break;
20976           ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
20977           ffestb_local_.decl.badname = "TYPEDECL";
20978           return (ffelexHandler) ffestb_decl_kindparam_;
20979         }
20980       if (!ffesrc_is_name_init (*p))
20981         goto bad_i;             /* :::::::::::::::::::: */
20982       ffestb_local_.decl.kind = NULL;
20983       ffestb_local_.decl.kindt = NULL;
20984       ffestb_local_.decl.len = NULL;
20985       ffestb_local_.decl.lent = NULL;
20986       ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
20987       return (ffelexHandler) ffestb_decl_entsp_2_ (t);
20988
20989     default:
20990       goto bad_0;               /* :::::::::::::::::::: */
20991     }
20992
20993 bad_0:                          /* :::::::::::::::::::: */
20994   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
20995   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
20996
20997 bad_1:                          /* :::::::::::::::::::: */
20998   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
20999   return (ffelexHandler) ffelex_swallow_tokens (t,
21000                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
21001
21002 bad_i:                          /* :::::::::::::::::::: */
21003   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
21004   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21005 }
21006
21007 /* ffestb_decl_recursive -- Parse the RECURSIVE FUNCTION statement
21008
21009    return ffestb_decl_recursive;  // to lexer
21010
21011    Make sure the statement has a valid form for the RECURSIVE FUNCTION
21012    statement.  If it does, implement the statement.  */
21013
21014 #if FFESTR_F90
21015 ffelexHandler
21016 ffestb_decl_recursive (ffelexToken t)
21017 {
21018   ffeTokenLength i;
21019   const char *p;
21020   ffelexToken nt;
21021   ffelexToken ot;
21022   ffelexHandler next;
21023   bool needfunc;
21024
21025   switch (ffelex_token_type (ffesta_tokens[0]))
21026     {
21027     case FFELEX_typeNAME:
21028       if (ffesta_first_kw != FFESTR_firstRECURSIVE)
21029         goto bad_0;             /* :::::::::::::::::::: */
21030       switch (ffelex_token_type (t))
21031         {
21032         case FFELEX_typeEOS:
21033         case FFELEX_typeSEMICOLON:
21034         case FFELEX_typeCOMMA:
21035         case FFELEX_typeCOLONCOLON:
21036           ffesta_confirmed ();  /* Error, but clearly intended. */
21037           goto bad_1;           /* :::::::::::::::::::: */
21038
21039         default:
21040           goto bad_1;           /* :::::::::::::::::::: */
21041
21042         case FFELEX_typeNAME:
21043           break;
21044         }
21045       ffesta_confirmed ();
21046       ffestb_local_.decl.recursive = ffelex_token_use (ffesta_tokens[0]);
21047       switch (ffesta_second_kw)
21048         {
21049         case FFESTR_secondINTEGER:
21050           ffestb_local_.decl.type = FFESTP_typeINTEGER;
21051           return (ffelexHandler) ffestb_decl_recursive1_;
21052
21053         case FFESTR_secondBYTE:
21054           ffestb_local_.decl.type = FFESTP_typeBYTE;
21055           return (ffelexHandler) ffestb_decl_recursive1_;
21056
21057         case FFESTR_secondWORD:
21058           ffestb_local_.decl.type = FFESTP_typeWORD;
21059           return (ffelexHandler) ffestb_decl_recursive1_;
21060
21061         case FFESTR_secondREAL:
21062           ffestb_local_.decl.type = FFESTP_typeREAL;
21063           return (ffelexHandler) ffestb_decl_recursive1_;
21064
21065         case FFESTR_secondCOMPLEX:
21066           ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
21067           return (ffelexHandler) ffestb_decl_recursive1_;
21068
21069         case FFESTR_secondLOGICAL:
21070           ffestb_local_.decl.type = FFESTP_typeLOGICAL;
21071           return (ffelexHandler) ffestb_decl_recursive1_;
21072
21073         case FFESTR_secondCHARACTER:
21074           ffestb_local_.decl.type = FFESTP_typeCHARACTER;
21075           return (ffelexHandler) ffestb_decl_recursive1_;
21076
21077         case FFESTR_secondDOUBLE:
21078           return (ffelexHandler) ffestb_decl_recursive2_;
21079
21080         case FFESTR_secondDOUBLEPRECISION:
21081           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
21082           ffestb_local_.decl.kind = NULL;
21083           ffestb_local_.decl.kindt = NULL;
21084           ffestb_local_.decl.len = NULL;
21085           ffestb_local_.decl.lent = NULL;
21086           return (ffelexHandler) ffestb_decl_func_;
21087
21088         case FFESTR_secondDOUBLECOMPLEX:
21089           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
21090           ffestb_local_.decl.kind = NULL;
21091           ffestb_local_.decl.kindt = NULL;
21092           ffestb_local_.decl.len = NULL;
21093           ffestb_local_.decl.lent = NULL;
21094           return (ffelexHandler) ffestb_decl_func_;
21095
21096         case FFESTR_secondTYPE:
21097           ffestb_local_.decl.type = FFESTP_typeTYPE;
21098           return (ffelexHandler) ffestb_decl_recursive3_;
21099
21100         case FFESTR_secondFUNCTION:
21101           ffestb_local_.dummy.first_kw = FFESTR_firstFUNCTION;
21102           ffestb_local_.dummy.badname = "FUNCTION";
21103           ffestb_local_.dummy.is_subr = FALSE;
21104           return (ffelexHandler) ffestb_decl_recursive4_;
21105
21106         case FFESTR_secondSUBROUTINE:
21107           ffestb_local_.dummy.first_kw = FFESTR_firstSUBROUTINE;
21108           ffestb_local_.dummy.badname = "SUBROUTINE";
21109           ffestb_local_.dummy.is_subr = TRUE;
21110           return (ffelexHandler) ffestb_decl_recursive4_;
21111
21112         default:
21113           ffelex_token_kill (ffestb_local_.decl.recursive);
21114           goto bad_1;           /* :::::::::::::::::::: */
21115         }
21116
21117     case FFELEX_typeNAMES:
21118       if (ffesta_first_kw != FFESTR_firstRECURSIVE)
21119         goto bad_0;             /* :::::::::::::::::::: */
21120       switch (ffelex_token_type (t))
21121         {
21122         case FFELEX_typeCOMMA:
21123         case FFELEX_typeCOLONCOLON:
21124         case FFELEX_typeASTERISK:
21125         case FFELEX_typeSEMICOLON:
21126         case FFELEX_typeEOS:
21127           ffesta_confirmed ();
21128           break;
21129
21130         default:
21131           break;
21132         }
21133       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlRECURSIVE);
21134       if (!ffesrc_is_name_init (*p))
21135         goto bad_0;             /* :::::::::::::::::::: */
21136       ffestb_local_.decl.recursive
21137         = ffelex_token_name_from_names (ffesta_tokens[0], 0,
21138                                         FFESTR_firstlRECURSIVE);
21139       nt = ffelex_token_names_from_names (ffesta_tokens[0],
21140                                           FFESTR_firstlRECURSIVE, 0);
21141       switch (ffestr_first (nt))
21142         {
21143         case FFESTR_firstINTGR:
21144           p = ffelex_token_text (nt) + (i = FFESTR_firstlINTGR);
21145           ffestb_local_.decl.type = FFESTP_typeINTEGER;
21146           needfunc = FALSE;
21147           goto typefunc;        /* :::::::::::::::::::: */
21148
21149         case FFESTR_firstBYTE:
21150           p = ffelex_token_text (nt) + (i = FFESTR_firstlBYTE);
21151           ffestb_local_.decl.type = FFESTP_typeBYTE;
21152           needfunc = FALSE;
21153           goto typefunc;        /* :::::::::::::::::::: */
21154
21155         case FFESTR_firstWORD:
21156           p = ffelex_token_text (nt) + (i = FFESTR_firstlWORD);
21157           ffestb_local_.decl.type = FFESTP_typeWORD;
21158           needfunc = FALSE;
21159           goto typefunc;        /* :::::::::::::::::::: */
21160
21161         case FFESTR_firstREAL:
21162           p = ffelex_token_text (nt) + (i = FFESTR_firstlREAL);
21163           ffestb_local_.decl.type = FFESTP_typeREAL;
21164           needfunc = FALSE;
21165           goto typefunc;        /* :::::::::::::::::::: */
21166
21167         case FFESTR_firstCMPLX:
21168           p = ffelex_token_text (nt) + (i = FFESTR_firstlCMPLX);
21169           ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
21170           needfunc = FALSE;
21171           goto typefunc;        /* :::::::::::::::::::: */
21172
21173         case FFESTR_firstLGCL:
21174           p = ffelex_token_text (nt) + (i = FFESTR_firstlLGCL);
21175           ffestb_local_.decl.type = FFESTP_typeLOGICAL;
21176           needfunc = FALSE;
21177           goto typefunc;        /* :::::::::::::::::::: */
21178
21179         case FFESTR_firstCHRCTR:
21180           p = ffelex_token_text (nt) + (i = FFESTR_firstlCHRCTR);
21181           ffestb_local_.decl.type = FFESTP_typeCHARACTER;
21182           needfunc = FALSE;
21183           goto typefunc;        /* :::::::::::::::::::: */
21184
21185         case FFESTR_firstDBLPRCSN:
21186           p = ffelex_token_text (nt) + (i = FFESTR_firstlDBLPRCSN);
21187           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
21188           needfunc = TRUE;
21189           goto typefunc;        /* :::::::::::::::::::: */
21190
21191         case FFESTR_firstDBLCMPLX:
21192           p = ffelex_token_text (nt) + (i = FFESTR_firstlDBLCMPLX);
21193           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
21194           needfunc = TRUE;
21195           goto typefunc;        /* :::::::::::::::::::: */
21196
21197         case FFESTR_firstTYPE:
21198           p = ffelex_token_text (nt) + (i = FFESTR_firstlTYPE);
21199           ffestb_local_.decl.type = FFESTP_typeTYPE;
21200           next = (ffelexHandler) ffestb_decl_recursive3_;
21201           break;
21202
21203         case FFESTR_firstFUNCTION:
21204           p = ffelex_token_text (nt) + (i = FFESTR_firstlFUNCTION);
21205           ffestb_local_.dummy.first_kw = FFESTR_firstFUNCTION;
21206           ffestb_local_.dummy.badname = "FUNCTION";
21207           ffestb_local_.dummy.is_subr = FALSE;
21208           next = (ffelexHandler) ffestb_decl_recursive4_;
21209           break;
21210
21211         case FFESTR_firstSUBROUTINE:
21212           p = ffelex_token_text (nt) + (i = FFESTR_firstlSUBROUTINE);
21213           ffestb_local_.dummy.first_kw = FFESTR_firstSUBROUTINE;
21214           ffestb_local_.dummy.badname = "SUBROUTINE";
21215           ffestb_local_.dummy.is_subr = TRUE;
21216           next = (ffelexHandler) ffestb_decl_recursive4_;
21217           break;
21218
21219         default:
21220           ffelex_token_kill (ffestb_local_.decl.recursive);
21221           ffelex_token_kill (nt);
21222           goto bad_1;           /* :::::::::::::::::::: */
21223         }
21224       if (*p == '\0')
21225         {
21226           ffelex_token_kill (nt);
21227           return (ffelexHandler) (*next) (t);
21228         }
21229       if (!ffesrc_is_name_init (*p))
21230         goto bad_i;             /* :::::::::::::::::::: */
21231       ot = ffelex_token_name_from_names (nt, i, 0);
21232       ffelex_token_kill (nt);
21233       next = (ffelexHandler) (*next) (ot);
21234       ffelex_token_kill (ot);
21235       return (ffelexHandler) (*next) (t);
21236
21237     default:
21238       goto bad_0;               /* :::::::::::::::::::: */
21239     }
21240
21241 typefunc:                       /* :::::::::::::::::::: */
21242   if (*p == '\0')
21243     {
21244       ffelex_token_kill (nt);
21245       if (needfunc)             /* DOUBLE PRECISION or DOUBLE COMPLEX? */
21246         {
21247           ffelex_token_kill (ffestb_local_.decl.recursive);
21248           goto bad_1;           /* :::::::::::::::::::: */
21249         }
21250       return (ffelexHandler) ffestb_decl_recursive1_ (t);
21251     }
21252   if (!ffesrc_is_name_init (*p))
21253     goto bad_i;                 /* :::::::::::::::::::: */
21254   ot = ffelex_token_names_from_names (nt, i, 0);
21255   ffelex_token_kill (nt);
21256   if (ffestr_first (ot) != FFESTR_firstFUNCTION)
21257     goto bad_o;                 /* :::::::::::::::::::: */
21258   p = ffelex_token_text (ot) + (i = FFESTR_firstlFUNCTION);
21259   if (!ffesrc_is_name_init (*p))
21260     goto bad_i;                 /* :::::::::::::::::::: */
21261   ffesta_tokens[1] = ffelex_token_name_from_names (ot, i, 0);
21262   ffelex_token_kill (ot);
21263   ffestb_local_.decl.kind = NULL;
21264   ffestb_local_.decl.kindt = NULL;
21265   ffestb_local_.decl.len = NULL;
21266   ffestb_local_.decl.lent = NULL;
21267   return (ffelexHandler) ffestb_decl_funcname_1_ (t);
21268
21269 bad_0:                          /* :::::::::::::::::::: */
21270   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ffesta_tokens[0]);
21271   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21272
21273 bad_1:                          /* :::::::::::::::::::: */
21274   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21275   return (ffelexHandler) ffelex_swallow_tokens (t,
21276                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
21277
21278 bad_i:                          /* :::::::::::::::::::: */
21279   ffelex_token_kill (ffestb_local_.decl.recursive);
21280   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", nt, i, t);
21281   ffelex_token_kill (nt);
21282   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21283
21284 bad_o:                          /* :::::::::::::::::::: */
21285   ffelex_token_kill (ffestb_local_.decl.recursive);
21286   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ot);
21287   ffelex_token_kill (ot);
21288   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21289 }
21290
21291 /* ffestb_decl_recursive1_ -- "RECURSIVE" generic-type
21292
21293    return ffestb_decl_recursive1_;  // to lexer
21294
21295    Handle ASTERISK, OPEN_PAREN, or NAME.  */
21296
21297 static ffelexHandler
21298 ffestb_decl_recursive1_ (ffelexToken t)
21299 {
21300   switch (ffelex_token_type (t))
21301     {
21302     case FFELEX_typeASTERISK:
21303       ffesta_confirmed ();
21304       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
21305       ffestb_local_.decl.badname = "TYPEFUNC";
21306       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
21307         return (ffelexHandler) ffestb_decl_starlen_;
21308       return (ffelexHandler) ffestb_decl_starkind_;
21309
21310     case FFELEX_typeOPEN_PAREN:
21311       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
21312       ffestb_local_.decl.badname = "TYPEFUNC";
21313       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
21314         {
21315           ffestb_local_.decl.kind = NULL;
21316           ffestb_local_.decl.kindt = NULL;
21317           ffestb_local_.decl.len = NULL;
21318           ffestb_local_.decl.lent = NULL;
21319           return (ffelexHandler) ffestb_decl_typeparams_;
21320         }
21321       return (ffelexHandler) ffestb_decl_kindparam_;
21322
21323     case FFELEX_typeNAME:
21324       ffestb_local_.decl.kind = NULL;
21325       ffestb_local_.decl.kindt = NULL;
21326       ffestb_local_.decl.len = NULL;
21327       ffestb_local_.decl.lent = NULL;
21328       return (ffelexHandler) ffestb_decl_func_ (t);
21329
21330     default:
21331       break;
21332     }
21333
21334   if (ffestb_local_.decl.recursive != NULL)
21335     ffelex_token_kill (ffestb_local_.decl.recursive);
21336   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21337   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21338 }
21339
21340 /* ffestb_decl_recursive2_ -- "RECURSIVE" "DOUBLE"
21341
21342    return ffestb_decl_recursive2_;  // to lexer
21343
21344    Handle NAME.  */
21345
21346 static ffelexHandler
21347 ffestb_decl_recursive2_ (ffelexToken t)
21348 {
21349   switch (ffelex_token_type (t))
21350     {
21351     case FFELEX_typeNAME:
21352       switch (ffestr_second (t))
21353         {
21354         case FFESTR_secondPRECISION:
21355           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
21356           break;
21357
21358         case FFESTR_secondCOMPLEX:
21359           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
21360           break;
21361
21362         default:
21363           goto bad;             /* :::::::::::::::::::: */
21364         }
21365       ffestb_local_.decl.kind = NULL;
21366       ffestb_local_.decl.kindt = NULL;
21367       ffestb_local_.decl.len = NULL;
21368       ffestb_local_.decl.lent = NULL;
21369       return (ffelexHandler) ffestb_decl_func_;
21370
21371     default:
21372       break;
21373     }
21374
21375 bad:                            /* :::::::::::::::::::: */
21376   if (ffestb_local_.decl.recursive != NULL)
21377     ffelex_token_kill (ffestb_local_.decl.recursive);
21378   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21379   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21380 }
21381
21382 /* ffestb_decl_recursive3_ -- "RECURSIVE" "TYPE"
21383
21384    return ffestb_decl_recursive3_;  // to lexer
21385
21386    Handle OPEN_PAREN.  */
21387
21388 static ffelexHandler
21389 ffestb_decl_recursive3_ (ffelexToken t)
21390 {
21391   switch (ffelex_token_type (t))
21392     {
21393     case FFELEX_typeOPEN_PAREN:
21394       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
21395       ffestb_local_.decl.badname = "TYPEFUNC";
21396       return (ffelexHandler) ffestb_decl_typetype1_;
21397
21398     default:
21399       break;
21400     }
21401
21402   if (ffestb_local_.decl.recursive != NULL)
21403     ffelex_token_kill (ffestb_local_.decl.recursive);
21404   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21405   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21406 }
21407
21408 /* ffestb_decl_recursive4_ -- "RECURSIVE" "FUNCTION/SUBROUTINE"
21409
21410    return ffestb_decl_recursive4_;  // to lexer
21411
21412    Handle OPEN_PAREN.  */
21413
21414 static ffelexHandler
21415 ffestb_decl_recursive4_ (ffelexToken t)
21416 {
21417   switch (ffelex_token_type (t))
21418     {
21419     case FFELEX_typeNAME:
21420       ffesta_tokens[1] = ffelex_token_use (t);
21421       return (ffelexHandler) ffestb_dummy1_;
21422
21423     default:
21424       break;
21425     }
21426
21427   if (ffestb_local_.decl.recursive != NULL)
21428     ffelex_token_kill (ffestb_local_.decl.recursive);
21429   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
21430   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21431 }
21432
21433 #endif
21434 /* ffestb_decl_typetype -- Parse the R426/R501/R1219 TYPE statement
21435
21436    return ffestb_decl_typetype;  // to lexer
21437
21438    Make sure the statement has a valid form for the TYPE statement.  If it
21439    does, implement the statement.  */
21440
21441 #if FFESTR_F90
21442 ffelexHandler
21443 ffestb_decl_typetype (ffelexToken t)
21444 {
21445   switch (ffelex_token_type (ffesta_tokens[0]))
21446     {
21447     case FFELEX_typeNAME:
21448       if (ffesta_first_kw != FFESTR_firstTYPE)
21449         goto bad_0;             /* :::::::::::::::::::: */
21450       break;
21451
21452     case FFELEX_typeNAMES:
21453       if (ffesta_first_kw != FFESTR_firstTYPE)
21454         goto bad_0;             /* :::::::::::::::::::: */
21455       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlTYPE)
21456         goto bad_0;             /* :::::::::::::::::::: */
21457       break;
21458
21459     default:
21460       goto bad_0;               /* :::::::::::::::::::: */
21461     }
21462
21463   switch (ffelex_token_type (t))
21464     {
21465     case FFELEX_typeOPEN_PAREN:
21466       break;
21467
21468     case FFELEX_typeEOS:
21469     case FFELEX_typeSEMICOLON:
21470     case FFELEX_typeCOLONCOLON:/* Not COMMA: R424 "TYPE,PUBLIC::A". */
21471       ffesta_confirmed ();      /* Error, but clearly intended. */
21472       goto bad_1;               /* :::::::::::::::::::: */
21473
21474     default:
21475       goto bad_1;               /* :::::::::::::::::::: */
21476     }
21477
21478   ffestb_local_.decl.recursive = NULL;
21479   ffestb_local_.decl.parameter = FALSE; /* No PARAMETER attribute seen. */
21480   ffestb_local_.decl.coloncolon = FALSE;        /* No COLONCOLON seen. */
21481
21482   ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
21483   ffestb_local_.decl.badname = "type-declaration";
21484   return (ffelexHandler) ffestb_decl_typetype1_;
21485
21486 bad_0:                          /* :::::::::::::::::::: */
21487   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
21488   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21489
21490 bad_1:                          /* :::::::::::::::::::: */
21491   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21492   return (ffelexHandler) ffelex_swallow_tokens (t,
21493                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
21494 }
21495
21496 #endif
21497 /* ffestb_decl_attrs_ -- "type" [type parameters] COMMA
21498
21499    return ffestb_decl_attrs_;  // to lexer
21500
21501    Handle NAME of an attribute.  */
21502
21503 static ffelexHandler
21504 ffestb_decl_attrs_ (ffelexToken t)
21505 {
21506   switch (ffelex_token_type (t))
21507     {
21508     case FFELEX_typeNAME:
21509       switch (ffestr_first (t))
21510         {
21511 #if FFESTR_F90
21512         case FFESTR_firstALLOCATABLE:
21513           if (!ffesta_is_inhibited ())
21514             ffestc_decl_attrib (FFESTP_attribALLOCATABLE, t,
21515                                 FFESTR_otherNone, NULL);
21516           return (ffelexHandler) ffestb_decl_attrs_7_;
21517 #endif
21518
21519         case FFESTR_firstDIMENSION:
21520           ffesta_tokens[1] = ffelex_token_use (t);
21521           return (ffelexHandler) ffestb_decl_attrs_1_;
21522
21523         case FFESTR_firstEXTERNAL:
21524           if (!ffesta_is_inhibited ())
21525             ffestc_decl_attrib (FFESTP_attribEXTERNAL, t,
21526                                 FFESTR_otherNone, NULL);
21527           return (ffelexHandler) ffestb_decl_attrs_7_;
21528
21529 #if FFESTR_F90
21530         case FFESTR_firstINTENT:
21531           ffesta_tokens[1] = ffelex_token_use (t);
21532           return (ffelexHandler) ffestb_decl_attrs_3_;
21533 #endif
21534
21535         case FFESTR_firstINTRINSIC:
21536           if (!ffesta_is_inhibited ())
21537             ffestc_decl_attrib (FFESTP_attribINTRINSIC, t,
21538                                 FFESTR_otherNone, NULL);
21539           return (ffelexHandler) ffestb_decl_attrs_7_;
21540
21541 #if FFESTR_F90
21542         case FFESTR_firstOPTIONAL:
21543           if (!ffesta_is_inhibited ())
21544             ffestc_decl_attrib (FFESTP_attribOPTIONAL, t,
21545                                 FFESTR_otherNone, NULL);
21546           return (ffelexHandler) ffestb_decl_attrs_7_;
21547 #endif
21548
21549         case FFESTR_firstPARAMETER:
21550           ffestb_local_.decl.parameter = TRUE;
21551           if (!ffesta_is_inhibited ())
21552             ffestc_decl_attrib (FFESTP_attribPARAMETER, t,
21553                                 FFESTR_otherNone, NULL);
21554           return (ffelexHandler) ffestb_decl_attrs_7_;
21555
21556 #if FFESTR_F90
21557         case FFESTR_firstPOINTER:
21558           if (!ffesta_is_inhibited ())
21559             ffestc_decl_attrib (FFESTP_attribPOINTER, t,
21560                                 FFESTR_otherNone, NULL);
21561           return (ffelexHandler) ffestb_decl_attrs_7_;
21562 #endif
21563
21564 #if FFESTR_F90
21565         case FFESTR_firstPRIVATE:
21566           if (!ffesta_is_inhibited ())
21567             ffestc_decl_attrib (FFESTP_attribPRIVATE, t,
21568                                 FFESTR_otherNone, NULL);
21569           return (ffelexHandler) ffestb_decl_attrs_7_;
21570
21571         case FFESTR_firstPUBLIC:
21572           if (!ffesta_is_inhibited ())
21573             ffestc_decl_attrib (FFESTP_attribPUBLIC, t,
21574                                 FFESTR_otherNone, NULL);
21575           return (ffelexHandler) ffestb_decl_attrs_7_;
21576 #endif
21577
21578         case FFESTR_firstSAVE:
21579           if (!ffesta_is_inhibited ())
21580             ffestc_decl_attrib (FFESTP_attribSAVE, t,
21581                                 FFESTR_otherNone, NULL);
21582           return (ffelexHandler) ffestb_decl_attrs_7_;
21583
21584 #if FFESTR_F90
21585         case FFESTR_firstTARGET:
21586           if (!ffesta_is_inhibited ())
21587             ffestc_decl_attrib (FFESTP_attribTARGET, t,
21588                                 FFESTR_otherNone, NULL);
21589           return (ffelexHandler) ffestb_decl_attrs_7_;
21590 #endif
21591
21592         default:
21593           ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21594           return (ffelexHandler) ffestb_decl_attrs_7_;
21595         }
21596       break;
21597
21598     default:
21599       break;
21600     }
21601
21602   if (!ffesta_is_inhibited ())
21603     ffestc_decl_finish ();
21604   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21605   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21606 }
21607
21608 /* ffestb_decl_attrs_1_ -- "type" [type parameters] ",DIMENSION"
21609
21610    return ffestb_decl_attrs_1_;  // to lexer
21611
21612    Handle OPEN_PAREN.  */
21613
21614 static ffelexHandler
21615 ffestb_decl_attrs_1_ (ffelexToken t)
21616 {
21617   switch (ffelex_token_type (t))
21618     {
21619     case FFELEX_typeOPEN_PAREN:
21620       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
21621       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_decl_attrs_2_;
21622       ffestb_subrargs_.dim_list.pool = ffesta_scratch_pool;
21623       ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
21624         ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
21625 #ifdef FFECOM_dimensionsMAX
21626       ffestb_subrargs_.dim_list.ndims = 0;
21627 #endif
21628       return (ffelexHandler) ffeexpr_rhs (ffesta_scratch_pool,
21629                                           ffestb_subrargs_.dim_list.ctx,
21630                                     (ffeexprCallback) ffestb_subr_dimlist_);
21631
21632     case FFELEX_typeCOMMA:
21633     case FFELEX_typeCOLONCOLON:
21634       ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, ffesta_tokens[1]);
21635       ffelex_token_kill (ffesta_tokens[1]);
21636       return (ffelexHandler) ffestb_decl_attrs_7_ (t);
21637
21638     default:
21639       break;
21640     }
21641
21642   if (!ffesta_is_inhibited ())
21643     ffestc_decl_finish ();
21644   ffelex_token_kill (ffesta_tokens[1]);
21645   ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21646   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21647 }
21648
21649 /* ffestb_decl_attrs_2_ -- "type" [type parameters] ",DIMENSION" OPEN_PAREN
21650                           dimlist CLOSE_PAREN
21651
21652    return ffestb_decl_attrs_2_;  // to lexer
21653
21654    Handle COMMA or COLONCOLON.  */
21655
21656 static ffelexHandler
21657 ffestb_decl_attrs_2_ (ffelexToken t)
21658 {
21659   if (!ffestb_subrargs_.dim_list.ok)
21660     goto bad;                   /* :::::::::::::::::::: */
21661
21662   switch (ffelex_token_type (t))
21663     {
21664     case FFELEX_typeCOMMA:
21665     case FFELEX_typeCOLONCOLON:
21666       if (!ffesta_is_inhibited ())
21667         ffestc_decl_attrib (FFESTP_attribDIMENSION, ffesta_tokens[1],
21668                           FFESTR_otherNone, ffestb_subrargs_.dim_list.dims);
21669       ffelex_token_kill (ffesta_tokens[1]);
21670       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
21671       return (ffelexHandler) ffestb_decl_attrs_7_ (t);
21672
21673     default:
21674       break;
21675     }
21676
21677 bad:                            /* :::::::::::::::::::: */
21678   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21679   if (!ffesta_is_inhibited ())
21680     ffestc_decl_finish ();
21681   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
21682   ffelex_token_kill (ffesta_tokens[1]);
21683   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21684 }
21685
21686 /* ffestb_decl_attrs_3_ -- "type" [type parameters] ",INTENT"
21687
21688    return ffestb_decl_attrs_3_;  // to lexer
21689
21690    Handle OPEN_PAREN.  */
21691
21692 #if FFESTR_F90
21693 static ffelexHandler
21694 ffestb_decl_attrs_3_ (ffelexToken t)
21695 {
21696   switch (ffelex_token_type (t))
21697     {
21698     case FFELEX_typeOPEN_PAREN:
21699       return (ffelexHandler) ffestb_decl_attrs_4_;
21700
21701     case FFELEX_typeCOMMA:
21702     case FFELEX_typeCOLONCOLON:
21703       ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, ffesta_tokens[1]);
21704       ffelex_token_kill (ffesta_tokens[1]);
21705       return (ffelexHandler) ffestb_decl_attrs_7_ (t);
21706
21707     default:
21708       break;
21709     }
21710
21711   if (!ffesta_is_inhibited ())
21712     ffestc_decl_finish ();
21713   ffelex_token_kill (ffesta_tokens[1]);
21714   ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21715   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21716 }
21717
21718 /* ffestb_decl_attrs_4_ -- "type" [type parameters] ",INTENT" OPEN_PAREN
21719
21720    return ffestb_decl_attrs_4_;  // to lexer
21721
21722    Handle NAME.  */
21723
21724 static ffelexHandler
21725 ffestb_decl_attrs_4_ (ffelexToken t)
21726 {
21727   switch (ffelex_token_type (t))
21728     {
21729     case FFELEX_typeNAME:
21730       ffestb_local_.decl.kw = ffestr_other (t);
21731       switch (ffestb_local_.decl.kw)
21732         {
21733         case FFESTR_otherIN:
21734           return (ffelexHandler) ffestb_decl_attrs_5_;
21735
21736         case FFESTR_otherINOUT:
21737           return (ffelexHandler) ffestb_decl_attrs_6_;
21738
21739         case FFESTR_otherOUT:
21740           return (ffelexHandler) ffestb_decl_attrs_6_;
21741
21742         default:
21743           ffestb_local_.decl.kw = FFESTR_otherNone;
21744           ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21745           return (ffelexHandler) ffestb_decl_attrs_5_;
21746         }
21747       break;
21748
21749     default:
21750       break;
21751     }
21752
21753   if (!ffesta_is_inhibited ())
21754     ffestc_decl_finish ();
21755   ffelex_token_kill (ffesta_tokens[1]);
21756   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21757   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21758 }
21759
21760 /* ffestb_decl_attrs_5_ -- "type" [type parameters] ",INTENT" OPEN_PAREN "IN"
21761
21762    return ffestb_decl_attrs_5_;  // to lexer
21763
21764    Handle NAME or CLOSE_PAREN.  */
21765
21766 static ffelexHandler
21767 ffestb_decl_attrs_5_ (ffelexToken t)
21768 {
21769   switch (ffelex_token_type (t))
21770     {
21771     case FFELEX_typeNAME:
21772       switch (ffestr_other (t))
21773         {
21774         case FFESTR_otherOUT:
21775           if (ffestb_local_.decl.kw != FFESTR_otherNone)
21776             ffestb_local_.decl.kw = FFESTR_otherINOUT;
21777           return (ffelexHandler) ffestb_decl_attrs_6_;
21778
21779         default:
21780           if (ffestb_local_.decl.kw != FFESTR_otherNone)
21781             {
21782               ffestb_local_.decl.kw = FFESTR_otherNone;
21783               ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
21784             }
21785           return (ffelexHandler) ffestb_decl_attrs_5_;
21786         }
21787       break;
21788
21789     case FFELEX_typeCLOSE_PAREN:
21790       return (ffelexHandler) ffestb_decl_attrs_6_ (t);
21791
21792     default:
21793       break;
21794     }
21795
21796   if (!ffesta_is_inhibited ())
21797     ffestc_decl_finish ();
21798   ffelex_token_kill (ffesta_tokens[1]);
21799   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21800   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21801 }
21802
21803 /* ffestb_decl_attrs_6_ -- "type" [type parameters] ",INTENT" OPEN_PAREN "IN"
21804                           ["OUT"]
21805
21806    return ffestb_decl_attrs_6_;  // to lexer
21807
21808    Handle CLOSE_PAREN.  */
21809
21810 static ffelexHandler
21811 ffestb_decl_attrs_6_ (ffelexToken t)
21812 {
21813   switch (ffelex_token_type (t))
21814     {
21815     case FFELEX_typeCLOSE_PAREN:
21816       if ((ffestb_local_.decl.kw != FFESTR_otherNone)
21817           && !ffesta_is_inhibited ())
21818         ffestc_decl_attrib (FFESTP_attribINTENT, ffesta_tokens[1],
21819                             ffestb_local_.decl.kw, NULL);
21820       ffelex_token_kill (ffesta_tokens[1]);
21821       return (ffelexHandler) ffestb_decl_attrs_7_;
21822
21823     default:
21824       break;
21825     }
21826
21827   if (!ffesta_is_inhibited ())
21828     ffestc_decl_finish ();
21829   ffelex_token_kill (ffesta_tokens[1]);
21830   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21831   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21832 }
21833
21834 #endif
21835 /* ffestb_decl_attrs_7_ -- "type" [type parameters] attribute
21836
21837    return ffestb_decl_attrs_7_;  // to lexer
21838
21839    Handle COMMA (another attribute) or COLONCOLON (entities).  */
21840
21841 static ffelexHandler
21842 ffestb_decl_attrs_7_ (ffelexToken t)
21843 {
21844   switch (ffelex_token_type (t))
21845     {
21846     case FFELEX_typeCOMMA:
21847       return (ffelexHandler) ffestb_decl_attrs_;
21848
21849     case FFELEX_typeCOLONCOLON:
21850       ffestb_local_.decl.coloncolon = TRUE;
21851       return (ffelexHandler) ffestb_decl_ents_;
21852
21853     default:
21854       break;
21855     }
21856
21857   if (!ffesta_is_inhibited ())
21858     ffestc_decl_finish ();
21859   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21860   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21861 }
21862
21863 /* ffestb_decl_attrsp_ -- "type" [type parameters]
21864
21865    return ffestb_decl_attrsp_;  // to lexer
21866
21867    Handle COMMA (meaning we have attributes), COLONCOLON (meaning we have
21868    no attributes but entities), or go to entsp to see about functions or
21869    entities.  */
21870
21871 static ffelexHandler
21872 ffestb_decl_attrsp_ (ffelexToken t)
21873 {
21874   ffelex_set_names (FALSE);
21875
21876   switch (ffelex_token_type (t))
21877     {
21878     case FFELEX_typeCOMMA:
21879       ffesta_confirmed ();
21880       if (!ffesta_is_inhibited ())
21881         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
21882                            ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
21883                            ffestb_local_.decl.len, ffestb_local_.decl.lent);
21884       if (ffestb_local_.decl.kindt != NULL)
21885         ffelex_token_kill (ffestb_local_.decl.kindt);
21886       if (ffestb_local_.decl.lent != NULL)
21887         ffelex_token_kill (ffestb_local_.decl.lent);
21888       return (ffelexHandler) ffestb_decl_attrs_;
21889
21890     case FFELEX_typeCOLONCOLON:
21891       ffestb_local_.decl.coloncolon = TRUE;
21892       ffesta_confirmed ();
21893       if (!ffesta_is_inhibited ())
21894         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
21895                            ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
21896                            ffestb_local_.decl.len, ffestb_local_.decl.lent);
21897       if (ffestb_local_.decl.kindt != NULL)
21898         ffelex_token_kill (ffestb_local_.decl.kindt);
21899       if (ffestb_local_.decl.lent != NULL)
21900         ffelex_token_kill (ffestb_local_.decl.lent);
21901       return (ffelexHandler) ffestb_decl_ents_;
21902
21903     default:
21904       return (ffelexHandler) ffestb_decl_entsp_ (t);
21905     }
21906 }
21907
21908 /* ffestb_decl_ents_ -- "type" [type parameters] [attributes "::"]
21909
21910    return ffestb_decl_ents_;  // to lexer
21911
21912    Handle NAME of an entity.  */
21913
21914 static ffelexHandler
21915 ffestb_decl_ents_ (ffelexToken t)
21916 {
21917   switch (ffelex_token_type (t))
21918     {
21919     case FFELEX_typeNAME:
21920       ffesta_tokens[1] = ffelex_token_use (t);
21921       return (ffelexHandler) ffestb_decl_ents_1_;
21922
21923     default:
21924       break;
21925     }
21926
21927   if (!ffesta_is_inhibited ())
21928     ffestc_decl_finish ();
21929   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21930   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21931 }
21932
21933 /* ffestb_decl_ents_1_ -- "type" [type parameters] [attributes "::"] NAME
21934
21935    return ffestb_decl_ents_1_;  // to lexer
21936
21937    Handle ASTERISK, OPEN_PAREN, EQUALS, SLASH, COMMA, or EOS/SEMICOLON.  */
21938
21939 static ffelexHandler
21940 ffestb_decl_ents_1_ (ffelexToken t)
21941 {
21942   switch (ffelex_token_type (t))
21943     {
21944     case FFELEX_typeCOMMA:
21945       if (!ffesta_is_inhibited ())
21946         ffestc_decl_item (ffesta_tokens[1], NULL, NULL, NULL, NULL, NULL, NULL,
21947                           NULL, FALSE);
21948       ffelex_token_kill (ffesta_tokens[1]);
21949       return (ffelexHandler) ffestb_decl_ents_;
21950
21951     case FFELEX_typeEOS:
21952     case FFELEX_typeSEMICOLON:
21953       if (!ffesta_is_inhibited ())
21954         {
21955           ffestc_decl_item (ffesta_tokens[1], NULL, NULL, NULL, NULL, NULL, NULL,
21956                             NULL, FALSE);
21957           ffestc_decl_finish ();
21958         }
21959       ffelex_token_kill (ffesta_tokens[1]);
21960       return (ffelexHandler) ffesta_zero (t);
21961
21962     case FFELEX_typeASTERISK:
21963       ffestb_local_.decl.len = NULL;
21964       ffestb_local_.decl.lent = NULL;
21965       return (ffelexHandler) ffestb_decl_ents_2_;
21966
21967     case FFELEX_typeOPEN_PAREN:
21968       ffestb_local_.decl.kind = NULL;
21969       ffestb_local_.decl.kindt = NULL;
21970       ffestb_local_.decl.len = NULL;
21971       ffestb_local_.decl.lent = NULL;
21972       return (ffelexHandler) ffestb_decl_ents_3_ (t);
21973
21974     case FFELEX_typeEQUALS:
21975     case FFELEX_typeSLASH:
21976       ffestb_local_.decl.kind = NULL;
21977       ffestb_local_.decl.kindt = NULL;
21978       ffestb_subrargs_.dim_list.dims = NULL;
21979       ffestb_local_.decl.len = NULL;
21980       ffestb_local_.decl.lent = NULL;
21981       return (ffelexHandler) ffestb_decl_ents_7_ (t);
21982
21983     default:
21984       break;
21985     }
21986
21987   if (!ffesta_is_inhibited ())
21988     ffestc_decl_finish ();
21989   ffelex_token_kill (ffesta_tokens[1]);
21990   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
21991   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
21992 }
21993
21994 /* ffestb_decl_ents_2_ -- "type" [type parameters] [attributes "::"] NAME
21995                          ASTERISK
21996
21997    return ffestb_decl_ents_2_;  // to lexer
21998
21999    Handle NUMBER or OPEN_PAREN.  */
22000
22001 static ffelexHandler
22002 ffestb_decl_ents_2_ (ffelexToken t)
22003 {
22004   switch (ffelex_token_type (t))
22005     {
22006     case FFELEX_typeNUMBER:
22007       if (ffestb_local_.decl.type != FFESTP_typeCHARACTER)
22008         {
22009           ffestb_local_.decl.kind = NULL;
22010           ffestb_local_.decl.kindt = ffelex_token_use (t);
22011           return (ffelexHandler) ffestb_decl_ents_3_;
22012         }
22013       /* Fall through. *//* (CHARACTER's *n is always a len spec. */
22014     case FFELEX_typeOPEN_PAREN:/* "*(" is after the (omitted)
22015                                    "(array-spec)". */
22016       ffestb_local_.decl.kind = NULL;
22017       ffestb_local_.decl.kindt = NULL;
22018       ffestb_subrargs_.dim_list.dims = NULL;
22019       return (ffelexHandler) ffestb_decl_ents_5_ (t);
22020
22021     default:
22022       break;
22023     }
22024
22025   if (!ffesta_is_inhibited ())
22026     ffestc_decl_finish ();
22027   ffelex_token_kill (ffesta_tokens[1]);
22028   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22029   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22030 }
22031
22032 /* ffestb_decl_ents_3_ -- "type" [type parameters] [attributes "::"] NAME
22033                          [ASTERISK NUMBER]
22034
22035    return ffestb_decl_ents_3_;  // to lexer
22036
22037    Handle ASTERISK, OPEN_PAREN, EQUALS, SLASH, COMMA, or EOS/SEMICOLON.  */
22038
22039 static ffelexHandler
22040 ffestb_decl_ents_3_ (ffelexToken t)
22041 {
22042   switch (ffelex_token_type (t))
22043     {
22044     case FFELEX_typeCOMMA:
22045       if (!ffesta_is_inhibited ())
22046         ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22047              ffestb_local_.decl.kindt, NULL, NULL, NULL, NULL, NULL, FALSE);
22048       ffelex_token_kill (ffesta_tokens[1]);
22049       if (ffestb_local_.decl.kindt != NULL)
22050         ffelex_token_kill (ffestb_local_.decl.kindt);
22051       return (ffelexHandler) ffestb_decl_ents_;
22052
22053     case FFELEX_typeEOS:
22054     case FFELEX_typeSEMICOLON:
22055       if (!ffesta_is_inhibited ())
22056         {
22057           ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22058              ffestb_local_.decl.kindt, NULL, NULL, NULL, NULL, NULL, FALSE);
22059           ffestc_decl_finish ();
22060         }
22061       ffelex_token_kill (ffesta_tokens[1]);
22062       if (ffestb_local_.decl.kindt != NULL)
22063         ffelex_token_kill (ffestb_local_.decl.kindt);
22064       return (ffelexHandler) ffesta_zero (t);
22065
22066     case FFELEX_typeASTERISK:
22067       ffestb_subrargs_.dim_list.dims = NULL;
22068       return (ffelexHandler) ffestb_decl_ents_5_;
22069
22070     case FFELEX_typeOPEN_PAREN:
22071       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
22072       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_decl_ents_4_;
22073       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
22074       ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
22075         ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
22076 #ifdef FFECOM_dimensionsMAX
22077       ffestb_subrargs_.dim_list.ndims = 0;
22078 #endif
22079       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22080                                           ffestb_subrargs_.dim_list.ctx,
22081                                     (ffeexprCallback) ffestb_subr_dimlist_);
22082
22083     case FFELEX_typeEQUALS:
22084     case FFELEX_typeSLASH:
22085       ffestb_local_.decl.kind = NULL;
22086       ffestb_local_.decl.kindt = NULL;
22087       ffestb_subrargs_.dim_list.dims = NULL;
22088       ffestb_local_.decl.len = NULL;
22089       ffestb_local_.decl.lent = NULL;
22090       return (ffelexHandler) ffestb_decl_ents_7_ (t);
22091
22092     default:
22093       break;
22094     }
22095
22096   if (!ffesta_is_inhibited ())
22097     ffestc_decl_finish ();
22098   ffelex_token_kill (ffesta_tokens[1]);
22099   if (ffestb_local_.decl.kindt != NULL)
22100     ffelex_token_kill (ffestb_local_.decl.kindt);
22101   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22102   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22103 }
22104
22105 /* ffestb_decl_ents_4_ -- "type" [type parameters] [attributes "::"] NAME
22106                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22107
22108    return ffestb_decl_ents_4_;  // to lexer
22109
22110    Handle ASTERISK, EQUALS, SLASH, COMMA, or EOS/SEMICOLON.  */
22111
22112 static ffelexHandler
22113 ffestb_decl_ents_4_ (ffelexToken t)
22114 {
22115   ffelexToken nt;
22116
22117   if (!ffestb_subrargs_.dim_list.ok)
22118     goto bad;                   /* :::::::::::::::::::: */
22119
22120   if (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeNAMES)
22121     {
22122       switch (ffelex_token_type (t))
22123         {
22124         case FFELEX_typeCOMMA:
22125         case FFELEX_typeEOS:
22126         case FFELEX_typeSEMICOLON:
22127         case FFELEX_typeASTERISK:
22128         case FFELEX_typeSLASH:  /* But NOT FFELEX_typeEQUALS. */
22129         case FFELEX_typeCOLONCOLON:     /* Actually an error. */
22130           break;                /* Confirm and handle. */
22131
22132         default:                /* Perhaps EQUALS, as in
22133                                    INTEGERFUNCTIONX(A)=B. */
22134           goto bad;             /* :::::::::::::::::::: */
22135         }
22136       ffesta_confirmed ();
22137       if (!ffesta_is_inhibited ())
22138         {
22139           nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
22140           ffelex_token_kill (ffesta_tokens[1]);
22141           ffesta_tokens[1] = nt;
22142           ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
22143                              NULL, NULL, NULL, NULL);
22144         }
22145     }
22146
22147   switch (ffelex_token_type (t))
22148     {
22149     case FFELEX_typeCOMMA:
22150       if (!ffesta_is_inhibited ())
22151         ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22152                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22153                 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22154                           FALSE);
22155       ffelex_token_kill (ffesta_tokens[1]);
22156       if (ffestb_local_.decl.kindt != NULL)
22157         ffelex_token_kill (ffestb_local_.decl.kindt);
22158       if (ffestb_local_.decl.lent != NULL)
22159         ffelex_token_kill (ffestb_local_.decl.lent);
22160       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22161       return (ffelexHandler) ffestb_decl_ents_;
22162
22163     case FFELEX_typeEOS:
22164     case FFELEX_typeSEMICOLON:
22165       if (!ffesta_is_inhibited ())
22166         {
22167           ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22168                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22169                 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22170                             FALSE);
22171           ffestc_decl_finish ();
22172         }
22173       ffelex_token_kill (ffesta_tokens[1]);
22174       if (ffestb_local_.decl.kindt != NULL)
22175         ffelex_token_kill (ffestb_local_.decl.kindt);
22176       if (ffestb_local_.decl.lent != NULL)
22177         ffelex_token_kill (ffestb_local_.decl.lent);
22178       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22179       return (ffelexHandler) ffesta_zero (t);
22180
22181     case FFELEX_typeASTERISK:
22182       if (ffestb_local_.decl.lent != NULL)
22183         break;                  /* Can't specify "*length" twice. */
22184       return (ffelexHandler) ffestb_decl_ents_5_;
22185
22186     case FFELEX_typeEQUALS:
22187     case FFELEX_typeSLASH:
22188       return (ffelexHandler) ffestb_decl_ents_7_ (t);
22189
22190     default:
22191       break;
22192     }
22193
22194 bad:                            /* :::::::::::::::::::: */
22195   if ((ffelex_token_type (ffesta_tokens[1]) != FFELEX_typeNAMES)
22196       && !ffesta_is_inhibited ())
22197     ffestc_decl_finish ();
22198   ffelex_token_kill (ffesta_tokens[1]);
22199   if (ffestb_local_.decl.kindt != NULL)
22200     ffelex_token_kill (ffestb_local_.decl.kindt);
22201   if (ffestb_local_.decl.lent != NULL)
22202     ffelex_token_kill (ffestb_local_.decl.lent);
22203   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22204   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22205   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22206 }
22207
22208 /* ffestb_decl_ents_5_ -- "type" [type parameters] [attributes "::"] NAME
22209                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22210                          ASTERISK
22211
22212    return ffestb_decl_ents_5_;  // to lexer
22213
22214    Handle NUMBER or OPEN_PAREN.  */
22215
22216 static ffelexHandler
22217 ffestb_decl_ents_5_ (ffelexToken t)
22218 {
22219   switch (ffelex_token_type (t))
22220     {
22221     case FFELEX_typeNUMBER:
22222       ffestb_local_.decl.len = NULL;
22223       ffestb_local_.decl.lent = ffelex_token_use (t);
22224       return (ffelexHandler) ffestb_decl_ents_7_;
22225
22226     case FFELEX_typeOPEN_PAREN:
22227       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22228        FFEEXPR_contextCHARACTERSIZE, (ffeexprCallback) ffestb_decl_ents_6_);
22229
22230     default:
22231       break;
22232     }
22233
22234   if (!ffesta_is_inhibited ())
22235     ffestc_decl_finish ();
22236   ffelex_token_kill (ffesta_tokens[1]);
22237   if (ffestb_local_.decl.kindt != NULL)
22238     ffelex_token_kill (ffestb_local_.decl.kindt);
22239   if (ffestb_subrargs_.dim_list.dims != NULL)
22240     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22241   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22242   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22243 }
22244
22245 /* ffestb_decl_ents_6_ -- "type" [type parameters] [attributes "::"] NAME
22246                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22247                          ASTERISK OPEN_PAREN expr
22248
22249    (ffestb_decl_ents_6_)  // to expression handler
22250
22251    Handle CLOSE_PAREN.  */
22252
22253 static ffelexHandler
22254 ffestb_decl_ents_6_ (ffelexToken ft, ffebld expr, ffelexToken t)
22255 {
22256   switch (ffelex_token_type (t))
22257     {
22258     case FFELEX_typeCLOSE_PAREN:
22259       if (expr == NULL)
22260         break;
22261       ffestb_local_.decl.len = expr;
22262       ffestb_local_.decl.lent = ffelex_token_use (ft);
22263       return (ffelexHandler) ffestb_decl_ents_7_;
22264
22265     default:
22266       break;
22267     }
22268
22269   if (!ffesta_is_inhibited ())
22270     ffestc_decl_finish ();
22271   ffelex_token_kill (ffesta_tokens[1]);
22272   if (ffestb_local_.decl.kindt != NULL)
22273     ffelex_token_kill (ffestb_local_.decl.kindt);
22274   if (ffestb_subrargs_.dim_list.dims != NULL)
22275     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22276   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22277   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22278 }
22279
22280 /* ffestb_decl_ents_7_ -- "type" [type parameters] [attributes "::"] NAME
22281                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22282                          [ASTERISK charlength]
22283
22284    return ffestb_decl_ents_7_;  // to lexer
22285
22286    Handle EQUALS, SLASH, COMMA, or EOS/SEMICOLON.  */
22287
22288 static ffelexHandler
22289 ffestb_decl_ents_7_ (ffelexToken t)
22290 {
22291   switch (ffelex_token_type (t))
22292     {
22293     case FFELEX_typeCOMMA:
22294       if (!ffesta_is_inhibited ())
22295         ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22296                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22297                 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22298                           FALSE);
22299       ffelex_token_kill (ffesta_tokens[1]);
22300       if (ffestb_local_.decl.kindt != NULL)
22301         ffelex_token_kill (ffestb_local_.decl.kindt);
22302       if (ffestb_subrargs_.dim_list.dims != NULL)
22303         ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22304       if (ffestb_local_.decl.lent != NULL)
22305         ffelex_token_kill (ffestb_local_.decl.lent);
22306       return (ffelexHandler) ffestb_decl_ents_;
22307
22308     case FFELEX_typeEOS:
22309     case FFELEX_typeSEMICOLON:
22310       if (!ffesta_is_inhibited ())
22311         {
22312           ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22313                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22314                 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22315                             FALSE);
22316           ffestc_decl_finish ();
22317         }
22318       ffelex_token_kill (ffesta_tokens[1]);
22319       if (ffestb_local_.decl.kindt != NULL)
22320         ffelex_token_kill (ffestb_local_.decl.kindt);
22321       if (ffestb_subrargs_.dim_list.dims != NULL)
22322         ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22323       if (ffestb_local_.decl.lent != NULL)
22324         ffelex_token_kill (ffestb_local_.decl.lent);
22325       return (ffelexHandler) ffesta_zero (t);
22326
22327     case FFELEX_typeEQUALS:
22328       if (!ffestb_local_.decl.coloncolon)
22329         ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_INIT, t);
22330       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22331                      ffestb_local_.decl.parameter ? FFEEXPR_contextPARAMETER
22332            : FFEEXPR_contextINITVAL, (ffeexprCallback) ffestb_decl_ents_8_);
22333
22334     case FFELEX_typeSLASH:
22335       if (!ffesta_is_inhibited ())
22336         {
22337           ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22338                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22339                 ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
22340                             TRUE);
22341           ffestc_decl_itemstartvals ();
22342         }
22343       ffelex_token_kill (ffesta_tokens[1]);
22344       if (ffestb_local_.decl.kindt != NULL)
22345         ffelex_token_kill (ffestb_local_.decl.kindt);
22346       if (ffestb_subrargs_.dim_list.dims != NULL)
22347         ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22348       if (ffestb_local_.decl.lent != NULL)
22349         ffelex_token_kill (ffestb_local_.decl.lent);
22350       return (ffelexHandler) ffeexpr_rhs
22351         (ffesta_output_pool, FFEEXPR_contextDATA,
22352          (ffeexprCallback) ffestb_decl_ents_9_);
22353
22354     default:
22355       break;
22356     }
22357
22358   if (!ffesta_is_inhibited ())
22359     ffestc_decl_finish ();
22360   ffelex_token_kill (ffesta_tokens[1]);
22361   if (ffestb_local_.decl.kindt != NULL)
22362     ffelex_token_kill (ffestb_local_.decl.kindt);
22363   if (ffestb_subrargs_.dim_list.dims != NULL)
22364     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22365   if (ffestb_local_.decl.lent != NULL)
22366     ffelex_token_kill (ffestb_local_.decl.lent);
22367   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22368   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22369 }
22370
22371 /* ffestb_decl_ents_8_ -- "type" [type parameters] [attributes "::"] NAME
22372                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22373                          [ASTERISK charlength] EQUALS expr
22374
22375    (ffestb_decl_ents_8_)  // to expression handler
22376
22377    Handle COMMA or EOS/SEMICOLON.  */
22378
22379 static ffelexHandler
22380 ffestb_decl_ents_8_ (ffelexToken ft, ffebld expr, ffelexToken t)
22381 {
22382   switch (ffelex_token_type (t))
22383     {
22384     case FFELEX_typeCOMMA:
22385       if (expr == NULL)
22386         break;
22387       if (!ffesta_is_inhibited ())
22388         ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22389                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22390                   ffestb_local_.decl.len, ffestb_local_.decl.lent, expr, ft,
22391                           FALSE);
22392       ffelex_token_kill (ffesta_tokens[1]);
22393       if (ffestb_local_.decl.kindt != NULL)
22394         ffelex_token_kill (ffestb_local_.decl.kindt);
22395       if (ffestb_subrargs_.dim_list.dims != NULL)
22396         ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22397       if (ffestb_local_.decl.lent != NULL)
22398         ffelex_token_kill (ffestb_local_.decl.lent);
22399       return (ffelexHandler) ffestb_decl_ents_;
22400
22401     case FFELEX_typeEOS:
22402     case FFELEX_typeSEMICOLON:
22403       if (!ffesta_is_inhibited ())
22404         {
22405           ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
22406                    ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
22407                   ffestb_local_.decl.len, ffestb_local_.decl.lent, expr, ft,
22408                             FALSE);
22409           ffestc_decl_finish ();
22410         }
22411       ffelex_token_kill (ffesta_tokens[1]);
22412       if (ffestb_local_.decl.kindt != NULL)
22413         ffelex_token_kill (ffestb_local_.decl.kindt);
22414       if (ffestb_subrargs_.dim_list.dims != NULL)
22415         ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22416       if (ffestb_local_.decl.lent != NULL)
22417         ffelex_token_kill (ffestb_local_.decl.lent);
22418       return (ffelexHandler) ffesta_zero (t);
22419
22420     default:
22421       break;
22422     }
22423
22424   if (!ffesta_is_inhibited ())
22425     ffestc_decl_finish ();
22426   ffelex_token_kill (ffesta_tokens[1]);
22427   if (ffestb_local_.decl.kindt != NULL)
22428     ffelex_token_kill (ffestb_local_.decl.kindt);
22429   if (ffestb_subrargs_.dim_list.dims != NULL)
22430     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
22431   if (ffestb_local_.decl.lent != NULL)
22432     ffelex_token_kill (ffestb_local_.decl.lent);
22433   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22434   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22435 }
22436
22437 /* ffestb_decl_ents_9_ -- "type" ... SLASH expr
22438
22439    (ffestb_decl_ents_9_)  // to expression handler
22440
22441    Handle ASTERISK, COMMA, or SLASH.  */
22442
22443 static ffelexHandler
22444 ffestb_decl_ents_9_ (ffelexToken ft, ffebld expr, ffelexToken t)
22445 {
22446   switch (ffelex_token_type (t))
22447     {
22448     case FFELEX_typeCOMMA:
22449       if (expr == NULL)
22450         break;
22451       if (!ffesta_is_inhibited ())
22452         ffestc_decl_itemvalue (NULL, NULL, expr, ft);
22453       return (ffelexHandler) ffeexpr_rhs
22454         (ffesta_output_pool, FFEEXPR_contextDATA,
22455          (ffeexprCallback) ffestb_decl_ents_9_);
22456
22457     case FFELEX_typeASTERISK:
22458       if (expr == NULL)
22459         break;
22460       ffestb_local_.decl.expr = expr;
22461       ffesta_tokens[1] = ffelex_token_use (ft);
22462       return (ffelexHandler) ffeexpr_rhs
22463         (ffesta_output_pool, FFEEXPR_contextDATA,
22464          (ffeexprCallback) ffestb_decl_ents_10_);
22465
22466     case FFELEX_typeSLASH:
22467       if (expr == NULL)
22468         break;
22469       if (!ffesta_is_inhibited ())
22470         {
22471           ffestc_decl_itemvalue (NULL, NULL, expr, ft);
22472           ffestc_decl_itemendvals (t);
22473         }
22474       return (ffelexHandler) ffestb_decl_ents_11_;
22475
22476     default:
22477       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22478       break;
22479     }
22480
22481   if (!ffesta_is_inhibited ())
22482     {
22483       ffestc_decl_itemendvals (t);
22484       ffestc_decl_finish ();
22485     }
22486   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22487 }
22488
22489 /* ffestb_decl_ents_10_ -- "type" ... SLASH expr ASTERISK expr
22490
22491    (ffestb_decl_ents_10_)  // to expression handler
22492
22493    Handle COMMA or SLASH.  */
22494
22495 static ffelexHandler
22496 ffestb_decl_ents_10_ (ffelexToken ft, ffebld expr, ffelexToken t)
22497 {
22498   switch (ffelex_token_type (t))
22499     {
22500     case FFELEX_typeCOMMA:
22501       if (expr == NULL)
22502         break;
22503       if (!ffesta_is_inhibited ())
22504         ffestc_decl_itemvalue (ffestb_local_.decl.expr, ffesta_tokens[1],
22505                                expr, ft);
22506       ffelex_token_kill (ffesta_tokens[1]);
22507       return (ffelexHandler) ffeexpr_rhs
22508         (ffesta_output_pool, FFEEXPR_contextDATA,
22509          (ffeexprCallback) ffestb_decl_ents_9_);
22510
22511     case FFELEX_typeSLASH:
22512       if (expr == NULL)
22513         break;
22514       if (!ffesta_is_inhibited ())
22515         {
22516           ffestc_decl_itemvalue (ffestb_local_.decl.expr, ffesta_tokens[1],
22517                                  expr, ft);
22518           ffestc_decl_itemendvals (t);
22519         }
22520       ffelex_token_kill (ffesta_tokens[1]);
22521       return (ffelexHandler) ffestb_decl_ents_11_;
22522
22523     default:
22524       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22525       break;
22526     }
22527
22528   if (!ffesta_is_inhibited ())
22529     {
22530       ffestc_decl_itemendvals (t);
22531       ffestc_decl_finish ();
22532     }
22533   ffelex_token_kill (ffesta_tokens[1]);
22534   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22535 }
22536
22537 /* ffestb_decl_ents_11_ -- "type" [type parameters] [attributes "::"] NAME
22538                          [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
22539                          [ASTERISK charlength] SLASH initvals SLASH
22540
22541    return ffestb_decl_ents_11_;  // to lexer
22542
22543    Handle COMMA or EOS/SEMICOLON.  */
22544
22545 static ffelexHandler
22546 ffestb_decl_ents_11_ (ffelexToken t)
22547 {
22548   switch (ffelex_token_type (t))
22549     {
22550     case FFELEX_typeCOMMA:
22551       return (ffelexHandler) ffestb_decl_ents_;
22552
22553     case FFELEX_typeEOS:
22554     case FFELEX_typeSEMICOLON:
22555       if (!ffesta_is_inhibited ())
22556         ffestc_decl_finish ();
22557       return (ffelexHandler) ffesta_zero (t);
22558
22559     default:
22560       break;
22561     }
22562
22563   if (!ffesta_is_inhibited ())
22564     ffestc_decl_finish ();
22565   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22566   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22567 }
22568
22569 /* ffestb_decl_entsp_ -- "type" [type parameters]
22570
22571    return ffestb_decl_entsp_;  // to lexer
22572
22573    Handle NAME or NAMES beginning either an entity (object) declaration or
22574    a function definition..  */
22575
22576 static ffelexHandler
22577 ffestb_decl_entsp_ (ffelexToken t)
22578 {
22579   switch (ffelex_token_type (t))
22580     {
22581     case FFELEX_typeNAME:
22582       ffesta_confirmed ();
22583       ffesta_tokens[1] = ffelex_token_use (t);
22584       return (ffelexHandler) ffestb_decl_entsp_1_;
22585
22586     case FFELEX_typeNAMES:
22587       ffesta_confirmed ();
22588       ffesta_tokens[1] = ffelex_token_use (t);
22589       return (ffelexHandler) ffestb_decl_entsp_2_;
22590
22591     default:
22592       break;
22593     }
22594
22595   if (ffestb_local_.decl.kindt != NULL)
22596     ffelex_token_kill (ffestb_local_.decl.kindt);
22597   if (ffestb_local_.decl.lent != NULL)
22598     ffelex_token_kill (ffestb_local_.decl.lent);
22599   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
22600   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22601 }
22602
22603 /* ffestb_decl_entsp_1_ -- "type" [type parameters] NAME
22604
22605    return ffestb_decl_entsp_1_;  // to lexer
22606
22607    If we get another NAME token here, then the previous one must be
22608    "RECURSIVE" or "FUNCTION" and we handle it accordingly.  Otherwise,
22609    we send the previous and current token through to _ents_.  */
22610
22611 static ffelexHandler
22612 ffestb_decl_entsp_1_ (ffelexToken t)
22613 {
22614   switch (ffelex_token_type (t))
22615     {
22616     case FFELEX_typeNAME:
22617       switch (ffestr_first (ffesta_tokens[1]))
22618         {
22619 #if FFESTR_F90
22620         case FFESTR_firstRECURSIVE:
22621           if (ffestr_first (t) != FFESTR_firstFUNCTION)
22622             {
22623               ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22624               break;
22625             }
22626           ffestb_local_.decl.recursive = ffesta_tokens[1];
22627           return (ffelexHandler) ffestb_decl_funcname_;
22628 #endif
22629
22630         case FFESTR_firstFUNCTION:
22631           ffelex_token_kill (ffesta_tokens[1]);
22632           return (ffelexHandler) ffestb_decl_funcname_ (t);
22633
22634         default:
22635           ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ffesta_tokens[1]);
22636           break;
22637         }
22638       break;
22639
22640     default:
22641       if ((ffelex_token_type (ffesta_tokens[1]) != FFELEX_typeNAMES)
22642           && !ffesta_is_inhibited ())
22643         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
22644                            ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
22645                            ffestb_local_.decl.len, ffestb_local_.decl.lent);
22646       if (ffestb_local_.decl.kindt != NULL)
22647         ffelex_token_kill (ffestb_local_.decl.kindt);
22648       if (ffestb_local_.decl.lent != NULL)
22649         ffelex_token_kill (ffestb_local_.decl.lent);
22650       /* NAME/NAMES token already in ffesta_tokens[1]. */
22651       return (ffelexHandler) ffestb_decl_ents_1_ (t);
22652     }
22653
22654   if (ffestb_local_.decl.kindt != NULL)
22655     ffelex_token_kill (ffestb_local_.decl.kindt);
22656   if (ffestb_local_.decl.lent != NULL)
22657     ffelex_token_kill (ffestb_local_.decl.lent);
22658   ffelex_token_kill (ffesta_tokens[1]);
22659   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22660 }
22661
22662 /* ffestb_decl_entsp_2_ -- "type" [type parameters] NAMES
22663
22664    return ffestb_decl_entsp_2_;  // to lexer
22665
22666    If we get an ASTERISK or OPEN_PAREN here, then if the previous NAMES
22667    begins with "FUNCTION" or "RECURSIVEFUNCTION" and is followed by a
22668    first-name-char, we have a possible syntactically ambiguous situation.
22669    Otherwise, we have a straightforward situation just as if we went
22670    through _entsp_1_ instead of here.  */
22671
22672 static ffelexHandler
22673 ffestb_decl_entsp_2_ (ffelexToken t)
22674 {
22675   ffelexToken nt;
22676   bool asterisk_ok;
22677   unsigned const char *p;
22678   ffeTokenLength i;
22679
22680   switch (ffelex_token_type (t))
22681     {
22682     case FFELEX_typeASTERISK:
22683       ffesta_confirmed ();
22684       switch (ffestb_local_.decl.type)
22685         {
22686         case FFESTP_typeINTEGER:
22687         case FFESTP_typeREAL:
22688         case FFESTP_typeCOMPLEX:
22689         case FFESTP_typeLOGICAL:
22690           asterisk_ok = (ffestb_local_.decl.kindt == NULL);
22691           break;
22692
22693         case FFESTP_typeCHARACTER:
22694           asterisk_ok = (ffestb_local_.decl.lent == NULL);
22695           break;
22696
22697         case FFESTP_typeBYTE:
22698         case FFESTP_typeWORD:
22699         default:
22700           asterisk_ok = FALSE;
22701           break;
22702         }
22703       switch (ffestr_first (ffesta_tokens[1]))
22704         {
22705 #if FFESTR_F90
22706         case FFESTR_firstRECURSIVEFNCTN:
22707           if (!asterisk_ok)
22708             break;              /* For our own convenience, treat as non-FN
22709                                    stmt. */
22710           p = ffelex_token_text (ffesta_tokens[1])
22711             + (i = FFESTR_firstlRECURSIVEFNCTN);
22712           if (!ffesrc_is_name_init (*p))
22713             break;
22714           ffestb_local_.decl.recursive
22715             = ffelex_token_name_from_names (ffesta_tokens[1], 0,
22716                                             FFESTR_firstlRECURSIVEFNCTN);
22717           ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22718                                             FFESTR_firstlRECURSIVEFNCTN, 0);
22719           return (ffelexHandler) ffestb_decl_entsp_3_;
22720 #endif
22721
22722         case FFESTR_firstFUNCTION:
22723           if (!asterisk_ok)
22724             break;              /* For our own convenience, treat as non-FN
22725                                    stmt. */
22726           p = ffelex_token_text (ffesta_tokens[1])
22727             + (i = FFESTR_firstlFUNCTION);
22728           if (!ffesrc_is_name_init (*p))
22729             break;
22730           ffestb_local_.decl.recursive = NULL;
22731           ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22732                                                   FFESTR_firstlFUNCTION, 0);
22733           return (ffelexHandler) ffestb_decl_entsp_3_;
22734
22735         default:
22736           break;
22737         }
22738       break;
22739
22740     case FFELEX_typeOPEN_PAREN:
22741       ffestb_local_.decl.aster_after = FALSE;
22742       switch (ffestr_first (ffesta_tokens[1]))
22743         {
22744 #if FFESTR_F90
22745         case FFESTR_firstRECURSIVEFNCTN:
22746           p = ffelex_token_text (ffesta_tokens[1])
22747             + (i = FFESTR_firstlRECURSIVEFNCTN);
22748           if (!ffesrc_is_name_init (*p))
22749             break;
22750           ffestb_local_.decl.recursive
22751             = ffelex_token_name_from_names (ffesta_tokens[1], 0,
22752                                             FFESTR_firstlRECURSIVEFNCTN);
22753           ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22754                                             FFESTR_firstlRECURSIVEFNCTN, 0);
22755           return (ffelexHandler) ffestb_decl_entsp_5_ (t);
22756 #endif
22757
22758         case FFESTR_firstFUNCTION:
22759           p = ffelex_token_text (ffesta_tokens[1])
22760             + (i = FFESTR_firstlFUNCTION);
22761           if (!ffesrc_is_name_init (*p))
22762             break;
22763           ffestb_local_.decl.recursive = NULL;
22764           ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
22765                                                   FFESTR_firstlFUNCTION, 0);
22766           return (ffelexHandler) ffestb_decl_entsp_5_ (t);
22767
22768         default:
22769           break;
22770         }
22771       if ((ffestb_local_.decl.kindt != NULL)
22772           || (ffestb_local_.decl.lent != NULL))
22773         break;                  /* Have kind/len type param, definitely not
22774                                    assignment stmt. */
22775       return (ffelexHandler) ffestb_decl_entsp_1_ (t);
22776
22777     default:
22778       break;
22779     }
22780
22781   nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
22782   ffelex_token_kill (ffesta_tokens[1]);
22783   ffesta_tokens[1] = nt;        /* Change NAMES to NAME. */
22784   return (ffelexHandler) ffestb_decl_entsp_1_ (t);
22785 }
22786
22787 /* ffestb_decl_entsp_3_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22788                              NAME ASTERISK
22789
22790    return ffestb_decl_entsp_3_;  // to lexer
22791
22792    Handle NUMBER or OPEN_PAREN.  */
22793
22794 static ffelexHandler
22795 ffestb_decl_entsp_3_ (ffelexToken t)
22796 {
22797   ffestb_local_.decl.aster_after = TRUE;
22798
22799   switch (ffelex_token_type (t))
22800     {
22801     case FFELEX_typeNUMBER:
22802       switch (ffestb_local_.decl.type)
22803         {
22804         case FFESTP_typeINTEGER:
22805         case FFESTP_typeREAL:
22806         case FFESTP_typeCOMPLEX:
22807         case FFESTP_typeLOGICAL:
22808           ffestb_local_.decl.kindt = ffelex_token_use (t);
22809           break;
22810
22811         case FFESTP_typeCHARACTER:
22812           ffestb_local_.decl.lent = ffelex_token_use (t);
22813           break;
22814
22815         case FFESTP_typeBYTE:
22816         case FFESTP_typeWORD:
22817         default:
22818           assert (FALSE);
22819         }
22820       return (ffelexHandler) ffestb_decl_entsp_5_;
22821
22822     case FFELEX_typeOPEN_PAREN:
22823       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
22824                                           FFEEXPR_contextCHARACTERSIZE,
22825                                     (ffeexprCallback) ffestb_decl_entsp_4_);
22826
22827     default:
22828       break;
22829     }
22830
22831   if (ffestb_local_.decl.recursive != NULL)
22832     ffelex_token_kill (ffestb_local_.decl.recursive);
22833   if (ffestb_local_.decl.kindt != NULL)
22834     ffelex_token_kill (ffestb_local_.decl.kindt);
22835   if (ffestb_local_.decl.lent != NULL)
22836     ffelex_token_kill (ffestb_local_.decl.lent);
22837   ffelex_token_kill (ffesta_tokens[1]);
22838   ffelex_token_kill (ffesta_tokens[2]);
22839   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22840   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22841 }
22842
22843 /* ffestb_decl_entsp_4_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22844                              NAME ASTERISK OPEN_PAREN expr
22845
22846    (ffestb_decl_entsp_4_)  // to expression handler
22847
22848    Allow only CLOSE_PAREN; and deal with character-length expression.  */
22849
22850 static ffelexHandler
22851 ffestb_decl_entsp_4_ (ffelexToken ft, ffebld expr, ffelexToken t)
22852 {
22853   switch (ffelex_token_type (t))
22854     {
22855     case FFELEX_typeCLOSE_PAREN:
22856       if (expr == NULL)
22857         break;
22858       switch (ffestb_local_.decl.type)
22859         {
22860         case FFESTP_typeCHARACTER:
22861           ffestb_local_.decl.len = expr;
22862           ffestb_local_.decl.lent = ffelex_token_use (ft);
22863           break;
22864
22865         default:
22866           ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22867           break;
22868         }
22869       return (ffelexHandler) ffestb_decl_entsp_5_;
22870
22871     default:
22872       break;
22873     }
22874
22875   if (ffestb_local_.decl.recursive != NULL)
22876     ffelex_token_kill (ffestb_local_.decl.recursive);
22877   if (ffestb_local_.decl.kindt != NULL)
22878     ffelex_token_kill (ffestb_local_.decl.kindt);
22879   if (ffestb_local_.decl.lent != NULL)
22880     ffelex_token_kill (ffestb_local_.decl.lent);
22881   ffelex_token_kill (ffesta_tokens[1]);
22882   ffelex_token_kill (ffesta_tokens[2]);
22883   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
22884   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
22885 }
22886
22887 /* ffestb_decl_entsp_5_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22888                              NAME [type parameter]
22889
22890    return ffestb_decl_entsp_5_;  // to lexer
22891
22892    Make sure the next token is an OPEN_PAREN.  Get the arg list or dimension
22893    list.  If it can't be an arg list, or if the CLOSE_PAREN is followed by
22894    something other than EOS/SEMICOLON or NAME, then treat as dimension list
22895    and handle statement as an R426/R501.  If it can't be a dimension list, or
22896    if the CLOSE_PAREN is followed by NAME, treat as an arg list and handle
22897    statement as an R1219.  If it can be either an arg list or a dimension
22898    list and if the CLOSE_PAREN is followed by EOS/SEMICOLON, ask FFESTC
22899    whether to treat the statement as an R426/R501 or an R1219 and act
22900    accordingly.  */
22901
22902 static ffelexHandler
22903 ffestb_decl_entsp_5_ (ffelexToken t)
22904 {
22905   switch (ffelex_token_type (t))
22906     {
22907     case FFELEX_typeOPEN_PAREN:
22908       if (ffestb_local_.decl.aster_after && (ffestb_local_.decl.len != NULL))
22909         {                       /* "CHARACTER[RECURSIVE]FUNCTIONxyz*(len-expr)
22910                                    (..." must be a function-stmt, since the
22911                                    (len-expr) cannot precede (array-spec) in
22912                                    an object declaration but can precede
22913                                    (name-list) in a function stmt. */
22914           ffelex_token_kill (ffesta_tokens[1]);
22915           ffesta_tokens[1] = ffesta_tokens[2];
22916           return (ffelexHandler) ffestb_decl_funcname_4_ (t);
22917         }
22918       ffestb_local_.decl.toklist = ffestt_tokenlist_create ();
22919       ffestb_local_.decl.empty = TRUE;
22920       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
22921       return (ffelexHandler) ffestb_decl_entsp_6_;
22922
22923     default:
22924       break;
22925     }
22926
22927   assert (ffestb_local_.decl.aster_after);
22928   ffesta_confirmed ();          /* We've seen an ASTERISK, so even EQUALS
22929                                    confirmed. */
22930   ffestb_subr_ambig_to_ents_ ();
22931   ffestb_subrargs_.dim_list.dims = NULL;
22932   return (ffelexHandler) ffestb_decl_ents_7_ (t);
22933 }
22934
22935 /* ffestb_decl_entsp_6_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22936                              NAME [type parameter] OPEN_PAREN
22937
22938    return ffestb_decl_entsp_6_;  // to lexer
22939
22940    If CLOSE_PAREN, we definitely have an R1219 function-stmt, since
22941    the notation "name()" is invalid for a declaration.  */
22942
22943 static ffelexHandler
22944 ffestb_decl_entsp_6_ (ffelexToken t)
22945 {
22946   ffelexHandler next;
22947
22948   switch (ffelex_token_type (t))
22949     {
22950     case FFELEX_typeCLOSE_PAREN:
22951       if (!ffestb_local_.decl.empty)
22952         {                       /* Trailing comma, just a warning for
22953                                    stmt func def, so allow ambiguity. */
22954           ffestt_tokenlist_append (ffestb_local_.decl.toklist,
22955                                    ffelex_token_use (t));
22956           return (ffelexHandler) ffestb_decl_entsp_8_;
22957         }
22958       ffelex_token_kill (ffesta_tokens[1]);
22959       ffesta_tokens[1] = ffesta_tokens[2];
22960       next = (ffelexHandler) ffestt_tokenlist_handle
22961         (ffestb_local_.decl.toklist, (ffelexHandler) ffestb_decl_funcname_4_);
22962       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
22963       return (ffelexHandler) (*next) (t);
22964
22965     case FFELEX_typeNAME:
22966       ffestb_local_.decl.empty = FALSE;
22967       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
22968       return (ffelexHandler) ffestb_decl_entsp_7_;
22969
22970     case FFELEX_typeEQUALS:
22971     case FFELEX_typePOINTS:
22972     case FFELEX_typePERCENT:
22973     case FFELEX_typePERIOD:
22974     case FFELEX_typeOPEN_PAREN:
22975       if ((ffestb_local_.decl.kindt != NULL)
22976           || (ffestb_local_.decl.lent != NULL))
22977         break;                  /* type(params)name or type*val name, either
22978                                    way confirmed. */
22979       return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
22980
22981     default:
22982       break;
22983     }
22984
22985   ffesta_confirmed ();
22986   ffestb_subr_ambig_to_ents_ ();
22987   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
22988                                        (ffelexHandler) ffestb_decl_ents_3_);
22989   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
22990   return (ffelexHandler) (*next) (t);
22991 }
22992
22993 /* ffestb_decl_entsp_7_ -- "type" [type parameters] [RECURSIVE] FUNCTION
22994                              NAME [type parameter] OPEN_PAREN NAME
22995
22996    return ffestb_decl_entsp_7_;  // to lexer
22997
22998    Expect COMMA or CLOSE_PAREN to remain ambiguous, else not an R1219
22999    function-stmt.  */
23000
23001 static ffelexHandler
23002 ffestb_decl_entsp_7_ (ffelexToken t)
23003 {
23004   ffelexHandler next;
23005
23006   switch (ffelex_token_type (t))
23007     {
23008     case FFELEX_typeCLOSE_PAREN:
23009       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
23010       return (ffelexHandler) ffestb_decl_entsp_8_;
23011
23012     case FFELEX_typeCOMMA:
23013       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
23014       return (ffelexHandler) ffestb_decl_entsp_6_;
23015
23016     case FFELEX_typeEQUALS:
23017     case FFELEX_typePOINTS:
23018     case FFELEX_typePERCENT:
23019     case FFELEX_typePERIOD:
23020     case FFELEX_typeOPEN_PAREN:
23021       if ((ffestb_local_.decl.kindt != NULL)
23022           || (ffestb_local_.decl.lent != NULL))
23023         break;                  /* type(params)name or type*val name, either
23024                                    way confirmed. */
23025       return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
23026
23027     default:
23028       break;
23029     }
23030
23031   ffesta_confirmed ();
23032   ffestb_subr_ambig_to_ents_ ();
23033   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
23034                                        (ffelexHandler) ffestb_decl_ents_3_);
23035   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
23036   return (ffelexHandler) (*next) (t);
23037 }
23038
23039 /* ffestb_decl_entsp_8_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23040                              NAME [type parameter] OPEN_PAREN name-list
23041                              CLOSE_PAREN
23042
23043    return ffestb_decl_entsp_8_;  // to lexer
23044
23045    If EOS/SEMICOLON, situation remains ambiguous, ask FFESTC to resolve
23046    it.  If NAME (must be "RESULT", but that is checked later on),
23047    definitely an R1219 function-stmt.  Anything else, handle as entity decl.  */
23048
23049 static ffelexHandler
23050 ffestb_decl_entsp_8_ (ffelexToken t)
23051 {
23052   ffelexHandler next;
23053
23054   switch (ffelex_token_type (t))
23055     {
23056     case FFELEX_typeEOS:
23057     case FFELEX_typeSEMICOLON:
23058       ffesta_confirmed ();
23059       if (ffestc_is_decl_not_R1219 ())
23060         break;
23061       /* Fall through. */
23062     case FFELEX_typeNAME:
23063       ffesta_confirmed ();
23064       ffelex_token_kill (ffesta_tokens[1]);
23065       ffesta_tokens[1] = ffesta_tokens[2];
23066       next = (ffelexHandler) ffestt_tokenlist_handle
23067         (ffestb_local_.decl.toklist, (ffelexHandler) ffestb_decl_funcname_4_);
23068       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
23069       return (ffelexHandler) (*next) (t);
23070
23071     case FFELEX_typeEQUALS:
23072     case FFELEX_typePOINTS:
23073     case FFELEX_typePERCENT:
23074     case FFELEX_typePERIOD:
23075     case FFELEX_typeOPEN_PAREN:
23076       if ((ffestb_local_.decl.kindt != NULL)
23077           || (ffestb_local_.decl.lent != NULL))
23078         break;                  /* type(params)name or type*val name, either
23079                                    way confirmed. */
23080       return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
23081
23082     default:
23083       break;
23084     }
23085
23086   ffesta_confirmed ();
23087   ffestb_subr_ambig_to_ents_ ();
23088   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
23089                                        (ffelexHandler) ffestb_decl_ents_3_);
23090   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
23091   return (ffelexHandler) (*next) (t);
23092 }
23093
23094 /* ffestb_decl_func_ -- ["type" [type parameters]] RECURSIVE
23095
23096    return ffestb_decl_func_;  // to lexer
23097
23098    Handle "FUNCTION".  */
23099
23100 #if FFESTR_F90
23101 static ffelexHandler
23102 ffestb_decl_func_ (ffelexToken t)
23103 {
23104   const char *p;
23105   ffeTokenLength i;
23106
23107   ffelex_set_names (FALSE);
23108
23109   switch (ffelex_token_type (t))
23110     {
23111     case FFELEX_typeNAME:
23112       if (ffestr_first (t) != FFESTR_firstFUNCTION)
23113         break;
23114       return (ffelexHandler) ffestb_decl_funcname_;
23115
23116     case FFELEX_typeNAMES:
23117       ffesta_confirmed ();
23118       if (ffestr_first (t) != FFESTR_firstFUNCTION)
23119         break;
23120       p = ffelex_token_text (t) + (i = FFESTR_firstlFUNCTION);
23121       if (*p == '\0')
23122         break;
23123       if (!ffesrc_is_name_init (*p))
23124         goto bad_i;             /* :::::::::::::::::::: */
23125       ffesta_tokens[1] = ffelex_token_name_from_names (t, i, 0);
23126       return (ffelexHandler) ffestb_decl_funcname_1_;
23127
23128     default:
23129       break;
23130     }
23131
23132   if (ffestb_local_.decl.recursive != NULL)
23133     ffelex_token_kill (ffestb_local_.decl.recursive);
23134   if (ffestb_local_.decl.kindt != NULL)
23135     ffelex_token_kill (ffestb_local_.decl.kindt);
23136   if (ffestb_local_.decl.lent != NULL)
23137     ffelex_token_kill (ffestb_local_.decl.lent);
23138   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23139   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23140
23141 bad_i:                          /* :::::::::::::::::::: */
23142   if (ffestb_local_.decl.recursive != NULL)
23143     ffelex_token_kill (ffestb_local_.decl.recursive);
23144   if (ffestb_local_.decl.kindt != NULL)
23145     ffelex_token_kill (ffestb_local_.decl.kindt);
23146   if (ffestb_local_.decl.lent != NULL)
23147     ffelex_token_kill (ffestb_local_.decl.lent);
23148   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t, i, NULL);
23149   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23150 }
23151
23152 #endif
23153 /* ffestb_decl_funcname_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23154
23155    return ffestb_decl_funcname_;  // to lexer
23156
23157    Handle NAME of a function.  */
23158
23159 static ffelexHandler
23160 ffestb_decl_funcname_ (ffelexToken t)
23161 {
23162   switch (ffelex_token_type (t))
23163     {
23164     case FFELEX_typeNAME:
23165       ffesta_tokens[1] = ffelex_token_use (t);
23166       return (ffelexHandler) ffestb_decl_funcname_1_;
23167
23168     default:
23169       break;
23170     }
23171
23172   if (ffestb_local_.decl.recursive != NULL)
23173     ffelex_token_kill (ffestb_local_.decl.recursive);
23174   if (ffestb_local_.decl.kindt != NULL)
23175     ffelex_token_kill (ffestb_local_.decl.kindt);
23176   if (ffestb_local_.decl.lent != NULL)
23177     ffelex_token_kill (ffestb_local_.decl.lent);
23178   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23179   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23180 }
23181
23182 /* ffestb_decl_funcname_1_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23183                              NAME
23184
23185    return ffestb_decl_funcname_1_;  // to lexer
23186
23187    Handle ASTERISK or OPEN_PAREN.  */
23188
23189 static ffelexHandler
23190 ffestb_decl_funcname_1_ (ffelexToken t)
23191 {
23192   switch (ffelex_token_type (t))
23193     {
23194     case FFELEX_typeASTERISK:
23195       return (ffelexHandler) ffestb_decl_funcname_2_;
23196
23197     case FFELEX_typeOPEN_PAREN:
23198       return (ffelexHandler) ffestb_decl_funcname_4_ (t);
23199
23200     default:
23201       break;
23202     }
23203
23204   if (ffestb_local_.decl.recursive != NULL)
23205     ffelex_token_kill (ffestb_local_.decl.recursive);
23206   if (ffestb_local_.decl.kindt != NULL)
23207     ffelex_token_kill (ffestb_local_.decl.kindt);
23208   if (ffestb_local_.decl.lent != NULL)
23209     ffelex_token_kill (ffestb_local_.decl.lent);
23210   ffelex_token_kill (ffesta_tokens[1]);
23211   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23212   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23213 }
23214
23215 /* ffestb_decl_funcname_2_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23216                              NAME ASTERISK
23217
23218    return ffestb_decl_funcname_2_;  // to lexer
23219
23220    Handle NUMBER or OPEN_PAREN.  */
23221
23222 static ffelexHandler
23223 ffestb_decl_funcname_2_ (ffelexToken t)
23224 {
23225   switch (ffelex_token_type (t))
23226     {
23227     case FFELEX_typeNUMBER:
23228       switch (ffestb_local_.decl.type)
23229         {
23230         case FFESTP_typeINTEGER:
23231         case FFESTP_typeREAL:
23232         case FFESTP_typeCOMPLEX:
23233         case FFESTP_typeLOGICAL:
23234           if (ffestb_local_.decl.kindt == NULL)
23235             ffestb_local_.decl.kindt = ffelex_token_use (t);
23236           else
23237             ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23238           break;
23239
23240         case FFESTP_typeCHARACTER:
23241           if (ffestb_local_.decl.lent == NULL)
23242             ffestb_local_.decl.lent = ffelex_token_use (t);
23243           else
23244             ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23245           break;
23246
23247         case FFESTP_typeBYTE:
23248         case FFESTP_typeWORD:
23249         default:
23250           ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23251           break;
23252         }
23253       return (ffelexHandler) ffestb_decl_funcname_4_;
23254
23255     case FFELEX_typeOPEN_PAREN:
23256       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
23257                                           FFEEXPR_contextCHARACTERSIZE,
23258                                  (ffeexprCallback) ffestb_decl_funcname_3_);
23259
23260     default:
23261       break;
23262     }
23263
23264   if (ffestb_local_.decl.recursive != NULL)
23265     ffelex_token_kill (ffestb_local_.decl.recursive);
23266   if (ffestb_local_.decl.kindt != NULL)
23267     ffelex_token_kill (ffestb_local_.decl.kindt);
23268   if (ffestb_local_.decl.lent != NULL)
23269     ffelex_token_kill (ffestb_local_.decl.lent);
23270   ffelex_token_kill (ffesta_tokens[1]);
23271   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23272   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23273 }
23274
23275 /* ffestb_decl_funcname_3_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23276                              NAME ASTERISK OPEN_PAREN expr
23277
23278    (ffestb_decl_funcname_3_)  // to expression handler
23279
23280    Allow only CLOSE_PAREN; and deal with character-length expression.  */
23281
23282 static ffelexHandler
23283 ffestb_decl_funcname_3_ (ffelexToken ft, ffebld expr, ffelexToken t)
23284 {
23285   switch (ffelex_token_type (t))
23286     {
23287     case FFELEX_typeCLOSE_PAREN:
23288       if (expr == NULL)
23289         break;
23290       switch (ffestb_local_.decl.type)
23291         {
23292         case FFESTP_typeCHARACTER:
23293           if (ffestb_local_.decl.lent == NULL)
23294             {
23295               ffestb_local_.decl.len = expr;
23296               ffestb_local_.decl.lent = ffelex_token_use (ft);
23297             }
23298           else
23299             ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23300           break;
23301
23302         default:
23303           ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23304           break;
23305         }
23306       return (ffelexHandler) ffestb_decl_funcname_4_;
23307
23308     default:
23309       break;
23310     }
23311
23312   if (ffestb_local_.decl.recursive != NULL)
23313     ffelex_token_kill (ffestb_local_.decl.recursive);
23314   if (ffestb_local_.decl.kindt != NULL)
23315     ffelex_token_kill (ffestb_local_.decl.kindt);
23316   if (ffestb_local_.decl.lent != NULL)
23317     ffelex_token_kill (ffestb_local_.decl.lent);
23318   ffelex_token_kill (ffesta_tokens[1]);
23319   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23320   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23321 }
23322
23323 /* ffestb_decl_funcname_4_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23324                              NAME [type parameter]
23325
23326    return ffestb_decl_funcname_4_;  // to lexer
23327
23328    Make sure the next token is an OPEN_PAREN.  Get the arg list and
23329    then implement.  */
23330
23331 static ffelexHandler
23332 ffestb_decl_funcname_4_ (ffelexToken t)
23333 {
23334   switch (ffelex_token_type (t))
23335     {
23336     case FFELEX_typeOPEN_PAREN:
23337       ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
23338       ffestb_subrargs_.name_list.handler
23339         = (ffelexHandler) ffestb_decl_funcname_5_;
23340       ffestb_subrargs_.name_list.is_subr = FALSE;
23341       ffestb_subrargs_.name_list.names = FALSE;
23342       return (ffelexHandler) ffestb_subr_name_list_;
23343
23344     default:
23345       break;
23346     }
23347
23348   if (ffestb_local_.decl.recursive != NULL)
23349     ffelex_token_kill (ffestb_local_.decl.recursive);
23350   if (ffestb_local_.decl.kindt != NULL)
23351     ffelex_token_kill (ffestb_local_.decl.kindt);
23352   if (ffestb_local_.decl.lent != NULL)
23353     ffelex_token_kill (ffestb_local_.decl.lent);
23354   ffelex_token_kill (ffesta_tokens[1]);
23355   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23356   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23357 }
23358
23359 /* ffestb_decl_funcname_5_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23360                              NAME [type parameter] OPEN_PAREN arg-list
23361                              CLOSE_PAREN
23362
23363    return ffestb_decl_funcname_5_;  // to lexer
23364
23365    Must have EOS/SEMICOLON or "RESULT" here.  */
23366
23367 static ffelexHandler
23368 ffestb_decl_funcname_5_ (ffelexToken t)
23369 {
23370   if (!ffestb_subrargs_.name_list.ok)
23371     goto bad;                   /* :::::::::::::::::::: */
23372
23373   switch (ffelex_token_type (t))
23374     {
23375     case FFELEX_typeEOS:
23376     case FFELEX_typeSEMICOLON:
23377       ffesta_confirmed ();
23378       if (!ffesta_is_inhibited ())
23379         ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
23380             ffestb_subrargs_.name_list.close_paren, ffestb_local_.decl.type,
23381                       ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
23382                       ffestb_local_.decl.len, ffestb_local_.decl.lent,
23383                       ffestb_local_.decl.recursive, NULL);
23384       if (ffestb_local_.decl.recursive != NULL)
23385         ffelex_token_kill (ffestb_local_.decl.recursive);
23386       if (ffestb_local_.decl.kindt != NULL)
23387         ffelex_token_kill (ffestb_local_.decl.kindt);
23388       if (ffestb_local_.decl.lent != NULL)
23389         ffelex_token_kill (ffestb_local_.decl.lent);
23390       ffelex_token_kill (ffesta_tokens[1]);
23391       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23392       ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23393       return (ffelexHandler) ffesta_zero (t);
23394
23395     case FFELEX_typeNAME:
23396       if (ffestr_other (t) != FFESTR_otherRESULT)
23397         break;
23398       return (ffelexHandler) ffestb_decl_funcname_6_;
23399
23400     default:
23401       break;
23402     }
23403
23404 bad:                            /* :::::::::::::::::::: */
23405   if (ffestb_local_.decl.recursive != NULL)
23406     ffelex_token_kill (ffestb_local_.decl.recursive);
23407   if (ffestb_local_.decl.kindt != NULL)
23408     ffelex_token_kill (ffestb_local_.decl.kindt);
23409   if (ffestb_local_.decl.lent != NULL)
23410     ffelex_token_kill (ffestb_local_.decl.lent);
23411   ffelex_token_kill (ffesta_tokens[1]);
23412   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23413   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23414   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23415   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23416 }
23417
23418 /* ffestb_decl_funcname_6_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23419                              NAME [type parameter] OPEN_PAREN arglist
23420                              CLOSE_PAREN "RESULT"
23421
23422    return ffestb_decl_funcname_6_;  // to lexer
23423
23424    Make sure the next token is an OPEN_PAREN.  */
23425
23426 static ffelexHandler
23427 ffestb_decl_funcname_6_ (ffelexToken t)
23428 {
23429   switch (ffelex_token_type (t))
23430     {
23431     case FFELEX_typeOPEN_PAREN:
23432       return (ffelexHandler) ffestb_decl_funcname_7_;
23433
23434     default:
23435       break;
23436     }
23437
23438   if (ffestb_local_.decl.recursive != NULL)
23439     ffelex_token_kill (ffestb_local_.decl.recursive);
23440   if (ffestb_local_.decl.kindt != NULL)
23441     ffelex_token_kill (ffestb_local_.decl.kindt);
23442   if (ffestb_local_.decl.lent != NULL)
23443     ffelex_token_kill (ffestb_local_.decl.lent);
23444   ffelex_token_kill (ffesta_tokens[1]);
23445   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23446   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23447   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23448   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23449 }
23450
23451 /* ffestb_decl_funcname_7_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23452                              NAME [type parameter] OPEN_PAREN arglist
23453                              CLOSE_PAREN "RESULT" OPEN_PAREN
23454
23455    return ffestb_decl_funcname_7_;  // to lexer
23456
23457    Make sure the next token is a NAME.  */
23458
23459 static ffelexHandler
23460 ffestb_decl_funcname_7_ (ffelexToken t)
23461 {
23462   switch (ffelex_token_type (t))
23463     {
23464     case FFELEX_typeNAME:
23465       ffesta_tokens[2] = ffelex_token_use (t);
23466       return (ffelexHandler) ffestb_decl_funcname_8_;
23467
23468     default:
23469       break;
23470     }
23471
23472   if (ffestb_local_.decl.recursive != NULL)
23473     ffelex_token_kill (ffestb_local_.decl.recursive);
23474   if (ffestb_local_.decl.kindt != NULL)
23475     ffelex_token_kill (ffestb_local_.decl.kindt);
23476   if (ffestb_local_.decl.lent != NULL)
23477     ffelex_token_kill (ffestb_local_.decl.lent);
23478   ffelex_token_kill (ffesta_tokens[1]);
23479   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23480   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23481   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23482   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23483 }
23484
23485 /* ffestb_decl_funcname_8_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23486                              NAME [type parameter] OPEN_PAREN arglist
23487                              CLOSE_PAREN "RESULT" OPEN_PAREN NAME
23488
23489    return ffestb_decl_funcname_8_;  // to lexer
23490
23491    Make sure the next token is a CLOSE_PAREN.  */
23492
23493 static ffelexHandler
23494 ffestb_decl_funcname_8_ (ffelexToken t)
23495 {
23496   switch (ffelex_token_type (t))
23497     {
23498     case FFELEX_typeCLOSE_PAREN:
23499       return (ffelexHandler) ffestb_decl_funcname_9_;
23500
23501     default:
23502       break;
23503     }
23504
23505   if (ffestb_local_.decl.recursive != NULL)
23506     ffelex_token_kill (ffestb_local_.decl.recursive);
23507   if (ffestb_local_.decl.kindt != NULL)
23508     ffelex_token_kill (ffestb_local_.decl.kindt);
23509   if (ffestb_local_.decl.lent != NULL)
23510     ffelex_token_kill (ffestb_local_.decl.lent);
23511   ffelex_token_kill (ffesta_tokens[1]);
23512   ffelex_token_kill (ffesta_tokens[2]);
23513   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23514   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23515   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23516   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23517 }
23518
23519 /* ffestb_decl_funcname_9_ -- "type" [type parameters] [RECURSIVE] FUNCTION
23520                              NAME [type parameter] OPEN_PAREN arg-list
23521                              CLOSE_PAREN "RESULT" OPEN_PAREN NAME CLOSE_PAREN
23522
23523    return ffestb_decl_funcname_9_;  // to lexer
23524
23525    Must have EOS/SEMICOLON here.  */
23526
23527 static ffelexHandler
23528 ffestb_decl_funcname_9_ (ffelexToken t)
23529 {
23530   switch (ffelex_token_type (t))
23531     {
23532     case FFELEX_typeEOS:
23533     case FFELEX_typeSEMICOLON:
23534       if (!ffesta_is_inhibited ())
23535         ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
23536             ffestb_subrargs_.name_list.close_paren, ffestb_local_.decl.type,
23537                       ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
23538                       ffestb_local_.decl.len, ffestb_local_.decl.lent,
23539                       ffestb_local_.decl.recursive, ffesta_tokens[2]);
23540       if (ffestb_local_.decl.recursive != NULL)
23541         ffelex_token_kill (ffestb_local_.decl.recursive);
23542       if (ffestb_local_.decl.kindt != NULL)
23543         ffelex_token_kill (ffestb_local_.decl.kindt);
23544       if (ffestb_local_.decl.lent != NULL)
23545         ffelex_token_kill (ffestb_local_.decl.lent);
23546       ffelex_token_kill (ffesta_tokens[1]);
23547       ffelex_token_kill (ffesta_tokens[2]);
23548       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23549       ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23550       return (ffelexHandler) ffesta_zero (t);
23551
23552     default:
23553       break;
23554     }
23555
23556   if (ffestb_local_.decl.recursive != NULL)
23557     ffelex_token_kill (ffestb_local_.decl.recursive);
23558   if (ffestb_local_.decl.kindt != NULL)
23559     ffelex_token_kill (ffestb_local_.decl.kindt);
23560   if (ffestb_local_.decl.lent != NULL)
23561     ffelex_token_kill (ffestb_local_.decl.lent);
23562   ffelex_token_kill (ffesta_tokens[1]);
23563   ffelex_token_kill (ffesta_tokens[2]);
23564   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
23565   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
23566   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
23567   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23568 }
23569
23570 /* ffestb_V003 -- Parse the STRUCTURE statement
23571
23572    return ffestb_V003;  // to lexer
23573
23574    Make sure the statement has a valid form for the STRUCTURE statement.
23575    If it does, implement the statement.  */
23576
23577 #if FFESTR_VXT
23578 ffelexHandler
23579 ffestb_V003 (ffelexToken t)
23580 {
23581   ffeTokenLength i;
23582   const char *p;
23583   ffelexToken nt;
23584   ffelexHandler next;
23585
23586   switch (ffelex_token_type (ffesta_tokens[0]))
23587     {
23588     case FFELEX_typeNAME:
23589       if (ffesta_first_kw != FFESTR_firstSTRUCTURE)
23590         goto bad_0;             /* :::::::::::::::::::: */
23591       switch (ffelex_token_type (t))
23592         {
23593         case FFELEX_typeCOMMA:
23594         case FFELEX_typeCOLONCOLON:
23595         case FFELEX_typeEOS:
23596         case FFELEX_typeSEMICOLON:
23597           ffesta_confirmed ();  /* Error, but clearly intended. */
23598           goto bad_1;           /* :::::::::::::::::::: */
23599
23600         default:
23601           goto bad_1;           /* :::::::::::::::::::: */
23602
23603         case FFELEX_typeNAME:
23604           ffesta_confirmed ();
23605           if (!ffesta_is_inhibited ())
23606             ffestc_V003_start (NULL);
23607           ffestb_local_.structure.started = TRUE;
23608           return (ffelexHandler) ffestb_V0034_ (t);
23609
23610         case FFELEX_typeSLASH:
23611           ffesta_confirmed ();
23612           return (ffelexHandler) ffestb_V0031_;
23613         }
23614
23615     case FFELEX_typeNAMES:
23616       if (ffesta_first_kw != FFESTR_firstSTRUCTURE)
23617         goto bad_0;             /* :::::::::::::::::::: */
23618       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSTRUCTURE);
23619       switch (ffelex_token_type (t))
23620         {
23621         default:
23622           goto bad_1;           /* :::::::::::::::::::: */
23623
23624         case FFELEX_typeEOS:
23625         case FFELEX_typeSEMICOLON:
23626         case FFELEX_typeCOMMA:
23627         case FFELEX_typeCOLONCOLON:
23628           ffesta_confirmed ();
23629           break;
23630
23631         case FFELEX_typeSLASH:
23632           ffesta_confirmed ();
23633           if (*p != '\0')
23634             goto bad_1;         /* :::::::::::::::::::: */
23635           return (ffelexHandler) ffestb_V0031_;
23636
23637         case FFELEX_typeOPEN_PAREN:
23638           break;
23639         }
23640
23641       /* Here, we have at least one char after "STRUCTURE" and t is COMMA,
23642          EOS/SEMICOLON, or OPEN_PAREN. */
23643
23644       if (!ffesrc_is_name_init (*p))
23645         goto bad_i;             /* :::::::::::::::::::: */
23646       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
23647       if (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN)
23648         ffestb_local_.structure.started = FALSE;
23649       else
23650         {
23651           if (!ffesta_is_inhibited ())
23652             ffestc_V003_start (NULL);
23653           ffestb_local_.structure.started = TRUE;
23654         }
23655       next = (ffelexHandler) ffestb_V0034_ (nt);
23656       ffelex_token_kill (nt);
23657       return (ffelexHandler) (*next) (t);
23658
23659     default:
23660       goto bad_0;               /* :::::::::::::::::::: */
23661     }
23662
23663 bad_0:                          /* :::::::::::::::::::: */
23664   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", ffesta_tokens[0]);
23665   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23666
23667 bad_1:                          /* :::::::::::::::::::: */
23668   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23669   return (ffelexHandler) ffelex_swallow_tokens (t,
23670                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
23671
23672 bad_i:                          /* :::::::::::::::::::: */
23673   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", ffesta_tokens[0], i, t);
23674   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23675 }
23676
23677 /* ffestb_V0031_ -- "STRUCTURE" SLASH
23678
23679    return ffestb_V0031_;  // to lexer
23680
23681    Handle NAME.  */
23682
23683 static ffelexHandler
23684 ffestb_V0031_ (ffelexToken t)
23685 {
23686   switch (ffelex_token_type (t))
23687     {
23688     case FFELEX_typeNAME:
23689       ffesta_tokens[1] = ffelex_token_use (t);
23690       return (ffelexHandler) ffestb_V0032_;
23691
23692     default:
23693       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23694       break;
23695     }
23696
23697   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23698 }
23699
23700 /* ffestb_V0032_ -- "STRUCTURE" SLASH NAME
23701
23702    return ffestb_V0032_;  // to lexer
23703
23704    Handle SLASH.  */
23705
23706 static ffelexHandler
23707 ffestb_V0032_ (ffelexToken t)
23708 {
23709   switch (ffelex_token_type (t))
23710     {
23711     case FFELEX_typeSLASH:
23712       if (!ffesta_is_inhibited ())
23713         ffestc_V003_start (ffesta_tokens[1]);
23714       ffestb_local_.structure.started = TRUE;
23715       ffelex_token_kill (ffesta_tokens[1]);
23716       return (ffelexHandler) ffestb_V0033_;
23717
23718     default:
23719       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23720       break;
23721     }
23722
23723   ffelex_token_kill (ffesta_tokens[1]);
23724   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23725 }
23726
23727 /* ffestb_V0033_ -- "STRUCTURE" SLASH NAME SLASH
23728
23729    return ffestb_V0033_;  // to lexer
23730
23731    Handle NAME or EOS/SEMICOLON.  */
23732
23733 static ffelexHandler
23734 ffestb_V0033_ (ffelexToken t)
23735 {
23736   switch (ffelex_token_type (t))
23737     {
23738     case FFELEX_typeNAME:
23739       return (ffelexHandler) ffestb_V0034_ (t);
23740
23741     case FFELEX_typeEOS:
23742     case FFELEX_typeSEMICOLON:
23743       if (!ffesta_is_inhibited ())
23744         ffestc_V003_finish ();
23745       return (ffelexHandler) ffesta_zero (t);
23746
23747     default:
23748       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23749       break;
23750     }
23751
23752   ffelex_token_kill (ffesta_tokens[1]);
23753   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23754 }
23755
23756 /* ffestb_V0034_ -- "STRUCTURE" [SLASH NAME SLASH]
23757
23758    return ffestb_V0034_;  // to lexer
23759
23760    Handle NAME.  */
23761
23762 static ffelexHandler
23763 ffestb_V0034_ (ffelexToken t)
23764 {
23765   switch (ffelex_token_type (t))
23766     {
23767     case FFELEX_typeNAME:
23768       ffesta_tokens[1] = ffelex_token_use (t);
23769       return (ffelexHandler) ffestb_V0035_;
23770
23771     default:
23772       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23773       break;
23774     }
23775
23776   if (!ffesta_is_inhibited ())
23777     ffestc_V003_finish ();
23778   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23779 }
23780
23781 /* ffestb_V0035_ -- "STRUCTURE" ... NAME
23782
23783    return ffestb_V0035_;  // to lexer
23784
23785    Handle OPEN_PAREN.  */
23786
23787 static ffelexHandler
23788 ffestb_V0035_ (ffelexToken t)
23789 {
23790   switch (ffelex_token_type (t))
23791     {
23792     case FFELEX_typeOPEN_PAREN:
23793       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
23794       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_V0036_;
23795       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
23796       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
23797 #ifdef FFECOM_dimensionsMAX
23798       ffestb_subrargs_.dim_list.ndims = 0;
23799 #endif
23800       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
23801       FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
23802
23803     case FFELEX_typeCOMMA:
23804       if (!ffesta_is_inhibited ())
23805         ffestc_V003_item (ffesta_tokens[1], NULL);
23806       ffelex_token_kill (ffesta_tokens[1]);
23807       return (ffelexHandler) ffestb_V0034_;
23808
23809     case FFELEX_typeEOS:
23810     case FFELEX_typeSEMICOLON:
23811       if (!ffesta_is_inhibited ())
23812         {
23813           ffestc_V003_item (ffesta_tokens[1], NULL);
23814           ffestc_V003_finish ();
23815         }
23816       ffelex_token_kill (ffesta_tokens[1]);
23817       return (ffelexHandler) ffesta_zero (t);
23818
23819     default:
23820       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23821       break;
23822     }
23823
23824   if (!ffesta_is_inhibited ())
23825     ffestc_V003_finish ();
23826   ffelex_token_kill (ffesta_tokens[1]);
23827   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23828 }
23829
23830 /* ffestb_V0036_ -- "STRUCTURE" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
23831
23832    return ffestb_V0036_;  // to lexer
23833
23834    Handle COMMA or EOS/SEMICOLON.  */
23835
23836 static ffelexHandler
23837 ffestb_V0036_ (ffelexToken t)
23838 {
23839   if (!ffestb_subrargs_.dim_list.ok)
23840     goto bad;                   /* :::::::::::::::::::: */
23841
23842   switch (ffelex_token_type (t))
23843     {
23844     case FFELEX_typeCOMMA:
23845       ffesta_confirmed ();
23846       if (!ffesta_is_inhibited ())
23847         {
23848           if (!ffestb_local_.structure.started)
23849             {
23850               ffestc_V003_start (NULL);
23851               ffestb_local_.structure.started = TRUE;
23852             }
23853           ffestc_V003_item (ffesta_tokens[1],
23854                             ffestb_subrargs_.dim_list.dims);
23855         }
23856       ffelex_token_kill (ffesta_tokens[1]);
23857       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
23858       return (ffelexHandler) ffestb_V0034_;
23859
23860     case FFELEX_typeEOS:
23861     case FFELEX_typeSEMICOLON:
23862       ffesta_confirmed ();
23863       if (!ffesta_is_inhibited ())
23864         {
23865           if (!ffestb_local_.structure.started)
23866             ffestc_V003_start (NULL);
23867           ffestc_V003_item (ffesta_tokens[1],
23868                             ffestb_subrargs_.dim_list.dims);
23869           ffestc_V003_finish ();
23870         }
23871       ffelex_token_kill (ffesta_tokens[1]);
23872       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
23873       return (ffelexHandler) ffesta_zero (t);
23874
23875     default:
23876       break;
23877     }
23878
23879 bad:                            /* :::::::::::::::::::: */
23880   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
23881   if (ffestb_local_.structure.started && !ffesta_is_inhibited ())
23882     ffestc_V003_finish ();
23883   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
23884   ffelex_token_kill (ffesta_tokens[1]);
23885   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23886 }
23887
23888 /* ffestb_V016 -- Parse the RECORD statement
23889
23890    return ffestb_V016;  // to lexer
23891
23892    Make sure the statement has a valid form for the RECORD statement.  If it
23893    does, implement the statement.  */
23894
23895 ffelexHandler
23896 ffestb_V016 (ffelexToken t)
23897 {
23898   const char *p;
23899   ffeTokenLength i;
23900
23901   switch (ffelex_token_type (ffesta_tokens[0]))
23902     {
23903     case FFELEX_typeNAME:
23904       if (ffesta_first_kw != FFESTR_firstRECORD)
23905         goto bad_0;             /* :::::::::::::::::::: */
23906       break;
23907
23908     case FFELEX_typeNAMES:
23909       if (ffesta_first_kw != FFESTR_firstRECORD)
23910         goto bad_0;             /* :::::::::::::::::::: */
23911       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlRECORD);
23912       if (*p != '\0')
23913         goto bad_i;             /* :::::::::::::::::::: */
23914       break;
23915
23916     default:
23917       goto bad_0;               /* :::::::::::::::::::: */
23918     }
23919
23920   switch (ffelex_token_type (t))
23921     {
23922     case FFELEX_typeCOMMA:
23923     case FFELEX_typeEOS:
23924     case FFELEX_typeSEMICOLON:
23925     case FFELEX_typeCOLONCOLON:
23926       ffesta_confirmed ();      /* Error, but clearly intended. */
23927       goto bad_1;               /* :::::::::::::::::::: */
23928
23929     default:
23930       goto bad_1;               /* :::::::::::::::::::: */
23931
23932     case FFELEX_typeSLASH:
23933       break;
23934     }
23935
23936   ffesta_confirmed ();
23937   if (!ffesta_is_inhibited ())
23938     ffestc_V016_start ();
23939   return (ffelexHandler) ffestb_V0161_;
23940
23941 bad_0:                          /* :::::::::::::::::::: */
23942   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", ffesta_tokens[0]);
23943   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23944
23945 bad_1:                          /* :::::::::::::::::::: */
23946   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
23947   return (ffelexHandler) ffelex_swallow_tokens (t,
23948                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
23949
23950 bad_i:                          /* :::::::::::::::::::: */
23951   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "RECORD", ffesta_tokens[0], i, t);
23952   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23953 }
23954
23955 /* ffestb_V0161_ -- "RECORD" SLASH
23956
23957    return ffestb_V0161_;  // to lexer
23958
23959    Handle NAME.  */
23960
23961 static ffelexHandler
23962 ffestb_V0161_ (ffelexToken t)
23963 {
23964   switch (ffelex_token_type (t))
23965     {
23966     case FFELEX_typeNAME:
23967       if (!ffesta_is_inhibited ())
23968         ffestc_V016_item_structure (t);
23969       return (ffelexHandler) ffestb_V0162_;
23970
23971     default:
23972       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
23973       break;
23974     }
23975
23976   if (!ffesta_is_inhibited ())
23977     ffestc_V016_finish ();
23978   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
23979 }
23980
23981 /* ffestb_V0162_ -- "RECORD" SLASH NAME
23982
23983    return ffestb_V0162_;  // to lexer
23984
23985    Handle SLASH.  */
23986
23987 static ffelexHandler
23988 ffestb_V0162_ (ffelexToken t)
23989 {
23990   switch (ffelex_token_type (t))
23991     {
23992     case FFELEX_typeSLASH:
23993       return (ffelexHandler) ffestb_V0163_;
23994
23995     default:
23996       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
23997       break;
23998     }
23999
24000   if (!ffesta_is_inhibited ())
24001     ffestc_V016_finish ();
24002   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24003 }
24004
24005 /* ffestb_V0163_ -- "RECORD" SLASH NAME SLASH
24006
24007    return ffestb_V0163_;  // to lexer
24008
24009    Handle NAME.  */
24010
24011 static ffelexHandler
24012 ffestb_V0163_ (ffelexToken t)
24013 {
24014   switch (ffelex_token_type (t))
24015     {
24016     case FFELEX_typeNAME:
24017       ffesta_tokens[1] = ffelex_token_use (t);
24018       return (ffelexHandler) ffestb_V0164_;
24019
24020     default:
24021       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24022       break;
24023     }
24024
24025   if (!ffesta_is_inhibited ())
24026     ffestc_V016_finish ();
24027   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24028 }
24029
24030 /* ffestb_V0164_ -- "RECORD" ... NAME
24031
24032    return ffestb_V0164_;  // to lexer
24033
24034    Handle OPEN_PAREN.  */
24035
24036 static ffelexHandler
24037 ffestb_V0164_ (ffelexToken t)
24038 {
24039   switch (ffelex_token_type (t))
24040     {
24041     case FFELEX_typeOPEN_PAREN:
24042       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
24043       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_V0165_;
24044       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
24045       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
24046 #ifdef FFECOM_dimensionsMAX
24047       ffestb_subrargs_.dim_list.ndims = 0;
24048 #endif
24049       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
24050       FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
24051
24052     case FFELEX_typeCOMMA:
24053       if (!ffesta_is_inhibited ())
24054         ffestc_V016_item_object (ffesta_tokens[1], NULL);
24055       ffelex_token_kill (ffesta_tokens[1]);
24056       return (ffelexHandler) ffestb_V0166_;
24057
24058     case FFELEX_typeEOS:
24059     case FFELEX_typeSEMICOLON:
24060       if (!ffesta_is_inhibited ())
24061         {
24062           ffestc_V016_item_object (ffesta_tokens[1], NULL);
24063           ffestc_V016_finish ();
24064         }
24065       ffelex_token_kill (ffesta_tokens[1]);
24066       return (ffelexHandler) ffesta_zero (t);
24067
24068     default:
24069       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24070       break;
24071     }
24072
24073   if (!ffesta_is_inhibited ())
24074     ffestc_V016_finish ();
24075   ffelex_token_kill (ffesta_tokens[1]);
24076   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24077 }
24078
24079 /* ffestb_V0165_ -- "RECORD" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
24080
24081    return ffestb_V0165_;  // to lexer
24082
24083    Handle COMMA or EOS/SEMICOLON.  */
24084
24085 static ffelexHandler
24086 ffestb_V0165_ (ffelexToken t)
24087 {
24088   if (!ffestb_subrargs_.dim_list.ok)
24089     goto bad;                   /* :::::::::::::::::::: */
24090
24091   switch (ffelex_token_type (t))
24092     {
24093     case FFELEX_typeCOMMA:
24094       if (!ffesta_is_inhibited ())
24095         ffestc_V016_item_object (ffesta_tokens[1],
24096                                  ffestb_subrargs_.dim_list.dims);
24097       ffelex_token_kill (ffesta_tokens[1]);
24098       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
24099       return (ffelexHandler) ffestb_V0166_;
24100
24101     case FFELEX_typeEOS:
24102     case FFELEX_typeSEMICOLON:
24103       if (!ffesta_is_inhibited ())
24104         {
24105           ffestc_V016_item_object (ffesta_tokens[1],
24106                                    ffestb_subrargs_.dim_list.dims);
24107           ffestc_V016_finish ();
24108         }
24109       ffelex_token_kill (ffesta_tokens[1]);
24110       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
24111       return (ffelexHandler) ffesta_zero (t);
24112
24113     default:
24114       break;
24115     }
24116
24117 bad:                            /* :::::::::::::::::::: */
24118   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24119   if (ffestb_local_.structure.started && !ffesta_is_inhibited ())
24120     ffestc_V016_finish ();
24121   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
24122   ffelex_token_kill (ffesta_tokens[1]);
24123   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24124 }
24125
24126 /* ffestb_V0166_ -- "RECORD" SLASH NAME SLASH NAME [OPEN_PAREN dimlist
24127                     CLOSE_PAREN] COMMA
24128
24129    return ffestb_V0166_;  // to lexer
24130
24131    Handle NAME or SLASH.  */
24132
24133 static ffelexHandler
24134 ffestb_V0166_ (ffelexToken t)
24135 {
24136   switch (ffelex_token_type (t))
24137     {
24138     case FFELEX_typeNAME:
24139       ffesta_tokens[1] = ffelex_token_use (t);
24140       return (ffelexHandler) ffestb_V0164_;
24141
24142     case FFELEX_typeSLASH:
24143       return (ffelexHandler) ffestb_V0161_;
24144
24145     default:
24146       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
24147       break;
24148     }
24149
24150   if (!ffesta_is_inhibited ())
24151     ffestc_V016_finish ();
24152   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24153 }
24154
24155 #endif
24156 /* ffestb_V027 -- Parse the VXT PARAMETER statement
24157
24158    return ffestb_V027;  // to lexer
24159
24160    Make sure the statement has a valid form for the VXT PARAMETER statement.
24161    If it does, implement the statement.  */
24162
24163 ffelexHandler
24164 ffestb_V027 (ffelexToken t)
24165 {
24166   unsigned const char *p;
24167   ffeTokenLength i;
24168
24169   switch (ffelex_token_type (ffesta_tokens[0]))
24170     {
24171     case FFELEX_typeNAME:
24172       if (ffesta_first_kw != FFESTR_firstPARAMETER)
24173         goto bad_0;             /* :::::::::::::::::::: */
24174       switch (ffelex_token_type (t))
24175         {
24176         case FFELEX_typeNAME:
24177           break;
24178
24179         default:
24180           goto bad_1;           /* :::::::::::::::::::: */
24181         }
24182       ffesta_confirmed ();
24183       ffestb_local_.vxtparam.started = TRUE;
24184       if (!ffesta_is_inhibited ())
24185         ffestc_V027_start ();
24186       ffesta_tokens[1] = ffelex_token_use (t);
24187       return (ffelexHandler) ffestb_V0271_;
24188
24189     case FFELEX_typeNAMES:
24190       if (ffesta_first_kw != FFESTR_firstPARAMETER)
24191         goto bad_0;             /* :::::::::::::::::::: */
24192       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlPARAMETER);
24193       switch (ffelex_token_type (t))
24194         {
24195         case FFELEX_typeEQUALS:
24196           break;
24197
24198         default:
24199           goto bad_1;           /* :::::::::::::::::::: */
24200         }
24201       if (!ffesrc_is_name_init (*p))
24202         goto bad_i;             /* :::::::::::::::::::: */
24203       ffestb_local_.vxtparam.started = FALSE;
24204       ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i,
24205                                                        0);
24206       return (ffelexHandler) ffestb_V0271_ (t);
24207
24208     default:
24209       goto bad_0;               /* :::::::::::::::::::: */
24210     }
24211
24212 bad_0:                          /* :::::::::::::::::::: */
24213   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0]);
24214   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24215
24216 bad_1:                          /* :::::::::::::::::::: */
24217   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24218   return (ffelexHandler) ffelex_swallow_tokens (t,
24219                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
24220
24221 bad_i:                          /* :::::::::::::::::::: */
24222   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0], i, t);
24223   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24224 }
24225
24226 /* ffestb_V0271_ -- "PARAMETER" NAME
24227
24228    return ffestb_V0271_;  // to lexer
24229
24230    Handle EQUALS.  */
24231
24232 static ffelexHandler
24233 ffestb_V0271_ (ffelexToken t)
24234 {
24235   switch (ffelex_token_type (t))
24236     {
24237     case FFELEX_typeEQUALS:
24238       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
24239                  FFEEXPR_contextPARAMETER, (ffeexprCallback) ffestb_V0272_);
24240
24241     default:
24242       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24243       break;
24244     }
24245
24246   ffelex_token_kill (ffesta_tokens[1]);
24247   if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
24248     ffestc_V027_finish ();
24249   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24250 }
24251
24252 /* ffestb_V0272_ -- "PARAMETER" NAME EQUALS expr
24253
24254    (ffestb_V0272_)  // to expression handler
24255
24256    Handle COMMA or EOS/SEMICOLON.  */
24257
24258 static ffelexHandler
24259 ffestb_V0272_ (ffelexToken ft, ffebld expr, ffelexToken t)
24260 {
24261   switch (ffelex_token_type (t))
24262     {
24263     case FFELEX_typeEOS:
24264     case FFELEX_typeSEMICOLON:
24265       if (!ffestb_local_.vxtparam.started)
24266         {
24267           if (ffestc_is_let_not_V027 ())
24268             break;              /* Not a valid VXTPARAMETER stmt. */
24269           ffesta_confirmed ();
24270           if (!ffesta_is_inhibited ())
24271             ffestc_V027_start ();
24272           ffestb_local_.vxtparam.started = TRUE;
24273         }
24274       if (expr == NULL)
24275         break;
24276       if (!ffesta_is_inhibited ())
24277         {
24278           ffestc_V027_item (ffesta_tokens[1], expr, ft);
24279           ffestc_V027_finish ();
24280         }
24281       ffelex_token_kill (ffesta_tokens[1]);
24282       return (ffelexHandler) ffesta_zero (t);
24283
24284     case FFELEX_typeCOMMA:
24285       ffesta_confirmed ();
24286       if (!ffestb_local_.vxtparam.started)
24287         {
24288           if (!ffesta_is_inhibited ())
24289             ffestc_V027_start ();
24290           ffestb_local_.vxtparam.started = TRUE;
24291         }
24292       if (expr == NULL)
24293         break;
24294       if (!ffesta_is_inhibited ())
24295         ffestc_V027_item (ffesta_tokens[1], expr, ft);
24296       ffelex_token_kill (ffesta_tokens[1]);
24297       return (ffelexHandler) ffestb_V0273_;
24298
24299     default:
24300       break;
24301     }
24302
24303   ffelex_token_kill (ffesta_tokens[1]);
24304   if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
24305     ffestc_V027_finish ();
24306   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24307   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24308 }
24309
24310 /* ffestb_V0273_ -- "PARAMETER" NAME EQUALS expr COMMA
24311
24312    return ffestb_V0273_;  // to lexer
24313
24314    Handle NAME.  */
24315
24316 static ffelexHandler
24317 ffestb_V0273_ (ffelexToken t)
24318 {
24319   switch (ffelex_token_type (t))
24320     {
24321     case FFELEX_typeNAME:
24322       ffesta_tokens[1] = ffelex_token_use (t);
24323       return (ffelexHandler) ffestb_V0271_;
24324
24325     default:
24326       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
24327       break;
24328     }
24329
24330   if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
24331     ffestc_V027_finish ();
24332   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24333 }
24334
24335 /* ffestb_decl_R539 -- Parse the IMPLICIT FUNCTION statement
24336
24337    return ffestb_decl_R539;  // to lexer
24338
24339    Make sure the statement has a valid form for the IMPLICIT
24340    statement.  If it does, implement the statement.  */
24341
24342 ffelexHandler
24343 ffestb_decl_R539 (ffelexToken t)
24344 {
24345   ffeTokenLength i;
24346   unsigned const char *p;
24347   ffelexToken nt;
24348   ffestrSecond kw;
24349
24350   ffestb_local_.decl.recursive = NULL;
24351
24352   switch (ffelex_token_type (ffesta_tokens[0]))
24353     {
24354     case FFELEX_typeNAME:
24355       if (ffesta_first_kw != FFESTR_firstIMPLICIT)
24356         goto bad_0;             /* :::::::::::::::::::: */
24357       switch (ffelex_token_type (t))
24358         {
24359         case FFELEX_typeEOS:
24360         case FFELEX_typeSEMICOLON:
24361         case FFELEX_typeCOMMA:
24362         case FFELEX_typeCOLONCOLON:
24363           ffesta_confirmed ();  /* Error, but clearly intended. */
24364           goto bad_1;           /* :::::::::::::::::::: */
24365
24366         default:
24367           goto bad_1;           /* :::::::::::::::::::: */
24368
24369         case FFELEX_typeNAME:
24370           break;
24371         }
24372       ffesta_confirmed ();
24373       ffestb_local_.decl.imp_started = FALSE;
24374       switch (ffesta_second_kw)
24375         {
24376         case FFESTR_secondINTEGER:
24377           ffestb_local_.decl.type = FFESTP_typeINTEGER;
24378           return (ffelexHandler) ffestb_decl_R5391_;
24379
24380         case FFESTR_secondBYTE:
24381           ffestb_local_.decl.type = FFESTP_typeBYTE;
24382           return (ffelexHandler) ffestb_decl_R5391_;
24383
24384         case FFESTR_secondWORD:
24385           ffestb_local_.decl.type = FFESTP_typeWORD;
24386           return (ffelexHandler) ffestb_decl_R5391_;
24387
24388         case FFESTR_secondREAL:
24389           ffestb_local_.decl.type = FFESTP_typeREAL;
24390           return (ffelexHandler) ffestb_decl_R5391_;
24391
24392         case FFESTR_secondCOMPLEX:
24393           ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
24394           return (ffelexHandler) ffestb_decl_R5391_;
24395
24396         case FFESTR_secondLOGICAL:
24397           ffestb_local_.decl.type = FFESTP_typeLOGICAL;
24398           return (ffelexHandler) ffestb_decl_R5391_;
24399
24400         case FFESTR_secondCHARACTER:
24401           ffestb_local_.decl.type = FFESTP_typeCHARACTER;
24402           return (ffelexHandler) ffestb_decl_R5391_;
24403
24404         case FFESTR_secondDOUBLE:
24405           return (ffelexHandler) ffestb_decl_R5392_;
24406
24407         case FFESTR_secondDOUBLEPRECISION:
24408           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24409           ffestb_local_.decl.kind = NULL;
24410           ffestb_local_.decl.kindt = NULL;
24411           ffestb_local_.decl.len = NULL;
24412           ffestb_local_.decl.lent = NULL;
24413           return (ffelexHandler) ffestb_decl_R539letters_;
24414
24415         case FFESTR_secondDOUBLECOMPLEX:
24416           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24417           ffestb_local_.decl.kind = NULL;
24418           ffestb_local_.decl.kindt = NULL;
24419           ffestb_local_.decl.len = NULL;
24420           ffestb_local_.decl.lent = NULL;
24421           return (ffelexHandler) ffestb_decl_R539letters_;
24422
24423         case FFESTR_secondNONE:
24424           return (ffelexHandler) ffestb_decl_R5394_;
24425
24426 #if FFESTR_F90
24427         case FFESTR_secondTYPE:
24428           ffestb_local_.decl.type = FFESTP_typeTYPE;
24429           return (ffelexHandler) ffestb_decl_R5393_;
24430 #endif
24431
24432         default:
24433           goto bad_1;           /* :::::::::::::::::::: */
24434         }
24435
24436     case FFELEX_typeNAMES:
24437       if (ffesta_first_kw != FFESTR_firstIMPLICIT)
24438         goto bad_0;             /* :::::::::::::::::::: */
24439       switch (ffelex_token_type (t))
24440         {
24441         case FFELEX_typeCOMMA:
24442         case FFELEX_typeCOLONCOLON:
24443         case FFELEX_typeASTERISK:
24444         case FFELEX_typeSEMICOLON:
24445         case FFELEX_typeEOS:
24446           ffesta_confirmed ();
24447           break;
24448
24449         case FFELEX_typeOPEN_PAREN:
24450           break;
24451
24452         default:
24453           goto bad_1;           /* :::::::::::::::::::: */
24454         }
24455       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlIMPLICIT);
24456       if (!ffesrc_is_name_init (*p))
24457         goto bad_0;             /* :::::::::::::::::::: */
24458       ffestb_local_.decl.imp_started = FALSE;
24459       nt = ffelex_token_name_from_names (ffesta_tokens[0],
24460                                          FFESTR_firstlIMPLICIT, 0);
24461       kw = ffestr_second (nt);
24462       ffelex_token_kill (nt);
24463       switch (kw)
24464         {
24465         case FFESTR_secondINTEGER:
24466           ffestb_local_.decl.type = FFESTP_typeINTEGER;
24467           return (ffelexHandler) ffestb_decl_R5391_ (t);
24468
24469         case FFESTR_secondBYTE:
24470           ffestb_local_.decl.type = FFESTP_typeBYTE;
24471           return (ffelexHandler) ffestb_decl_R5391_ (t);
24472
24473         case FFESTR_secondWORD:
24474           ffestb_local_.decl.type = FFESTP_typeWORD;
24475           return (ffelexHandler) ffestb_decl_R5391_ (t);
24476
24477         case FFESTR_secondREAL:
24478           ffestb_local_.decl.type = FFESTP_typeREAL;
24479           return (ffelexHandler) ffestb_decl_R5391_ (t);
24480
24481         case FFESTR_secondCOMPLEX:
24482           ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
24483           return (ffelexHandler) ffestb_decl_R5391_ (t);
24484
24485         case FFESTR_secondLOGICAL:
24486           ffestb_local_.decl.type = FFESTP_typeLOGICAL;
24487           return (ffelexHandler) ffestb_decl_R5391_ (t);
24488
24489         case FFESTR_secondCHARACTER:
24490           ffestb_local_.decl.type = FFESTP_typeCHARACTER;
24491           return (ffelexHandler) ffestb_decl_R5391_ (t);
24492
24493         case FFESTR_secondDOUBLEPRECISION:
24494           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24495           ffestb_local_.decl.kind = NULL;
24496           ffestb_local_.decl.kindt = NULL;
24497           ffestb_local_.decl.len = NULL;
24498           ffestb_local_.decl.lent = NULL;
24499           return (ffelexHandler) ffestb_decl_R539letters_ (t);
24500
24501         case FFESTR_secondDOUBLECOMPLEX:
24502           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24503           ffestb_local_.decl.kind = NULL;
24504           ffestb_local_.decl.kindt = NULL;
24505           ffestb_local_.decl.len = NULL;
24506           ffestb_local_.decl.lent = NULL;
24507           return (ffelexHandler) ffestb_decl_R539letters_ (t);
24508
24509         case FFESTR_secondNONE:
24510           return (ffelexHandler) ffestb_decl_R5394_ (t);
24511
24512 #if FFESTR_F90
24513         case FFESTR_secondTYPE:
24514           ffestb_local_.decl.type = FFESTP_typeTYPE;
24515           return (ffelexHandler) ffestb_decl_R5393_ (t);
24516 #endif
24517
24518         default:
24519           goto bad_1;           /* :::::::::::::::::::: */
24520         }
24521
24522     default:
24523       goto bad_0;               /* :::::::::::::::::::: */
24524     }
24525
24526 bad_0:                          /* :::::::::::::::::::: */
24527   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", ffesta_tokens[0]);
24528   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24529
24530 bad_1:                          /* :::::::::::::::::::: */
24531   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24532   return (ffelexHandler) ffelex_swallow_tokens (t,
24533                                                 (ffelexHandler) ffesta_zero);   /* Invalid second token. */
24534 }
24535
24536 /* ffestb_decl_R5391_ -- "IMPLICIT" generic-type
24537
24538    return ffestb_decl_R5391_;  // to lexer
24539
24540    Handle ASTERISK or OPEN_PAREN.  */
24541
24542 static ffelexHandler
24543 ffestb_decl_R5391_ (ffelexToken t)
24544 {
24545   switch (ffelex_token_type (t))
24546     {
24547     case FFELEX_typeASTERISK:
24548       ffesta_confirmed ();
24549       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
24550       ffestb_local_.decl.badname = "IMPLICIT";
24551       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
24552         return (ffelexHandler) ffestb_decl_starlen_;
24553       return (ffelexHandler) ffestb_decl_starkind_;
24554
24555     case FFELEX_typeOPEN_PAREN:
24556       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
24557       ffestb_local_.decl.badname = "IMPLICIT";
24558       ffestb_local_.decl.kind = NULL;
24559       ffestb_local_.decl.kindt = NULL;
24560       ffestb_local_.decl.len = NULL;
24561       ffestb_local_.decl.lent = NULL;
24562       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
24563         ffestb_local_.decl.imp_handler
24564           = (ffelexHandler) ffestb_decl_typeparams_;
24565       else
24566         ffestb_local_.decl.imp_handler
24567           = (ffelexHandler) ffestb_decl_kindparam_;
24568       return (ffelexHandler) ffestb_decl_R539maybe_ (t);
24569
24570     default:
24571       break;
24572     }
24573
24574   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24575     ffestc_R539finish ();
24576   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24577   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24578 }
24579
24580 /* ffestb_decl_R5392_ -- "IMPLICIT" "DOUBLE"
24581
24582    return ffestb_decl_R5392_;  // to lexer
24583
24584    Handle NAME.  */
24585
24586 static ffelexHandler
24587 ffestb_decl_R5392_ (ffelexToken t)
24588 {
24589   switch (ffelex_token_type (t))
24590     {
24591     case FFELEX_typeNAME:
24592       switch (ffestr_second (t))
24593         {
24594         case FFESTR_secondPRECISION:
24595           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24596           break;
24597
24598         case FFESTR_secondCOMPLEX:
24599           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24600           break;
24601
24602         default:
24603           goto bad;             /* :::::::::::::::::::: */
24604         }
24605       ffestb_local_.decl.kind = NULL;
24606       ffestb_local_.decl.kindt = NULL;
24607       ffestb_local_.decl.len = NULL;
24608       ffestb_local_.decl.lent = NULL;
24609       return (ffelexHandler) ffestb_decl_R539letters_;
24610
24611     default:
24612       break;
24613     }
24614
24615 bad:                            /* :::::::::::::::::::: */
24616   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24617     ffestc_R539finish ();
24618   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24619   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24620 }
24621
24622 /* ffestb_decl_R5393_ -- "IMPLICIT" "TYPE"
24623
24624    return ffestb_decl_R5393_;  // to lexer
24625
24626    Handle OPEN_PAREN.  */
24627
24628 #if FFESTR_F90
24629 static ffelexHandler
24630 ffestb_decl_R5393_ (ffelexToken t)
24631 {
24632   switch (ffelex_token_type (t))
24633     {
24634     case FFELEX_typeOPEN_PAREN:
24635       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
24636       ffestb_local_.decl.badname = "IMPLICIT";
24637       return (ffelexHandler) ffestb_decl_typetype1_;
24638
24639     default:
24640       break;
24641     }
24642
24643   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24644     ffestc_R539finish ();
24645   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24646   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24647 }
24648
24649 #endif
24650 /* ffestb_decl_R5394_ -- "IMPLICIT" "NONE"
24651
24652    return ffestb_decl_R5394_;  // to lexer
24653
24654    Handle EOS/SEMICOLON.  */
24655
24656 static ffelexHandler
24657 ffestb_decl_R5394_ (ffelexToken t)
24658 {
24659   switch (ffelex_token_type (t))
24660     {
24661     case FFELEX_typeEOS:
24662     case FFELEX_typeSEMICOLON:
24663       ffesta_confirmed ();
24664       if (!ffesta_is_inhibited ())
24665         ffestc_R539 ();         /* IMPLICIT NONE. */
24666       return (ffelexHandler) ffesta_zero (t);
24667
24668     default:
24669       break;
24670     }
24671
24672   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24673   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24674 }
24675
24676 /* ffestb_decl_R5395_ -- "IMPLICIT" implicit-spec-list COMMA
24677
24678    return ffestb_decl_R5395_;  // to lexer
24679
24680    Handle NAME for next type-spec.  */
24681
24682 static ffelexHandler
24683 ffestb_decl_R5395_ (ffelexToken t)
24684 {
24685   switch (ffelex_token_type (t))
24686     {
24687     case FFELEX_typeNAME:
24688       switch (ffestr_second (t))
24689         {
24690         case FFESTR_secondINTEGER:
24691           ffestb_local_.decl.type = FFESTP_typeINTEGER;
24692           return (ffelexHandler) ffestb_decl_R5391_;
24693
24694         case FFESTR_secondBYTE:
24695           ffestb_local_.decl.type = FFESTP_typeBYTE;
24696           return (ffelexHandler) ffestb_decl_R5391_;
24697
24698         case FFESTR_secondWORD:
24699           ffestb_local_.decl.type = FFESTP_typeWORD;
24700           return (ffelexHandler) ffestb_decl_R5391_;
24701
24702         case FFESTR_secondREAL:
24703           ffestb_local_.decl.type = FFESTP_typeREAL;
24704           return (ffelexHandler) ffestb_decl_R5391_;
24705
24706         case FFESTR_secondCOMPLEX:
24707           ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
24708           return (ffelexHandler) ffestb_decl_R5391_;
24709
24710         case FFESTR_secondLOGICAL:
24711           ffestb_local_.decl.type = FFESTP_typeLOGICAL;
24712           return (ffelexHandler) ffestb_decl_R5391_;
24713
24714         case FFESTR_secondCHARACTER:
24715           ffestb_local_.decl.type = FFESTP_typeCHARACTER;
24716           return (ffelexHandler) ffestb_decl_R5391_;
24717
24718         case FFESTR_secondDOUBLE:
24719           return (ffelexHandler) ffestb_decl_R5392_;
24720
24721         case FFESTR_secondDOUBLEPRECISION:
24722           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
24723           ffestb_local_.decl.kind = NULL;
24724           ffestb_local_.decl.kindt = NULL;
24725           ffestb_local_.decl.len = NULL;
24726           ffestb_local_.decl.lent = NULL;
24727           return (ffelexHandler) ffestb_decl_R539letters_;
24728
24729         case FFESTR_secondDOUBLECOMPLEX:
24730           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
24731           ffestb_local_.decl.kind = NULL;
24732           ffestb_local_.decl.kindt = NULL;
24733           ffestb_local_.decl.len = NULL;
24734           ffestb_local_.decl.lent = NULL;
24735           return (ffelexHandler) ffestb_decl_R539letters_;
24736
24737 #if FFESTR_F90
24738         case FFESTR_secondTYPE:
24739           ffestb_local_.decl.type = FFESTP_typeTYPE;
24740           return (ffelexHandler) ffestb_decl_R5393_;
24741 #endif
24742
24743         default:
24744           break;
24745         }
24746       break;
24747
24748     default:
24749       break;
24750     }
24751
24752   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24753     ffestc_R539finish ();
24754   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24755   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24756 }
24757
24758 /* ffestb_decl_R539letters_ -- "IMPLICIT" type-spec
24759
24760    return ffestb_decl_R539letters_;  // to lexer
24761
24762    Handle OPEN_PAREN.  */
24763
24764 static ffelexHandler
24765 ffestb_decl_R539letters_ (ffelexToken t)
24766 {
24767   ffelex_set_names (FALSE);
24768
24769   switch (ffelex_token_type (t))
24770     {
24771     case FFELEX_typeOPEN_PAREN:
24772       ffestb_local_.decl.imps = ffestt_implist_create ();
24773       return (ffelexHandler) ffestb_decl_R539letters_1_;
24774
24775     default:
24776       break;
24777     }
24778
24779   if (ffestb_local_.decl.kindt != NULL)
24780     ffelex_token_kill (ffestb_local_.decl.kindt);
24781   if (ffestb_local_.decl.lent != NULL)
24782     ffelex_token_kill (ffestb_local_.decl.lent);
24783   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24784     ffestc_R539finish ();
24785   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24786   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24787 }
24788
24789 /* ffestb_decl_R539letters_1_ -- "IMPLICIT" type-spec OPEN_PAREN
24790
24791    return ffestb_decl_R539letters_1_;  // to lexer
24792
24793    Handle NAME.  */
24794
24795 static ffelexHandler
24796 ffestb_decl_R539letters_1_ (ffelexToken t)
24797 {
24798   switch (ffelex_token_type (t))
24799     {
24800     case FFELEX_typeNAME:
24801       if (ffelex_token_length (t) != 1)
24802         break;
24803       ffesta_tokens[1] = ffelex_token_use (t);
24804       return (ffelexHandler) ffestb_decl_R539letters_2_;
24805
24806     default:
24807       break;
24808     }
24809
24810   ffestt_implist_kill (ffestb_local_.decl.imps);
24811   if (ffestb_local_.decl.kindt != NULL)
24812     ffelex_token_kill (ffestb_local_.decl.kindt);
24813   if (ffestb_local_.decl.lent != NULL)
24814     ffelex_token_kill (ffestb_local_.decl.lent);
24815   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24816     ffestc_R539finish ();
24817   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24818   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24819 }
24820
24821 /* ffestb_decl_R539letters_2_ -- "IMPLICIT" type-spec OPEN_PAREN NAME
24822
24823    return ffestb_decl_R539letters_2_;  // to lexer
24824
24825    Handle COMMA or MINUS.  */
24826
24827 static ffelexHandler
24828 ffestb_decl_R539letters_2_ (ffelexToken t)
24829 {
24830   switch (ffelex_token_type (t))
24831     {
24832     case FFELEX_typeCOMMA:
24833       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
24834       return (ffelexHandler) ffestb_decl_R539letters_1_;
24835
24836     case FFELEX_typeCLOSE_PAREN:
24837       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
24838       return (ffelexHandler) ffestb_decl_R539letters_5_;
24839
24840     case FFELEX_typeMINUS:
24841       return (ffelexHandler) ffestb_decl_R539letters_3_;
24842
24843     default:
24844       break;
24845     }
24846
24847   ffelex_token_kill (ffesta_tokens[1]);
24848   ffestt_implist_kill (ffestb_local_.decl.imps);
24849   if (ffestb_local_.decl.kindt != NULL)
24850     ffelex_token_kill (ffestb_local_.decl.kindt);
24851   if (ffestb_local_.decl.lent != NULL)
24852     ffelex_token_kill (ffestb_local_.decl.lent);
24853   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24854     ffestc_R539finish ();
24855   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24856   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24857 }
24858
24859 /* ffestb_decl_R539letters_3_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
24860
24861    return ffestb_decl_R539letters_3_;  // to lexer
24862
24863    Handle NAME.  */
24864
24865 static ffelexHandler
24866 ffestb_decl_R539letters_3_ (ffelexToken t)
24867 {
24868   switch (ffelex_token_type (t))
24869     {
24870     case FFELEX_typeNAME:
24871       if (ffelex_token_length (t) != 1)
24872         break;
24873       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1],
24874                              ffelex_token_use (t));
24875       return (ffelexHandler) ffestb_decl_R539letters_4_;
24876
24877     default:
24878       break;
24879     }
24880
24881   ffelex_token_kill (ffesta_tokens[1]);
24882   ffestt_implist_kill (ffestb_local_.decl.imps);
24883   if (ffestb_local_.decl.kindt != NULL)
24884     ffelex_token_kill (ffestb_local_.decl.kindt);
24885   if (ffestb_local_.decl.lent != NULL)
24886     ffelex_token_kill (ffestb_local_.decl.lent);
24887   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24888     ffestc_R539finish ();
24889   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24890   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24891 }
24892
24893 /* ffestb_decl_R539letters_4_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
24894                                  NAME
24895
24896    return ffestb_decl_R539letters_4_;  // to lexer
24897
24898    Handle COMMA or CLOSE_PAREN.  */
24899
24900 static ffelexHandler
24901 ffestb_decl_R539letters_4_ (ffelexToken t)
24902 {
24903   switch (ffelex_token_type (t))
24904     {
24905     case FFELEX_typeCOMMA:
24906       return (ffelexHandler) ffestb_decl_R539letters_1_;
24907
24908     case FFELEX_typeCLOSE_PAREN:
24909       return (ffelexHandler) ffestb_decl_R539letters_5_;
24910
24911     default:
24912       break;
24913     }
24914
24915   ffestt_implist_kill (ffestb_local_.decl.imps);
24916   if (ffestb_local_.decl.kindt != NULL)
24917     ffelex_token_kill (ffestb_local_.decl.kindt);
24918   if (ffestb_local_.decl.lent != NULL)
24919     ffelex_token_kill (ffestb_local_.decl.lent);
24920   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24921     ffestc_R539finish ();
24922   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24923   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24924 }
24925
24926 /* ffestb_decl_R539letters_5_ -- "IMPLICIT" type-spec OPEN_PAREN
24927                                  letter-spec-list CLOSE_PAREN
24928
24929    return ffestb_decl_R539letters_5_;  // to lexer
24930
24931    Handle COMMA or EOS/SEMICOLON.  */
24932
24933 static ffelexHandler
24934 ffestb_decl_R539letters_5_ (ffelexToken t)
24935 {
24936   switch (ffelex_token_type (t))
24937     {
24938     case FFELEX_typeCOMMA:
24939     case FFELEX_typeEOS:
24940     case FFELEX_typeSEMICOLON:
24941       if (!ffestb_local_.decl.imp_started)
24942         {
24943           ffestb_local_.decl.imp_started = TRUE;
24944           ffesta_confirmed ();
24945           if (!ffesta_is_inhibited ())
24946             ffestc_R539start ();
24947         }
24948       if (!ffesta_is_inhibited ())
24949         ffestc_R539item (ffestb_local_.decl.type, ffestb_local_.decl.kind,
24950                          ffestb_local_.decl.kindt, ffestb_local_.decl.len,
24951                          ffestb_local_.decl.lent, ffestb_local_.decl.imps);
24952       if (ffestb_local_.decl.kindt != NULL)
24953         ffelex_token_kill (ffestb_local_.decl.kindt);
24954       if (ffestb_local_.decl.lent != NULL)
24955         ffelex_token_kill (ffestb_local_.decl.lent);
24956       ffestt_implist_kill (ffestb_local_.decl.imps);
24957       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
24958         return (ffelexHandler) ffestb_decl_R5395_;
24959       if (!ffesta_is_inhibited ())
24960         ffestc_R539finish ();
24961       return (ffelexHandler) ffesta_zero (t);
24962
24963     default:
24964       break;
24965     }
24966
24967   ffestt_implist_kill (ffestb_local_.decl.imps);
24968   if (ffestb_local_.decl.kindt != NULL)
24969     ffelex_token_kill (ffestb_local_.decl.kindt);
24970   if (ffestb_local_.decl.lent != NULL)
24971     ffelex_token_kill (ffestb_local_.decl.lent);
24972   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
24973     ffestc_R539finish ();
24974   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
24975   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
24976 }
24977
24978 /* ffestb_decl_R539maybe_ -- "IMPLICIT" generic-type-spec
24979
24980    return ffestb_decl_R539maybe_;  // to lexer
24981
24982    Handle OPEN_PAREN.  */
24983
24984 static ffelexHandler
24985 ffestb_decl_R539maybe_ (ffelexToken t)
24986 {
24987   assert (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN);
24988   ffestb_local_.decl.imps = ffestt_implist_create ();
24989   ffestb_local_.decl.toklist = ffestt_tokenlist_create ();
24990   ffestb_local_.decl.imp_seen_comma
24991     = (ffestb_local_.decl.type != FFESTP_typeCHARACTER);
24992   return (ffelexHandler) ffestb_decl_R539maybe_1_;
24993 }
24994
24995 /* ffestb_decl_R539maybe_1_ -- "IMPLICIT" generic-type-spec OPEN_PAREN
24996
24997    return ffestb_decl_R539maybe_1_;  // to lexer
24998
24999    Handle NAME.  */
25000
25001 static ffelexHandler
25002 ffestb_decl_R539maybe_1_ (ffelexToken t)
25003 {
25004   ffelexHandler next;
25005
25006   switch (ffelex_token_type (t))
25007     {
25008     case FFELEX_typeNAME:
25009       if (ffelex_token_length (t) != 1)
25010         break;
25011       ffesta_tokens[1] = ffelex_token_use (t);
25012       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25013       return (ffelexHandler) ffestb_decl_R539maybe_2_;
25014
25015     default:
25016       break;
25017     }
25018
25019   ffestt_implist_kill (ffestb_local_.decl.imps);
25020   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25021                             (ffelexHandler) ffestb_local_.decl.imp_handler);
25022   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25023   return (ffelexHandler) (*next) (t);
25024 }
25025
25026 /* ffestb_decl_R539maybe_2_ -- "IMPLICIT" generic-type-spec OPEN_PAREN NAME
25027
25028    return ffestb_decl_R539maybe_2_;  // to lexer
25029
25030    Handle COMMA or MINUS.  */
25031
25032 static ffelexHandler
25033 ffestb_decl_R539maybe_2_ (ffelexToken t)
25034 {
25035   ffelexHandler next;
25036
25037   switch (ffelex_token_type (t))
25038     {
25039     case FFELEX_typeCOMMA:
25040       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
25041       if (ffestb_local_.decl.imp_seen_comma)
25042         {
25043           ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25044           return (ffelexHandler) ffestb_decl_R539letters_1_;
25045         }
25046       ffestb_local_.decl.imp_seen_comma = TRUE;
25047       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25048       return (ffelexHandler) ffestb_decl_R539maybe_1_;
25049
25050     case FFELEX_typeCLOSE_PAREN:
25051       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
25052       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25053       return (ffelexHandler) ffestb_decl_R539maybe_5_;
25054
25055     case FFELEX_typeMINUS:
25056       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25057       return (ffelexHandler) ffestb_decl_R539maybe_3_;
25058
25059     default:
25060       break;
25061     }
25062
25063   ffelex_token_kill (ffesta_tokens[1]);
25064   ffestt_implist_kill (ffestb_local_.decl.imps);
25065   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25066                             (ffelexHandler) ffestb_local_.decl.imp_handler);
25067   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25068   return (ffelexHandler) (*next) (t);
25069 }
25070
25071 /* ffestb_decl_R539maybe_3_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
25072
25073    return ffestb_decl_R539maybe_3_;  // to lexer
25074
25075    Handle NAME.  */
25076
25077 static ffelexHandler
25078 ffestb_decl_R539maybe_3_ (ffelexToken t)
25079 {
25080   ffelexHandler next;
25081
25082   switch (ffelex_token_type (t))
25083     {
25084     case FFELEX_typeNAME:
25085       if (ffelex_token_length (t) != 1)
25086         break;
25087       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1],
25088                              ffelex_token_use (t));
25089       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25090       return (ffelexHandler) ffestb_decl_R539maybe_4_;
25091
25092     default:
25093       break;
25094     }
25095
25096   ffelex_token_kill (ffesta_tokens[1]);
25097   ffestt_implist_kill (ffestb_local_.decl.imps);
25098   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25099                             (ffelexHandler) ffestb_local_.decl.imp_handler);
25100   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25101   return (ffelexHandler) (*next) (t);
25102 }
25103
25104 /* ffestb_decl_R539maybe_4_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
25105                                  NAME
25106
25107    return ffestb_decl_R539maybe_4_;  // to lexer
25108
25109    Handle COMMA or CLOSE_PAREN.  */
25110
25111 static ffelexHandler
25112 ffestb_decl_R539maybe_4_ (ffelexToken t)
25113 {
25114   ffelexHandler next;
25115
25116   switch (ffelex_token_type (t))
25117     {
25118     case FFELEX_typeCOMMA:
25119       if (ffestb_local_.decl.imp_seen_comma)
25120         {
25121           ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25122           return (ffelexHandler) ffestb_decl_R539letters_1_;
25123         }
25124       ffestb_local_.decl.imp_seen_comma = TRUE;
25125       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25126       return (ffelexHandler) ffestb_decl_R539maybe_1_;
25127
25128     case FFELEX_typeCLOSE_PAREN:
25129       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
25130       return (ffelexHandler) ffestb_decl_R539maybe_5_;
25131
25132     default:
25133       break;
25134     }
25135
25136   ffestt_implist_kill (ffestb_local_.decl.imps);
25137   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25138                             (ffelexHandler) ffestb_local_.decl.imp_handler);
25139   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25140   return (ffelexHandler) (*next) (t);
25141 }
25142
25143 /* ffestb_decl_R539maybe_5_ -- "IMPLICIT" type-spec OPEN_PAREN
25144                                  letter-spec-list CLOSE_PAREN
25145
25146    return ffestb_decl_R539maybe_5_;  // to lexer
25147
25148    Handle COMMA or EOS/SEMICOLON.  */
25149
25150 static ffelexHandler
25151 ffestb_decl_R539maybe_5_ (ffelexToken t)
25152 {
25153   ffelexHandler next;
25154
25155   switch (ffelex_token_type (t))
25156     {
25157     case FFELEX_typeCOMMA:
25158     case FFELEX_typeEOS:
25159     case FFELEX_typeSEMICOLON:
25160       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25161       if (!ffestb_local_.decl.imp_started)
25162         {
25163           ffestb_local_.decl.imp_started = TRUE;
25164           ffesta_confirmed ();
25165           if (!ffesta_is_inhibited ())
25166             ffestc_R539start ();
25167         }
25168       if (!ffesta_is_inhibited ())
25169         ffestc_R539item (ffestb_local_.decl.type, ffestb_local_.decl.kind,
25170                          ffestb_local_.decl.kindt, ffestb_local_.decl.len,
25171                          ffestb_local_.decl.lent, ffestb_local_.decl.imps);
25172       if (ffestb_local_.decl.kindt != NULL)
25173         ffelex_token_kill (ffestb_local_.decl.kindt);
25174       if (ffestb_local_.decl.lent != NULL)
25175         ffelex_token_kill (ffestb_local_.decl.lent);
25176       ffestt_implist_kill (ffestb_local_.decl.imps);
25177       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
25178         return (ffelexHandler) ffestb_decl_R5395_;
25179       if (!ffesta_is_inhibited ())
25180         ffestc_R539finish ();
25181       return (ffelexHandler) ffesta_zero (t);
25182
25183     case FFELEX_typeOPEN_PAREN:
25184       ffesta_confirmed ();
25185       ffestt_implist_kill (ffestb_local_.decl.imps);
25186       next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
25187                             (ffelexHandler) ffestb_local_.decl.imp_handler);
25188       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25189       return (ffelexHandler) (*next) (t);
25190
25191     default:
25192       break;
25193     }
25194
25195   ffestt_implist_kill (ffestb_local_.decl.imps);
25196   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
25197   if (ffestb_local_.decl.kindt != NULL)
25198     ffelex_token_kill (ffestb_local_.decl.kindt);
25199   if (ffestb_local_.decl.lent != NULL)
25200     ffelex_token_kill (ffestb_local_.decl.lent);
25201   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
25202     ffestc_R539finish ();
25203   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
25204   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
25205 }