home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / g77-0.5.15-src.tgz / tar.out / fsf / g77 / f / stb.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  716KB  |  25,023 lines
  1. /* stb.c -- Implementation File (module.c template V1.0)
  2.    Copyright (C) 1995 Free Software Foundation, Inc.
  3.    Contributed by James Craig Burley (burley@gnu.ai.mit.edu).
  4.  
  5. This file is part of GNU Fortran.
  6.  
  7. GNU Fortran is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11.  
  12. GNU Fortran is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU Fortran; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21.    Related Modules:
  22.       st.c
  23.  
  24.    Description:
  25.       Parses the proper form for statements, builds up expression trees for
  26.       them, but does not actually implement them.  Uses ffebad (primarily via
  27.       ffesta_ffebad_start) to indicate errors in form.    In many cases, an invalid
  28.       statement form indicates another possible statement needs to be looked at
  29.       by ffest.     In a few cases, a valid statement form might not completely
  30.       determine the nature of the statement, as in REALFUNCTIONA(B), which is
  31.       a valid form for either the first statement of a function named A taking
  32.       an argument named B or for the declaration of a real array named FUNCTIONA
  33.       with an adjustable size of B.  A similar (though somewhat easier) choice
  34.       must be made for the statement-function-def vs. assignment forms, as in
  35.       the case of FOO(A) = A+2.0.
  36.  
  37.       A given parser consists of one or more state handlers, the first of which
  38.       is the initial state, and the last of which (for any given input) returns
  39.       control to a final state handler (ffesta_zero or ffesta_two, explained
  40.       below).  The functions handling the states for a given parser usually have
  41.       the same names, differing only in the final number, as in ffestb_foo_
  42.       (handles the initial state), ffestb_foo_1_, ffestb_foo_2_ (handle
  43.       subsequent states), although liberties sometimes are taken with the "foo"
  44.       part either when keywords are clarified into given statements or are
  45.       transferred into other possible areas.  (For example, the type-name
  46.       states can hop over to _dummy_ functions when the FUNCTION or RECURSIVE
  47.       keywords are seen, though this kind of thing is kept to a minimum.)  Only
  48.       the names without numbers are exported to the rest of ffest; the others
  49.       are local (static).
  50.  
  51.       Each initial state is provided with the first token in ffesta_tokens[0],
  52.       which will be killed upon return to the final state (ffesta_zero or
  53.       ffelex_swallow_tokens passed through to ffesta_zero), so while it may
  54.       be changed to another token, a valid token must be left there to be
  55.       killed.  Also, a "convenient" array of tokens are left in
  56.       ffesta_tokens[1..FFESTA_tokensMAX].  The initial state of this set of
  57.       elements is undefined, thus, if tokens are stored here, they must be
  58.       killed before returning to the final state.  Any parser may also use
  59.       cross-state local variables by sticking a structure containing storage
  60.       for those variables in the local union ffestb_local_ (unless the union
  61.       goes on strike).    Furthermore, parsers that handle more than one first or
  62.       second tokens (like _varlist_, which handles EXTERNAL, INTENT, INTRINSIC,
  63.       OPTIONAL,
  64.       PUBLIC, or PRIVATE, and _endxyz_, which handles ENDBLOCK, ENDBLOCKDATA,
  65.       ENDDO, ENDIF, and so on) may expect arguments from ffest in the
  66.       ffest-wide union ffest_args_, the substructure specific to the parser.
  67.  
  68.       A parser's responsibility is: to call either ffesta_confirmed or
  69.       ffest_ffebad_start before returning to the final state; to be the only
  70.       parser that can possibly call ffesta_confirmed for a given statement;
  71.       to call ffest_ffebad_start immediately upon recognizing a bad token
  72.       (specifically one that another statement parser might confirm upon);
  73.       to call ffestc functions only after calling ffesta_confirmed and only
  74.       when ffesta_is_inhibited returns FALSE; and to call ffesta_is_inhibited
  75.       only after calling ffesta_confirmed.  Confirm as early as reasonably
  76.       possible, even when only one ffestc function is called for the statement
  77.       later on, because early confirmation can enhance the error-reporting
  78.       capabilities if a subsequent error is detected and this parser isn't
  79.       the first possibility for the statement.
  80.  
  81.       To assist the parser, functions like ffesta_ffebad_1t and _1p_ have
  82.       been provided to make use of ffest_ffebad_start fairly easy.
  83.  
  84.    Modifications:
  85. */
  86.  
  87. /* Include files. */
  88.  
  89. #include "proj.h"
  90. #include <ctype.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.     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.     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_R9101_ (ffelexToken t);
  779. static ffelexHandler ffestb_R9102_ (ffelexToken t);
  780. static ffelexHandler ffestb_R9103_ (ffelexToken ft, ffebld expr,
  781.                     ffelexToken t);
  782. static ffelexHandler ffestb_R9104_ (ffelexToken t);
  783. static ffelexHandler ffestb_R9105_ (ffelexToken t);
  784. static ffelexHandler ffestb_R9106_ (ffelexToken ft, ffebld expr,
  785.                     ffelexToken t);
  786. static ffelexHandler ffestb_R9107_ (ffelexToken t);
  787. static ffelexHandler ffestb_R9108_ (ffelexToken t);
  788. static ffelexHandler ffestb_R9109_ (ffelexToken ft, ffebld expr,
  789.                     ffelexToken t);
  790. static ffelexHandler ffestb_R91010_ (ffelexToken t);
  791. static ffelexHandler ffestb_R91011_ (ffelexToken t);
  792. static ffelexHandler ffestb_R91012_ (ffelexToken t);
  793. static ffelexHandler ffestb_R91013_ (ffelexToken ft, ffebld expr,
  794.                      ffelexToken t);
  795. static ffelexHandler ffestb_R9111_ (ffelexToken ft, ffebld expr,
  796.                     ffelexToken t);
  797. static ffelexHandler ffestb_R9112_ (ffelexToken ft, ffebld expr,
  798.                     ffelexToken t);
  799. static ffelexHandler ffestb_R9231_ (ffelexToken t);
  800. static ffelexHandler ffestb_R9232_ (ffelexToken t);
  801. static ffelexHandler ffestb_R9233_ (ffelexToken ft, ffebld expr,
  802.                     ffelexToken t);
  803. static ffelexHandler ffestb_R9234_ (ffelexToken t);
  804. static ffelexHandler ffestb_R9235_ (ffelexToken t);
  805. static ffelexHandler ffestb_R9236_ (ffelexToken ft, ffebld expr,
  806.                     ffelexToken t);
  807. static ffelexHandler ffestb_R9237_ (ffelexToken t);
  808. static ffelexHandler ffestb_R9238_ (ffelexToken t);
  809. static ffelexHandler ffestb_R9239_ (ffelexToken t);
  810. static ffelexHandler ffestb_R92310_ (ffelexToken t);
  811. static ffelexHandler ffestb_R92311_ (ffelexToken ft, ffebld expr,
  812.                      ffelexToken t);
  813. #if FFESTR_VXT
  814. static ffelexHandler ffestb_V0181_ (ffelexToken t);
  815. static ffelexHandler ffestb_V0182_ (ffelexToken t);
  816. static ffelexHandler ffestb_V0183_ (ffelexToken ft, ffebld expr,
  817.                     ffelexToken t);
  818. static ffelexHandler ffestb_V0184_ (ffelexToken t);
  819. static ffelexHandler ffestb_V0185_ (ffelexToken t);
  820. static ffelexHandler ffestb_V0186_ (ffelexToken ft, ffebld expr,
  821.                     ffelexToken t);
  822. static ffelexHandler ffestb_V0187_ (ffelexToken t);
  823. static ffelexHandler ffestb_V0188_ (ffelexToken t);
  824. static ffelexHandler ffestb_V0189_ (ffelexToken ft, ffebld expr,
  825.                     ffelexToken t);
  826. static ffelexHandler ffestb_V01810_ (ffelexToken t);
  827. static ffelexHandler ffestb_V01811_ (ffelexToken t);
  828. static ffelexHandler ffestb_V01812_ (ffelexToken t);
  829. static ffelexHandler ffestb_V01813_ (ffelexToken ft, ffebld expr,
  830.                      ffelexToken t);
  831. static ffelexHandler ffestb_V0191_ (ffelexToken ft, ffebld expr,
  832.                     ffelexToken t);
  833. static ffelexHandler ffestb_V0192_ (ffelexToken ft, ffebld expr,
  834.                     ffelexToken t);
  835. #endif
  836. static ffelexHandler ffestb_V0201_ (ffelexToken ft, ffebld expr,
  837.                     ffelexToken t);
  838. static ffelexHandler ffestb_V0202_ (ffelexToken ft, ffebld expr,
  839.                     ffelexToken t);
  840. #if FFESTR_VXT
  841. static ffelexHandler ffestb_V0211_ (ffelexToken t);
  842. static ffelexHandler ffestb_V0212_ (ffelexToken t);
  843. static ffelexHandler ffestb_V0213_ (ffelexToken ft, ffebld expr,
  844.                     ffelexToken t);
  845. static ffelexHandler ffestb_V0214_ (ffelexToken t);
  846. static ffelexHandler ffestb_V0215_ (ffelexToken t);
  847. static ffelexHandler ffestb_V0216_ (ffelexToken ft, ffebld expr,
  848.                     ffelexToken t);
  849. static ffelexHandler ffestb_V0217_ (ffelexToken t);
  850. static ffelexHandler ffestb_V0218_ (ffelexToken t);
  851. static ffelexHandler ffestb_V0219_ (ffelexToken t);
  852. static ffelexHandler ffestb_V0261_ (ffelexToken t);
  853. static ffelexHandler ffestb_V0262_ (ffelexToken t);
  854. static ffelexHandler ffestb_V0263_ (ffelexToken ft, ffebld expr,
  855.                     ffelexToken t);
  856. static ffelexHandler ffestb_V0264_ (ffelexToken t);
  857. static ffelexHandler ffestb_V0265_ (ffelexToken t);
  858. static ffelexHandler ffestb_V0266_ (ffelexToken ft, ffebld expr,
  859.                     ffelexToken t);
  860. static ffelexHandler ffestb_V0267_ (ffelexToken t);
  861. static ffelexHandler ffestb_V0268_ (ffelexToken t);
  862. static ffelexHandler ffestb_V0269_ (ffelexToken t);
  863. #endif
  864. #if FFESTR_F90
  865. static ffelexHandler ffestb_dimlist1_ (ffelexToken t);
  866. static ffelexHandler ffestb_dimlist2_ (ffelexToken t);
  867. static ffelexHandler ffestb_dimlist3_ (ffelexToken t);
  868. static ffelexHandler ffestb_dimlist4_ (ffelexToken t);
  869. #endif
  870. static ffelexHandler ffestb_dummy1_ (ffelexToken t);
  871. static ffelexHandler ffestb_dummy2_ (ffelexToken t);
  872. static ffelexHandler ffestb_R5241_ (ffelexToken t);
  873. static ffelexHandler ffestb_R5242_ (ffelexToken t);
  874. static ffelexHandler ffestb_R5243_ (ffelexToken t);
  875. static ffelexHandler ffestb_R5244_ (ffelexToken t);
  876. static ffelexHandler ffestb_R5471_ (ffelexToken t);
  877. static ffelexHandler ffestb_R5472_ (ffelexToken t);
  878. static ffelexHandler ffestb_R5473_ (ffelexToken t);
  879. static ffelexHandler ffestb_R5474_ (ffelexToken t);
  880. static ffelexHandler ffestb_R5475_ (ffelexToken t);
  881. static ffelexHandler ffestb_R5476_ (ffelexToken t);
  882. static ffelexHandler ffestb_R5477_ (ffelexToken t);
  883. #if FFESTR_F90
  884. static ffelexHandler ffestb_R6241_ (ffelexToken ft, ffebld expr,
  885.                     ffelexToken t);
  886. static ffelexHandler ffestb_R6242_ (ffelexToken t);
  887. #endif
  888. static ffelexHandler ffestb_R12291_ (ffelexToken t);
  889. static ffelexHandler ffestb_R12292_ (ffelexToken ft, ffebld expr,
  890.                      ffelexToken t);
  891. static ffelexHandler ffestb_decl_chartype1_ (ffelexToken t);
  892. #if FFESTR_F90
  893. static ffelexHandler ffestb_decl_recursive1_ (ffelexToken t);
  894. static ffelexHandler ffestb_decl_recursive2_ (ffelexToken t);
  895. static ffelexHandler ffestb_decl_recursive3_ (ffelexToken t);
  896. static ffelexHandler ffestb_decl_recursive4_ (ffelexToken t);
  897. #endif
  898. static ffelexHandler ffestb_decl_attrs_ (ffelexToken t);
  899. static ffelexHandler ffestb_decl_attrs_1_ (ffelexToken t);
  900. static ffelexHandler ffestb_decl_attrs_2_ (ffelexToken t);
  901. #if FFESTR_F90
  902. static ffelexHandler ffestb_decl_attrs_3_ (ffelexToken t);
  903. static ffelexHandler ffestb_decl_attrs_4_ (ffelexToken t);
  904. static ffelexHandler ffestb_decl_attrs_5_ (ffelexToken t);
  905. static ffelexHandler ffestb_decl_attrs_6_ (ffelexToken t);
  906. #endif
  907. static ffelexHandler ffestb_decl_attrs_7_ (ffelexToken t);
  908. static ffelexHandler ffestb_decl_attrsp_ (ffelexToken t);
  909. static ffelexHandler ffestb_decl_ents_ (ffelexToken t);
  910. static ffelexHandler ffestb_decl_ents_1_ (ffelexToken t);
  911. static ffelexHandler ffestb_decl_ents_2_ (ffelexToken t);
  912. static ffelexHandler ffestb_decl_ents_3_ (ffelexToken t);
  913. static ffelexHandler ffestb_decl_ents_4_ (ffelexToken t);
  914. static ffelexHandler ffestb_decl_ents_5_ (ffelexToken t);
  915. static ffelexHandler ffestb_decl_ents_6_ (ffelexToken ft, ffebld expr,
  916.                       ffelexToken t);
  917. static ffelexHandler ffestb_decl_ents_7_ (ffelexToken t);
  918. static ffelexHandler ffestb_decl_ents_8_ (ffelexToken ft, ffebld expr,
  919.                       ffelexToken t);
  920. static ffelexHandler ffestb_decl_ents_9_ (ffelexToken ft, ffebld expr,
  921.                       ffelexToken t);
  922. static ffelexHandler ffestb_decl_ents_10_ (ffelexToken ft, ffebld expr,
  923.                        ffelexToken t);
  924. static ffelexHandler ffestb_decl_ents_11_ (ffelexToken t);
  925. static ffelexHandler ffestb_decl_entsp_ (ffelexToken t);
  926. static ffelexHandler ffestb_decl_entsp_1_ (ffelexToken t);
  927. static ffelexHandler ffestb_decl_entsp_2_ (ffelexToken t);
  928. static ffelexHandler ffestb_decl_entsp_3_ (ffelexToken t);
  929. static ffelexHandler ffestb_decl_entsp_4_ (ffelexToken ft, ffebld expr,
  930.                        ffelexToken t);
  931. static ffelexHandler ffestb_decl_entsp_5_ (ffelexToken t);
  932. static ffelexHandler ffestb_decl_entsp_6_ (ffelexToken t);
  933. static ffelexHandler ffestb_decl_entsp_7_ (ffelexToken t);
  934. static ffelexHandler ffestb_decl_entsp_8_ (ffelexToken t);
  935. #if FFESTR_F90
  936. static ffelexHandler ffestb_decl_func_ (ffelexToken t);
  937. #endif
  938. static ffelexHandler ffestb_decl_funcname_ (ffelexToken t);
  939. static ffelexHandler ffestb_decl_funcname_1_ (ffelexToken t);
  940. static ffelexHandler ffestb_decl_funcname_2_ (ffelexToken t);
  941. static ffelexHandler ffestb_decl_funcname_3_ (ffelexToken ft, ffebld expr,
  942.                           ffelexToken t);
  943. static ffelexHandler ffestb_decl_funcname_4_ (ffelexToken t);
  944. static ffelexHandler ffestb_decl_funcname_5_ (ffelexToken t);
  945. static ffelexHandler ffestb_decl_funcname_6_ (ffelexToken t);
  946. static ffelexHandler ffestb_decl_funcname_7_ (ffelexToken t);
  947. static ffelexHandler ffestb_decl_funcname_8_ (ffelexToken t);
  948. static ffelexHandler ffestb_decl_funcname_9_ (ffelexToken t);
  949. #if FFESTR_VXT
  950. static ffelexHandler ffestb_V0031_ (ffelexToken t);
  951. static ffelexHandler ffestb_V0032_ (ffelexToken t);
  952. static ffelexHandler ffestb_V0033_ (ffelexToken t);
  953. static ffelexHandler ffestb_V0034_ (ffelexToken t);
  954. static ffelexHandler ffestb_V0035_ (ffelexToken t);
  955. static ffelexHandler ffestb_V0036_ (ffelexToken t);
  956. static ffelexHandler ffestb_V0161_ (ffelexToken t);
  957. static ffelexHandler ffestb_V0162_ (ffelexToken t);
  958. static ffelexHandler ffestb_V0163_ (ffelexToken t);
  959. static ffelexHandler ffestb_V0164_ (ffelexToken t);
  960. static ffelexHandler ffestb_V0165_ (ffelexToken t);
  961. static ffelexHandler ffestb_V0166_ (ffelexToken t);
  962. #endif
  963. static ffelexHandler ffestb_V0271_ (ffelexToken t);
  964. static ffelexHandler ffestb_V0272_ (ffelexToken ft, ffebld expr,
  965.                     ffelexToken t);
  966. static ffelexHandler ffestb_V0273_ (ffelexToken t);
  967. static ffelexHandler ffestb_decl_R5391_ (ffelexToken t);
  968. static ffelexHandler ffestb_decl_R5392_ (ffelexToken t);
  969. #if FFESTR_F90
  970. static ffelexHandler ffestb_decl_R5393_ (ffelexToken t);
  971. #endif
  972. static ffelexHandler ffestb_decl_R5394_ (ffelexToken t);
  973. static ffelexHandler ffestb_decl_R5395_ (ffelexToken t);
  974. static ffelexHandler ffestb_decl_R539letters_ (ffelexToken t);
  975. static ffelexHandler ffestb_decl_R539letters_1_ (ffelexToken t);
  976. static ffelexHandler ffestb_decl_R539letters_2_ (ffelexToken t);
  977. static ffelexHandler ffestb_decl_R539letters_3_ (ffelexToken t);
  978. static ffelexHandler ffestb_decl_R539letters_4_ (ffelexToken t);
  979. static ffelexHandler ffestb_decl_R539letters_5_ (ffelexToken t);
  980. static ffelexHandler ffestb_decl_R539maybe_ (ffelexToken t);
  981. static ffelexHandler ffestb_decl_R539maybe_1_ (ffelexToken t);
  982. static ffelexHandler ffestb_decl_R539maybe_2_ (ffelexToken t);
  983. static ffelexHandler ffestb_decl_R539maybe_3_ (ffelexToken t);
  984. static ffelexHandler ffestb_decl_R539maybe_4_ (ffelexToken t);
  985. static ffelexHandler ffestb_decl_R539maybe_5_ (ffelexToken t);
  986.  
  987. /* Internal macros. */
  988.  
  989. #if FFESTB_KILL_EASY_
  990. #define ffestb_subr_kill_accept_() \
  991.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_acceptix)
  992. #define ffestb_subr_kill_beru_() \
  993.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_beruix)
  994. #define ffestb_subr_kill_close_() \
  995.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_closeix)
  996. #define ffestb_subr_kill_delete_() \
  997.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_deleteix)
  998. #define ffestb_subr_kill_find_() \
  999.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_findix)
  1000. #define ffestb_subr_kill_inquire_() \
  1001.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_inquireix)
  1002. #define ffestb_subr_kill_open_() \
  1003.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_openix)
  1004. #define ffestb_subr_kill_print_() \
  1005.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_printix)
  1006. #define ffestb_subr_kill_read_() \
  1007.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_readix)
  1008. #define ffestb_subr_kill_rewrite_() \
  1009.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_rewriteix)
  1010. #define ffestb_subr_kill_type_() \
  1011.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_typeix)
  1012. #define ffestb_subr_kill_vxtcode_() \
  1013.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_vxtcodeix)
  1014. #define ffestb_subr_kill_write_() \
  1015.       ffestb_subr_kill_easy_((ffestpInquireIx) FFESTP_writeix)
  1016. #endif
  1017.  
  1018. /* ffestb_subr_ambig_nope_ -- Cleans up and aborts ambig w/o confirming
  1019.  
  1020.    ffestb_subr_ambig_nope_();
  1021.  
  1022.    Switch from ambiguity handling in _entsp_ functions to handling entities
  1023.    in _ents_ (perform housekeeping tasks).  */
  1024.  
  1025. static ffelexHandler
  1026. ffestb_subr_ambig_nope_ (ffelexToken t)
  1027. {
  1028.   if (ffestb_local_.decl.recursive != NULL)
  1029.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1030.   if (ffestb_local_.decl.kindt != NULL)
  1031.     ffelex_token_kill (ffestb_local_.decl.kindt);
  1032.   if (ffestb_local_.decl.lent != NULL)
  1033.     ffelex_token_kill (ffestb_local_.decl.lent);
  1034.   ffelex_token_kill (ffesta_tokens[1]);
  1035.   ffelex_token_kill (ffesta_tokens[2]);
  1036.   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  1037.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  1038.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1039. }
  1040.  
  1041. /* ffestb_subr_ambig_to_ents_ -- Switches from ambiguity to entity decl
  1042.  
  1043.    ffestb_subr_ambig_to_ents_();
  1044.  
  1045.    Switch from ambiguity handling in _entsp_ functions to handling entities
  1046.    in _ents_ (perform housekeeping tasks).  */
  1047.  
  1048. static void
  1049. ffestb_subr_ambig_to_ents_ ()
  1050. {
  1051.   ffelexToken nt;
  1052.  
  1053.   nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
  1054.   ffelex_token_kill (ffesta_tokens[1]);
  1055.   ffelex_token_kill (ffesta_tokens[2]);
  1056.   ffesta_tokens[1] = nt;
  1057.   if (ffestb_local_.decl.recursive != NULL)
  1058.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1059.   if (!ffestb_local_.decl.aster_after)
  1060.     {
  1061.       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
  1062.     {
  1063.       if (!ffesta_is_inhibited ())
  1064.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  1065.               ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
  1066.                ffestb_local_.decl.len, ffestb_local_.decl.lent);
  1067.       if (ffestb_local_.decl.kindt != NULL)
  1068.         {
  1069.           ffelex_token_kill (ffestb_local_.decl.kindt);
  1070.           ffestb_local_.decl.kind = NULL;
  1071.           ffestb_local_.decl.kindt = NULL;
  1072.         }
  1073.       if (ffestb_local_.decl.lent != NULL)
  1074.         {
  1075.           ffelex_token_kill (ffestb_local_.decl.lent);
  1076.           ffestb_local_.decl.len = NULL;
  1077.           ffestb_local_.decl.lent = NULL;
  1078.         }
  1079.     }
  1080.       else
  1081.     {
  1082.       if (!ffesta_is_inhibited ())
  1083.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  1084.             ffestb_local_.decl.kind, ffestb_local_.decl.kindt, NULL,
  1085.                    NULL);
  1086.       if (ffestb_local_.decl.kindt != NULL)
  1087.         {
  1088.           ffelex_token_kill (ffestb_local_.decl.kindt);
  1089.           ffestb_local_.decl.kind = NULL;
  1090.           ffestb_local_.decl.kindt = NULL;
  1091.         }
  1092.     }
  1093.       return;
  1094.     }
  1095.   if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
  1096.     {
  1097.       if (!ffesta_is_inhibited ())
  1098.     ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  1099.          ffestb_local_.decl.kind, ffestb_local_.decl.kindt, NULL, NULL);
  1100.       if (ffestb_local_.decl.kindt != NULL)
  1101.     {
  1102.       ffelex_token_kill (ffestb_local_.decl.kindt);
  1103.       ffestb_local_.decl.kind = NULL;
  1104.       ffestb_local_.decl.kindt = NULL;
  1105.     }
  1106.     }
  1107.   else if (!ffesta_is_inhibited ())
  1108.     ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  1109.                NULL, NULL, NULL, NULL);
  1110.   /* NAME/NAMES token already in ffesta_tokens[1]. */
  1111. }
  1112.  
  1113. /* ffestb_subr_dimlist_ -- OPEN_PAREN expr
  1114.  
  1115.    (ffestb_subr_dimlist_)  // to expression handler
  1116.  
  1117.    Deal with a dimension list.
  1118.  
  1119.    19-Dec-90  JCB  1.1
  1120.       Detect too many dimensions if backend wants it.  */
  1121.  
  1122. static ffelexHandler
  1123. ffestb_subr_dimlist_ (ffelexToken ft, ffebld expr, ffelexToken t)
  1124. {
  1125.   switch (ffelex_token_type (t))
  1126.     {
  1127.     case FFELEX_typeCLOSE_PAREN:
  1128.       if (expr == NULL)
  1129.     break;
  1130. #ifdef FFECOM_dimensionsMAX
  1131.       if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
  1132.     {
  1133.       ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
  1134.       ffestb_subrargs_.dim_list.ok = TRUE;    /* Not a parse error, really. */
  1135.       return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
  1136.     }
  1137. #endif
  1138.       ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, NULL, expr,
  1139.                  ffelex_token_use (t));
  1140.       ffestb_subrargs_.dim_list.ok = TRUE;
  1141.       return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
  1142.  
  1143.     case FFELEX_typeCOMMA:
  1144.       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
  1145.     break;
  1146. #ifdef FFECOM_dimensionsMAX
  1147.       if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
  1148.     {
  1149.       ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
  1150.       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
  1151.                           ffestb_subrargs_.dim_list.ctx,
  1152.                   (ffeexprCallback) ffestb_subr_dimlist_2_);
  1153.     }
  1154. #endif
  1155.       ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, NULL, expr,
  1156.                  ffelex_token_use (t));
  1157.       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
  1158.                       ffestb_subrargs_.dim_list.ctx,
  1159.                     (ffeexprCallback) ffestb_subr_dimlist_);
  1160.  
  1161.     case FFELEX_typeCOLON:
  1162.       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
  1163.     break;
  1164. #ifdef FFECOM_dimensionsMAX
  1165.       if (ffestb_subrargs_.dim_list.ndims++ == FFECOM_dimensionsMAX)
  1166.     {
  1167.       ffesta_ffebad_1t (FFEBAD_TOO_MANY_DIMS, ft);
  1168.       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
  1169.                           ffestb_subrargs_.dim_list.ctx,
  1170.                   (ffeexprCallback) ffestb_subr_dimlist_2_);
  1171.     }
  1172. #endif
  1173.       ffestt_dimlist_append (ffestb_subrargs_.dim_list.dims, expr, NULL,
  1174.                  ffelex_token_use (t));    /* NULL second expr for
  1175.                                now, just plug in. */
  1176.       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
  1177.                       ffestb_subrargs_.dim_list.ctx,
  1178.                   (ffeexprCallback) ffestb_subr_dimlist_1_);
  1179.  
  1180.     default:
  1181.       break;
  1182.     }
  1183.  
  1184.   ffestb_subrargs_.dim_list.ok = FALSE;
  1185.   return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
  1186. }
  1187.  
  1188. /* ffestb_subr_dimlist_1_ -- OPEN_PAREN expr COLON expr
  1189.  
  1190.    (ffestb_subr_dimlist_1_)  // to expression handler
  1191.  
  1192.    Get the upper bound.     */
  1193.  
  1194. static ffelexHandler
  1195. ffestb_subr_dimlist_1_ (ffelexToken ft, ffebld expr, ffelexToken t)
  1196. {
  1197.   switch (ffelex_token_type (t))
  1198.     {
  1199.     case FFELEX_typeCLOSE_PAREN:
  1200.       ffestb_subrargs_.dim_list.dims->previous->upper = expr;
  1201.       ffestb_subrargs_.dim_list.ok = TRUE;
  1202.       return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
  1203.  
  1204.     case FFELEX_typeCOMMA:
  1205.       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
  1206.     break;
  1207.       ffestb_subrargs_.dim_list.dims->previous->upper = expr;
  1208.       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
  1209.       ffestb_subrargs_.dim_list.ctx, (ffeexprCallback) ffestb_subr_dimlist_);
  1210.  
  1211.     default:
  1212.       break;
  1213.     }
  1214.  
  1215.   ffestb_subrargs_.dim_list.ok = FALSE;
  1216.   return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
  1217. }
  1218.  
  1219. /* ffestb_subr_dimlist_2_ -- OPEN_PAREN too-many-dim-exprs
  1220.  
  1221.    (ffestb_subr_dimlist_2_)  // to expression handler
  1222.  
  1223.    Get the upper bound.     */
  1224.  
  1225. static ffelexHandler
  1226. ffestb_subr_dimlist_2_ (ffelexToken ft, ffebld expr, ffelexToken t)
  1227. {
  1228.   switch (ffelex_token_type (t))
  1229.     {
  1230.     case FFELEX_typeCLOSE_PAREN:
  1231.       ffestb_subrargs_.dim_list.ok = TRUE;    /* Not a parse error, really. */
  1232.       return (ffelexHandler) ffestb_subrargs_.dim_list.handler;
  1233.  
  1234.     case FFELEX_typeCOMMA:
  1235.     case FFELEX_typeCOLON:
  1236.       if ((expr != NULL) && (ffebld_op (expr) == FFEBLD_opSTAR))
  1237.     break;
  1238.       return (ffelexHandler) ffeexpr_rhs (ffestb_subrargs_.dim_list.pool,
  1239.                       ffestb_subrargs_.dim_list.ctx,
  1240.                   (ffeexprCallback) ffestb_subr_dimlist_2_);
  1241.  
  1242.     default:
  1243.       break;
  1244.     }
  1245.  
  1246.   ffestb_subrargs_.dim_list.ok = FALSE;
  1247.   return (ffelexHandler) ffestb_subrargs_.dim_list.handler (t);
  1248. }
  1249.  
  1250. /* ffestb_subr_name_list_ -- Collect a list of name args and close-paren
  1251.  
  1252.    return ffestb_subr_name_list_;  // to lexer after seeing OPEN_PAREN
  1253.  
  1254.    This implements R1224 in the Fortran 90 spec.  The arg list may be
  1255.    empty, or be a comma-separated list (an optional trailing comma currently
  1256.    results in a warning but no other effect) of arguments.  For functions,
  1257.    however, "*" is invalid (we implement dummy-arg-name, rather than R1224
  1258.    dummy-arg, which itself is either dummy-arg-name or "*").  */
  1259.  
  1260. static ffelexHandler
  1261. ffestb_subr_name_list_ (ffelexToken t)
  1262. {
  1263.   switch (ffelex_token_type (t))
  1264.     {
  1265.     case FFELEX_typeCLOSE_PAREN:
  1266.       if (ffestt_tokenlist_count (ffestb_subrargs_.name_list.args) != 0)
  1267.     {            /* Trailing comma, warn. */
  1268.       ffebad_start (FFEBAD_TRAILING_COMMA);
  1269.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  1270.       ffebad_finish ();
  1271.     }
  1272.       ffestb_subrargs_.name_list.ok = TRUE;
  1273.       ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
  1274.       if (ffestb_subrargs_.name_list.names)
  1275.     ffelex_set_names (TRUE);
  1276.       return (ffelexHandler) ffestb_subrargs_.name_list.handler;
  1277.  
  1278.     case FFELEX_typeASTERISK:
  1279.       if (!ffestb_subrargs_.name_list.is_subr)
  1280.     break;
  1281.  
  1282.     case FFELEX_typeNAME:
  1283.       ffestt_tokenlist_append (ffestb_subrargs_.name_list.args,
  1284.                    ffelex_token_use (t));
  1285.       return (ffelexHandler) ffestb_subr_name_list_1_;
  1286.  
  1287.     default:
  1288.       break;
  1289.     }
  1290.  
  1291.   ffestb_subrargs_.name_list.ok = FALSE;
  1292.   ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
  1293.   if (ffestb_subrargs_.name_list.names)
  1294.     ffelex_set_names (TRUE);
  1295.   return (ffelexHandler) (*ffestb_subrargs_.name_list.handler) (t);
  1296. }
  1297.  
  1298. /* ffestb_subr_name_list_1_ -- NAME or ASTERISK
  1299.  
  1300.    return ffestb_subr_name_list_1_;  // to lexer
  1301.  
  1302.    The next token must be COMMA or CLOSE_PAREN, either way go to original
  1303.    state, but only after adding the appropriate name list item.     */
  1304.  
  1305. static ffelexHandler
  1306. ffestb_subr_name_list_1_ (ffelexToken t)
  1307. {
  1308.   switch (ffelex_token_type (t))
  1309.     {
  1310.     case FFELEX_typeCOMMA:
  1311.       return (ffelexHandler) ffestb_subr_name_list_;
  1312.  
  1313.     case FFELEX_typeCLOSE_PAREN:
  1314.       ffestb_subrargs_.name_list.ok = TRUE;
  1315.       ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
  1316.       if (ffestb_subrargs_.name_list.names)
  1317.     ffelex_set_names (TRUE);
  1318.       return (ffelexHandler) ffestb_subrargs_.name_list.handler;
  1319.  
  1320.     default:
  1321.       ffestb_subrargs_.name_list.ok = FALSE;
  1322.       ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
  1323.       if (ffestb_subrargs_.name_list.names)
  1324.     ffelex_set_names (TRUE);
  1325.       return (ffelexHandler) (*ffestb_subrargs_.name_list.handler) (t);
  1326.     }
  1327. }
  1328.  
  1329. static void
  1330. ffestb_subr_R1001_append_p_ (void)
  1331. {
  1332.   ffesttFormatList f;
  1333.  
  1334.   if (!ffestb_local_.format.pre.present)
  1335.     {
  1336.       ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_P_SPEC, ffestb_local_.format.t);
  1337.       ffelex_token_kill (ffestb_local_.format.t);
  1338.       return;
  1339.     }
  1340.  
  1341.   f = ffestt_formatlist_append (ffestb_local_.format.f);
  1342.   f->type = FFESTP_formattypeP;
  1343.   f->t = ffestb_local_.format.t;
  1344.   f->u.R1010.val = ffestb_local_.format.pre;
  1345. }
  1346.  
  1347. /* ffestb_decl_kindparam_ -- "type" OPEN_PAREN
  1348.  
  1349.    return ffestb_decl_kindparam_;  // to lexer
  1350.  
  1351.    Handle "[KIND=]expr)".  */
  1352.  
  1353. static ffelexHandler
  1354. ffestb_decl_kindparam_ (ffelexToken t)
  1355. {
  1356.   switch (ffelex_token_type (t))
  1357.     {
  1358.     case FFELEX_typeNAME:
  1359.       ffesta_tokens[1] = ffelex_token_use (t);
  1360.       return (ffelexHandler) ffestb_decl_kindparam_1_;
  1361.  
  1362.     default:
  1363.       return (ffelexHandler) (*((ffelexHandler)
  1364.                 ffeexpr_rhs (ffesta_output_pool,
  1365.                          FFEEXPR_contextKINDTYPE,
  1366.                    (ffeexprCallback) ffestb_decl_kindparam_2_)))
  1367.     (t);
  1368.     }
  1369. }
  1370.  
  1371. /* ffestb_decl_kindparam_1_ -- "type" OPEN_PAREN NAME
  1372.  
  1373.    return ffestb_decl_kindparam_1_;  // to lexer
  1374.  
  1375.    Handle "[KIND=]expr)".  */
  1376.  
  1377. static ffelexHandler
  1378. ffestb_decl_kindparam_1_ (ffelexToken t)
  1379. {
  1380.   ffelexHandler next;
  1381.   ffelexToken nt;
  1382.  
  1383.   switch (ffelex_token_type (t))
  1384.     {
  1385.     case FFELEX_typeEQUALS:
  1386.       ffesta_confirmed ();
  1387.       if (ffestr_other (ffesta_tokens[1]) != FFESTR_otherKIND)
  1388.     break;
  1389.       ffelex_token_kill (ffesta_tokens[1]);
  1390.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  1391.        FFEEXPR_contextKINDTYPE, (ffeexprCallback) ffestb_decl_kindparam_2_);
  1392.  
  1393.     default:
  1394.       nt = ffesta_tokens[1];
  1395.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  1396.       FFEEXPR_contextKINDTYPE, (ffeexprCallback) ffestb_decl_kindparam_2_)))
  1397.     (nt);
  1398.       ffelex_token_kill (nt);
  1399.       return (ffelexHandler) (*next) (t);
  1400.     }
  1401.  
  1402.   if (ffestb_local_.decl.recursive != NULL)
  1403.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1404.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  1405.              ffestb_local_.decl.badname,
  1406.              ffesta_tokens[1]);
  1407.   ffelex_token_kill (ffesta_tokens[1]);
  1408.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1409. }
  1410.  
  1411. /* ffestb_decl_kindparam_2_ -- "type" OPEN_PAREN ["KIND="] expr
  1412.  
  1413.    (ffestb_decl_kindparam_2_)  // to expression handler
  1414.  
  1415.    Handle "[KIND=]expr)".  */
  1416.  
  1417. static ffelexHandler
  1418. ffestb_decl_kindparam_2_ (ffelexToken ft, ffebld expr, ffelexToken t)
  1419. {
  1420.   switch (ffelex_token_type (t))
  1421.     {
  1422.     case FFELEX_typeCLOSE_PAREN:
  1423.       ffestb_local_.decl.kind = expr;
  1424.       ffestb_local_.decl.kindt = ffelex_token_use (ft);
  1425.       ffestb_local_.decl.len = NULL;
  1426.       ffestb_local_.decl.lent = NULL;
  1427.       ffelex_set_names (TRUE);
  1428.       return (ffelexHandler) ffestb_local_.decl.handler;
  1429.  
  1430.     default:
  1431.       break;
  1432.     }
  1433.  
  1434.   if (ffestb_local_.decl.recursive != NULL)
  1435.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1436.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  1437.             ffestb_local_.decl.badname,
  1438.             t);
  1439.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1440. }
  1441.  
  1442. /* ffestb_decl_starkind_ -- "type" ASTERISK
  1443.  
  1444.    return ffestb_decl_starkind_;  // to lexer
  1445.  
  1446.    Handle NUMBER.  */
  1447.  
  1448. static ffelexHandler
  1449. ffestb_decl_starkind_ (ffelexToken t)
  1450. {
  1451.   switch (ffelex_token_type (t))
  1452.     {
  1453.     case FFELEX_typeNUMBER:
  1454.       ffestb_local_.decl.kindt = ffelex_token_use (t);
  1455.       ffestb_local_.decl.kind = NULL;
  1456.       ffestb_local_.decl.len = NULL;
  1457.       ffestb_local_.decl.lent = NULL;
  1458.       ffelex_set_names (TRUE);
  1459.       return (ffelexHandler) ffestb_local_.decl.handler;
  1460.  
  1461.     default:
  1462.       break;
  1463.     }
  1464.  
  1465.   if (ffestb_local_.decl.recursive != NULL)
  1466.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1467.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  1468.             ffestb_local_.decl.badname,
  1469.             t);
  1470.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1471. }
  1472.  
  1473. /* ffestb_decl_starlen_ -- "CHARACTER" ASTERISK
  1474.  
  1475.    return ffestb_decl_starlen_;     // to lexer
  1476.  
  1477.    Handle NUMBER.  */
  1478.  
  1479. static ffelexHandler
  1480. ffestb_decl_starlen_ (ffelexToken t)
  1481. {
  1482.   switch (ffelex_token_type (t))
  1483.     {
  1484.     case FFELEX_typeNUMBER:
  1485.       ffestb_local_.decl.kind = NULL;
  1486.       ffestb_local_.decl.kindt = NULL;
  1487.       ffestb_local_.decl.len = NULL;
  1488.       ffestb_local_.decl.lent = ffelex_token_use (t);
  1489.       ffelex_set_names (TRUE);
  1490.       return (ffelexHandler) ffestb_local_.decl.handler;
  1491.  
  1492.     case FFELEX_typeOPEN_PAREN:
  1493.       ffestb_local_.decl.kind = NULL;
  1494.       ffestb_local_.decl.kindt = NULL;
  1495.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  1496.                       FFEEXPR_contextCHARACTERSIZE,
  1497.                   (ffeexprCallback) ffestb_decl_starlen_1_);
  1498.  
  1499.     default:
  1500.       break;
  1501.     }
  1502.  
  1503.   if (ffestb_local_.decl.recursive != NULL)
  1504.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1505.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  1506.             ffestb_local_.decl.badname,
  1507.             t);
  1508.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1509. }
  1510.  
  1511. /* ffestb_decl_starlen_1_ -- "CHARACTER" ASTERISK OPEN_PAREN expr
  1512.  
  1513.    (ffestb_decl_starlen_1_)  // to expression handler
  1514.  
  1515.    Handle CLOSE_PAREN.    */
  1516.  
  1517. static ffelexHandler
  1518. ffestb_decl_starlen_1_ (ffelexToken ft, ffebld expr, ffelexToken t)
  1519. {
  1520.   switch (ffelex_token_type (t))
  1521.     {
  1522.     case FFELEX_typeCLOSE_PAREN:
  1523.       if (expr == NULL)
  1524.     break;
  1525.       ffestb_local_.decl.len = expr;
  1526.       ffestb_local_.decl.lent = ffelex_token_use (ft);
  1527.       ffelex_set_names (TRUE);
  1528.       return (ffelexHandler) ffestb_local_.decl.handler;
  1529.  
  1530.     default:
  1531.       break;
  1532.     }
  1533.  
  1534.   if (ffestb_local_.decl.recursive != NULL)
  1535.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1536.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  1537.             ffestb_local_.decl.badname,
  1538.             t);
  1539.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1540. }
  1541.  
  1542. /* ffestb_decl_typeparams_ -- "CHARACTER" OPEN_PAREN
  1543.  
  1544.    return ffestb_decl_typeparams_;  // to lexer
  1545.  
  1546.    Handle "[KIND=]expr)".  */
  1547.  
  1548. static ffelexHandler
  1549. ffestb_decl_typeparams_ (ffelexToken t)
  1550. {
  1551.   switch (ffelex_token_type (t))
  1552.     {
  1553.     case FFELEX_typeNAME:
  1554.       ffesta_tokens[1] = ffelex_token_use (t);
  1555.       return (ffelexHandler) ffestb_decl_typeparams_1_;
  1556.  
  1557.     default:
  1558.       if (ffestb_local_.decl.lent == NULL)
  1559.     return (ffelexHandler) (*((ffelexHandler)
  1560.                   ffeexpr_rhs (ffesta_output_pool,
  1561.                            FFEEXPR_contextCHARACTERSIZE,
  1562.                   (ffeexprCallback) ffestb_decl_typeparams_2_)))
  1563.       (t);
  1564.       if (ffestb_local_.decl.kindt != NULL)
  1565.     break;
  1566.       return (ffelexHandler) (*((ffelexHandler)
  1567.                 ffeexpr_rhs (ffesta_output_pool,
  1568.                          FFEEXPR_contextKINDTYPE,
  1569.                   (ffeexprCallback) ffestb_decl_typeparams_3_)))
  1570.     (t);
  1571.     }
  1572.  
  1573.   if (ffestb_local_.decl.recursive != NULL)
  1574.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1575.   if (ffestb_local_.decl.kindt != NULL)
  1576.     ffelex_token_kill (ffestb_local_.decl.kindt);
  1577.   if (ffestb_local_.decl.lent != NULL)
  1578.     ffelex_token_kill (ffestb_local_.decl.lent);
  1579.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  1580.             ffestb_local_.decl.badname,
  1581.             t);
  1582.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1583. }
  1584.  
  1585. /* ffestb_decl_typeparams_1_ -- "CHARACTER" OPEN_PAREN NAME
  1586.  
  1587.    return ffestb_decl_typeparams_1_;  // to lexer
  1588.  
  1589.    Handle "[KIND=]expr)".  */
  1590.  
  1591. static ffelexHandler
  1592. ffestb_decl_typeparams_1_ (ffelexToken t)
  1593. {
  1594.   ffelexHandler next;
  1595.   ffelexToken nt;
  1596.  
  1597.   switch (ffelex_token_type (t))
  1598.     {
  1599.     case FFELEX_typeEQUALS:
  1600.       ffesta_confirmed ();
  1601.       switch (ffestr_other (ffesta_tokens[1]))
  1602.     {
  1603.     case FFESTR_otherLEN:
  1604.       if (ffestb_local_.decl.lent != NULL)
  1605.         break;
  1606.       ffelex_token_kill (ffesta_tokens[1]);
  1607.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  1608.                           FFEEXPR_contextCHARACTERSIZE,
  1609.                    (ffeexprCallback) ffestb_decl_typeparams_2_);
  1610.  
  1611.     case FFESTR_otherKIND:
  1612.       if (ffestb_local_.decl.kindt != NULL)
  1613.         break;
  1614.       ffelex_token_kill (ffesta_tokens[1]);
  1615.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  1616.                           FFEEXPR_contextKINDTYPE,
  1617.                    (ffeexprCallback) ffestb_decl_typeparams_3_);
  1618.  
  1619.     default:
  1620.       break;
  1621.     }
  1622.       break;
  1623.  
  1624.     default:
  1625.       nt = ffesta_tokens[1];
  1626.       if (ffestb_local_.decl.lent == NULL)
  1627.     next = (ffelexHandler) (*((ffelexHandler)
  1628.                   ffeexpr_rhs (ffesta_output_pool,
  1629.                            FFEEXPR_contextCHARACTERSIZE,
  1630.                   (ffeexprCallback) ffestb_decl_typeparams_2_)))
  1631.       (nt);
  1632.       else if (ffestb_local_.decl.kindt == NULL)
  1633.     next = (ffelexHandler) (*((ffelexHandler)
  1634.                   ffeexpr_rhs (ffesta_output_pool,
  1635.                            FFEEXPR_contextKINDTYPE,
  1636.                   (ffeexprCallback) ffestb_decl_typeparams_3_)))
  1637.       (nt);
  1638.       else
  1639.     {
  1640.       ffesta_tokens[1] = nt;
  1641.       break;
  1642.     }
  1643.       ffelex_token_kill (nt);
  1644.       return (ffelexHandler) (*next) (t);
  1645.     }
  1646.  
  1647.   if (ffestb_local_.decl.recursive != NULL)
  1648.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1649.   if (ffestb_local_.decl.kindt != NULL)
  1650.     ffelex_token_kill (ffestb_local_.decl.kindt);
  1651.   if (ffestb_local_.decl.lent != NULL)
  1652.     ffelex_token_kill (ffestb_local_.decl.lent);
  1653.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  1654.             ffestb_local_.decl.badname,
  1655.             ffesta_tokens[1]);
  1656.   ffelex_token_kill (ffesta_tokens[1]);
  1657.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1658. }
  1659.  
  1660. /* ffestb_decl_typeparams_2_ -- "CHARACTER" OPEN_PAREN ["LEN="] expr
  1661.  
  1662.    (ffestb_decl_typeparams_2_)    // to expression handler
  1663.  
  1664.    Handle "[LEN=]expr)".  */
  1665.  
  1666. static ffelexHandler
  1667. ffestb_decl_typeparams_2_ (ffelexToken ft, ffebld expr, ffelexToken t)
  1668. {
  1669.   switch (ffelex_token_type (t))
  1670.     {
  1671.     case FFELEX_typeCLOSE_PAREN:
  1672.       ffestb_local_.decl.len = expr;
  1673.       ffestb_local_.decl.lent = ffelex_token_use (ft);
  1674.       ffelex_set_names (TRUE);
  1675.       return (ffelexHandler) ffestb_local_.decl.handler;
  1676.  
  1677.     case FFELEX_typeCOMMA:
  1678.       ffestb_local_.decl.len = expr;
  1679.       ffestb_local_.decl.lent = ffelex_token_use (ft);
  1680.       return (ffelexHandler) ffestb_decl_typeparams_;
  1681.  
  1682.     default:
  1683.       break;
  1684.     }
  1685.  
  1686.   if (ffestb_local_.decl.recursive != NULL)
  1687.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1688.   if (ffestb_local_.decl.kindt != NULL)
  1689.     ffelex_token_kill (ffestb_local_.decl.kindt);
  1690.   if (ffestb_local_.decl.lent != NULL)
  1691.     ffelex_token_kill (ffestb_local_.decl.lent);
  1692.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  1693.             ffestb_local_.decl.badname,
  1694.             t);
  1695.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1696. }
  1697.  
  1698. /* ffestb_decl_typeparams_3_ -- "CHARACTER" OPEN_PAREN ["KIND="] expr
  1699.  
  1700.    (ffestb_decl_typeparams_3_)    // to expression handler
  1701.  
  1702.    Handle "[KIND=]expr)".  */
  1703.  
  1704. static ffelexHandler
  1705. ffestb_decl_typeparams_3_ (ffelexToken ft, ffebld expr, ffelexToken t)
  1706. {
  1707.   switch (ffelex_token_type (t))
  1708.     {
  1709.     case FFELEX_typeCLOSE_PAREN:
  1710.       ffestb_local_.decl.kind = expr;
  1711.       ffestb_local_.decl.kindt = ffelex_token_use (ft);
  1712.       ffelex_set_names (TRUE);
  1713.       return (ffelexHandler) ffestb_local_.decl.handler;
  1714.  
  1715.     case FFELEX_typeCOMMA:
  1716.       ffestb_local_.decl.kind = expr;
  1717.       ffestb_local_.decl.kindt = ffelex_token_use (ft);
  1718.       return (ffelexHandler) ffestb_decl_typeparams_;
  1719.  
  1720.     default:
  1721.       break;
  1722.     }
  1723.  
  1724.   if (ffestb_local_.decl.recursive != NULL)
  1725.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1726.   if (ffestb_local_.decl.kindt != NULL)
  1727.     ffelex_token_kill (ffestb_local_.decl.kindt);
  1728.   if (ffestb_local_.decl.lent != NULL)
  1729.     ffelex_token_kill (ffestb_local_.decl.lent);
  1730.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  1731.             ffestb_local_.decl.badname,
  1732.             t);
  1733.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1734. }
  1735.  
  1736. /* ffestb_decl_typetype1_ -- "TYPE" OPEN_PAREN
  1737.  
  1738.    return ffestb_decl_typetype1_;  // to lexer
  1739.  
  1740.    Handle NAME.     */
  1741.  
  1742. #if FFESTR_F90
  1743. static ffelexHandler
  1744. ffestb_decl_typetype1_ (ffelexToken t)
  1745. {
  1746.   switch (ffelex_token_type (t))
  1747.     {
  1748.     case FFELEX_typeNAME:
  1749.       ffestb_local_.decl.kindt = ffelex_token_use (t);
  1750.       return (ffelexHandler) ffestb_decl_typetype2_;
  1751.  
  1752.     default:
  1753.       break;
  1754.     }
  1755.  
  1756.   if (ffestb_local_.decl.recursive != NULL)
  1757.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1758.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  1759.             ffestb_local_.decl.badname,
  1760.             t);
  1761.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1762. }
  1763.  
  1764. /* ffestb_decl_typetype2_ -- "TYPE" OPEN_PAREN NAME
  1765.  
  1766.    return ffestb_decl_typetype2_;  // to lexer
  1767.  
  1768.    Handle CLOSE_PAREN.    */
  1769.  
  1770. static ffelexHandler
  1771. ffestb_decl_typetype2_ (ffelexToken t)
  1772. {
  1773.   switch (ffelex_token_type (t))
  1774.     {
  1775.     case FFELEX_typeCLOSE_PAREN:
  1776.       ffestb_local_.decl.type = FFESTP_typeTYPE;
  1777.       ffestb_local_.decl.kind = NULL;
  1778.       ffestb_local_.decl.len = NULL;
  1779.       ffestb_local_.decl.lent = NULL;
  1780.       ffelex_set_names (TRUE);
  1781.       return (ffelexHandler) ffestb_local_.decl.handler;
  1782.  
  1783.     default:
  1784.       break;
  1785.     }
  1786.  
  1787.   if (ffestb_local_.decl.recursive != NULL)
  1788.     ffelex_token_kill (ffestb_local_.decl.recursive);
  1789.   ffelex_token_kill (ffestb_local_.decl.kindt);
  1790.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  1791.             ffestb_local_.decl.badname,
  1792.             t);
  1793.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1794. }
  1795.  
  1796. #endif
  1797. /* ffestb_subr_label_list_ -- Collect a tokenlist of labels and close-paren
  1798.  
  1799.    return ffestb_subr_label_list_;  // to lexer after seeing OPEN_PAREN
  1800.  
  1801.    First token must be a NUMBER.  Must be followed by zero or more COMMA
  1802.    NUMBER pairs.  Must then be followed by a CLOSE_PAREN.  If all ok, put
  1803.    the NUMBER tokens in a token list and return via the handler for the
  1804.    token after CLOSE_PAREN.  Else return via
  1805.    same handler, but with the ok return value set FALSE.  */
  1806.  
  1807. static ffelexHandler
  1808. ffestb_subr_label_list_ (ffelexToken t)
  1809. {
  1810.   if (ffelex_token_type (t) == FFELEX_typeNUMBER)
  1811.     {
  1812.       ffestt_tokenlist_append (ffestb_subrargs_.label_list.labels,
  1813.                    ffelex_token_use (t));
  1814.       return (ffelexHandler) ffestb_subr_label_list_1_;
  1815.     }
  1816.  
  1817.   ffestb_subrargs_.label_list.ok = FALSE;
  1818.   return (ffelexHandler) (*ffestb_subrargs_.label_list.handler) (t);
  1819. }
  1820.  
  1821. /* ffestb_subr_label_list_1_ -- NUMBER
  1822.  
  1823.    return ffestb_subr_label_list_1_;  // to lexer after seeing NUMBER
  1824.  
  1825.    The next token must be COMMA, in which case go back to
  1826.    ffestb_subr_label_list_, or CLOSE_PAREN, in which case set ok to TRUE
  1827.    and go to the handler.  */
  1828.  
  1829. static ffelexHandler
  1830. ffestb_subr_label_list_1_ (ffelexToken t)
  1831. {
  1832.   switch (ffelex_token_type (t))
  1833.     {
  1834.     case FFELEX_typeCOMMA:
  1835.       return (ffelexHandler) ffestb_subr_label_list_;
  1836.  
  1837.     case FFELEX_typeCLOSE_PAREN:
  1838.       ffestb_subrargs_.label_list.ok = TRUE;
  1839.       return (ffelexHandler) ffestb_subrargs_.label_list.handler;
  1840.  
  1841.     default:
  1842.       ffestb_subrargs_.label_list.ok = FALSE;
  1843.       return (ffelexHandler) (*ffestb_subrargs_.label_list.handler) (t);
  1844.     }
  1845. }
  1846.  
  1847. /* ffestb_unimplemented -- Report a not-implemented error for stmt
  1848.  
  1849.    return ffestb_unimplemented;     // to lexer after seeing EOS
  1850.  
  1851.    Issue an error via ffest_ffebad_start and return via ffesta_zero.  */
  1852.  
  1853. ffelexHandler
  1854. ffestb_unimplemented (ffelexToken t)
  1855. {
  1856.   ffesta_ffebad_1t (FFEBAD_UNIMPL_STMT, ffesta_tokens[0]);
  1857.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  1858. }
  1859.  
  1860. /* ffestb_do -- Parse the DO statement
  1861.  
  1862.    return ffestb_do;  // to lexer
  1863.  
  1864.    Make sure the statement has a valid form for the DO statement.  If it
  1865.    does, implement the statement.  */
  1866.  
  1867. ffelexHandler
  1868. ffestb_do (ffelexToken t)
  1869. {
  1870.   ffeTokenLength i;
  1871.   char *p;
  1872.   ffelexHandler next;
  1873.   ffelexToken nt;
  1874.   ffestrSecond kw;
  1875.  
  1876.   switch (ffelex_token_type (ffesta_tokens[0]))
  1877.     {
  1878.     case FFELEX_typeNAME:
  1879.       if (ffesta_first_kw != FFESTR_firstDO)
  1880.     goto bad_0;        /* :::::::::::::::::::: */
  1881.       switch (ffelex_token_type (t))
  1882.     {
  1883.     case FFELEX_typeNUMBER:
  1884.       ffesta_confirmed ();
  1885.       ffesta_tokens[1] = ffelex_token_use (t);
  1886.       return (ffelexHandler) ffestb_do1_;
  1887.  
  1888.     case FFELEX_typeCOMMA:
  1889.       ffesta_confirmed ();
  1890.       ffesta_tokens[1] = NULL;
  1891.       return (ffelexHandler) ffestb_do2_;
  1892.  
  1893.     case FFELEX_typeNAME:
  1894.       ffesta_confirmed ();
  1895.       ffesta_tokens[1] = NULL;
  1896.       ffesta_tokens[2] = ffelex_token_use (t);
  1897.       return (ffelexHandler) ffestb_do3_;
  1898.  
  1899.     case FFELEX_typeEOS:
  1900.     case FFELEX_typeSEMICOLON:
  1901.       ffesta_confirmed ();
  1902.       ffesta_tokens[1] = NULL;
  1903.       return (ffelexHandler) ffestb_do1_ (t);
  1904.  
  1905.     case FFELEX_typeCOLONCOLON:
  1906.       ffesta_confirmed ();    /* Error, but clearly intended. */
  1907.       goto bad_1;        /* :::::::::::::::::::: */
  1908.  
  1909.     default:
  1910.       goto bad_1;        /* :::::::::::::::::::: */
  1911.     }
  1912.  
  1913.     case FFELEX_typeNAMES:
  1914.       if (ffesta_first_kw != FFESTR_firstDO)
  1915.     goto bad_0;        /* :::::::::::::::::::: */
  1916.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDO);
  1917.       switch (ffelex_token_type (t))
  1918.     {
  1919.     case FFELEX_typeCOLONCOLON:
  1920.       ffesta_confirmed ();    /* Error, but clearly intended. */
  1921.       goto bad_1;        /* :::::::::::::::::::: */
  1922.  
  1923.     default:
  1924.       goto bad_1;        /* :::::::::::::::::::: */
  1925.  
  1926.     case FFELEX_typeOPEN_PAREN:    /* Must be "DO" label "WHILE". */
  1927.       if (!isdigit (*p))
  1928.         goto bad_i;        /* :::::::::::::::::::: */
  1929.       ffesta_tokens[1] = ffelex_token_number_from_names (ffesta_tokens[0],
  1930.                                  i);
  1931.       p += ffelex_token_length (ffesta_tokens[1]);
  1932.       i += ffelex_token_length (ffesta_tokens[1]);
  1933.       if (((*p) != 'W') && ((*p) != 'w'))
  1934.         goto bad_i1;    /* :::::::::::::::::::: */
  1935.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  1936.       kw = ffestr_second (nt);
  1937.       ffelex_token_kill (nt);
  1938.       if (kw != FFESTR_secondWHILE)
  1939.         goto bad_i1;    /* :::::::::::::::::::: */
  1940.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  1941.              FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
  1942.  
  1943.     case FFELEX_typeCOMMA:
  1944.       ffesta_confirmed ();
  1945.       if (*p == '\0')
  1946.         {
  1947.           ffesta_tokens[1] = NULL;
  1948.           return (ffelexHandler) ffestb_do2_;
  1949.         }
  1950.       if (!isdigit (*p))
  1951.         goto bad_i;        /* :::::::::::::::::::: */
  1952.       ffesta_tokens[1] = ffelex_token_number_from_names (ffesta_tokens[0],
  1953.                                  i);
  1954.       p += ffelex_token_length (ffesta_tokens[1]);
  1955.       i += ffelex_token_length (ffesta_tokens[1]);
  1956.       if (*p != '\0')
  1957.         goto bad_i1;    /* :::::::::::::::::::: */
  1958.       return (ffelexHandler) ffestb_do2_;
  1959.  
  1960.     case FFELEX_typeEQUALS:
  1961.       if (isdigit (*p))
  1962.         {
  1963.           ffesta_tokens[1]
  1964.         = ffelex_token_number_from_names (ffesta_tokens[0], i);
  1965.           p += ffelex_token_length (ffesta_tokens[1]);
  1966.           i += ffelex_token_length (ffesta_tokens[1]);
  1967.         }
  1968.       else
  1969.         ffesta_tokens[1] = NULL;
  1970.       if (!ffesrc_is_name_init (*p))
  1971.         goto bad_i1;    /* :::::::::::::::::::: */
  1972.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  1973.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_lhs
  1974.                     (ffesta_output_pool, FFEEXPR_contextDO,
  1975.                      (ffeexprCallback) ffestb_do6_)))
  1976.         (nt);
  1977.       ffelex_token_kill (nt);    /* Will get it back in _6_... */
  1978.       return (ffelexHandler) (*next) (t);
  1979.  
  1980.     case FFELEX_typeEOS:
  1981.     case FFELEX_typeSEMICOLON:
  1982.       ffesta_confirmed ();
  1983.       if (isdigit (*p))
  1984.         {
  1985.           ffesta_tokens[1]
  1986.         = ffelex_token_number_from_names (ffesta_tokens[0], i);
  1987.           p += ffelex_token_length (ffesta_tokens[1]);
  1988.           i += ffelex_token_length (ffesta_tokens[1]);
  1989.         }
  1990.       else
  1991.         ffesta_tokens[1] = NULL;
  1992.       if (*p != '\0')
  1993.         goto bad_i1;    /* :::::::::::::::::::: */
  1994.       return (ffelexHandler) ffestb_do1_ (t);
  1995.     }
  1996.  
  1997.     default:
  1998.       goto bad_0;        /* :::::::::::::::::::: */
  1999.     }
  2000.  
  2001. bad_0:                /* :::::::::::::::::::: */
  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", ffesta_tokens[0]);
  2008.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2009.  
  2010. bad_1:                /* :::::::::::::::::::: */
  2011.   if (ffesta_construct_name != NULL)
  2012.     {
  2013.       ffelex_token_kill (ffesta_construct_name);
  2014.       ffesta_construct_name = NULL;
  2015.     }
  2016.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
  2017.   return (ffelexHandler) ffelex_swallow_tokens (t,
  2018.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  2019.  
  2020. bad_i1:            /* :::::::::::::::::::: */
  2021.   if (ffesta_tokens[1])
  2022.     ffelex_token_kill (ffesta_tokens[1]);
  2023.  
  2024. bad_i:                /* :::::::::::::::::::: */
  2025.   if (ffesta_construct_name != NULL)
  2026.     {
  2027.       ffelex_token_kill (ffesta_construct_name);
  2028.       ffesta_construct_name = NULL;
  2029.     }
  2030.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0], i, t);
  2031.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2032. }
  2033.  
  2034. /* ffestb_dowhile -- Parse the DOWHILE statement
  2035.  
  2036.    return ffestb_dowhile;  // to lexer
  2037.  
  2038.    Make sure the statement has a valid form for the DOWHILE statement.    If it
  2039.    does, implement the statement.  */
  2040.  
  2041. ffelexHandler
  2042. ffestb_dowhile (ffelexToken t)
  2043. {
  2044.   ffeTokenLength i;
  2045.   char *p;
  2046.   ffelexHandler next;
  2047.   ffelexToken nt;
  2048.  
  2049.   switch (ffelex_token_type (ffesta_tokens[0]))
  2050.     {
  2051.     case FFELEX_typeNAMES:
  2052.       if (ffesta_first_kw != FFESTR_firstDOWHILE)
  2053.     goto bad_0;        /* :::::::::::::::::::: */
  2054.       switch (ffelex_token_type (t))
  2055.     {
  2056.     case FFELEX_typeEOS:
  2057.     case FFELEX_typeSEMICOLON:
  2058.     case FFELEX_typeCOMMA:
  2059.     case FFELEX_typeCOLONCOLON:
  2060.       ffesta_confirmed ();    /* Error, but clearly intended. */
  2061.       goto bad_1;        /* :::::::::::::::::::: */
  2062.  
  2063.     default:
  2064.       goto bad_1;        /* :::::::::::::::::::: */
  2065.  
  2066.     case FFELEX_typeOPEN_PAREN:
  2067.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDOWHILE);
  2068.       if (*p != '\0')
  2069.         goto bad_i;        /* :::::::::::::::::::: */
  2070.       ffesta_tokens[1] = NULL;
  2071.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  2072.              FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
  2073.  
  2074.     case FFELEX_typeEQUALS:/* Not really DOWHILE, but DOWHILExyz=.... */
  2075.       ffesta_tokens[1] = NULL;
  2076.       nt = ffelex_token_name_from_names (ffesta_tokens[0], FFESTR_firstlDO,
  2077.                          0);
  2078.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_lhs
  2079.                     (ffesta_output_pool, FFEEXPR_contextDO,
  2080.                      (ffeexprCallback) ffestb_do6_)))
  2081.         (nt);
  2082.       ffelex_token_kill (nt);    /* Will get it back in _6_... */
  2083.       return (ffelexHandler) (*next) (t);
  2084.     }
  2085.  
  2086.     default:
  2087.       goto bad_0;        /* :::::::::::::::::::: */
  2088.     }
  2089.  
  2090. bad_0:                /* :::::::::::::::::::: */
  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", ffesta_tokens[0]);
  2097.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2098.  
  2099. bad_1:                /* :::::::::::::::::::: */
  2100.   if (ffesta_construct_name != NULL)
  2101.     {
  2102.       ffelex_token_kill (ffesta_construct_name);
  2103.       ffesta_construct_name = NULL;
  2104.     }
  2105.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
  2106.   return (ffelexHandler) ffelex_swallow_tokens (t,
  2107.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  2108.  
  2109. bad_i:                /* :::::::::::::::::::: */
  2110.   if (ffesta_construct_name != NULL)
  2111.     {
  2112.       ffelex_token_kill (ffesta_construct_name);
  2113.       ffesta_construct_name = NULL;
  2114.     }
  2115.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[0], i, t);
  2116.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2117. }
  2118.  
  2119. /* ffestb_do1_ -- "DO" [label]
  2120.  
  2121.    return ffestb_do1_;    // to lexer
  2122.  
  2123.    Make sure the statement has a valid form for the DO statement.  If it
  2124.    does, implement the statement.  */
  2125.  
  2126. static ffelexHandler
  2127. ffestb_do1_ (ffelexToken t)
  2128. {
  2129.   switch (ffelex_token_type (t))
  2130.     {
  2131.     case FFELEX_typeCOMMA:
  2132.       ffesta_confirmed ();
  2133.       return (ffelexHandler) ffestb_do2_;
  2134.  
  2135.     case FFELEX_typeEOS:
  2136.     case FFELEX_typeSEMICOLON:
  2137.       ffesta_confirmed ();
  2138.       if (!ffesta_is_inhibited ())
  2139.     {
  2140.       if (ffesta_tokens[1] != NULL)
  2141.         ffestc_R819B (ffesta_construct_name, ffesta_tokens[1], NULL,
  2142.               NULL);
  2143.       else
  2144.         ffestc_R820B (ffesta_construct_name, NULL, NULL);
  2145.     }
  2146.       if (ffesta_tokens[1] != NULL)
  2147.     ffelex_token_kill (ffesta_tokens[1]);
  2148.       if (ffesta_construct_name != NULL)
  2149.     {
  2150.       ffelex_token_kill (ffesta_construct_name);
  2151.       ffesta_construct_name = NULL;
  2152.     }
  2153.       return (ffelexHandler) ffesta_zero (t);
  2154.  
  2155.     case FFELEX_typeNAME:
  2156.       return (ffelexHandler) ffestb_do2_ (t);
  2157.  
  2158.     default:
  2159.       break;
  2160.     }
  2161.  
  2162.   if (ffesta_tokens[1] != NULL)
  2163.     ffelex_token_kill (ffesta_tokens[1]);
  2164.   if (ffesta_construct_name != NULL)
  2165.     {
  2166.       ffelex_token_kill (ffesta_construct_name);
  2167.       ffesta_construct_name = NULL;
  2168.     }
  2169.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
  2170.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2171. }
  2172.  
  2173. /* ffestb_do2_ -- "DO" [label] [,]
  2174.  
  2175.    return ffestb_do2_;    // to lexer
  2176.  
  2177.    Make sure the statement has a valid form for the DO statement.  If it
  2178.    does, implement the statement.  */
  2179.  
  2180. static ffelexHandler
  2181. ffestb_do2_ (ffelexToken t)
  2182. {
  2183.   switch (ffelex_token_type (t))
  2184.     {
  2185.     case FFELEX_typeNAME:
  2186.       ffesta_tokens[2] = ffelex_token_use (t);
  2187.       return (ffelexHandler) ffestb_do3_;
  2188.  
  2189.     default:
  2190.       break;
  2191.     }
  2192.  
  2193.   if (ffesta_tokens[1] != NULL)
  2194.     ffelex_token_kill (ffesta_tokens[1]);
  2195.   if (ffesta_construct_name != NULL)
  2196.     {
  2197.       ffelex_token_kill (ffesta_construct_name);
  2198.       ffesta_construct_name = NULL;
  2199.     }
  2200.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
  2201.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2202. }
  2203.  
  2204. /* ffestb_do3_ -- "DO" [label] [,] NAME
  2205.  
  2206.    return ffestb_do3_;    // to lexer
  2207.  
  2208.    Make sure the statement has a valid form for the DO statement.  If it
  2209.    does, implement the statement.  */
  2210.  
  2211. static ffelexHandler
  2212. ffestb_do3_ (ffelexToken t)
  2213. {
  2214.   ffelexHandler next;
  2215.  
  2216.   switch (ffelex_token_type (t))
  2217.     {
  2218.     case FFELEX_typeEQUALS:
  2219.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  2220.              FFEEXPR_contextDO, (ffeexprCallback) ffestb_do6_)))
  2221.     (ffesta_tokens[2]);
  2222.       ffelex_token_kill (ffesta_tokens[2]);    /* Will get it back in _6_... */
  2223.       return (ffelexHandler) (*next) (t);
  2224.  
  2225.     case FFELEX_typeOPEN_PAREN:
  2226.       if (ffestr_second (ffesta_tokens[2]) != FFESTR_secondWHILE)
  2227.     {
  2228.       if (ffesta_tokens[1] != NULL)
  2229.         ffelex_token_kill (ffesta_tokens[1]);
  2230.       if (ffesta_construct_name != NULL)
  2231.         {
  2232.           ffelex_token_kill (ffesta_construct_name);
  2233.           ffesta_construct_name = NULL;
  2234.         }
  2235.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", ffesta_tokens[2]);
  2236.       ffelex_token_kill (ffesta_tokens[2]);
  2237.       return (ffelexHandler) ffelex_swallow_tokens (t,
  2238.                            (ffelexHandler) ffesta_zero);    /* Invalid token. */
  2239.     }
  2240.       ffelex_token_kill (ffesta_tokens[2]);
  2241.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  2242.              FFEEXPR_contextDOWHILE, (ffeexprCallback) ffestb_do4_);
  2243.  
  2244.     default:
  2245.       break;
  2246.     }
  2247.  
  2248.   ffelex_token_kill (ffesta_tokens[2]);
  2249.   if (ffesta_tokens[1] != NULL)
  2250.     ffelex_token_kill (ffesta_tokens[1]);
  2251.   if (ffesta_construct_name != NULL)
  2252.     {
  2253.       ffelex_token_kill (ffesta_construct_name);
  2254.       ffesta_construct_name = NULL;
  2255.     }
  2256.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
  2257.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2258. }
  2259.  
  2260. /* ffestb_do4_ -- "DO" [label] [,] "WHILE" OPEN_PAREN expr
  2261.  
  2262.    (ffestb_do4_)  // to expression handler
  2263.  
  2264.    Make sure the statement has a valid form for the DO statement.  If it
  2265.    does, implement the statement.  */
  2266.  
  2267. static ffelexHandler
  2268. ffestb_do4_ (ffelexToken ft, ffebld expr, ffelexToken t)
  2269. {
  2270.   switch (ffelex_token_type (t))
  2271.     {
  2272.     case FFELEX_typeCLOSE_PAREN:
  2273.       if (expr == NULL)
  2274.     break;
  2275.       ffesta_tokens[2] = ffelex_token_use (ft);
  2276.       ffestb_local_.dowhile.expr = expr;
  2277.       return (ffelexHandler) ffestb_do5_;
  2278.  
  2279.     default:
  2280.       break;
  2281.     }
  2282.  
  2283.   if (ffesta_tokens[1] != NULL)
  2284.     ffelex_token_kill (ffesta_tokens[1]);
  2285.   if (ffesta_construct_name != NULL)
  2286.     {
  2287.       ffelex_token_kill (ffesta_construct_name);
  2288.       ffesta_construct_name = NULL;
  2289.     }
  2290.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
  2291.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2292. }
  2293.  
  2294. /* ffestb_do5_ -- "DO" [label] [,] "WHILE" OPEN_PAREN expr CLOSE_PAREN
  2295.  
  2296.    return ffestb_do5_;    // to lexer
  2297.  
  2298.    Make sure the statement has a valid form for the DO statement.  If it
  2299.    does, implement the statement.  */
  2300.  
  2301. static ffelexHandler
  2302. ffestb_do5_ (ffelexToken t)
  2303. {
  2304.   switch (ffelex_token_type (t))
  2305.     {
  2306.     case FFELEX_typeEOS:
  2307.     case FFELEX_typeSEMICOLON:
  2308.       ffesta_confirmed ();
  2309.       if (!ffesta_is_inhibited ())
  2310.     {
  2311.       if (ffesta_tokens[1] != NULL)
  2312.         ffestc_R819B (ffesta_construct_name, ffesta_tokens[1],
  2313.               ffestb_local_.dowhile.expr, ffesta_tokens[2]);
  2314.       else
  2315.         ffestc_R820B (ffesta_construct_name, ffestb_local_.dowhile.expr,
  2316.               ffesta_tokens[2]);
  2317.     }
  2318.       ffelex_token_kill (ffesta_tokens[2]);
  2319.       if (ffesta_tokens[1] != NULL)
  2320.     ffelex_token_kill (ffesta_tokens[1]);
  2321.       if (ffesta_construct_name != NULL)
  2322.     {
  2323.       ffelex_token_kill (ffesta_construct_name);
  2324.       ffesta_construct_name = NULL;
  2325.     }
  2326.       return (ffelexHandler) ffesta_zero (t);
  2327.  
  2328.     default:
  2329.       break;
  2330.     }
  2331.  
  2332.   ffelex_token_kill (ffesta_tokens[2]);
  2333.   if (ffesta_tokens[1] != NULL)
  2334.     ffelex_token_kill (ffesta_tokens[1]);
  2335.   if (ffesta_construct_name != NULL)
  2336.     {
  2337.       ffelex_token_kill (ffesta_construct_name);
  2338.       ffesta_construct_name = NULL;
  2339.     }
  2340.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
  2341.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2342. }
  2343.  
  2344. /* ffestb_do6_ -- "DO" [label] [,] var-expr
  2345.  
  2346.    (ffestb_do6_)  // to expression handler
  2347.  
  2348.    Make sure the statement has a valid form for the DO statement.  If it
  2349.    does, implement the statement.  */
  2350.  
  2351. static ffelexHandler
  2352. ffestb_do6_ (ffelexToken ft, ffebld expr, ffelexToken t)
  2353. {
  2354.   /* _3_ already ensured that this would be an EQUALS token.  If not, it is a
  2355.      bug in the FFE. */
  2356.  
  2357.   assert (ffelex_token_type (t) == FFELEX_typeEQUALS);
  2358.  
  2359.   ffesta_tokens[2] = ffelex_token_use (ft);
  2360.   ffestb_local_.do_stmt.var = expr;
  2361.   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  2362.               FFEEXPR_contextDO, (ffeexprCallback) ffestb_do7_);
  2363. }
  2364.  
  2365. /* ffestb_do7_ -- "DO" [label] [,] var-expr EQUALS expr
  2366.  
  2367.    (ffestb_do7_)  // to expression handler
  2368.  
  2369.    Make sure the statement has a valid form for the DO statement.  If it
  2370.    does, implement the statement.  */
  2371.  
  2372. static ffelexHandler
  2373. ffestb_do7_ (ffelexToken ft, ffebld expr, ffelexToken t)
  2374. {
  2375.   switch (ffelex_token_type (t))
  2376.     {
  2377.     case FFELEX_typeCOMMA:
  2378.       ffesta_confirmed ();
  2379.       if (expr == NULL)
  2380.     break;
  2381.       ffesta_tokens[3] = ffelex_token_use (ft);
  2382.       ffestb_local_.do_stmt.start = expr;
  2383.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  2384.               FFEEXPR_contextDO, (ffeexprCallback) ffestb_do8_);
  2385.  
  2386.     default:
  2387.       break;
  2388.     }
  2389.  
  2390.   ffelex_token_kill (ffesta_tokens[2]);
  2391.   if (ffesta_tokens[1] != NULL)
  2392.     ffelex_token_kill (ffesta_tokens[1]);
  2393.   if (ffesta_construct_name != NULL)
  2394.     {
  2395.       ffelex_token_kill (ffesta_construct_name);
  2396.       ffesta_construct_name = NULL;
  2397.     }
  2398.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
  2399.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2400. }
  2401.  
  2402. /* ffestb_do8_ -- "DO" [label] [,] var-expr EQUALS expr COMMA expr
  2403.  
  2404.    (ffestb_do8_)  // to expression handler
  2405.  
  2406.    Make sure the statement has a valid form for the DO statement.  If it
  2407.    does, implement the statement.  */
  2408.  
  2409. static ffelexHandler
  2410. ffestb_do8_ (ffelexToken ft, ffebld expr, ffelexToken t)
  2411. {
  2412.   switch (ffelex_token_type (t))
  2413.     {
  2414.     case FFELEX_typeCOMMA:
  2415.       if (expr == NULL)
  2416.     break;
  2417.       ffesta_tokens[4] = ffelex_token_use (ft);
  2418.       ffestb_local_.do_stmt.end = expr;
  2419.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  2420.               FFEEXPR_contextDO, (ffeexprCallback) ffestb_do9_);
  2421.  
  2422.     case FFELEX_typeEOS:
  2423.     case FFELEX_typeSEMICOLON:
  2424.       if (expr == NULL)
  2425.     break;
  2426.       ffesta_tokens[4] = ffelex_token_use (ft);
  2427.       ffestb_local_.do_stmt.end = expr;
  2428.       return (ffelexHandler) ffestb_do9_ (NULL, NULL, t);
  2429.  
  2430.     default:
  2431.       break;
  2432.     }
  2433.  
  2434.   ffelex_token_kill (ffesta_tokens[3]);
  2435.   ffelex_token_kill (ffesta_tokens[2]);
  2436.   if (ffesta_tokens[1] != NULL)
  2437.     ffelex_token_kill (ffesta_tokens[1]);
  2438.   if (ffesta_construct_name != NULL)
  2439.     {
  2440.       ffelex_token_kill (ffesta_construct_name);
  2441.       ffesta_construct_name = NULL;
  2442.     }
  2443.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
  2444.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2445. }
  2446.  
  2447. /* ffestb_do9_ -- "DO" [label] [,] var-expr EQUALS expr COMMA expr
  2448.           [COMMA expr]
  2449.  
  2450.    (ffestb_do9_)  // to expression handler
  2451.  
  2452.    Make sure the statement has a valid form for the DO statement.  If it
  2453.    does, implement the statement.  */
  2454.  
  2455. static ffelexHandler
  2456. ffestb_do9_ (ffelexToken ft, ffebld expr, ffelexToken t)
  2457. {
  2458.   switch (ffelex_token_type (t))
  2459.     {
  2460.     case FFELEX_typeEOS:
  2461.     case FFELEX_typeSEMICOLON:
  2462.       if ((expr == NULL) && (ft != NULL))
  2463.     break;
  2464.       if (!ffesta_is_inhibited ())
  2465.     {
  2466.       if (ffesta_tokens[1] != NULL)
  2467.         ffestc_R819A (ffesta_construct_name, ffesta_tokens[1],
  2468.               ffestb_local_.do_stmt.var, ffesta_tokens[2],
  2469.               ffestb_local_.do_stmt.start, ffesta_tokens[3],
  2470.              ffestb_local_.do_stmt.end, ffesta_tokens[4], expr, ft);
  2471.       else
  2472.         ffestc_R820A (ffesta_construct_name, ffestb_local_.do_stmt.var,
  2473.               ffesta_tokens[2], ffestb_local_.do_stmt.start,
  2474.               ffesta_tokens[3], ffestb_local_.do_stmt.end,
  2475.               ffesta_tokens[4], expr, ft);
  2476.     }
  2477.       ffelex_token_kill (ffesta_tokens[4]);
  2478.       ffelex_token_kill (ffesta_tokens[3]);
  2479.       ffelex_token_kill (ffesta_tokens[2]);
  2480.       if (ffesta_tokens[1] != NULL)
  2481.     ffelex_token_kill (ffesta_tokens[1]);
  2482.       if (ffesta_construct_name != NULL)
  2483.     {
  2484.       ffelex_token_kill (ffesta_construct_name);
  2485.       ffesta_construct_name = NULL;
  2486.     }
  2487.  
  2488.       return (ffelexHandler) ffesta_zero (t);
  2489.  
  2490.     default:
  2491.       break;
  2492.     }
  2493.  
  2494.   ffelex_token_kill (ffesta_tokens[4]);
  2495.   ffelex_token_kill (ffesta_tokens[3]);
  2496.   ffelex_token_kill (ffesta_tokens[2]);
  2497.   if (ffesta_tokens[1] != NULL)
  2498.     ffelex_token_kill (ffesta_tokens[1]);
  2499.   if (ffesta_construct_name != NULL)
  2500.     {
  2501.       ffelex_token_kill (ffesta_construct_name);
  2502.       ffesta_construct_name = NULL;
  2503.     }
  2504.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DO", t);
  2505.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2506. }
  2507.  
  2508. /* ffestb_else -- Parse the ELSE statement
  2509.  
  2510.    return ffestb_else;    // to lexer
  2511.  
  2512.    Make sure the statement has a valid form for the ELSE statement.  If it
  2513.    does, implement the statement.  */
  2514.  
  2515. ffelexHandler
  2516. ffestb_else (ffelexToken t)
  2517. {
  2518.   ffeTokenLength i;
  2519.   char *p;
  2520.  
  2521.   switch (ffelex_token_type (ffesta_tokens[0]))
  2522.     {
  2523.     case FFELEX_typeNAME:
  2524.       if (ffesta_first_kw != FFESTR_firstELSE)
  2525.     goto bad_0;        /* :::::::::::::::::::: */
  2526.       switch (ffelex_token_type (t))
  2527.     {
  2528.     case FFELEX_typeEOS:
  2529.     case FFELEX_typeSEMICOLON:
  2530.       ffesta_confirmed ();
  2531.       ffesta_tokens[1] = NULL;
  2532.       ffestb_args.elsexyz.second = FFESTR_secondNone;
  2533.       return (ffelexHandler) ffestb_else1_ (t);
  2534.  
  2535.     case FFELEX_typeCOMMA:
  2536.     case FFELEX_typeCOLONCOLON:
  2537.       ffesta_confirmed ();    /* Error, but clearly intended. */
  2538.       goto bad_1;        /* :::::::::::::::::::: */
  2539.  
  2540.     default:
  2541.       goto bad_1;        /* :::::::::::::::::::: */
  2542.  
  2543.     case FFELEX_typeNAME:
  2544.       break;
  2545.     }
  2546.  
  2547.       ffesta_confirmed ();
  2548.       ffestb_args.elsexyz.second = ffesta_second_kw;
  2549.       ffesta_tokens[1] = ffelex_token_use (t);
  2550.       return (ffelexHandler) ffestb_else1_;
  2551.  
  2552.     case FFELEX_typeNAMES:
  2553.       if (ffesta_first_kw != FFESTR_firstELSE)
  2554.     goto bad_0;        /* :::::::::::::::::::: */
  2555.       switch (ffelex_token_type (t))
  2556.     {
  2557.     case FFELEX_typeCOMMA:
  2558.     case FFELEX_typeCOLONCOLON:
  2559.       ffesta_confirmed ();    /* Error, but clearly intended. */
  2560.       goto bad_1;        /* :::::::::::::::::::: */
  2561.  
  2562.     default:
  2563.       goto bad_1;        /* :::::::::::::::::::: */
  2564.  
  2565.     case FFELEX_typeEOS:
  2566.     case FFELEX_typeSEMICOLON:
  2567.       break;
  2568.     }
  2569.       ffesta_confirmed ();
  2570.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlELSE)
  2571.     {
  2572.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlELSE);
  2573.       if (!ffesrc_is_name_init (*p))
  2574.         goto bad_i;        /* :::::::::::::::::::: */
  2575.       ffesta_tokens[1]
  2576.         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  2577.     }
  2578.       else
  2579.     ffesta_tokens[1] = NULL;
  2580.       ffestb_args.elsexyz.second = FFESTR_secondNone;
  2581.       return (ffelexHandler) ffestb_else1_ (t);
  2582.  
  2583.     default:
  2584.       goto bad_0;        /* :::::::::::::::::::: */
  2585.     }
  2586.  
  2587. bad_0:                /* :::::::::::::::::::: */
  2588.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0]);
  2589.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2590.  
  2591. bad_1:                /* :::::::::::::::::::: */
  2592.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
  2593.   return (ffelexHandler) ffelex_swallow_tokens (t,
  2594.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  2595.  
  2596. bad_i:                /* :::::::::::::::::::: */
  2597.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0], i, t);
  2598.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2599. }
  2600.  
  2601. /* ffestb_elsexyz -- Parse an ELSEIF/ELSEWHERE statement
  2602.  
  2603.    return ffestb_elsexyz;  // to lexer
  2604.  
  2605.    Expects len and second to be set in ffestb_args.elsexyz to the length
  2606.    of the ELSExyz keyword involved and the corresponding ffestrSecond value.  */
  2607.  
  2608. ffelexHandler
  2609. ffestb_elsexyz (ffelexToken t)
  2610. {
  2611.   ffeTokenLength i;
  2612.   char *p;
  2613.  
  2614.   switch (ffelex_token_type (ffesta_tokens[0]))
  2615.     {
  2616.     case FFELEX_typeNAME:
  2617.       switch (ffelex_token_type (t))
  2618.     {
  2619.     case FFELEX_typeEOS:
  2620.     case FFELEX_typeSEMICOLON:
  2621.       if (ffesta_first_kw == FFESTR_firstELSEIF)
  2622.         goto bad_0;        /* :::::::::::::::::::: */
  2623.       ffesta_confirmed ();
  2624.       ffesta_tokens[1] = NULL;
  2625.       return (ffelexHandler) ffestb_else1_ (t);
  2626.  
  2627.     case FFELEX_typeNAME:
  2628.       ffesta_confirmed ();
  2629.       goto bad_1;        /* :::::::::::::::::::: */
  2630.  
  2631.     case FFELEX_typeOPEN_PAREN:
  2632.       if (ffesta_first_kw != FFESTR_firstELSEIF)
  2633.         goto bad_0;        /* :::::::::::::::::::: */
  2634.       ffesta_tokens[1] = NULL;
  2635.       return (ffelexHandler) ffestb_else1_ (t);
  2636.  
  2637.     case FFELEX_typeCOMMA:
  2638.     case FFELEX_typeCOLONCOLON:
  2639.       ffesta_confirmed ();    /* Error, but clearly intended. */
  2640.       goto bad_1;        /* :::::::::::::::::::: */
  2641.  
  2642.     default:
  2643.       goto bad_1;        /* :::::::::::::::::::: */
  2644.     }
  2645.  
  2646.     case FFELEX_typeNAMES:
  2647.       switch (ffelex_token_type (t))
  2648.     {
  2649.     case FFELEX_typeCOMMA:
  2650.     case FFELEX_typeCOLONCOLON:
  2651.       ffesta_confirmed ();    /* Error, but clearly intended. */
  2652.       goto bad_1;        /* :::::::::::::::::::: */
  2653.  
  2654.     default:
  2655.       goto bad_1;        /* :::::::::::::::::::: */
  2656.  
  2657.     case FFELEX_typeOPEN_PAREN:
  2658.       if (ffesta_first_kw != FFESTR_firstELSEIF)
  2659.         goto bad_1;        /* :::::::::::::::::::: */
  2660.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlELSEIF)
  2661.         {
  2662.           i = FFESTR_firstlELSEIF;
  2663.           goto bad_i;    /* :::::::::::::::::::: */
  2664.         }
  2665.       ffesta_tokens[1] = NULL;
  2666.       return (ffelexHandler) ffestb_else1_ (t);
  2667.  
  2668.     case FFELEX_typeEOS:
  2669.     case FFELEX_typeSEMICOLON:
  2670.       break;
  2671.     }
  2672.       ffesta_confirmed ();
  2673.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlELSE);
  2674.       ffesta_tokens[1]
  2675.     = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  2676. #if FFESTR_F90
  2677.       if ((ffestb_args.elsexyz.second == FFESTR_secondWHERE)
  2678.       && (ffelex_token_length (ffesta_tokens[1]) != FFESTR_secondlWHERE))
  2679.     ffestb_args.elsexyz.second = FFESTR_secondNone;
  2680. #endif
  2681.       return (ffelexHandler) ffestb_else1_ (t);
  2682.  
  2683.     default:
  2684.       goto bad_0;        /* :::::::::::::::::::: */
  2685.     }
  2686.  
  2687. bad_0:                /* :::::::::::::::::::: */
  2688.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", ffesta_tokens[0]);
  2689.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2690.  
  2691. bad_1:                /* :::::::::::::::::::: */
  2692.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
  2693.   return (ffelexHandler) ffelex_swallow_tokens (t,
  2694.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  2695.  
  2696. bad_i:                /* :::::::::::::::::::: */
  2697.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE IF", ffesta_tokens[0], i, t);
  2698.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2699. }
  2700.  
  2701. /* ffestb_else1_ -- "ELSE" (NAME)
  2702.  
  2703.    return ffestb_else1_;  // to lexer
  2704.  
  2705.    If EOS/SEMICOLON, implement the appropriate statement (keep in mind that
  2706.    "ELSE WHERE" is ambiguous at the syntactic level).  If OPEN_PAREN, start
  2707.    expression analysis with callback at _2_.  */
  2708.  
  2709. static ffelexHandler
  2710. ffestb_else1_ (ffelexToken t)
  2711. {
  2712.   switch (ffelex_token_type (t))
  2713.     {
  2714.     case FFELEX_typeOPEN_PAREN:
  2715.       if (ffestb_args.elsexyz.second == FFESTR_secondIF)
  2716.     {
  2717.       if (ffesta_tokens[1] != NULL)
  2718.         ffelex_token_kill (ffesta_tokens[1]);
  2719.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  2720.             FFEEXPR_contextIF, (ffeexprCallback) ffestb_else2_);
  2721.     }
  2722.       /* Fall through. */
  2723.     default:
  2724.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE", t);
  2725.       if (ffesta_tokens[1] != NULL)
  2726.     ffelex_token_kill (ffesta_tokens[1]);
  2727.       return (ffelexHandler) ffelex_swallow_tokens (t,
  2728.                            (ffelexHandler) ffesta_zero);
  2729.  
  2730.     case FFELEX_typeEOS:
  2731.     case FFELEX_typeSEMICOLON:
  2732.       ffesta_confirmed ();
  2733.       break;
  2734.  
  2735.     }
  2736.  
  2737.   switch (ffestb_args.elsexyz.second)
  2738.     {
  2739. #if FFESTR_F90
  2740.     case FFESTR_secondWHERE:
  2741.       if (!ffesta_is_inhibited ())
  2742.     if ((ffesta_first_kw == FFESTR_firstELSEWHERE)
  2743.         && (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME))
  2744.       ffestc_R744 ();
  2745.     else
  2746.       ffestc_elsewhere (ffesta_tokens[1]);    /* R744 or R805. */
  2747.       break;
  2748. #endif
  2749.  
  2750.     default:
  2751.       if (!ffesta_is_inhibited ())
  2752.     ffestc_R805 (ffesta_tokens[1]);
  2753.       break;
  2754.     }
  2755.  
  2756.   if (ffesta_tokens[1] != NULL)
  2757.     ffelex_token_kill (ffesta_tokens[1]);
  2758.   return (ffelexHandler) ffesta_zero (t);
  2759. }
  2760.  
  2761. /* ffestb_else2_ -- "ELSE" "IF" OPEN_PAREN expr
  2762.  
  2763.    (ffestb_else2_)  // to expression handler
  2764.  
  2765.    Make sure the next token is CLOSE_PAREN.  */
  2766.  
  2767. static ffelexHandler
  2768. ffestb_else2_ (ffelexToken ft, ffebld expr, ffelexToken t)
  2769. {
  2770.   ffestb_local_.else_stmt.expr = expr;
  2771.  
  2772.   switch (ffelex_token_type (t))
  2773.     {
  2774.     case FFELEX_typeCLOSE_PAREN:
  2775.       if (expr == NULL)
  2776.     break;
  2777.       ffesta_tokens[1] = ffelex_token_use (ft);
  2778.       ffelex_set_names (TRUE);
  2779.       return (ffelexHandler) ffestb_else3_;
  2780.  
  2781.     default:
  2782.       break;
  2783.     }
  2784.  
  2785.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
  2786.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2787. }
  2788.  
  2789. /* ffestb_else3_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN
  2790.  
  2791.    return ffestb_else3_;  // to lexer
  2792.  
  2793.    Make sure the next token is "THEN".    */
  2794.  
  2795. static ffelexHandler
  2796. ffestb_else3_ (ffelexToken t)
  2797. {
  2798.   ffeTokenLength i;
  2799.   char *p;
  2800.  
  2801.   ffelex_set_names (FALSE);
  2802.  
  2803.   switch (ffelex_token_type (t))
  2804.     {
  2805.     case FFELEX_typeNAME:
  2806.       ffesta_confirmed ();
  2807.       if (ffestr_first (t) == FFESTR_firstTHEN)
  2808.     return (ffelexHandler) ffestb_else4_;
  2809.       break;
  2810.  
  2811.     case FFELEX_typeNAMES:
  2812.       ffesta_confirmed ();
  2813.       if (ffestr_first (t) != FFESTR_firstTHEN)
  2814.     break;
  2815.       if (ffelex_token_length (t) == FFESTR_firstlTHEN)
  2816.     return (ffelexHandler) ffestb_else4_;
  2817.       p = ffelex_token_text (t) + (i = FFESTR_firstlTHEN);
  2818.       if (!ffesrc_is_name_init (*p))
  2819.     goto bad_i;        /* :::::::::::::::::::: */
  2820.       ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
  2821.       return (ffelexHandler) ffestb_else5_;
  2822.  
  2823.     default:
  2824.       break;
  2825.     }
  2826.  
  2827.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
  2828.   ffelex_token_kill (ffesta_tokens[1]);
  2829.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2830.  
  2831. bad_i:                /* :::::::::::::::::::: */
  2832.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t, i, NULL);
  2833.   ffelex_token_kill (ffesta_tokens[1]);
  2834.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2835. }
  2836.  
  2837. /* ffestb_else4_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN "THEN"
  2838.  
  2839.    return ffestb_else4_;  // to lexer
  2840.  
  2841.    Handle a NAME or EOS/SEMICOLON, then go to state _5_.  */
  2842.  
  2843. static ffelexHandler
  2844. ffestb_else4_ (ffelexToken t)
  2845. {
  2846.   ffelex_set_names (FALSE);
  2847.  
  2848.   switch (ffelex_token_type (t))
  2849.     {
  2850.     case FFELEX_typeEOS:
  2851.     case FFELEX_typeSEMICOLON:
  2852.       ffesta_tokens[2] = NULL;
  2853.       return (ffelexHandler) ffestb_else5_ (t);
  2854.  
  2855.     case FFELEX_typeNAME:
  2856.       ffesta_tokens[2] = ffelex_token_use (t);
  2857.       return (ffelexHandler) ffestb_else5_;
  2858.  
  2859.     default:
  2860.       break;
  2861.     }
  2862.  
  2863.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
  2864.   ffelex_token_kill (ffesta_tokens[1]);
  2865.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2866. }
  2867.  
  2868. /* ffestb_else5_ -- "ELSE" "IF" OPEN_PAREN expr CLOSE_PAREN "THEN"
  2869.  
  2870.    return ffestb_else5_;  // to lexer
  2871.  
  2872.    Make sure the next token is EOS or SEMICOLON; implement R804.  */
  2873.  
  2874. static ffelexHandler
  2875. ffestb_else5_ (ffelexToken t)
  2876. {
  2877.   switch (ffelex_token_type (t))
  2878.     {
  2879.     case FFELEX_typeEOS:
  2880.     case FFELEX_typeSEMICOLON:
  2881.       if (!ffesta_is_inhibited ())
  2882.     ffestc_R804 (ffestb_local_.else_stmt.expr, ffesta_tokens[1],
  2883.              ffesta_tokens[2]);
  2884.       ffelex_token_kill (ffesta_tokens[1]);
  2885.       if (ffesta_tokens[2] != NULL)
  2886.     ffelex_token_kill (ffesta_tokens[2]);
  2887.       return (ffelexHandler) ffesta_zero (t);
  2888.  
  2889.     default:
  2890.       break;
  2891.     }
  2892.  
  2893.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ELSE IF", t);
  2894.   ffelex_token_kill (ffesta_tokens[1]);
  2895.   if (ffesta_tokens[2] != NULL)
  2896.     ffelex_token_kill (ffesta_tokens[2]);
  2897.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  2898. }
  2899.  
  2900. /* ffestb_end -- Parse the END statement
  2901.  
  2902.    return ffestb_end;  // to lexer
  2903.  
  2904.    Make sure the statement has a valid form for the END statement.  If it
  2905.    does, implement the statement.  */
  2906.  
  2907. ffelexHandler
  2908. ffestb_end (ffelexToken t)
  2909. {
  2910.   ffeTokenLength i;
  2911.  
  2912.   switch (ffelex_token_type (ffesta_tokens[0]))
  2913.     {
  2914.     case FFELEX_typeNAME:
  2915.       if (ffesta_first_kw != FFESTR_firstEND)
  2916.     goto bad_0;        /* :::::::::::::::::::: */
  2917.       switch (ffelex_token_type (t))
  2918.     {
  2919.     case FFELEX_typeEOS:
  2920.     case FFELEX_typeSEMICOLON:
  2921.       ffesta_tokens[1] = NULL;
  2922.       ffestb_args.endxyz.second = FFESTR_secondNone;
  2923.       return (ffelexHandler) ffestb_end3_ (t);
  2924.  
  2925.     case FFELEX_typeCOMMA:
  2926.     case FFELEX_typeCOLONCOLON:
  2927.       ffesta_confirmed ();    /* Error, but clearly intended. */
  2928.       goto bad_1;        /* :::::::::::::::::::: */
  2929.  
  2930.     default:
  2931.       goto bad_1;        /* :::::::::::::::::::: */
  2932.  
  2933.     case FFELEX_typeNAME:
  2934.       break;
  2935.     }
  2936.  
  2937.       ffesta_confirmed ();
  2938.       ffestb_args.endxyz.second = ffesta_second_kw;
  2939.       switch (ffesta_second_kw)
  2940.     {
  2941.     case FFESTR_secondFILE:
  2942.       ffestb_args.beru.badname = "ENDFILE";
  2943.       return (ffelexHandler) ffestb_beru;
  2944.  
  2945.     case FFESTR_secondBLOCK:
  2946.       return (ffelexHandler) ffestb_end1_;
  2947.  
  2948. #if FFESTR_F90
  2949.     case FFESTR_secondINTERFACE:
  2950. #endif
  2951. #if FFESTR_VXT
  2952.     case FFESTR_secondMAP:
  2953.     case FFESTR_secondSTRUCTURE:
  2954.     case FFESTR_secondUNION:
  2955. #endif
  2956. #if FFESTR_F90
  2957.     case FFESTR_secondWHERE:
  2958.       ffesta_tokens[1] = NULL;
  2959.       return (ffelexHandler) ffestb_end3_;
  2960. #endif
  2961.  
  2962.     case FFESTR_secondNone:
  2963.       goto bad_1;        /* :::::::::::::::::::: */
  2964.  
  2965.     default:
  2966.       return (ffelexHandler) ffestb_end2_;
  2967.     }
  2968.  
  2969.     case FFELEX_typeNAMES:
  2970.       if (ffesta_first_kw != FFESTR_firstEND)
  2971.     goto bad_0;        /* :::::::::::::::::::: */
  2972.       switch (ffelex_token_type (t))
  2973.     {
  2974.     case FFELEX_typeCOMMA:
  2975.     case FFELEX_typeCOLONCOLON:
  2976.       ffesta_confirmed ();    /* Error, but clearly intended. */
  2977.       goto bad_1;        /* :::::::::::::::::::: */
  2978.  
  2979.     default:
  2980.       goto bad_1;        /* :::::::::::::::::::: */
  2981.  
  2982.     case FFELEX_typeEOS:
  2983.     case FFELEX_typeSEMICOLON:
  2984.       break;
  2985.     }
  2986.       ffesta_confirmed ();
  2987.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlEND)
  2988.     {
  2989.       i = FFESTR_firstlEND;
  2990.       goto bad_i;        /* :::::::::::::::::::: */
  2991.     }
  2992.       ffesta_tokens[1] = NULL;
  2993.       ffestb_args.endxyz.second = FFESTR_secondNone;
  2994.       return (ffelexHandler) ffestb_end3_ (t);
  2995.  
  2996.     default:
  2997.       goto bad_0;        /* :::::::::::::::::::: */
  2998.     }
  2999.  
  3000. bad_0:                /* :::::::::::::::::::: */
  3001.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
  3002.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3003.  
  3004. bad_1:                /* :::::::::::::::::::: */
  3005.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
  3006.   return (ffelexHandler) ffelex_swallow_tokens (t,
  3007.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  3008.  
  3009. bad_i:                /* :::::::::::::::::::: */
  3010.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0], i, t);
  3011.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3012. }
  3013.  
  3014. /* ffestb_endxyz -- Parse an ENDxyz statement
  3015.  
  3016.    return ffestb_endxyz;  // to lexer
  3017.  
  3018.    Expects len and second to be set in ffestb_args.endxyz to the length
  3019.    of the ENDxyz keyword involved and the corresponding ffestrSecond value.  */
  3020.  
  3021. ffelexHandler
  3022. ffestb_endxyz (ffelexToken t)
  3023. {
  3024.   ffeTokenLength i;
  3025.   char *p;
  3026.  
  3027.   switch (ffelex_token_type (ffesta_tokens[0]))
  3028.     {
  3029.     case FFELEX_typeNAME:
  3030.       switch (ffelex_token_type (t))
  3031.     {
  3032.     case FFELEX_typeEOS:
  3033.     case FFELEX_typeSEMICOLON:
  3034.       ffesta_confirmed ();
  3035.       ffesta_tokens[1] = NULL;
  3036.       return (ffelexHandler) ffestb_end3_ (t);
  3037.  
  3038.     case FFELEX_typeNAME:
  3039.       ffesta_confirmed ();
  3040.       switch (ffestb_args.endxyz.second)
  3041.         {
  3042. #if FFESTR_F90
  3043.         case FFESTR_secondINTERFACE:
  3044. #endif
  3045. #if FFESTR_VXT
  3046.         case FFESTR_secondMAP:
  3047.         case FFESTR_secondSTRUCTURE:
  3048.         case FFESTR_secondUNION:
  3049. #endif
  3050. #if FFESTR_F90
  3051.         case FFESTR_secondWHERE:
  3052.           goto bad_1;    /* :::::::::::::::::::: */
  3053. #endif
  3054.  
  3055.         case FFESTR_secondBLOCK:
  3056.           if (ffesta_second_kw != FFESTR_secondDATA)
  3057.         goto bad_1;    /* :::::::::::::::::::: */
  3058.           return (ffelexHandler) ffestb_end2_;
  3059.  
  3060.         default:
  3061.           return (ffelexHandler) ffestb_end2_ (t);
  3062.         }
  3063.  
  3064.     case FFELEX_typeCOMMA:
  3065.     case FFELEX_typeCOLONCOLON:
  3066.       ffesta_confirmed ();    /* Error, but clearly intended. */
  3067.       goto bad_1;        /* :::::::::::::::::::: */
  3068.  
  3069.     default:
  3070.       goto bad_1;        /* :::::::::::::::::::: */
  3071.     }
  3072.  
  3073.     case FFELEX_typeNAMES:
  3074.       switch (ffelex_token_type (t))
  3075.     {
  3076.     case FFELEX_typeCOMMA:
  3077.     case FFELEX_typeCOLONCOLON:
  3078.       ffesta_confirmed ();    /* Error, but clearly intended. */
  3079.       goto bad_1;        /* :::::::::::::::::::: */
  3080.  
  3081.     default:
  3082.       goto bad_1;        /* :::::::::::::::::::: */
  3083.  
  3084.     case FFELEX_typeEOS:
  3085.     case FFELEX_typeSEMICOLON:
  3086.       break;
  3087.     }
  3088.       ffesta_confirmed ();
  3089.       if (ffestb_args.endxyz.second == FFESTR_secondBLOCK)
  3090.     {
  3091.       i = FFESTR_firstlEND;
  3092.       goto bad_i;        /* :::::::::::::::::::: */
  3093.     }
  3094.       if (ffelex_token_length (ffesta_tokens[0]) != ffestb_args.endxyz.len)
  3095.     {
  3096.       p = ffelex_token_text (ffesta_tokens[0])
  3097.         + (i = ffestb_args.endxyz.len);
  3098.       switch (ffestb_args.endxyz.second)
  3099.         {
  3100. #if FFESTR_F90
  3101.         case FFESTR_secondINTERFACE:
  3102. #endif
  3103. #if FFESTR_VXT
  3104.         case FFESTR_secondMAP:
  3105.         case FFESTR_secondSTRUCTURE:
  3106.         case FFESTR_secondUNION:
  3107. #endif
  3108. #if FFESTR_F90
  3109.         case FFESTR_secondWHERE:
  3110.           goto bad_i;    /* :::::::::::::::::::: */
  3111. #endif
  3112.  
  3113.         default:
  3114.           break;
  3115.         }
  3116.       if (!ffesrc_is_name_init (*p))
  3117.         goto bad_i;        /* :::::::::::::::::::: */
  3118.       ffesta_tokens[1]
  3119.         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  3120.       return (ffelexHandler) ffestb_end3_ (t);
  3121.     }
  3122.       ffesta_tokens[1] = NULL;
  3123.       return (ffelexHandler) ffestb_end3_ (t);
  3124.  
  3125.     default:
  3126.       goto bad_0;        /* :::::::::::::::::::: */
  3127.     }
  3128.  
  3129. bad_0:                /* :::::::::::::::::::: */
  3130.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
  3131.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3132.  
  3133. bad_1:                /* :::::::::::::::::::: */
  3134.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
  3135.   return (ffelexHandler) ffelex_swallow_tokens (t,
  3136.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  3137.  
  3138. bad_i:                /* :::::::::::::::::::: */
  3139.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0], i, t);
  3140.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3141. }
  3142.  
  3143. /* ffestb_end1_ -- "END" "BLOCK"
  3144.  
  3145.    return ffestb_end1_;     // to lexer
  3146.  
  3147.    Make sure the next token is "DATA".    */
  3148.  
  3149. static ffelexHandler
  3150. ffestb_end1_ (ffelexToken t)
  3151. {
  3152.   if ((ffelex_token_type (t) == FFELEX_typeNAME)
  3153.       && (ffesrc_strcmp_2c (ffe_case_match (), ffelex_token_text (t), "DATA",
  3154.                 "data", "Data")
  3155.       == 0))
  3156.     {
  3157.       return (ffelexHandler) ffestb_end2_;
  3158.     }
  3159.  
  3160.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
  3161.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3162. }
  3163.  
  3164. /* ffestb_end2_ -- "END" <unit-kind>
  3165.  
  3166.    return ffestb_end2_;     // to lexer
  3167.  
  3168.    Make sure the next token is a NAME or EOS.  */
  3169.  
  3170. static ffelexHandler
  3171. ffestb_end2_ (ffelexToken t)
  3172. {
  3173.   switch (ffelex_token_type (t))
  3174.     {
  3175.     case FFELEX_typeNAME:
  3176.       ffesta_tokens[1] = ffelex_token_use (t);
  3177.       return (ffelexHandler) ffestb_end3_;
  3178.  
  3179.     case FFELEX_typeEOS:
  3180.     case FFELEX_typeSEMICOLON:
  3181.       ffesta_tokens[1] = NULL;
  3182.       return (ffelexHandler) ffestb_end3_ (t);
  3183.  
  3184.     default:
  3185.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
  3186.       return (ffelexHandler) ffelex_swallow_tokens (t,
  3187.                            (ffelexHandler) ffesta_zero);
  3188.     }
  3189. }
  3190.  
  3191. /* ffestb_end3_ -- "END" <unit-kind> (NAME)
  3192.  
  3193.    return ffestb_end3_;     // to lexer
  3194.  
  3195.    Make sure the next token is an EOS, then implement the statement.  */
  3196.  
  3197. static ffelexHandler
  3198. ffestb_end3_ (ffelexToken t)
  3199. {
  3200.   switch (ffelex_token_type (t))
  3201.     {
  3202.     default:
  3203.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", t);
  3204.       if (ffesta_tokens[1] != NULL)
  3205.     ffelex_token_kill (ffesta_tokens[1]);
  3206.       return (ffelexHandler) ffelex_swallow_tokens (t,
  3207.                            (ffelexHandler) ffesta_zero);
  3208.  
  3209.     case FFELEX_typeEOS:
  3210.     case FFELEX_typeSEMICOLON:
  3211.       ffesta_confirmed ();
  3212.       if (ffestb_args.endxyz.second == FFESTR_secondNone)
  3213.     {
  3214.       if (!ffesta_is_inhibited ())
  3215.         ffestc_end ();
  3216.       return (ffelexHandler) ffesta_zero (t);
  3217.     }
  3218.       break;
  3219.     }
  3220.  
  3221.   switch (ffestb_args.endxyz.second)
  3222.     {
  3223. #if FFESTR_F90
  3224.     case FFESTR_secondTYPE:
  3225.       if (!ffesta_is_inhibited ())
  3226.     ffestc_R425 (ffesta_tokens[1]);
  3227.       break;
  3228. #endif
  3229.  
  3230. #if FFESTR_F90
  3231.     case FFESTR_secondWHERE:
  3232.       if (!ffesta_is_inhibited ())
  3233.     ffestc_R745 ();
  3234.       break;
  3235. #endif
  3236.  
  3237.     case FFESTR_secondIF:
  3238.       if (!ffesta_is_inhibited ())
  3239.     ffestc_R806 (ffesta_tokens[1]);
  3240.       break;
  3241.  
  3242.     case FFESTR_secondSELECT:
  3243.       if (!ffesta_is_inhibited ())
  3244.     ffestc_R811 (ffesta_tokens[1]);
  3245.       break;
  3246.  
  3247.     case FFESTR_secondDO:
  3248.       if (!ffesta_is_inhibited ())
  3249.     ffestc_R825 (ffesta_tokens[1]);
  3250.       break;
  3251.  
  3252.     case FFESTR_secondPROGRAM:
  3253.       if (!ffesta_is_inhibited ())
  3254.     ffestc_R1103 (ffesta_tokens[1]);
  3255.       break;
  3256.  
  3257. #if FFESTR_F90
  3258.     case FFESTR_secondMODULE:
  3259.       if (!ffesta_is_inhibited ())
  3260.     ffestc_R1106 (ffesta_tokens[1]);
  3261.       break;
  3262. #endif
  3263.     case FFESTR_secondBLOCK:
  3264.     case FFESTR_secondBLOCKDATA:
  3265.       if (!ffesta_is_inhibited ())
  3266.     ffestc_R1112 (ffesta_tokens[1]);
  3267.       break;
  3268.  
  3269. #if FFESTR_F90
  3270.     case FFESTR_secondINTERFACE:
  3271.       if (!ffesta_is_inhibited ())
  3272.     ffestc_R1203 ();
  3273.       break;
  3274. #endif
  3275.  
  3276.     case FFESTR_secondFUNCTION:
  3277.       if (!ffesta_is_inhibited ())
  3278.     ffestc_R1221 (ffesta_tokens[1]);
  3279.       break;
  3280.  
  3281.     case FFESTR_secondSUBROUTINE:
  3282.       if (!ffesta_is_inhibited ())
  3283.     ffestc_R1225 (ffesta_tokens[1]);
  3284.       break;
  3285.  
  3286. #if FFESTR_VXT
  3287.     case FFESTR_secondSTRUCTURE:
  3288.       if (!ffesta_is_inhibited ())
  3289.     ffestc_V004 ();
  3290.       break;
  3291. #endif
  3292.  
  3293. #if FFESTR_VXT
  3294.     case FFESTR_secondUNION:
  3295.       if (!ffesta_is_inhibited ())
  3296.     ffestc_V010 ();
  3297.       break;
  3298. #endif
  3299.  
  3300. #if FFESTR_VXT
  3301.     case FFESTR_secondMAP:
  3302.       if (!ffesta_is_inhibited ())
  3303.     ffestc_V013 ();
  3304.       break;
  3305. #endif
  3306.  
  3307.     default:
  3308.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "END", ffesta_tokens[0]);
  3309.       if (ffesta_tokens[1] != NULL)
  3310.     ffelex_token_kill (ffesta_tokens[1]);
  3311.       return (ffelexHandler) ffelex_swallow_tokens (t,
  3312.                            (ffelexHandler) ffesta_zero);
  3313.     }
  3314.  
  3315.   if (ffesta_tokens[1] != NULL)
  3316.     ffelex_token_kill (ffesta_tokens[1]);
  3317.   return (ffelexHandler) ffesta_zero (t);
  3318. }
  3319.  
  3320. /* ffestb_goto -- Parse the GOTO statement
  3321.  
  3322.    return ffestb_goto;    // to lexer
  3323.  
  3324.    Make sure the statement has a valid form for the GOTO statement.  If it
  3325.    does, implement the statement.  */
  3326.  
  3327. ffelexHandler
  3328. ffestb_goto (ffelexToken t)
  3329. {
  3330.   ffeTokenLength i;
  3331.   char *p;
  3332.   ffelexHandler next;
  3333.   ffelexToken nt;
  3334.  
  3335.   switch (ffelex_token_type (ffesta_tokens[0]))
  3336.     {
  3337.     case FFELEX_typeNAME:
  3338.       switch (ffesta_first_kw)
  3339.     {
  3340.     case FFESTR_firstGO:
  3341.       if ((ffelex_token_type (t) != FFELEX_typeNAME)
  3342.           || (ffesta_second_kw != FFESTR_secondTO))
  3343.         goto bad_1;        /* :::::::::::::::::::: */
  3344.       ffesta_confirmed ();
  3345.       return (ffelexHandler) ffestb_goto1_;
  3346.  
  3347.     case FFESTR_firstGOTO:
  3348.       return (ffelexHandler) ffestb_goto1_ (t);
  3349.  
  3350.     default:
  3351.       goto bad_0;        /* :::::::::::::::::::: */
  3352.     }
  3353.  
  3354.     case FFELEX_typeNAMES:
  3355.       if (ffesta_first_kw != FFESTR_firstGOTO)
  3356.     goto bad_0;        /* :::::::::::::::::::: */
  3357.       switch (ffelex_token_type (t))
  3358.     {
  3359.     case FFELEX_typeCOLONCOLON:
  3360.       ffesta_confirmed ();    /* Error, but clearly intended. */
  3361.       goto bad_1;        /* :::::::::::::::::::: */
  3362.  
  3363.     default:
  3364.       goto bad_1;        /* :::::::::::::::::::: */
  3365.  
  3366.     case FFELEX_typeOPEN_PAREN:
  3367.     case FFELEX_typePERCENT:    /* Since GOTO I%J is apparently valid
  3368.                        in '90. */
  3369.     case FFELEX_typeCOMMA:
  3370.       break;
  3371.  
  3372.     case FFELEX_typeEOS:
  3373.     case FFELEX_typeSEMICOLON:
  3374.       ffesta_confirmed ();
  3375.       break;
  3376.     }
  3377.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlGOTO)
  3378.     {
  3379.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlGOTO);
  3380.       if (isdigit (*p))
  3381.         {
  3382.           nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
  3383.           p += ffelex_token_length (nt);
  3384.           i += ffelex_token_length (nt);
  3385.           if (*p != '\0')
  3386.         {
  3387.           ffelex_token_kill (nt);
  3388.           goto bad_i;    /* :::::::::::::::::::: */
  3389.         }
  3390.         }
  3391.       else if (ffesrc_is_name_init (*p))
  3392.         {
  3393.           nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  3394.         }
  3395.       else
  3396.         goto bad_i;        /* :::::::::::::::::::: */
  3397.       next = (ffelexHandler) ffestb_goto1_ (nt);
  3398.       ffelex_token_kill (nt);
  3399.       return (ffelexHandler) (*next) (t);
  3400.     }
  3401.       return (ffelexHandler) ffestb_goto1_ (t);
  3402.  
  3403.     default:
  3404.       goto bad_0;        /* :::::::::::::::::::: */
  3405.     }
  3406.  
  3407. bad_0:                /* :::::::::::::::::::: */
  3408.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", ffesta_tokens[0]);
  3409.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3410.  
  3411. bad_1:                /* :::::::::::::::::::: */
  3412.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
  3413.   return (ffelexHandler) ffelex_swallow_tokens (t,
  3414.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  3415.  
  3416. bad_i:                /* :::::::::::::::::::: */
  3417.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "GO TO", ffesta_tokens[0], i, t);
  3418.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3419. }
  3420.  
  3421. /* ffestb_goto1_ -- "GOTO" or "GO" "TO"
  3422.  
  3423.    return ffestb_goto1_;  // to lexer
  3424.  
  3425.    Make sure the statement has a valid form for the GOTO statement.  If it
  3426.    does, implement the statement.  */
  3427.  
  3428. static ffelexHandler
  3429. ffestb_goto1_ (ffelexToken t)
  3430. {
  3431.   switch (ffelex_token_type (t))
  3432.     {
  3433.     case FFELEX_typeNUMBER:
  3434.       if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
  3435.     ffesta_confirmed ();
  3436.       ffesta_tokens[1] = ffelex_token_use (t);
  3437.       return (ffelexHandler) ffestb_goto2_;
  3438.  
  3439.     case FFELEX_typeOPEN_PAREN:
  3440.       ffesta_tokens[1] = ffelex_token_use (t);
  3441.       ffestb_subrargs_.label_list.labels = ffestt_tokenlist_create ();
  3442.       ffestb_subrargs_.label_list.handler = (ffelexHandler) ffestb_goto3_;
  3443.       return (ffelexHandler) ffestb_subr_label_list_;
  3444.  
  3445.     case FFELEX_typeNAME:
  3446.       if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
  3447.     ffesta_confirmed ();
  3448.       return (ffelexHandler) (*((ffelexHandler)
  3449.                 ffeexpr_lhs (ffesta_output_pool,
  3450.                          FFEEXPR_contextAGOTO,
  3451.                       (ffeexprCallback) ffestb_goto4_)))
  3452.     (t);
  3453.  
  3454.     case FFELEX_typeEOS:
  3455.     case FFELEX_typeSEMICOLON:
  3456.     case FFELEX_typeCOMMA:
  3457.     case FFELEX_typeCOLONCOLON:
  3458.       ffesta_confirmed ();    /* Error, but clearly intended. */
  3459.       break;
  3460.  
  3461.     default:
  3462.       break;
  3463.     }
  3464.  
  3465.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
  3466.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3467. }
  3468.  
  3469. /* ffestb_goto2_ -- "GO/TO" NUMBER
  3470.  
  3471.    return ffestb_goto2_;  // to lexer
  3472.  
  3473.    Make sure the statement has a valid form for the GOTO statement.  If it
  3474.    does, implement the statement.  */
  3475.  
  3476. static ffelexHandler
  3477. ffestb_goto2_ (ffelexToken t)
  3478. {
  3479.   switch (ffelex_token_type (t))
  3480.     {
  3481.     case FFELEX_typeEOS:
  3482.     case FFELEX_typeSEMICOLON:
  3483.       ffesta_confirmed ();
  3484.       if (!ffesta_is_inhibited ())
  3485.     ffestc_R836 (ffesta_tokens[1]);
  3486.       ffelex_token_kill (ffesta_tokens[1]);
  3487.       return (ffelexHandler) ffesta_zero (t);
  3488.  
  3489.     default:
  3490.       break;
  3491.     }
  3492.  
  3493.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "GO TO", t);
  3494.   ffelex_token_kill (ffesta_tokens[1]);
  3495.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3496. }
  3497.  
  3498. /* ffestb_goto3_ -- "GO/TO" OPEN_PAREN label-list CLOSE_PAREN
  3499.  
  3500.    return ffestb_goto3_;  // to lexer
  3501.  
  3502.    Make sure the statement has a valid form for the GOTO statement.  If it
  3503.    does, implement the statement.  */
  3504.  
  3505. static ffelexHandler
  3506. ffestb_goto3_ (ffelexToken t)
  3507. {
  3508.   if (!ffestb_subrargs_.label_list.ok)
  3509.     goto bad;            /* :::::::::::::::::::: */
  3510.  
  3511.   switch (ffelex_token_type (t))
  3512.     {
  3513.     case FFELEX_typeCOMMA:
  3514.       ffesta_confirmed ();
  3515.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextCGOTO,
  3516.                       (ffeexprCallback) ffestb_goto5_);
  3517.  
  3518.     case FFELEX_typeEQUALS:
  3519.     case FFELEX_typePOINTS:
  3520.     case FFELEX_typeEOS:
  3521.     case FFELEX_typeSEMICOLON:
  3522.       break;
  3523.  
  3524.     default:
  3525.       ffesta_confirmed ();
  3526.       return (ffelexHandler) (*((ffelexHandler)
  3527.               ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextCGOTO,
  3528.                    (ffeexprCallback) ffestb_goto5_)))
  3529.     (t);
  3530.     }
  3531.  
  3532. bad:                /* :::::::::::::::::::: */
  3533.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "computed-GOTO", t);
  3534.   ffelex_token_kill (ffesta_tokens[1]);
  3535.   ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
  3536.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3537. }
  3538.  
  3539. /* ffestb_goto4_ -- "GO/TO" expr
  3540.  
  3541.    (ffestb_goto4_)  // to expression handler
  3542.  
  3543.    Make sure the statement has a valid form for the GOTO statement.  If it
  3544.    does, implement the statement.  */
  3545.  
  3546. static ffelexHandler
  3547. ffestb_goto4_ (ffelexToken ft, ffebld expr, ffelexToken t)
  3548. {
  3549.   switch (ffelex_token_type (t))
  3550.     {
  3551.     case FFELEX_typeCOMMA:
  3552.       ffesta_confirmed ();
  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_;
  3558.  
  3559.     case FFELEX_typeOPEN_PAREN:
  3560.       if (expr == NULL)
  3561.     break;
  3562.       ffesta_tokens[1] = ffelex_token_use (ft);
  3563.       ffestb_local_.go_to.expr = expr;
  3564.       return (ffelexHandler) ffestb_goto6_ (t);
  3565.  
  3566.     case FFELEX_typeEOS:
  3567.     case FFELEX_typeSEMICOLON:
  3568.       ffesta_confirmed ();
  3569.       if (expr == NULL)
  3570.     break;
  3571.       if (!ffesta_is_inhibited ())
  3572.     ffestc_R839 (expr, ft, NULL);
  3573.       return (ffelexHandler) ffesta_zero (t);
  3574.  
  3575.     default:
  3576.       break;
  3577.     }
  3578.  
  3579.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
  3580.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3581. }
  3582.  
  3583. /* ffestb_goto5_ -- "GO/TO" OPEN_PAREN label-list CLOSE_PAREN (COMMA) expr
  3584.  
  3585.    (ffestb_goto5_)  // to expression handler
  3586.  
  3587.    Make sure the statement has a valid form for the GOTO statement.  If it
  3588.    does, implement the statement.  */
  3589.  
  3590. static ffelexHandler
  3591. ffestb_goto5_ (ffelexToken ft, ffebld expr, ffelexToken t)
  3592. {
  3593.   switch (ffelex_token_type (t))
  3594.     {
  3595.     case FFELEX_typeEOS:
  3596.     case FFELEX_typeSEMICOLON:
  3597.       if (expr == NULL)
  3598.     break;
  3599.       if (!ffesta_is_inhibited ())
  3600.     ffestc_R837 (ffestb_subrargs_.label_list.labels, expr, ft);
  3601.       ffelex_token_kill (ffesta_tokens[1]);
  3602.       ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
  3603.       return (ffelexHandler) ffesta_zero (t);
  3604.  
  3605.     default:
  3606.       break;
  3607.     }
  3608.  
  3609.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "computed-GOTO", t);
  3610.   ffelex_token_kill (ffesta_tokens[1]);
  3611.   ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
  3612.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3613. }
  3614.  
  3615. /* ffestb_goto6_ -- "GO/TO" expr (COMMA)
  3616.  
  3617.    return ffestb_goto6_;  // to lexer
  3618.  
  3619.    Make sure the statement has a valid form for the GOTO statement.  If it
  3620.    does, implement the statement.  */
  3621.  
  3622. static ffelexHandler
  3623. ffestb_goto6_ (ffelexToken t)
  3624. {
  3625.   switch (ffelex_token_type (t))
  3626.     {
  3627.     case FFELEX_typeOPEN_PAREN:
  3628.       ffesta_tokens[2] = ffelex_token_use (t);
  3629.       ffestb_subrargs_.label_list.labels = ffestt_tokenlist_create ();
  3630.       ffestb_subrargs_.label_list.handler = (ffelexHandler) ffestb_goto7_;
  3631.       return (ffelexHandler) ffestb_subr_label_list_;
  3632.  
  3633.     default:
  3634.       break;
  3635.     }
  3636.  
  3637.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
  3638.   ffelex_token_kill (ffesta_tokens[1]);
  3639.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3640. }
  3641.  
  3642. /* ffestb_goto7_ -- "GO/TO" expr (COMMA) OPEN_PAREN label-list CLOSE_PAREN
  3643.  
  3644.    return ffestb_goto7_;  // to lexer
  3645.  
  3646.    Make sure the statement has a valid form for the GOTO statement.  If it
  3647.    does, implement the statement.  */
  3648.  
  3649. static ffelexHandler
  3650. ffestb_goto7_ (ffelexToken t)
  3651. {
  3652.   if (!ffestb_subrargs_.label_list.ok)
  3653.     goto bad;            /* :::::::::::::::::::: */
  3654.  
  3655.   switch (ffelex_token_type (t))
  3656.     {
  3657.     case FFELEX_typeEOS:
  3658.     case FFELEX_typeSEMICOLON:
  3659.       ffesta_confirmed ();
  3660.       if (!ffesta_is_inhibited ())
  3661.     ffestc_R839 (ffestb_local_.go_to.expr, ffesta_tokens[1],
  3662.              ffestb_subrargs_.label_list.labels);
  3663.       ffelex_token_kill (ffesta_tokens[1]);
  3664.       ffelex_token_kill (ffesta_tokens[2]);
  3665.       ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
  3666.       return (ffelexHandler) ffesta_zero (t);
  3667.  
  3668.     default:
  3669.       break;
  3670.     }
  3671.  
  3672. bad:                /* :::::::::::::::::::: */
  3673.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assigned-GOTO", t);
  3674.   ffelex_token_kill (ffesta_tokens[1]);
  3675.   ffelex_token_kill (ffesta_tokens[2]);
  3676.   ffestt_tokenlist_kill (ffestb_subrargs_.label_list.labels);
  3677.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3678. }
  3679.  
  3680. /* ffestb_halt -- Parse the STOP/PAUSE statement
  3681.  
  3682.    return ffestb_halt;    // to lexer
  3683.  
  3684.    Make sure the statement has a valid form for the STOP/PAUSE statement.  If
  3685.    it does, implement the statement.  */
  3686.  
  3687. ffelexHandler
  3688. ffestb_halt (ffelexToken t)
  3689. {
  3690.   ffelexHandler next;
  3691.  
  3692.   switch (ffelex_token_type (ffesta_tokens[0]))
  3693.     {
  3694.     case FFELEX_typeNAME:
  3695.       switch (ffelex_token_type (t))
  3696.     {
  3697.     case FFELEX_typeCOMMA:
  3698.     case FFELEX_typeCOLONCOLON:
  3699.       ffesta_confirmed ();    /* Error, but clearly intended. */
  3700.       goto bad_1;        /* :::::::::::::::::::: */
  3701.  
  3702.     default:
  3703.       goto bad_1;        /* :::::::::::::::::::: */
  3704.  
  3705.     case FFELEX_typeEOS:
  3706.     case FFELEX_typeSEMICOLON:
  3707.     case FFELEX_typeNAME:
  3708.     case FFELEX_typeNUMBER:
  3709.     case FFELEX_typeAPOSTROPHE:
  3710.     case FFELEX_typeQUOTE:
  3711.       ffesta_confirmed ();
  3712.       break;
  3713.     }
  3714.  
  3715.       return (ffelexHandler) (*((ffelexHandler)
  3716.                 ffeexpr_rhs (ffesta_output_pool,
  3717.                          FFEEXPR_contextSTOP,
  3718.                       (ffeexprCallback) ffestb_halt1_)))
  3719.     (t);
  3720.  
  3721.     case FFELEX_typeNAMES:
  3722.       switch (ffelex_token_type (t))
  3723.     {
  3724.     default:
  3725.       goto bad_1;        /* :::::::::::::::::::: */
  3726.  
  3727.     case FFELEX_typeEOS:
  3728.     case FFELEX_typeSEMICOLON:
  3729.     case FFELEX_typeNAME:
  3730.     case FFELEX_typeNUMBER:
  3731.     case FFELEX_typeAPOSTROPHE:
  3732.     case FFELEX_typeQUOTE:
  3733.       ffesta_confirmed ();
  3734.       break;
  3735.     }
  3736.       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  3737.                       FFEEXPR_contextSTOP,
  3738.                       (ffeexprCallback) ffestb_halt1_);
  3739.       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
  3740.                            ffestb_args.halt.len);
  3741.       if (next == NULL)
  3742.     return (ffelexHandler) ffelex_swallow_tokens (t,
  3743.                            (ffelexHandler) ffesta_zero);
  3744.       return (ffelexHandler) (*next) (t);
  3745.  
  3746.     default:
  3747.       goto bad_0;        /* :::::::::::::::::::: */
  3748.     }
  3749.  
  3750. bad_0:                /* :::::::::::::::::::: */
  3751.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  3752.              (ffesta_first_kw == FFESTR_firstSTOP)
  3753.              ? "STOP" : "PAUSE",
  3754.              ffesta_tokens[0]);
  3755.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3756.  
  3757. bad_1:                /* :::::::::::::::::::: */
  3758.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  3759.              (ffesta_first_kw == FFESTR_firstSTOP)
  3760.              ? "STOP" : "PAUSE",
  3761.              t);
  3762.   return (ffelexHandler) ffelex_swallow_tokens (t,
  3763.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  3764. }
  3765.  
  3766. /* ffestb_halt1_ -- "STOP/PAUSE" expr
  3767.  
  3768.    (ffestb_halt1_)  // to expression handler
  3769.  
  3770.    Make sure the next token is an EOS or SEMICOLON.  */
  3771.  
  3772. static ffelexHandler
  3773. ffestb_halt1_ (ffelexToken ft, ffebld expr, ffelexToken t)
  3774. {
  3775.   switch (ffelex_token_type (t))
  3776.     {
  3777.     case FFELEX_typeEOS:
  3778.     case FFELEX_typeSEMICOLON:
  3779.       ffesta_confirmed ();
  3780.       if (!ffesta_is_inhibited ())
  3781.     if (ffesta_first_kw == FFESTR_firstSTOP)
  3782.       ffestc_R842 (expr, ft);
  3783.     else
  3784.       ffestc_R843 (expr, ft);
  3785.       return (ffelexHandler) ffesta_zero (t);
  3786.  
  3787.     default:
  3788.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  3789.              (ffesta_first_kw == FFESTR_firstSTOP)
  3790.              ? "STOP" : "PAUSE",
  3791.              t);
  3792.       break;
  3793.     }
  3794.  
  3795.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3796. }
  3797.  
  3798. /* ffestb_if -- Parse an IF statement
  3799.  
  3800.    return ffestb_if;  // to lexer
  3801.  
  3802.    Make sure the statement has a valid form for an IF statement.
  3803.    If it does, implement the statement.     */
  3804.  
  3805. ffelexHandler
  3806. ffestb_if (ffelexToken t)
  3807. {
  3808.   switch (ffelex_token_type (ffesta_tokens[0]))
  3809.     {
  3810.     case FFELEX_typeNAME:
  3811.       if (ffesta_first_kw != FFESTR_firstIF)
  3812.     goto bad_0;        /* :::::::::::::::::::: */
  3813.       break;
  3814.  
  3815.     case FFELEX_typeNAMES:
  3816.       if (ffesta_first_kw != FFESTR_firstIF)
  3817.     goto bad_0;        /* :::::::::::::::::::: */
  3818.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlIF)
  3819.     goto bad_0;        /* :::::::::::::::::::: */
  3820.       break;
  3821.  
  3822.     default:
  3823.       goto bad_0;        /* :::::::::::::::::::: */
  3824.     }
  3825.  
  3826.   switch (ffelex_token_type (t))
  3827.     {
  3828.     case FFELEX_typeOPEN_PAREN:
  3829.       break;
  3830.  
  3831.     case FFELEX_typeEOS:
  3832.     case FFELEX_typeSEMICOLON:
  3833.     case FFELEX_typeCOMMA:
  3834.     case FFELEX_typeCOLONCOLON:
  3835.       ffesta_confirmed ();    /* Error, but clearly intended. */
  3836.       goto bad_1;        /* :::::::::::::::::::: */
  3837.  
  3838.     default:
  3839.       goto bad_1;        /* :::::::::::::::::::: */
  3840.     }
  3841.  
  3842.   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextIF,
  3843.                       (ffeexprCallback) ffestb_if1_);
  3844.  
  3845. bad_0:                /* :::::::::::::::::::: */
  3846.   if (ffesta_construct_name != NULL)
  3847.     {
  3848.       ffelex_token_kill (ffesta_construct_name);
  3849.       ffesta_construct_name = NULL;
  3850.     }
  3851.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", ffesta_tokens[0]);
  3852.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3853.  
  3854. bad_1:                /* :::::::::::::::::::: */
  3855.   if (ffesta_construct_name != NULL)
  3856.     {
  3857.       ffelex_token_kill (ffesta_construct_name);
  3858.       ffesta_construct_name = NULL;
  3859.     }
  3860.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
  3861.   return (ffelexHandler) ffelex_swallow_tokens (t,
  3862.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  3863. }
  3864.  
  3865. /* ffestb_if1_ -- "IF" OPEN_PAREN expr
  3866.  
  3867.    (ffestb_if1_)  // to expression handler
  3868.  
  3869.    Make sure the next token is CLOSE_PAREN.  */
  3870.  
  3871. static ffelexHandler
  3872. ffestb_if1_ (ffelexToken ft, ffebld expr, ffelexToken t)
  3873. {
  3874.   ffestb_local_.if_stmt.expr = expr;
  3875.  
  3876.   switch (ffelex_token_type (t))
  3877.     {
  3878.     case FFELEX_typeCLOSE_PAREN:
  3879.       if (expr == NULL)
  3880.     break;
  3881.       ffesta_tokens[1] = ffelex_token_use (ft);
  3882.       ffelex_set_names (TRUE);
  3883.       return (ffelexHandler) ffestb_if2_;
  3884.  
  3885.     default:
  3886.       break;
  3887.     }
  3888.  
  3889.   if (ffesta_construct_name != NULL)
  3890.     {
  3891.       ffelex_token_kill (ffesta_construct_name);
  3892.       ffesta_construct_name = NULL;
  3893.     }
  3894.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
  3895.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3896. }
  3897.  
  3898. /* ffestb_if2_ -- "IF" OPEN_PAREN expr CLOSE_PAREN
  3899.  
  3900.    return ffestb_if2_;    // to lexer
  3901.  
  3902.    Make sure the next token is NAME.  */
  3903.  
  3904. static ffelexHandler
  3905. ffestb_if2_ (ffelexToken t)
  3906. {
  3907.   ffelex_set_names (FALSE);
  3908.  
  3909.   switch (ffelex_token_type (t))
  3910.     {
  3911.     case FFELEX_typeNAME:
  3912.     case FFELEX_typeNAMES:
  3913.       ffesta_confirmed ();
  3914.       ffesta_tokens[2] = ffelex_token_use (t);
  3915.       return (ffelexHandler) ffestb_if3_;
  3916.  
  3917.     default:
  3918.       break;
  3919.     }
  3920.  
  3921.   ffelex_token_kill (ffesta_tokens[1]);
  3922.   if ((ffesta_construct_name == NULL)
  3923.       || (ffelex_token_type (t) != FFELEX_typeNUMBER))
  3924.     ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IF", t);
  3925.   else
  3926.     ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
  3927.                ffesta_construct_name, t);
  3928.   if (ffesta_construct_name != NULL)
  3929.     {
  3930.       ffelex_token_kill (ffesta_construct_name);
  3931.       ffesta_construct_name = NULL;
  3932.     }
  3933.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3934. }
  3935.  
  3936. /* ffestb_if3_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NAME
  3937.  
  3938.    return ffestb_if3_;    // to lexer
  3939.  
  3940.    If the next token is EOS or SEMICOLON and the preceding NAME was "THEN",
  3941.    implement R803.  Else, implement R807 and send the preceding NAME followed
  3942.    by the current token.  */
  3943.  
  3944. static ffelexHandler
  3945. ffestb_if3_ (ffelexToken t)
  3946. {
  3947.   ffelexHandler next;
  3948.  
  3949.   switch (ffelex_token_type (t))
  3950.     {
  3951.     case FFELEX_typeEOS:
  3952.     case FFELEX_typeSEMICOLON:
  3953.       if (ffestr_first (ffesta_tokens[2]) == FFESTR_firstTHEN)
  3954.     {
  3955.       if (!ffesta_is_inhibited ())
  3956.         ffestc_R803 (ffesta_construct_name, ffestb_local_.if_stmt.expr,
  3957.              ffesta_tokens[1]);
  3958.       ffelex_token_kill (ffesta_tokens[1]);
  3959.       ffelex_token_kill (ffesta_tokens[2]);
  3960.       if (ffesta_construct_name != NULL)
  3961.         {
  3962.           ffelex_token_kill (ffesta_construct_name);
  3963.           ffesta_construct_name = NULL;
  3964.         }
  3965.       return (ffelexHandler) ffesta_zero (t);
  3966.     }
  3967.       break;
  3968.  
  3969.     default:
  3970.       break;
  3971.     }
  3972.  
  3973.   if (ffesta_construct_name != NULL)
  3974.     {
  3975.       if (!ffesta_is_inhibited ())
  3976.     ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
  3977.                ffesta_construct_name, ffesta_tokens[2]);
  3978.       ffelex_token_kill (ffesta_construct_name);
  3979.       ffesta_construct_name = NULL;
  3980.       ffelex_token_kill (ffesta_tokens[1]);
  3981.       ffelex_token_kill (ffesta_tokens[2]);
  3982.       return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  3983.     }
  3984.  
  3985.   if (!ffesta_is_inhibited ())
  3986.     ffestc_R807 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
  3987.   ffelex_token_kill (ffesta_tokens[1]);
  3988.   {
  3989.     ffelexToken my_2 = ffesta_tokens[2];
  3990.  
  3991.     next = (ffelexHandler) ffesta_two (my_2, t);
  3992.     ffelex_token_kill (my_2);
  3993.   }
  3994.   return (ffelexHandler) next;
  3995. }
  3996.  
  3997. /* ffestb_where -- Parse a WHERE statement
  3998.  
  3999.    return ffestb_where;     // to lexer
  4000.  
  4001.    Make sure the statement has a valid form for a WHERE statement.
  4002.    If it does, implement the statement.     */
  4003.  
  4004. #if FFESTR_F90
  4005. ffelexHandler
  4006. ffestb_where (ffelexToken t)
  4007. {
  4008.   switch (ffelex_token_type (ffesta_tokens[0]))
  4009.     {
  4010.     case FFELEX_typeNAME:
  4011.       if (ffesta_first_kw != FFESTR_firstWHERE)
  4012.     goto bad_0;        /* :::::::::::::::::::: */
  4013.       break;
  4014.  
  4015.     case FFELEX_typeNAMES:
  4016.       if (ffesta_first_kw != FFESTR_firstWHERE)
  4017.     goto bad_0;        /* :::::::::::::::::::: */
  4018.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlWHERE)
  4019.     goto bad_0;        /* :::::::::::::::::::: */
  4020.       break;
  4021.  
  4022.     default:
  4023.       goto bad_0;        /* :::::::::::::::::::: */
  4024.     }
  4025.  
  4026.   switch (ffelex_token_type (t))
  4027.     {
  4028.     case FFELEX_typeOPEN_PAREN:
  4029.       break;
  4030.  
  4031.     case FFELEX_typeEOS:
  4032.     case FFELEX_typeSEMICOLON:
  4033.     case FFELEX_typeCOMMA:
  4034.     case FFELEX_typeCOLONCOLON:
  4035.       ffesta_confirmed ();    /* Error, but clearly intended. */
  4036.       goto bad_1;        /* :::::::::::::::::::: */
  4037.  
  4038.     default:
  4039.       goto bad_1;        /* :::::::::::::::::::: */
  4040.     }
  4041.  
  4042.   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextWHERE,
  4043.                       (ffeexprCallback) ffestb_where1_);
  4044.  
  4045. bad_0:                /* :::::::::::::::::::: */
  4046.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", ffesta_tokens[0]);
  4047.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4048.  
  4049. bad_1:                /* :::::::::::::::::::: */
  4050.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
  4051.   return (ffelexHandler) ffelex_swallow_tokens (t,
  4052.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  4053. }
  4054.  
  4055. #endif
  4056. /* ffestb_where1_ -- "WHERE" OPEN_PAREN expr
  4057.  
  4058.    (ffestb_where1_)  // to expression handler
  4059.  
  4060.    Make sure the next token is CLOSE_PAREN.  */
  4061.  
  4062. #if FFESTR_F90
  4063. static ffelexHandler
  4064. ffestb_where1_ (ffelexToken ft, ffebld expr, ffelexToken t)
  4065. {
  4066.   ffestb_local_.if_stmt.expr = expr;
  4067.  
  4068.   switch (ffelex_token_type (t))
  4069.     {
  4070.     case FFELEX_typeCLOSE_PAREN:
  4071.       if (expr == NULL)
  4072.     break;
  4073.       ffesta_tokens[1] = ffelex_token_use (ft);
  4074.       ffelex_set_names (TRUE);
  4075.       return (ffelexHandler) ffestb_where2_;
  4076.  
  4077.     default:
  4078.       break;
  4079.     }
  4080.  
  4081.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
  4082.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4083. }
  4084.  
  4085. #endif
  4086. /* ffestb_where2_ -- "WHERE" OPEN_PAREN expr CLOSE_PAREN
  4087.  
  4088.    return ffestb_where2_;  // to lexer
  4089.  
  4090.    Make sure the next token is NAME.  */
  4091.  
  4092. #if FFESTR_F90
  4093. static ffelexHandler
  4094. ffestb_where2_ (ffelexToken t)
  4095. {
  4096.   ffelex_set_names (FALSE);
  4097.  
  4098.   switch (ffelex_token_type (t))
  4099.     {
  4100.     case FFELEX_typeNAME:
  4101.     case FFELEX_typeNAMES:
  4102.       ffesta_confirmed ();
  4103.       ffesta_tokens[2] = ffelex_token_use (t);
  4104.       return (ffelexHandler) ffestb_where3_;
  4105.  
  4106.     case FFELEX_typeEOS:
  4107.     case FFELEX_typeSEMICOLON:
  4108.       ffesta_confirmed ();
  4109.       if (!ffesta_is_inhibited ())
  4110.     ffestc_R742 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
  4111.       ffelex_token_kill (ffesta_tokens[1]);
  4112.       return (ffelexHandler) ffesta_zero (t);
  4113.  
  4114.     default:
  4115.       break;
  4116.     }
  4117.  
  4118.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WHERE", t);
  4119.   ffelex_token_kill (ffesta_tokens[1]);
  4120.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4121. }
  4122.  
  4123. #endif
  4124. /* ffestb_where3_ -- "WHERE" OPEN_PAREN expr CLOSE_PAREN NAME
  4125.  
  4126.    return ffestb_where3_;  // to lexer
  4127.  
  4128.    Implement R742.  */
  4129.  
  4130. #if FFESTR_F90
  4131. static ffelexHandler
  4132. ffestb_where3_ (ffelexToken t)
  4133. {
  4134.   ffelexHandler next;
  4135.   ffelexToken my_2 = ffesta_tokens[2];
  4136.  
  4137.   if (!ffesta_is_inhibited ())
  4138.     ffestc_R740 (ffestb_local_.if_stmt.expr, ffesta_tokens[1]);
  4139.   ffelex_token_kill (ffesta_tokens[1]);
  4140.   next = (ffelexHandler) ffesta_two (my_2, t);
  4141.   ffelex_token_kill (my_2);
  4142.   return (ffelexHandler) next;
  4143. }
  4144.  
  4145. #endif
  4146. /* ffestb_let -- Parse an assignment statement
  4147.  
  4148.    return ffestb_let;  // to lexer
  4149.  
  4150.    Make sure the statement has a valid form for an assignment statement.  If
  4151.    it does, implement the statement.  */
  4152.  
  4153. ffelexHandler
  4154. ffestb_let (ffelexToken t)
  4155. {
  4156.   ffelexHandler next;
  4157.   bool vxtparam;        /* TRUE if it might really be a VXT PARAMETER
  4158.                    stmt. */
  4159.   char *p;
  4160.  
  4161.   switch (ffelex_token_type (ffesta_tokens[0]))
  4162.     {
  4163.     case FFELEX_typeNAME:
  4164.       vxtparam = FALSE;
  4165.       break;
  4166.  
  4167.     case FFELEX_typeNAMES:
  4168.       vxtparam = TRUE;
  4169.       break;
  4170.  
  4171.     default:
  4172.       goto bad_0;        /* :::::::::::::::::::: */
  4173.     }
  4174.  
  4175.   switch (ffelex_token_type (t))
  4176.     {
  4177.     case FFELEX_typeOPEN_PAREN:
  4178.     case FFELEX_typePERCENT:
  4179.     case FFELEX_typePOINTS:
  4180.       ffestb_local_.let.vxtparam = FALSE;
  4181.       break;
  4182.  
  4183.     case FFELEX_typeEQUALS:
  4184.       if (!vxtparam || (ffesta_first_kw != FFESTR_firstPARAMETER))
  4185.     {
  4186.       ffestb_local_.let.vxtparam = FALSE;
  4187.       break;
  4188.     }
  4189.       p = ffelex_token_text (ffesta_tokens[0]) + FFESTR_firstlPARAMETER;
  4190.       ffestb_local_.let.vxtparam = ffesrc_is_name_init (*p);
  4191.       break;
  4192.  
  4193.     default:
  4194.       goto bad_1;        /* :::::::::::::::::::: */
  4195.     }
  4196.  
  4197.   next = (ffelexHandler) (*((ffelexHandler)
  4198.                 ffeexpr_lhs (ffesta_output_pool,
  4199.                      FFEEXPR_contextLET,
  4200.                      (ffeexprCallback) ffestb_let1_)))
  4201.     (ffesta_tokens[0]);
  4202.   return (ffelexHandler) (*next) (t);
  4203.  
  4204. bad_0:                /* :::::::::::::::::::: */
  4205.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", ffesta_tokens[0]);
  4206.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4207.  
  4208. bad_1:                /* :::::::::::::::::::: */
  4209.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", t);
  4210.   return (ffelexHandler) ffelex_swallow_tokens (t,
  4211.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  4212. }
  4213.  
  4214. /* ffestb_let1_ -- expr
  4215.  
  4216.    (ffestb_let1_)  // to expression handler
  4217.  
  4218.    Make sure the next token is EQUALS or POINTS.  */
  4219.  
  4220. static ffelexHandler
  4221. ffestb_let1_ (ffelexToken ft, ffebld expr, ffelexToken t)
  4222. {
  4223.   ffestb_local_.let.dest = expr;
  4224.  
  4225.   switch (ffelex_token_type (t))
  4226.     {
  4227. #if FFESTR_F90
  4228.     case FFELEX_typePOINTS:
  4229. #endif
  4230.     case FFELEX_typeEQUALS:
  4231.       if (expr == NULL)
  4232.     break;
  4233.       ffesta_tokens[1] = ffelex_token_use (t);
  4234.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  4235.             FFEEXPR_contextLET, (ffeexprCallback) ffestb_let2_);
  4236.  
  4237.     default:
  4238.       break;
  4239.     }
  4240.  
  4241.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "assignment", t);
  4242.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4243. }
  4244.  
  4245. /* ffestb_let2_ -- expr EQUALS/POINTS expr
  4246.  
  4247.    (ffestb_end2_)  // to expression handler
  4248.  
  4249.    Make sure the next token is EOS or SEMICOLON; implement the statement.  */
  4250.  
  4251. static ffelexHandler
  4252. ffestb_let2_ (ffelexToken ft, ffebld expr, ffelexToken t)
  4253. {
  4254.   switch (ffelex_token_type (t))
  4255.     {
  4256.     case FFELEX_typeEOS:
  4257.     case FFELEX_typeSEMICOLON:
  4258.       if (expr == NULL)
  4259.     break;
  4260.       if (ffestb_local_.let.vxtparam && !ffestc_is_let_not_V027 ())
  4261.     break;
  4262.       ffesta_confirmed ();
  4263.       if (!ffesta_is_inhibited ())
  4264. #if FFESTR_F90
  4265.     if (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeEQUALS)
  4266. #endif
  4267.       ffestc_let (ffestb_local_.let.dest, expr, ft);
  4268. #if FFESTR_F90
  4269.     else
  4270.       ffestc_R738 (ffestb_local_.let.dest, expr, ft);
  4271. #endif
  4272.       ffelex_token_kill (ffesta_tokens[1]);
  4273.       return (ffelexHandler) ffesta_zero (t);
  4274.  
  4275.     default:
  4276.       break;
  4277.     }
  4278.  
  4279.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM,
  4280.              (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeEQUALS)
  4281.              ? "assignment" : "pointer-assignment",
  4282.              t);
  4283.   ffelex_token_kill (ffesta_tokens[1]);
  4284.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4285. }
  4286.  
  4287. /* ffestb_type -- Parse the TYPE statement
  4288.  
  4289.    return ffestb_type;    // to lexer
  4290.  
  4291.    Make sure the statement has a valid form for the TYPE statement.  If
  4292.    it does, implement the statement.  */
  4293.  
  4294. #if FFESTR_F90
  4295. ffelexHandler
  4296. ffestb_type (ffelexToken t)
  4297. {
  4298.   ffeTokenLength i;
  4299.   char *p;
  4300.  
  4301.   switch (ffelex_token_type (ffesta_tokens[0]))
  4302.     {
  4303.     case FFELEX_typeNAME:
  4304.       if (ffesta_first_kw != FFESTR_firstTYPE)
  4305.     goto bad_0;        /* :::::::::::::::::::: */
  4306.       switch (ffelex_token_type (t))
  4307.     {
  4308.     case FFELEX_typeEOS:
  4309.     case FFELEX_typeSEMICOLON:
  4310.     case FFELEX_typeCOLONCOLON:
  4311.       ffesta_confirmed ();    /* Error, but clearly intended. */
  4312.       goto bad_1;        /* :::::::::::::::::::: */
  4313.  
  4314.     default:
  4315.       goto bad_1;        /* :::::::::::::::::::: */
  4316.  
  4317.     case FFELEX_typeCOMMA:
  4318.       ffesta_confirmed ();
  4319.       return (ffelexHandler) ffestb_type1_;
  4320.  
  4321.     case FFELEX_typeNAME:    /* No confirm here, because ambig w/V020 VXT
  4322.                    TYPE. */
  4323.       ffesta_tokens[1] = NULL;
  4324.       ffesta_tokens[2] = ffelex_token_use (t);
  4325.       return (ffelexHandler) ffestb_type4_;
  4326.     }
  4327.  
  4328.     case FFELEX_typeNAMES:
  4329.       if (ffesta_first_kw != FFESTR_firstTYPE)
  4330.     goto bad_0;        /* :::::::::::::::::::: */
  4331.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlTYPE);
  4332.       switch (ffelex_token_type (t))
  4333.     {
  4334.     default:
  4335.       goto bad_1;        /* :::::::::::::::::::: */
  4336.  
  4337.     case FFELEX_typeCOMMA:
  4338.       if (*p != '\0')
  4339.         goto bad_i;        /* :::::::::::::::::::: */
  4340.       ffesta_confirmed ();
  4341.       ffelex_set_names (TRUE);
  4342.       return (ffelexHandler) ffestb_type1_;
  4343.  
  4344.     case FFELEX_typeEOS:
  4345.     case FFELEX_typeSEMICOLON:
  4346.       break;
  4347.     }
  4348.       if (!ffesrc_is_name_init (*p))
  4349.     goto bad_i;        /* :::::::::::::::::::: */
  4350.       ffesta_tokens[1] = NULL;
  4351.       ffesta_tokens[2]
  4352.     = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  4353.       return (ffelexHandler) ffestb_type4_ (t);
  4354.  
  4355.     default:
  4356.       goto bad_0;        /* :::::::::::::::::::: */
  4357.     }
  4358.  
  4359. bad_0:                /* :::::::::::::::::::: */
  4360.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", ffesta_tokens[0]);
  4361.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4362.  
  4363. bad_1:                /* :::::::::::::::::::: */
  4364.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
  4365.   return (ffelexHandler) ffelex_swallow_tokens (t,
  4366.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  4367.  
  4368. bad_i:                /* :::::::::::::::::::: */
  4369.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "TYPE", ffesta_tokens[0], i, t);
  4370.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4371. }
  4372.  
  4373. /* ffestb_type1_ -- "TYPE" COMMA
  4374.  
  4375.    return ffestb_type1_;  // to lexer
  4376.  
  4377.    Make sure the next token is a NAME.    */
  4378.  
  4379. static ffelexHandler
  4380. ffestb_type1_ (ffelexToken t)
  4381. {
  4382.   ffeTokenLength i;
  4383.   char *p;
  4384.  
  4385.   ffelex_set_names (FALSE);
  4386.  
  4387.   switch (ffelex_token_type (t))
  4388.     {
  4389.     case FFELEX_typeNAME:
  4390.       ffesta_tokens[1] = ffelex_token_use (t);
  4391.       ffestb_local_.type.kw = ffestr_other (t);
  4392.       switch (ffestb_local_.varlist.kw)
  4393.     {
  4394.     case FFESTR_otherPUBLIC:
  4395.     case FFESTR_otherPRIVATE:
  4396.       return (ffelexHandler) ffestb_type2_;
  4397.  
  4398.     default:
  4399.       ffelex_token_kill (ffesta_tokens[1]);
  4400.       break;
  4401.     }
  4402.       break;
  4403.  
  4404.     case FFELEX_typeNAMES:
  4405.       ffesta_tokens[1] = ffelex_token_use (t);
  4406.       ffestb_local_.type.kw = ffestr_other (t);
  4407.       switch (ffestb_local_.varlist.kw)
  4408.     {
  4409.     case FFESTR_otherPUBLIC:
  4410.       p = ffelex_token_text (t) + (i = FFESTR_otherlPUBLIC);
  4411.       if (*p == '\0')
  4412.         return (ffelexHandler) ffestb_type2_;
  4413.       if (!ffesrc_is_name_init (*p))
  4414.         goto bad_i1;    /* :::::::::::::::::::: */
  4415.       ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
  4416.       return (ffelexHandler) ffestb_type4_;
  4417.  
  4418.     case FFESTR_otherPRIVATE:
  4419.       p = ffelex_token_text (t) + (i = FFESTR_otherlPRIVATE);
  4420.       if (*p == '\0')
  4421.         return (ffelexHandler) ffestb_type2_;
  4422.       if (!ffesrc_is_name_init (*p))
  4423.         goto bad_i1;    /* :::::::::::::::::::: */
  4424.       ffesta_tokens[2] = ffelex_token_name_from_names (t, i, 0);
  4425.       return (ffelexHandler) ffestb_type4_;
  4426.  
  4427.     default:
  4428.       ffelex_token_kill (ffesta_tokens[1]);
  4429.       break;
  4430.     }
  4431.       break;
  4432.  
  4433.     default:
  4434.       break;
  4435.     }
  4436.  
  4437.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
  4438.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4439.  
  4440. bad_i1:            /* :::::::::::::::::::: */
  4441.   ffelex_token_kill (ffesta_tokens[1]);
  4442.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "TYPE", t, i, NULL);
  4443.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4444. }
  4445.  
  4446. /* ffestb_type2_ -- "TYPE" COMMA NAME
  4447.  
  4448.    return ffestb_type2_;  // to lexer
  4449.  
  4450.    Handle COLONCOLON or NAME.  */
  4451.  
  4452. static ffelexHandler
  4453. ffestb_type2_ (ffelexToken t)
  4454. {
  4455.   switch (ffelex_token_type (t))
  4456.     {
  4457.     case FFELEX_typeCOLONCOLON:
  4458.       return (ffelexHandler) ffestb_type3_;
  4459.  
  4460.     case FFELEX_typeNAME:
  4461.       return (ffelexHandler) ffestb_type3_ (t);
  4462.  
  4463.     default:
  4464.       break;
  4465.     }
  4466.  
  4467.   if (ffesta_tokens[1] != NULL)
  4468.     ffelex_token_kill (ffesta_tokens[1]);
  4469.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
  4470.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4471. }
  4472.  
  4473. /* ffestb_type3_ -- "TYPE" [COMMA NAME [COLONCOLON]]
  4474.  
  4475.    return ffestb_type3_;  // to lexer
  4476.  
  4477.    Make sure the next token is a NAME.    */
  4478.  
  4479. static ffelexHandler
  4480. ffestb_type3_ (ffelexToken t)
  4481. {
  4482.   switch (ffelex_token_type (t))
  4483.     {
  4484.     case FFELEX_typeNAME:
  4485.       ffesta_tokens[2] = ffelex_token_use (t);
  4486.       return (ffelexHandler) ffestb_type4_;
  4487.  
  4488.     default:
  4489.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
  4490.       break;
  4491.     }
  4492.  
  4493.   if (ffesta_tokens[1] != NULL)
  4494.     ffelex_token_kill (ffesta_tokens[1]);
  4495.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4496. }
  4497.  
  4498. /* ffestb_type4_ -- "TYPE" [COMMA NAME [COLONCOLON]] NAME
  4499.  
  4500.    return ffestb_type4_;  // to lexer
  4501.  
  4502.    Make sure the next token is an EOS or SEMICOLON.  */
  4503.  
  4504. static ffelexHandler
  4505. ffestb_type4_ (ffelexToken t)
  4506. {
  4507.   switch (ffelex_token_type (t))
  4508.     {
  4509.     case FFELEX_typeEOS:
  4510.     case FFELEX_typeSEMICOLON:
  4511.       ffesta_confirmed ();
  4512.       if (!ffesta_is_inhibited ())
  4513.     ffestc_R424 (ffesta_tokens[1], ffestb_local_.type.kw,
  4514.              ffesta_tokens[2]);
  4515.       if (ffesta_tokens[1] != NULL)
  4516.     ffelex_token_kill (ffesta_tokens[1]);
  4517.       ffelex_token_kill (ffesta_tokens[2]);
  4518.       return (ffelexHandler) ffesta_zero (t);
  4519.  
  4520.     default:
  4521.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE", t);
  4522.       break;
  4523.     }
  4524.  
  4525.   if (ffesta_tokens[1] != NULL)
  4526.     ffelex_token_kill (ffesta_tokens[1]);
  4527.   ffelex_token_kill (ffesta_tokens[2]);
  4528.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4529. }
  4530.  
  4531. #endif
  4532. /* ffestb_varlist -- Parse EXTERNAL/INTENT/INTRINSIC/OPTIONAL/PUBLIC/PRIVATE
  4533.              statement
  4534.  
  4535.    return ffestb_varlist;  // to lexer
  4536.  
  4537.    Make sure the statement has a valid form.  If it
  4538.    does, implement the statement.  */
  4539.  
  4540. ffelexHandler
  4541. ffestb_varlist (ffelexToken t)
  4542. {
  4543.   ffeTokenLength i;
  4544.   char *p;
  4545.   ffelexToken nt;
  4546.   ffelexHandler next;
  4547.  
  4548.   switch (ffelex_token_type (ffesta_tokens[0]))
  4549.     {
  4550.     case FFELEX_typeNAME:
  4551.       switch (ffelex_token_type (t))
  4552.     {
  4553.     case FFELEX_typeEOS:
  4554.     case FFELEX_typeSEMICOLON:
  4555.       ffesta_confirmed ();
  4556.       switch (ffesta_first_kw)
  4557.         {
  4558. #if FFESTR_F90
  4559.         case FFESTR_firstPUBLIC:
  4560.           if (!ffesta_is_inhibited ())
  4561.         ffestc_R521A ();
  4562.           return (ffelexHandler) ffesta_zero (t);
  4563.  
  4564.         case FFESTR_firstPRIVATE:
  4565.           if (!ffesta_is_inhibited ())
  4566.         ffestc_private ();    /* Either R523A or R521B. */
  4567.           return (ffelexHandler) ffesta_zero (t);
  4568. #endif
  4569.  
  4570.         default:
  4571.           goto bad_1;    /* :::::::::::::::::::: */
  4572.         }
  4573.  
  4574.     case FFELEX_typeCOMMA:
  4575.       ffesta_confirmed ();    /* Error, but clearly intended. */
  4576.       goto bad_1;        /* :::::::::::::::::::: */
  4577.  
  4578.     case FFELEX_typeCOLONCOLON:
  4579.       ffesta_confirmed ();
  4580.       switch (ffesta_first_kw)
  4581.         {
  4582. #if FFESTR_F90
  4583.         case FFESTR_firstOPTIONAL:
  4584.           if (!ffesta_is_inhibited ())
  4585.         ffestc_R520_start ();
  4586.           break;
  4587.  
  4588.         case FFESTR_firstPUBLIC:
  4589.           if (!ffesta_is_inhibited ())
  4590.         ffestc_R521Astart ();
  4591.           break;
  4592.  
  4593.         case FFESTR_firstPRIVATE:
  4594.           if (!ffesta_is_inhibited ())
  4595.         ffestc_R521Bstart ();
  4596.           break;
  4597. #endif
  4598.  
  4599.         default:
  4600.           ffesta_confirmed ();    /* Error, but clearly intended. */
  4601.           goto bad_1;    /* :::::::::::::::::::: */
  4602.         }
  4603.       return (ffelexHandler) ffestb_varlist5_;
  4604.  
  4605.     default:
  4606.       goto bad_1;        /* :::::::::::::::::::: */
  4607.  
  4608.     case FFELEX_typeOPEN_PAREN:
  4609.       switch (ffesta_first_kw)
  4610.         {
  4611. #if FFESTR_F90
  4612.         case FFESTR_firstINTENT:
  4613.           return (ffelexHandler) ffestb_varlist1_;
  4614. #endif
  4615.  
  4616.         default:
  4617.           goto bad_1;    /* :::::::::::::::::::: */
  4618.         }
  4619.  
  4620.     case FFELEX_typeNAME:
  4621.       ffesta_confirmed ();
  4622.       switch (ffesta_first_kw)
  4623.         {
  4624.         case FFESTR_firstEXTERNAL:
  4625.           if (!ffesta_is_inhibited ())
  4626.         ffestc_R1207_start ();
  4627.           break;
  4628.  
  4629. #if FFESTR_F90
  4630.         case FFESTR_firstINTENT:
  4631.           goto bad_1;    /* :::::::::::::::::::: */
  4632. #endif
  4633.  
  4634.         case FFESTR_firstINTRINSIC:
  4635.           if (!ffesta_is_inhibited ())
  4636.         ffestc_R1208_start ();
  4637.           break;
  4638.  
  4639. #if FFESTR_F90
  4640.         case FFESTR_firstOPTIONAL:
  4641.           if (!ffesta_is_inhibited ())
  4642.         ffestc_R520_start ();
  4643.           break;
  4644. #endif
  4645.  
  4646. #if FFESTR_F90
  4647.         case FFESTR_firstPUBLIC:
  4648.           if (!ffesta_is_inhibited ())
  4649.         ffestc_R521Astart ();
  4650.           break;
  4651.  
  4652.         case FFESTR_firstPRIVATE:
  4653.           if (!ffesta_is_inhibited ())
  4654.         ffestc_R521Bstart ();
  4655.           break;
  4656. #endif
  4657.  
  4658.         default:
  4659.           break;
  4660.         }
  4661.       return (ffelexHandler) ffestb_varlist5_ (t);
  4662.     }
  4663.  
  4664.     case FFELEX_typeNAMES:
  4665.       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.varlist.len);
  4666.       switch (ffelex_token_type (t))
  4667.     {
  4668.     case FFELEX_typeEOS:
  4669.     case FFELEX_typeSEMICOLON:
  4670.       ffesta_confirmed ();
  4671.       switch (ffesta_first_kw)
  4672.         {
  4673. #if FFESTR_F90
  4674.         case FFESTR_firstINTENT:
  4675.           goto bad_1;    /* :::::::::::::::::::: */
  4676. #endif
  4677.  
  4678.         default:
  4679.           break;
  4680.         }
  4681.       if (*p != '\0')
  4682.         break;
  4683.       switch (ffesta_first_kw)
  4684.         {
  4685. #if FFESTR_F90
  4686.         case FFESTR_firstPUBLIC:
  4687.           if (!ffesta_is_inhibited ())
  4688.         ffestc_R521A ();
  4689.           return (ffelexHandler) ffesta_zero (t);
  4690.  
  4691.         case FFESTR_firstPRIVATE:
  4692.           if (!ffesta_is_inhibited ())
  4693.         ffestc_private ();    /* Either R423A or R521B. */
  4694.           return (ffelexHandler) ffesta_zero (t);
  4695. #endif
  4696.  
  4697.         default:
  4698.           goto bad_1;    /* :::::::::::::::::::: */
  4699.         }
  4700.  
  4701.     case FFELEX_typeCOMMA:
  4702.       ffesta_confirmed ();    /* Error, but clearly intended. */
  4703.       switch (ffesta_first_kw)
  4704.         {
  4705. #if FFESTR_F90
  4706.         case FFESTR_firstINTENT:
  4707.           goto bad_1;    /* :::::::::::::::::::: */
  4708. #endif
  4709.  
  4710.         default:
  4711.           break;
  4712.         }
  4713.       if (*p != '\0')
  4714.         break;
  4715.       goto bad_1;        /* :::::::::::::::::::: */
  4716.  
  4717.     case FFELEX_typeCOLONCOLON:
  4718.       ffesta_confirmed ();
  4719.       switch (ffesta_first_kw)
  4720.         {
  4721. #if FFESTR_F90
  4722.         case FFESTR_firstOPTIONAL:
  4723.           if (!ffesta_is_inhibited ())
  4724.         ffestc_R520_start ();
  4725.           break;
  4726. #endif
  4727.  
  4728. #if FFESTR_F90
  4729.         case FFESTR_firstPUBLIC:
  4730.           if (!ffesta_is_inhibited ())
  4731.         ffestc_R521Astart ();
  4732.           break;
  4733.  
  4734.         case FFESTR_firstPRIVATE:
  4735.           if (!ffesta_is_inhibited ())
  4736.         ffestc_R521Bstart ();
  4737.           break;
  4738. #endif
  4739.  
  4740.         default:
  4741.           goto bad_1;    /* :::::::::::::::::::: */
  4742.         }
  4743.       return (ffelexHandler) ffestb_varlist5_;
  4744.  
  4745.     case FFELEX_typeOPEN_PAREN:
  4746.       switch (ffesta_first_kw)
  4747.         {
  4748. #if FFESTR_F90
  4749.         case FFESTR_firstINTENT:
  4750.           if (*p != '\0')
  4751.         goto bad_1;    /* :::::::::::::::::::: */
  4752.           return (ffelexHandler) ffestb_varlist1_;
  4753. #endif
  4754.  
  4755.         default:
  4756.           goto bad_1;    /* :::::::::::::::::::: */
  4757.         }
  4758.  
  4759.     case FFELEX_typeNAME:
  4760.       ffesta_confirmed ();
  4761.       switch (ffesta_first_kw)
  4762.         {
  4763.         case FFESTR_firstEXTERNAL:
  4764.           if (!ffesta_is_inhibited ())
  4765.         ffestc_R1207_start ();
  4766.           break;
  4767.  
  4768. #if FFESTR_F90
  4769.         case FFESTR_firstINTENT:
  4770.           goto bad_1;    /* :::::::::::::::::::: */
  4771. #endif
  4772.  
  4773.         case FFESTR_firstINTRINSIC:
  4774.           if (!ffesta_is_inhibited ())
  4775.         ffestc_R1208_start ();
  4776.           break;
  4777.  
  4778. #if FFESTR_F90
  4779.         case FFESTR_firstOPTIONAL:
  4780.           if (!ffesta_is_inhibited ())
  4781.         ffestc_R520_start ();
  4782.           break;
  4783. #endif
  4784.  
  4785. #if FFESTR_F90
  4786.         case FFESTR_firstPUBLIC:
  4787.           if (!ffesta_is_inhibited ())
  4788.         ffestc_R521Astart ();
  4789.           break;
  4790.  
  4791.         case FFESTR_firstPRIVATE:
  4792.           if (!ffesta_is_inhibited ())
  4793.         ffestc_R521Bstart ();
  4794.           break;
  4795. #endif
  4796.  
  4797.         default:
  4798.           break;
  4799.         }
  4800.       return (ffelexHandler) ffestb_varlist5_ (t);
  4801.  
  4802.     default:
  4803.       goto bad_1;        /* :::::::::::::::::::: */
  4804.     }
  4805.  
  4806.       /* Here, we have at least one char after the first keyword and t is
  4807.          COMMA or EOS/SEMICOLON.  Also we know that this form is valid for
  4808.          only the statements reaching here (specifically, INTENT won't reach
  4809.          here). */
  4810.  
  4811.       if (!ffesrc_is_name_init (*p))
  4812.     goto bad_i;        /* :::::::::::::::::::: */
  4813.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  4814.       if (!ffesta_is_inhibited ())
  4815.     {
  4816.       switch (ffesta_first_kw)
  4817.         {
  4818.         case FFESTR_firstEXTERNAL:
  4819.           ffestc_R1207_start ();
  4820.           break;
  4821.  
  4822.         case FFESTR_firstINTRINSIC:
  4823.           ffestc_R1208_start ();
  4824.           break;
  4825.  
  4826. #if FFESTR_F90
  4827.         case FFESTR_firstOPTIONAL:
  4828.           ffestc_R520_start ();
  4829.           break;
  4830. #endif
  4831.  
  4832. #if FFESTR_F90
  4833.         case FFESTR_firstPUBLIC:
  4834.           ffestc_R521Astart ();
  4835.           break;
  4836.  
  4837.         case FFESTR_firstPRIVATE:
  4838.           ffestc_R521Bstart ();
  4839.           break;
  4840. #endif
  4841.  
  4842.         default:
  4843.           assert (FALSE);
  4844.         }
  4845.     }
  4846.       next = (ffelexHandler) ffestb_varlist5_ (nt);
  4847.       ffelex_token_kill (nt);
  4848.       return (ffelexHandler) (*next) (t);
  4849.  
  4850.     default:
  4851.       goto bad_0;        /* :::::::::::::::::::: */
  4852.     }
  4853.  
  4854. bad_0:                /* :::::::::::::::::::: */
  4855.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, ffesta_tokens[0]);
  4856.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4857.  
  4858. bad_1:                /* :::::::::::::::::::: */
  4859.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
  4860.   return (ffelexHandler) ffelex_swallow_tokens (t,
  4861.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  4862.  
  4863. bad_i:                /* :::::::::::::::::::: */
  4864.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, ffesta_tokens[0], i, t);
  4865.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4866. }
  4867.  
  4868. /* ffestb_varlist1_ -- "INTENT" OPEN_PAREN
  4869.  
  4870.    return ffestb_varlist1_;  // to lexer
  4871.  
  4872.    Handle NAME.     */
  4873.  
  4874. #if FFESTR_F90
  4875. static ffelexHandler
  4876. ffestb_varlist1_ (ffelexToken t)
  4877. {
  4878.   switch (ffelex_token_type (t))
  4879.     {
  4880.     case FFELEX_typeNAME:
  4881.       ffesta_tokens[1] = ffelex_token_use (t);
  4882.       ffestb_local_.varlist.kw = ffestr_other (t);
  4883.       switch (ffestb_local_.varlist.kw)
  4884.     {
  4885.     case FFESTR_otherIN:
  4886.       return (ffelexHandler) ffestb_varlist2_;
  4887.  
  4888.     case FFESTR_otherINOUT:
  4889.       return (ffelexHandler) ffestb_varlist3_;
  4890.  
  4891.     case FFESTR_otherOUT:
  4892.       return (ffelexHandler) ffestb_varlist3_;
  4893.  
  4894.     default:
  4895.       ffelex_token_kill (ffesta_tokens[1]);
  4896.       break;
  4897.     }
  4898.       break;
  4899.  
  4900.     default:
  4901.       break;
  4902.     }
  4903.  
  4904.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
  4905.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4906. }
  4907.  
  4908. /* ffestb_varlist2_ -- "INTENT" OPEN_PAREN "IN"
  4909.  
  4910.    return ffestb_varlist2_;  // to lexer
  4911.  
  4912.    Handle NAME.     */
  4913.  
  4914. static ffelexHandler
  4915. ffestb_varlist2_ (ffelexToken t)
  4916. {
  4917.   switch (ffelex_token_type (t))
  4918.     {
  4919.     case FFELEX_typeNAME:
  4920.       switch (ffestr_other (t))
  4921.     {
  4922.     case FFESTR_otherOUT:
  4923.       ffestb_local_.varlist.kw = FFESTR_otherINOUT;
  4924.       return (ffelexHandler) ffestb_varlist3_;
  4925.  
  4926.     default:
  4927.       break;
  4928.     }
  4929.       break;
  4930.  
  4931.     case FFELEX_typeCLOSE_PAREN:
  4932.       return (ffelexHandler) ffestb_varlist4_;
  4933.  
  4934.     default:
  4935.       break;
  4936.     }
  4937.  
  4938.   ffelex_token_kill (ffesta_tokens[1]);
  4939.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
  4940.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4941. }
  4942.  
  4943. /* ffestb_varlist3_ -- "INTENT" OPEN_PAREN NAME ["OUT"]
  4944.  
  4945.    return ffestb_varlist3_;  // to lexer
  4946.  
  4947.    Handle CLOSE_PAREN.    */
  4948.  
  4949. static ffelexHandler
  4950. ffestb_varlist3_ (ffelexToken t)
  4951. {
  4952.   switch (ffelex_token_type (t))
  4953.     {
  4954.     case FFELEX_typeCLOSE_PAREN:
  4955.       return (ffelexHandler) ffestb_varlist4_;
  4956.  
  4957.     default:
  4958.       break;
  4959.     }
  4960.  
  4961.   ffelex_token_kill (ffesta_tokens[1]);
  4962.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
  4963.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4964. }
  4965.  
  4966. /* ffestb_varlist4_ -- "INTENT" OPEN_PAREN NAME ["OUT"] CLOSE_PAREN
  4967.  
  4968.    return ffestb_varlist4_;  // to lexer
  4969.  
  4970.    Handle COLONCOLON or NAME.  */
  4971.  
  4972. static ffelexHandler
  4973. ffestb_varlist4_ (ffelexToken t)
  4974. {
  4975.   switch (ffelex_token_type (t))
  4976.     {
  4977.     case FFELEX_typeCOLONCOLON:
  4978.       ffesta_confirmed ();
  4979.       if (!ffesta_is_inhibited ())
  4980.     ffestc_R519_start (ffesta_tokens[1], ffestb_local_.varlist.kw);
  4981.       ffelex_token_kill (ffesta_tokens[1]);
  4982.       return (ffelexHandler) ffestb_varlist5_;
  4983.  
  4984.     case FFELEX_typeNAME:
  4985.       ffesta_confirmed ();
  4986.       if (!ffesta_is_inhibited ())
  4987.     ffestc_R519_start (ffesta_tokens[1], ffestb_local_.varlist.kw);
  4988.       ffelex_token_kill (ffesta_tokens[1]);
  4989.       return (ffelexHandler) ffestb_varlist5_ (t);
  4990.  
  4991.     default:
  4992.       break;
  4993.     }
  4994.  
  4995.   ffelex_token_kill (ffesta_tokens[1]);
  4996.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
  4997.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  4998. }
  4999.  
  5000. #endif
  5001. /* ffestb_varlist5_ -- Handles the list of variable names
  5002.  
  5003.    return ffestb_varlist5_;  // to lexer
  5004.  
  5005.    Handle NAME.     */
  5006.  
  5007. static ffelexHandler
  5008. ffestb_varlist5_ (ffelexToken t)
  5009. {
  5010.   switch (ffelex_token_type (t))
  5011.     {
  5012.     case FFELEX_typeNAME:
  5013.       ffesta_tokens[1] = ffelex_token_use (t);
  5014.       return (ffelexHandler) ffestb_varlist6_;
  5015.  
  5016.     default:
  5017.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
  5018.       break;
  5019.     }
  5020.  
  5021.   if (!ffesta_is_inhibited ())
  5022.     {
  5023.       switch (ffesta_first_kw)
  5024.     {
  5025.     case FFESTR_firstEXTERNAL:
  5026.       ffestc_R1207_finish ();
  5027.       break;
  5028.  
  5029. #if FFESTR_F90
  5030.     case FFESTR_firstINTENT:
  5031.       ffestc_R519_finish ();
  5032.       break;
  5033. #endif
  5034.  
  5035.     case FFESTR_firstINTRINSIC:
  5036.       ffestc_R1208_finish ();
  5037.       break;
  5038.  
  5039. #if FFESTR_F90
  5040.     case FFESTR_firstOPTIONAL:
  5041.       ffestc_R520_finish ();
  5042.       break;
  5043. #endif
  5044.  
  5045. #if FFESTR_F90
  5046.     case FFESTR_firstPUBLIC:
  5047.       ffestc_R521Afinish ();
  5048.       break;
  5049.  
  5050.     case FFESTR_firstPRIVATE:
  5051.       ffestc_R521Bfinish ();
  5052.       break;
  5053. #endif
  5054.  
  5055.     default:
  5056.       assert (FALSE);
  5057.     }
  5058.     }
  5059.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5060. }
  5061.  
  5062. /* ffestb_varlist6_ -- (whatever) NAME
  5063.  
  5064.    return ffestb_varlist6_;  // to lexer
  5065.  
  5066.    Handle COMMA or EOS/SEMICOLON.  */
  5067.  
  5068. static ffelexHandler
  5069. ffestb_varlist6_ (ffelexToken t)
  5070. {
  5071.   switch (ffelex_token_type (t))
  5072.     {
  5073.     case FFELEX_typeCOMMA:
  5074.       if (!ffesta_is_inhibited ())
  5075.     {
  5076.       switch (ffesta_first_kw)
  5077.         {
  5078.         case FFESTR_firstEXTERNAL:
  5079.           ffestc_R1207_item (ffesta_tokens[1]);
  5080.           break;
  5081.  
  5082. #if FFESTR_F90
  5083.         case FFESTR_firstINTENT:
  5084.           ffestc_R519_item (ffesta_tokens[1]);
  5085.           break;
  5086. #endif
  5087.  
  5088.         case FFESTR_firstINTRINSIC:
  5089.           ffestc_R1208_item (ffesta_tokens[1]);
  5090.           break;
  5091.  
  5092. #if FFESTR_F90
  5093.         case FFESTR_firstOPTIONAL:
  5094.           ffestc_R520_item (ffesta_tokens[1]);
  5095.           break;
  5096. #endif
  5097.  
  5098. #if FFESTR_F90
  5099.         case FFESTR_firstPUBLIC:
  5100.           ffestc_R521Aitem (ffesta_tokens[1]);
  5101.           break;
  5102.  
  5103.         case FFESTR_firstPRIVATE:
  5104.           ffestc_R521Bitem (ffesta_tokens[1]);
  5105.           break;
  5106. #endif
  5107.  
  5108.         default:
  5109.           assert (FALSE);
  5110.         }
  5111.     }
  5112.       ffelex_token_kill (ffesta_tokens[1]);
  5113.       return (ffelexHandler) ffestb_varlist5_;
  5114.  
  5115.     case FFELEX_typeEOS:
  5116.     case FFELEX_typeSEMICOLON:
  5117.       if (!ffesta_is_inhibited ())
  5118.     {
  5119.       switch (ffesta_first_kw)
  5120.         {
  5121.         case FFESTR_firstEXTERNAL:
  5122.           ffestc_R1207_item (ffesta_tokens[1]);
  5123.           ffestc_R1207_finish ();
  5124.           break;
  5125.  
  5126. #if FFESTR_F90
  5127.         case FFESTR_firstINTENT:
  5128.           ffestc_R519_item (ffesta_tokens[1]);
  5129.           ffestc_R519_finish ();
  5130.           break;
  5131. #endif
  5132.  
  5133.         case FFESTR_firstINTRINSIC:
  5134.           ffestc_R1208_item (ffesta_tokens[1]);
  5135.           ffestc_R1208_finish ();
  5136.           break;
  5137.  
  5138. #if FFESTR_F90
  5139.         case FFESTR_firstOPTIONAL:
  5140.           ffestc_R520_item (ffesta_tokens[1]);
  5141.           ffestc_R520_finish ();
  5142.           break;
  5143. #endif
  5144.  
  5145. #if FFESTR_F90
  5146.         case FFESTR_firstPUBLIC:
  5147.           ffestc_R521Aitem (ffesta_tokens[1]);
  5148.           ffestc_R521Afinish ();
  5149.           break;
  5150.  
  5151.         case FFESTR_firstPRIVATE:
  5152.           ffestc_R521Bitem (ffesta_tokens[1]);
  5153.           ffestc_R521Bfinish ();
  5154.           break;
  5155. #endif
  5156.  
  5157.         default:
  5158.           assert (FALSE);
  5159.         }
  5160.     }
  5161.       ffelex_token_kill (ffesta_tokens[1]);
  5162.       return (ffelexHandler) ffesta_zero (t);
  5163.  
  5164.     default:
  5165.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.varlist.badname, t);
  5166.       break;
  5167.     }
  5168.  
  5169.   if (!ffesta_is_inhibited ())
  5170.     {
  5171.       switch (ffesta_first_kw)
  5172.     {
  5173.     case FFESTR_firstEXTERNAL:
  5174.       ffestc_R1207_finish ();
  5175.       break;
  5176.  
  5177. #if FFESTR_F90
  5178.     case FFESTR_firstINTENT:
  5179.       ffestc_R519_finish ();
  5180.       break;
  5181. #endif
  5182.  
  5183.     case FFESTR_firstINTRINSIC:
  5184.       ffestc_R1208_finish ();
  5185.       break;
  5186.  
  5187. #if FFESTR_F90
  5188.     case FFESTR_firstOPTIONAL:
  5189.       ffestc_R520_finish ();
  5190.       break;
  5191. #endif
  5192.  
  5193. #if FFESTR_F90
  5194.     case FFESTR_firstPUBLIC:
  5195.       ffestc_R521Afinish ();
  5196.       break;
  5197.  
  5198.     case FFESTR_firstPRIVATE:
  5199.       ffestc_R521Bfinish ();
  5200.       break;
  5201. #endif
  5202.  
  5203.     default:
  5204.       assert (FALSE);
  5205.     }
  5206.     }
  5207.   ffelex_token_kill (ffesta_tokens[1]);
  5208.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5209. }
  5210.  
  5211. /* ffestb_R423B -- Parse the SEQUENCE statement
  5212.  
  5213.    return ffestb_R423B;     // to lexer
  5214.  
  5215.    Make sure the statement has a valid form for the SEQUENCE statement.     If
  5216.    it does, implement the statement.  */
  5217.  
  5218. #if FFESTR_F90
  5219. ffelexHandler
  5220. ffestb_R423B (ffelexToken t)
  5221. {
  5222.   char *p;
  5223.   ffeTokenLength i;
  5224.  
  5225.   switch (ffelex_token_type (ffesta_tokens[0]))
  5226.     {
  5227.     case FFELEX_typeNAME:
  5228.       if (ffesta_first_kw != FFESTR_firstSEQUENCE)
  5229.     goto bad_0;        /* :::::::::::::::::::: */
  5230.       break;
  5231.  
  5232.     case FFELEX_typeNAMES:
  5233.       if (ffesta_first_kw != FFESTR_firstSEQUENCE)
  5234.     goto bad_0;        /* :::::::::::::::::::: */
  5235.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlSEQUENCE)
  5236.     {
  5237.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSEQUENCE);
  5238.       goto bad_i;        /* :::::::::::::::::::: */
  5239.     }
  5240.       break;
  5241.  
  5242.     default:
  5243.       goto bad_0;        /* :::::::::::::::::::: */
  5244.     }
  5245.  
  5246.   switch (ffelex_token_type (t))
  5247.     {
  5248.     case FFELEX_typeEOS:
  5249.     case FFELEX_typeSEMICOLON:
  5250.       ffesta_confirmed ();
  5251.       if (!ffesta_is_inhibited ())
  5252.     ffestc_R423B ();
  5253.       return (ffelexHandler) ffesta_zero (t);
  5254.  
  5255.     case FFELEX_typeCOMMA:
  5256.     case FFELEX_typeCOLONCOLON:
  5257.       ffesta_confirmed ();    /* Error, but clearly intended. */
  5258.       goto bad_1;        /* :::::::::::::::::::: */
  5259.  
  5260.     default:
  5261.       goto bad_1;        /* :::::::::::::::::::: */
  5262.     }
  5263.  
  5264. bad_0:                /* :::::::::::::::::::: */
  5265.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", ffesta_tokens[0]);
  5266.   return (ffelexHandler) ffelex_swallow_tokens (t,
  5267.                         (ffelexHandler) ffesta_zero);    /* Invalid first token. */
  5268.  
  5269. bad_1:                /* :::::::::::::::::::: */
  5270.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", t);
  5271.   return (ffelexHandler) ffelex_swallow_tokens (t,
  5272.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  5273.  
  5274. bad_i:                /* :::::::::::::::::::: */
  5275.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SEQUENCE", ffesta_tokens[0], i, t);
  5276.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5277. }
  5278.  
  5279. #endif
  5280. /* ffestb_R522 -- Parse the SAVE statement
  5281.  
  5282.    return ffestb_R522;    // to lexer
  5283.  
  5284.    Make sure the statement has a valid form for the SAVE statement.  If it
  5285.    does, implement the statement.  */
  5286.  
  5287. ffelexHandler
  5288. ffestb_R522 (ffelexToken t)
  5289. {
  5290.   ffeTokenLength i;
  5291.   char *p;
  5292.   ffelexToken nt;
  5293.   ffelexHandler next;
  5294.  
  5295.   switch (ffelex_token_type (ffesta_tokens[0]))
  5296.     {
  5297.     case FFELEX_typeNAME:
  5298.       if (ffesta_first_kw != FFESTR_firstSAVE)
  5299.     goto bad_0;        /* :::::::::::::::::::: */
  5300.       switch (ffelex_token_type (t))
  5301.     {
  5302.     case FFELEX_typeCOMMA:
  5303.       ffesta_confirmed ();    /* Error, but clearly intended. */
  5304.       goto bad_1;        /* :::::::::::::::::::: */
  5305.  
  5306.     default:
  5307.       goto bad_1;        /* :::::::::::::::::::: */
  5308.  
  5309.     case FFELEX_typeEOS:
  5310.     case FFELEX_typeSEMICOLON:
  5311.       ffesta_confirmed ();
  5312.       if (!ffesta_is_inhibited ())
  5313.         ffestc_R522 ();
  5314.       return (ffelexHandler) ffesta_zero (t);
  5315.  
  5316.     case FFELEX_typeNAME:
  5317.     case FFELEX_typeSLASH:
  5318.       ffesta_confirmed ();
  5319.       if (!ffesta_is_inhibited ())
  5320.         ffestc_R522start ();
  5321.       return (ffelexHandler) ffestb_R5221_ (t);
  5322.  
  5323.     case FFELEX_typeCOLONCOLON:
  5324.       ffesta_confirmed ();
  5325.       if (!ffesta_is_inhibited ())
  5326.         ffestc_R522start ();
  5327.       return (ffelexHandler) ffestb_R5221_;
  5328.     }
  5329.  
  5330.     case FFELEX_typeNAMES:
  5331.       if (ffesta_first_kw != FFESTR_firstSAVE)
  5332.     goto bad_0;        /* :::::::::::::::::::: */
  5333.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSAVE);
  5334.       switch (ffelex_token_type (t))
  5335.     {
  5336.     default:
  5337.       goto bad_1;        /* :::::::::::::::::::: */
  5338.  
  5339.     case FFELEX_typeCOMMA:
  5340.       ffesta_confirmed ();
  5341.       break;
  5342.  
  5343.     case FFELEX_typeEOS:
  5344.     case FFELEX_typeSEMICOLON:
  5345.       ffesta_confirmed ();
  5346.       if (*p != '\0')
  5347.         break;
  5348.       if (!ffesta_is_inhibited ())
  5349.         ffestc_R522 ();
  5350.       return (ffelexHandler) ffesta_zero (t);
  5351.  
  5352.     case FFELEX_typeSLASH:
  5353.       ffesta_confirmed ();
  5354.       if (*p != '\0')
  5355.         goto bad_i;        /* :::::::::::::::::::: */
  5356.       if (!ffesta_is_inhibited ())
  5357.         ffestc_R522start ();
  5358.       return (ffelexHandler) ffestb_R5221_ (t);
  5359.  
  5360.     case FFELEX_typeCOLONCOLON:
  5361.       ffesta_confirmed ();
  5362.       if (*p != '\0')
  5363.         goto bad_i;        /* :::::::::::::::::::: */
  5364.       if (!ffesta_is_inhibited ())
  5365.         ffestc_R522start ();
  5366.       return (ffelexHandler) ffestb_R5221_;
  5367.     }
  5368.  
  5369.       /* Here, we have at least one char after "SAVE" and t is COMMA or
  5370.          EOS/SEMICOLON. */
  5371.  
  5372.       if (!ffesrc_is_name_init (*p))
  5373.     goto bad_i;        /* :::::::::::::::::::: */
  5374.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  5375.       if (!ffesta_is_inhibited ())
  5376.     ffestc_R522start ();
  5377.       next = (ffelexHandler) ffestb_R5221_ (nt);
  5378.       ffelex_token_kill (nt);
  5379.       return (ffelexHandler) (*next) (t);
  5380.  
  5381.     default:
  5382.       goto bad_0;        /* :::::::::::::::::::: */
  5383.     }
  5384.  
  5385. bad_0:                /* :::::::::::::::::::: */
  5386.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", ffesta_tokens[0]);
  5387.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5388.  
  5389. bad_1:                /* :::::::::::::::::::: */
  5390.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
  5391.   return (ffelexHandler) ffelex_swallow_tokens (t,
  5392.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  5393.  
  5394. bad_i:                /* :::::::::::::::::::: */
  5395.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SAVE", ffesta_tokens[0], i, t);
  5396.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5397. }
  5398.  
  5399. /* ffestb_R5221_ -- "SAVE" [COLONCOLON]
  5400.  
  5401.    return ffestb_R5221_;  // to lexer
  5402.  
  5403.    Handle NAME or SLASH.  */
  5404.  
  5405. static ffelexHandler
  5406. ffestb_R5221_ (ffelexToken t)
  5407. {
  5408.   switch (ffelex_token_type (t))
  5409.     {
  5410.     case FFELEX_typeNAME:
  5411.       ffestb_local_.R522.is_cblock = FALSE;
  5412.       ffesta_tokens[1] = ffelex_token_use (t);
  5413.       return (ffelexHandler) ffestb_R5224_;
  5414.  
  5415.     case FFELEX_typeSLASH:
  5416.       ffestb_local_.R522.is_cblock = TRUE;
  5417.       return (ffelexHandler) ffestb_R5222_;
  5418.  
  5419.     default:
  5420.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
  5421.       break;
  5422.     }
  5423.  
  5424.   if (!ffesta_is_inhibited ())
  5425.     ffestc_R522finish ();
  5426.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5427. }
  5428.  
  5429. /* ffestb_R5222_ -- "SAVE" [COLONCOLON] SLASH
  5430.  
  5431.    return ffestb_R5222_;  // to lexer
  5432.  
  5433.    Handle NAME.     */
  5434.  
  5435. static ffelexHandler
  5436. ffestb_R5222_ (ffelexToken t)
  5437. {
  5438.   switch (ffelex_token_type (t))
  5439.     {
  5440.     case FFELEX_typeNAME:
  5441.       ffesta_tokens[1] = ffelex_token_use (t);
  5442.       return (ffelexHandler) ffestb_R5223_;
  5443.  
  5444.     default:
  5445.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
  5446.       break;
  5447.     }
  5448.  
  5449.   if (!ffesta_is_inhibited ())
  5450.     ffestc_R522finish ();
  5451.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5452. }
  5453.  
  5454. /* ffestb_R5223_ -- "SAVE" [COLONCOLON] SLASH NAME
  5455.  
  5456.    return ffestb_R5223_;  // to lexer
  5457.  
  5458.    Handle SLASH.  */
  5459.  
  5460. static ffelexHandler
  5461. ffestb_R5223_ (ffelexToken t)
  5462. {
  5463.   switch (ffelex_token_type (t))
  5464.     {
  5465.     case FFELEX_typeSLASH:
  5466.       return (ffelexHandler) ffestb_R5224_;
  5467.  
  5468.     default:
  5469.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
  5470.       break;
  5471.     }
  5472.  
  5473.   if (!ffesta_is_inhibited ())
  5474.     ffestc_R522finish ();
  5475.   ffelex_token_kill (ffesta_tokens[1]);
  5476.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5477. }
  5478.  
  5479. /* ffestb_R5224_ -- "SAVE" [COLONCOLON] R523
  5480.  
  5481.    return ffestb_R5224_;  // to lexer
  5482.  
  5483.    Handle COMMA or EOS/SEMICOLON.  */
  5484.  
  5485. static ffelexHandler
  5486. ffestb_R5224_ (ffelexToken t)
  5487. {
  5488.   switch (ffelex_token_type (t))
  5489.     {
  5490.     case FFELEX_typeCOMMA:
  5491.       if (!ffesta_is_inhibited ())
  5492.     {
  5493.       if (ffestb_local_.R522.is_cblock)
  5494.         ffestc_R522item_cblock (ffesta_tokens[1]);
  5495.       else
  5496.         ffestc_R522item_object (ffesta_tokens[1]);
  5497.     }
  5498.       ffelex_token_kill (ffesta_tokens[1]);
  5499.       return (ffelexHandler) ffestb_R5221_;
  5500.  
  5501.     case FFELEX_typeEOS:
  5502.     case FFELEX_typeSEMICOLON:
  5503.       if (!ffesta_is_inhibited ())
  5504.     {
  5505.       if (ffestb_local_.R522.is_cblock)
  5506.         ffestc_R522item_cblock (ffesta_tokens[1]);
  5507.       else
  5508.         ffestc_R522item_object (ffesta_tokens[1]);
  5509.       ffestc_R522finish ();
  5510.     }
  5511.       ffelex_token_kill (ffesta_tokens[1]);
  5512.       return (ffelexHandler) ffesta_zero (t);
  5513.  
  5514.     default:
  5515.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SAVE", t);
  5516.       break;
  5517.     }
  5518.  
  5519.   if (!ffesta_is_inhibited ())
  5520.     ffestc_R522finish ();
  5521.   ffelex_token_kill (ffesta_tokens[1]);
  5522.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5523. }
  5524.  
  5525. /* ffestb_R528 -- Parse the DATA statement
  5526.  
  5527.    return ffestb_R528;    // to lexer
  5528.  
  5529.    Make sure the statement has a valid form for the DATA statement.  If it
  5530.    does, implement the statement.  */
  5531.  
  5532. ffelexHandler
  5533. ffestb_R528 (ffelexToken t)
  5534. {
  5535.   char *p;
  5536.   ffeTokenLength i;
  5537.   ffelexToken nt;
  5538.   ffelexHandler next;
  5539.  
  5540.   switch (ffelex_token_type (ffesta_tokens[0]))
  5541.     {
  5542.     case FFELEX_typeNAME:
  5543.       if (ffesta_first_kw != FFESTR_firstDATA)
  5544.     goto bad_0;        /* :::::::::::::::::::: */
  5545.       switch (ffelex_token_type (t))
  5546.     {
  5547.     case FFELEX_typeCOMMA:
  5548.     case FFELEX_typeEOS:
  5549.     case FFELEX_typeSEMICOLON:
  5550.     case FFELEX_typeSLASH:
  5551.     case FFELEX_typeCOLONCOLON:
  5552.       ffesta_confirmed ();    /* Error, but clearly intended. */
  5553.       goto bad_1;        /* :::::::::::::::::::: */
  5554.  
  5555.     default:
  5556.       goto bad_1;        /* :::::::::::::::::::: */
  5557.  
  5558.     case FFELEX_typeNAME:
  5559.       ffesta_confirmed ();
  5560.       break;
  5561.  
  5562.     case FFELEX_typeOPEN_PAREN:
  5563.       break;
  5564.     }
  5565.       ffestb_local_.data.started = FALSE;
  5566.       return (ffelexHandler) (*((ffelexHandler)
  5567.                 ffeexpr_lhs (ffesta_output_pool,
  5568.                          FFEEXPR_contextDATA,
  5569.                       (ffeexprCallback) ffestb_R5281_)))
  5570.     (t);
  5571.  
  5572.     case FFELEX_typeNAMES:
  5573.       if (ffesta_first_kw != FFESTR_firstDATA)
  5574.     goto bad_0;        /* :::::::::::::::::::: */
  5575.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDATA);
  5576.       switch (ffelex_token_type (t))
  5577.     {
  5578.     case FFELEX_typeEOS:
  5579.     case FFELEX_typeSEMICOLON:
  5580.     case FFELEX_typeCOLONCOLON:
  5581.       ffesta_confirmed ();    /* Error, but clearly intended. */
  5582.       goto bad_1;        /* :::::::::::::::::::: */
  5583.  
  5584.     default:
  5585.       goto bad_1;        /* :::::::::::::::::::: */
  5586.  
  5587.     case FFELEX_typeOPEN_PAREN:
  5588.       if (*p == '\0')
  5589.         {
  5590.           ffestb_local_.data.started = FALSE;
  5591.           return (ffelexHandler) (*((ffelexHandler)
  5592.                     ffeexpr_lhs (ffesta_output_pool,
  5593.                              FFEEXPR_contextDATA,
  5594.                              (ffeexprCallback)
  5595.                              ffestb_R5281_)))
  5596.         (t);
  5597.         }
  5598.       break;
  5599.  
  5600.     case FFELEX_typeCOMMA:
  5601.     case FFELEX_typeSLASH:
  5602.       ffesta_confirmed ();
  5603.       break;
  5604.     }
  5605.       if (!ffesrc_is_name_init (*p))
  5606.     goto bad_i;        /* :::::::::::::::::::: */
  5607.       ffestb_local_.data.started = FALSE;
  5608.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  5609.       next = (ffelexHandler) (*((ffelexHandler)
  5610.                 ffeexpr_lhs (ffesta_output_pool,
  5611.                          FFEEXPR_contextDATA,
  5612.                       (ffeexprCallback) ffestb_R5281_)))
  5613.     (nt);
  5614.       ffelex_token_kill (nt);
  5615.       return (ffelexHandler) (*next) (t);
  5616.  
  5617.     default:
  5618.       goto bad_0;        /* :::::::::::::::::::: */
  5619.     }
  5620.  
  5621. bad_0:                /* :::::::::::::::::::: */
  5622.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", ffesta_tokens[0]);
  5623.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5624.  
  5625. bad_1:                /* :::::::::::::::::::: */
  5626.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
  5627.   return (ffelexHandler) ffelex_swallow_tokens (t,
  5628.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  5629.  
  5630. bad_i:                /* :::::::::::::::::::: */
  5631.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DATA", ffesta_tokens[0], i, t);
  5632.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5633. }
  5634.  
  5635. /* ffestb_R5281_ -- "DATA" expr-list
  5636.  
  5637.    (ffestb_R5281_)  // to expression handler
  5638.  
  5639.    Handle COMMA or SLASH.  */
  5640.  
  5641. static ffelexHandler
  5642. ffestb_R5281_ (ffelexToken ft, ffebld expr, ffelexToken t)
  5643. {
  5644.   switch (ffelex_token_type (t))
  5645.     {
  5646.     case FFELEX_typeCOMMA:
  5647.       ffesta_confirmed ();
  5648.       if (expr == NULL)
  5649.     break;
  5650.       if (!ffesta_is_inhibited ())
  5651.     {
  5652.       if (!ffestb_local_.data.started)
  5653.         {
  5654.           ffestc_R528_start ();
  5655.           ffestb_local_.data.started = TRUE;
  5656.         }
  5657.       ffestc_R528_item_object (expr, ft);
  5658.     }
  5659.       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  5660.                       FFEEXPR_contextDATA,
  5661.                       (ffeexprCallback) ffestb_R5281_);
  5662.  
  5663.     case FFELEX_typeSLASH:
  5664.       ffesta_confirmed ();
  5665.       if (expr == NULL)
  5666.     break;
  5667.       if (!ffesta_is_inhibited ())
  5668.     {
  5669.       if (!ffestb_local_.data.started)
  5670.         {
  5671.           ffestc_R528_start ();
  5672.           ffestb_local_.data.started = TRUE;
  5673.         }
  5674.       ffestc_R528_item_object (expr, ft);
  5675.       ffestc_R528_item_startvals ();
  5676.     }
  5677.       return (ffelexHandler) ffeexpr_rhs
  5678.     (ffesta_output_pool, FFEEXPR_contextDATA,
  5679.      (ffeexprCallback) ffestb_R5282_);
  5680.  
  5681.     default:
  5682.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
  5683.       break;
  5684.     }
  5685.  
  5686.   if (ffestb_local_.data.started && !ffesta_is_inhibited ())
  5687.     ffestc_R528_finish ();
  5688.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5689. }
  5690.  
  5691. /* ffestb_R5282_ -- "DATA" expr-list SLASH expr-list
  5692.  
  5693.    (ffestb_R5282_)  // to expression handler
  5694.  
  5695.    Handle ASTERISK, COMMA, or SLASH.  */
  5696.  
  5697. static ffelexHandler
  5698. ffestb_R5282_ (ffelexToken ft, ffebld expr, ffelexToken t)
  5699. {
  5700.   switch (ffelex_token_type (t))
  5701.     {
  5702.     case FFELEX_typeCOMMA:
  5703.       if (expr == NULL)
  5704.     break;
  5705.       if (!ffesta_is_inhibited ())
  5706.     ffestc_R528_item_value (NULL, NULL, expr, ft);
  5707.       return (ffelexHandler) ffeexpr_rhs
  5708.     (ffesta_output_pool, FFEEXPR_contextDATA,
  5709.      (ffeexprCallback) ffestb_R5282_);
  5710.  
  5711.     case FFELEX_typeASTERISK:
  5712.       if (expr == NULL)
  5713.     break;
  5714.       ffestb_local_.data.expr = expr;
  5715.       ffesta_tokens[1] = ffelex_token_use (ft);
  5716.       return (ffelexHandler) ffeexpr_rhs
  5717.     (ffesta_output_pool, FFEEXPR_contextDATA,
  5718.      (ffeexprCallback) ffestb_R5283_);
  5719.  
  5720.     case FFELEX_typeSLASH:
  5721.       if (expr == NULL)
  5722.     break;
  5723.       if (!ffesta_is_inhibited ())
  5724.     {
  5725.       ffestc_R528_item_value (NULL, NULL, expr, ft);
  5726.       ffestc_R528_item_endvals (t);
  5727.     }
  5728.       return (ffelexHandler) ffestb_R5284_;
  5729.  
  5730.     default:
  5731.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
  5732.       break;
  5733.     }
  5734.  
  5735.   if (!ffesta_is_inhibited ())
  5736.     {
  5737.       ffestc_R528_item_endvals (t);
  5738.       ffestc_R528_finish ();
  5739.     }
  5740.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5741. }
  5742.  
  5743. /* ffestb_R5283_ -- "DATA" expr-list SLASH expr ASTERISK expr
  5744.  
  5745.    (ffestb_R5283_)  // to expression handler
  5746.  
  5747.    Handle COMMA or SLASH.  */
  5748.  
  5749. static ffelexHandler
  5750. ffestb_R5283_ (ffelexToken ft, ffebld expr, ffelexToken t)
  5751. {
  5752.   switch (ffelex_token_type (t))
  5753.     {
  5754.     case FFELEX_typeCOMMA:
  5755.       if (expr == NULL)
  5756.     break;
  5757.       if (!ffesta_is_inhibited ())
  5758.     ffestc_R528_item_value (ffestb_local_.data.expr, ffesta_tokens[1],
  5759.                 expr, ft);
  5760.       ffelex_token_kill (ffesta_tokens[1]);
  5761.       return (ffelexHandler) ffeexpr_rhs
  5762.     (ffesta_output_pool, FFEEXPR_contextDATA,
  5763.      (ffeexprCallback) ffestb_R5282_);
  5764.  
  5765.     case FFELEX_typeSLASH:
  5766.       if (expr == NULL)
  5767.     break;
  5768.       if (!ffesta_is_inhibited ())
  5769.     {
  5770.       ffestc_R528_item_value (ffestb_local_.data.expr, ffesta_tokens[1],
  5771.                   expr, ft);
  5772.       ffestc_R528_item_endvals (t);
  5773.     }
  5774.       ffelex_token_kill (ffesta_tokens[1]);
  5775.       return (ffelexHandler) ffestb_R5284_;
  5776.  
  5777.     default:
  5778.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
  5779.       break;
  5780.     }
  5781.  
  5782.   if (!ffesta_is_inhibited ())
  5783.     {
  5784.       ffestc_R528_item_endvals (t);
  5785.       ffestc_R528_finish ();
  5786.     }
  5787.   ffelex_token_kill (ffesta_tokens[1]);
  5788.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5789. }
  5790.  
  5791. /* ffestb_R5284_ -- "DATA" expr-list SLASH expr-list SLASH
  5792.  
  5793.    return ffestb_R5284_;  // to lexer
  5794.  
  5795.    Handle [COMMA] NAME or EOS/SEMICOLON.  */
  5796.  
  5797. static ffelexHandler
  5798. ffestb_R5284_ (ffelexToken t)
  5799. {
  5800.   switch (ffelex_token_type (t))
  5801.     {
  5802.     case FFELEX_typeCOMMA:
  5803.       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  5804.                       FFEEXPR_contextDATA,
  5805.                       (ffeexprCallback) ffestb_R5281_);
  5806.  
  5807.     case FFELEX_typeNAME:
  5808.       return (ffelexHandler) (*((ffelexHandler)
  5809.                 ffeexpr_lhs (ffesta_output_pool,
  5810.                          FFEEXPR_contextDATA,
  5811.                       (ffeexprCallback) ffestb_R5281_)))
  5812.     (t);
  5813.  
  5814.     case FFELEX_typeEOS:
  5815.     case FFELEX_typeSEMICOLON:
  5816.       if (!ffesta_is_inhibited ())
  5817.     ffestc_R528_finish ();
  5818.       return (ffelexHandler) ffesta_zero (t);
  5819.  
  5820.     default:
  5821.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DATA", t);
  5822.       break;
  5823.     }
  5824.  
  5825.   if (!ffesta_is_inhibited ())
  5826.     ffestc_R528_finish ();
  5827.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5828. }
  5829.  
  5830. /* ffestb_R537 -- Parse a PARAMETER statement
  5831.  
  5832.    return ffestb_R537;    // to lexer
  5833.  
  5834.    Make sure the statement has a valid form for an PARAMETER statement.
  5835.    If it does, implement the statement.     */
  5836.  
  5837. ffelexHandler
  5838. ffestb_R537 (ffelexToken t)
  5839. {
  5840.   switch (ffelex_token_type (ffesta_tokens[0]))
  5841.     {
  5842.     case FFELEX_typeNAME:
  5843.       if (ffesta_first_kw != FFESTR_firstPARAMETER)
  5844.     goto bad_0;        /* :::::::::::::::::::: */
  5845.       break;
  5846.  
  5847.     case FFELEX_typeNAMES:
  5848.       if (ffesta_first_kw != FFESTR_firstPARAMETER)
  5849.     goto bad_0;        /* :::::::::::::::::::: */
  5850.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlPARAMETER)
  5851.     goto bad_0;        /* :::::::::::::::::::: */
  5852.       break;
  5853.  
  5854.     default:
  5855.       goto bad_0;        /* :::::::::::::::::::: */
  5856.     }
  5857.  
  5858.   switch (ffelex_token_type (t))
  5859.     {
  5860.     case FFELEX_typeOPEN_PAREN:
  5861.       break;
  5862.  
  5863.     case FFELEX_typeEOS:
  5864.     case FFELEX_typeSEMICOLON:
  5865.     case FFELEX_typeCOMMA:
  5866.     case FFELEX_typeCOLONCOLON:
  5867.       ffesta_confirmed ();    /* Error, but clearly intended. */
  5868.       goto bad_1;        /* :::::::::::::::::::: */
  5869.  
  5870.     default:
  5871.       goto bad_1;        /* :::::::::::::::::::: */
  5872.     }
  5873.  
  5874.   ffestb_local_.parameter.started = FALSE;
  5875.   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  5876.                       FFEEXPR_contextPARAMETER,
  5877.                       (ffeexprCallback) ffestb_R5371_);
  5878.  
  5879. bad_0:                /* :::::::::::::::::::: */
  5880.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0]);
  5881.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5882.  
  5883. bad_1:                /* :::::::::::::::::::: */
  5884.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
  5885.   return (ffelexHandler) ffelex_swallow_tokens (t,
  5886.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  5887. }
  5888.  
  5889. /* ffestb_R5371_ -- "PARAMETER" OPEN_PAREN expr
  5890.  
  5891.    (ffestb_R5371_)  // to expression handler
  5892.  
  5893.    Make sure the next token is EQUALS.    */
  5894.  
  5895. static ffelexHandler
  5896. ffestb_R5371_ (ffelexToken ft, ffebld expr, ffelexToken t)
  5897. {
  5898.   ffestb_local_.parameter.expr = expr;
  5899.  
  5900.   switch (ffelex_token_type (t))
  5901.     {
  5902.     case FFELEX_typeEQUALS:
  5903.       ffesta_confirmed ();
  5904.       if (expr == NULL)
  5905.     break;
  5906.       ffesta_tokens[1] = ffelex_token_use (ft);
  5907.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  5908.          FFEEXPR_contextPARAMETER, (ffeexprCallback) ffestb_R5372_);
  5909.  
  5910.     default:
  5911.       break;
  5912.     }
  5913.  
  5914.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
  5915.   if (ffestb_local_.parameter.started)
  5916.     ffestc_R537_finish ();
  5917.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5918. }
  5919.  
  5920. /* ffestb_R5372_ -- "PARAMETER" OPEN_PAREN expr EQUALS expr
  5921.  
  5922.    (ffestb_R5372_)  // to expression handler
  5923.  
  5924.    Make sure the next token is COMMA or CLOSE_PAREN.  */
  5925.  
  5926. static ffelexHandler
  5927. ffestb_R5372_ (ffelexToken ft, ffebld expr, ffelexToken t)
  5928. {
  5929.   switch (ffelex_token_type (t))
  5930.     {
  5931.     case FFELEX_typeCOMMA:
  5932.       if (expr == NULL)
  5933.     break;
  5934.       if (!ffesta_is_inhibited ())
  5935.     {
  5936.       if (!ffestb_local_.parameter.started)
  5937.         {
  5938.           ffestc_R537_start ();
  5939.           ffestb_local_.parameter.started = TRUE;
  5940.         }
  5941.       ffestc_R537_item (ffestb_local_.parameter.expr, ffesta_tokens[1],
  5942.                 expr, ft);
  5943.     }
  5944.       ffelex_token_kill (ffesta_tokens[1]);
  5945.       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  5946.                       FFEEXPR_contextPARAMETER,
  5947.                       (ffeexprCallback) ffestb_R5371_);
  5948.  
  5949.     case FFELEX_typeCLOSE_PAREN:
  5950.       if (expr == NULL)
  5951.     break;
  5952.       if (!ffesta_is_inhibited ())
  5953.     {
  5954.       if (!ffestb_local_.parameter.started)
  5955.         {
  5956.           ffestc_R537_start ();
  5957.           ffestb_local_.parameter.started = TRUE;
  5958.         }
  5959.       ffestc_R537_item (ffestb_local_.parameter.expr, ffesta_tokens[1],
  5960.                 expr, ft);
  5961.       ffestc_R537_finish ();
  5962.     }
  5963.       ffelex_token_kill (ffesta_tokens[1]);
  5964.       return (ffelexHandler) ffestb_R5373_;
  5965.  
  5966.     default:
  5967.       break;
  5968.     }
  5969.  
  5970.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
  5971.   if (ffestb_local_.parameter.started)
  5972.     ffestc_R537_finish ();
  5973.   ffelex_token_kill (ffesta_tokens[1]);
  5974.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5975. }
  5976.  
  5977. /* ffestb_R5373_ -- "PARAMETER" OPEN_PAREN expr EQUALS expr CLOSE_PAREN
  5978.  
  5979.    return ffestb_R5373_;  // to lexer
  5980.  
  5981.    Make sure the next token is EOS or SEMICOLON, or generate an error.    All
  5982.    cleanup has already been done, by the way.  */
  5983.  
  5984. static ffelexHandler
  5985. ffestb_R5373_ (ffelexToken t)
  5986. {
  5987.   switch (ffelex_token_type (t))
  5988.     {
  5989.     case FFELEX_typeEOS:
  5990.     case FFELEX_typeSEMICOLON:
  5991.       return (ffelexHandler) ffesta_zero (t);
  5992.  
  5993.     default:
  5994.       break;
  5995.     }
  5996.  
  5997.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
  5998.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  5999. }
  6000.  
  6001. /* ffestb_R542 -- Parse the NAMELIST statement
  6002.  
  6003.    return ffestb_R542;    // to lexer
  6004.  
  6005.    Make sure the statement has a valid form for the NAMELIST statement.     If it
  6006.    does, implement the statement.  */
  6007.  
  6008. ffelexHandler
  6009. ffestb_R542 (ffelexToken t)
  6010. {
  6011.   char *p;
  6012.   ffeTokenLength i;
  6013.  
  6014.   switch (ffelex_token_type (ffesta_tokens[0]))
  6015.     {
  6016.     case FFELEX_typeNAME:
  6017.       if (ffesta_first_kw != FFESTR_firstNAMELIST)
  6018.     goto bad_0;        /* :::::::::::::::::::: */
  6019.       break;
  6020.  
  6021.     case FFELEX_typeNAMES:
  6022.       if (ffesta_first_kw != FFESTR_firstNAMELIST)
  6023.     goto bad_0;        /* :::::::::::::::::::: */
  6024.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlNAMELIST);
  6025.       if (*p != '\0')
  6026.     goto bad_i;        /* :::::::::::::::::::: */
  6027.       break;
  6028.  
  6029.     default:
  6030.       goto bad_0;        /* :::::::::::::::::::: */
  6031.     }
  6032.  
  6033.   switch (ffelex_token_type (t))
  6034.     {
  6035.     case FFELEX_typeCOMMA:
  6036.     case FFELEX_typeEOS:
  6037.     case FFELEX_typeSEMICOLON:
  6038.     case FFELEX_typeCOLONCOLON:
  6039.       ffesta_confirmed ();    /* Error, but clearly intended. */
  6040.       goto bad_1;        /* :::::::::::::::::::: */
  6041.  
  6042.     default:
  6043.       goto bad_1;        /* :::::::::::::::::::: */
  6044.  
  6045.     case FFELEX_typeSLASH:
  6046.       break;
  6047.     }
  6048.  
  6049.   ffesta_confirmed ();
  6050.   if (!ffesta_is_inhibited ())
  6051.     ffestc_R542_start ();
  6052.   return (ffelexHandler) ffestb_R5421_;
  6053.  
  6054. bad_0:                /* :::::::::::::::::::: */
  6055.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", ffesta_tokens[0]);
  6056.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6057.  
  6058. bad_1:                /* :::::::::::::::::::: */
  6059.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
  6060.   return (ffelexHandler) ffelex_swallow_tokens (t,
  6061.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  6062.  
  6063. bad_i:                /* :::::::::::::::::::: */
  6064.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "NAMELIST", ffesta_tokens[0], i, t);
  6065.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6066. }
  6067.  
  6068. /* ffestb_R5421_ -- "NAMELIST" SLASH
  6069.  
  6070.    return ffestb_R5421_;  // to lexer
  6071.  
  6072.    Handle NAME.     */
  6073.  
  6074. static ffelexHandler
  6075. ffestb_R5421_ (ffelexToken t)
  6076. {
  6077.   switch (ffelex_token_type (t))
  6078.     {
  6079.     case FFELEX_typeNAME:
  6080.       if (!ffesta_is_inhibited ())
  6081.     ffestc_R542_item_nlist (t);
  6082.       return (ffelexHandler) ffestb_R5422_;
  6083.  
  6084.     default:
  6085.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
  6086.       break;
  6087.     }
  6088.  
  6089.   if (!ffesta_is_inhibited ())
  6090.     ffestc_R542_finish ();
  6091.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6092. }
  6093.  
  6094. /* ffestb_R5422_ -- "NAMELIST" SLASH NAME
  6095.  
  6096.    return ffestb_R5422_;  // to lexer
  6097.  
  6098.    Handle SLASH.  */
  6099.  
  6100. static ffelexHandler
  6101. ffestb_R5422_ (ffelexToken t)
  6102. {
  6103.   switch (ffelex_token_type (t))
  6104.     {
  6105.     case FFELEX_typeSLASH:
  6106.       return (ffelexHandler) ffestb_R5423_;
  6107.  
  6108.     default:
  6109.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
  6110.       break;
  6111.     }
  6112.  
  6113.   if (!ffesta_is_inhibited ())
  6114.     ffestc_R542_finish ();
  6115.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6116. }
  6117.  
  6118. /* ffestb_R5423_ -- "NAMELIST" SLASH NAME SLASH
  6119.  
  6120.    return ffestb_R5423_;  // to lexer
  6121.  
  6122.    Handle NAME.     */
  6123.  
  6124. static ffelexHandler
  6125. ffestb_R5423_ (ffelexToken t)
  6126. {
  6127.   switch (ffelex_token_type (t))
  6128.     {
  6129.     case FFELEX_typeNAME:
  6130.       if (!ffesta_is_inhibited ())
  6131.     ffestc_R542_item_nitem (t);
  6132.       return (ffelexHandler) ffestb_R5424_;
  6133.  
  6134.     default:
  6135.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
  6136.       break;
  6137.     }
  6138.  
  6139.   if (!ffesta_is_inhibited ())
  6140.     ffestc_R542_finish ();
  6141.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6142. }
  6143.  
  6144. /* ffestb_R5424_ -- "NAMELIST" SLASH NAME SLASH NAME
  6145.  
  6146.    return ffestb_R5424_;  // to lexer
  6147.  
  6148.    Handle COMMA, EOS/SEMICOLON, or SLASH.  */
  6149.  
  6150. static ffelexHandler
  6151. ffestb_R5424_ (ffelexToken t)
  6152. {
  6153.   switch (ffelex_token_type (t))
  6154.     {
  6155.     case FFELEX_typeCOMMA:
  6156.       return (ffelexHandler) ffestb_R5425_;
  6157.  
  6158.     case FFELEX_typeEOS:
  6159.     case FFELEX_typeSEMICOLON:
  6160.       if (!ffesta_is_inhibited ())
  6161.     ffestc_R542_finish ();
  6162.       return (ffelexHandler) ffesta_zero (t);
  6163.  
  6164.     case FFELEX_typeSLASH:
  6165.       return (ffelexHandler) ffestb_R5421_;
  6166.  
  6167.     default:
  6168.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
  6169.       break;
  6170.     }
  6171.  
  6172.   if (!ffesta_is_inhibited ())
  6173.     ffestc_R542_finish ();
  6174.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6175. }
  6176.  
  6177. /* ffestb_R5425_ -- "NAMELIST" SLASH NAME SLASH NAME COMMA
  6178.  
  6179.    return ffestb_R5425_;  // to lexer
  6180.  
  6181.    Handle NAME or SLASH.  */
  6182.  
  6183. static ffelexHandler
  6184. ffestb_R5425_ (ffelexToken t)
  6185. {
  6186.   switch (ffelex_token_type (t))
  6187.     {
  6188.     case FFELEX_typeNAME:
  6189.       if (!ffesta_is_inhibited ())
  6190.     ffestc_R542_item_nitem (t);
  6191.       return (ffelexHandler) ffestb_R5424_;
  6192.  
  6193.     case FFELEX_typeSLASH:
  6194.       return (ffelexHandler) ffestb_R5421_;
  6195.  
  6196.     default:
  6197.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NAMELIST", t);
  6198.       break;
  6199.     }
  6200.  
  6201.   if (!ffesta_is_inhibited ())
  6202.     ffestc_R542_finish ();
  6203.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6204. }
  6205.  
  6206. /* ffestb_R544 -- Parse an EQUIVALENCE statement
  6207.  
  6208.    return ffestb_R544;    // to lexer
  6209.  
  6210.    Make sure the statement has a valid form for an EQUIVALENCE statement.
  6211.    If it does, implement the statement.     */
  6212.  
  6213. ffelexHandler
  6214. ffestb_R544 (ffelexToken t)
  6215. {
  6216.   switch (ffelex_token_type (ffesta_tokens[0]))
  6217.     {
  6218.     case FFELEX_typeNAME:
  6219.       if (ffesta_first_kw != FFESTR_firstEQUIVALENCE)
  6220.     goto bad_0;        /* :::::::::::::::::::: */
  6221.       break;
  6222.  
  6223.     case FFELEX_typeNAMES:
  6224.       if (ffesta_first_kw != FFESTR_firstEQUIVALENCE)
  6225.     goto bad_0;        /* :::::::::::::::::::: */
  6226.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlEQUIVALENCE)
  6227.     goto bad_0;        /* :::::::::::::::::::: */
  6228.       break;
  6229.  
  6230.     default:
  6231.       goto bad_0;        /* :::::::::::::::::::: */
  6232.     }
  6233.  
  6234.   switch (ffelex_token_type (t))
  6235.     {
  6236.     case FFELEX_typeOPEN_PAREN:
  6237.       break;
  6238.  
  6239.     case FFELEX_typeEOS:
  6240.     case FFELEX_typeSEMICOLON:
  6241.     case FFELEX_typeCOMMA:
  6242.     case FFELEX_typeCOLONCOLON:
  6243.       ffesta_confirmed ();    /* Error, but clearly intended. */
  6244.       goto bad_1;        /* :::::::::::::::::::: */
  6245.  
  6246.     default:
  6247.       goto bad_1;        /* :::::::::::::::::::: */
  6248.     }
  6249.  
  6250.   ffestb_local_.equivalence.started = FALSE;
  6251.   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  6252.                       FFEEXPR_contextEQUIVALENCE,
  6253.                       (ffeexprCallback) ffestb_R5441_);
  6254.  
  6255. bad_0:                /* :::::::::::::::::::: */
  6256.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", ffesta_tokens[0]);
  6257.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6258.  
  6259. bad_1:                /* :::::::::::::::::::: */
  6260.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
  6261.   return (ffelexHandler) ffelex_swallow_tokens (t,
  6262.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  6263. }
  6264.  
  6265. /* ffestb_R5441_ -- "EQUIVALENCE" OPEN_PAREN expr
  6266.  
  6267.    (ffestb_R5441_)  // to expression handler
  6268.  
  6269.    Make sure the next token is COMMA.  */
  6270.  
  6271. static ffelexHandler
  6272. ffestb_R5441_ (ffelexToken ft, ffebld expr, ffelexToken t)
  6273. {
  6274.   switch (ffelex_token_type (t))
  6275.     {
  6276.     case FFELEX_typeCOMMA:
  6277.       if (expr == NULL)
  6278.     break;
  6279.       ffestb_local_.equivalence.exprs = ffestt_exprlist_create ();
  6280.       ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
  6281.                   ffelex_token_use (ft));
  6282.       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  6283.                       FFEEXPR_contextEQUIVALENCE,
  6284.                       (ffeexprCallback) ffestb_R5442_);
  6285.  
  6286.     default:
  6287.       break;
  6288.     }
  6289.  
  6290.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
  6291.   if (ffestb_local_.equivalence.started)
  6292.     ffestc_R544_finish ();
  6293.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6294. }
  6295.  
  6296. /* ffestb_R5442_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr
  6297.  
  6298.    (ffestb_R5442_)  // to expression handler
  6299.  
  6300.    Make sure the next token is COMMA or CLOSE_PAREN.  For COMMA, we just
  6301.    append the expression to our list and continue; for CLOSE_PAREN, we
  6302.    append the expression and move to _3_.  */
  6303.  
  6304. static ffelexHandler
  6305. ffestb_R5442_ (ffelexToken ft, ffebld expr, ffelexToken t)
  6306. {
  6307.   switch (ffelex_token_type (t))
  6308.     {
  6309.     case FFELEX_typeCOMMA:
  6310.       if (expr == NULL)
  6311.     break;
  6312.       ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
  6313.                   ffelex_token_use (ft));
  6314.       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  6315.                       FFEEXPR_contextEQUIVALENCE,
  6316.                       (ffeexprCallback) ffestb_R5442_);
  6317.  
  6318.     case FFELEX_typeCLOSE_PAREN:
  6319.       if (expr == NULL)
  6320.     break;
  6321.       ffestt_exprlist_append (ffestb_local_.equivalence.exprs, expr,
  6322.                   ffelex_token_use (ft));
  6323.       return (ffelexHandler) ffestb_R5443_;
  6324.  
  6325.     default:
  6326.       break;
  6327.     }
  6328.  
  6329.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
  6330.   if (ffestb_local_.equivalence.started)
  6331.     ffestc_R544_finish ();
  6332.   ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
  6333.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6334. }
  6335.  
  6336. /* ffestb_R5443_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr CLOSE_PAREN
  6337.  
  6338.    return ffestb_R5443_;  // to lexer
  6339.  
  6340.    Make sure the next token is COMMA or EOS/SEMICOLON.    */
  6341.  
  6342. static ffelexHandler
  6343. ffestb_R5443_ (ffelexToken t)
  6344. {
  6345.   switch (ffelex_token_type (t))
  6346.     {
  6347.     case FFELEX_typeCOMMA:
  6348.       ffesta_confirmed ();
  6349.       if (!ffesta_is_inhibited ())
  6350.     {
  6351.       if (!ffestb_local_.equivalence.started)
  6352.         {
  6353.           ffestc_R544_start ();
  6354.           ffestb_local_.equivalence.started = TRUE;
  6355.         }
  6356.       ffestc_R544_item (ffestb_local_.equivalence.exprs);
  6357.     }
  6358.       ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
  6359.       return (ffelexHandler) ffestb_R5444_;
  6360.  
  6361.     case FFELEX_typeEOS:
  6362.     case FFELEX_typeSEMICOLON:
  6363.       ffesta_confirmed ();
  6364.       if (!ffesta_is_inhibited ())
  6365.     {
  6366.       if (!ffestb_local_.equivalence.started)
  6367.         {
  6368.           ffestc_R544_start ();
  6369.           ffestb_local_.equivalence.started = TRUE;
  6370.         }
  6371.       ffestc_R544_item (ffestb_local_.equivalence.exprs);
  6372.       ffestc_R544_finish ();
  6373.     }
  6374.       ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
  6375.       return (ffelexHandler) ffesta_zero (t);
  6376.  
  6377.     default:
  6378.       break;
  6379.     }
  6380.  
  6381.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
  6382.   if (ffestb_local_.equivalence.started)
  6383.     ffestc_R544_finish ();
  6384.   ffestt_exprlist_kill (ffestb_local_.equivalence.exprs);
  6385.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6386. }
  6387.  
  6388. /* ffestb_R5444_ -- "EQUIVALENCE" OPEN_PAREN expr COMMA expr CLOSE_PAREN COMMA
  6389.  
  6390.    return ffestb_R5444_;  // to lexer
  6391.  
  6392.    Make sure the next token is OPEN_PAREN, or generate an error.  */
  6393.  
  6394. static ffelexHandler
  6395. ffestb_R5444_ (ffelexToken t)
  6396. {
  6397.   switch (ffelex_token_type (t))
  6398.     {
  6399.     case FFELEX_typeOPEN_PAREN:
  6400.       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  6401.                       FFEEXPR_contextEQUIVALENCE,
  6402.                       (ffeexprCallback) ffestb_R5441_);
  6403.  
  6404.     default:
  6405.       break;
  6406.     }
  6407.  
  6408.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EQUIVALENCE", t);
  6409.   if (ffestb_local_.equivalence.started)
  6410.     ffestc_R544_finish ();
  6411.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6412. }
  6413.  
  6414. /* ffestb_R834 -- Parse the CYCLE statement
  6415.  
  6416.    return ffestb_R834;    // to lexer
  6417.  
  6418.    Make sure the statement has a valid form for the CYCLE statement.  If
  6419.    it does, implement the statement.  */
  6420.  
  6421. ffelexHandler
  6422. ffestb_R834 (ffelexToken t)
  6423. {
  6424.   ffeTokenLength i;
  6425.   char *p;
  6426.  
  6427.   switch (ffelex_token_type (ffesta_tokens[0]))
  6428.     {
  6429.     case FFELEX_typeNAME:
  6430.       if (ffesta_first_kw != FFESTR_firstCYCLE)
  6431.     goto bad_0;        /* :::::::::::::::::::: */
  6432.       switch (ffelex_token_type (t))
  6433.     {
  6434.     case FFELEX_typeCOMMA:
  6435.     case FFELEX_typeCOLONCOLON:
  6436.       ffesta_confirmed ();    /* Error, but clearly intended. */
  6437.       goto bad_1;        /* :::::::::::::::::::: */
  6438.  
  6439.     default:
  6440.       goto bad_1;        /* :::::::::::::::::::: */
  6441.  
  6442.     case FFELEX_typeNAME:
  6443.       ffesta_confirmed ();
  6444.       ffesta_tokens[1] = ffelex_token_use (t);
  6445.       return (ffelexHandler) ffestb_R8341_;
  6446.  
  6447.     case FFELEX_typeEOS:
  6448.     case FFELEX_typeSEMICOLON:
  6449.       ffesta_confirmed ();
  6450.       ffesta_tokens[1] = NULL;
  6451.       return (ffelexHandler) ffestb_R8341_ (t);
  6452.     }
  6453.  
  6454.     case FFELEX_typeNAMES:
  6455.       if (ffesta_first_kw != FFESTR_firstCYCLE)
  6456.     goto bad_0;        /* :::::::::::::::::::: */
  6457.       switch (ffelex_token_type (t))
  6458.     {
  6459.     default:
  6460.       goto bad_1;        /* :::::::::::::::::::: */
  6461.  
  6462.     case FFELEX_typeEOS:
  6463.     case FFELEX_typeSEMICOLON:
  6464.       break;
  6465.     }
  6466.       ffesta_confirmed ();
  6467.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCYCLE);
  6468.       if (*p == '\0')
  6469.     {
  6470.       ffesta_tokens[1] = NULL;
  6471.     }
  6472.       else
  6473.     {
  6474.       if (!ffesrc_is_name_init (*p))
  6475.         goto bad_i;        /* :::::::::::::::::::: */
  6476.       ffesta_tokens[1]
  6477.         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  6478.     }
  6479.       return (ffelexHandler) ffestb_R8341_ (t);
  6480.  
  6481.     default:
  6482.       goto bad_0;        /* :::::::::::::::::::: */
  6483.     }
  6484.  
  6485. bad_0:                /* :::::::::::::::::::: */
  6486.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", ffesta_tokens[0]);
  6487.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6488.  
  6489. bad_1:                /* :::::::::::::::::::: */
  6490.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", t);
  6491.   return (ffelexHandler) ffelex_swallow_tokens (t,
  6492.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  6493.  
  6494. bad_i:                /* :::::::::::::::::::: */
  6495.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CYCLE", ffesta_tokens[0], i, t);
  6496.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6497. }
  6498.  
  6499. /* ffestb_R8341_ -- "CYCLE" [NAME]
  6500.  
  6501.    return ffestb_R8341_;  // to lexer
  6502.  
  6503.    Make sure the next token is an EOS or SEMICOLON.  */
  6504.  
  6505. static ffelexHandler
  6506. ffestb_R8341_ (ffelexToken t)
  6507. {
  6508.   switch (ffelex_token_type (t))
  6509.     {
  6510.     case FFELEX_typeEOS:
  6511.     case FFELEX_typeSEMICOLON:
  6512.       ffesta_confirmed ();
  6513.       if (!ffesta_is_inhibited ())
  6514.     ffestc_R834 (ffesta_tokens[1]);
  6515.       if (ffesta_tokens[1] != NULL)
  6516.     ffelex_token_kill (ffesta_tokens[1]);
  6517.       return (ffelexHandler) ffesta_zero (t);
  6518.  
  6519.     default:
  6520.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CYCLE", t);
  6521.       break;
  6522.     }
  6523.  
  6524.   if (ffesta_tokens[1] != NULL)
  6525.     ffelex_token_kill (ffesta_tokens[1]);
  6526.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6527. }
  6528.  
  6529. /* ffestb_R835 -- Parse the EXIT statement
  6530.  
  6531.    return ffestb_R835;    // to lexer
  6532.  
  6533.    Make sure the statement has a valid form for the EXIT statement.  If
  6534.    it does, implement the statement.  */
  6535.  
  6536. ffelexHandler
  6537. ffestb_R835 (ffelexToken t)
  6538. {
  6539.   ffeTokenLength i;
  6540.   char *p;
  6541.  
  6542.   switch (ffelex_token_type (ffesta_tokens[0]))
  6543.     {
  6544.     case FFELEX_typeNAME:
  6545.       if (ffesta_first_kw != FFESTR_firstEXIT)
  6546.     goto bad_0;        /* :::::::::::::::::::: */
  6547.       switch (ffelex_token_type (t))
  6548.     {
  6549.     case FFELEX_typeCOMMA:
  6550.     case FFELEX_typeCOLONCOLON:
  6551.       ffesta_confirmed ();    /* Error, but clearly intended. */
  6552.       goto bad_1;        /* :::::::::::::::::::: */
  6553.  
  6554.     default:
  6555.       goto bad_1;        /* :::::::::::::::::::: */
  6556.  
  6557.     case FFELEX_typeNAME:
  6558.       ffesta_confirmed ();
  6559.       ffesta_tokens[1] = ffelex_token_use (t);
  6560.       return (ffelexHandler) ffestb_R8351_;
  6561.  
  6562.     case FFELEX_typeEOS:
  6563.     case FFELEX_typeSEMICOLON:
  6564.       ffesta_confirmed ();
  6565.       ffesta_tokens[1] = NULL;
  6566.       return (ffelexHandler) ffestb_R8351_ (t);
  6567.     }
  6568.  
  6569.     case FFELEX_typeNAMES:
  6570.       if (ffesta_first_kw != FFESTR_firstEXIT)
  6571.     goto bad_0;        /* :::::::::::::::::::: */
  6572.       switch (ffelex_token_type (t))
  6573.     {
  6574.     default:
  6575.       goto bad_1;        /* :::::::::::::::::::: */
  6576.  
  6577.     case FFELEX_typeEOS:
  6578.     case FFELEX_typeSEMICOLON:
  6579.       break;
  6580.     }
  6581.       ffesta_confirmed ();
  6582.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlEXIT);
  6583.       if (*p == '\0')
  6584.     {
  6585.       ffesta_tokens[1] = NULL;
  6586.     }
  6587.       else
  6588.     {
  6589.       if (!ffesrc_is_name_init (*p))
  6590.         goto bad_i;        /* :::::::::::::::::::: */
  6591.       ffesta_tokens[1]
  6592.         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  6593.     }
  6594.       return (ffelexHandler) ffestb_R8351_ (t);
  6595.  
  6596.     default:
  6597.       goto bad_0;        /* :::::::::::::::::::: */
  6598.     }
  6599.  
  6600. bad_0:                /* :::::::::::::::::::: */
  6601.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", ffesta_tokens[0]);
  6602.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6603.  
  6604. bad_1:                /* :::::::::::::::::::: */
  6605.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", t);
  6606.   return (ffelexHandler) ffelex_swallow_tokens (t,
  6607.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  6608.  
  6609. bad_i:                /* :::::::::::::::::::: */
  6610.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "EXIT", ffesta_tokens[0], i, t);
  6611.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6612. }
  6613.  
  6614. /* ffestb_R8351_ -- "EXIT" [NAME]
  6615.  
  6616.    return ffestb_R8351_;  // to lexer
  6617.  
  6618.    Make sure the next token is an EOS or SEMICOLON.  */
  6619.  
  6620. static ffelexHandler
  6621. ffestb_R8351_ (ffelexToken t)
  6622. {
  6623.   switch (ffelex_token_type (t))
  6624.     {
  6625.     case FFELEX_typeEOS:
  6626.     case FFELEX_typeSEMICOLON:
  6627.       ffesta_confirmed ();
  6628.       if (!ffesta_is_inhibited ())
  6629.     ffestc_R835 (ffesta_tokens[1]);
  6630.       if (ffesta_tokens[1] != NULL)
  6631.     ffelex_token_kill (ffesta_tokens[1]);
  6632.       return (ffelexHandler) ffesta_zero (t);
  6633.  
  6634.     default:
  6635.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "EXIT", t);
  6636.       break;
  6637.     }
  6638.  
  6639.   if (ffesta_tokens[1] != NULL)
  6640.     ffelex_token_kill (ffesta_tokens[1]);
  6641.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6642. }
  6643.  
  6644. /* ffestb_R838 -- Parse the ASSIGN statement
  6645.  
  6646.    return ffestb_R838;    // to lexer
  6647.  
  6648.    Make sure the statement has a valid form for the ASSIGN statement.  If it
  6649.    does, implement the statement.  */
  6650.  
  6651. ffelexHandler
  6652. ffestb_R838 (ffelexToken t)
  6653. {
  6654.   char *p;
  6655.   ffeTokenLength i;
  6656.   ffelexHandler next;
  6657.   ffelexToken et;        /* First token in target. */
  6658.  
  6659.   switch (ffelex_token_type (ffesta_tokens[0]))
  6660.     {
  6661.     case FFELEX_typeNAME:
  6662.       if (ffesta_first_kw != FFESTR_firstASSIGN)
  6663.     goto bad_0;        /* :::::::::::::::::::: */
  6664.       switch (ffelex_token_type (t))
  6665.     {
  6666.     case FFELEX_typeEOS:
  6667.     case FFELEX_typeSEMICOLON:
  6668.     case FFELEX_typeCOMMA:
  6669.     case FFELEX_typeCOLONCOLON:
  6670.       ffesta_confirmed ();    /* Error, but clearly intended. */
  6671.       goto bad_1;        /* :::::::::::::::::::: */
  6672.  
  6673.     default:
  6674.       goto bad_1;        /* :::::::::::::::::::: */
  6675.  
  6676.     case FFELEX_typeNUMBER:
  6677.       break;
  6678.     }
  6679.       ffesta_tokens[1] = ffelex_token_use (t);
  6680.       ffesta_confirmed ();
  6681.       return (ffelexHandler) ffestb_R8381_;
  6682.  
  6683.     case FFELEX_typeNAMES:
  6684.       if (ffesta_first_kw != FFESTR_firstASSIGN)
  6685.     goto bad_0;        /* :::::::::::::::::::: */
  6686.  
  6687.       switch (ffelex_token_type (t))
  6688.     {
  6689.     case FFELEX_typeEOS:
  6690.     case FFELEX_typeSEMICOLON:
  6691.       ffesta_confirmed ();
  6692.       /* Fall through. */
  6693.     case FFELEX_typePERCENT:
  6694.     case FFELEX_typeOPEN_PAREN:
  6695.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlASSIGN);
  6696.       if (!isdigit (*p))
  6697.         goto bad_i;        /* :::::::::::::::::::: */
  6698.       ffesta_tokens[1]
  6699.         = ffelex_token_number_from_names (ffesta_tokens[0], i);
  6700.       p += ffelex_token_length (ffesta_tokens[1]);    /* Skip to "TO". */
  6701.       i += ffelex_token_length (ffesta_tokens[1]);
  6702.       if (!ffesrc_char_match_init (*p, 'T', 't')    /* "TO". */
  6703.           || (++i, !ffesrc_char_match_noninit (*++p, 'O', 'o')))
  6704.         {
  6705.         bad_i_1:        /* :::::::::::::::::::: */
  6706.           ffelex_token_kill (ffesta_tokens[1]);
  6707.           goto bad_i;    /* :::::::::::::::::::: */
  6708.         }
  6709.       ++p, ++i;
  6710.       if (!ffesrc_is_name_init (*p))
  6711.         goto bad_i_1;    /* :::::::::::::::::::: */
  6712.       et = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  6713.       next = (ffelexHandler)
  6714.         (*((ffelexHandler)
  6715.            ffeexpr_lhs (ffesta_output_pool,
  6716.                 FFEEXPR_contextASSIGN,
  6717.                 (ffeexprCallback)
  6718.                 ffestb_R8383_)))
  6719.         (et);
  6720.       ffelex_token_kill (et);
  6721.       return (ffelexHandler) (*next) (t);
  6722.  
  6723.     case FFELEX_typeCOMMA:
  6724.     case FFELEX_typeCOLONCOLON:
  6725.       ffesta_confirmed ();    /* Error, but clearly intended. */
  6726.       goto bad_1;        /* :::::::::::::::::::: */
  6727.  
  6728.     default:
  6729.       goto bad_1;        /* :::::::::::::::::::: */
  6730.     }
  6731.  
  6732.     default:
  6733.       goto bad_0;        /* :::::::::::::::::::: */
  6734.     }
  6735.  
  6736. bad_0:                /* :::::::::::::::::::: */
  6737.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", ffesta_tokens[0]);
  6738.   return (ffelexHandler) ffelex_swallow_tokens (t,
  6739.                         (ffelexHandler) ffesta_zero);    /* Invalid first token. */
  6740.  
  6741. bad_1:                /* :::::::::::::::::::: */
  6742.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
  6743.   return (ffelexHandler) ffelex_swallow_tokens (t,
  6744.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  6745.  
  6746. bad_i:                /* :::::::::::::::::::: */
  6747.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "ASSIGN", ffesta_tokens[0], i, t);
  6748.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6749. }
  6750.  
  6751. /* ffestb_R8381_ -- "ASSIGN" NUMBER
  6752.  
  6753.    return ffestb_R8381_;  // to lexer
  6754.  
  6755.    Make sure the next token is "TO".  */
  6756.  
  6757. static ffelexHandler
  6758. ffestb_R8381_ (ffelexToken t)
  6759. {
  6760.   if ((ffelex_token_type (t) == FFELEX_typeNAME)
  6761.   && (ffesrc_strcmp_2c (ffe_case_match (), ffelex_token_text (t), "TO", "to",
  6762.             "To") == 0))
  6763.     {
  6764.       return (ffelexHandler) ffestb_R8382_;
  6765.     }
  6766.  
  6767.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
  6768.   if (ffelex_token_type (t) == FFELEX_typeNAME)
  6769.     return (ffelexHandler) ffestb_R8382_ (t);    /* Maybe user forgot "TO". */
  6770.  
  6771.   ffelex_token_kill (ffesta_tokens[1]);
  6772.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6773. }
  6774.  
  6775. /* ffestb_R8382_ -- "ASSIGN" NUMBER ("TO")
  6776.  
  6777.    return ffestb_R8382_;  // to lexer
  6778.  
  6779.    Make sure the next token is a name, then pass it along to the expression
  6780.    evaluator as an LHS expression.  The callback function is _3_.  */
  6781.  
  6782. static ffelexHandler
  6783. ffestb_R8382_ (ffelexToken t)
  6784. {
  6785.   if (ffelex_token_type (t) == FFELEX_typeNAME)
  6786.     {
  6787.       return (ffelexHandler)
  6788.       (*((ffelexHandler)
  6789.      ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextASSIGN,
  6790.               (ffeexprCallback) ffestb_R8383_)))
  6791.       (t);
  6792.     }
  6793.  
  6794.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
  6795.   ffelex_token_kill (ffesta_tokens[1]);
  6796.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6797. }
  6798.  
  6799. /* ffestb_R8383_ -- "ASSIGN" NUMBER ("TO") expression
  6800.  
  6801.    (ffestb_R8383_)  // to expression handler
  6802.  
  6803.    Make sure the next token is an EOS or SEMICOLON.  */
  6804.  
  6805. static ffelexHandler
  6806. ffestb_R8383_ (ffelexToken ft, ffebld expr, ffelexToken t)
  6807. {
  6808.   switch (ffelex_token_type (t))
  6809.     {
  6810.     case FFELEX_typeEOS:
  6811.     case FFELEX_typeSEMICOLON:
  6812.       ffesta_confirmed ();
  6813.       if (expr == NULL)
  6814.     break;
  6815.       if (!ffesta_is_inhibited ())
  6816.     ffestc_R838 (ffesta_tokens[1], expr, ft);
  6817.       ffelex_token_kill (ffesta_tokens[1]);
  6818.       return (ffelexHandler) ffesta_zero (t);
  6819.  
  6820.     default:
  6821.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ASSIGN", t);
  6822.       break;
  6823.     }
  6824.  
  6825.   ffelex_token_kill (ffesta_tokens[1]);
  6826.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6827. }
  6828.  
  6829. /* ffestb_R840 -- Parse an arithmetic-IF statement
  6830.  
  6831.    return ffestb_R840;    // to lexer
  6832.  
  6833.    Make sure the statement has a valid form for an arithmetic-IF statement.
  6834.    If it does, implement the statement.     */
  6835.  
  6836. ffelexHandler
  6837. ffestb_R840 (ffelexToken t)
  6838. {
  6839.   switch (ffelex_token_type (ffesta_tokens[0]))
  6840.     {
  6841.     case FFELEX_typeNAME:
  6842.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlIF)
  6843.     goto bad_0;        /* :::::::::::::::::::: */
  6844.       if (ffesta_first_kw != FFESTR_firstIF)
  6845.     goto bad_0;        /* :::::::::::::::::::: */
  6846.       break;
  6847.  
  6848.     case FFELEX_typeNAMES:
  6849.       if (ffesta_first_kw != FFESTR_firstIF)
  6850.     goto bad_0;        /* :::::::::::::::::::: */
  6851.       break;
  6852.  
  6853.     default:
  6854.       goto bad_0;        /* :::::::::::::::::::: */
  6855.     }
  6856.  
  6857.   switch (ffelex_token_type (t))
  6858.     {
  6859.     case FFELEX_typeOPEN_PAREN:
  6860.       break;
  6861.  
  6862.     default:
  6863.       goto bad_1;        /* :::::::::::::::::::: */
  6864.     }
  6865.  
  6866.   return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextARITHIF,
  6867.                       (ffeexprCallback) ffestb_R8401_);
  6868.  
  6869. bad_0:                /* :::::::::::::::::::: */
  6870.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", ffesta_tokens[0]);
  6871.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6872.  
  6873. bad_1:                /* :::::::::::::::::::: */
  6874.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
  6875.   return (ffelexHandler) ffelex_swallow_tokens (t,
  6876.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  6877. }
  6878.  
  6879. /* ffestb_R8401_ -- "IF" OPEN_PAREN expr
  6880.  
  6881.    (ffestb_R8401_)  // to expression handler
  6882.  
  6883.    Make sure the next token is CLOSE_PAREN.  */
  6884.  
  6885. static ffelexHandler
  6886. ffestb_R8401_ (ffelexToken ft, ffebld expr, ffelexToken t)
  6887. {
  6888.   ffestb_local_.if_stmt.expr = expr;
  6889.  
  6890.   switch (ffelex_token_type (t))
  6891.     {
  6892.     case FFELEX_typeCLOSE_PAREN:
  6893.       if (expr == NULL)
  6894.     break;
  6895.       ffesta_tokens[1] = ffelex_token_use (ft);
  6896.       ffelex_set_names (TRUE);    /* In case it's a logical IF instead. */
  6897.       return (ffelexHandler) ffestb_R8402_;
  6898.  
  6899.     default:
  6900.       break;
  6901.     }
  6902.  
  6903.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
  6904.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6905. }
  6906.  
  6907. /* ffestb_R8402_ -- "IF" OPEN_PAREN expr CLOSE_PAREN
  6908.  
  6909.    return ffestb_R8402_;  // to lexer
  6910.  
  6911.    Make sure the next token is NUMBER.    */
  6912.  
  6913. static ffelexHandler
  6914. ffestb_R8402_ (ffelexToken t)
  6915. {
  6916.   ffelex_set_names (FALSE);
  6917.  
  6918.   switch (ffelex_token_type (t))
  6919.     {
  6920.     case FFELEX_typeNUMBER:
  6921.       ffesta_confirmed ();
  6922.       ffesta_tokens[2] = ffelex_token_use (t);
  6923.       return (ffelexHandler) ffestb_R8403_;
  6924.  
  6925.     default:
  6926.       break;
  6927.     }
  6928.  
  6929.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
  6930.   ffelex_token_kill (ffesta_tokens[1]);
  6931.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6932. }
  6933.  
  6934. /* ffestb_R8403_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER
  6935.  
  6936.    return ffestb_R8403_;  // to lexer
  6937.  
  6938.    Make sure the next token is COMMA.  */
  6939.  
  6940. static ffelexHandler
  6941. ffestb_R8403_ (ffelexToken t)
  6942. {
  6943.   switch (ffelex_token_type (t))
  6944.     {
  6945.     case FFELEX_typeCOMMA:
  6946.       return (ffelexHandler) ffestb_R8404_;
  6947.  
  6948.     default:
  6949.       break;
  6950.     }
  6951.  
  6952.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
  6953.   ffelex_token_kill (ffesta_tokens[1]);
  6954.   ffelex_token_kill (ffesta_tokens[2]);
  6955.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6956. }
  6957.  
  6958. /* ffestb_R8404_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA
  6959.  
  6960.    return ffestb_R8404_;  // to lexer
  6961.  
  6962.    Make sure the next token is NUMBER.    */
  6963.  
  6964. static ffelexHandler
  6965. ffestb_R8404_ (ffelexToken t)
  6966. {
  6967.   switch (ffelex_token_type (t))
  6968.     {
  6969.     case FFELEX_typeNUMBER:
  6970.       ffesta_tokens[3] = ffelex_token_use (t);
  6971.       return (ffelexHandler) ffestb_R8405_;
  6972.  
  6973.     default:
  6974.       break;
  6975.     }
  6976.  
  6977.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
  6978.   ffelex_token_kill (ffesta_tokens[1]);
  6979.   ffelex_token_kill (ffesta_tokens[2]);
  6980.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  6981. }
  6982.  
  6983. /* ffestb_R8405_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER
  6984.  
  6985.    return ffestb_R8405_;  // to lexer
  6986.  
  6987.    Make sure the next token is COMMA.  */
  6988.  
  6989. static ffelexHandler
  6990. ffestb_R8405_ (ffelexToken t)
  6991. {
  6992.   switch (ffelex_token_type (t))
  6993.     {
  6994.     case FFELEX_typeCOMMA:
  6995.       return (ffelexHandler) ffestb_R8406_;
  6996.  
  6997.     default:
  6998.       break;
  6999.     }
  7000.  
  7001.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
  7002.   ffelex_token_kill (ffesta_tokens[1]);
  7003.   ffelex_token_kill (ffesta_tokens[2]);
  7004.   ffelex_token_kill (ffesta_tokens[3]);
  7005.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7006. }
  7007.  
  7008. /* ffestb_R8406_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER COMMA
  7009.  
  7010.    return ffestb_R8406_;  // to lexer
  7011.  
  7012.    Make sure the next token is NUMBER.    */
  7013.  
  7014. static ffelexHandler
  7015. ffestb_R8406_ (ffelexToken t)
  7016. {
  7017.   switch (ffelex_token_type (t))
  7018.     {
  7019.     case FFELEX_typeNUMBER:
  7020.       ffesta_tokens[4] = ffelex_token_use (t);
  7021.       return (ffelexHandler) ffestb_R8407_;
  7022.  
  7023.     default:
  7024.       break;
  7025.     }
  7026.  
  7027.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
  7028.   ffelex_token_kill (ffesta_tokens[1]);
  7029.   ffelex_token_kill (ffesta_tokens[2]);
  7030.   ffelex_token_kill (ffesta_tokens[3]);
  7031.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7032. }
  7033.  
  7034. /* ffestb_R8407_ -- "IF" OPEN_PAREN expr CLOSE_PAREN NUMBER COMMA NUMBER COMMA
  7035.             NUMBER
  7036.  
  7037.    return ffestb_R8407_;  // to lexer
  7038.  
  7039.    Make sure the next token is EOS or SEMICOLON.  */
  7040.  
  7041. static ffelexHandler
  7042. ffestb_R8407_ (ffelexToken t)
  7043. {
  7044.   switch (ffelex_token_type (t))
  7045.     {
  7046.     case FFELEX_typeEOS:
  7047.     case FFELEX_typeSEMICOLON:
  7048.       if (!ffesta_is_inhibited ())
  7049.     ffestc_R840 (ffestb_local_.if_stmt.expr, ffesta_tokens[1],
  7050.              ffesta_tokens[2], ffesta_tokens[3], ffesta_tokens[4]);
  7051.       ffelex_token_kill (ffesta_tokens[1]);
  7052.       ffelex_token_kill (ffesta_tokens[2]);
  7053.       ffelex_token_kill (ffesta_tokens[3]);
  7054.       ffelex_token_kill (ffesta_tokens[4]);
  7055.       return (ffelexHandler) ffesta_zero (t);
  7056.  
  7057.     default:
  7058.       break;
  7059.     }
  7060.  
  7061.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "arithmetic-IF", t);
  7062.   ffelex_token_kill (ffesta_tokens[1]);
  7063.   ffelex_token_kill (ffesta_tokens[2]);
  7064.   ffelex_token_kill (ffesta_tokens[3]);
  7065.   ffelex_token_kill (ffesta_tokens[4]);
  7066.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7067. }
  7068.  
  7069. /* ffestb_R841 -- Parse the CONTINUE statement
  7070.  
  7071.    return ffestb_R841;    // to lexer
  7072.  
  7073.    Make sure the statement has a valid form for the CONTINUE statement.     If
  7074.    it does, implement the statement.  */
  7075.  
  7076. ffelexHandler
  7077. ffestb_R841 (ffelexToken t)
  7078. {
  7079.   char *p;
  7080.   ffeTokenLength i;
  7081.  
  7082.   switch (ffelex_token_type (ffesta_tokens[0]))
  7083.     {
  7084.     case FFELEX_typeNAME:
  7085.       if (ffesta_first_kw != FFESTR_firstCONTINUE)
  7086.     goto bad_0;        /* :::::::::::::::::::: */
  7087.       break;
  7088.  
  7089.     case FFELEX_typeNAMES:
  7090.       if (ffesta_first_kw != FFESTR_firstCONTINUE)
  7091.     goto bad_0;        /* :::::::::::::::::::: */
  7092.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCONTINUE)
  7093.     {
  7094.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCONTINUE);
  7095.       goto bad_i;        /* :::::::::::::::::::: */
  7096.     }
  7097.       break;
  7098.  
  7099.     default:
  7100.       goto bad_0;        /* :::::::::::::::::::: */
  7101.     }
  7102.  
  7103.   switch (ffelex_token_type (t))
  7104.     {
  7105.     case FFELEX_typeEOS:
  7106.     case FFELEX_typeSEMICOLON:
  7107.       ffesta_confirmed ();
  7108.       if (!ffesta_is_inhibited ())
  7109.     ffestc_R841 ();
  7110.       return (ffelexHandler) ffesta_zero (t);
  7111.  
  7112.     case FFELEX_typeCOMMA:
  7113.     case FFELEX_typeCOLONCOLON:
  7114.       ffesta_confirmed ();    /* Error, but clearly intended. */
  7115.       goto bad_1;        /* :::::::::::::::::::: */
  7116.  
  7117.     default:
  7118.       goto bad_1;        /* :::::::::::::::::::: */
  7119.     }
  7120.  
  7121. bad_0:                /* :::::::::::::::::::: */
  7122.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTINUE", ffesta_tokens[0]);
  7123.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7124.                         (ffelexHandler) ffesta_zero);    /* Invalid first token. */
  7125.  
  7126. bad_1:                /* :::::::::::::::::::: */
  7127.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTINUE", t);
  7128.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7129.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  7130.  
  7131. bad_i:                /* :::::::::::::::::::: */
  7132.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CONTINUE", ffesta_tokens[0], i, t);
  7133.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7134. }
  7135.  
  7136. /* ffestb_R1102 -- Parse the PROGRAM statement
  7137.  
  7138.    return ffestb_R1102;     // to lexer
  7139.  
  7140.    Make sure the statement has a valid form for the PROGRAM statement.    If it
  7141.    does, implement the statement.  */
  7142.  
  7143. ffelexHandler
  7144. ffestb_R1102 (ffelexToken t)
  7145. {
  7146.   ffeTokenLength i;
  7147.   char *p;
  7148.  
  7149.   switch (ffelex_token_type (ffesta_tokens[0]))
  7150.     {
  7151.     case FFELEX_typeNAME:
  7152.       if (ffesta_first_kw != FFESTR_firstPROGRAM)
  7153.     goto bad_0;        /* :::::::::::::::::::: */
  7154.       switch (ffelex_token_type (t))
  7155.     {
  7156.     case FFELEX_typeEOS:
  7157.     case FFELEX_typeSEMICOLON:
  7158.     case FFELEX_typeCOMMA:
  7159.     case FFELEX_typeCOLONCOLON:
  7160.       ffesta_confirmed ();    /* Error, but clearly intended. */
  7161.       goto bad_1;        /* :::::::::::::::::::: */
  7162.  
  7163.     default:
  7164.       goto bad_1;        /* :::::::::::::::::::: */
  7165.  
  7166.     case FFELEX_typeNAME:
  7167.       break;
  7168.     }
  7169.  
  7170.       ffesta_confirmed ();
  7171.       ffesta_tokens[1] = ffelex_token_use (t);
  7172.       return (ffelexHandler) ffestb_R11021_;
  7173.  
  7174.     case FFELEX_typeNAMES:
  7175.       if (ffesta_first_kw != FFESTR_firstPROGRAM)
  7176.     goto bad_0;        /* :::::::::::::::::::: */
  7177.       switch (ffelex_token_type (t))
  7178.     {
  7179.     case FFELEX_typeCOMMA:
  7180.     case FFELEX_typeCOLONCOLON:
  7181.       ffesta_confirmed ();    /* Error, but clearly intended. */
  7182.       goto bad_1;        /* :::::::::::::::::::: */
  7183.  
  7184.     default:
  7185.       goto bad_1;        /* :::::::::::::::::::: */
  7186.  
  7187.     case FFELEX_typeEOS:
  7188.     case FFELEX_typeSEMICOLON:
  7189.       break;
  7190.     }
  7191.       ffesta_confirmed ();
  7192.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlPROGRAM);
  7193.       if (!ffesrc_is_name_init (*p))
  7194.     goto bad_i;        /* :::::::::::::::::::: */
  7195.       ffesta_tokens[1]
  7196.     = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  7197.       return (ffelexHandler) ffestb_R11021_ (t);
  7198.  
  7199.     default:
  7200.       goto bad_0;        /* :::::::::::::::::::: */
  7201.     }
  7202.  
  7203. bad_0:                /* :::::::::::::::::::: */
  7204.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", ffesta_tokens[0]);
  7205.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7206.  
  7207. bad_1:                /* :::::::::::::::::::: */
  7208.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", t);
  7209.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7210.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  7211.  
  7212. bad_i:                /* :::::::::::::::::::: */
  7213.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "PROGRAM", ffesta_tokens[0], i, t);
  7214.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7215. }
  7216.  
  7217. /* ffestb_R11021_ -- "PROGRAM" NAME
  7218.  
  7219.    return ffestb_R11021_;  // to lexer
  7220.  
  7221.    Make sure the next token is an EOS or SEMICOLON.  */
  7222.  
  7223. static ffelexHandler
  7224. ffestb_R11021_ (ffelexToken t)
  7225. {
  7226.   switch (ffelex_token_type (t))
  7227.     {
  7228.     case FFELEX_typeEOS:
  7229.     case FFELEX_typeSEMICOLON:
  7230.       ffesta_confirmed ();
  7231.       if (!ffesta_is_inhibited ())
  7232.     ffestc_R1102 (ffesta_tokens[1]);
  7233.       ffelex_token_kill (ffesta_tokens[1]);
  7234.       return (ffelexHandler) ffesta_zero (t);
  7235.  
  7236.     default:
  7237.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PROGRAM", t);
  7238.       break;
  7239.     }
  7240.  
  7241.   ffelex_token_kill (ffesta_tokens[1]);
  7242.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7243. }
  7244.  
  7245. /* ffestb_block -- Parse the BLOCK DATA statement
  7246.  
  7247.    return ffestb_block;     // to lexer
  7248.  
  7249.    Make sure the statement has a valid form for the BLOCK DATA statement.  If
  7250.    it does, implement the statement.  */
  7251.  
  7252. ffelexHandler
  7253. ffestb_block (ffelexToken t)
  7254. {
  7255.   switch (ffelex_token_type (ffesta_tokens[0]))
  7256.     {
  7257.     case FFELEX_typeNAME:
  7258.       if (ffesta_first_kw != FFESTR_firstBLOCK)
  7259.     goto bad_0;        /* :::::::::::::::::::: */
  7260.       switch (ffelex_token_type (t))
  7261.     {
  7262.     default:
  7263.       goto bad_1;        /* :::::::::::::::::::: */
  7264.  
  7265.     case FFELEX_typeNAME:
  7266.       if (ffesta_second_kw != FFESTR_secondDATA)
  7267.         goto bad_1;        /* :::::::::::::::::::: */
  7268.       break;
  7269.     }
  7270.  
  7271.       ffesta_confirmed ();
  7272.       return (ffelexHandler) ffestb_R1111_1_;
  7273.  
  7274.     default:
  7275.       goto bad_0;        /* :::::::::::::::::::: */
  7276.     }
  7277.  
  7278. bad_0:                /* :::::::::::::::::::: */
  7279.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0]);
  7280.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7281.  
  7282. bad_1:                /* :::::::::::::::::::: */
  7283.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
  7284.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7285.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  7286. }
  7287.  
  7288. /* ffestb_blockdata -- Parse the BLOCKDATA statement
  7289.  
  7290.    return ffestb_blockdata;  // to lexer
  7291.  
  7292.    Make sure the statement has a valid form for the BLOCKDATA statement.  If
  7293.    it does, implement the statement.  */
  7294.  
  7295. ffelexHandler
  7296. ffestb_blockdata (ffelexToken t)
  7297. {
  7298.   ffeTokenLength i;
  7299.   char *p;
  7300.  
  7301.   switch (ffelex_token_type (ffesta_tokens[0]))
  7302.     {
  7303.     case FFELEX_typeNAME:
  7304.       if (ffesta_first_kw != FFESTR_firstBLOCKDATA)
  7305.     goto bad_0;        /* :::::::::::::::::::: */
  7306.       switch (ffelex_token_type (t))
  7307.     {
  7308.     case FFELEX_typeCOMMA:
  7309.     case FFELEX_typeCOLONCOLON:
  7310.       ffesta_confirmed ();    /* Error, but clearly intended. */
  7311.       goto bad_1;        /* :::::::::::::::::::: */
  7312.  
  7313.     default:
  7314.       goto bad_1;        /* :::::::::::::::::::: */
  7315.  
  7316.     case FFELEX_typeNAME:
  7317.       ffesta_confirmed ();
  7318.       ffesta_tokens[1] = ffelex_token_use (t);
  7319.       return (ffelexHandler) ffestb_R1111_2_;
  7320.  
  7321.     case FFELEX_typeEOS:
  7322.     case FFELEX_typeSEMICOLON:
  7323.       ffesta_confirmed ();
  7324.       ffesta_tokens[1] = NULL;
  7325.       return (ffelexHandler) ffestb_R1111_2_ (t);
  7326.     }
  7327.  
  7328.     case FFELEX_typeNAMES:
  7329.       if (ffesta_first_kw != FFESTR_firstBLOCKDATA)
  7330.     goto bad_0;        /* :::::::::::::::::::: */
  7331.       switch (ffelex_token_type (t))
  7332.     {
  7333.     default:
  7334.       goto bad_1;        /* :::::::::::::::::::: */
  7335.  
  7336.     case FFELEX_typeEOS:
  7337.     case FFELEX_typeSEMICOLON:
  7338.       break;
  7339.     }
  7340.       ffesta_confirmed ();
  7341.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlBLOCKDATA);
  7342.       if (*p == '\0')
  7343.     {
  7344.       ffesta_tokens[1] = NULL;
  7345.     }
  7346.       else
  7347.     {
  7348.       if (!ffesrc_is_name_init (*p))
  7349.         goto bad_i;        /* :::::::::::::::::::: */
  7350.       ffesta_tokens[1]
  7351.         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  7352.     }
  7353.       return (ffelexHandler) ffestb_R1111_2_ (t);
  7354.  
  7355.     default:
  7356.       goto bad_0;        /* :::::::::::::::::::: */
  7357.     }
  7358.  
  7359. bad_0:                /* :::::::::::::::::::: */
  7360.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0]);
  7361.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7362.  
  7363. bad_1:                /* :::::::::::::::::::: */
  7364.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
  7365.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7366.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  7367.  
  7368. bad_i:                /* :::::::::::::::::::: */
  7369.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", ffesta_tokens[0], i, t);
  7370.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7371. }
  7372.  
  7373. /* ffestb_R1111_1_ -- "BLOCK" "DATA"
  7374.  
  7375.    return ffestb_R1111_1_;  // to lexer
  7376.  
  7377.    Make sure the next token is a NAME, EOS, or SEMICOLON token.     */
  7378.  
  7379. static ffelexHandler
  7380. ffestb_R1111_1_ (ffelexToken t)
  7381. {
  7382.   switch (ffelex_token_type (t))
  7383.     {
  7384.     case FFELEX_typeNAME:
  7385.       ffesta_tokens[1] = ffelex_token_use (t);
  7386.       return (ffelexHandler) ffestb_R1111_2_;
  7387.  
  7388.     case FFELEX_typeEOS:
  7389.     case FFELEX_typeSEMICOLON:
  7390.       ffesta_tokens[1] = NULL;
  7391.       return (ffelexHandler) ffestb_R1111_2_ (t);
  7392.  
  7393.     default:
  7394.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
  7395.       break;
  7396.     }
  7397.  
  7398.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7399. }
  7400.  
  7401. /* ffestb_R1111_2_ -- "BLOCK/DATA" NAME
  7402.  
  7403.    return ffestb_R1111_2_;  // to lexer
  7404.  
  7405.    Make sure the next token is an EOS or SEMICOLON.  */
  7406.  
  7407. static ffelexHandler
  7408. ffestb_R1111_2_ (ffelexToken t)
  7409. {
  7410.   switch (ffelex_token_type (t))
  7411.     {
  7412.     case FFELEX_typeEOS:
  7413.     case FFELEX_typeSEMICOLON:
  7414.       ffesta_confirmed ();
  7415.       if (!ffesta_is_inhibited ())
  7416.     ffestc_R1111 (ffesta_tokens[1]);
  7417.       if (ffesta_tokens[1] != NULL)
  7418.     ffelex_token_kill (ffesta_tokens[1]);
  7419.       return (ffelexHandler) ffesta_zero (t);
  7420.  
  7421.     default:
  7422.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "BLOCK DATA", t);
  7423.       break;
  7424.     }
  7425.  
  7426.   if (ffesta_tokens[1] != NULL)
  7427.     ffelex_token_kill (ffesta_tokens[1]);
  7428.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7429. }
  7430.  
  7431. /* ffestb_R1212 -- Parse the CALL statement
  7432.  
  7433.    return ffestb_R1212;     // to lexer
  7434.  
  7435.    Make sure the statement has a valid form for the CALL statement.  If it
  7436.    does, implement the statement.  */
  7437.  
  7438. ffelexHandler
  7439. ffestb_R1212 (ffelexToken t)
  7440. {
  7441.   ffeTokenLength i;
  7442.   char *p;
  7443.   ffelexHandler next;
  7444.   ffelexToken nt;
  7445.  
  7446.   switch (ffelex_token_type (ffesta_tokens[0]))
  7447.     {
  7448.     case FFELEX_typeNAME:
  7449.       if (ffesta_first_kw != FFESTR_firstCALL)
  7450.     goto bad_0;        /* :::::::::::::::::::: */
  7451.       switch (ffelex_token_type (t))
  7452.     {
  7453.     case FFELEX_typeEOS:
  7454.     case FFELEX_typeSEMICOLON:
  7455.     case FFELEX_typeCOMMA:
  7456.     case FFELEX_typeCOLONCOLON:
  7457.       ffesta_confirmed ();    /* Error, but clearly intended. */
  7458.       goto bad_1;        /* :::::::::::::::::::: */
  7459.  
  7460.     default:
  7461.       goto bad_1;        /* :::::::::::::::::::: */
  7462.  
  7463.     case FFELEX_typeNAME:
  7464.       break;
  7465.     }
  7466.       ffesta_confirmed ();
  7467.       return (ffelexHandler)
  7468.     (*((ffelexHandler)
  7469.        ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextSUBROUTINEREF,
  7470.             (ffeexprCallback) ffestb_R12121_)))
  7471.     (t);
  7472.  
  7473.     case FFELEX_typeNAMES:
  7474.       if (ffesta_first_kw != FFESTR_firstCALL)
  7475.     goto bad_0;        /* :::::::::::::::::::: */
  7476.       switch (ffelex_token_type (t))
  7477.     {
  7478.     case FFELEX_typeCOLONCOLON:
  7479.     case FFELEX_typeCOMMA:
  7480.       ffesta_confirmed ();    /* Error, but clearly intended. */
  7481.       goto bad_1;        /* :::::::::::::::::::: */
  7482.  
  7483.     default:
  7484.       goto bad_1;        /* :::::::::::::::::::: */
  7485.  
  7486.     case FFELEX_typeOPEN_PAREN:
  7487.       break;
  7488.  
  7489.     case FFELEX_typeEOS:
  7490.     case FFELEX_typeSEMICOLON:
  7491.       ffesta_confirmed ();
  7492.       break;
  7493.     }
  7494.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCALL);
  7495.       if (!ffesrc_is_name_init (*p))
  7496.     goto bad_i;        /* :::::::::::::::::::: */
  7497.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  7498.       next = (ffelexHandler)
  7499.     (*((ffelexHandler)
  7500.        ffeexpr_lhs (ffesta_output_pool, FFEEXPR_contextSUBROUTINEREF,
  7501.             (ffeexprCallback) ffestb_R12121_)))
  7502.     (nt);
  7503.       ffelex_token_kill (nt);
  7504.       return (ffelexHandler) (*next) (t);
  7505.  
  7506.     default:
  7507.       goto bad_0;        /* :::::::::::::::::::: */
  7508.     }
  7509.  
  7510. bad_0:                /* :::::::::::::::::::: */
  7511.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", ffesta_tokens[0]);
  7512.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7513.  
  7514. bad_1:                /* :::::::::::::::::::: */
  7515.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", t);
  7516.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7517.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  7518.  
  7519. bad_i:                /* :::::::::::::::::::: */
  7520.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CALL", ffesta_tokens[0], i, t);
  7521.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7522. }
  7523.  
  7524. /* ffestb_R12121_ -- "CALL" expr
  7525.  
  7526.    (ffestb_R12121_)  // to expression handler
  7527.  
  7528.    Make sure the statement has a valid form for the CALL statement.  If it
  7529.    does, implement the statement.  */
  7530.  
  7531. static ffelexHandler
  7532. ffestb_R12121_ (ffelexToken ft, ffebld expr, ffelexToken t)
  7533. {
  7534.   switch (ffelex_token_type (t))
  7535.     {
  7536.     case FFELEX_typeEOS:
  7537.     case FFELEX_typeSEMICOLON:
  7538.       ffesta_confirmed ();
  7539.       if (expr == NULL)
  7540.     break;
  7541.       if (!ffesta_is_inhibited ())
  7542.     ffestc_R1212 (expr, ft);
  7543.       return (ffelexHandler) ffesta_zero (t);
  7544.  
  7545.     default:
  7546.       break;
  7547.     }
  7548.  
  7549.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CALL", t);
  7550.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7551. }
  7552.  
  7553. /* ffestb_R1227 -- Parse the RETURN statement
  7554.  
  7555.    return ffestb_R1227;     // to lexer
  7556.  
  7557.    Make sure the statement has a valid form for the RETURN statement.  If it
  7558.    does, implement the statement.  */
  7559.  
  7560. ffelexHandler
  7561. ffestb_R1227 (ffelexToken t)
  7562. {
  7563.   ffelexHandler next;
  7564.  
  7565.   switch (ffelex_token_type (ffesta_tokens[0]))
  7566.     {
  7567.     case FFELEX_typeNAME:
  7568.       if (ffesta_first_kw != FFESTR_firstRETURN)
  7569.     goto bad_0;        /* :::::::::::::::::::: */
  7570.       switch (ffelex_token_type (t))
  7571.     {
  7572.     case FFELEX_typeCOMMA:
  7573.     case FFELEX_typeCOLONCOLON:
  7574.       ffesta_confirmed ();    /* Error, but clearly intended. */
  7575.       goto bad_1;        /* :::::::::::::::::::: */
  7576.  
  7577.     case FFELEX_typeEQUALS:
  7578.     case FFELEX_typePOINTS:
  7579.     case FFELEX_typeCOLON:
  7580.       goto bad_1;        /* :::::::::::::::::::: */
  7581.  
  7582.     case FFELEX_typeEOS:
  7583.     case FFELEX_typeSEMICOLON:
  7584.     case FFELEX_typeNAME:
  7585.     case FFELEX_typeNUMBER:
  7586.       ffesta_confirmed ();
  7587.       break;
  7588.  
  7589.     default:
  7590.       break;
  7591.     }
  7592.  
  7593.       return (ffelexHandler) (*((ffelexHandler)
  7594.              ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextRETURN,
  7595.                   (ffeexprCallback) ffestb_R12271_)))
  7596.     (t);
  7597.  
  7598.     case FFELEX_typeNAMES:
  7599.       if (ffesta_first_kw != FFESTR_firstRETURN)
  7600.     goto bad_0;        /* :::::::::::::::::::: */
  7601.       switch (ffelex_token_type (t))
  7602.     {
  7603.     case FFELEX_typeCOMMA:
  7604.     case FFELEX_typeCOLONCOLON:
  7605.       ffesta_confirmed ();    /* Error, but clearly intended. */
  7606.       goto bad_1;        /* :::::::::::::::::::: */
  7607.  
  7608.     case FFELEX_typeEQUALS:
  7609.     case FFELEX_typePOINTS:
  7610.     case FFELEX_typeCOLON:
  7611.       goto bad_1;        /* :::::::::::::::::::: */
  7612.  
  7613.     case FFELEX_typeEOS:
  7614.     case FFELEX_typeSEMICOLON:
  7615.       ffesta_confirmed ();
  7616.       break;
  7617.  
  7618.     default:
  7619.       break;
  7620.     }
  7621.       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  7622.            FFEEXPR_contextRETURN, (ffeexprCallback) ffestb_R12271_);
  7623.       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
  7624.                            FFESTR_firstlRETURN);
  7625.       if (next == NULL)
  7626.     return (ffelexHandler) ffelex_swallow_tokens (t,
  7627.                            (ffelexHandler) ffesta_zero);
  7628.       return (ffelexHandler) (*next) (t);
  7629.  
  7630.     default:
  7631.       goto bad_0;        /* :::::::::::::::::::: */
  7632.     }
  7633.  
  7634. bad_0:                /* :::::::::::::::::::: */
  7635.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", ffesta_tokens[0]);
  7636.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7637.  
  7638. bad_1:                /* :::::::::::::::::::: */
  7639.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", t);
  7640.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7641.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  7642. }
  7643.  
  7644. /* ffestb_R12271_ -- "RETURN" expr
  7645.  
  7646.    (ffestb_R12271_)  // to expression handler
  7647.  
  7648.    Make sure the next token is an EOS or SEMICOLON.  */
  7649.  
  7650. static ffelexHandler
  7651. ffestb_R12271_ (ffelexToken ft, ffebld expr, ffelexToken t)
  7652. {
  7653.   switch (ffelex_token_type (t))
  7654.     {
  7655.     case FFELEX_typeEOS:
  7656.     case FFELEX_typeSEMICOLON:
  7657.       ffesta_confirmed ();
  7658.       if (!ffesta_is_inhibited ())
  7659.     ffestc_R1227 (expr, ft);
  7660.       return (ffelexHandler) ffesta_zero (t);
  7661.  
  7662.     default:
  7663.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RETURN", t);
  7664.       break;
  7665.     }
  7666.  
  7667.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7668. }
  7669.  
  7670. /* ffestb_R1228 -- Parse the CONTAINS statement
  7671.  
  7672.    return ffestb_R1228;     // to lexer
  7673.  
  7674.    Make sure the statement has a valid form for the CONTAINS statement.     If
  7675.    it does, implement the statement.  */
  7676.  
  7677. #if FFESTR_F90
  7678. ffelexHandler
  7679. ffestb_R1228 (ffelexToken t)
  7680. {
  7681.   char *p;
  7682.   ffeTokenLength i;
  7683.  
  7684.   switch (ffelex_token_type (ffesta_tokens[0]))
  7685.     {
  7686.     case FFELEX_typeNAME:
  7687.       if (ffesta_first_kw != FFESTR_firstCONTAINS)
  7688.     goto bad_0;        /* :::::::::::::::::::: */
  7689.       break;
  7690.  
  7691.     case FFELEX_typeNAMES:
  7692.       if (ffesta_first_kw != FFESTR_firstCONTAINS)
  7693.     goto bad_0;        /* :::::::::::::::::::: */
  7694.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCONTAINS)
  7695.     {
  7696.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCONTAINS);
  7697.       goto bad_i;        /* :::::::::::::::::::: */
  7698.     }
  7699.       break;
  7700.  
  7701.     default:
  7702.       goto bad_0;        /* :::::::::::::::::::: */
  7703.     }
  7704.  
  7705.   switch (ffelex_token_type (t))
  7706.     {
  7707.     case FFELEX_typeEOS:
  7708.     case FFELEX_typeSEMICOLON:
  7709.       ffesta_confirmed ();
  7710.       if (!ffesta_is_inhibited ())
  7711.     ffestc_R1228 ();
  7712.       return (ffelexHandler) ffesta_zero (t);
  7713.  
  7714.     case FFELEX_typeCOMMA:
  7715.     case FFELEX_typeCOLONCOLON:
  7716.       ffesta_confirmed ();    /* Error, but clearly intended. */
  7717.       goto bad_1;        /* :::::::::::::::::::: */
  7718.  
  7719.     default:
  7720.       goto bad_1;        /* :::::::::::::::::::: */
  7721.     }
  7722.  
  7723. bad_0:                /* :::::::::::::::::::: */
  7724.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTAINS", ffesta_tokens[0]);
  7725.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7726.                         (ffelexHandler) ffesta_zero);    /* Invalid first token. */
  7727.  
  7728. bad_1:                /* :::::::::::::::::::: */
  7729.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CONTAINS", t);
  7730.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7731.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  7732.  
  7733. bad_i:                /* :::::::::::::::::::: */
  7734.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CONTAINS", ffesta_tokens[0], i, t);
  7735.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7736. }
  7737.  
  7738. #endif
  7739. /* ffestb_V009 -- Parse the UNION statement
  7740.  
  7741.    return ffestb_V009;    // to lexer
  7742.  
  7743.    Make sure the statement has a valid form for the UNION statement.  If
  7744.    it does, implement the statement.  */
  7745.  
  7746. #if FFESTR_VXT
  7747. ffelexHandler
  7748. ffestb_V009 (ffelexToken t)
  7749. {
  7750.   char *p;
  7751.   ffeTokenLength i;
  7752.  
  7753.   switch (ffelex_token_type (ffesta_tokens[0]))
  7754.     {
  7755.     case FFELEX_typeNAME:
  7756.       if (ffesta_first_kw != FFESTR_firstUNION)
  7757.     goto bad_0;        /* :::::::::::::::::::: */
  7758.       break;
  7759.  
  7760.     case FFELEX_typeNAMES:
  7761.       if (ffesta_first_kw != FFESTR_firstUNION)
  7762.     goto bad_0;        /* :::::::::::::::::::: */
  7763.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlUNION)
  7764.     {
  7765.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlUNION);
  7766.       goto bad_i;        /* :::::::::::::::::::: */
  7767.     }
  7768.       break;
  7769.  
  7770.     default:
  7771.       goto bad_0;        /* :::::::::::::::::::: */
  7772.     }
  7773.  
  7774.   switch (ffelex_token_type (t))
  7775.     {
  7776.     case FFELEX_typeEOS:
  7777.     case FFELEX_typeSEMICOLON:
  7778.       ffesta_confirmed ();
  7779.       if (!ffesta_is_inhibited ())
  7780.     ffestc_V009 ();
  7781.       return (ffelexHandler) ffesta_zero (t);
  7782.  
  7783.     case FFELEX_typeCOMMA:
  7784.     case FFELEX_typeCOLONCOLON:
  7785.       ffesta_confirmed ();    /* Error, but clearly intended. */
  7786.       goto bad_1;        /* :::::::::::::::::::: */
  7787.  
  7788.     default:
  7789.       goto bad_1;        /* :::::::::::::::::::: */
  7790.     }
  7791.  
  7792. bad_0:                /* :::::::::::::::::::: */
  7793.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "UNION", ffesta_tokens[0]);
  7794.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7795.                         (ffelexHandler) ffesta_zero);    /* Invalid first token. */
  7796.  
  7797. bad_1:                /* :::::::::::::::::::: */
  7798.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "UNION", t);
  7799.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7800.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  7801.  
  7802. bad_i:                /* :::::::::::::::::::: */
  7803.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "UNION", ffesta_tokens[0], i, t);
  7804.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7805. }
  7806.  
  7807. #endif
  7808. /* ffestb_construct -- Parse a construct name
  7809.  
  7810.    return ffestb_construct;  // to lexer
  7811.  
  7812.    Make sure the statement can have a construct name (if-then-stmt, do-stmt,
  7813.    select-case-stmt).  */
  7814.  
  7815. ffelexHandler
  7816. ffestb_construct (ffelexToken t)
  7817. {
  7818.   /* This handler gets invoked only when token 0 is NAME/NAMES and token 1 is
  7819.      COLON. */
  7820.  
  7821.   ffesta_confirmed ();
  7822.   ffelex_set_names (TRUE);
  7823.   return (ffelexHandler) ffestb_construct1_;
  7824. }
  7825.  
  7826. /* ffestb_construct1_ -- NAME COLON
  7827.  
  7828.    return ffestb_construct1_;  // to lexer
  7829.  
  7830.    Make sure we've got a NAME that is DO, DOWHILE, IF, SELECT, or SELECTCASE.  */
  7831.  
  7832. static ffelexHandler
  7833. ffestb_construct1_ (ffelexToken t)
  7834. {
  7835.   ffelex_set_names (FALSE);
  7836.  
  7837.   switch (ffelex_token_type (t))
  7838.     {
  7839.     case FFELEX_typeNAME:
  7840.       ffesta_first_kw = ffestr_first (t);
  7841.       switch (ffesta_first_kw)
  7842.     {
  7843.     case FFESTR_firstIF:
  7844.       ffestb_local_.construct.next = (ffelexHandler) ffestb_if;
  7845.       break;
  7846.  
  7847.     case FFESTR_firstDO:
  7848.       ffestb_local_.construct.next = (ffelexHandler) ffestb_do;
  7849.       break;
  7850.  
  7851.     case FFESTR_firstDOWHILE:
  7852.       ffestb_local_.construct.next = (ffelexHandler) ffestb_dowhile;
  7853.       break;
  7854.  
  7855.     case FFESTR_firstSELECT:
  7856.     case FFESTR_firstSELECTCASE:
  7857.       ffestb_local_.construct.next = (ffelexHandler) ffestb_R809;
  7858.       break;
  7859.  
  7860.     default:
  7861.       goto bad;        /* :::::::::::::::::::: */
  7862.     }
  7863.       ffesta_construct_name = ffesta_tokens[0];
  7864.       ffesta_tokens[0] = ffelex_token_use (t);
  7865.       return (ffelexHandler) ffestb_construct2_;
  7866.  
  7867.     case FFELEX_typeNAMES:
  7868.       ffesta_first_kw = ffestr_first (t);
  7869.       switch (ffesta_first_kw)
  7870.     {
  7871.     case FFESTR_firstIF:
  7872.       if (ffelex_token_length (t) != FFESTR_firstlIF)
  7873.         goto bad;        /* :::::::::::::::::::: */
  7874.       ffestb_local_.construct.next = (ffelexHandler) ffestb_if;
  7875.       break;
  7876.  
  7877.     case FFESTR_firstDO:
  7878.       ffestb_local_.construct.next = (ffelexHandler) ffestb_do;
  7879.       break;
  7880.  
  7881.     case FFESTR_firstDOWHILE:
  7882.       if (ffelex_token_length (t) != FFESTR_firstlDOWHILE)
  7883.         goto bad;        /* :::::::::::::::::::: */
  7884.       ffestb_local_.construct.next = (ffelexHandler) ffestb_dowhile;
  7885.       break;
  7886.  
  7887.     case FFESTR_firstSELECTCASE:
  7888.       if (ffelex_token_length (t) != FFESTR_firstlSELECTCASE)
  7889.         goto bad;        /* :::::::::::::::::::: */
  7890.       ffestb_local_.construct.next = (ffelexHandler) ffestb_R809;
  7891.       break;
  7892.  
  7893.     default:
  7894.       goto bad;        /* :::::::::::::::::::: */
  7895.     }
  7896.       ffesta_construct_name = ffesta_tokens[0];
  7897.       ffesta_tokens[0] = ffelex_token_use (t);
  7898.       return (ffelexHandler) ffestb_construct2_;
  7899.  
  7900.     default:
  7901.       break;
  7902.     }
  7903.  
  7904. bad:                /* :::::::::::::::::::: */
  7905.   ffesta_ffebad_2st (FFEBAD_INVALID_STMT_FORM, "CONSTRUCT",
  7906.              ffesta_tokens[0], t);
  7907.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7908. }
  7909.  
  7910. /* ffestb_construct2_ -- NAME COLON "DO/DOWHILE/IF/SELECT/SELECTCASE"
  7911.  
  7912.    return ffestb_construct2_;  // to lexer
  7913.  
  7914.    This extra step is needed to set ffesta_second_kw if the second token
  7915.    (here) is a NAME, so DO and SELECT can continue to expect it.  */
  7916.  
  7917. static ffelexHandler
  7918. ffestb_construct2_ (ffelexToken t)
  7919. {
  7920.   if (ffelex_token_type (t) == FFELEX_typeNAME)
  7921.     ffesta_second_kw = ffestr_second (t);
  7922.   return (ffelexHandler) (*ffestb_local_.construct.next) (t);
  7923. }
  7924.  
  7925. /* ffestb_heap -- Parse an ALLOCATE/DEALLOCATE statement
  7926.  
  7927.    return ffestb_heap;    // to lexer
  7928.  
  7929.    Make sure the statement has a valid form for an ALLOCATE/DEALLOCATE
  7930.    statement.  If it does, implement the statement.  */
  7931.  
  7932. #if FFESTR_F90
  7933. ffelexHandler
  7934. ffestb_heap (ffelexToken t)
  7935. {
  7936.   switch (ffelex_token_type (ffesta_tokens[0]))
  7937.     {
  7938.     case FFELEX_typeNAME:
  7939.       break;
  7940.  
  7941.     case FFELEX_typeNAMES:
  7942.       if (ffelex_token_length (ffesta_tokens[0]) != ffestb_args.heap.len)
  7943.     goto bad_0;        /* :::::::::::::::::::: */
  7944.       break;
  7945.  
  7946.     default:
  7947.       goto bad_0;        /* :::::::::::::::::::: */
  7948.     }
  7949.  
  7950.   switch (ffelex_token_type (t))
  7951.     {
  7952.     case FFELEX_typeOPEN_PAREN:
  7953.       break;
  7954.  
  7955.     case FFELEX_typeEOS:
  7956.     case FFELEX_typeSEMICOLON:
  7957.     case FFELEX_typeCOMMA:
  7958.     case FFELEX_typeCOLONCOLON:
  7959.       ffesta_confirmed ();    /* Error, but clearly intended. */
  7960.       goto bad_1;        /* :::::::::::::::::::: */
  7961.  
  7962.     default:
  7963.       goto bad_1;        /* :::::::::::::::::::: */
  7964.     }
  7965.  
  7966.   ffestb_local_.heap.exprs = ffestt_exprlist_create ();
  7967.   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  7968.                       ffestb_args.heap.ctx,
  7969.                       (ffeexprCallback) ffestb_heap1_);
  7970.  
  7971. bad_0:                /* :::::::::::::::::::: */
  7972.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, ffesta_tokens[0]);
  7973.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  7974.  
  7975. bad_1:                /* :::::::::::::::::::: */
  7976.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
  7977.   return (ffelexHandler) ffelex_swallow_tokens (t,
  7978.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  7979. }
  7980.  
  7981. /* ffestb_heap1_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr
  7982.  
  7983.    (ffestb_heap1_)  // to expression handler
  7984.  
  7985.    Make sure the next token is COMMA.  */
  7986.  
  7987. static ffelexHandler
  7988. ffestb_heap1_ (ffelexToken ft, ffebld expr, ffelexToken t)
  7989. {
  7990.   switch (ffelex_token_type (t))
  7991.     {
  7992.     case FFELEX_typeCOMMA:
  7993.       if (expr == NULL)
  7994.     break;
  7995.       ffestt_exprlist_append (ffestb_local_.heap.exprs, expr,
  7996.                   ffelex_token_use (t));
  7997.       return (ffelexHandler) ffestb_heap2_;
  7998.  
  7999.     case FFELEX_typeCLOSE_PAREN:
  8000.       if (expr == NULL)
  8001.     break;
  8002.       ffestt_exprlist_append (ffestb_local_.heap.exprs, expr,
  8003.                   ffelex_token_use (t));
  8004.       ffesta_tokens[1] = NULL;
  8005.       ffestb_local_.heap.expr = NULL;
  8006.       return (ffelexHandler) ffestb_heap5_;
  8007.  
  8008.     default:
  8009.       break;
  8010.     }
  8011.  
  8012.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
  8013.   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
  8014.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8015. }
  8016.  
  8017. /* ffestb_heap2_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr COMMA
  8018.  
  8019.    return ffestb_heap2_;  // to lexer
  8020.  
  8021.    Make sure the next token is NAME.  */
  8022.  
  8023. static ffelexHandler
  8024. ffestb_heap2_ (ffelexToken t)
  8025. {
  8026.   switch (ffelex_token_type (t))
  8027.     {
  8028.     case FFELEX_typeNAME:
  8029.       ffesta_tokens[1] = ffelex_token_use (t);
  8030.       return (ffelexHandler) ffestb_heap3_;
  8031.  
  8032.     default:
  8033.       break;
  8034.     }
  8035.  
  8036.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
  8037.   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
  8038.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8039. }
  8040.  
  8041. /* ffestb_heap3_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN expr COMMA NAME
  8042.  
  8043.    return ffestb_heap3_;  // to lexer
  8044.  
  8045.    If token is EQUALS, make sure NAME was "STAT" and handle STAT variable;
  8046.    else pass NAME and token to expression handler.  */
  8047.  
  8048. static ffelexHandler
  8049. ffestb_heap3_ (ffelexToken t)
  8050. {
  8051.   ffelexHandler next;
  8052.  
  8053.   switch (ffelex_token_type (t))
  8054.     {
  8055.     case FFELEX_typeEQUALS:
  8056.       ffesta_confirmed ();
  8057.       if (ffestr_other (ffesta_tokens[1]) != FFESTR_otherSTAT)
  8058.     break;
  8059.       ffelex_token_kill (ffesta_tokens[1]);
  8060.       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  8061.                       FFEEXPR_contextHEAPSTAT,
  8062.                       (ffeexprCallback) ffestb_heap4_);
  8063.  
  8064.     default:
  8065.       next = (ffelexHandler)
  8066.     (*((ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  8067.                     ffestb_args.heap.ctx,
  8068.                     (ffeexprCallback) ffestb_heap1_)))
  8069.     (ffesta_tokens[1]);
  8070.       ffelex_token_kill (ffesta_tokens[1]);
  8071.       return (ffelexHandler) (*next) (t);
  8072.     }
  8073.  
  8074.   ffelex_token_kill (ffesta_tokens[1]);
  8075.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
  8076.   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
  8077.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8078. }
  8079.  
  8080. /* ffestb_heap4_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN ... COMMA "STAT" EQUALS
  8081.             expr
  8082.  
  8083.    (ffestb_heap4_)  // to expression handler
  8084.  
  8085.    Make sure the next token is CLOSE_PAREN.  */
  8086.  
  8087. static ffelexHandler
  8088. ffestb_heap4_ (ffelexToken ft, ffebld expr, ffelexToken t)
  8089. {
  8090.   switch (ffelex_token_type (t))
  8091.     {
  8092.     case FFELEX_typeCLOSE_PAREN:
  8093.       if (expr == NULL)
  8094.     break;
  8095.       ffesta_tokens[1] = ffelex_token_use (ft);
  8096.       ffestb_local_.heap.expr = expr;
  8097.       return (ffelexHandler) ffestb_heap5_;
  8098.  
  8099.     default:
  8100.       break;
  8101.     }
  8102.  
  8103.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
  8104.   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
  8105.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8106. }
  8107.  
  8108. /* ffestb_heap5_ -- "ALLOCATE/DEALLOCATE" OPEN_PAREN ... CLOSE_PAREN
  8109.  
  8110.    return ffestb_heap5_;  // to lexer
  8111.  
  8112.    Make sure the next token is EOS/SEMICOLON.  */
  8113.  
  8114. static ffelexHandler
  8115. ffestb_heap5_ (ffelexToken t)
  8116. {
  8117.   switch (ffelex_token_type (t))
  8118.     {
  8119.     case FFELEX_typeEOS:
  8120.     case FFELEX_typeSEMICOLON:
  8121.       ffesta_confirmed ();
  8122.       if (!ffesta_is_inhibited ())
  8123.     if (ffesta_first_kw == FFESTR_firstALLOCATE)
  8124.       ffestc_R620 (ffestb_local_.heap.exprs, ffestb_local_.heap.expr,
  8125.                ffesta_tokens[1]);
  8126.     else
  8127.       ffestc_R625 (ffestb_local_.heap.exprs, ffestb_local_.heap.expr,
  8128.                ffesta_tokens[1]);
  8129.       ffestt_exprlist_kill (ffestb_local_.heap.exprs);
  8130.       if (ffesta_tokens[1] != NULL)
  8131.     ffelex_token_kill (ffesta_tokens[1]);
  8132.       return (ffelexHandler) ffesta_zero (t);
  8133.  
  8134.     default:
  8135.       break;
  8136.     }
  8137.  
  8138.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.heap.badname, t);
  8139.   ffestt_exprlist_kill (ffestb_local_.heap.exprs);
  8140.   if (ffesta_tokens[1] != NULL)
  8141.     ffelex_token_kill (ffesta_tokens[1]);
  8142.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8143. }
  8144.  
  8145. #endif
  8146. /* ffestb_module -- Parse the MODULEPROCEDURE statement
  8147.  
  8148.    return ffestb_module;  // to lexer
  8149.  
  8150.    Make sure the statement has a valid form for the MODULEPROCEDURE statement.
  8151.    If it does, implement the statement.
  8152.  
  8153.    31-May-90  JCB  1.1
  8154.       Confirm NAME==MODULE followed by standard four invalid tokens, so we
  8155.       get decent message if somebody forgets that MODULE requires a name.  */
  8156.  
  8157. #if FFESTR_F90
  8158. ffelexHandler
  8159. ffestb_module (ffelexToken t)
  8160. {
  8161.   ffeTokenLength i;
  8162.   char *p;
  8163.   ffelexToken nt;
  8164.   ffelexToken mt;        /* Name in MODULE PROCEDUREname, i.e.
  8165.                    includes "PROCEDURE". */
  8166.  
  8167.   switch (ffelex_token_type (ffesta_tokens[0]))
  8168.     {
  8169.     case FFELEX_typeNAME:
  8170.       if (ffesta_first_kw != FFESTR_firstMODULE)
  8171.     goto bad_0;        /* :::::::::::::::::::: */
  8172.       switch (ffelex_token_type (t))
  8173.     {
  8174.     case FFELEX_typeNAME:
  8175.       break;
  8176.  
  8177.     case FFELEX_typeCOLONCOLON:
  8178.     case FFELEX_typeCOMMA:
  8179.     case FFELEX_typeEOS:
  8180.     case FFELEX_typeSEMICOLON:
  8181.       ffesta_confirmed ();
  8182.       goto bad_1m;        /* :::::::::::::::::::: */
  8183.  
  8184.     default:
  8185.       goto bad_1m;        /* :::::::::::::::::::: */
  8186.     }
  8187.  
  8188.       ffesta_confirmed ();
  8189.       if (ffesta_second_kw != FFESTR_secondPROCEDURE)
  8190.     {
  8191.       ffesta_tokens[1] = ffelex_token_use (t);
  8192.       return (ffelexHandler) ffestb_module3_;
  8193.     }
  8194.       ffestb_local_.moduleprocedure.started = FALSE;
  8195.       ffesta_tokens[1] = ffelex_token_use (t);
  8196.       return (ffelexHandler) ffestb_module1_;
  8197.  
  8198.     case FFELEX_typeNAMES:
  8199.       p = ffelex_token_text (ffesta_tokens[0])
  8200.     + (i = FFESTR_firstlMODULEPROCEDURE);
  8201.       if ((ffesta_first_kw == FFESTR_firstMODULE)
  8202.       || ((ffesta_first_kw == FFESTR_firstMODULEPROCEDURE)
  8203.           && !ffesrc_is_name_init (*p)))
  8204.     {            /* Definitely not "MODULE PROCEDURE name". */
  8205.       switch (ffelex_token_type (t))
  8206.         {
  8207.         case FFELEX_typeCOMMA:
  8208.         case FFELEX_typeCOLONCOLON:
  8209.           ffesta_confirmed ();    /* Error, but clearly intended. */
  8210.           goto bad_1m;    /* :::::::::::::::::::: */
  8211.  
  8212.         default:
  8213.           goto bad_1m;    /* :::::::::::::::::::: */
  8214.  
  8215.         case FFELEX_typeEOS:
  8216.         case FFELEX_typeSEMICOLON:
  8217.           ffesta_confirmed ();
  8218.           break;
  8219.         }
  8220.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlMODULE);
  8221.       if (!ffesrc_is_name_init (*p))
  8222.         goto bad_im;    /* :::::::::::::::::::: */
  8223.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  8224.       if (!ffesta_is_inhibited ())
  8225.         ffestc_R1105 (nt);
  8226.       ffelex_token_kill (nt);
  8227.       return (ffelexHandler) ffesta_zero (t);
  8228.     }
  8229.  
  8230.       /* Here we know that we're indeed looking at a MODULEPROCEDURE
  8231.          statement rather than MODULE and that the character following
  8232.          MODULEPROCEDURE in the NAMES token is a valid first character for a
  8233.          NAME.    This means that unless the second token is COMMA, we have an
  8234.          ambiguous statement that can be read either as MODULE PROCEDURE name
  8235.          or MODULE PROCEDUREname, the former being an R1205, the latter an
  8236.          R1105. */
  8237.  
  8238.       if (ffesta_first_kw != FFESTR_firstMODULEPROCEDURE)
  8239.     goto bad_0;        /* :::::::::::::::::::: */
  8240.       switch (ffelex_token_type (t))
  8241.     {
  8242.     case FFELEX_typeCOLONCOLON:
  8243.       ffesta_confirmed ();    /* Error, but clearly intended. */
  8244.       goto bad_1;        /* :::::::::::::::::::: */
  8245.  
  8246.     default:
  8247.       goto bad_1;        /* :::::::::::::::::::: */
  8248.  
  8249.     case FFELEX_typeCOMMA:    /* Aha, clearly not MODULE PROCEDUREname. */
  8250.       ffesta_confirmed ();
  8251.       ffestb_local_.moduleprocedure.started = FALSE;
  8252.       ffesta_tokens[1]
  8253.         = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  8254.       return (ffelexHandler) ffestb_module2_ (t);
  8255.  
  8256.     case FFELEX_typeEOS:    /* MODULE PROCEDURE name or MODULE
  8257.                    PROCEDUREname. */
  8258.     case FFELEX_typeSEMICOLON:
  8259.       ffesta_confirmed ();
  8260.       break;
  8261.     }
  8262.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  8263.       mt = ffelex_token_name_from_names (ffesta_tokens[0], FFESTR_firstlMODULE,
  8264.                      0);
  8265.       if (!ffesta_is_inhibited ())
  8266.     ffestc_module (mt, nt);    /* Implement ambiguous statement. */
  8267.       ffelex_token_kill (nt);
  8268.       ffelex_token_kill (mt);
  8269.       return (ffelexHandler) ffesta_zero (t);
  8270.  
  8271.     default:
  8272.       goto bad_0;        /* :::::::::::::::::::: */
  8273.     }
  8274.  
  8275. bad_0:                /* :::::::::::::::::::: */
  8276.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", ffesta_tokens[0]);
  8277.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8278.  
  8279. bad_1:                /* :::::::::::::::::::: */
  8280.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
  8281.   return (ffelexHandler) ffelex_swallow_tokens (t,
  8282.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  8283.  
  8284. bad_1m:            /* :::::::::::::::::::: */
  8285.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE", t);
  8286.   return (ffelexHandler) ffelex_swallow_tokens (t,
  8287.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  8288.  
  8289. bad_im:            /* :::::::::::::::::::: */
  8290.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "MODULE", ffesta_tokens[0], i, t);
  8291.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8292. }
  8293.  
  8294. /* ffestb_module1_ -- "MODULEPROCEDURE" or "MODULE" "PROCEDURE"
  8295.  
  8296.    return ffestb_module1_;  // to lexer
  8297.  
  8298.    Make sure the statement has a valid form for the MODULEPROCEDURE statement.    If it
  8299.    does, implement the statement.  */
  8300.  
  8301. static ffelexHandler
  8302. ffestb_module1_ (ffelexToken t)
  8303. {
  8304.   switch (ffelex_token_type (t))
  8305.     {
  8306.     case FFELEX_typeNAME:
  8307.       if (!ffestb_local_.moduleprocedure.started
  8308.       && (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME))
  8309.     {
  8310.       ffesta_confirmed ();
  8311.       ffelex_token_kill (ffesta_tokens[1]);
  8312.     }
  8313.       ffesta_tokens[1] = ffelex_token_use (t);
  8314.       return (ffelexHandler) ffestb_module2_;
  8315.  
  8316.     case FFELEX_typeEOS:
  8317.     case FFELEX_typeSEMICOLON:
  8318.       if (ffestb_local_.moduleprocedure.started)
  8319.     break;            /* Error if we've already seen NAME COMMA. */
  8320.       ffesta_confirmed ();
  8321.       if (!ffesta_is_inhibited ())
  8322.     ffestc_R1105 (ffesta_tokens[1]);
  8323.       ffelex_token_kill (ffesta_tokens[1]);
  8324.       return (ffelexHandler) ffesta_zero (t);
  8325.  
  8326.     case FFELEX_typeCOMMA:
  8327.     case FFELEX_typeCOLONCOLON:
  8328.       ffesta_confirmed ();    /* Error, but clearly intended. */
  8329.       break;
  8330.  
  8331.     default:
  8332.       break;
  8333.     }
  8334.  
  8335.   if (ffestb_local_.moduleprocedure.started && !ffesta_is_inhibited ())
  8336.     ffestc_R1205_finish ();
  8337.   else if (!ffestb_local_.moduleprocedure.started)
  8338.     ffelex_token_kill (ffesta_tokens[1]);
  8339.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
  8340.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8341. }
  8342.  
  8343. /* ffestb_module2_ -- "MODULE/PROCEDURE" NAME
  8344.  
  8345.    return ffestb_module2_;  // to lexer
  8346.  
  8347.    Make sure the statement has a valid form for the MODULEPROCEDURE statement.    If it
  8348.    does, implement the statement.  */
  8349.  
  8350. static ffelexHandler
  8351. ffestb_module2_ (ffelexToken t)
  8352. {
  8353.   switch (ffelex_token_type (t))
  8354.     {
  8355.     case FFELEX_typeEOS:
  8356.     case FFELEX_typeSEMICOLON:
  8357.       if (!ffestb_local_.moduleprocedure.started)
  8358.     {
  8359.       ffesta_confirmed ();
  8360.       if (!ffesta_is_inhibited ())
  8361.         ffestc_R1205_start ();
  8362.     }
  8363.       if (!ffesta_is_inhibited ())
  8364.     {
  8365.       ffestc_R1205_item (ffesta_tokens[1]);
  8366.       ffestc_R1205_finish ();
  8367.     }
  8368.       ffelex_token_kill (ffesta_tokens[1]);
  8369.       return (ffelexHandler) ffesta_zero (t);
  8370.  
  8371.     case FFELEX_typeCOMMA:
  8372.       if (!ffestb_local_.moduleprocedure.started)
  8373.     {
  8374.       ffestb_local_.moduleprocedure.started = TRUE;
  8375.       ffesta_confirmed ();
  8376.       if (!ffesta_is_inhibited ())
  8377.         ffestc_R1205_start ();
  8378.     }
  8379.       if (!ffesta_is_inhibited ())
  8380.     ffestc_R1205_item (ffesta_tokens[1]);
  8381.       ffelex_token_kill (ffesta_tokens[1]);
  8382.       return (ffelexHandler) ffestb_module1_;
  8383.  
  8384.     default:
  8385.       break;
  8386.     }
  8387.  
  8388.   if (ffestb_local_.moduleprocedure.started && !ffesta_is_inhibited ())
  8389.     ffestc_R1205_finish ();
  8390.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE PROCEDURE", t);
  8391.   ffelex_token_kill (ffesta_tokens[1]);
  8392.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8393. }
  8394.  
  8395. /* ffestb_module3_ -- "MODULE" NAME
  8396.  
  8397.    return ffestb_module3_;  // to lexer
  8398.  
  8399.    Make sure the statement has a valid form for the MODULE statement.  If it
  8400.    does, implement the statement.  */
  8401.  
  8402. static ffelexHandler
  8403. ffestb_module3_ (ffelexToken t)
  8404. {
  8405.   switch (ffelex_token_type (t))
  8406.     {
  8407.     case FFELEX_typeEOS:
  8408.     case FFELEX_typeSEMICOLON:
  8409.       if (!ffesta_is_inhibited ())
  8410.     ffestc_R1105 (ffesta_tokens[1]);
  8411.       ffelex_token_kill (ffesta_tokens[1]);
  8412.       return (ffelexHandler) ffesta_zero (t);
  8413.  
  8414.     default:
  8415.       break;
  8416.     }
  8417.  
  8418.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MODULE", t);
  8419.   ffelex_token_kill (ffesta_tokens[1]);
  8420.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8421. }
  8422.  
  8423. #endif
  8424. /* ffestb_R809 -- Parse the SELECTCASE statement
  8425.  
  8426.    return ffestb_R809;    // to lexer
  8427.  
  8428.    Make sure the statement has a valid form for the SELECTCASE statement.
  8429.    If it does, implement the statement.     */
  8430.  
  8431. ffelexHandler
  8432. ffestb_R809 (ffelexToken t)
  8433. {
  8434.   ffeTokenLength i;
  8435.   char *p;
  8436.  
  8437.   switch (ffelex_token_type (ffesta_tokens[0]))
  8438.     {
  8439.     case FFELEX_typeNAME:
  8440.       switch (ffesta_first_kw)
  8441.     {
  8442.     case FFESTR_firstSELECT:
  8443.       if ((ffelex_token_type (t) != FFELEX_typeNAME)
  8444.           || (ffesta_second_kw != FFESTR_secondCASE))
  8445.         goto bad_1;        /* :::::::::::::::::::: */
  8446.       ffesta_confirmed ();
  8447.       return (ffelexHandler) ffestb_R8091_;
  8448.  
  8449.     case FFESTR_firstSELECTCASE:
  8450.       return (ffelexHandler) ffestb_R8091_ (t);
  8451.  
  8452.     default:
  8453.       goto bad_0;        /* :::::::::::::::::::: */
  8454.     }
  8455.  
  8456.     case FFELEX_typeNAMES:
  8457.       if (ffesta_first_kw != FFESTR_firstSELECTCASE)
  8458.     goto bad_0;        /* :::::::::::::::::::: */
  8459.       switch (ffelex_token_type (t))
  8460.     {
  8461.     case FFELEX_typeCOMMA:
  8462.     case FFELEX_typeEOS:
  8463.     case FFELEX_typeSEMICOLON:
  8464.     case FFELEX_typeCOLONCOLON:
  8465.       ffesta_confirmed ();    /* Error, but clearly intended. */
  8466.       goto bad_1;        /* :::::::::::::::::::: */
  8467.  
  8468.     default:
  8469.       goto bad_1;        /* :::::::::::::::::::: */
  8470.  
  8471.     case FFELEX_typeOPEN_PAREN:
  8472.       break;
  8473.     }
  8474.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSELECTCASE);
  8475.       if (*p != '\0')
  8476.     goto bad_i;        /* :::::::::::::::::::: */
  8477.       return (ffelexHandler) ffestb_R8091_ (t);
  8478.  
  8479.     default:
  8480.       goto bad_0;        /* :::::::::::::::::::: */
  8481.     }
  8482.  
  8483. bad_0:                /* :::::::::::::::::::: */
  8484.   if (ffesta_construct_name != NULL)
  8485.     {
  8486.       ffelex_token_kill (ffesta_construct_name);
  8487.       ffesta_construct_name = NULL;
  8488.     }
  8489.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", ffesta_tokens[0]);
  8490.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8491.  
  8492. bad_1:                /* :::::::::::::::::::: */
  8493.   if (ffesta_construct_name != NULL)
  8494.     {
  8495.       ffelex_token_kill (ffesta_construct_name);
  8496.       ffesta_construct_name = NULL;
  8497.     }
  8498.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
  8499.   return (ffelexHandler) ffelex_swallow_tokens (t,
  8500.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  8501.  
  8502. bad_i:                /* :::::::::::::::::::: */
  8503.   if (ffesta_construct_name != NULL)
  8504.     {
  8505.       ffelex_token_kill (ffesta_construct_name);
  8506.       ffesta_construct_name = NULL;
  8507.     }
  8508.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", ffesta_tokens[0], i, t);
  8509.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8510. }
  8511.  
  8512. /* ffestb_R8091_ -- "SELECTCASE" or "SELECT" "CASE"
  8513.  
  8514.    return ffestb_R8091_;  // to lexer
  8515.  
  8516.    Make sure the statement has a valid form for the SELECTCASE statement.  If it
  8517.    does, implement the statement.  */
  8518.  
  8519. static ffelexHandler
  8520. ffestb_R8091_ (ffelexToken t)
  8521. {
  8522.   switch (ffelex_token_type (t))
  8523.     {
  8524.     case FFELEX_typeOPEN_PAREN:
  8525.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  8526.         FFEEXPR_contextSELECTCASE, (ffeexprCallback) ffestb_R8092_);
  8527.  
  8528.     case FFELEX_typeEOS:
  8529.     case FFELEX_typeSEMICOLON:
  8530.     case FFELEX_typeCOMMA:
  8531.     case FFELEX_typeCOLONCOLON:
  8532.       ffesta_confirmed ();    /* Error, but clearly intended. */
  8533.       break;
  8534.  
  8535.     default:
  8536.       break;
  8537.     }
  8538.  
  8539.   if (ffesta_construct_name != NULL)
  8540.     {
  8541.       ffelex_token_kill (ffesta_construct_name);
  8542.       ffesta_construct_name = NULL;
  8543.     }
  8544.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
  8545.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8546. }
  8547.  
  8548. /* ffestb_R8092_ -- "SELECT/CASE" OPEN_PAREN expr
  8549.  
  8550.    (ffestb_R8092_)  // to expression handler
  8551.  
  8552.    Make sure the statement has a valid form for the SELECTCASE statement.  If it
  8553.    does, implement the statement.  */
  8554.  
  8555. static ffelexHandler
  8556. ffestb_R8092_ (ffelexToken ft, ffebld expr, ffelexToken t)
  8557. {
  8558.   switch (ffelex_token_type (t))
  8559.     {
  8560.     case FFELEX_typeCLOSE_PAREN:
  8561.       if (expr == NULL)
  8562.     break;
  8563.       ffesta_tokens[1] = ffelex_token_use (ft);
  8564.       ffestb_local_.selectcase.expr = expr;
  8565.       return (ffelexHandler) ffestb_R8093_;
  8566.  
  8567.     default:
  8568.       break;
  8569.     }
  8570.  
  8571.   if (ffesta_construct_name != NULL)
  8572.     {
  8573.       ffelex_token_kill (ffesta_construct_name);
  8574.       ffesta_construct_name = NULL;
  8575.     }
  8576.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
  8577.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8578. }
  8579.  
  8580. /* ffestb_R8093_ -- "SELECT/CASE" OPEN_PAREN expr CLOSE_PAREN
  8581.  
  8582.    return ffestb_R8093_;  // to lexer
  8583.  
  8584.    Make sure the statement has a valid form for the SELECTCASE statement.  If it
  8585.    does, implement the statement.  */
  8586.  
  8587. static ffelexHandler
  8588. ffestb_R8093_ (ffelexToken t)
  8589. {
  8590.   switch (ffelex_token_type (t))
  8591.     {
  8592.     case FFELEX_typeEOS:
  8593.     case FFELEX_typeSEMICOLON:
  8594.       ffesta_confirmed ();
  8595.       if (!ffesta_is_inhibited ())
  8596.     ffestc_R809 (ffesta_construct_name, ffestb_local_.selectcase.expr,
  8597.              ffesta_tokens[1]);
  8598.       ffelex_token_kill (ffesta_tokens[1]);
  8599.       if (ffesta_construct_name != NULL)
  8600.     {
  8601.       ffelex_token_kill (ffesta_construct_name);
  8602.       ffesta_construct_name = NULL;
  8603.     }
  8604.       return ffesta_zero (t);
  8605.  
  8606.     case FFELEX_typeCOMMA:
  8607.     case FFELEX_typeCOLONCOLON:
  8608.       ffesta_confirmed ();    /* Error, but clearly intended. */
  8609.       break;
  8610.  
  8611.     default:
  8612.       break;
  8613.     }
  8614.  
  8615.   ffelex_token_kill (ffesta_tokens[1]);
  8616.   if (ffesta_construct_name != NULL)
  8617.     {
  8618.       ffelex_token_kill (ffesta_construct_name);
  8619.       ffesta_construct_name = NULL;
  8620.     }
  8621.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "SELECT CASE", t);
  8622.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8623. }
  8624.  
  8625. /* ffestb_R810 -- Parse the CASE statement
  8626.  
  8627.    return ffestb_R810;    // to lexer
  8628.  
  8629.    Make sure the statement has a valid form for the CASE statement.
  8630.    If it does, implement the statement.     */
  8631.  
  8632. ffelexHandler
  8633. ffestb_R810 (ffelexToken t)
  8634. {
  8635.   ffeTokenLength i;
  8636.   char *p;
  8637.  
  8638.   switch (ffelex_token_type (ffesta_tokens[0]))
  8639.     {
  8640.     case FFELEX_typeNAME:
  8641.       if (ffesta_first_kw != FFESTR_firstCASE)
  8642.     goto bad_0;        /* :::::::::::::::::::: */
  8643.       switch (ffelex_token_type (t))
  8644.     {
  8645.     case FFELEX_typeCOMMA:
  8646.     case FFELEX_typeEOS:
  8647.     case FFELEX_typeSEMICOLON:
  8648.     case FFELEX_typeCOLONCOLON:
  8649.       ffesta_confirmed ();    /* Error, but clearly intended. */
  8650.       goto bad_1;        /* :::::::::::::::::::: */
  8651.  
  8652.     default:
  8653.       goto bad_1;        /* :::::::::::::::::::: */
  8654.  
  8655.     case FFELEX_typeNAME:
  8656.       ffesta_confirmed ();
  8657.       if (ffesta_second_kw != FFESTR_secondDEFAULT)
  8658.         goto bad_1;        /* :::::::::::::::::::: */
  8659.       ffestb_local_.case_stmt.cases = NULL;
  8660.       return (ffelexHandler) ffestb_R8101_;
  8661.  
  8662.     case FFELEX_typeOPEN_PAREN:
  8663.       ffestb_local_.case_stmt.cases = ffestt_caselist_create ();
  8664.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  8665.               FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
  8666.     }
  8667.  
  8668.     case FFELEX_typeNAMES:
  8669.       switch (ffesta_first_kw)
  8670.     {
  8671.     case FFESTR_firstCASEDEFAULT:
  8672.       switch (ffelex_token_type (t))
  8673.         {
  8674.         case FFELEX_typeCOMMA:
  8675.         case FFELEX_typeCOLONCOLON:
  8676.           ffesta_confirmed ();    /* Error, but clearly intended. */
  8677.           goto bad_1;    /* :::::::::::::::::::: */
  8678.  
  8679.         default:
  8680.           goto bad_1;    /* :::::::::::::::::::: */
  8681.  
  8682.         case FFELEX_typeEOS:
  8683.         case FFELEX_typeSEMICOLON:
  8684.           ffesta_confirmed ();
  8685.           break;
  8686.         }
  8687.       ffestb_local_.case_stmt.cases = NULL;
  8688.       p = ffelex_token_text (ffesta_tokens[0])
  8689.         + (i = FFESTR_firstlCASEDEFAULT);
  8690.       if (*p == '\0')
  8691.         return (ffelexHandler) ffestb_R8101_ (t);
  8692.       if (!ffesrc_is_name_init (*p))
  8693.         goto bad_i;        /* :::::::::::::::::::: */
  8694.       ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i,
  8695.                                0);
  8696.       return (ffelexHandler) ffestb_R8102_ (t);
  8697.  
  8698.     case FFESTR_firstCASE:
  8699.       break;
  8700.  
  8701.     default:
  8702.       goto bad_0;        /* :::::::::::::::::::: */
  8703.     }
  8704.  
  8705.       switch (ffelex_token_type (t))
  8706.     {
  8707.     case FFELEX_typeCOMMA:
  8708.     case FFELEX_typeEOS:
  8709.     case FFELEX_typeSEMICOLON:
  8710.     case FFELEX_typeCOLONCOLON:
  8711.       ffesta_confirmed ();    /* Error, but clearly intended. */
  8712.       goto bad_1;        /* :::::::::::::::::::: */
  8713.  
  8714.     default:
  8715.       goto bad_1;        /* :::::::::::::::::::: */
  8716.  
  8717.     case FFELEX_typeOPEN_PAREN:
  8718.       break;
  8719.     }
  8720.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCASE);
  8721.       if (*p != '\0')
  8722.     goto bad_i;        /* :::::::::::::::::::: */
  8723.       ffestb_local_.case_stmt.cases = ffestt_caselist_create ();
  8724.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  8725.               FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
  8726.  
  8727.     default:
  8728.       goto bad_0;        /* :::::::::::::::::::: */
  8729.     }
  8730.  
  8731. bad_0:                /* :::::::::::::::::::: */
  8732.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", ffesta_tokens[0]);
  8733.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8734.  
  8735. bad_1:                /* :::::::::::::::::::: */
  8736.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
  8737.   return (ffelexHandler) ffelex_swallow_tokens (t,
  8738.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  8739.  
  8740. bad_i:                /* :::::::::::::::::::: */
  8741.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "CASE", ffesta_tokens[0], i, t);
  8742.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8743. }
  8744.  
  8745. /* ffestb_R8101_ -- "CASE" case-selector
  8746.  
  8747.    return ffestb_R8101_;  // to lexer
  8748.  
  8749.    Make sure the statement has a valid form for the CASE statement.  If it
  8750.    does, implement the statement.  */
  8751.  
  8752. static ffelexHandler
  8753. ffestb_R8101_ (ffelexToken t)
  8754. {
  8755.   switch (ffelex_token_type (t))
  8756.     {
  8757.     case FFELEX_typeNAME:
  8758.       ffesta_tokens[1] = ffelex_token_use (t);
  8759.       return (ffelexHandler) ffestb_R8102_;
  8760.  
  8761.     case FFELEX_typeEOS:
  8762.     case FFELEX_typeSEMICOLON:
  8763.       ffesta_tokens[1] = NULL;
  8764.       return (ffelexHandler) ffestb_R8102_ (t);
  8765.  
  8766.     case FFELEX_typeCOMMA:
  8767.     case FFELEX_typeCOLONCOLON:
  8768.       ffesta_confirmed ();    /* Error, but clearly intended. */
  8769.       break;
  8770.  
  8771.     default:
  8772.       break;
  8773.     }
  8774.  
  8775.   if (ffestb_local_.case_stmt.cases != NULL)
  8776.     ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
  8777.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
  8778.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8779. }
  8780.  
  8781. /* ffestb_R8102_ -- "CASE" case-selector [NAME]
  8782.  
  8783.    return ffestb_R8102_;  // to lexer
  8784.  
  8785.    Make sure the statement has a valid form for the CASE statement.  If it
  8786.    does, implement the statement.  */
  8787.  
  8788. static ffelexHandler
  8789. ffestb_R8102_ (ffelexToken t)
  8790. {
  8791.   switch (ffelex_token_type (t))
  8792.     {
  8793.     case FFELEX_typeEOS:
  8794.     case FFELEX_typeSEMICOLON:
  8795.       ffesta_confirmed ();
  8796.       if (!ffesta_is_inhibited ())
  8797.     ffestc_R810 (ffestb_local_.case_stmt.cases, ffesta_tokens[1]);
  8798.       if (ffestb_local_.case_stmt.cases != NULL)
  8799.     ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
  8800.       if (ffesta_tokens[1] != NULL)
  8801.     ffelex_token_kill (ffesta_tokens[1]);
  8802.       return (ffelexHandler) ffesta_zero (t);
  8803.  
  8804.     case FFELEX_typeCOMMA:
  8805.     case FFELEX_typeCOLONCOLON:
  8806.       ffesta_confirmed ();    /* Error, but clearly intended. */
  8807.       break;
  8808.  
  8809.     default:
  8810.       break;
  8811.     }
  8812.  
  8813.   if (ffestb_local_.case_stmt.cases != NULL)
  8814.     ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
  8815.   if (ffesta_tokens[1] != NULL)
  8816.     ffelex_token_kill (ffesta_tokens[1]);
  8817.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
  8818.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8819. }
  8820.  
  8821. /* ffestb_R8103_ -- "CASE" OPEN_PAREN expr
  8822.  
  8823.    (ffestb_R8103_)  // to expression handler
  8824.  
  8825.    Make sure the statement has a valid form for the CASE statement.  If it
  8826.    does, implement the statement.  */
  8827.  
  8828. static ffelexHandler
  8829. ffestb_R8103_ (ffelexToken ft, ffebld expr, ffelexToken t)
  8830. {
  8831.   switch (ffelex_token_type (t))
  8832.     {
  8833.     case FFELEX_typeCLOSE_PAREN:
  8834.       ffestt_caselist_append (ffestb_local_.case_stmt.cases, FALSE, expr, NULL,
  8835.                   ffelex_token_use (ft));
  8836.       return (ffelexHandler) ffestb_R8101_;
  8837.  
  8838.     case FFELEX_typeCOMMA:
  8839.       ffestt_caselist_append (ffestb_local_.case_stmt.cases, FALSE, expr, NULL,
  8840.                   ffelex_token_use (ft));
  8841.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  8842.               FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
  8843.  
  8844.     case FFELEX_typeCOLON:
  8845.       ffestt_caselist_append (ffestb_local_.case_stmt.cases, TRUE, expr, NULL,
  8846.                   ffelex_token_use (ft));    /* NULL second expr for
  8847.                                now, just plug in. */
  8848.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  8849.               FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8104_);
  8850.  
  8851.     default:
  8852.       break;
  8853.     }
  8854.  
  8855.   ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
  8856.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
  8857.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8858. }
  8859.  
  8860. /* ffestb_R8104_ -- "CASE" OPEN_PAREN expr COLON expr
  8861.  
  8862.    (ffestb_R8104_)  // to expression handler
  8863.  
  8864.    Make sure the statement has a valid form for the CASE statement.  If it
  8865.    does, implement the statement.  */
  8866.  
  8867. static ffelexHandler
  8868. ffestb_R8104_ (ffelexToken ft, ffebld expr, ffelexToken t)
  8869. {
  8870.   switch (ffelex_token_type (t))
  8871.     {
  8872.     case FFELEX_typeCLOSE_PAREN:
  8873.       ffestb_local_.case_stmt.cases->previous->expr2 = expr;
  8874.       return (ffelexHandler) ffestb_R8101_;
  8875.  
  8876.     case FFELEX_typeCOMMA:
  8877.       ffestb_local_.case_stmt.cases->previous->expr2 = expr;
  8878.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  8879.               FFEEXPR_contextCASE, (ffeexprCallback) ffestb_R8103_);
  8880.  
  8881.     default:
  8882.       break;
  8883.     }
  8884.  
  8885.   ffestt_caselist_kill (ffestb_local_.case_stmt.cases);
  8886.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CASE", t);
  8887.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8888. }
  8889.  
  8890. /* ffestb_R1001 -- Parse a FORMAT statement
  8891.  
  8892.    return ffestb_R1001;     // to lexer
  8893.  
  8894.    Make sure the statement has a valid form for an FORMAT statement.
  8895.    If it does, implement the statement.     */
  8896.  
  8897. ffelexHandler
  8898. ffestb_R1001 (ffelexToken t)
  8899. {
  8900.   ffesttFormatList f;
  8901.  
  8902.   switch (ffelex_token_type (ffesta_tokens[0]))
  8903.     {
  8904.     case FFELEX_typeNAME:
  8905.       if (ffesta_first_kw != FFESTR_firstFORMAT)
  8906.     goto bad_0;        /* :::::::::::::::::::: */
  8907.       break;
  8908.  
  8909.     case FFELEX_typeNAMES:
  8910.       if (ffesta_first_kw != FFESTR_firstFORMAT)
  8911.     goto bad_0;        /* :::::::::::::::::::: */
  8912.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlFORMAT)
  8913.     goto bad_0;        /* :::::::::::::::::::: */
  8914.       break;
  8915.  
  8916.     default:
  8917.       goto bad_0;        /* :::::::::::::::::::: */
  8918.     }
  8919.  
  8920.   switch (ffelex_token_type (t))
  8921.     {
  8922.     case FFELEX_typeOPEN_PAREN:
  8923.       ffestb_local_.format.complained = FALSE;
  8924.       ffestb_local_.format.f = NULL;    /* No parent yet. */
  8925.       ffestb_local_.format.f = ffestt_formatlist_create (NULL,
  8926.                               ffelex_token_use (t));
  8927.       ffelex_set_names_pure (TRUE);    /* Have even free-form lexer give us
  8928.                        NAMES. */
  8929.       return (ffelexHandler) ffestb_R10011_;
  8930.  
  8931.     case FFELEX_typeOPEN_ARRAY:/* "(/". */
  8932.       ffesta_confirmed ();
  8933.       ffestb_local_.format.complained = FALSE;
  8934.       ffestb_local_.format.f = ffestt_formatlist_create (NULL,
  8935.                               ffelex_token_use (t));
  8936.       f = ffestt_formatlist_append (ffestb_local_.format.f);
  8937.       f->type = FFESTP_formattypeSLASH;
  8938.       f->t = ffelex_token_use (t);
  8939.       f->u.R1010.val.present = FALSE;
  8940.       f->u.R1010.val.rtexpr = FALSE;
  8941.       f->u.R1010.val.t = NULL;
  8942.       f->u.R1010.val.u.unsigned_val = 1;
  8943.       ffelex_set_names_pure (TRUE);    /* Have even free-form lexer give us
  8944.                        NAMES. */
  8945.       return (ffelexHandler) ffestb_R100112_;
  8946.  
  8947.     case FFELEX_typeEOS:
  8948.     case FFELEX_typeSEMICOLON:
  8949.     case FFELEX_typeCOMMA:
  8950.     case FFELEX_typeCOLONCOLON:
  8951.       ffesta_confirmed ();    /* Error, but clearly intended. */
  8952.       goto bad_1;        /* :::::::::::::::::::: */
  8953.  
  8954.     default:
  8955.       goto bad_1;        /* :::::::::::::::::::: */
  8956.     }
  8957.  
  8958. bad_0:                /* :::::::::::::::::::: */
  8959.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", ffesta_tokens[0]);
  8960.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  8961.  
  8962. bad_1:                /* :::::::::::::::::::: */
  8963.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
  8964.   return (ffelexHandler) ffelex_swallow_tokens (t,
  8965.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  8966. }
  8967.  
  8968. /* ffestb_R10011_ -- "FORMAT" OPEN_PAREN expr
  8969.  
  8970.    return ffestb_R10011_;  // to lexer
  8971.  
  8972.    For CLOSE_PAREN, wrap up the format list and if it is the top-level one,
  8973.    exit.  For anything else, pass it to _2_.  */
  8974.  
  8975. static ffelexHandler
  8976. ffestb_R10011_ (ffelexToken t)
  8977. {
  8978.   ffesttFormatList f;
  8979.  
  8980.   switch (ffelex_token_type (t))
  8981.     {
  8982.     case FFELEX_typeCLOSE_PAREN:
  8983.       break;
  8984.  
  8985.     default:
  8986.       return (ffelexHandler) ffestb_R10012_ (t);
  8987.     }
  8988.  
  8989.   /* If we have a format we're working on, continue working on it. */
  8990.  
  8991.   f = ffestb_local_.format.f->u.root.parent;
  8992.  
  8993.   if (f != NULL)
  8994.     {
  8995.       ffestb_local_.format.f = f->next;
  8996.       return (ffelexHandler) ffestb_R100111_;
  8997.     }
  8998.  
  8999.   return (ffelexHandler) ffestb_R100114_;
  9000. }
  9001.  
  9002. /* ffestb_R10012_ -- "FORMAT" OPEN_PAREN [format-item-list]
  9003.  
  9004.    return ffestb_R10012_;  // to lexer
  9005.  
  9006.    The initial state for a format-item.     Here, just handle the initial
  9007.    number, sign for number, or run-time expression.  Also handle spurious
  9008.    comma, close-paren (indicating spurious comma), close-array (like
  9009.    close-paren but preceded by slash), and quoted strings.  */
  9010.  
  9011. static ffelexHandler
  9012. ffestb_R10012_ (ffelexToken t)
  9013. {
  9014.   unsigned long unsigned_val;
  9015.   ffesttFormatList f;
  9016.  
  9017.   switch (ffelex_token_type (t))
  9018.     {
  9019.     case FFELEX_typeOPEN_ANGLE:
  9020.       ffesta_confirmed ();
  9021.       ffestb_local_.format.pre.t = ffelex_token_use (t);
  9022.       ffelex_set_names_pure (FALSE);
  9023.       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
  9024.     {
  9025.       ffestb_local_.format.complained = TRUE;
  9026.       ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
  9027.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  9028.       ffebad_finish ();
  9029.     }
  9030.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  9031.           FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100115_);
  9032.  
  9033.     case FFELEX_typeNUMBER:
  9034.       ffestb_local_.format.sign = FALSE;    /* No sign present. */
  9035.       ffestb_local_.format.pre.present = TRUE;
  9036.       ffestb_local_.format.pre.rtexpr = FALSE;
  9037.       ffestb_local_.format.pre.t = ffelex_token_use (t);
  9038.       ffestb_local_.format.pre.u.unsigned_val = unsigned_val
  9039.     = strtoul (ffelex_token_text (t), NULL, 10);
  9040.       ffelex_set_expecting_hollerith (unsigned_val, '\0',
  9041.                       ffelex_token_where_line (t),
  9042.                       ffelex_token_where_column (t));
  9043.       return (ffelexHandler) ffestb_R10014_;
  9044.  
  9045.     case FFELEX_typePLUS:
  9046.       ffestb_local_.format.sign = TRUE;    /* Positive. */
  9047.       ffestb_local_.format.pre.t = ffelex_token_use (t);
  9048.       return (ffelexHandler) ffestb_R10013_;
  9049.  
  9050.     case FFELEX_typeMINUS:
  9051.       ffestb_local_.format.sign = FALSE;    /* Negative. */
  9052.       ffestb_local_.format.pre.t = ffelex_token_use (t);
  9053.       return (ffelexHandler) ffestb_R10013_;
  9054.  
  9055.     case FFELEX_typeCOLON:
  9056.     case FFELEX_typeCOLONCOLON:/* "::". */
  9057.     case FFELEX_typeSLASH:
  9058.     case FFELEX_typeCONCAT:    /* "//". */
  9059.     case FFELEX_typeNAMES:
  9060.     case FFELEX_typeDOLLAR:
  9061.     case FFELEX_typeOPEN_PAREN:
  9062.     case FFELEX_typeOPEN_ARRAY:/* "(/". */
  9063.       ffestb_local_.format.sign = FALSE;    /* No sign present. */
  9064.       ffestb_local_.format.pre.present = FALSE;
  9065.       ffestb_local_.format.pre.rtexpr = FALSE;
  9066.       ffestb_local_.format.pre.t = NULL;
  9067.       ffestb_local_.format.pre.u.unsigned_val = 1;
  9068.       return (ffelexHandler) ffestb_R10014_ (t);
  9069.  
  9070.     case FFELEX_typeCOMMA:
  9071.       ffesta_confirmed ();
  9072.       ffebad_start (FFEBAD_FORMAT_EXTRA_COMMA);
  9073.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  9074.       ffebad_finish ();
  9075.       return (ffelexHandler) ffestb_R10012_;
  9076.  
  9077.     case FFELEX_typeCLOSE_PAREN:
  9078.       ffesta_confirmed ();
  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_not_90 ())
  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.sign = TRUE;    /* Sign present. */
  9158.       ffestb_local_.format.pre.present = TRUE;
  9159.       ffestb_local_.format.pre.rtexpr = FALSE;
  9160.       unsigned_val = strtoul (ffelex_token_text (t), NULL, 10);
  9161.       ffestb_local_.format.pre.u.signed_val = ffestb_local_.format.sign
  9162.     ? unsigned_val : -unsigned_val;
  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.   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 = 0; i < ffelex_token_length (t); ++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 = 0; i < ffelex_token_length (t); ++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.       /* Fall through. */
  9258.     case FFELEX_typeCOLON:
  9259.       if (ffestb_local_.format.pre.present)
  9260.     {
  9261.       ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_COLON_SPEC,
  9262.                 ffestb_local_.format.pre.t);
  9263.       ffelex_token_kill (ffestb_local_.format.pre.t);
  9264.       return (ffelexHandler) ffestb_R100112_;
  9265.     }
  9266.       f = ffestt_formatlist_append (ffestb_local_.format.f);
  9267.       f->type = FFESTP_formattypeCOLON;
  9268.       f->t = ffelex_token_use (t);
  9269.       f->u.R1010.val.present = FALSE;
  9270.       f->u.R1010.val.rtexpr = FALSE;
  9271.       f->u.R1010.val.t = NULL;
  9272.       f->u.R1010.val.u.unsigned_val = 1;
  9273.       return (ffelexHandler) ffestb_R100112_;
  9274.  
  9275.     case FFELEX_typeCONCAT:    /* "//". */
  9276.       f = ffestt_formatlist_append (ffestb_local_.format.f);
  9277.       f->type = FFESTP_formattypeSLASH;
  9278.       f->t = ffelex_token_use (t);
  9279.       f->u.R1010.val = ffestb_local_.format.pre;
  9280.       ffestb_local_.format.pre.present = FALSE;
  9281.       ffestb_local_.format.pre.rtexpr = FALSE;
  9282.       ffestb_local_.format.pre.t = NULL;
  9283.       ffestb_local_.format.pre.u.unsigned_val = 1;
  9284.       /* Fall through. */
  9285.     case FFELEX_typeSLASH:
  9286.       if (ffestb_local_.format.sign)
  9287.     {
  9288.       ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
  9289.       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
  9290.             ffelex_token_where_column (ffestb_local_.format.pre.t));
  9291.       ffebad_finish ();
  9292.       ffestb_local_.format.pre.u.unsigned_val
  9293.         = (ffestb_local_.format.pre.u.signed_val < 0)
  9294.         ? -ffestb_local_.format.pre.u.signed_val
  9295.         : ffestb_local_.format.pre.u.signed_val;
  9296.     }
  9297.       f = ffestt_formatlist_append (ffestb_local_.format.f);
  9298.       f->type = FFESTP_formattypeSLASH;
  9299.       f->t = ffelex_token_use (t);
  9300.       f->u.R1010.val = ffestb_local_.format.pre;
  9301.       return (ffelexHandler) ffestb_R100112_;
  9302.  
  9303.     case FFELEX_typeOPEN_PAREN:
  9304.       if (ffestb_local_.format.sign)
  9305.     {
  9306.       ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
  9307.       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
  9308.             ffelex_token_where_column (ffestb_local_.format.pre.t));
  9309.       ffebad_finish ();
  9310.       ffestb_local_.format.pre.u.unsigned_val
  9311.         = (ffestb_local_.format.pre.u.signed_val < 0)
  9312.         ? -ffestb_local_.format.pre.u.signed_val
  9313.         : ffestb_local_.format.pre.u.signed_val;
  9314.     }
  9315.       f = ffestt_formatlist_append (ffestb_local_.format.f);
  9316.       f->type = FFESTP_formattypeFORMAT;
  9317.       f->t = ffelex_token_use (t);
  9318.       f->u.R1003D.R1004 = ffestb_local_.format.pre;
  9319.       f->u.R1003D.format = ffestb_local_.format.f
  9320.     = ffestt_formatlist_create (f, ffelex_token_use (t));
  9321.       return (ffelexHandler) ffestb_R10011_;
  9322.  
  9323.     case FFELEX_typeOPEN_ARRAY:/* "(/". */
  9324.       if (ffestb_local_.format.sign)
  9325.     {
  9326.       ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
  9327.       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
  9328.             ffelex_token_where_column (ffestb_local_.format.pre.t));
  9329.       ffebad_finish ();
  9330.       ffestb_local_.format.pre.u.unsigned_val
  9331.         = (ffestb_local_.format.pre.u.signed_val < 0)
  9332.         ? -ffestb_local_.format.pre.u.signed_val
  9333.         : ffestb_local_.format.pre.u.signed_val;
  9334.     }
  9335.       f = ffestt_formatlist_append (ffestb_local_.format.f);
  9336.       f->type = FFESTP_formattypeFORMAT;
  9337.       f->t = ffelex_token_use (t);
  9338.       f->u.R1003D.R1004 = ffestb_local_.format.pre;
  9339.       f->u.R1003D.format = ffestb_local_.format.f
  9340.     = ffestt_formatlist_create (f, ffelex_token_use (t));
  9341.       f = ffestt_formatlist_append (ffestb_local_.format.f);
  9342.       f->type = FFESTP_formattypeSLASH;
  9343.       f->t = ffelex_token_use (t);
  9344.       f->u.R1010.val.present = FALSE;
  9345.       f->u.R1010.val.rtexpr = FALSE;
  9346.       f->u.R1010.val.t = NULL;
  9347.       f->u.R1010.val.u.unsigned_val = 1;
  9348.       return (ffelexHandler) ffestb_R100112_;
  9349.  
  9350.     case FFELEX_typeCLOSE_ARRAY:    /* "/)". */
  9351.       f = ffestt_formatlist_append (ffestb_local_.format.f);
  9352.       f->type = FFESTP_formattypeSLASH;
  9353.       f->t = ffelex_token_use (t);
  9354.       f->u.R1010.val = ffestb_local_.format.pre;
  9355.       f = ffestb_local_.format.f->u.root.parent;
  9356.       if (f == NULL)
  9357.     return (ffelexHandler) ffestb_R100114_;
  9358.       ffestb_local_.format.f = f->next;
  9359.       return (ffelexHandler) ffestb_R100111_;
  9360.  
  9361.     case FFELEX_typeQUOTE:
  9362.       if (ffe_is_vxt_not_90 ())
  9363.     break;            /* A totally bad character in a VXT FORMAT. */
  9364.       ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
  9365.       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
  9366.            ffelex_token_where_column (ffestb_local_.format.pre.t));
  9367.       ffebad_finish ();
  9368.       ffelex_token_kill (ffestb_local_.format.pre.t);
  9369.       ffesta_confirmed ();
  9370. #if 0                /* No apparent need for this, and not killed
  9371.                    anywhere. */
  9372.       ffesta_tokens[1] = ffelex_token_use (t);
  9373. #endif
  9374.       ffelex_set_expecting_hollerith (-1, '\"',
  9375.                       ffelex_token_where_line (t),
  9376.                       ffelex_token_where_column (t));    /* Don't have to unset
  9377.                                        this one. */
  9378.       return (ffelexHandler) ffestb_R100113_;
  9379.  
  9380.     case FFELEX_typeAPOSTROPHE:
  9381.       ffesta_confirmed ();
  9382.       ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
  9383.       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
  9384.            ffelex_token_where_column (ffestb_local_.format.pre.t));
  9385.       ffebad_finish ();
  9386.       ffelex_token_kill (ffestb_local_.format.pre.t);
  9387. #if 0                /* No apparent need for this, and not killed
  9388.                    anywhere. */
  9389.       ffesta_tokens[1] = ffelex_token_use (t);
  9390. #endif
  9391.       ffelex_set_expecting_hollerith (-1, '\'', ffelex_token_where_line (t),
  9392.                       ffelex_token_where_column (t));    /* Don't have to unset
  9393.                                        this one. */
  9394.       return (ffelexHandler) ffestb_R100113_;
  9395.  
  9396.     case FFELEX_typeEOS:
  9397.     case FFELEX_typeSEMICOLON:
  9398.       ffesta_confirmed ();
  9399.       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
  9400.       for (f = ffestb_local_.format.f;
  9401.        f->u.root.parent != NULL;
  9402.        f = f->u.root.parent->next)
  9403.     ;
  9404.       ffestb_local_.format.f = f;
  9405.       ffelex_token_kill (ffestb_local_.format.pre.t);
  9406.       return (ffelexHandler) ffestb_R100114_ (t);
  9407.  
  9408.     case FFELEX_typeDOLLAR:
  9409.       ffestb_local_.format.t = ffelex_token_use (t);
  9410.       if (ffestb_local_.format.pre.present)
  9411.     ffesta_confirmed ();    /* Number preceding this invalid elsewhere. */
  9412.       ffestb_local_.format.current = FFESTP_formattypeDOLLAR;
  9413.       return (ffelexHandler) ffestb_R10015_;
  9414.  
  9415.     case FFELEX_typeNAMES:
  9416.       kw = ffestr_format (t);
  9417.       ffestb_local_.format.t = ffelex_token_use (t);
  9418.       switch (kw)
  9419.     {
  9420.     case FFESTR_formatI:
  9421.       if (ffestb_local_.format.pre.present)
  9422.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9423.       ffestb_local_.format.current = FFESTP_formattypeI;
  9424.       i = FFESTR_formatlI;
  9425.       break;
  9426.  
  9427.     case FFESTR_formatB:
  9428.       if (ffestb_local_.format.pre.present)
  9429.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9430.       ffestb_local_.format.current = FFESTP_formattypeB;
  9431.       i = FFESTR_formatlB;
  9432.       break;
  9433.  
  9434.     case FFESTR_formatO:
  9435.       if (ffestb_local_.format.pre.present)
  9436.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9437.       ffestb_local_.format.current = FFESTP_formattypeO;
  9438.       i = FFESTR_formatlO;
  9439.       break;
  9440.  
  9441.     case FFESTR_formatZ:
  9442.       if (ffestb_local_.format.pre.present)
  9443.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9444.       ffestb_local_.format.current = FFESTP_formattypeZ;
  9445.       i = FFESTR_formatlZ;
  9446.       break;
  9447.  
  9448.     case FFESTR_formatF:
  9449.       if (ffestb_local_.format.pre.present)
  9450.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9451.       ffestb_local_.format.current = FFESTP_formattypeF;
  9452.       i = FFESTR_formatlF;
  9453.       break;
  9454.  
  9455.     case FFESTR_formatE:
  9456.       ffestb_local_.format.current = FFESTP_formattypeE;
  9457.       i = FFESTR_formatlE;
  9458.       break;
  9459.  
  9460.     case FFESTR_formatEN:
  9461.       if (ffestb_local_.format.pre.present)
  9462.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9463.       ffestb_local_.format.current = FFESTP_formattypeEN;
  9464.       i = FFESTR_formatlEN;
  9465.       break;
  9466.  
  9467.     case FFESTR_formatG:
  9468.       if (ffestb_local_.format.pre.present)
  9469.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9470.       ffestb_local_.format.current = FFESTP_formattypeG;
  9471.       i = FFESTR_formatlG;
  9472.       break;
  9473.  
  9474.     case FFESTR_formatL:
  9475.       if (ffestb_local_.format.pre.present)
  9476.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9477.       ffestb_local_.format.current = FFESTP_formattypeL;
  9478.       i = FFESTR_formatlL;
  9479.       break;
  9480.  
  9481.     case FFESTR_formatA:
  9482.       if (ffestb_local_.format.pre.present)
  9483.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9484.       ffestb_local_.format.current = FFESTP_formattypeA;
  9485.       i = FFESTR_formatlA;
  9486.       break;
  9487.  
  9488.     case FFESTR_formatD:
  9489.       ffestb_local_.format.current = FFESTP_formattypeD;
  9490.       i = FFESTR_formatlD;
  9491.       break;
  9492.  
  9493.     case FFESTR_formatQ:
  9494.       ffestb_local_.format.current = FFESTP_formattypeQ;
  9495.       i = FFESTR_formatlQ;
  9496.       break;
  9497.  
  9498.     case FFESTR_formatDOLLAR:
  9499.       if (ffestb_local_.format.pre.present)
  9500.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9501.       ffestb_local_.format.current = FFESTP_formattypeDOLLAR;
  9502.       i = FFESTR_formatlDOLLAR;
  9503.       break;
  9504.  
  9505.     case FFESTR_formatP:
  9506.       if (ffestb_local_.format.pre.present)
  9507.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9508.       ffestb_local_.format.current = FFESTP_formattypeP;
  9509.       i = FFESTR_formatlP;
  9510.       break;
  9511.  
  9512.     case FFESTR_formatT:
  9513.       if (ffestb_local_.format.pre.present)
  9514.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9515.       ffestb_local_.format.current = FFESTP_formattypeT;
  9516.       i = FFESTR_formatlT;
  9517.       break;
  9518.  
  9519.     case FFESTR_formatTL:
  9520.       if (ffestb_local_.format.pre.present)
  9521.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9522.       ffestb_local_.format.current = FFESTP_formattypeTL;
  9523.       i = FFESTR_formatlTL;
  9524.       break;
  9525.  
  9526.     case FFESTR_formatTR:
  9527.       if (ffestb_local_.format.pre.present)
  9528.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9529.       ffestb_local_.format.current = FFESTP_formattypeTR;
  9530.       i = FFESTR_formatlTR;
  9531.       break;
  9532.  
  9533.     case FFESTR_formatX:
  9534.       if (ffestb_local_.format.pre.present)
  9535.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9536.       ffestb_local_.format.current = FFESTP_formattypeX;
  9537.       i = FFESTR_formatlX;
  9538.       break;
  9539.  
  9540.     case FFESTR_formatS:
  9541.       if (ffestb_local_.format.pre.present)
  9542.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9543.       ffestb_local_.format.current = FFESTP_formattypeS;
  9544.       i = FFESTR_formatlS;
  9545.       break;
  9546.  
  9547.     case FFESTR_formatSP:
  9548.       if (ffestb_local_.format.pre.present)
  9549.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9550.       ffestb_local_.format.current = FFESTP_formattypeSP;
  9551.       i = FFESTR_formatlSP;
  9552.       break;
  9553.  
  9554.     case FFESTR_formatSS:
  9555.       if (ffestb_local_.format.pre.present)
  9556.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9557.       ffestb_local_.format.current = FFESTP_formattypeSS;
  9558.       i = FFESTR_formatlSS;
  9559.       break;
  9560.  
  9561.     case FFESTR_formatBN:
  9562.       if (ffestb_local_.format.pre.present)
  9563.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9564.       ffestb_local_.format.current = FFESTP_formattypeBN;
  9565.       i = FFESTR_formatlBN;
  9566.       break;
  9567.  
  9568.     case FFESTR_formatBZ:
  9569.       if (ffestb_local_.format.pre.present)
  9570.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9571.       ffestb_local_.format.current = FFESTP_formattypeBZ;
  9572.       i = FFESTR_formatlBZ;
  9573.       break;
  9574.  
  9575.     case FFESTR_formatH:    /* Error, either "H" or "<expr>H". */
  9576.       if (ffestb_local_.format.pre.present)
  9577.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9578.       ffestb_local_.format.current = FFESTP_formattypeH;
  9579.       i = FFESTR_formatlH;
  9580.       break;
  9581.  
  9582.     case FFESTR_formatPD:
  9583.       if (ffestb_local_.format.pre.present)
  9584.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9585.       ffestb_subr_R1001_append_p_ ();
  9586.       ffestb_local_.format.t = ffelex_token_name_from_names (t,
  9587.                             FFESTR_formatlP, 1);
  9588.       ffestb_local_.format.sign = FALSE;
  9589.       ffestb_local_.format.pre.present = FALSE;
  9590.       ffestb_local_.format.pre.rtexpr = FALSE;
  9591.       ffestb_local_.format.pre.t = NULL;
  9592.       ffestb_local_.format.pre.u.unsigned_val = 1;
  9593.       ffestb_local_.format.current = FFESTP_formattypeD;
  9594.       i = FFESTR_formatlPD;
  9595.       break;
  9596.  
  9597.     case FFESTR_formatPE:
  9598.       if (ffestb_local_.format.pre.present)
  9599.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9600.       ffestb_subr_R1001_append_p_ ();
  9601.       ffestb_local_.format.t = ffelex_token_name_from_names (t,
  9602.                             FFESTR_formatlP, 1);
  9603.       ffestb_local_.format.sign = FALSE;
  9604.       ffestb_local_.format.pre.present = FALSE;
  9605.       ffestb_local_.format.pre.rtexpr = FALSE;
  9606.       ffestb_local_.format.pre.t = NULL;
  9607.       ffestb_local_.format.pre.u.unsigned_val = 1;
  9608.       ffestb_local_.format.current = FFESTP_formattypeE;
  9609.       i = FFESTR_formatlPE;
  9610.       break;
  9611.  
  9612.     case FFESTR_formatPEN:
  9613.       if (ffestb_local_.format.pre.present)
  9614.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9615.       ffestb_subr_R1001_append_p_ ();
  9616.       ffestb_local_.format.t = ffelex_token_name_from_names (t,
  9617.                             FFESTR_formatlP, 1);
  9618.       ffestb_local_.format.sign = FALSE;
  9619.       ffestb_local_.format.pre.present = FALSE;
  9620.       ffestb_local_.format.pre.rtexpr = FALSE;
  9621.       ffestb_local_.format.pre.t = NULL;
  9622.       ffestb_local_.format.pre.u.unsigned_val = 1;
  9623.       ffestb_local_.format.current = FFESTP_formattypeEN;
  9624.       i = FFESTR_formatlPEN;
  9625.       break;
  9626.  
  9627.     case FFESTR_formatPF:
  9628.       if (ffestb_local_.format.pre.present)
  9629.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9630.       ffestb_subr_R1001_append_p_ ();
  9631.       ffestb_local_.format.t = ffelex_token_name_from_names (t,
  9632.                             FFESTR_formatlP, 1);
  9633.       ffestb_local_.format.sign = FALSE;
  9634.       ffestb_local_.format.pre.present = FALSE;
  9635.       ffestb_local_.format.pre.rtexpr = FALSE;
  9636.       ffestb_local_.format.pre.t = NULL;
  9637.       ffestb_local_.format.pre.u.unsigned_val = 1;
  9638.       ffestb_local_.format.current = FFESTP_formattypeF;
  9639.       i = FFESTR_formatlPF;
  9640.       break;
  9641.  
  9642.     case FFESTR_formatPG:
  9643.       if (ffestb_local_.format.pre.present)
  9644.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9645.       ffestb_subr_R1001_append_p_ ();
  9646.       ffestb_local_.format.t = ffelex_token_name_from_names (t,
  9647.                             FFESTR_formatlP, 1);
  9648.       ffestb_local_.format.sign = FALSE;
  9649.       ffestb_local_.format.pre.present = FALSE;
  9650.       ffestb_local_.format.pre.rtexpr = FALSE;
  9651.       ffestb_local_.format.pre.t = NULL;
  9652.       ffestb_local_.format.pre.u.unsigned_val = 1;
  9653.       ffestb_local_.format.current = FFESTP_formattypeG;
  9654.       i = FFESTR_formatlPG;
  9655.       break;
  9656.  
  9657.     default:
  9658.       if (ffestb_local_.format.pre.present)
  9659.         ffesta_confirmed ();/* Number preceding this invalid elsewhere. */
  9660.       ffestb_local_.format.current = FFESTP_formattypeNone;
  9661.       p = strpbrk (ffelex_token_text (t), "0123456789");
  9662.       if (p == NULL)
  9663.         i = ffelex_token_length (t);
  9664.       else
  9665.         i = p - ffelex_token_text (t);
  9666.       break;
  9667.     }
  9668.       p = ffelex_token_text (t) + i;
  9669.       if (*p == '\0')
  9670.     return (ffelexHandler) ffestb_R10015_;
  9671.       if (!isdigit (*p))
  9672.     {
  9673.       if (ffestb_local_.format.current != FFESTP_formattypeH)
  9674.         ffestb_local_.format.current = FFESTP_formattypeNone;
  9675.       p = strpbrk (p, "0123456789");
  9676.       if (p == NULL)
  9677.         return (ffelexHandler) ffestb_R10015_;
  9678.       i = p - ffelex_token_text (t);    /* Collect digits anyway. */
  9679.     }
  9680.       ffestb_local_.format.post.present = TRUE;
  9681.       ffestb_local_.format.post.rtexpr = FALSE;
  9682.       ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
  9683.       ffestb_local_.format.post.u.unsigned_val
  9684.     = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
  9685.       p += ffelex_token_length (ffestb_local_.format.post.t);
  9686.       i += ffelex_token_length (ffestb_local_.format.post.t);
  9687.       if (*p == '\0')
  9688.     return (ffelexHandler) ffestb_R10016_;
  9689.       if ((kw != FFESTR_formatP) || !ffelex_is_firstnamechar (*p))
  9690.     {
  9691.       if (ffestb_local_.format.current != FFESTP_formattypeH)
  9692.         ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
  9693.       return (ffelexHandler) ffestb_R10016_;
  9694.     }
  9695.  
  9696.       /* Here we have [number]P[number][text].    Treat as
  9697.          [number]P,[number][text]. */
  9698.  
  9699.       ffestb_subr_R1001_append_p_ ();
  9700.       t = ffestb_local_.format.t = ffelex_token_names_from_names (t, i, 0);
  9701.       ffestb_local_.format.sign = FALSE;
  9702.       ffestb_local_.format.pre = ffestb_local_.format.post;
  9703.       kw = ffestr_format (t);
  9704.       switch (kw)
  9705.     {            /* Only a few possibilities here. */
  9706.     case FFESTR_formatD:
  9707.       ffestb_local_.format.current = FFESTP_formattypeD;
  9708.       i = FFESTR_formatlD;
  9709.       break;
  9710.  
  9711.     case FFESTR_formatE:
  9712.       ffestb_local_.format.current = FFESTP_formattypeE;
  9713.       i = FFESTR_formatlE;
  9714.       break;
  9715.  
  9716.     case FFESTR_formatEN:
  9717.       ffestb_local_.format.current = FFESTP_formattypeEN;
  9718.       i = FFESTR_formatlEN;
  9719.       break;
  9720.  
  9721.     case FFESTR_formatF:
  9722.       ffestb_local_.format.current = FFESTP_formattypeF;
  9723.       i = FFESTR_formatlF;
  9724.       break;
  9725.  
  9726.     case FFESTR_formatG:
  9727.       ffestb_local_.format.current = FFESTP_formattypeG;
  9728.       i = FFESTR_formatlG;
  9729.       break;
  9730.  
  9731.     default:
  9732.       ffebad_start (FFEBAD_FORMAT_P_NOCOMMA);
  9733.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  9734.       ffebad_finish ();
  9735.       ffestb_local_.format.current = FFESTP_formattypeNone;
  9736.       p = strpbrk (ffelex_token_text (t), "0123456789");
  9737.       if (p == NULL)
  9738.         i = ffelex_token_length (t);
  9739.       else
  9740.         i = p - ffelex_token_text (t);
  9741.     }
  9742.       p = ffelex_token_text (t) + i;
  9743.       if (*p == '\0')
  9744.     return (ffelexHandler) ffestb_R10015_;
  9745.       if (!isdigit (*p))
  9746.     {
  9747.       ffestb_local_.format.current = FFESTP_formattypeNone;
  9748.       p = strpbrk (p, "0123456789");
  9749.       if (p == NULL)
  9750.         return (ffelexHandler) ffestb_R10015_;
  9751.       i = p - ffelex_token_text (t);    /* Collect digits anyway. */
  9752.     }
  9753.       ffestb_local_.format.post.present = TRUE;
  9754.       ffestb_local_.format.post.rtexpr = FALSE;
  9755.       ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
  9756.       ffestb_local_.format.post.u.unsigned_val
  9757.     = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
  9758.       p += ffelex_token_length (ffestb_local_.format.post.t);
  9759.       i += ffelex_token_length (ffestb_local_.format.post.t);
  9760.       if (*p == '\0')
  9761.     return (ffelexHandler) ffestb_R10016_;
  9762.       ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
  9763.       return (ffelexHandler) ffestb_R10016_;
  9764.  
  9765.     default:
  9766.       break;
  9767.     }
  9768.  
  9769.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
  9770.   if (ffestb_local_.format.pre.present)
  9771.     ffelex_token_kill (ffestb_local_.format.pre.t);
  9772.   ffestt_formatlist_kill (ffestb_local_.format.f);
  9773.   return (ffelexHandler) ffelex_swallow_tokens (t,
  9774.                         (ffelexHandler) ffesta_zero);
  9775. }
  9776.  
  9777. /* ffestb_R10015_ -- [[+/-] NUMBER] NAMES
  9778.  
  9779.    return ffestb_R10015_;  // to lexer
  9780.  
  9781.    Here we've gotten at least the initial mnemonic for the edit descriptor.
  9782.    We expect either a NUMBER, for the post-mnemonic value, a NAMES, for
  9783.    further clarification (in free-form only, sigh) of the mnemonic, or
  9784.    anything else.  In all cases we go to _6_, with the difference that for
  9785.    NUMBER and NAMES we send the next token rather than the current token.  */
  9786.  
  9787. static ffelexHandler
  9788. ffestb_R10015_ (ffelexToken t)
  9789. {
  9790.   bool split_pea;        /* New NAMES requires splitting kP from new
  9791.                    edit desc. */
  9792.   ffestrFormat kw;
  9793.   char *p;
  9794.   ffeTokenLength i;
  9795.  
  9796.   switch (ffelex_token_type (t))
  9797.     {
  9798.     case FFELEX_typeOPEN_ANGLE:
  9799.       ffesta_confirmed ();
  9800.       ffestb_local_.format.post.t = ffelex_token_use (t);
  9801.       ffelex_set_names_pure (FALSE);
  9802.       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
  9803.     {
  9804.       ffestb_local_.format.complained = TRUE;
  9805.       ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
  9806.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  9807.       ffebad_finish ();
  9808.     }
  9809.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  9810.           FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100116_);
  9811.  
  9812.     case FFELEX_typeNUMBER:
  9813.       ffestb_local_.format.post.present = TRUE;
  9814.       ffestb_local_.format.post.rtexpr = FALSE;
  9815.       ffestb_local_.format.post.t = ffelex_token_use (t);
  9816.       ffestb_local_.format.post.u.unsigned_val
  9817.     = strtoul (ffelex_token_text (t), NULL, 10);
  9818.       return (ffelexHandler) ffestb_R10016_;
  9819.  
  9820.     case FFELEX_typeNAMES:
  9821.       ffesta_confirmed ();    /* NAMES " " NAMES invalid elsewhere in
  9822.                    free-form. */
  9823.       kw = ffestr_format (t);
  9824.       switch (ffestb_local_.format.current)
  9825.     {
  9826.     case FFESTP_formattypeP:
  9827.       split_pea = TRUE;
  9828.       break;
  9829.  
  9830.     case FFESTP_formattypeH:    /* An error, maintain this indicator. */
  9831.       kw = FFESTR_formatNone;
  9832.       split_pea = FALSE;
  9833.       break;
  9834.  
  9835.     default:
  9836.       split_pea = FALSE;
  9837.       break;
  9838.     }
  9839.  
  9840.       switch (kw)
  9841.     {
  9842.     case FFESTR_formatF:
  9843.       switch (ffestb_local_.format.current)
  9844.         {
  9845.         case FFESTP_formattypeP:
  9846.           ffestb_local_.format.current = FFESTP_formattypeF;
  9847.           break;
  9848.  
  9849.         default:
  9850.           ffestb_local_.format.current = FFESTP_formattypeNone;
  9851.           break;
  9852.         }
  9853.       i = FFESTR_formatlF;
  9854.       break;
  9855.  
  9856.     case FFESTR_formatE:
  9857.       switch (ffestb_local_.format.current)
  9858.         {
  9859.         case FFESTP_formattypeP:
  9860.           ffestb_local_.format.current = FFESTP_formattypeE;
  9861.           break;
  9862.  
  9863.         default:
  9864.           ffestb_local_.format.current = FFESTP_formattypeNone;
  9865.           break;
  9866.         }
  9867.       i = FFESTR_formatlE;
  9868.       break;
  9869.  
  9870.     case FFESTR_formatEN:
  9871.       switch (ffestb_local_.format.current)
  9872.         {
  9873.         case FFESTP_formattypeP:
  9874.           ffestb_local_.format.current = FFESTP_formattypeEN;
  9875.           break;
  9876.  
  9877.         default:
  9878.           ffestb_local_.format.current = FFESTP_formattypeNone;
  9879.           break;
  9880.         }
  9881.       i = FFESTR_formatlEN;
  9882.       break;
  9883.  
  9884.     case FFESTR_formatG:
  9885.       switch (ffestb_local_.format.current)
  9886.         {
  9887.         case FFESTP_formattypeP:
  9888.           ffestb_local_.format.current = FFESTP_formattypeG;
  9889.           break;
  9890.  
  9891.         default:
  9892.           ffestb_local_.format.current = FFESTP_formattypeNone;
  9893.           break;
  9894.         }
  9895.       i = FFESTR_formatlG;
  9896.       break;
  9897.  
  9898.     case FFESTR_formatL:
  9899.       switch (ffestb_local_.format.current)
  9900.         {
  9901.         case FFESTP_formattypeT:
  9902.           ffestb_local_.format.current = FFESTP_formattypeTL;
  9903.           break;
  9904.  
  9905.         default:
  9906.           ffestb_local_.format.current = FFESTP_formattypeNone;
  9907.           break;
  9908.         }
  9909.       i = FFESTR_formatlL;
  9910.       break;
  9911.  
  9912.     case FFESTR_formatD:
  9913.       switch (ffestb_local_.format.current)
  9914.         {
  9915.         case FFESTP_formattypeP:
  9916.           ffestb_local_.format.current = FFESTP_formattypeD;
  9917.           break;
  9918.  
  9919.         default:
  9920.           ffestb_local_.format.current = FFESTP_formattypeNone;
  9921.           break;
  9922.         }
  9923.       i = FFESTR_formatlD;
  9924.       break;
  9925.  
  9926.     case FFESTR_formatS:
  9927.       switch (ffestb_local_.format.current)
  9928.         {
  9929.         case FFESTP_formattypeS:
  9930.           ffestb_local_.format.current = FFESTP_formattypeSS;
  9931.           break;
  9932.  
  9933.         default:
  9934.           ffestb_local_.format.current = FFESTP_formattypeNone;
  9935.           break;
  9936.         }
  9937.       i = FFESTR_formatlS;
  9938.       break;
  9939.  
  9940.     case FFESTR_formatP:
  9941.       switch (ffestb_local_.format.current)
  9942.         {
  9943.         case FFESTP_formattypeS:
  9944.           ffestb_local_.format.current = FFESTP_formattypeSP;
  9945.           break;
  9946.  
  9947.         default:
  9948.           ffestb_local_.format.current = FFESTP_formattypeNone;
  9949.           break;
  9950.         }
  9951.       i = FFESTR_formatlP;
  9952.       break;
  9953.  
  9954.     case FFESTR_formatR:
  9955.       switch (ffestb_local_.format.current)
  9956.         {
  9957.         case FFESTP_formattypeT:
  9958.           ffestb_local_.format.current = FFESTP_formattypeTR;
  9959.           break;
  9960.  
  9961.         default:
  9962.           ffestb_local_.format.current = FFESTP_formattypeNone;
  9963.           break;
  9964.         }
  9965.       i = FFESTR_formatlR;
  9966.       break;
  9967.  
  9968.     case FFESTR_formatZ:
  9969.       switch (ffestb_local_.format.current)
  9970.         {
  9971.         case FFESTP_formattypeB:
  9972.           ffestb_local_.format.current = FFESTP_formattypeBZ;
  9973.           break;
  9974.  
  9975.         default:
  9976.           ffestb_local_.format.current = FFESTP_formattypeNone;
  9977.           break;
  9978.         }
  9979.       i = FFESTR_formatlZ;
  9980.       break;
  9981.  
  9982.     case FFESTR_formatN:
  9983.       switch (ffestb_local_.format.current)
  9984.         {
  9985.         case FFESTP_formattypeE:
  9986.           ffestb_local_.format.current = FFESTP_formattypeEN;
  9987.           break;
  9988.  
  9989.         case FFESTP_formattypeB:
  9990.           ffestb_local_.format.current = FFESTP_formattypeBN;
  9991.           break;
  9992.  
  9993.         default:
  9994.           ffestb_local_.format.current = FFESTP_formattypeNone;
  9995.           break;
  9996.         }
  9997.       i = FFESTR_formatlN;
  9998.       break;
  9999.  
  10000.     default:
  10001.       if (ffestb_local_.format.current != FFESTP_formattypeH)
  10002.         ffestb_local_.format.current = FFESTP_formattypeNone;
  10003.       split_pea = FALSE;    /* Go ahead and let the P be in the party. */
  10004.       p = strpbrk (ffelex_token_text (t), "0123456789");
  10005.       if (p == NULL)
  10006.         i = ffelex_token_length (t);
  10007.       else
  10008.         i = p - ffelex_token_text (t);
  10009.     }
  10010.  
  10011.       if (split_pea)
  10012.     {
  10013.       ffestb_subr_R1001_append_p_ ();
  10014.       ffestb_local_.format.t = ffelex_token_use (t);
  10015.       ffestb_local_.format.sign = FALSE;
  10016.       ffestb_local_.format.pre.present = FALSE;
  10017.       ffestb_local_.format.pre.rtexpr = FALSE;
  10018.       ffestb_local_.format.pre.t = NULL;
  10019.       ffestb_local_.format.pre.u.unsigned_val = 1;
  10020.     }
  10021.  
  10022.       p = ffelex_token_text (t) + i;
  10023.       if (*p == '\0')
  10024.     return (ffelexHandler) ffestb_R10015_;
  10025.       if (!isdigit (*p))
  10026.     {
  10027.       ffestb_local_.format.current = FFESTP_formattypeNone;
  10028.       p = strpbrk (p, "0123456789");
  10029.       if (p == NULL)
  10030.         return (ffelexHandler) ffestb_R10015_;
  10031.       i = p - ffelex_token_text (t);    /* Collect digits anyway. */
  10032.     }
  10033.       ffestb_local_.format.post.present = TRUE;
  10034.       ffestb_local_.format.post.rtexpr = FALSE;
  10035.       ffestb_local_.format.post.t = ffelex_token_number_from_names (t, i);
  10036.       ffestb_local_.format.post.u.unsigned_val
  10037.     = strtoul (ffelex_token_text (ffestb_local_.format.post.t), NULL, 10);
  10038.       p += ffelex_token_length (ffestb_local_.format.post.t);
  10039.       i += ffelex_token_length (ffestb_local_.format.post.t);
  10040.       if (*p == '\0')
  10041.     return (ffelexHandler) ffestb_R10016_;
  10042.       ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
  10043.       return (ffelexHandler) ffestb_R10016_;
  10044.  
  10045.     default:
  10046.       ffestb_local_.format.post.present = FALSE;
  10047.       ffestb_local_.format.post.rtexpr = FALSE;
  10048.       ffestb_local_.format.post.t = NULL;
  10049.       ffestb_local_.format.post.u.unsigned_val = 1;
  10050.       return (ffelexHandler) ffestb_R10016_ (t);
  10051.     }
  10052. }
  10053.  
  10054. /* ffestb_R10016_ -- [[+/-] NUMBER] NAMES NUMBER
  10055.  
  10056.    return ffestb_R10016_;  // to lexer
  10057.  
  10058.    Expect a PERIOD here.  Maybe find a NUMBER to append to the current
  10059.    number, in which case return to this state.    Maybe find a NAMES to switch
  10060.    from a kP descriptor to a new descriptor (else the NAMES is spurious),
  10061.    in which case generator the P item and go to state _4_.  Anything
  10062.    else, pass token on to state _8_.  */
  10063.  
  10064. static ffelexHandler
  10065. ffestb_R10016_ (ffelexToken t)
  10066. {
  10067.   ffeTokenLength i;
  10068.  
  10069.   switch (ffelex_token_type (t))
  10070.     {
  10071.     case FFELEX_typePERIOD:
  10072.       return (ffelexHandler) ffestb_R10017_;
  10073.  
  10074.     case FFELEX_typeNUMBER:
  10075.       assert (ffestb_local_.format.post.present);
  10076.       ffesta_confirmed ();
  10077.       if (ffestb_local_.format.post.rtexpr)
  10078.     {
  10079.       ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
  10080.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  10081.       ffebad_finish ();
  10082.       return (ffelexHandler) ffestb_R10016_;
  10083.     }
  10084.       for (i = 0; i < ffelex_token_length (t); ++i)
  10085.     ffestb_local_.format.post.u.unsigned_val *= 10;
  10086.       ffestb_local_.format.post.u.unsigned_val += strtoul (ffelex_token_text (t),
  10087.                                NULL, 10);
  10088.       return (ffelexHandler) ffestb_R10016_;
  10089.  
  10090.     case FFELEX_typeNAMES:
  10091.       ffesta_confirmed ();    /* NUMBER " " NAMES invalid elsewhere. */
  10092.       if (ffestb_local_.format.current != FFESTP_formattypeP)
  10093.     {
  10094.       ffesta_ffebad_1t (FFEBAD_FORMAT_TEXT_IN_NUMBER, t);
  10095.       return (ffelexHandler) ffestb_R10016_;
  10096.     }
  10097.       ffestb_subr_R1001_append_p_ ();
  10098.       ffestb_local_.format.sign = FALSE;
  10099.       ffestb_local_.format.pre = ffestb_local_.format.post;
  10100.       return (ffelexHandler) ffestb_R10014_ (t);
  10101.  
  10102.     default:
  10103.       ffestb_local_.format.dot.present = FALSE;
  10104.       ffestb_local_.format.dot.rtexpr = FALSE;
  10105.       ffestb_local_.format.dot.t = NULL;
  10106.       ffestb_local_.format.dot.u.unsigned_val = 1;
  10107.       return (ffelexHandler) ffestb_R10018_ (t);
  10108.     }
  10109. }
  10110.  
  10111. /* ffestb_R10017_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD
  10112.  
  10113.    return ffestb_R10017_;  // to lexer
  10114.  
  10115.    Here we've gotten the period following the edit descriptor.
  10116.    We expect either a NUMBER, for the dot value, or something else, which
  10117.    probably means we're not even close to being in a real FORMAT statement.  */
  10118.  
  10119. static ffelexHandler
  10120. ffestb_R10017_ (ffelexToken t)
  10121. {
  10122.   switch (ffelex_token_type (t))
  10123.     {
  10124.     case FFELEX_typeOPEN_ANGLE:
  10125.       ffestb_local_.format.dot.t = ffelex_token_use (t);
  10126.       ffelex_set_names_pure (FALSE);
  10127.       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
  10128.     {
  10129.       ffestb_local_.format.complained = TRUE;
  10130.       ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
  10131.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  10132.       ffebad_finish ();
  10133.     }
  10134.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  10135.           FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100117_);
  10136.  
  10137.     case FFELEX_typeNUMBER:
  10138.       ffestb_local_.format.dot.present = TRUE;
  10139.       ffestb_local_.format.dot.rtexpr = FALSE;
  10140.       ffestb_local_.format.dot.t = ffelex_token_use (t);
  10141.       ffestb_local_.format.dot.u.unsigned_val
  10142.     = strtoul (ffelex_token_text (t), NULL, 10);
  10143.       return (ffelexHandler) ffestb_R10018_;
  10144.  
  10145.     default:
  10146.       ffelex_token_kill (ffestb_local_.format.t);
  10147.       if (ffestb_local_.format.pre.present)
  10148.     ffelex_token_kill (ffestb_local_.format.pre.t);
  10149.       if (ffestb_local_.format.post.present)
  10150.     ffelex_token_kill (ffestb_local_.format.post.t);
  10151.       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_DOT, t);
  10152.       ffestt_formatlist_kill (ffestb_local_.format.f);
  10153.       return (ffelexHandler) ffelex_swallow_tokens (t,
  10154.                            (ffelexHandler) ffesta_zero);
  10155.     }
  10156. }
  10157.  
  10158. /* ffestb_R10018_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD NUMBER
  10159.  
  10160.    return ffestb_R10018_;  // to lexer
  10161.  
  10162.    Expect a NAMES here, which must begin with "E" to be valid.    Maybe find a
  10163.    NUMBER to append to the current number, in which case return to this state.
  10164.    Anything else, pass token on to state _10_.    */
  10165.  
  10166. static ffelexHandler
  10167. ffestb_R10018_ (ffelexToken t)
  10168. {
  10169.   ffeTokenLength i;
  10170.   char *p;
  10171.  
  10172.   switch (ffelex_token_type (t))
  10173.     {
  10174.     case FFELEX_typeNUMBER:
  10175.       assert (ffestb_local_.format.dot.present);
  10176.       ffesta_confirmed ();
  10177.       if (ffestb_local_.format.dot.rtexpr)
  10178.     {
  10179.       ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
  10180.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  10181.       ffebad_finish ();
  10182.       return (ffelexHandler) ffestb_R10018_;
  10183.     }
  10184.       for (i = 0; i < ffelex_token_length (t); ++i)
  10185.     ffestb_local_.format.dot.u.unsigned_val *= 10;
  10186.       ffestb_local_.format.dot.u.unsigned_val += strtoul (ffelex_token_text (t),
  10187.                               NULL, 10);
  10188.       return (ffelexHandler) ffestb_R10018_;
  10189.  
  10190.     case FFELEX_typeNAMES:
  10191.       if (!ffesrc_char_match_init (*(p = ffelex_token_text (t)), 'E', 'e'))
  10192.     {
  10193.       ffesta_ffebad_1t (FFEBAD_FORMAT_TEXT_IN_NUMBER, t);
  10194.       return (ffelexHandler) ffestb_R10018_;
  10195.     }
  10196.       if (*++p == '\0')
  10197.     return (ffelexHandler) ffestb_R10019_;    /* Go get NUMBER. */
  10198.       i = 1;
  10199.       if (!isdigit (*p))
  10200.     {
  10201.       ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, 1, NULL);
  10202.       return (ffelexHandler) ffestb_R10018_;
  10203.     }
  10204.       ffestb_local_.format.exp.present = TRUE;
  10205.       ffestb_local_.format.exp.rtexpr = FALSE;
  10206.       ffestb_local_.format.exp.t = ffelex_token_number_from_names (t, i);
  10207.       ffestb_local_.format.exp.u.unsigned_val
  10208.     = strtoul (ffelex_token_text (ffestb_local_.format.exp.t), NULL, 10);
  10209.       p += ffelex_token_length (ffestb_local_.format.exp.t);
  10210.       i += ffelex_token_length (ffestb_local_.format.exp.t);
  10211.       if (*p == '\0')
  10212.     return (ffelexHandler) ffestb_R100110_;
  10213.       ffesta_ffebad_1p (FFEBAD_FORMAT_TEXT_IN_NUMBER, t, i, NULL);
  10214.       return (ffelexHandler) ffestb_R100110_;
  10215.  
  10216.     default:
  10217.       ffestb_local_.format.exp.present = FALSE;
  10218.       ffestb_local_.format.exp.rtexpr = FALSE;
  10219.       ffestb_local_.format.exp.t = NULL;
  10220.       ffestb_local_.format.exp.u.unsigned_val = 1;
  10221.       return (ffelexHandler) ffestb_R100110_ (t);
  10222.     }
  10223. }
  10224.  
  10225. /* ffestb_R10019_ -- [[+/-] NUMBER] NAMES NUMBER PERIOD NUMBER "E"
  10226.  
  10227.    return ffestb_R10019_;  // to lexer
  10228.  
  10229.    Here we've gotten the "E" following the edit descriptor.
  10230.    We expect either a NUMBER, for the exponent value, or something else.  */
  10231.  
  10232. static ffelexHandler
  10233. ffestb_R10019_ (ffelexToken t)
  10234. {
  10235.   switch (ffelex_token_type (t))
  10236.     {
  10237.     case FFELEX_typeOPEN_ANGLE:
  10238.       ffestb_local_.format.exp.t = ffelex_token_use (t);
  10239.       ffelex_set_names_pure (FALSE);
  10240.       if (!ffesta_seen_first_exec && !ffestb_local_.format.complained)
  10241.     {
  10242.       ffestb_local_.format.complained = TRUE;
  10243.       ffebad_start (FFEBAD_FORMAT_EXPR_SPEC);
  10244.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  10245.       ffebad_finish ();
  10246.     }
  10247.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  10248.           FFEEXPR_contextFORMAT, (ffeexprCallback) ffestb_R100118_);
  10249.  
  10250.     case FFELEX_typeNUMBER:
  10251.       ffestb_local_.format.exp.present = TRUE;
  10252.       ffestb_local_.format.exp.rtexpr = FALSE;
  10253.       ffestb_local_.format.exp.t = ffelex_token_use (t);
  10254.       ffestb_local_.format.exp.u.unsigned_val
  10255.     = strtoul (ffelex_token_text (t), NULL, 10);
  10256.       return (ffelexHandler) ffestb_R100110_;
  10257.  
  10258.     default:
  10259.       ffelex_token_kill (ffestb_local_.format.t);
  10260.       if (ffestb_local_.format.pre.present)
  10261.     ffelex_token_kill (ffestb_local_.format.pre.t);
  10262.       if (ffestb_local_.format.post.present)
  10263.     ffelex_token_kill (ffestb_local_.format.post.t);
  10264.       if (ffestb_local_.format.dot.present)
  10265.     ffelex_token_kill (ffestb_local_.format.dot.t);
  10266.       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_EXP, t);
  10267.       ffestt_formatlist_kill (ffestb_local_.format.f);
  10268.       return (ffelexHandler) ffelex_swallow_tokens (t,
  10269.                            (ffelexHandler) ffesta_zero);
  10270.     }
  10271. }
  10272.  
  10273. /* ffestb_R100110_ -- [[+/-] NUMBER] NAMES NUMBER [PERIOD NUMBER ["E" NUMBER]]
  10274.  
  10275.    return ffestb_R100110_;  // to lexer
  10276.  
  10277.    Maybe find a NUMBER to append to the current number, in which case return
  10278.    to this state.  Anything else, handle current descriptor, then pass token
  10279.    on to state _10_.  */
  10280.  
  10281. static ffelexHandler
  10282. ffestb_R100110_ (ffelexToken t)
  10283. {
  10284.   ffeTokenLength i;
  10285.   enum expect
  10286.     {
  10287.       required,
  10288.       optional,
  10289.       disallowed
  10290.     };
  10291.   ffebad err;
  10292.   enum expect pre;
  10293.   enum expect post;
  10294.   enum expect dot;
  10295.   enum expect exp;
  10296.   bool R1005;
  10297.   ffesttFormatList f;
  10298.  
  10299.   switch (ffelex_token_type (t))
  10300.     {
  10301.     case FFELEX_typeNUMBER:
  10302.       assert (ffestb_local_.format.exp.present);
  10303.       ffesta_confirmed ();
  10304.       if (ffestb_local_.format.exp.rtexpr)
  10305.     {
  10306.       ffebad_start (FFEBAD_FORMAT_SPURIOUS_NUMBER);
  10307.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  10308.       ffebad_finish ();
  10309.       return (ffelexHandler) ffestb_R100110_;
  10310.     }
  10311.       for (i = 0; i < ffelex_token_length (t); ++i)
  10312.     ffestb_local_.format.exp.u.unsigned_val *= 10;
  10313.       ffestb_local_.format.exp.u.unsigned_val += strtoul (ffelex_token_text (t),
  10314.                               NULL, 10);
  10315.       return (ffelexHandler) ffestb_R100110_;
  10316.  
  10317.     default:
  10318.       if (ffestb_local_.format.sign
  10319.       && (ffestb_local_.format.current != FFESTP_formattypeP)
  10320.       && (ffestb_local_.format.current != FFESTP_formattypeH))
  10321.     {
  10322.       ffebad_start (FFEBAD_FORMAT_SPURIOUS_SIGN);
  10323.       ffebad_here (0, ffelex_token_where_line (ffestb_local_.format.pre.t),
  10324.             ffelex_token_where_column (ffestb_local_.format.pre.t));
  10325.       ffebad_finish ();
  10326.       ffestb_local_.format.pre.u.unsigned_val
  10327.         = (ffestb_local_.format.pre.u.signed_val < 0)
  10328.         ? -ffestb_local_.format.pre.u.signed_val
  10329.         : ffestb_local_.format.pre.u.signed_val;
  10330.     }
  10331.       switch (ffestb_local_.format.current)
  10332.     {
  10333.     case FFESTP_formattypeI:
  10334.       err = FFEBAD_FORMAT_BAD_I_SPEC;
  10335.       pre = optional;
  10336.       post = required;
  10337.       dot = optional;
  10338.       exp = disallowed;
  10339.       R1005 = TRUE;
  10340.       break;
  10341.  
  10342.     case FFESTP_formattypeB:
  10343.       err = FFEBAD_FORMAT_BAD_B_SPEC;
  10344.       pre = optional;
  10345.       post = required;
  10346.       dot = optional;
  10347.       exp = disallowed;
  10348.       R1005 = TRUE;
  10349.       break;
  10350.  
  10351.     case FFESTP_formattypeO:
  10352.       err = FFEBAD_FORMAT_BAD_O_SPEC;
  10353.       pre = optional;
  10354.       post = required;
  10355.       dot = optional;
  10356.       exp = disallowed;
  10357.       R1005 = TRUE;
  10358.       break;
  10359.  
  10360.     case FFESTP_formattypeZ:
  10361.       err = FFEBAD_FORMAT_BAD_Z_SPEC;
  10362.       pre = optional;
  10363.       post = required;
  10364.       dot = optional;
  10365.       exp = disallowed;
  10366.       R1005 = TRUE;
  10367.       break;
  10368.  
  10369.     case FFESTP_formattypeF:
  10370.       err = FFEBAD_FORMAT_BAD_F_SPEC;
  10371.       pre = optional;
  10372.       post = required;
  10373.       dot = required;
  10374.       exp = disallowed;
  10375.       R1005 = TRUE;
  10376.       break;
  10377.  
  10378.     case FFESTP_formattypeE:
  10379.       err = FFEBAD_FORMAT_BAD_E_SPEC;
  10380.       pre = optional;
  10381.       post = required;
  10382.       dot = required;
  10383.       exp = optional;
  10384.       R1005 = TRUE;
  10385.       break;
  10386.  
  10387.     case FFESTP_formattypeEN:
  10388.       err = FFEBAD_FORMAT_BAD_EN_SPEC;
  10389.       pre = optional;
  10390.       post = required;
  10391.       dot = required;
  10392.       exp = optional;
  10393.       R1005 = TRUE;
  10394.       break;
  10395.  
  10396.     case FFESTP_formattypeG:
  10397.       err = FFEBAD_FORMAT_BAD_G_SPEC;
  10398.       pre = optional;
  10399.       post = required;
  10400.       dot = required;
  10401.       exp = optional;
  10402.       R1005 = TRUE;
  10403.       break;
  10404.  
  10405.     case FFESTP_formattypeL:
  10406.       err = FFEBAD_FORMAT_BAD_L_SPEC;
  10407.       pre = optional;
  10408.       post = required;
  10409.       dot = disallowed;
  10410.       exp = disallowed;
  10411.       R1005 = TRUE;
  10412.       break;
  10413.  
  10414.     case FFESTP_formattypeA:
  10415.       err = FFEBAD_FORMAT_BAD_A_SPEC;
  10416.       pre = optional;
  10417.       post = optional;
  10418.       dot = disallowed;
  10419.       exp = disallowed;
  10420.       R1005 = TRUE;
  10421.       break;
  10422.  
  10423.     case FFESTP_formattypeD:
  10424.       err = FFEBAD_FORMAT_BAD_D_SPEC;
  10425.       pre = optional;
  10426.       post = required;
  10427.       dot = required;
  10428.       exp = disallowed;
  10429.       R1005 = TRUE;
  10430.       break;
  10431.  
  10432.     case FFESTP_formattypeQ:
  10433.       err = FFEBAD_FORMAT_BAD_Q_SPEC;
  10434.       pre = disallowed;
  10435.       post = disallowed;
  10436.       dot = disallowed;
  10437.       exp = disallowed;
  10438.       R1005 = FALSE;
  10439.       break;
  10440.  
  10441.     case FFESTP_formattypeDOLLAR:
  10442.       err = FFEBAD_FORMAT_BAD_DOLLAR_SPEC;
  10443.       pre = disallowed;
  10444.       post = disallowed;
  10445.       dot = disallowed;
  10446.       exp = disallowed;
  10447.       R1005 = FALSE;
  10448.       break;
  10449.  
  10450.     case FFESTP_formattypeP:
  10451.       err = FFEBAD_FORMAT_BAD_P_SPEC;
  10452.       pre = required;
  10453.       post = disallowed;
  10454.       dot = disallowed;
  10455.       exp = disallowed;
  10456.       R1005 = FALSE;
  10457.       break;
  10458.  
  10459.     case FFESTP_formattypeT:
  10460.       err = FFEBAD_FORMAT_BAD_T_SPEC;
  10461.       pre = disallowed;
  10462.       post = required;
  10463.       dot = disallowed;
  10464.       exp = disallowed;
  10465.       R1005 = FALSE;
  10466.       break;
  10467.  
  10468.     case FFESTP_formattypeTL:
  10469.       err = FFEBAD_FORMAT_BAD_TL_SPEC;
  10470.       pre = disallowed;
  10471.       post = required;
  10472.       dot = disallowed;
  10473.       exp = disallowed;
  10474.       R1005 = FALSE;
  10475.       break;
  10476.  
  10477.     case FFESTP_formattypeTR:
  10478.       err = FFEBAD_FORMAT_BAD_TR_SPEC;
  10479.       pre = disallowed;
  10480.       post = required;
  10481.       dot = disallowed;
  10482.       exp = disallowed;
  10483.       R1005 = FALSE;
  10484.       break;
  10485.  
  10486.     case FFESTP_formattypeX:
  10487.       err = FFEBAD_FORMAT_BAD_X_SPEC;
  10488.       pre = required;
  10489.       post = disallowed;
  10490.       dot = disallowed;
  10491.       exp = disallowed;
  10492.       R1005 = FALSE;
  10493.       break;
  10494.  
  10495.     case FFESTP_formattypeS:
  10496.       err = FFEBAD_FORMAT_BAD_S_SPEC;
  10497.       pre = disallowed;
  10498.       post = disallowed;
  10499.       dot = disallowed;
  10500.       exp = disallowed;
  10501.       R1005 = FALSE;
  10502.       break;
  10503.  
  10504.     case FFESTP_formattypeSP:
  10505.       err = FFEBAD_FORMAT_BAD_SP_SPEC;
  10506.       pre = disallowed;
  10507.       post = disallowed;
  10508.       dot = disallowed;
  10509.       exp = disallowed;
  10510.       R1005 = FALSE;
  10511.       break;
  10512.  
  10513.     case FFESTP_formattypeSS:
  10514.       err = FFEBAD_FORMAT_BAD_SS_SPEC;
  10515.       pre = disallowed;
  10516.       post = disallowed;
  10517.       dot = disallowed;
  10518.       exp = disallowed;
  10519.       R1005 = FALSE;
  10520.       break;
  10521.  
  10522.     case FFESTP_formattypeBN:
  10523.       err = FFEBAD_FORMAT_BAD_BN_SPEC;
  10524.       pre = disallowed;
  10525.       post = disallowed;
  10526.       dot = disallowed;
  10527.       exp = disallowed;
  10528.       R1005 = FALSE;
  10529.       break;
  10530.  
  10531.     case FFESTP_formattypeBZ:
  10532.       err = FFEBAD_FORMAT_BAD_BZ_SPEC;
  10533.       pre = disallowed;
  10534.       post = disallowed;
  10535.       dot = disallowed;
  10536.       exp = disallowed;
  10537.       R1005 = FALSE;
  10538.       break;
  10539.  
  10540.     case FFESTP_formattypeH:    /* Definitely an error, make sure of
  10541.                        it. */
  10542.       err = FFEBAD_FORMAT_BAD_H_SPEC;
  10543.       pre = ffestb_local_.format.pre.present ? disallowed : required;
  10544.       post = disallowed;
  10545.       dot = disallowed;
  10546.       exp = disallowed;
  10547.       R1005 = FALSE;
  10548.       break;
  10549.  
  10550.     case FFESTP_formattypeNone:
  10551.       ffesta_ffebad_1t (FFEBAD_FORMAT_BAD_SPEC,
  10552.                 ffestb_local_.format.t);
  10553.  
  10554.     clean_up_to_11_:    /* :::::::::::::::::::: */
  10555.  
  10556.       ffelex_token_kill (ffestb_local_.format.t);
  10557.       if (ffestb_local_.format.pre.present)
  10558.         ffelex_token_kill (ffestb_local_.format.pre.t);
  10559.       if (ffestb_local_.format.post.present)
  10560.         ffelex_token_kill (ffestb_local_.format.post.t);
  10561.       if (ffestb_local_.format.dot.present)
  10562.         ffelex_token_kill (ffestb_local_.format.dot.t);
  10563.       if (ffestb_local_.format.exp.present)
  10564.         ffelex_token_kill (ffestb_local_.format.exp.t);
  10565.       return (ffelexHandler) ffestb_R100111_ (t);
  10566.  
  10567.     default:
  10568.       assert (FALSE);
  10569.       err = FFEBAD_FORMAT_BAD_H_SPEC;
  10570.       pre = disallowed;
  10571.       post = disallowed;
  10572.       dot = disallowed;
  10573.       exp = disallowed;
  10574.       R1005 = FALSE;
  10575.       break;
  10576.     }
  10577.       if (((pre == disallowed) && ffestb_local_.format.pre.present)
  10578.       || ((pre == required) && !ffestb_local_.format.pre.present))
  10579.     {
  10580.       ffesta_ffebad_1t (err, (pre == required)
  10581.              ? ffestb_local_.format.t : ffestb_local_.format.pre.t);
  10582.       goto clean_up_to_11_;    /* :::::::::::::::::::: */
  10583.     }
  10584.       if (((post == disallowed) && ffestb_local_.format.post.present)
  10585.       || ((post == required) && !ffestb_local_.format.post.present))
  10586.     {
  10587.       ffesta_ffebad_1t (err, (post == required)
  10588.             ? ffestb_local_.format.t : ffestb_local_.format.post.t);
  10589.       goto clean_up_to_11_;    /* :::::::::::::::::::: */
  10590.     }
  10591.       if (((dot == disallowed) && ffestb_local_.format.dot.present)
  10592.       || ((dot == required) && !ffestb_local_.format.dot.present))
  10593.     {
  10594.       ffesta_ffebad_1t (err, (dot == required)
  10595.              ? ffestb_local_.format.t : ffestb_local_.format.dot.t);
  10596.       goto clean_up_to_11_;    /* :::::::::::::::::::: */
  10597.     }
  10598.       if (((exp == disallowed) && ffestb_local_.format.exp.present)
  10599.       || ((exp == required) && !ffestb_local_.format.exp.present))
  10600.     {
  10601.       ffesta_ffebad_1t (err, (exp == required)
  10602.              ? ffestb_local_.format.t : ffestb_local_.format.exp.t);
  10603.       goto clean_up_to_11_;    /* :::::::::::::::::::: */
  10604.     }
  10605.       f = ffestt_formatlist_append (ffestb_local_.format.f);
  10606.       f->type = ffestb_local_.format.current;
  10607.       f->t = ffestb_local_.format.t;
  10608.       if (R1005)
  10609.     {
  10610.       f->u.R1005.R1004 = ffestb_local_.format.pre;
  10611.       f->u.R1005.R1006 = ffestb_local_.format.post;
  10612.       f->u.R1005.R1007_or_R1008 = ffestb_local_.format.dot;
  10613.       f->u.R1005.R1009 = ffestb_local_.format.exp;
  10614.     }
  10615.       else
  10616.     /* Must be R1010. */
  10617.     {
  10618.       if (pre == disallowed)
  10619.         f->u.R1010.val = ffestb_local_.format.post;
  10620.       else
  10621.         f->u.R1010.val = ffestb_local_.format.pre;
  10622.     }
  10623.       return (ffelexHandler) ffestb_R100111_ (t);
  10624.     }
  10625. }
  10626.  
  10627. /* ffestb_R100111_ -- edit-descriptor
  10628.  
  10629.    return ffestb_R100111_;  // to lexer
  10630.  
  10631.    Expect a COMMA, CLOSE_PAREN, CLOSE_ARRAY, COLON, COLONCOLON, SLASH, or
  10632.    CONCAT, or complain about missing comma.  */
  10633.  
  10634. static ffelexHandler
  10635. ffestb_R100111_ (ffelexToken t)
  10636. {
  10637.   ffesttFormatList f;
  10638.  
  10639.   switch (ffelex_token_type (t))
  10640.     {
  10641.     case FFELEX_typeCOMMA:
  10642.       return (ffelexHandler) ffestb_R10012_;
  10643.  
  10644.     case FFELEX_typeCOLON:
  10645.     case FFELEX_typeCOLONCOLON:
  10646.     case FFELEX_typeSLASH:
  10647.     case FFELEX_typeCONCAT:
  10648.       return (ffelexHandler) ffestb_R10012_ (t);
  10649.  
  10650.     case FFELEX_typeCLOSE_PAREN:
  10651.       f = ffestb_local_.format.f->u.root.parent;
  10652.       if (f == NULL)
  10653.     return (ffelexHandler) ffestb_R100114_;
  10654.       ffestb_local_.format.f = f->next;
  10655.       return (ffelexHandler) ffestb_R100111_;
  10656.  
  10657.     case FFELEX_typeCLOSE_ARRAY:    /* "/)". */
  10658.       f = ffestt_formatlist_append (ffestb_local_.format.f);
  10659.       f->type = FFESTP_formattypeSLASH;
  10660.       f->t = ffelex_token_use (t);
  10661.       f->u.R1010.val.present = FALSE;
  10662.       f->u.R1010.val.rtexpr = FALSE;
  10663.       f->u.R1010.val.t = NULL;
  10664.       f->u.R1010.val.u.unsigned_val = 1;
  10665.       f = ffestb_local_.format.f->u.root.parent;
  10666.       if (f == NULL)
  10667.     return (ffelexHandler) ffestb_R100114_;
  10668.       ffestb_local_.format.f = f->next;
  10669.       return (ffelexHandler) ffestb_R100111_;
  10670.  
  10671.     case FFELEX_typeOPEN_ANGLE:
  10672.     case FFELEX_typeDOLLAR:
  10673.     case FFELEX_typeNUMBER:
  10674.     case FFELEX_typeOPEN_PAREN:
  10675.     case FFELEX_typeOPEN_ARRAY:
  10676.     case FFELEX_typeQUOTE:
  10677.     case FFELEX_typeAPOSTROPHE:
  10678.     case FFELEX_typeNAMES:
  10679.       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_COMMA, t);
  10680.       return (ffelexHandler) ffestb_R10012_ (t);
  10681.  
  10682.     case FFELEX_typeEOS:
  10683.     case FFELEX_typeSEMICOLON:
  10684.       ffesta_confirmed ();
  10685.       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
  10686.       for (f = ffestb_local_.format.f;
  10687.        f->u.root.parent != NULL;
  10688.        f = f->u.root.parent->next)
  10689.     ;
  10690.       ffestb_local_.format.f = f;
  10691.       return (ffelexHandler) ffestb_R100114_ (t);
  10692.  
  10693.     default:
  10694.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
  10695.       ffestt_formatlist_kill (ffestb_local_.format.f);
  10696.       return (ffelexHandler) ffelex_swallow_tokens (t,
  10697.                            (ffelexHandler) ffesta_zero);
  10698.     }
  10699. }
  10700.  
  10701. /* ffestb_R100112_ -- COLON, COLONCOLON, SLASH, OPEN_ARRAY, or CONCAT
  10702.  
  10703.    return ffestb_R100112_;  // to lexer
  10704.  
  10705.    Like _11_ except the COMMA is optional.  */
  10706.  
  10707. static ffelexHandler
  10708. ffestb_R100112_ (ffelexToken t)
  10709. {
  10710.   ffesttFormatList f;
  10711.  
  10712.   switch (ffelex_token_type (t))
  10713.     {
  10714.     case FFELEX_typeCOMMA:
  10715.       return (ffelexHandler) ffestb_R10012_;
  10716.  
  10717.     case FFELEX_typeCOLON:
  10718.     case FFELEX_typeCOLONCOLON:
  10719.     case FFELEX_typeSLASH:
  10720.     case FFELEX_typeCONCAT:
  10721.     case FFELEX_typeOPEN_ANGLE:
  10722.     case FFELEX_typeNAMES:
  10723.     case FFELEX_typeDOLLAR:
  10724.     case FFELEX_typeNUMBER:
  10725.     case FFELEX_typeOPEN_PAREN:
  10726.     case FFELEX_typeOPEN_ARRAY:
  10727.     case FFELEX_typeQUOTE:
  10728.     case FFELEX_typeAPOSTROPHE:
  10729.     case FFELEX_typePLUS:
  10730.     case FFELEX_typeMINUS:
  10731.       return (ffelexHandler) ffestb_R10012_ (t);
  10732.  
  10733.     case FFELEX_typeCLOSE_PAREN:
  10734.       f = ffestb_local_.format.f->u.root.parent;
  10735.       if (f == NULL)
  10736.     return (ffelexHandler) ffestb_R100114_;
  10737.       ffestb_local_.format.f = f->next;
  10738.       return (ffelexHandler) ffestb_R100111_;
  10739.  
  10740.     case FFELEX_typeCLOSE_ARRAY:    /* "/)". */
  10741.       f = ffestt_formatlist_append (ffestb_local_.format.f);
  10742.       f->type = FFESTP_formattypeSLASH;
  10743.       f->t = ffelex_token_use (t);
  10744.       f->u.R1010.val.present = FALSE;
  10745.       f->u.R1010.val.rtexpr = FALSE;
  10746.       f->u.R1010.val.t = NULL;
  10747.       f->u.R1010.val.u.unsigned_val = 1;
  10748.       f = ffestb_local_.format.f->u.root.parent;
  10749.       if (f == NULL)
  10750.     return (ffelexHandler) ffestb_R100114_;
  10751.       ffestb_local_.format.f = f->next;
  10752.       return (ffelexHandler) ffestb_R100111_;
  10753.  
  10754.     case FFELEX_typeEOS:
  10755.     case FFELEX_typeSEMICOLON:
  10756.       ffesta_confirmed ();
  10757.       ffesta_ffebad_1t (FFEBAD_FORMAT_MISSING_PAREN, t);
  10758.       for (f = ffestb_local_.format.f;
  10759.        f->u.root.parent != NULL;
  10760.        f = f->u.root.parent->next)
  10761.     ;
  10762.       ffestb_local_.format.f = f;
  10763.       return (ffelexHandler) ffestb_R100114_ (t);
  10764.  
  10765.     default:
  10766.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
  10767.       ffestt_formatlist_kill (ffestb_local_.format.f);
  10768.       return (ffelexHandler) ffelex_swallow_tokens (t,
  10769.                            (ffelexHandler) ffesta_zero);
  10770.     }
  10771. }
  10772.  
  10773. /* ffestb_R100113_ -- Handle CHARACTER token.
  10774.  
  10775.    return ffestb_R100113_;  // to lexer
  10776.  
  10777.    Append the format item to the list, go to _11_.  */
  10778.  
  10779. static ffelexHandler
  10780. ffestb_R100113_ (ffelexToken t)
  10781. {
  10782.   ffesttFormatList f;
  10783.  
  10784.   assert (ffelex_token_type (t) == FFELEX_typeCHARACTER);
  10785.  
  10786.   if (ffe_is_pedantic_not_90 () && (ffelex_token_length (t) == 0))
  10787.     {
  10788.       ffebad_start (FFEBAD_NULL_CHAR_CONST);
  10789.       ffebad_here (0, ffelex_token_where_line (t),
  10790.            ffelex_token_where_column (t));
  10791.       ffebad_finish ();
  10792.     }
  10793.  
  10794.   f = ffestt_formatlist_append (ffestb_local_.format.f);
  10795.   f->type = FFESTP_formattypeR1016;
  10796.   f->t = ffelex_token_use (t);
  10797.   return (ffelexHandler) ffestb_R100111_;
  10798. }
  10799.  
  10800. /* ffestb_R100114_ -- "FORMAT" OPEN_PAREN format-item-list CLOSE_PAREN
  10801.  
  10802.    return ffestb_R100114_;  // to lexer
  10803.  
  10804.    Handle EOS/SEMICOLON or something else.  */
  10805.  
  10806. static ffelexHandler
  10807. ffestb_R100114_ (ffelexToken t)
  10808. {
  10809.   ffelex_set_names_pure (FALSE);
  10810.  
  10811.   switch (ffelex_token_type (t))
  10812.     {
  10813.     case FFELEX_typeEOS:
  10814.     case FFELEX_typeSEMICOLON:
  10815.       ffesta_confirmed ();
  10816.       if (!ffesta_is_inhibited () && !ffestb_local_.format.complained)
  10817.     ffestc_R1001 (ffestb_local_.format.f);
  10818.       ffestt_formatlist_kill (ffestb_local_.format.f);
  10819.       return (ffelexHandler) ffesta_zero (t);
  10820.  
  10821.     default:
  10822.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
  10823.       ffestt_formatlist_kill (ffestb_local_.format.f);
  10824.       return (ffelexHandler) ffelex_swallow_tokens (t,
  10825.                            (ffelexHandler) ffesta_zero);
  10826.     }
  10827. }
  10828.  
  10829. /* ffestb_R100115_ -- OPEN_ANGLE expr
  10830.  
  10831.    (ffestb_R100115_)  // to expression handler
  10832.  
  10833.    Handle expression prior to the edit descriptor.  */
  10834.  
  10835. static ffelexHandler
  10836. ffestb_R100115_ (ffelexToken ft, ffebld expr, ffelexToken t)
  10837. {
  10838.   switch (ffelex_token_type (t))
  10839.     {
  10840.     case FFELEX_typeCLOSE_ANGLE:
  10841.       ffestb_local_.format.pre.present = TRUE;
  10842.       ffestb_local_.format.pre.rtexpr = TRUE;
  10843.       ffestb_local_.format.pre.u.expr = expr;
  10844.       ffelex_set_names_pure (TRUE);
  10845.       return (ffelexHandler) ffestb_R10014_;
  10846.  
  10847.     default:
  10848.       ffelex_token_kill (ffestb_local_.format.pre.t);
  10849.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
  10850.       ffestt_formatlist_kill (ffestb_local_.format.f);
  10851.       return (ffelexHandler) ffelex_swallow_tokens (t,
  10852.                            (ffelexHandler) ffesta_zero);
  10853.     }
  10854. }
  10855.  
  10856. /* ffestb_R100116_ -- "[n]X" OPEN_ANGLE expr
  10857.  
  10858.    (ffestb_R100116_)  // to expression handler
  10859.  
  10860.    Handle expression after the edit descriptor.     */
  10861.  
  10862. static ffelexHandler
  10863. ffestb_R100116_ (ffelexToken ft, ffebld expr, ffelexToken t)
  10864. {
  10865.   switch (ffelex_token_type (t))
  10866.     {
  10867.     case FFELEX_typeCLOSE_ANGLE:
  10868.       ffestb_local_.format.post.present = TRUE;
  10869.       ffestb_local_.format.post.rtexpr = TRUE;
  10870.       ffestb_local_.format.post.u.expr = expr;
  10871.       ffelex_set_names_pure (TRUE);
  10872.       return (ffelexHandler) ffestb_R10016_;
  10873.  
  10874.     default:
  10875.       ffelex_token_kill (ffestb_local_.format.t);
  10876.       ffelex_token_kill (ffestb_local_.format.post.t);
  10877.       if (ffestb_local_.format.pre.present)
  10878.     ffelex_token_kill (ffestb_local_.format.pre.t);
  10879.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
  10880.       ffestt_formatlist_kill (ffestb_local_.format.f);
  10881.       return (ffelexHandler) ffelex_swallow_tokens (t,
  10882.                            (ffelexHandler) ffesta_zero);
  10883.     }
  10884. }
  10885.  
  10886. /* ffestb_R100117_ -- "[n]X[n]." OPEN_ANGLE expr
  10887.  
  10888.    (ffestb_R100117_)  // to expression handler
  10889.  
  10890.    Handle expression after the PERIOD.    */
  10891.  
  10892. static ffelexHandler
  10893. ffestb_R100117_ (ffelexToken ft, ffebld expr, ffelexToken t)
  10894. {
  10895.   switch (ffelex_token_type (t))
  10896.     {
  10897.     case FFELEX_typeCLOSE_ANGLE:
  10898.       ffestb_local_.format.dot.present = TRUE;
  10899.       ffestb_local_.format.dot.rtexpr = TRUE;
  10900.       ffestb_local_.format.dot.u.expr = expr;
  10901.       ffelex_set_names_pure (TRUE);
  10902.       return (ffelexHandler) ffestb_R10018_;
  10903.  
  10904.     default:
  10905.       ffelex_token_kill (ffestb_local_.format.t);
  10906.       ffelex_token_kill (ffestb_local_.format.dot.t);
  10907.       if (ffestb_local_.format.pre.present)
  10908.     ffelex_token_kill (ffestb_local_.format.pre.t);
  10909.       if (ffestb_local_.format.post.present)
  10910.     ffelex_token_kill (ffestb_local_.format.post.t);
  10911.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
  10912.       ffestt_formatlist_kill (ffestb_local_.format.f);
  10913.       return (ffelexHandler) ffelex_swallow_tokens (t,
  10914.                            (ffelexHandler) ffesta_zero);
  10915.     }
  10916. }
  10917.  
  10918. /* ffestb_R100118_ -- "[n]X[n].[n]E" OPEN_ANGLE expr
  10919.  
  10920.    (ffestb_R100118_)  // to expression handler
  10921.  
  10922.    Handle expression after the "E".  */
  10923.  
  10924. static ffelexHandler
  10925. ffestb_R100118_ (ffelexToken ft, ffebld expr, ffelexToken t)
  10926. {
  10927.   switch (ffelex_token_type (t))
  10928.     {
  10929.     case FFELEX_typeCLOSE_ANGLE:
  10930.       ffestb_local_.format.exp.present = TRUE;
  10931.       ffestb_local_.format.exp.rtexpr = TRUE;
  10932.       ffestb_local_.format.exp.u.expr = expr;
  10933.       ffelex_set_names_pure (TRUE);
  10934.       return (ffelexHandler) ffestb_R100110_;
  10935.  
  10936.     default:
  10937.       ffelex_token_kill (ffestb_local_.format.t);
  10938.       ffelex_token_kill (ffestb_local_.format.exp.t);
  10939.       if (ffestb_local_.format.pre.present)
  10940.     ffelex_token_kill (ffestb_local_.format.pre.t);
  10941.       if (ffestb_local_.format.post.present)
  10942.     ffelex_token_kill (ffestb_local_.format.post.t);
  10943.       if (ffestb_local_.format.dot.present)
  10944.     ffelex_token_kill (ffestb_local_.format.dot.t);
  10945.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FORMAT", t);
  10946.       ffestt_formatlist_kill (ffestb_local_.format.f);
  10947.       return (ffelexHandler) ffelex_swallow_tokens (t,
  10948.                            (ffelexHandler) ffesta_zero);
  10949.     }
  10950. }
  10951.  
  10952. /* ffestb_R1107 -- Parse the USE statement
  10953.  
  10954.    return ffestb_R1107;     // to lexer
  10955.  
  10956.    Make sure the statement has a valid form for the USE statement.
  10957.    If it does, implement the statement.     */
  10958.  
  10959. #if FFESTR_F90
  10960. ffelexHandler
  10961. ffestb_R1107 (ffelexToken t)
  10962. {
  10963.   ffeTokenLength i;
  10964.   char *p;
  10965.  
  10966.   switch (ffelex_token_type (ffesta_tokens[0]))
  10967.     {
  10968.     case FFELEX_typeNAME:
  10969.       if (ffesta_first_kw != FFESTR_firstUSE)
  10970.     goto bad_0;        /* :::::::::::::::::::: */
  10971.       switch (ffelex_token_type (t))
  10972.     {
  10973.     case FFELEX_typeNAME:
  10974.       break;
  10975.  
  10976.     case FFELEX_typeEOS:
  10977.     case FFELEX_typeSEMICOLON:
  10978.     case FFELEX_typeCOMMA:
  10979.     case FFELEX_typeCOLONCOLON:
  10980.       ffesta_confirmed ();    /* Error, but clearly intended. */
  10981.       goto bad_1;        /* :::::::::::::::::::: */
  10982.  
  10983.     default:
  10984.       goto bad_0;        /* :::::::::::::::::::: */
  10985.     }
  10986.       ffesta_confirmed ();
  10987.       ffesta_tokens[1] = ffelex_token_use (t);
  10988.       return (ffelexHandler) ffestb_R11071_;
  10989.  
  10990.     case FFELEX_typeNAMES:
  10991.       if (ffesta_first_kw != FFESTR_firstUSE)
  10992.     goto bad_0;        /* :::::::::::::::::::: */
  10993.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlUSE);
  10994.       if (!ffesrc_is_name_init (*p))
  10995.     goto bad_i;        /* :::::::::::::::::::: */
  10996.       switch (ffelex_token_type (t))
  10997.     {
  10998.     case FFELEX_typeCOLONCOLON:
  10999.       ffesta_confirmed ();    /* Error, but clearly intended. */
  11000.       goto bad_1;        /* :::::::::::::::::::: */
  11001.  
  11002.     default:
  11003.       goto bad_1;        /* :::::::::::::::::::: */
  11004.  
  11005.     case FFELEX_typeCOMMA:
  11006.     case FFELEX_typeEOS:
  11007.     case FFELEX_typeSEMICOLON:
  11008.       break;
  11009.     }
  11010.       ffesta_confirmed ();
  11011.       ffesta_tokens[1]
  11012.     = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  11013.       return (ffelexHandler) ffestb_R11071_ (t);
  11014.  
  11015.     default:
  11016.       goto bad_0;        /* :::::::::::::::::::: */
  11017.     }
  11018.  
  11019. bad_0:                /* :::::::::::::::::::: */
  11020.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", ffesta_tokens[0]);
  11021.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11022.  
  11023. bad_1:                /* :::::::::::::::::::: */
  11024.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11025.   return (ffelexHandler) ffelex_swallow_tokens (t,
  11026.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  11027.  
  11028. bad_i:                /* :::::::::::::::::::: */
  11029.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "USE", ffesta_tokens[0], i, t);
  11030.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11031. }
  11032.  
  11033. /* ffestb_R11071_ -- "USE" NAME
  11034.  
  11035.    return ffestb_R11071_;  // to lexer
  11036.  
  11037.    Make sure the statement has a valid form for the USE statement.  If it
  11038.    does, implement the statement.  */
  11039.  
  11040. static ffelexHandler
  11041. ffestb_R11071_ (ffelexToken t)
  11042. {
  11043.   switch (ffelex_token_type (t))
  11044.     {
  11045.     case FFELEX_typeEOS:
  11046.     case FFELEX_typeSEMICOLON:
  11047.       if (!ffesta_is_inhibited ())
  11048.     {
  11049.       ffestc_R1107_start (ffesta_tokens[1], FALSE);
  11050.       ffestc_R1107_finish ();
  11051.     }
  11052.       ffelex_token_kill (ffesta_tokens[1]);
  11053.       return (ffelexHandler) ffesta_zero (t);
  11054.  
  11055.     case FFELEX_typeCOMMA:
  11056.       return (ffelexHandler) ffestb_R11072_;
  11057.  
  11058.     default:
  11059.       break;
  11060.     }
  11061.  
  11062.   ffelex_token_kill (ffesta_tokens[1]);
  11063.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11064.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11065. }
  11066.  
  11067. /* ffestb_R11072_ -- "USE" NAME COMMA
  11068.  
  11069.    return ffestb_R11072_;  // to lexer
  11070.  
  11071.    Make sure the statement has a valid form for the USE statement.  If it
  11072.    does, implement the statement.  */
  11073.  
  11074. static ffelexHandler
  11075. ffestb_R11072_ (ffelexToken t)
  11076. {
  11077.   switch (ffelex_token_type (t))
  11078.     {
  11079.     case FFELEX_typeNAME:
  11080.       ffesta_tokens[2] = ffelex_token_use (t);
  11081.       return (ffelexHandler) ffestb_R11073_;
  11082.  
  11083.     default:
  11084.       break;
  11085.     }
  11086.  
  11087.   ffelex_token_kill (ffesta_tokens[1]);
  11088.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11089.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11090. }
  11091.  
  11092. /* ffestb_R11073_ -- "USE" NAME COMMA NAME
  11093.  
  11094.    return ffestb_R11073_;  // to lexer
  11095.  
  11096.    Make sure the statement has a valid form for the USE statement.  If it
  11097.    does, implement the statement.  */
  11098.  
  11099. static ffelexHandler
  11100. ffestb_R11073_ (ffelexToken t)
  11101. {
  11102.   switch (ffelex_token_type (t))
  11103.     {
  11104.     case FFELEX_typeCOLON:
  11105.       if (ffestr_other (ffesta_tokens[2]) != FFESTR_otherONLY)
  11106.     break;
  11107.       if (!ffesta_is_inhibited ())
  11108.     ffestc_R1107_start (ffesta_tokens[1], TRUE);
  11109.       ffelex_token_kill (ffesta_tokens[1]);
  11110.       ffelex_token_kill (ffesta_tokens[2]);
  11111.       return (ffelexHandler) ffestb_R11074_;
  11112.  
  11113.     case FFELEX_typePOINTS:
  11114.       if (!ffesta_is_inhibited ())
  11115.     ffestc_R1107_start (ffesta_tokens[1], FALSE);
  11116.       ffelex_token_kill (ffesta_tokens[1]);
  11117.       ffesta_tokens[1] = ffesta_tokens[2];
  11118.       return (ffelexHandler) ffestb_R110711_;
  11119.  
  11120.     default:
  11121.       break;
  11122.     }
  11123.  
  11124.   ffelex_token_kill (ffesta_tokens[1]);
  11125.   ffelex_token_kill (ffesta_tokens[2]);
  11126.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11127.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11128. }
  11129.  
  11130. /* ffestb_R11074_ -- "USE" NAME COMMA "ONLY" COLON
  11131.  
  11132.    return ffestb_R11074_;  // to lexer
  11133.  
  11134.    Make sure the statement has a valid form for the USE statement.  If it
  11135.    does, implement the statement.  */
  11136.  
  11137. static ffelexHandler
  11138. ffestb_R11074_ (ffelexToken t)
  11139. {
  11140.   switch (ffelex_token_type (t))
  11141.     {
  11142.     case FFELEX_typeNAME:
  11143.       ffesta_tokens[1] = ffelex_token_use (t);
  11144.       return (ffelexHandler) ffestb_R11075_;
  11145.  
  11146.     case FFELEX_typeEOS:
  11147.     case FFELEX_typeSEMICOLON:
  11148.       if (!ffesta_is_inhibited ())
  11149.     ffestc_R1107_finish ();
  11150.       return (ffelexHandler) ffesta_zero (t);
  11151.  
  11152.     default:
  11153.       break;
  11154.     }
  11155.  
  11156.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11157.   ffestc_R1107_finish ();
  11158.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11159. }
  11160.  
  11161. /* ffestb_R11075_ -- "USE" NAME COMMA "ONLY" COLON NAME
  11162.  
  11163.    return ffestb_R11075_;  // to lexer
  11164.  
  11165.    Make sure the statement has a valid form for the USE statement.  If it
  11166.    does, implement the statement.  */
  11167.  
  11168. static ffelexHandler
  11169. ffestb_R11075_ (ffelexToken t)
  11170. {
  11171.   switch (ffelex_token_type (t))
  11172.     {
  11173.     case FFELEX_typeEOS:
  11174.     case FFELEX_typeSEMICOLON:
  11175.       if (!ffesta_is_inhibited ())
  11176.     {
  11177.       ffestc_R1107_item (NULL, ffesta_tokens[1]);
  11178.       ffestc_R1107_finish ();
  11179.     }
  11180.       ffelex_token_kill (ffesta_tokens[1]);
  11181.       return (ffelexHandler) ffesta_zero (t);
  11182.  
  11183.     case FFELEX_typeCOMMA:
  11184.       if (!ffesta_is_inhibited ())
  11185.     ffestc_R1107_item (NULL, ffesta_tokens[1]);
  11186.       ffelex_token_kill (ffesta_tokens[1]);
  11187.       return (ffelexHandler) ffestb_R11078_;
  11188.  
  11189.     case FFELEX_typePOINTS:
  11190.       return (ffelexHandler) ffestb_R11076_;
  11191.  
  11192.     default:
  11193.       break;
  11194.     }
  11195.  
  11196.   ffelex_token_kill (ffesta_tokens[1]);
  11197.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11198.   ffestc_R1107_finish ();
  11199.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11200. }
  11201.  
  11202. /* ffestb_R11076_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS
  11203.  
  11204.    return ffestb_R11076_;  // to lexer
  11205.  
  11206.    Make sure the statement has a valid form for the USE statement.  If it
  11207.    does, implement the statement.  */
  11208.  
  11209. static ffelexHandler
  11210. ffestb_R11076_ (ffelexToken t)
  11211. {
  11212.   switch (ffelex_token_type (t))
  11213.     {
  11214.     case FFELEX_typeNAME:
  11215.       if (!ffesta_is_inhibited ())
  11216.     ffestc_R1107_item (ffesta_tokens[1], t);
  11217.       ffelex_token_kill (ffesta_tokens[1]);
  11218.       return (ffelexHandler) ffestb_R11077_;
  11219.  
  11220.     default:
  11221.       break;
  11222.     }
  11223.  
  11224.   ffelex_token_kill (ffesta_tokens[1]);
  11225.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11226.   ffestc_R1107_finish ();
  11227.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11228. }
  11229.  
  11230. /* ffestb_R11077_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS NAME
  11231.  
  11232.    return ffestb_R11077_;  // to lexer
  11233.  
  11234.    Make sure the statement has a valid form for the USE statement.  If it
  11235.    does, implement the statement.  */
  11236.  
  11237. static ffelexHandler
  11238. ffestb_R11077_ (ffelexToken t)
  11239. {
  11240.   switch (ffelex_token_type (t))
  11241.     {
  11242.     case FFELEX_typeEOS:
  11243.     case FFELEX_typeSEMICOLON:
  11244.       if (!ffesta_is_inhibited ())
  11245.     ffestc_R1107_finish ();
  11246.       return (ffelexHandler) ffesta_zero (t);
  11247.  
  11248.     case FFELEX_typeCOMMA:
  11249.       return (ffelexHandler) ffestb_R11078_;
  11250.  
  11251.     default:
  11252.       break;
  11253.     }
  11254.  
  11255.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11256.   ffestc_R1107_finish ();
  11257.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11258. }
  11259.  
  11260. /* ffestb_R11078_ -- "USE" NAME COMMA "ONLY" COLON NAME POINTS NAME COMMA
  11261.  
  11262.    return ffestb_R11078_;  // to lexer
  11263.  
  11264.    Make sure the statement has a valid form for the USE statement.  If it
  11265.    does, implement the statement.  */
  11266.  
  11267. static ffelexHandler
  11268. ffestb_R11078_ (ffelexToken t)
  11269. {
  11270.   switch (ffelex_token_type (t))
  11271.     {
  11272.     case FFELEX_typeNAME:
  11273.       ffesta_tokens[1] = ffelex_token_use (t);
  11274.       return (ffelexHandler) ffestb_R11075_;
  11275.  
  11276.     default:
  11277.       break;
  11278.     }
  11279.  
  11280.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11281.   ffestc_R1107_finish ();
  11282.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11283. }
  11284.  
  11285. /* ffestb_R11079_ -- "USE" NAME COMMA
  11286.  
  11287.    return ffestb_R11079_;  // to lexer
  11288.  
  11289.    Make sure the statement has a valid form for the USE statement.  If it
  11290.    does, implement the statement.  */
  11291.  
  11292. static ffelexHandler
  11293. ffestb_R11079_ (ffelexToken t)
  11294. {
  11295.   switch (ffelex_token_type (t))
  11296.     {
  11297.     case FFELEX_typeNAME:
  11298.       ffesta_tokens[1] = ffelex_token_use (t);
  11299.       return (ffelexHandler) ffestb_R110710_;
  11300.  
  11301.     default:
  11302.       break;
  11303.     }
  11304.  
  11305.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11306.   ffestc_R1107_finish ();
  11307.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11308. }
  11309.  
  11310. /* ffestb_R110710_ -- "USE" NAME COMMA NAME
  11311.  
  11312.    return ffestb_R110710_;  // to lexer
  11313.  
  11314.    Make sure the statement has a valid form for the USE statement.  If it
  11315.    does, implement the statement.  */
  11316.  
  11317. static ffelexHandler
  11318. ffestb_R110710_ (ffelexToken t)
  11319. {
  11320.   switch (ffelex_token_type (t))
  11321.     {
  11322.     case FFELEX_typePOINTS:
  11323.       return (ffelexHandler) ffestb_R110711_;
  11324.  
  11325.     default:
  11326.       break;
  11327.     }
  11328.  
  11329.   ffelex_token_kill (ffesta_tokens[1]);
  11330.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11331.   ffestc_R1107_finish ();
  11332.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11333. }
  11334.  
  11335. /* ffestb_R110711_ -- "USE" NAME COMMA NAME POINTS
  11336.  
  11337.    return ffestb_R110711_;  // to lexer
  11338.  
  11339.    Make sure the statement has a valid form for the USE statement.  If it
  11340.    does, implement the statement.  */
  11341.  
  11342. static ffelexHandler
  11343. ffestb_R110711_ (ffelexToken t)
  11344. {
  11345.   switch (ffelex_token_type (t))
  11346.     {
  11347.     case FFELEX_typeNAME:
  11348.       if (!ffesta_is_inhibited ())
  11349.     ffestc_R1107_item (ffesta_tokens[1], t);
  11350.       ffelex_token_kill (ffesta_tokens[1]);
  11351.       return (ffelexHandler) ffestb_R110712_;
  11352.  
  11353.     default:
  11354.       break;
  11355.     }
  11356.  
  11357.   ffelex_token_kill (ffesta_tokens[1]);
  11358.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11359.   ffestc_R1107_finish ();
  11360.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11361. }
  11362.  
  11363. /* ffestb_R110712_ -- "USE" NAME COMMA NAME POINTS NAME
  11364.  
  11365.    return ffestb_R110712_;  // to lexer
  11366.  
  11367.    Make sure the statement has a valid form for the USE statement.  If it
  11368.    does, implement the statement.  */
  11369.  
  11370. static ffelexHandler
  11371. ffestb_R110712_ (ffelexToken t)
  11372. {
  11373.   switch (ffelex_token_type (t))
  11374.     {
  11375.     case FFELEX_typeEOS:
  11376.     case FFELEX_typeSEMICOLON:
  11377.       if (!ffesta_is_inhibited ())
  11378.     ffestc_R1107_finish ();
  11379.       return (ffelexHandler) ffesta_zero (t);
  11380.  
  11381.     case FFELEX_typeCOMMA:
  11382.       return (ffelexHandler) ffestb_R11079_;
  11383.  
  11384.     default:
  11385.       break;
  11386.     }
  11387.  
  11388.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "USE", t);
  11389.   ffestc_R1107_finish ();
  11390.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11391. }
  11392.  
  11393. #endif
  11394. /* ffestb_R1202 -- Parse the INTERFACE statement
  11395.  
  11396.    return ffestb_R1202;     // to lexer
  11397.  
  11398.    Make sure the statement has a valid form for the INTERFACE statement.
  11399.    If it does, implement the statement.
  11400.  
  11401.    15-May-90  JCB  1.1
  11402.       Allow INTERFACE by itself; missed this
  11403.       valid form when originally doing syntactic analysis code.     */
  11404.  
  11405. #if FFESTR_F90
  11406. ffelexHandler
  11407. ffestb_R1202 (ffelexToken t)
  11408. {
  11409.   ffeTokenLength i;
  11410.   char *p;
  11411.  
  11412.   switch (ffelex_token_type (ffesta_tokens[0]))
  11413.     {
  11414.     case FFELEX_typeNAME:
  11415.       if (ffesta_first_kw != FFESTR_firstINTERFACE)
  11416.     goto bad_0;        /* :::::::::::::::::::: */
  11417.       switch (ffelex_token_type (t))
  11418.     {
  11419.     case FFELEX_typeNAME:
  11420.       break;
  11421.  
  11422.     case FFELEX_typeEOS:
  11423.     case FFELEX_typeSEMICOLON:
  11424.       ffesta_confirmed ();
  11425.       if (!ffesta_is_inhibited ())
  11426.         ffestc_R1202 (FFESTP_definedoperatorNone, NULL);
  11427.       return (ffelexHandler) ffesta_zero (t);
  11428.  
  11429.     case FFELEX_typeCOMMA:
  11430.     case FFELEX_typeCOLONCOLON:
  11431.       ffesta_confirmed ();    /* Error, but clearly intended. */
  11432.       goto bad_1;        /* :::::::::::::::::::: */
  11433.  
  11434.     default:
  11435.       goto bad_1;        /* :::::::::::::::::::: */
  11436.     }
  11437.  
  11438.       ffesta_confirmed ();
  11439.       switch (ffesta_second_kw)
  11440.     {
  11441.     case FFESTR_secondOPERATOR:
  11442.       ffestb_local_.interface.operator = FFESTP_definedoperatorOPERATOR;
  11443.       break;
  11444.  
  11445.     case FFESTR_secondASSIGNMENT:
  11446.       ffestb_local_.interface.operator = FFESTP_definedoperatorASSIGNMENT;
  11447.       break;
  11448.  
  11449.     default:
  11450.       ffestb_local_.interface.operator = FFESTP_definedoperatorNone;
  11451.       break;
  11452.     }
  11453.       ffesta_tokens[1] = ffelex_token_use (t);
  11454.       return (ffelexHandler) ffestb_R12021_;
  11455.  
  11456.     case FFELEX_typeNAMES:
  11457.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlINTERFACE);
  11458.       switch (ffesta_first_kw)
  11459.     {
  11460.     case FFESTR_firstINTERFACEOPERATOR:
  11461.       if (*(ffelex_token_text (ffesta_tokens[0])
  11462.         + FFESTR_firstlINTERFACEOPERATOR) == '\0')
  11463.         ffestb_local_.interface.operator
  11464.           = FFESTP_definedoperatorOPERATOR;
  11465.       break;
  11466.  
  11467.     case FFESTR_firstINTERFACEASSGNMNT:
  11468.       if (*(ffelex_token_text (ffesta_tokens[0])
  11469.         + FFESTR_firstlINTERFACEASSGNMNT) == '\0')
  11470.         ffestb_local_.interface.operator
  11471.           = FFESTP_definedoperatorASSIGNMENT;
  11472.       break;
  11473.  
  11474.     case FFESTR_firstINTERFACE:
  11475.       ffestb_local_.interface.operator = FFESTP_definedoperatorNone;
  11476.       break;
  11477.  
  11478.     default:
  11479.       goto bad_0;        /* :::::::::::::::::::: */
  11480.     }
  11481.       switch (ffelex_token_type (t))
  11482.     {
  11483.     case FFELEX_typeCOMMA:
  11484.     case FFELEX_typeCOLONCOLON:
  11485.       ffesta_confirmed ();    /* Error, but clearly intended. */
  11486.       goto bad_1;        /* :::::::::::::::::::: */
  11487.  
  11488.     default:
  11489.       goto bad_1;        /* :::::::::::::::::::: */
  11490.  
  11491.     case FFELEX_typeOPEN_PAREN:
  11492.     case FFELEX_typeOPEN_ARRAY:    /* Sigh. */
  11493.       break;
  11494.  
  11495.     case FFELEX_typeEOS:
  11496.     case FFELEX_typeSEMICOLON:
  11497.       ffesta_confirmed ();
  11498.       if (*p == '\0')
  11499.         {
  11500.           if (!ffesta_is_inhibited ())
  11501.         ffestc_R1202 (FFESTP_definedoperatorNone, NULL);
  11502.           return (ffelexHandler) ffesta_zero (t);
  11503.         }
  11504.       break;
  11505.     }
  11506.       if (!ffesrc_is_name_init (*p))
  11507.     goto bad_i;        /* :::::::::::::::::::: */
  11508.       ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  11509.       return (ffelexHandler) ffestb_R12021_ (t);
  11510.  
  11511.     default:
  11512.       goto bad_0;        /* :::::::::::::::::::: */
  11513.     }
  11514.  
  11515. bad_0:                /* :::::::::::::::::::: */
  11516.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", ffesta_tokens[0]);
  11517.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11518.  
  11519. bad_1:                /* :::::::::::::::::::: */
  11520.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
  11521.   return (ffelexHandler) ffelex_swallow_tokens (t,
  11522.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  11523.  
  11524. bad_i:                /* :::::::::::::::::::: */
  11525.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "INTERFACE", ffesta_tokens[0], i, t);
  11526.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11527. }
  11528.  
  11529. /* ffestb_R12021_ -- "INTERFACE" NAME
  11530.  
  11531.    return ffestb_R12021_;  // to lexer
  11532.  
  11533.    Make sure the statement has a valid form for the INTERFACE statement.  If
  11534.    it does, implement the statement.  */
  11535.  
  11536. static ffelexHandler
  11537. ffestb_R12021_ (ffelexToken t)
  11538. {
  11539.   ffestb_local_.interface.slash = TRUE;    /* Slash follows open paren. */
  11540.  
  11541.   switch (ffelex_token_type (t))
  11542.     {
  11543.     case FFELEX_typeEOS:
  11544.     case FFELEX_typeSEMICOLON:
  11545.       if (!ffesta_is_inhibited ())
  11546.     ffestc_R1202 (FFESTP_definedoperatorNone, ffesta_tokens[1]);
  11547.       ffelex_token_kill (ffesta_tokens[1]);
  11548.       return (ffelexHandler) ffesta_zero (t);
  11549.  
  11550.     case FFELEX_typeOPEN_PAREN:
  11551.       ffestb_local_.interface.slash = FALSE;    /* Slash doesn't follow. */
  11552.       /* Fall through. */
  11553.     case FFELEX_typeOPEN_ARRAY:
  11554.       switch (ffestb_local_.interface.operator)
  11555.     {
  11556.     case FFESTP_definedoperatorNone:
  11557.       break;
  11558.  
  11559.     case FFESTP_definedoperatorOPERATOR:
  11560.       ffestb_local_.interface.assignment = FALSE;
  11561.       return (ffelexHandler) ffestb_R12022_;
  11562.  
  11563.     case FFESTP_definedoperatorASSIGNMENT:
  11564.       ffestb_local_.interface.assignment = TRUE;
  11565.       return (ffelexHandler) ffestb_R12022_;
  11566.  
  11567.     default:
  11568.       assert (FALSE);
  11569.     }
  11570.       break;
  11571.  
  11572.     case FFELEX_typeCOMMA:
  11573.     case FFELEX_typeCOLONCOLON:
  11574.       ffesta_confirmed ();    /* Error, but clearly intended. */
  11575.       break;
  11576.  
  11577.     default:
  11578.       break;
  11579.     }
  11580.  
  11581.   ffelex_token_kill (ffesta_tokens[1]);
  11582.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
  11583.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11584. }
  11585.  
  11586. /* ffestb_R12022_ -- "INTERFACE" "OPERATOR/ASSIGNMENT" OPEN_PAREN
  11587.  
  11588.    return ffestb_R12022_;  // to lexer
  11589.  
  11590.    Make sure the statement has a valid form for the INTERFACE statement.  If
  11591.    it does, implement the statement.  */
  11592.  
  11593. static ffelexHandler
  11594. ffestb_R12022_ (ffelexToken t)
  11595. {
  11596.   ffesta_tokens[2] = ffelex_token_use (t);
  11597.  
  11598.   switch (ffelex_token_type (t))
  11599.     {
  11600.     case FFELEX_typePERIOD:
  11601.       if (ffestb_local_.interface.slash)
  11602.     break;
  11603.       return (ffelexHandler) ffestb_R12023_;
  11604.  
  11605.     case FFELEX_typePOWER:
  11606.       if (ffestb_local_.interface.slash)
  11607.     break;
  11608.       ffestb_local_.interface.operator = FFESTP_definedoperatorPOWER;
  11609.       return (ffelexHandler) ffestb_R12025_;
  11610.  
  11611.     case FFELEX_typeASTERISK:
  11612.       if (ffestb_local_.interface.slash)
  11613.     break;
  11614.       ffestb_local_.interface.operator = FFESTP_definedoperatorMULT;
  11615.       return (ffelexHandler) ffestb_R12025_;
  11616.  
  11617.     case FFELEX_typePLUS:
  11618.       if (ffestb_local_.interface.slash)
  11619.     break;
  11620.       ffestb_local_.interface.operator = FFESTP_definedoperatorADD;
  11621.       return (ffelexHandler) ffestb_R12025_;
  11622.  
  11623.     case FFELEX_typeCONCAT:
  11624.       if (ffestb_local_.interface.slash)
  11625.     break;
  11626.       ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
  11627.       return (ffelexHandler) ffestb_R12025_;
  11628.  
  11629.     case FFELEX_typeSLASH:
  11630.       if (ffestb_local_.interface.slash)
  11631.     {
  11632.       ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
  11633.       return (ffelexHandler) ffestb_R12025_;
  11634.     }
  11635.       ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
  11636.       return (ffelexHandler) ffestb_R12025_;
  11637.  
  11638.     case FFELEX_typeMINUS:
  11639.       if (ffestb_local_.interface.slash)
  11640.     break;
  11641.       ffestb_local_.interface.operator = FFESTP_definedoperatorSUBTRACT;
  11642.       return (ffelexHandler) ffestb_R12025_;
  11643.  
  11644.     case FFELEX_typeREL_EQ:
  11645.       if (ffestb_local_.interface.slash)
  11646.     break;
  11647.       ffestb_local_.interface.operator = FFESTP_definedoperatorEQ;
  11648.       return (ffelexHandler) ffestb_R12025_;
  11649.  
  11650.     case FFELEX_typeREL_NE:
  11651.       if (ffestb_local_.interface.slash)
  11652.     break;
  11653.       ffestb_local_.interface.operator = FFESTP_definedoperatorNE;
  11654.       return (ffelexHandler) ffestb_R12025_;
  11655.  
  11656.     case FFELEX_typeOPEN_ANGLE:
  11657.       if (ffestb_local_.interface.slash)
  11658.     break;
  11659.       ffestb_local_.interface.operator = FFESTP_definedoperatorLT;
  11660.       return (ffelexHandler) ffestb_R12025_;
  11661.  
  11662.     case FFELEX_typeREL_LE:
  11663.       if (ffestb_local_.interface.slash)
  11664.     break;
  11665.       ffestb_local_.interface.operator = FFESTP_definedoperatorLE;
  11666.       return (ffelexHandler) ffestb_R12025_;
  11667.  
  11668.     case FFELEX_typeCLOSE_ANGLE:
  11669.       if (ffestb_local_.interface.slash)
  11670.     break;
  11671.       ffestb_local_.interface.operator = FFESTP_definedoperatorGT;
  11672.       return (ffelexHandler) ffestb_R12025_;
  11673.  
  11674.     case FFELEX_typeREL_GE:
  11675.       if (ffestb_local_.interface.slash)
  11676.     break;
  11677.       ffestb_local_.interface.operator = FFESTP_definedoperatorGE;
  11678.       return (ffelexHandler) ffestb_R12025_;
  11679.  
  11680.     case FFELEX_typeEQUALS:
  11681.       if (ffestb_local_.interface.slash)
  11682.     {
  11683.       ffestb_local_.interface.operator = FFESTP_definedoperatorNE;
  11684.       return (ffelexHandler) ffestb_R12025_;
  11685.     }
  11686.       ffestb_local_.interface.operator = FFESTP_definedoperatorASSIGNMENT;
  11687.       return (ffelexHandler) ffestb_R12025_;
  11688.  
  11689.     case FFELEX_typeCLOSE_ARRAY:
  11690.       if (!ffestb_local_.interface.slash)
  11691.     {
  11692.       ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
  11693.       return (ffelexHandler) ffestb_R12026_;
  11694.     }
  11695.       ffestb_local_.interface.operator = FFESTP_definedoperatorCONCAT;
  11696.       return (ffelexHandler) ffestb_R12026_;
  11697.  
  11698.     case FFELEX_typeCLOSE_PAREN:
  11699.       if (!ffestb_local_.interface.slash)
  11700.     break;
  11701.       ffestb_local_.interface.operator = FFESTP_definedoperatorDIVIDE;
  11702.       return (ffelexHandler) ffestb_R12026_;
  11703.  
  11704.     default:
  11705.       break;
  11706.     }
  11707.  
  11708.   ffelex_token_kill (ffesta_tokens[1]);
  11709.   ffelex_token_kill (ffesta_tokens[2]);
  11710.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
  11711.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11712. }
  11713.  
  11714. /* ffestb_R12023_ -- "INTERFACE" NAME OPEN_PAREN PERIOD
  11715.  
  11716.    return ffestb_R12023_;  // to lexer
  11717.  
  11718.    Make sure the statement has a valid form for the INTERFACE statement.  If
  11719.    it does, implement the statement.  */
  11720.  
  11721. static ffelexHandler
  11722. ffestb_R12023_ (ffelexToken t)
  11723. {
  11724.   switch (ffelex_token_type (t))
  11725.     {
  11726.     case FFELEX_typeNAME:
  11727.       ffelex_token_kill (ffesta_tokens[2]);
  11728.       ffesta_tokens[2] = ffelex_token_use (t);
  11729.       return (ffelexHandler) ffestb_R12024_;
  11730.  
  11731.     default:
  11732.       break;
  11733.     }
  11734.  
  11735.   ffelex_token_kill (ffesta_tokens[1]);
  11736.   ffelex_token_kill (ffesta_tokens[2]);
  11737.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
  11738.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11739. }
  11740.  
  11741. /* ffestb_R12024_ -- "INTERFACE" NAME OPEN_PAREN PERIOD NAME
  11742.  
  11743.    return ffestb_R12024_;  // to lexer
  11744.  
  11745.    Make sure the statement has a valid form for the INTERFACE statement.  If
  11746.    it does, implement the statement.  */
  11747.  
  11748. static ffelexHandler
  11749. ffestb_R12024_ (ffelexToken t)
  11750. {
  11751.   switch (ffelex_token_type (t))
  11752.     {
  11753.     case FFELEX_typePERIOD:
  11754.       return (ffelexHandler) ffestb_R12025_;
  11755.  
  11756.     default:
  11757.       break;
  11758.     }
  11759.  
  11760.   ffelex_token_kill (ffesta_tokens[1]);
  11761.   ffelex_token_kill (ffesta_tokens[2]);
  11762.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
  11763.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11764. }
  11765.  
  11766. /* ffestb_R12025_ -- "INTERFACE" NAME OPEN_PAREN operator
  11767.  
  11768.    return ffestb_R12025_;  // to lexer
  11769.  
  11770.    Make sure the statement has a valid form for the INTERFACE statement.  If
  11771.    it does, implement the statement.  */
  11772.  
  11773. static ffelexHandler
  11774. ffestb_R12025_ (ffelexToken t)
  11775. {
  11776.   switch (ffelex_token_type (t))
  11777.     {
  11778.     case FFELEX_typeCLOSE_PAREN:
  11779.       return (ffelexHandler) ffestb_R12026_;
  11780.  
  11781.     default:
  11782.       break;
  11783.     }
  11784.  
  11785.   ffelex_token_kill (ffesta_tokens[1]);
  11786.   ffelex_token_kill (ffesta_tokens[2]);
  11787.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
  11788.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11789. }
  11790.  
  11791. /* ffestb_R12026_ -- "INTERFACE" NAME OPEN_PAREN operator CLOSE_PAREN
  11792.  
  11793.    return ffestb_R12026_;  // to lexer
  11794.  
  11795.    Make sure the statement has a valid form for the INTERFACE statement.  If
  11796.    it does, implement the statement.  */
  11797.  
  11798. static ffelexHandler
  11799. ffestb_R12026_ (ffelexToken t)
  11800. {
  11801.   char *p;
  11802.  
  11803.   switch (ffelex_token_type (t))
  11804.     {
  11805.     case FFELEX_typeEOS:
  11806.     case FFELEX_typeSEMICOLON:
  11807.       ffesta_confirmed ();
  11808.       if (ffestb_local_.interface.assignment
  11809.       && (ffestb_local_.interface.operator
  11810.           != FFESTP_definedoperatorASSIGNMENT))
  11811.     {
  11812.       ffebad_start (FFEBAD_INTERFACE_ASSIGNMENT);
  11813.       ffebad_here (0, ffelex_token_where_line (ffesta_tokens[1]),
  11814.                ffelex_token_where_column (ffesta_tokens[1]));
  11815.       ffebad_here (1, ffelex_token_where_line (ffesta_tokens[2]),
  11816.                ffelex_token_where_column (ffesta_tokens[2]));
  11817.       ffebad_finish ();
  11818.     }
  11819.       switch (ffelex_token_type (ffesta_tokens[2]))
  11820.     {
  11821.     case FFELEX_typeNAME:
  11822.       switch (ffestr_other (ffesta_tokens[2]))
  11823.         {
  11824.         case FFESTR_otherNOT:
  11825.           if (!ffesta_is_inhibited ())
  11826.         ffestc_R1202 (FFESTP_definedoperatorNOT, NULL);
  11827.           break;
  11828.  
  11829.         case FFESTR_otherAND:
  11830.           if (!ffesta_is_inhibited ())
  11831.         ffestc_R1202 (FFESTP_definedoperatorAND, NULL);
  11832.           break;
  11833.  
  11834.         case FFESTR_otherOR:
  11835.           if (!ffesta_is_inhibited ())
  11836.         ffestc_R1202 (FFESTP_definedoperatorOR, NULL);
  11837.           break;
  11838.  
  11839.         case FFESTR_otherEQV:
  11840.           if (!ffesta_is_inhibited ())
  11841.         ffestc_R1202 (FFESTP_definedoperatorEQV, NULL);
  11842.           break;
  11843.  
  11844.         case FFESTR_otherNEQV:
  11845.           if (!ffesta_is_inhibited ())
  11846.         ffestc_R1202 (FFESTP_definedoperatorNEQV, NULL);
  11847.           break;
  11848.  
  11849.         case FFESTR_otherEQ:
  11850.           if (!ffesta_is_inhibited ())
  11851.         ffestc_R1202 (FFESTP_definedoperatorEQ, NULL);
  11852.           break;
  11853.  
  11854.         case FFESTR_otherNE:
  11855.           if (!ffesta_is_inhibited ())
  11856.         ffestc_R1202 (FFESTP_definedoperatorNE, NULL);
  11857.           break;
  11858.  
  11859.         case FFESTR_otherLT:
  11860.           if (!ffesta_is_inhibited ())
  11861.         ffestc_R1202 (FFESTP_definedoperatorLT, NULL);
  11862.           break;
  11863.  
  11864.         case FFESTR_otherLE:
  11865.           if (!ffesta_is_inhibited ())
  11866.         ffestc_R1202 (FFESTP_definedoperatorLE, NULL);
  11867.           break;
  11868.  
  11869.         case FFESTR_otherGT:
  11870.           if (!ffesta_is_inhibited ())
  11871.         ffestc_R1202 (FFESTP_definedoperatorGT, NULL);
  11872.           break;
  11873.  
  11874.         case FFESTR_otherGE:
  11875.           if (!ffesta_is_inhibited ())
  11876.         ffestc_R1202 (FFESTP_definedoperatorGE, NULL);
  11877.           break;
  11878.  
  11879.         default:
  11880.           for (p = ffelex_token_text (ffesta_tokens[2]); *p != '\0'; ++p)
  11881.         {
  11882.           if (!isalpha (*p))
  11883.             {
  11884.               ffelex_token_kill (ffesta_tokens[1]);
  11885.               ffelex_token_kill (ffesta_tokens[2]);
  11886.               ffesta_ffebad_1t (FFEBAD_INTERFACE_NONLETTER,
  11887.                     ffesta_tokens[2]);
  11888.               return (ffelexHandler) ffelex_swallow_tokens (t,
  11889.                            (ffelexHandler) ffesta_zero);
  11890.             }
  11891.         }
  11892.           if (!ffesta_is_inhibited ())
  11893.         ffestc_R1202 (FFESTP_definedoperatorOPERATOR,
  11894.                   ffesta_tokens[2]);
  11895.         }
  11896.       break;
  11897.  
  11898.     case FFELEX_typeEQUALS:
  11899.       if (!ffestb_local_.interface.assignment
  11900.           && (ffestb_local_.interface.operator
  11901.           == FFESTP_definedoperatorASSIGNMENT))
  11902.         {
  11903.           ffebad_start (FFEBAD_INTERFACE_OPERATOR);
  11904.           ffebad_here (0, ffelex_token_where_line (ffesta_tokens[1]),
  11905.                ffelex_token_where_column (ffesta_tokens[1]));
  11906.           ffebad_here (1, ffelex_token_where_line (ffesta_tokens[2]),
  11907.                ffelex_token_where_column (ffesta_tokens[2]));
  11908.           ffebad_finish ();
  11909.         }
  11910.       if (!ffesta_is_inhibited ())
  11911.         ffestc_R1202 (ffestb_local_.interface.operator, NULL);
  11912.       break;
  11913.  
  11914.     default:
  11915.       if (!ffesta_is_inhibited ())
  11916.         ffestc_R1202 (ffestb_local_.interface.operator, NULL);
  11917.     }
  11918.       ffelex_token_kill (ffesta_tokens[1]);
  11919.       ffelex_token_kill (ffesta_tokens[2]);
  11920.       return (ffelexHandler) ffesta_zero (t);
  11921.  
  11922.     default:
  11923.       break;
  11924.     }
  11925.  
  11926.   ffelex_token_kill (ffesta_tokens[1]);
  11927.   ffelex_token_kill (ffesta_tokens[2]);
  11928.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INTERFACE", t);
  11929.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  11930. }
  11931.  
  11932. #endif
  11933. /* ffestb_S3P4 -- Parse the INCLUDE line
  11934.  
  11935.    return ffestb_S3P4;    // to lexer
  11936.  
  11937.    Make sure the statement has a valid form for the INCLUDE line.  If it
  11938.    does, implement the statement.  */
  11939.  
  11940. ffelexHandler
  11941. ffestb_S3P4 (ffelexToken t)
  11942. {
  11943.   ffeTokenLength i;
  11944.   char *p;
  11945.   ffelexHandler next;
  11946.   ffelexToken nt;
  11947.   ffelexToken ut;
  11948.  
  11949.   switch (ffelex_token_type (ffesta_tokens[0]))
  11950.     {
  11951.     case FFELEX_typeNAME:
  11952.       if (ffesta_first_kw != FFESTR_firstINCLUDE)
  11953.     goto bad_0;        /* :::::::::::::::::::: */
  11954.       switch (ffelex_token_type (t))
  11955.     {
  11956.     case FFELEX_typeNUMBER:
  11957.     case FFELEX_typeAPOSTROPHE:
  11958.     case FFELEX_typeQUOTE:
  11959.       break;
  11960.  
  11961.     default:
  11962.       goto bad_1;        /* :::::::::::::::::::: */
  11963.     }
  11964.       ffesta_confirmed ();
  11965.       return (ffelexHandler) (*((ffelexHandler)
  11966.             ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextINCLUDE,
  11967.                  (ffeexprCallback) ffestb_S3P41_)))
  11968.     (t);
  11969.  
  11970.     case FFELEX_typeNAMES:
  11971.       if (ffesta_first_kw != FFESTR_firstINCLUDE)
  11972.     goto bad_0;        /* :::::::::::::::::::: */
  11973.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlINCLUDE);
  11974.       switch (ffelex_token_type (t))
  11975.     {
  11976.     default:
  11977.       goto bad_1;        /* :::::::::::::::::::: */
  11978.  
  11979.     case FFELEX_typeAPOSTROPHE:
  11980.     case FFELEX_typeQUOTE:
  11981.       break;
  11982.     }
  11983.       ffesta_confirmed ();
  11984.       if (*p == '\0')
  11985.     return (ffelexHandler) (*((ffelexHandler)
  11986.             ffeexpr_rhs (ffesta_output_pool, FFEEXPR_contextINCLUDE,
  11987.                  (ffeexprCallback) ffestb_S3P41_)))
  11988.       (t);
  11989.       if (!isdigit (*p))
  11990.     goto bad_i;        /* :::::::::::::::::::: */
  11991.       nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
  11992.       p += ffelex_token_length (nt);
  11993.       i += ffelex_token_length (nt);
  11994.       if ((*p != '_') || (++i, *++p != '\0'))
  11995.     {
  11996.       ffelex_token_kill (nt);
  11997.       goto bad_i;        /* :::::::::::::::::::: */
  11998.     }
  11999.       ut = ffelex_token_uscore_from_names (ffesta_tokens[0], i - 1);
  12000.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs
  12001.                 (ffesta_output_pool, FFEEXPR_contextINCLUDE,
  12002.                  (ffeexprCallback) ffestb_S3P41_)))
  12003.     (nt);
  12004.       ffelex_token_kill (nt);
  12005.       next = (ffelexHandler) (*next) (ut);
  12006.       ffelex_token_kill (ut);
  12007.       return (ffelexHandler) (*next) (t);
  12008.  
  12009.     default:
  12010.       goto bad_0;        /* :::::::::::::::::::: */
  12011.     }
  12012.  
  12013. bad_0:                /* :::::::::::::::::::: */
  12014.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", ffesta_tokens[0]);
  12015.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12016.  
  12017. bad_1:                /* :::::::::::::::::::: */
  12018.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", t);
  12019.   return (ffelexHandler) ffelex_swallow_tokens (t,
  12020.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  12021.  
  12022. bad_i:                /* :::::::::::::::::::: */
  12023.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "INCLUDE", ffesta_tokens[0], i, t);
  12024.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12025. }
  12026.  
  12027. /* ffestb_S3P41_ -- "INCLUDE" [NUMBER "_"] expr
  12028.  
  12029.    (ffestb_S3P41_)  // to expression handler
  12030.  
  12031.    Make sure the next token is an EOS, but not a SEMICOLON.  */
  12032.  
  12033. static ffelexHandler
  12034. ffestb_S3P41_ (ffelexToken ft, ffebld expr, ffelexToken t)
  12035. {
  12036.   switch (ffelex_token_type (t))
  12037.     {
  12038.     case FFELEX_typeEOS:
  12039.     case FFELEX_typeSEMICOLON:
  12040.       if (expr == NULL)
  12041.     break;
  12042.       if (!ffesta_is_inhibited ())
  12043.     {
  12044.       if (ffe_is_pedantic ()
  12045.           && ((ffelex_token_type (t) == FFELEX_typeSEMICOLON)
  12046.           || ffesta_line_has_semicolons))
  12047.         {
  12048.           ffebad_start_msg ("INCLUDE at %0 not the only statement on the source line", FFEBAD_severityWARNING);
  12049.           ffebad_here (0, ffelex_token_where_line (ffesta_tokens[0]),
  12050.                ffelex_token_where_column (ffesta_tokens[0]));
  12051.           ffebad_finish ();
  12052.         }
  12053.       ffestc_S3P4 (expr, ft);
  12054.     }
  12055.       return (ffelexHandler) ffesta_zero (t);
  12056.  
  12057.     default:
  12058.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INCLUDE", t);
  12059.       break;
  12060.     }
  12061.  
  12062.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12063. }
  12064.  
  12065. /* ffestb_V012 -- Parse the MAP statement
  12066.  
  12067.    return ffestb_V012;    // to lexer
  12068.  
  12069.    Make sure the statement has a valid form for the MAP statement.  If
  12070.    it does, implement the statement.  */
  12071.  
  12072. #if FFESTR_VXT
  12073. ffelexHandler
  12074. ffestb_V012 (ffelexToken t)
  12075. {
  12076.   char *p;
  12077.   ffeTokenLength i;
  12078.  
  12079.   switch (ffelex_token_type (ffesta_tokens[0]))
  12080.     {
  12081.     case FFELEX_typeNAME:
  12082.       if (ffesta_first_kw != FFESTR_firstMAP)
  12083.     goto bad_0;        /* :::::::::::::::::::: */
  12084.       break;
  12085.  
  12086.     case FFELEX_typeNAMES:
  12087.       if (ffesta_first_kw != FFESTR_firstMAP)
  12088.     goto bad_0;        /* :::::::::::::::::::: */
  12089.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlMAP)
  12090.     {
  12091.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlMAP);
  12092.       goto bad_i;        /* :::::::::::::::::::: */
  12093.     }
  12094.       break;
  12095.  
  12096.     default:
  12097.       goto bad_0;        /* :::::::::::::::::::: */
  12098.     }
  12099.  
  12100.   switch (ffelex_token_type (t))
  12101.     {
  12102.     case FFELEX_typeEOS:
  12103.     case FFELEX_typeSEMICOLON:
  12104.       ffesta_confirmed ();
  12105.       if (!ffesta_is_inhibited ())
  12106.     ffestc_V012 ();
  12107.       return (ffelexHandler) ffesta_zero (t);
  12108.  
  12109.     case FFELEX_typeCOMMA:
  12110.     case FFELEX_typeCOLONCOLON:
  12111.       ffesta_confirmed ();    /* Error, but clearly intended. */
  12112.       goto bad_1;        /* :::::::::::::::::::: */
  12113.  
  12114.     default:
  12115.       goto bad_1;        /* :::::::::::::::::::: */
  12116.     }
  12117.  
  12118. bad_0:                /* :::::::::::::::::::: */
  12119.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MAP", ffesta_tokens[0]);
  12120.   return (ffelexHandler) ffelex_swallow_tokens (t,
  12121.                         (ffelexHandler) ffesta_zero);    /* Invalid first token. */
  12122.  
  12123. bad_1:                /* :::::::::::::::::::: */
  12124.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "MAP", t);
  12125.   return (ffelexHandler) ffelex_swallow_tokens (t,
  12126.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  12127.  
  12128. bad_i:                /* :::::::::::::::::::: */
  12129.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "MAP", ffesta_tokens[0], i, t);
  12130.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12131. }
  12132.  
  12133. #endif
  12134. /* ffestb_V014 -- Parse the VOLATILE statement
  12135.  
  12136.    return ffestb_V014;    // to lexer
  12137.  
  12138.    Make sure the statement has a valid form for the VOLATILE statement.     If it
  12139.    does, implement the statement.  */
  12140.  
  12141. ffelexHandler
  12142. ffestb_V014 (ffelexToken t)
  12143. {
  12144.   ffeTokenLength i;
  12145.   char *p;
  12146.   ffelexToken nt;
  12147.   ffelexHandler next;
  12148.  
  12149.   switch (ffelex_token_type (ffesta_tokens[0]))
  12150.     {
  12151.     case FFELEX_typeNAME:
  12152.       if (ffesta_first_kw != FFESTR_firstVOLATILE)
  12153.     goto bad_0;        /* :::::::::::::::::::: */
  12154.       switch (ffelex_token_type (t))
  12155.     {
  12156.     case FFELEX_typeEOS:
  12157.     case FFELEX_typeSEMICOLON:
  12158.     case FFELEX_typeCOMMA:
  12159.       ffesta_confirmed ();    /* Error, but clearly intended. */
  12160.       goto bad_1;        /* :::::::::::::::::::: */
  12161.  
  12162.     default:
  12163.       goto bad_1;        /* :::::::::::::::::::: */
  12164.  
  12165.     case FFELEX_typeNAME:
  12166.     case FFELEX_typeSLASH:
  12167.       ffesta_confirmed ();
  12168.       if (!ffesta_is_inhibited ())
  12169.         ffestc_V014_start ();
  12170.       return (ffelexHandler) ffestb_V0141_ (t);
  12171.  
  12172.     case FFELEX_typeCOLONCOLON:
  12173.       ffesta_confirmed ();
  12174.       if (!ffesta_is_inhibited ())
  12175.         ffestc_V014_start ();
  12176.       return (ffelexHandler) ffestb_V0141_;
  12177.     }
  12178.  
  12179.     case FFELEX_typeNAMES:
  12180.       if (ffesta_first_kw != FFESTR_firstVOLATILE)
  12181.     goto bad_0;        /* :::::::::::::::::::: */
  12182.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlVOLATILE);
  12183.       switch (ffelex_token_type (t))
  12184.     {
  12185.     default:
  12186.       goto bad_1;        /* :::::::::::::::::::: */
  12187.  
  12188.     case FFELEX_typeCOMMA:
  12189.     case FFELEX_typeEOS:
  12190.     case FFELEX_typeSEMICOLON:
  12191.       ffesta_confirmed ();
  12192.       break;
  12193.  
  12194.     case FFELEX_typeSLASH:
  12195.       ffesta_confirmed ();
  12196.       if (*p != '\0')
  12197.         goto bad_i;        /* :::::::::::::::::::: */
  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 (*p != '\0')
  12205.         goto bad_i;        /* :::::::::::::::::::: */
  12206.       if (!ffesta_is_inhibited ())
  12207.         ffestc_V014_start ();
  12208.       return (ffelexHandler) ffestb_V0141_;
  12209.     }
  12210.  
  12211.       /* Here, we have at least one char after "VOLATILE" and t is COMMA or
  12212.          EOS/SEMICOLON. */
  12213.  
  12214.       if (!ffesrc_is_name_init (*p))
  12215.     goto bad_i;        /* :::::::::::::::::::: */
  12216.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  12217.       if (!ffesta_is_inhibited ())
  12218.     ffestc_V014_start ();
  12219.       next = (ffelexHandler) ffestb_V0141_ (nt);
  12220.       ffelex_token_kill (nt);
  12221.       return (ffelexHandler) (*next) (t);
  12222.  
  12223.     default:
  12224.       goto bad_0;        /* :::::::::::::::::::: */
  12225.     }
  12226.  
  12227. bad_0:                /* :::::::::::::::::::: */
  12228.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", ffesta_tokens[0]);
  12229.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12230.  
  12231. bad_1:                /* :::::::::::::::::::: */
  12232.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
  12233.   return (ffelexHandler) ffelex_swallow_tokens (t,
  12234.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  12235.  
  12236. bad_i:                /* :::::::::::::::::::: */
  12237.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "VOLATILE", ffesta_tokens[0], i, t);
  12238.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12239. }
  12240.  
  12241. /* ffestb_V0141_ -- "VOLATILE" [COLONCOLON]
  12242.  
  12243.    return ffestb_V0141_;  // to lexer
  12244.  
  12245.    Handle NAME or SLASH.  */
  12246.  
  12247. static ffelexHandler
  12248. ffestb_V0141_ (ffelexToken t)
  12249. {
  12250.   switch (ffelex_token_type (t))
  12251.     {
  12252.     case FFELEX_typeNAME:
  12253.       ffestb_local_.V014.is_cblock = FALSE;
  12254.       ffesta_tokens[1] = ffelex_token_use (t);
  12255.       return (ffelexHandler) ffestb_V0144_;
  12256.  
  12257.     case FFELEX_typeSLASH:
  12258.       ffestb_local_.V014.is_cblock = TRUE;
  12259.       return (ffelexHandler) ffestb_V0142_;
  12260.  
  12261.     default:
  12262.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
  12263.       break;
  12264.     }
  12265.  
  12266.   if (!ffesta_is_inhibited ())
  12267.     ffestc_V014_finish ();
  12268.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12269. }
  12270.  
  12271. /* ffestb_V0142_ -- "VOLATILE" [COLONCOLON] SLASH
  12272.  
  12273.    return ffestb_V0142_;  // to lexer
  12274.  
  12275.    Handle NAME.     */
  12276.  
  12277. static ffelexHandler
  12278. ffestb_V0142_ (ffelexToken t)
  12279. {
  12280.   switch (ffelex_token_type (t))
  12281.     {
  12282.     case FFELEX_typeNAME:
  12283.       ffesta_tokens[1] = ffelex_token_use (t);
  12284.       return (ffelexHandler) ffestb_V0143_;
  12285.  
  12286.     default:
  12287.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
  12288.       break;
  12289.     }
  12290.  
  12291.   if (!ffesta_is_inhibited ())
  12292.     ffestc_V014_finish ();
  12293.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12294. }
  12295.  
  12296. /* ffestb_V0143_ -- "VOLATILE" [COLONCOLON] SLASH NAME
  12297.  
  12298.    return ffestb_V0143_;  // to lexer
  12299.  
  12300.    Handle SLASH.  */
  12301.  
  12302. static ffelexHandler
  12303. ffestb_V0143_ (ffelexToken t)
  12304. {
  12305.   switch (ffelex_token_type (t))
  12306.     {
  12307.     case FFELEX_typeSLASH:
  12308.       return (ffelexHandler) ffestb_V0144_;
  12309.  
  12310.     default:
  12311.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
  12312.       break;
  12313.     }
  12314.  
  12315.   if (!ffesta_is_inhibited ())
  12316.     ffestc_V014_finish ();
  12317.   ffelex_token_kill (ffesta_tokens[1]);
  12318.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12319. }
  12320.  
  12321. /* ffestb_V0144_ -- "VOLATILE" [COLONCOLON] R523
  12322.  
  12323.    return ffestb_V0144_;  // to lexer
  12324.  
  12325.    Handle COMMA or EOS/SEMICOLON.  */
  12326.  
  12327. static ffelexHandler
  12328. ffestb_V0144_ (ffelexToken t)
  12329. {
  12330.   switch (ffelex_token_type (t))
  12331.     {
  12332.     case FFELEX_typeCOMMA:
  12333.       if (!ffesta_is_inhibited ())
  12334.     {
  12335.       if (ffestb_local_.V014.is_cblock)
  12336.         ffestc_V014_item_cblock (ffesta_tokens[1]);
  12337.       else
  12338.         ffestc_V014_item_object (ffesta_tokens[1]);
  12339.     }
  12340.       ffelex_token_kill (ffesta_tokens[1]);
  12341.       return (ffelexHandler) ffestb_V0141_;
  12342.  
  12343.     case FFELEX_typeEOS:
  12344.     case FFELEX_typeSEMICOLON:
  12345.       if (!ffesta_is_inhibited ())
  12346.     {
  12347.       if (ffestb_local_.V014.is_cblock)
  12348.         ffestc_V014_item_cblock (ffesta_tokens[1]);
  12349.       else
  12350.         ffestc_V014_item_object (ffesta_tokens[1]);
  12351.       ffestc_V014_finish ();
  12352.     }
  12353.       ffelex_token_kill (ffesta_tokens[1]);
  12354.       return (ffelexHandler) ffesta_zero (t);
  12355.  
  12356.     default:
  12357.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "VOLATILE", t);
  12358.       break;
  12359.     }
  12360.  
  12361.   if (!ffesta_is_inhibited ())
  12362.     ffestc_V014_finish ();
  12363.   ffelex_token_kill (ffesta_tokens[1]);
  12364.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12365. }
  12366.  
  12367. /* ffestb_V025 -- Parse the DEFINEFILE statement
  12368.  
  12369.    return ffestb_V025;    // to lexer
  12370.  
  12371.    Make sure the statement has a valid form for the DEFINEFILE statement.
  12372.    If it does, implement the statement.     */
  12373.  
  12374. #if FFESTR_VXT
  12375. ffelexHandler
  12376. ffestb_V025 (ffelexToken t)
  12377. {
  12378.   ffeTokenLength i;
  12379.   char *p;
  12380.   ffelexToken nt;
  12381.   ffelexHandler next;
  12382.  
  12383.   ffestb_local_.V025.started = FALSE;
  12384.   switch (ffelex_token_type (ffesta_tokens[0]))
  12385.     {
  12386.     case FFELEX_typeNAME:
  12387.       switch (ffesta_first_kw)
  12388.     {
  12389.     case FFESTR_firstDEFINE:
  12390.       if ((ffelex_token_type (t) != FFELEX_typeNAME)
  12391.           || (ffesta_second_kw != FFESTR_secondFILE))
  12392.         goto bad_1;        /* :::::::::::::::::::: */
  12393.       ffesta_confirmed ();
  12394.       return (ffelexHandler) ffestb_V0251_;
  12395.  
  12396.     case FFESTR_firstDEFINEFILE:
  12397.       return (ffelexHandler) ffestb_V0251_ (t);
  12398.  
  12399.     default:
  12400.       goto bad_0;        /* :::::::::::::::::::: */
  12401.     }
  12402.  
  12403.     case FFELEX_typeNAMES:
  12404.       if (ffesta_first_kw != FFESTR_firstDEFINEFILE)
  12405.     goto bad_0;        /* :::::::::::::::::::: */
  12406.       switch (ffelex_token_type (t))
  12407.     {
  12408.     case FFELEX_typeCOMMA:
  12409.     case FFELEX_typeEOS:
  12410.     case FFELEX_typeSEMICOLON:
  12411.     case FFELEX_typeCOLONCOLON:
  12412.       ffesta_confirmed ();    /* Error, but clearly intended. */
  12413.       goto bad_1;        /* :::::::::::::::::::: */
  12414.  
  12415.     default:
  12416.       goto bad_1;        /* :::::::::::::::::::: */
  12417.  
  12418.     case FFELEX_typeOPEN_PAREN:
  12419.       break;
  12420.     }
  12421.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlDEFINEFILE);
  12422.       if (isdigit (*p))
  12423.     nt = ffelex_token_number_from_names (ffesta_tokens[0], i);
  12424.       else if (ffesrc_is_name_init (*p))
  12425.     nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  12426.       else
  12427.     goto bad_i;        /* :::::::::::::::::::: */
  12428.       next = (ffelexHandler) ffestb_V0251_ (nt);
  12429.       ffelex_token_kill (nt);
  12430.       return (ffelexHandler) (*next) (t);
  12431.  
  12432.     default:
  12433.       goto bad_0;        /* :::::::::::::::::::: */
  12434.     }
  12435.  
  12436. bad_0:                /* :::::::::::::::::::: */
  12437.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", ffesta_tokens[0]);
  12438.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12439.  
  12440. bad_1:                /* :::::::::::::::::::: */
  12441.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
  12442.   return (ffelexHandler) ffelex_swallow_tokens (t,
  12443.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  12444.  
  12445. bad_i:                /* :::::::::::::::::::: */
  12446.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", ffesta_tokens[0], i, t);
  12447.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12448. }
  12449.  
  12450. /* ffestb_V0251_ -- "DEFINEFILE" or "DEFINE" "FILE"
  12451.  
  12452.    return ffestb_V0251_;  // to lexer
  12453.  
  12454.    Make sure the statement has a valid form for the DEFINEFILE statement.  If it
  12455.    does, implement the statement.  */
  12456.  
  12457. static ffelexHandler
  12458. ffestb_V0251_ (ffelexToken t)
  12459. {
  12460.   switch (ffelex_token_type (t))
  12461.     {
  12462.     case FFELEX_typeNAME:
  12463.     case FFELEX_typeNUMBER:
  12464.       if (ffelex_token_type (ffesta_tokens[0]) == FFELEX_typeNAME)
  12465.     ffesta_confirmed ();
  12466.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  12467.           FFEEXPR_contextFILEUNIT_DF, (ffeexprCallback) ffestb_V0252_)))
  12468.     (t);
  12469.  
  12470.     case FFELEX_typeEOS:
  12471.     case FFELEX_typeSEMICOLON:
  12472.     case FFELEX_typeCOMMA:
  12473.     case FFELEX_typeCOLONCOLON:
  12474.       ffesta_confirmed ();    /* Error, but clearly intended. */
  12475.       break;
  12476.  
  12477.     default:
  12478.       break;
  12479.     }
  12480.  
  12481.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
  12482.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12483. }
  12484.  
  12485. /* ffestb_V0252_ -- "DEFINEFILE" expr
  12486.  
  12487.    (ffestb_V0252_)  // to expression handler
  12488.  
  12489.    Make sure the statement has a valid form for the DEFINEFILE statement.  If
  12490.    it does, implement the statement.  */
  12491.  
  12492. static ffelexHandler
  12493. ffestb_V0252_ (ffelexToken ft, ffebld expr, ffelexToken t)
  12494. {
  12495.   switch (ffelex_token_type (t))
  12496.     {
  12497.     case FFELEX_typeOPEN_PAREN:
  12498.       ffestb_local_.V025.u = expr;
  12499.       ffesta_tokens[1] = ffelex_token_use (ft);
  12500.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  12501.            FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0253_);
  12502.  
  12503.     default:
  12504.       break;
  12505.     }
  12506.  
  12507.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
  12508.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12509. }
  12510.  
  12511. /* ffestb_V0253_ -- "DEFINEFILE" expr OPEN_PAREN expr
  12512.  
  12513.    (ffestb_V0253_)  // to expression handler
  12514.  
  12515.    Make sure the statement has a valid form for the DEFINEFILE statement.  If
  12516.    it does, implement the statement.  */
  12517.  
  12518. static ffelexHandler
  12519. ffestb_V0253_ (ffelexToken ft, ffebld expr, ffelexToken t)
  12520. {
  12521.   switch (ffelex_token_type (t))
  12522.     {
  12523.     case FFELEX_typeCOMMA:
  12524.       ffestb_local_.V025.m = expr;
  12525.       ffesta_tokens[2] = ffelex_token_use (ft);
  12526.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  12527.            FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0254_);
  12528.  
  12529.     default:
  12530.       break;
  12531.     }
  12532.  
  12533.   ffelex_token_kill (ffesta_tokens[1]);
  12534.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
  12535.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12536. }
  12537.  
  12538. /* ffestb_V0254_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr
  12539.  
  12540.    (ffestb_V0254_)  // to expression handler
  12541.  
  12542.    Make sure the statement has a valid form for the DEFINEFILE statement.  If
  12543.    it does, implement the statement.  */
  12544.  
  12545. static ffelexHandler
  12546. ffestb_V0254_ (ffelexToken ft, ffebld expr, ffelexToken t)
  12547. {
  12548.   switch (ffelex_token_type (t))
  12549.     {
  12550.     case FFELEX_typeCOMMA:
  12551.       ffestb_local_.V025.n = expr;
  12552.       ffesta_tokens[3] = ffelex_token_use (ft);
  12553.       return (ffelexHandler) ffestb_V0255_;
  12554.  
  12555.     default:
  12556.       break;
  12557.     }
  12558.  
  12559.   ffelex_token_kill (ffesta_tokens[1]);
  12560.   ffelex_token_kill (ffesta_tokens[2]);
  12561.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
  12562.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12563. }
  12564.  
  12565. /* ffestb_V0255_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA
  12566.  
  12567.    return ffestb_V0255_;  // to lexer
  12568.  
  12569.    Make sure the statement has a valid form for the DEFINEFILE statement.  If
  12570.    it does, implement the statement.  */
  12571.  
  12572. static ffelexHandler
  12573. ffestb_V0255_ (ffelexToken t)
  12574. {
  12575.   char *p;
  12576.  
  12577.   switch (ffelex_token_type (t))
  12578.     {
  12579.     case FFELEX_typeNAME:
  12580.       p = ffelex_token_text (t);
  12581.       if (!ffesrc_char_match_init (*p, 'U', 'u') || (*++p != '\0'))
  12582.     break;
  12583.       return (ffelexHandler) ffestb_V0256_;
  12584.  
  12585.     default:
  12586.       break;
  12587.     }
  12588.  
  12589.   ffelex_token_kill (ffesta_tokens[1]);
  12590.   ffelex_token_kill (ffesta_tokens[2]);
  12591.   ffelex_token_kill (ffesta_tokens[3]);
  12592.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
  12593.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12594. }
  12595.  
  12596. /* ffestb_V0256_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
  12597.  
  12598.    return ffestb_V0256_;  // to lexer
  12599.  
  12600.    Make sure the statement has a valid form for the DEFINEFILE statement.  If
  12601.    it does, implement the statement.  */
  12602.  
  12603. static ffelexHandler
  12604. ffestb_V0256_ (ffelexToken t)
  12605. {
  12606.   switch (ffelex_token_type (t))
  12607.     {
  12608.     case FFELEX_typeCOMMA:
  12609.       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  12610.                       FFEEXPR_contextFILEASSOC,
  12611.                       (ffeexprCallback) ffestb_V0257_);
  12612.  
  12613.     default:
  12614.       break;
  12615.     }
  12616.  
  12617.   ffelex_token_kill (ffesta_tokens[1]);
  12618.   ffelex_token_kill (ffesta_tokens[2]);
  12619.   ffelex_token_kill (ffesta_tokens[3]);
  12620.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
  12621.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12622. }
  12623.  
  12624. /* ffestb_V0257_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
  12625.             COMMA expr
  12626.  
  12627.    (ffestb_V0257_)  // to expression handler
  12628.  
  12629.    Make sure the statement has a valid form for the DEFINEFILE statement.  If
  12630.    it does, implement the statement.  */
  12631.  
  12632. static ffelexHandler
  12633. ffestb_V0257_ (ffelexToken ft, ffebld expr, ffelexToken t)
  12634. {
  12635.   switch (ffelex_token_type (t))
  12636.     {
  12637.     case FFELEX_typeCLOSE_PAREN:
  12638.       ffestb_local_.V025.asv = expr;
  12639.       ffesta_tokens[4] = ffelex_token_use (ft);
  12640.       return (ffelexHandler) ffestb_V0258_;
  12641.  
  12642.     default:
  12643.       break;
  12644.     }
  12645.  
  12646.   ffelex_token_kill (ffesta_tokens[1]);
  12647.   ffelex_token_kill (ffesta_tokens[2]);
  12648.   ffelex_token_kill (ffesta_tokens[3]);
  12649.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
  12650.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12651. }
  12652.  
  12653. /* ffestb_V0258_ -- "DEFINEFILE" expr OPEN_PAREN expr COMMA expr COMMA "U"
  12654.             COMMA expr CLOSE_PAREN
  12655.  
  12656.    return ffestb_V0258_;  // to lexer
  12657.  
  12658.    Make sure the statement has a valid form for the DEFINEFILE statement.  If
  12659.    it does, implement the statement.  */
  12660.  
  12661. static ffelexHandler
  12662. ffestb_V0258_ (ffelexToken t)
  12663. {
  12664.   switch (ffelex_token_type (t))
  12665.     {
  12666.     case FFELEX_typeCOMMA:
  12667.     case FFELEX_typeEOS:
  12668.     case FFELEX_typeSEMICOLON:
  12669.       if (!ffestb_local_.V025.started)
  12670.     {
  12671.       ffesta_confirmed ();
  12672.       if (!ffesta_is_inhibited ())
  12673.         ffestc_V025_start ();
  12674.       ffestb_local_.V025.started = TRUE;
  12675.     }
  12676.       if (!ffesta_is_inhibited ())
  12677.     ffestc_V025_item (ffestb_local_.V025.u, ffesta_tokens[1],
  12678.               ffestb_local_.V025.m, ffesta_tokens[2],
  12679.               ffestb_local_.V025.n, ffesta_tokens[3],
  12680.               ffestb_local_.V025.asv, ffesta_tokens[4]);
  12681.       ffelex_token_kill (ffesta_tokens[1]);
  12682.       ffelex_token_kill (ffesta_tokens[2]);
  12683.       ffelex_token_kill (ffesta_tokens[3]);
  12684.       ffelex_token_kill (ffesta_tokens[4]);
  12685.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  12686.     return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  12687.            FFEEXPR_contextFILEUNIT_DF, (ffeexprCallback) ffestb_V0252_);
  12688.       if (!ffesta_is_inhibited ())
  12689.     ffestc_V025_finish ();
  12690.       return (ffelexHandler) ffesta_zero (t);
  12691.  
  12692.     default:
  12693.       break;
  12694.     }
  12695.  
  12696.   ffelex_token_kill (ffesta_tokens[1]);
  12697.   ffelex_token_kill (ffesta_tokens[2]);
  12698.   ffelex_token_kill (ffesta_tokens[3]);
  12699.   ffelex_token_kill (ffesta_tokens[4]);
  12700.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DEFINE FILE", t);
  12701.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  12702. }
  12703.  
  12704. #endif
  12705. /* ffestb_subr_kill_easy_ -- Kill I/O statement data structure
  12706.  
  12707.    ffestb_subr_kill_easy_();
  12708.  
  12709.    Kills all tokens in the I/O data structure.    Assumes that they are
  12710.    overlaid with each other (union) in ffest_private.h and the typing
  12711.    and structure references assume (though not necessarily dangerous if
  12712.    FALSE) that INQUIRE has the most file elements.  */
  12713.  
  12714. #if FFESTB_KILL_EASY_
  12715. static void
  12716. ffestb_subr_kill_easy_ (ffestpInquireIx max)
  12717. {
  12718.   ffestpInquireIx ix;
  12719.  
  12720.   for (ix = 0; ix < max; ++ix)
  12721.     {
  12722.       if (ffestp_file.inquire.inquire_spec[ix].kw_or_val_present)
  12723.     {
  12724.       if (ffestp_file.inquire.inquire_spec[ix].kw_present)
  12725.         ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].kw);
  12726.       if (ffestp_file.inquire.inquire_spec[ix].value_present)
  12727.         ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].value);
  12728.     }
  12729.     }
  12730. }
  12731.  
  12732. #endif
  12733. /* ffestb_subr_kill_accept_ -- Kill ACCEPT statement data structure
  12734.  
  12735.    ffestb_subr_kill_accept_();
  12736.  
  12737.    Kills all tokens in the ACCEPT data structure.  */
  12738.  
  12739. #if !FFESTB_KILL_EASY_
  12740. static void
  12741. ffestb_subr_kill_accept_ ()
  12742. {
  12743.   ffestpAcceptIx ix;
  12744.  
  12745.   for (ix = 0; ix < FFESTP_acceptix; ++ix)
  12746.     {
  12747.       if (ffestp_file.accept.accept_spec[ix].kw_or_val_present)
  12748.     {
  12749.       if (ffestp_file.accept.accept_spec[ix].kw_present)
  12750.         ffelex_token_kill (ffestp_file.accept.accept_spec[ix].kw);
  12751.       if (ffestp_file.accept.accept_spec[ix].value_present)
  12752.         ffelex_token_kill (ffestp_file.accept.accept_spec[ix].value);
  12753.     }
  12754.     }
  12755. }
  12756.  
  12757. #endif
  12758. /* ffestb_subr_kill_beru_ -- Kill BACKSPACE/ENDFILE/REWIND/UNLOCK statement
  12759.                 data structure
  12760.  
  12761.    ffestb_subr_kill_beru_();
  12762.  
  12763.    Kills all tokens in the BACKSPACE/ENDFILE/REWIND/UNLOCK data structure.  */
  12764.  
  12765. #if !FFESTB_KILL_EASY_
  12766. static void
  12767. ffestb_subr_kill_beru_ ()
  12768. {
  12769.   ffestpBeruIx ix;
  12770.  
  12771.   for (ix = 0; ix < FFESTP_beruix; ++ix)
  12772.     {
  12773.       if (ffestp_file.beru.beru_spec[ix].kw_or_val_present)
  12774.     {
  12775.       if (ffestp_file.beru.beru_spec[ix].kw_present)
  12776.         ffelex_token_kill (ffestp_file.beru.beru_spec[ix].kw);
  12777.       if (ffestp_file.beru.beru_spec[ix].value_present)
  12778.         ffelex_token_kill (ffestp_file.beru.beru_spec[ix].value);
  12779.     }
  12780.     }
  12781. }
  12782.  
  12783. #endif
  12784. /* ffestb_subr_kill_close_ -- Kill CLOSE statement data structure
  12785.  
  12786.    ffestb_subr_kill_close_();
  12787.  
  12788.    Kills all tokens in the CLOSE data structure.  */
  12789.  
  12790. #if !FFESTB_KILL_EASY_
  12791. static void
  12792. ffestb_subr_kill_close_ ()
  12793. {
  12794.   ffestpCloseIx ix;
  12795.  
  12796.   for (ix = 0; ix < FFESTP_closeix; ++ix)
  12797.     {
  12798.       if (ffestp_file.close.close_spec[ix].kw_or_val_present)
  12799.     {
  12800.       if (ffestp_file.close.close_spec[ix].kw_present)
  12801.         ffelex_token_kill (ffestp_file.close.close_spec[ix].kw);
  12802.       if (ffestp_file.close.close_spec[ix].value_present)
  12803.         ffelex_token_kill (ffestp_file.close.close_spec[ix].value);
  12804.     }
  12805.     }
  12806. }
  12807.  
  12808. #endif
  12809. /* ffestb_subr_kill_delete_ -- Kill DELETE statement data structure
  12810.  
  12811.    ffestb_subr_kill_delete_();
  12812.  
  12813.    Kills all tokens in the DELETE data structure.  */
  12814.  
  12815. #if !FFESTB_KILL_EASY_
  12816. static void
  12817. ffestb_subr_kill_delete_ ()
  12818. {
  12819.   ffestpDeleteIx ix;
  12820.  
  12821.   for (ix = 0; ix < FFESTP_deleteix; ++ix)
  12822.     {
  12823.       if (ffestp_file.delete.delete_spec[ix].kw_or_val_present)
  12824.     {
  12825.       if (ffestp_file.delete.delete_spec[ix].kw_present)
  12826.         ffelex_token_kill (ffestp_file.delete.delete_spec[ix].kw);
  12827.       if (ffestp_file.delete.delete_spec[ix].value_present)
  12828.         ffelex_token_kill (ffestp_file.delete.delete_spec[ix].value);
  12829.     }
  12830.     }
  12831. }
  12832.  
  12833. #endif
  12834. /* ffestb_subr_kill_inquire_ -- Kill INQUIRE statement data structure
  12835.  
  12836.    ffestb_subr_kill_inquire_();
  12837.  
  12838.    Kills all tokens in the INQUIRE data structure.  */
  12839.  
  12840. #if !FFESTB_KILL_EASY_
  12841. static void
  12842. ffestb_subr_kill_inquire_ ()
  12843. {
  12844.   ffestpInquireIx ix;
  12845.  
  12846.   for (ix = 0; ix < FFESTP_inquireix; ++ix)
  12847.     {
  12848.       if (ffestp_file.inquire.inquire_spec[ix].kw_or_val_present)
  12849.     {
  12850.       if (ffestp_file.inquire.inquire_spec[ix].kw_present)
  12851.         ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].kw);
  12852.       if (ffestp_file.inquire.inquire_spec[ix].value_present)
  12853.         ffelex_token_kill (ffestp_file.inquire.inquire_spec[ix].value);
  12854.     }
  12855.     }
  12856. }
  12857.  
  12858. #endif
  12859. /* ffestb_subr_kill_open_ -- Kill OPEN statement data structure
  12860.  
  12861.    ffestb_subr_kill_open_();
  12862.  
  12863.    Kills all tokens in the OPEN data structure.     */
  12864.  
  12865. #if !FFESTB_KILL_EASY_
  12866. static void
  12867. ffestb_subr_kill_open_ ()
  12868. {
  12869.   ffestpOpenIx ix;
  12870.  
  12871.   for (ix = 0; ix < FFESTP_openix; ++ix)
  12872.     {
  12873.       if (ffestp_file.open.open_spec[ix].kw_or_val_present)
  12874.     {
  12875.       if (ffestp_file.open.open_spec[ix].kw_present)
  12876.         ffelex_token_kill (ffestp_file.open.open_spec[ix].kw);
  12877.       if (ffestp_file.open.open_spec[ix].value_present)
  12878.         ffelex_token_kill (ffestp_file.open.open_spec[ix].value);
  12879.     }
  12880.     }
  12881. }
  12882.  
  12883. #endif
  12884. /* ffestb_subr_kill_print_ -- Kill PRINT statement data structure
  12885.  
  12886.    ffestb_subr_kill_print_();
  12887.  
  12888.    Kills all tokens in the PRINT data structure.  */
  12889.  
  12890. #if !FFESTB_KILL_EASY_
  12891. static void
  12892. ffestb_subr_kill_print_ ()
  12893. {
  12894.   ffestpPrintIx ix;
  12895.  
  12896.   for (ix = 0; ix < FFESTP_printix; ++ix)
  12897.     {
  12898.       if (ffestp_file.print.print_spec[ix].kw_or_val_present)
  12899.     {
  12900.       if (ffestp_file.print.print_spec[ix].kw_present)
  12901.         ffelex_token_kill (ffestp_file.print.print_spec[ix].kw);
  12902.       if (ffestp_file.print.print_spec[ix].value_present)
  12903.         ffelex_token_kill (ffestp_file.print.print_spec[ix].value);
  12904.     }
  12905.     }
  12906. }
  12907.  
  12908. #endif
  12909. /* ffestb_subr_kill_read_ -- Kill READ statement data structure
  12910.  
  12911.    ffestb_subr_kill_read_();
  12912.  
  12913.    Kills all tokens in the READ data structure.     */
  12914.  
  12915. #if !FFESTB_KILL_EASY_
  12916. static void
  12917. ffestb_subr_kill_read_ ()
  12918. {
  12919.   ffestpReadIx ix;
  12920.  
  12921.   for (ix = 0; ix < FFESTP_readix; ++ix)
  12922.     {
  12923.       if (ffestp_file.read.read_spec[ix].kw_or_val_present)
  12924.     {
  12925.       if (ffestp_file.read.read_spec[ix].kw_present)
  12926.         ffelex_token_kill (ffestp_file.read.read_spec[ix].kw);
  12927.       if (ffestp_file.read.read_spec[ix].value_present)
  12928.         ffelex_token_kill (ffestp_file.read.read_spec[ix].value);
  12929.     }
  12930.     }
  12931. }
  12932.  
  12933. #endif
  12934. /* ffestb_subr_kill_rewrite_ -- Kill REWRITE statement data structure
  12935.  
  12936.    ffestb_subr_kill_rewrite_();
  12937.  
  12938.    Kills all tokens in the REWRITE data structure.  */
  12939.  
  12940. #if !FFESTB_KILL_EASY_
  12941. static void
  12942. ffestb_subr_kill_rewrite_ ()
  12943. {
  12944.   ffestpRewriteIx ix;
  12945.  
  12946.   for (ix = 0; ix < FFESTP_rewriteix; ++ix)
  12947.     {
  12948.       if (ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present)
  12949.     {
  12950.       if (ffestp_file.rewrite.rewrite_spec[ix].kw_present)
  12951.         ffelex_token_kill (ffestp_file.rewrite.rewrite_spec[ix].kw);
  12952.       if (ffestp_file.rewrite.rewrite_spec[ix].value_present)
  12953.         ffelex_token_kill (ffestp_file.rewrite.rewrite_spec[ix].value);
  12954.     }
  12955.     }
  12956. }
  12957.  
  12958. #endif
  12959. /* ffestb_subr_kill_type_ -- Kill TYPE statement data structure
  12960.  
  12961.    ffestb_subr_kill_type_();
  12962.  
  12963.    Kills all tokens in the TYPE data structure.     */
  12964.  
  12965. #if !FFESTB_KILL_EASY_
  12966. static void
  12967. ffestb_subr_kill_type_ ()
  12968. {
  12969.   ffestpTypeIx ix;
  12970.  
  12971.   for (ix = 0; ix < FFESTP_typeix; ++ix)
  12972.     {
  12973.       if (ffestp_file.type.type_spec[ix].kw_or_val_present)
  12974.     {
  12975.       if (ffestp_file.type.type_spec[ix].kw_present)
  12976.         ffelex_token_kill (ffestp_file.type.type_spec[ix].kw);
  12977.       if (ffestp_file.type.type_spec[ix].value_present)
  12978.         ffelex_token_kill (ffestp_file.type.type_spec[ix].value);
  12979.     }
  12980.     }
  12981. }
  12982.  
  12983. #endif
  12984. /* ffestb_subr_kill_write_ -- Kill WRITE statement data structure
  12985.  
  12986.    ffestb_subr_kill_write_();
  12987.  
  12988.    Kills all tokens in the WRITE data structure.  */
  12989.  
  12990. #if !FFESTB_KILL_EASY_
  12991. static void
  12992. ffestb_subr_kill_write_ ()
  12993. {
  12994.   ffestpWriteIx ix;
  12995.  
  12996.   for (ix = 0; ix < FFESTP_writeix; ++ix)
  12997.     {
  12998.       if (ffestp_file.write.write_spec[ix].kw_or_val_present)
  12999.     {
  13000.       if (ffestp_file.write.write_spec[ix].kw_present)
  13001.         ffelex_token_kill (ffestp_file.write.write_spec[ix].kw);
  13002.       if (ffestp_file.write.write_spec[ix].value_present)
  13003.         ffelex_token_kill (ffestp_file.write.write_spec[ix].value);
  13004.     }
  13005.     }
  13006. }
  13007.  
  13008. #endif
  13009. /* ffestb_beru -- Parse the BACKSPACE/ENDFILE/REWIND/UNLOCK statement
  13010.  
  13011.    return ffestb_beru;    // to lexer
  13012.  
  13013.    Make sure the statement has a valid form for the BACKSPACE/ENDFILE/REWIND/
  13014.    UNLOCK statement.  If it does, implement the statement.  */
  13015.  
  13016. ffelexHandler
  13017. ffestb_beru (ffelexToken t)
  13018. {
  13019.   ffelexHandler next;
  13020.   ffestpBeruIx ix;
  13021.  
  13022.   switch (ffelex_token_type (ffesta_tokens[0]))
  13023.     {
  13024.     case FFELEX_typeNAME:
  13025.       switch (ffelex_token_type (t))
  13026.     {
  13027.     case FFELEX_typeCOMMA:
  13028.     case FFELEX_typeCOLONCOLON:
  13029.     case FFELEX_typeEOS:
  13030.     case FFELEX_typeSEMICOLON:
  13031.       ffesta_confirmed ();    /* Error, but clearly intended. */
  13032.       goto bad_1;        /* :::::::::::::::::::: */
  13033.  
  13034.     case FFELEX_typeEQUALS:
  13035.     case FFELEX_typePOINTS:
  13036.     case FFELEX_typeCOLON:
  13037.       goto bad_1;        /* :::::::::::::::::::: */
  13038.  
  13039.     case FFELEX_typeNAME:
  13040.     case FFELEX_typeNUMBER:
  13041.       ffesta_confirmed ();
  13042.       break;
  13043.  
  13044.     case FFELEX_typeOPEN_PAREN:
  13045.       for (ix = 0; ix < FFESTP_beruix; ++ix)
  13046.         ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
  13047.       ffesta_tokens[1] = ffelex_token_use (t);
  13048.       return (ffelexHandler) ffestb_beru2_;
  13049.  
  13050.     default:
  13051.       break;
  13052.     }
  13053.  
  13054.       for (ix = 0; ix < FFESTP_beruix; ++ix)
  13055.     ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
  13056.       return (ffelexHandler) (*((ffelexHandler)
  13057.                 ffeexpr_rhs (ffesta_output_pool,
  13058.                          FFEEXPR_contextFILENUM,
  13059.                       (ffeexprCallback) ffestb_beru1_)))
  13060.     (t);
  13061.  
  13062.     case FFELEX_typeNAMES:
  13063.       switch (ffelex_token_type (t))
  13064.     {
  13065.     case FFELEX_typeCOMMA:
  13066.     case FFELEX_typeCOLONCOLON:
  13067.       ffesta_confirmed ();    /* Error, but clearly intended. */
  13068.       goto bad_1;        /* :::::::::::::::::::: */
  13069.  
  13070.     case FFELEX_typeEQUALS:
  13071.     case FFELEX_typePOINTS:
  13072.     case FFELEX_typeCOLON:
  13073.       goto bad_1;        /* :::::::::::::::::::: */
  13074.  
  13075.     case FFELEX_typeEOS:
  13076.     case FFELEX_typeSEMICOLON:
  13077.       ffesta_confirmed ();
  13078.       break;
  13079.  
  13080.     case FFELEX_typeOPEN_PAREN:
  13081.       if (ffelex_token_length (ffesta_tokens[0])
  13082.           != ffestb_args.beru.len)
  13083.         break;
  13084.  
  13085.       for (ix = 0; ix < FFESTP_beruix; ++ix)
  13086.         ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
  13087.       ffesta_tokens[1] = ffelex_token_use (t);
  13088.       return (ffelexHandler) ffestb_beru2_;
  13089.  
  13090.     default:
  13091.       break;
  13092.     }
  13093.       for (ix = 0; ix < FFESTP_beruix; ++ix)
  13094.     ffestp_file.beru.beru_spec[ix].kw_or_val_present = FALSE;
  13095.       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  13096.            FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_beru1_);
  13097.       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
  13098.                            ffestb_args.beru.len);
  13099.       if (next == NULL)
  13100.     return (ffelexHandler) ffelex_swallow_tokens (t,
  13101.                            (ffelexHandler) ffesta_zero);
  13102.       return (ffelexHandler) (*next) (t);
  13103.  
  13104.     default:
  13105.       goto bad_0;        /* :::::::::::::::::::: */
  13106.     }
  13107.  
  13108. bad_0:                /* :::::::::::::::::::: */
  13109.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, ffesta_tokens[0]);
  13110.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13111.  
  13112. bad_1:                /* :::::::::::::::::::: */
  13113.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
  13114.   return (ffelexHandler) ffelex_swallow_tokens (t,
  13115.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  13116. }
  13117.  
  13118. /* ffestb_beru1_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" expr
  13119.  
  13120.    (ffestb_beru1_)  // to expression handler
  13121.  
  13122.    Make sure the next token is an EOS or SEMICOLON.  */
  13123.  
  13124. static ffelexHandler
  13125. ffestb_beru1_ (ffelexToken ft, ffebld expr, ffelexToken t)
  13126. {
  13127.   switch (ffelex_token_type (t))
  13128.     {
  13129.     case FFELEX_typeEOS:
  13130.     case FFELEX_typeSEMICOLON:
  13131.       if (expr == NULL)
  13132.     break;
  13133.       ffesta_confirmed ();
  13134.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_or_val_present
  13135.     = TRUE;
  13136.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_present = FALSE;
  13137.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_present = TRUE;
  13138.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_is_label
  13139.     = FALSE;
  13140.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value
  13141.     = ffelex_token_use (ft);
  13142.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].u.expr = expr;
  13143.       if (!ffesta_is_inhibited ())
  13144.     {
  13145.       switch (ffesta_first_kw)
  13146.         {
  13147.         case FFESTR_firstBACKSPACE:
  13148.           ffestc_R919 ();
  13149.           break;
  13150.  
  13151.         case FFESTR_firstENDFILE:
  13152.         case FFESTR_firstEND:
  13153.           ffestc_R920 ();
  13154.           break;
  13155.  
  13156.         case FFESTR_firstREWIND:
  13157.           ffestc_R921 ();
  13158.           break;
  13159.  
  13160. #if FFESTR_VXT
  13161.         case FFESTR_firstUNLOCK:
  13162.           ffestc_V022 ();
  13163.           break;
  13164. #endif
  13165.  
  13166.         default:
  13167.           assert (FALSE);
  13168.         }
  13169.     }
  13170.       ffestb_subr_kill_beru_ ();
  13171.       return (ffelexHandler) ffesta_zero (t);
  13172.  
  13173.     default:
  13174.       break;
  13175.     }
  13176.  
  13177.   ffestb_subr_kill_beru_ ();
  13178.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
  13179.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13180. }
  13181.  
  13182. /* ffestb_beru2_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN
  13183.  
  13184.    return ffestb_beru2_;  // to lexer
  13185.  
  13186.    Handle expr construct (not NAME=expr construct) here.  */
  13187.  
  13188. static ffelexHandler
  13189. ffestb_beru2_ (ffelexToken t)
  13190. {
  13191.   ffelexToken nt;
  13192.   ffelexHandler next;
  13193.  
  13194.   switch (ffelex_token_type (t))
  13195.     {
  13196.     case FFELEX_typeNAME:
  13197.       ffesta_tokens[2] = ffelex_token_use (t);
  13198.       return (ffelexHandler) ffestb_beru3_;
  13199.  
  13200.     default:
  13201.       nt = ffesta_tokens[1];
  13202.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  13203.          FFEEXPR_contextFILENUMAMBIG, (ffeexprCallback) ffestb_beru4_)))
  13204.     (nt);
  13205.       ffelex_token_kill (nt);
  13206.       return (ffelexHandler) (*next) (t);
  13207.     }
  13208. }
  13209.  
  13210. /* ffestb_beru3_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN NAME
  13211.  
  13212.    return ffestb_beru3_;  // to lexer
  13213.  
  13214.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  13215.    token thru expression handler.  */
  13216.  
  13217. static ffelexHandler
  13218. ffestb_beru3_ (ffelexToken t)
  13219. {
  13220.   ffelexHandler next;
  13221.   ffelexToken nt;
  13222.   ffelexToken ot;
  13223.  
  13224.   switch (ffelex_token_type (t))
  13225.     {
  13226.     case FFELEX_typeEQUALS:
  13227.       ffelex_token_kill (ffesta_tokens[1]);
  13228.       nt = ffesta_tokens[2];
  13229.       next = (ffelexHandler) ffestb_beru5_ (nt);
  13230.       ffelex_token_kill (nt);
  13231.       return (ffelexHandler) (*next) (t);
  13232.  
  13233.     default:
  13234.       nt = ffesta_tokens[1];
  13235.       ot = ffesta_tokens[2];
  13236.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  13237.          FFEEXPR_contextFILENUMAMBIG, (ffeexprCallback) ffestb_beru4_)))
  13238.     (nt);
  13239.       ffelex_token_kill (nt);
  13240.       next = (ffelexHandler) (*next) (ot);
  13241.       ffelex_token_kill (ot);
  13242.       return (ffelexHandler) (*next) (t);
  13243.     }
  13244. }
  13245.  
  13246. /* ffestb_beru4_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN expr [CLOSE_PAREN]
  13247.  
  13248.    (ffestb_beru4_)  // to expression handler
  13249.  
  13250.    Handle COMMA or EOS/SEMICOLON here.
  13251.  
  13252.    15-Feb-91  JCB  1.2
  13253.       Now using new mechanism whereby expr comes back as opITEM if the
  13254.       expr is considered part (or all) of an I/O control list (and should
  13255.       be stripped of its outer opITEM node) or not if it is considered
  13256.       a plain unit number that happens to have been enclosed in parens.
  13257.    26-Mar-90  JCB  1.1
  13258.       No longer expecting close-paren here because of constructs like
  13259.       BACKSPACE (5)+2, so now expecting either COMMA because it was a
  13260.       construct like BACKSPACE (5+2,... or EOS/SEMICOLON because it is like
  13261.       the former construct.  Ah, the vagaries of Fortran.  */
  13262.  
  13263. static ffelexHandler
  13264. ffestb_beru4_ (ffelexToken ft, ffebld expr, ffelexToken t)
  13265. {
  13266.   bool inlist;
  13267.  
  13268.   switch (ffelex_token_type (t))
  13269.     {
  13270.     case FFELEX_typeCOMMA:
  13271.     case FFELEX_typeEOS:
  13272.     case FFELEX_typeSEMICOLON:
  13273.     case FFELEX_typeCLOSE_PAREN:
  13274.       if (expr == NULL)
  13275.     break;
  13276.       if (ffebld_op (expr) == FFEBLD_opITEM)
  13277.     {
  13278.       inlist = TRUE;
  13279.       expr = ffebld_head (expr);
  13280.     }
  13281.       else
  13282.     inlist = FALSE;
  13283.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_or_val_present
  13284.     = TRUE;
  13285.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].kw_present = FALSE;
  13286.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_present = TRUE;
  13287.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value_is_label
  13288.     = FALSE;
  13289.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].value
  13290.     = ffelex_token_use (ft);
  13291.       ffestp_file.beru.beru_spec[FFESTP_beruixUNIT].u.expr = expr;
  13292.       if (inlist)
  13293.     return (ffelexHandler) ffestb_beru9_ (t);
  13294.       return (ffelexHandler) ffestb_beru10_ (t);
  13295.  
  13296.     default:
  13297.       break;
  13298.     }
  13299.  
  13300.   ffestb_subr_kill_beru_ ();
  13301.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
  13302.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13303. }
  13304.  
  13305. /* ffestb_beru5_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN [external-file-unit
  13306.             COMMA]
  13307.  
  13308.    return ffestb_beru5_;  // to lexer
  13309.  
  13310.    Handle expr construct (not NAME=expr construct) here.  */
  13311.  
  13312. static ffelexHandler
  13313. ffestb_beru5_ (ffelexToken t)
  13314. {
  13315.   ffestrGenio kw;
  13316.  
  13317.   ffestb_local_.beru.label = FALSE;
  13318.  
  13319.   switch (ffelex_token_type (t))
  13320.     {
  13321.     case FFELEX_typeNAME:
  13322.       kw = ffestr_genio (t);
  13323.       switch (kw)
  13324.     {
  13325.     case FFESTR_genioERR:
  13326.       ffestb_local_.beru.ix = FFESTP_beruixERR;
  13327.       ffestb_local_.beru.label = TRUE;
  13328.       break;
  13329.  
  13330.     case FFESTR_genioIOSTAT:
  13331.       ffestb_local_.beru.ix = FFESTP_beruixIOSTAT;
  13332.       ffestb_local_.beru.left = TRUE;
  13333.       ffestb_local_.beru.context = FFEEXPR_contextFILEINT;
  13334.       break;
  13335.  
  13336.     case FFESTR_genioUNIT:
  13337.       ffestb_local_.beru.ix = FFESTP_beruixUNIT;
  13338.       ffestb_local_.beru.left = FALSE;
  13339.       ffestb_local_.beru.context = FFEEXPR_contextFILENUM;
  13340.       break;
  13341.  
  13342.     default:
  13343.       goto bad;        /* :::::::::::::::::::: */
  13344.     }
  13345.       if (ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
  13346.       .kw_or_val_present)
  13347.     break;            /* Can't specify a keyword twice! */
  13348.       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
  13349.     .kw_or_val_present = TRUE;
  13350.       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
  13351.     .kw_present = TRUE;
  13352.       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix]
  13353.     .value_present = FALSE;
  13354.       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value_is_label
  13355.     = ffestb_local_.beru.label;
  13356.       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].kw
  13357.     = ffelex_token_use (t);
  13358.       return (ffelexHandler) ffestb_beru6_;
  13359.  
  13360.     default:
  13361.       break;
  13362.     }
  13363.  
  13364. bad:                /* :::::::::::::::::::: */
  13365.   ffestb_subr_kill_beru_ ();
  13366.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
  13367.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13368. }
  13369.  
  13370. /* ffestb_beru6_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN [external-file-unit
  13371.             COMMA] NAME
  13372.  
  13373.    return ffestb_beru6_;  // to lexer
  13374.  
  13375.    Make sure EQUALS here, send next token to expression handler.  */
  13376.  
  13377. static ffelexHandler
  13378. ffestb_beru6_ (ffelexToken t)
  13379. {
  13380.  
  13381.   switch (ffelex_token_type (t))
  13382.     {
  13383.     case FFELEX_typeEQUALS:
  13384.       ffesta_confirmed ();
  13385.       if (ffestb_local_.beru.label)
  13386.     return (ffelexHandler) ffestb_beru8_;
  13387.       if (ffestb_local_.beru.left)
  13388.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  13389.                         ffestb_local_.beru.context,
  13390.                         (ffeexprCallback) ffestb_beru7_);
  13391.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  13392.                       ffestb_local_.beru.context,
  13393.                       (ffeexprCallback) ffestb_beru7_);
  13394.  
  13395.     default:
  13396.       break;
  13397.     }
  13398.  
  13399.   ffestb_subr_kill_beru_ ();
  13400.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
  13401.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13402. }
  13403.  
  13404. /* ffestb_beru7_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS expr
  13405.  
  13406.    (ffestb_beru7_)  // to expression handler
  13407.  
  13408.    Handle COMMA or CLOSE_PAREN here.  */
  13409.  
  13410. static ffelexHandler
  13411. ffestb_beru7_ (ffelexToken ft, ffebld expr, ffelexToken t)
  13412. {
  13413.   switch (ffelex_token_type (t))
  13414.     {
  13415.     case FFELEX_typeCOMMA:
  13416.     case FFELEX_typeCLOSE_PAREN:
  13417.       if (expr == NULL)
  13418.     break;
  13419.       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value_present
  13420.     = TRUE;
  13421.       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].value
  13422.     = ffelex_token_use (ft);
  13423.       ffestp_file.beru.beru_spec[ffestb_local_.beru.ix].u.expr = expr;
  13424.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  13425.     return (ffelexHandler) ffestb_beru5_;
  13426.       return (ffelexHandler) ffestb_beru10_;
  13427.  
  13428.     default:
  13429.       break;
  13430.     }
  13431.  
  13432.   ffestb_subr_kill_beru_ ();
  13433.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
  13434.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13435. }
  13436.  
  13437. /* ffestb_beru8_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS
  13438.  
  13439.    return ffestb_beru8_;  // to lexer
  13440.  
  13441.    Handle NUMBER for label here.  */
  13442.  
  13443. static ffelexHandler
  13444. ffestb_beru8_ (ffelexToken t)
  13445. {
  13446.   switch (ffelex_token_type (t))
  13447.     {
  13448.     case FFELEX_typeNUMBER:
  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 (t);
  13453.       return (ffelexHandler) ffestb_beru9_;
  13454.  
  13455.     default:
  13456.       break;
  13457.     }
  13458.  
  13459.   ffestb_subr_kill_beru_ ();
  13460.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
  13461.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13462. }
  13463.  
  13464. /* ffestb_beru9_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... NAME EQUALS
  13465.            NUMBER
  13466.  
  13467.    return ffestb_beru9_;  // to lexer
  13468.  
  13469.    Handle COMMA or CLOSE_PAREN here.  */
  13470.  
  13471. static ffelexHandler
  13472. ffestb_beru9_ (ffelexToken t)
  13473. {
  13474.   switch (ffelex_token_type (t))
  13475.     {
  13476.     case FFELEX_typeCOMMA:
  13477.       return (ffelexHandler) ffestb_beru5_;
  13478.  
  13479.     case FFELEX_typeCLOSE_PAREN:
  13480.       return (ffelexHandler) ffestb_beru10_;
  13481.  
  13482.     default:
  13483.       break;
  13484.     }
  13485.  
  13486.   ffestb_subr_kill_beru_ ();
  13487.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
  13488.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13489. }
  13490.  
  13491. /* ffestb_beru10_ -- "BACKSPACE/ENDFILE/REWIND/UNLOCK" OPEN_PAREN ... CLOSE_PAREN
  13492.  
  13493.    return ffestb_beru10_;  // to lexer
  13494.  
  13495.    Handle EOS or SEMICOLON here.  */
  13496.  
  13497. static ffelexHandler
  13498. ffestb_beru10_ (ffelexToken t)
  13499. {
  13500.   switch (ffelex_token_type (t))
  13501.     {
  13502.     case FFELEX_typeEOS:
  13503.     case FFELEX_typeSEMICOLON:
  13504.       ffesta_confirmed ();
  13505.       if (!ffesta_is_inhibited ())
  13506.     {
  13507.       switch (ffesta_first_kw)
  13508.         {
  13509.         case FFESTR_firstBACKSPACE:
  13510.           ffestc_R919 ();
  13511.           break;
  13512.  
  13513.         case FFESTR_firstENDFILE:
  13514.         case FFESTR_firstEND:
  13515.           ffestc_R920 ();
  13516.           break;
  13517.  
  13518.         case FFESTR_firstREWIND:
  13519.           ffestc_R921 ();
  13520.           break;
  13521.  
  13522. #if FFESTR_VXT
  13523.         case FFESTR_firstUNLOCK:
  13524.           ffestc_V022 ();
  13525.           break;
  13526. #endif
  13527.  
  13528.         default:
  13529.           assert (FALSE);
  13530.         }
  13531.     }
  13532.       ffestb_subr_kill_beru_ ();
  13533.       return (ffelexHandler) ffesta_zero (t);
  13534.  
  13535.     default:
  13536.       break;
  13537.     }
  13538.  
  13539.   ffestb_subr_kill_beru_ ();
  13540.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.beru.badname, t);
  13541.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13542. }
  13543.  
  13544. /* ffestb_vxtcode -- Parse the VXT DECODE/ENCODE statement
  13545.  
  13546.    return ffestb_vxtcode;  // to lexer
  13547.  
  13548.    Make sure the statement has a valid form for the VXT DECODE/ENCODE
  13549.    statement.  If it does, implement the statement.  */
  13550.  
  13551. #if FFESTR_VXT
  13552. ffelexHandler
  13553. ffestb_vxtcode (ffelexToken t)
  13554. {
  13555.   ffestpVxtcodeIx ix;
  13556.  
  13557.   switch (ffelex_token_type (ffesta_tokens[0]))
  13558.     {
  13559.     case FFELEX_typeNAME:
  13560.       switch (ffelex_token_type (t))
  13561.     {
  13562.     case FFELEX_typeCOMMA:
  13563.     case FFELEX_typeCOLONCOLON:
  13564.     case FFELEX_typeEOS:
  13565.     case FFELEX_typeSEMICOLON:
  13566.     case FFELEX_typeNAME:
  13567.     case FFELEX_typeNUMBER:
  13568.       ffesta_confirmed ();    /* Error, but clearly intended. */
  13569.       goto bad_1;        /* :::::::::::::::::::: */
  13570.  
  13571.     default:
  13572.       goto bad_1;        /* :::::::::::::::::::: */
  13573.  
  13574.     case FFELEX_typeOPEN_PAREN:
  13575.       for (ix = 0; ix < FFESTP_vxtcodeix; ++ix)
  13576.         ffestp_file.vxtcode.vxtcode_spec[ix].kw_or_val_present = FALSE;
  13577.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  13578.         FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_vxtcode1_);
  13579.     }
  13580.  
  13581.     case FFELEX_typeNAMES:
  13582.       switch (ffelex_token_type (t))
  13583.     {
  13584.     case FFELEX_typeEOS:
  13585.     case FFELEX_typeSEMICOLON:
  13586.     case FFELEX_typeCOMMA:
  13587.     case FFELEX_typeCOLONCOLON:
  13588.       ffesta_confirmed ();    /* Error, but clearly intended. */
  13589.       goto bad_1;        /* :::::::::::::::::::: */
  13590.  
  13591.     default:
  13592.       goto bad_1;        /* :::::::::::::::::::: */
  13593.  
  13594.     case FFELEX_typeOPEN_PAREN:
  13595.       if (ffelex_token_length (ffesta_tokens[0])
  13596.           != ffestb_args.vxtcode.len)
  13597.         goto bad_0;        /* :::::::::::::::::::: */
  13598.  
  13599.       for (ix = 0; ix < FFESTP_vxtcodeix; ++ix)
  13600.         ffestp_file.vxtcode.vxtcode_spec[ix].kw_or_val_present = FALSE;
  13601.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  13602.         FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_vxtcode1_);
  13603.     }
  13604.  
  13605.     default:
  13606.       goto bad_0;        /* :::::::::::::::::::: */
  13607.     }
  13608.  
  13609. bad_0:                /* :::::::::::::::::::: */
  13610.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, ffesta_tokens[0]);
  13611.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13612.  
  13613. bad_1:                /* :::::::::::::::::::: */
  13614.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
  13615.   return (ffelexHandler) ffelex_swallow_tokens (t,
  13616.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  13617. }
  13618.  
  13619. /* ffestb_vxtcode1_ -- "VXTCODE" OPEN_PAREN expr
  13620.  
  13621.    (ffestb_vxtcode1_)  // to expression handler
  13622.  
  13623.    Handle COMMA here.  */
  13624.  
  13625. static ffelexHandler
  13626. ffestb_vxtcode1_ (ffelexToken ft, ffebld expr, ffelexToken t)
  13627. {
  13628.   switch (ffelex_token_type (t))
  13629.     {
  13630.     case FFELEX_typeCOMMA:
  13631.       if (expr == NULL)
  13632.     break;
  13633.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].kw_or_val_present
  13634.     = TRUE;
  13635.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].kw_present = FALSE;
  13636.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value_present = TRUE;
  13637.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value_is_label
  13638.     = FALSE;
  13639.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].value
  13640.     = ffelex_token_use (ft);
  13641.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixC].u.expr = expr;
  13642.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  13643.          FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_vxtcode2_);
  13644.  
  13645.     default:
  13646.       break;
  13647.     }
  13648.  
  13649.   ffestb_subr_kill_vxtcode_ ();
  13650.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
  13651.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13652. }
  13653.  
  13654. /* ffestb_vxtcode2_ -- "VXTCODE" OPEN_PAREN expr COMMA expr
  13655.  
  13656.    (ffestb_vxtcode2_)  // to expression handler
  13657.  
  13658.    Handle COMMA here.  */
  13659.  
  13660. static ffelexHandler
  13661. ffestb_vxtcode2_ (ffelexToken ft, ffebld expr, ffelexToken t)
  13662. {
  13663.   switch (ffelex_token_type (t))
  13664.     {
  13665.     case FFELEX_typeCOMMA:
  13666.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].kw_or_val_present
  13667.     = TRUE;
  13668.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].kw_present = FALSE;
  13669.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value_present = TRUE;
  13670.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value_is_label
  13671.     = (expr == NULL);
  13672.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].value
  13673.     = ffelex_token_use (ft);
  13674.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixF].u.expr = expr;
  13675.       if (ffesta_first_kw == FFESTR_firstENCODE)
  13676.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  13677.                         FFEEXPR_contextFILEVXTCODE,
  13678.                     (ffeexprCallback) ffestb_vxtcode3_);
  13679.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  13680.                       FFEEXPR_contextFILEVXTCODE,
  13681.                     (ffeexprCallback) ffestb_vxtcode3_);
  13682.  
  13683.     default:
  13684.       break;
  13685.     }
  13686.  
  13687.   ffestb_subr_kill_vxtcode_ ();
  13688.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
  13689.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13690. }
  13691.  
  13692. /* ffestb_vxtcode3_ -- "VXTCODE" OPEN_PAREN expr COMMA expr COMMA expr
  13693.  
  13694.    (ffestb_vxtcode3_)  // to expression handler
  13695.  
  13696.    Handle COMMA or CLOSE_PAREN here.  */
  13697.  
  13698. static ffelexHandler
  13699. ffestb_vxtcode3_ (ffelexToken ft, ffebld expr, ffelexToken t)
  13700. {
  13701.   switch (ffelex_token_type (t))
  13702.     {
  13703.     case FFELEX_typeCOMMA:
  13704.     case FFELEX_typeCLOSE_PAREN:
  13705.       if (expr == NULL)
  13706.     break;
  13707.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].kw_or_val_present
  13708.     = TRUE;
  13709.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].kw_present = FALSE;
  13710.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value_present = TRUE;
  13711.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value_is_label
  13712.     = FALSE;
  13713.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].value
  13714.     = ffelex_token_use (ft);
  13715.       ffestp_file.vxtcode.vxtcode_spec[FFESTP_vxtcodeixB].u.expr = expr;
  13716.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  13717.     return (ffelexHandler) ffestb_vxtcode4_;
  13718.       return (ffelexHandler) ffestb_vxtcode9_;
  13719.  
  13720.     default:
  13721.       break;
  13722.     }
  13723.  
  13724.   ffestb_subr_kill_vxtcode_ ();
  13725.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
  13726.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13727. }
  13728.  
  13729. /* ffestb_vxtcode4_ -- "VXTCODE" OPEN_PAREN ...
  13730.  
  13731.    return ffestb_vxtcode4_;  // to lexer
  13732.  
  13733.    Handle NAME=expr construct here.  */
  13734.  
  13735. static ffelexHandler
  13736. ffestb_vxtcode4_ (ffelexToken t)
  13737. {
  13738.   ffestrGenio kw;
  13739.  
  13740.   ffestb_local_.vxtcode.label = FALSE;
  13741.  
  13742.   switch (ffelex_token_type (t))
  13743.     {
  13744.     case FFELEX_typeNAME:
  13745.       kw = ffestr_genio (t);
  13746.       switch (kw)
  13747.     {
  13748.     case FFESTR_genioERR:
  13749.       ffestb_local_.vxtcode.ix = FFESTP_vxtcodeixERR;
  13750.       ffestb_local_.vxtcode.label = TRUE;
  13751.       break;
  13752.  
  13753.     case FFESTR_genioIOSTAT:
  13754.       ffestb_local_.vxtcode.ix = FFESTP_vxtcodeixIOSTAT;
  13755.       ffestb_local_.vxtcode.left = TRUE;
  13756.       ffestb_local_.vxtcode.context = FFEEXPR_contextFILEINT;
  13757.       break;
  13758.  
  13759.     default:
  13760.       goto bad;        /* :::::::::::::::::::: */
  13761.     }
  13762.       if (ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
  13763.       .kw_or_val_present)
  13764.     break;            /* Can't specify a keyword twice! */
  13765.       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
  13766.     .kw_or_val_present = TRUE;
  13767.       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
  13768.     .kw_present = TRUE;
  13769.       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix]
  13770.     .value_present = FALSE;
  13771.       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value_is_label
  13772.     = ffestb_local_.vxtcode.label;
  13773.       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].kw
  13774.     = ffelex_token_use (t);
  13775.       return (ffelexHandler) ffestb_vxtcode5_;
  13776.  
  13777.     default:
  13778.       break;
  13779.     }
  13780.  
  13781. bad:                /* :::::::::::::::::::: */
  13782.   ffestb_subr_kill_vxtcode_ ();
  13783.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
  13784.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13785. }
  13786.  
  13787. /* ffestb_vxtcode5_ -- "VXTCODE" OPEN_PAREN [external-file-unit COMMA [format
  13788.            COMMA]] NAME
  13789.  
  13790.    return ffestb_vxtcode5_;  // to lexer
  13791.  
  13792.    Make sure EQUALS here, send next token to expression handler.  */
  13793.  
  13794. static ffelexHandler
  13795. ffestb_vxtcode5_ (ffelexToken t)
  13796. {
  13797.   switch (ffelex_token_type (t))
  13798.     {
  13799.     case FFELEX_typeEQUALS:
  13800.       ffesta_confirmed ();
  13801.       if (ffestb_local_.vxtcode.label)
  13802.     return (ffelexHandler) ffestb_vxtcode7_;
  13803.       if (ffestb_local_.vxtcode.left)
  13804.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  13805.                         ffestb_local_.vxtcode.context,
  13806.                     (ffeexprCallback) ffestb_vxtcode6_);
  13807.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  13808.                       ffestb_local_.vxtcode.context,
  13809.                     (ffeexprCallback) ffestb_vxtcode6_);
  13810.  
  13811.     default:
  13812.       break;
  13813.     }
  13814.  
  13815.   ffestb_subr_kill_vxtcode_ ();
  13816.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
  13817.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13818. }
  13819.  
  13820. /* ffestb_vxtcode6_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS expr
  13821.  
  13822.    (ffestb_vxtcode6_)  // to expression handler
  13823.  
  13824.    Handle COMMA or CLOSE_PAREN here.  */
  13825.  
  13826. static ffelexHandler
  13827. ffestb_vxtcode6_ (ffelexToken ft, ffebld expr, ffelexToken t)
  13828. {
  13829.   switch (ffelex_token_type (t))
  13830.     {
  13831.     case FFELEX_typeCOMMA:
  13832.     case FFELEX_typeCLOSE_PAREN:
  13833.       if (expr == NULL)
  13834.     break;
  13835.       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value_present
  13836.     = TRUE;
  13837.       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].value
  13838.     = ffelex_token_use (ft);
  13839.       ffestp_file.vxtcode.vxtcode_spec[ffestb_local_.vxtcode.ix].u.expr = expr;
  13840.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  13841.     return (ffelexHandler) ffestb_vxtcode4_;
  13842.       return (ffelexHandler) ffestb_vxtcode9_;
  13843.  
  13844.     default:
  13845.       break;
  13846.     }
  13847.  
  13848.   ffestb_subr_kill_vxtcode_ ();
  13849.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
  13850.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13851. }
  13852.  
  13853. /* ffestb_vxtcode7_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS
  13854.  
  13855.    return ffestb_vxtcode7_;  // to lexer
  13856.  
  13857.    Handle NUMBER for label here.  */
  13858.  
  13859. static ffelexHandler
  13860. ffestb_vxtcode7_ (ffelexToken t)
  13861. {
  13862.   switch (ffelex_token_type (t))
  13863.     {
  13864.     case FFELEX_typeNUMBER:
  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 (t);
  13869.       return (ffelexHandler) ffestb_vxtcode8_;
  13870.  
  13871.     default:
  13872.       break;
  13873.     }
  13874.  
  13875.   ffestb_subr_kill_vxtcode_ ();
  13876.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
  13877.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13878. }
  13879.  
  13880. /* ffestb_vxtcode8_ -- "VXTCODE" OPEN_PAREN ... NAME EQUALS NUMBER
  13881.  
  13882.    return ffestb_vxtcode8_;  // to lexer
  13883.  
  13884.    Handle COMMA or CLOSE_PAREN here.  */
  13885.  
  13886. static ffelexHandler
  13887. ffestb_vxtcode8_ (ffelexToken t)
  13888. {
  13889.   switch (ffelex_token_type (t))
  13890.     {
  13891.     case FFELEX_typeCOMMA:
  13892.       return (ffelexHandler) ffestb_vxtcode4_;
  13893.  
  13894.     case FFELEX_typeCLOSE_PAREN:
  13895.       return (ffelexHandler) ffestb_vxtcode9_;
  13896.  
  13897.     default:
  13898.       break;
  13899.     }
  13900.  
  13901.   ffestb_subr_kill_vxtcode_ ();
  13902.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
  13903.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13904. }
  13905.  
  13906. /* ffestb_vxtcode9_ -- "VXTCODE" OPEN_PAREN ... CLOSE_PAREN
  13907.  
  13908.    return ffestb_vxtcode9_;  // to lexer
  13909.  
  13910.    Handle EOS or SEMICOLON here.
  13911.  
  13912.    07-Jun-90  JCB  1.1
  13913.       Context for ENCODE/DECODE expressions is now IOLISTDF instead of IOLIST
  13914.       since they apply to internal files.  */
  13915.  
  13916. static ffelexHandler
  13917. ffestb_vxtcode9_ (ffelexToken t)
  13918. {
  13919.   ffelexHandler next;
  13920.  
  13921.   switch (ffelex_token_type (t))
  13922.     {
  13923.     case FFELEX_typeEOS:
  13924.     case FFELEX_typeSEMICOLON:
  13925.       ffesta_confirmed ();
  13926.       if (!ffesta_is_inhibited ())
  13927.     {
  13928.       if (ffesta_first_kw == FFESTR_firstENCODE)
  13929.         {
  13930.           ffestc_V023_start ();
  13931.           ffestc_V023_finish ();
  13932.         }
  13933.       else
  13934.         {
  13935.           ffestc_V024_start ();
  13936.           ffestc_V024_finish ();
  13937.         }
  13938.     }
  13939.       ffestb_subr_kill_vxtcode_ ();
  13940.       return (ffelexHandler) ffesta_zero (t);
  13941.  
  13942.     case FFELEX_typeNAME:
  13943.     case FFELEX_typeOPEN_PAREN:
  13944.     case FFELEX_typeCOMMA:
  13945.       ffesta_confirmed ();
  13946.       if (!ffesta_is_inhibited ())
  13947.     if (ffesta_first_kw == FFESTR_firstENCODE)
  13948.       ffestc_V023_start ();
  13949.     else
  13950.       ffestc_V024_start ();
  13951.       ffestb_subr_kill_vxtcode_ ();
  13952.       if (ffesta_first_kw == FFESTR_firstDECODE)
  13953.     next = (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  13954.                         FFEEXPR_contextIOLISTDF,
  13955.                        (ffeexprCallback) ffestb_vxtcode10_);
  13956.       else
  13957.     next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  13958.                         FFEEXPR_contextIOLISTDF,
  13959.                        (ffeexprCallback) ffestb_vxtcode10_);
  13960.  
  13961.       /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
  13962.          (f2c provides this extension, as do other compilers, supposedly.) */
  13963.  
  13964.       if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
  13965.     return next;
  13966.  
  13967.       return (ffelexHandler) (*next) (t);
  13968.  
  13969.     default:
  13970.       break;
  13971.     }
  13972.  
  13973.   ffestb_subr_kill_vxtcode_ ();
  13974.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
  13975.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  13976. }
  13977.  
  13978. /* ffestb_vxtcode10_ -- "VXTCODE(...)" expr
  13979.  
  13980.    (ffestb_vxtcode10_)    // to expression handler
  13981.  
  13982.    Handle COMMA or EOS/SEMICOLON here.
  13983.  
  13984.    07-Jun-90  JCB  1.1
  13985.       Context for ENCODE/DECODE expressions is now IOLISTDF instead of IOLIST
  13986.       since they apply to internal files.  */
  13987.  
  13988. static ffelexHandler
  13989. ffestb_vxtcode10_ (ffelexToken ft, ffebld expr, ffelexToken t)
  13990. {
  13991.   switch (ffelex_token_type (t))
  13992.     {
  13993.     case FFELEX_typeCOMMA:
  13994.       if (expr == NULL)
  13995.     break;
  13996.       if (!ffesta_is_inhibited ())
  13997.     if (ffesta_first_kw == FFESTR_firstENCODE)
  13998.       ffestc_V023_item (expr, ft);
  13999.     else
  14000.       ffestc_V024_item (expr, ft);
  14001.       if (ffesta_first_kw == FFESTR_firstDECODE)
  14002.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  14003.                         FFEEXPR_contextIOLISTDF,
  14004.                        (ffeexprCallback) ffestb_vxtcode10_);
  14005.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  14006.                       FFEEXPR_contextIOLISTDF,
  14007.                        (ffeexprCallback) ffestb_vxtcode10_);
  14008.  
  14009.     case FFELEX_typeEOS:
  14010.     case FFELEX_typeSEMICOLON:
  14011.       if (expr == NULL)
  14012.     break;
  14013.       if (!ffesta_is_inhibited ())
  14014.     {
  14015.       if (ffesta_first_kw == FFESTR_firstENCODE)
  14016.         {
  14017.           ffestc_V023_item (expr, ft);
  14018.           ffestc_V023_finish ();
  14019.         }
  14020.       else
  14021.         {
  14022.           ffestc_V024_item (expr, ft);
  14023.           ffestc_V024_finish ();
  14024.         }
  14025.     }
  14026.       return (ffelexHandler) ffesta_zero (t);
  14027.  
  14028.     default:
  14029.       break;
  14030.     }
  14031.  
  14032.   if (!ffesta_is_inhibited ())
  14033.     if (ffesta_first_kw == FFESTR_firstENCODE)
  14034.       ffestc_V023_finish ();
  14035.     else
  14036.       ffestc_V024_finish ();
  14037.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.vxtcode.badname, t);
  14038.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14039. }
  14040.  
  14041. #endif
  14042. /* ffestb_R904 -- Parse an OPEN statement
  14043.  
  14044.    return ffestb_R904;    // to lexer
  14045.  
  14046.    Make sure the statement has a valid form for an OPEN statement.
  14047.    If it does, implement the statement.     */
  14048.  
  14049. ffelexHandler
  14050. ffestb_R904 (ffelexToken t)
  14051. {
  14052.   ffestpOpenIx ix;
  14053.  
  14054.   switch (ffelex_token_type (ffesta_tokens[0]))
  14055.     {
  14056.     case FFELEX_typeNAME:
  14057.       if (ffesta_first_kw != FFESTR_firstOPEN)
  14058.     goto bad_0;        /* :::::::::::::::::::: */
  14059.       break;
  14060.  
  14061.     case FFELEX_typeNAMES:
  14062.       if (ffesta_first_kw != FFESTR_firstOPEN)
  14063.     goto bad_0;        /* :::::::::::::::::::: */
  14064.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlOPEN)
  14065.     goto bad_0;        /* :::::::::::::::::::: */
  14066.       break;
  14067.  
  14068.     default:
  14069.       goto bad_0;        /* :::::::::::::::::::: */
  14070.     }
  14071.  
  14072.   switch (ffelex_token_type (t))
  14073.     {
  14074.     case FFELEX_typeOPEN_PAREN:
  14075.       break;
  14076.  
  14077.     case FFELEX_typeEOS:
  14078.     case FFELEX_typeSEMICOLON:
  14079.     case FFELEX_typeCOMMA:
  14080.     case FFELEX_typeCOLONCOLON:
  14081.       ffesta_confirmed ();    /* Error, but clearly intended. */
  14082.       goto bad_1;        /* :::::::::::::::::::: */
  14083.  
  14084.     default:
  14085.       goto bad_1;        /* :::::::::::::::::::: */
  14086.     }
  14087.  
  14088.   for (ix = 0; ix < FFESTP_openix; ++ix)
  14089.     ffestp_file.open.open_spec[ix].kw_or_val_present = FALSE;
  14090.  
  14091.   return (ffelexHandler) ffestb_R9041_;
  14092.  
  14093. bad_0:                /* :::::::::::::::::::: */
  14094.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", ffesta_tokens[0]);
  14095.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14096.  
  14097. bad_1:                /* :::::::::::::::::::: */
  14098.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
  14099.   return (ffelexHandler) ffelex_swallow_tokens (t,
  14100.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  14101. }
  14102.  
  14103. /* ffestb_R9041_ -- "OPEN" OPEN_PAREN
  14104.  
  14105.    return ffestb_R9041_;  // to lexer
  14106.  
  14107.    Handle expr construct (not NAME=expr construct) here.  */
  14108.  
  14109. static ffelexHandler
  14110. ffestb_R9041_ (ffelexToken t)
  14111. {
  14112.   switch (ffelex_token_type (t))
  14113.     {
  14114.     case FFELEX_typeNAME:
  14115.       ffesta_tokens[1] = ffelex_token_use (t);
  14116.       return (ffelexHandler) ffestb_R9042_;
  14117.  
  14118.     default:
  14119.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  14120.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9043_)))
  14121.     (t);
  14122.     }
  14123. }
  14124.  
  14125. /* ffestb_R9042_ -- "OPEN" OPEN_PAREN NAME
  14126.  
  14127.    return ffestb_R9042_;  // to lexer
  14128.  
  14129.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  14130.    token thru expression handler.  */
  14131.  
  14132. static ffelexHandler
  14133. ffestb_R9042_ (ffelexToken t)
  14134. {
  14135.   ffelexHandler next;
  14136.   ffelexToken nt;
  14137.  
  14138.   switch (ffelex_token_type (t))
  14139.     {
  14140.     case FFELEX_typeEQUALS:
  14141.       nt = ffesta_tokens[1];
  14142.       next = (ffelexHandler) ffestb_R9044_ (nt);
  14143.       ffelex_token_kill (nt);
  14144.       return (ffelexHandler) (*next) (t);
  14145.  
  14146.     default:
  14147.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  14148.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9043_)))
  14149.     (ffesta_tokens[1]);
  14150.       ffelex_token_kill (ffesta_tokens[1]);
  14151.       return (ffelexHandler) (*next) (t);
  14152.     }
  14153. }
  14154.  
  14155. /* ffestb_R9043_ -- "OPEN" OPEN_PAREN expr
  14156.  
  14157.    (ffestb_R9043_)  // to expression handler
  14158.  
  14159.    Handle COMMA or CLOSE_PAREN here.  */
  14160.  
  14161. static ffelexHandler
  14162. ffestb_R9043_ (ffelexToken ft, ffebld expr, ffelexToken t)
  14163. {
  14164.   switch (ffelex_token_type (t))
  14165.     {
  14166.     case FFELEX_typeCOMMA:
  14167.     case FFELEX_typeCLOSE_PAREN:
  14168.       if (expr == NULL)
  14169.     break;
  14170.       ffestp_file.open.open_spec[FFESTP_openixUNIT].kw_or_val_present
  14171.     = TRUE;
  14172.       ffestp_file.open.open_spec[FFESTP_openixUNIT].kw_present = FALSE;
  14173.       ffestp_file.open.open_spec[FFESTP_openixUNIT].value_present = TRUE;
  14174.       ffestp_file.open.open_spec[FFESTP_openixUNIT].value_is_label
  14175.     = FALSE;
  14176.       ffestp_file.open.open_spec[FFESTP_openixUNIT].value
  14177.     = ffelex_token_use (ft);
  14178.       ffestp_file.open.open_spec[FFESTP_openixUNIT].u.expr = expr;
  14179.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  14180.     return (ffelexHandler) ffestb_R9044_;
  14181.       return (ffelexHandler) ffestb_R9049_;
  14182.  
  14183.     default:
  14184.       break;
  14185.     }
  14186.  
  14187.   ffestb_subr_kill_open_ ();
  14188.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
  14189.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14190. }
  14191.  
  14192. /* ffestb_R9044_ -- "OPEN" OPEN_PAREN [external-file-unit COMMA]
  14193.  
  14194.    return ffestb_R9044_;  // to lexer
  14195.  
  14196.    Handle expr construct (not NAME=expr construct) here.  */
  14197.  
  14198. static ffelexHandler
  14199. ffestb_R9044_ (ffelexToken t)
  14200. {
  14201.   ffestrOpen kw;
  14202.  
  14203.   ffestb_local_.open.label = FALSE;
  14204.  
  14205.   switch (ffelex_token_type (t))
  14206.     {
  14207.     case FFELEX_typeNAME:
  14208.       kw = ffestr_open (t);
  14209.       switch (kw)
  14210.     {
  14211.     case FFESTR_openACCESS:
  14212.       ffestb_local_.open.ix = FFESTP_openixACCESS;
  14213.       ffestb_local_.open.left = FALSE;
  14214.       ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
  14215.       break;
  14216.  
  14217.     case FFESTR_openACTION:
  14218.       ffestb_local_.open.ix = FFESTP_openixACTION;
  14219.       ffestb_local_.open.left = FALSE;
  14220.       ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
  14221.       break;
  14222.  
  14223.     case FFESTR_openASSOCIATEVARIABLE:
  14224.       ffestb_local_.open.ix = FFESTP_openixASSOCIATEVARIABLE;
  14225.       ffestb_local_.open.left = TRUE;
  14226.       ffestb_local_.open.context = FFEEXPR_contextFILEASSOC;
  14227.       break;
  14228.  
  14229.     case FFESTR_openBLANK:
  14230.       ffestb_local_.open.ix = FFESTP_openixBLANK;
  14231.       ffestb_local_.open.left = FALSE;
  14232.       ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
  14233.       break;
  14234.  
  14235.     case FFESTR_openBLOCKSIZE:
  14236.       ffestb_local_.open.ix = FFESTP_openixBLOCKSIZE;
  14237.       ffestb_local_.open.left = FALSE;
  14238.       ffestb_local_.open.context = FFEEXPR_contextFILENUM;
  14239.       break;
  14240.  
  14241.     case FFESTR_openBUFFERCOUNT:
  14242.       ffestb_local_.open.ix = FFESTP_openixBUFFERCOUNT;
  14243.       ffestb_local_.open.left = FALSE;
  14244.       ffestb_local_.open.context = FFEEXPR_contextFILENUM;
  14245.       break;
  14246.  
  14247.     case FFESTR_openCARRIAGECONTROL:
  14248.       ffestb_local_.open.ix = FFESTP_openixCARRIAGECONTROL;
  14249.       ffestb_local_.open.left = FALSE;
  14250.       ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
  14251.       break;
  14252.  
  14253.     case FFESTR_openDEFAULTFILE:
  14254.       ffestb_local_.open.ix = FFESTP_openixDEFAULTFILE;
  14255.       ffestb_local_.open.left = FALSE;
  14256.       ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
  14257.       break;
  14258.  
  14259.     case FFESTR_openDELIM:
  14260.       ffestb_local_.open.ix = FFESTP_openixDELIM;
  14261.       ffestb_local_.open.left = FALSE;
  14262.       ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
  14263.       break;
  14264.  
  14265.     case FFESTR_openDISP:
  14266.     case FFESTR_openDISPOSE:
  14267.       ffestb_local_.open.ix = FFESTP_openixDISPOSE;
  14268.       ffestb_local_.open.left = FALSE;
  14269.       ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
  14270.       break;
  14271.  
  14272.     case FFESTR_openERR:
  14273.       ffestb_local_.open.ix = FFESTP_openixERR;
  14274.       ffestb_local_.open.label = TRUE;
  14275.       break;
  14276.  
  14277.     case FFESTR_openEXTENDSIZE:
  14278.       ffestb_local_.open.ix = FFESTP_openixEXTENDSIZE;
  14279.       ffestb_local_.open.left = FALSE;
  14280.       ffestb_local_.open.context = FFEEXPR_contextFILENUM;
  14281.       break;
  14282.  
  14283.     case FFESTR_openFILE:
  14284.     case FFESTR_openNAME:
  14285.       ffestb_local_.open.ix = FFESTP_openixFILE;
  14286.       ffestb_local_.open.left = FALSE;
  14287.       ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
  14288.       break;
  14289.  
  14290.     case FFESTR_openFORM:
  14291.       ffestb_local_.open.ix = FFESTP_openixFORM;
  14292.       ffestb_local_.open.left = FALSE;
  14293.       ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
  14294.       break;
  14295.  
  14296.     case FFESTR_openINITIALSIZE:
  14297.       ffestb_local_.open.ix = FFESTP_openixINITIALSIZE;
  14298.       ffestb_local_.open.left = FALSE;
  14299.       ffestb_local_.open.context = FFEEXPR_contextFILENUM;
  14300.       break;
  14301.  
  14302.     case FFESTR_openIOSTAT:
  14303.       ffestb_local_.open.ix = FFESTP_openixIOSTAT;
  14304.       ffestb_local_.open.left = TRUE;
  14305.       ffestb_local_.open.context = FFEEXPR_contextFILEINT;
  14306.       break;
  14307.  
  14308. #if 0                /* Haven't added support for expression
  14309.                    context yet (though easy). */
  14310.     case FFESTR_openKEY:
  14311.       ffestb_local_.open.ix = FFESTP_openixKEY;
  14312.       ffestb_local_.open.left = FALSE;
  14313.       ffestb_local_.open.context = FFEEXPR_contextFILEKEY;
  14314.       break;
  14315. #endif
  14316.  
  14317.     case FFESTR_openMAXREC:
  14318.       ffestb_local_.open.ix = FFESTP_openixMAXREC;
  14319.       ffestb_local_.open.left = FALSE;
  14320.       ffestb_local_.open.context = FFEEXPR_contextFILENUM;
  14321.       break;
  14322.  
  14323.     case FFESTR_openNOSPANBLOCKS:
  14324.       if (ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
  14325.           .kw_or_val_present)
  14326.         goto bad;        /* :::::::::::::::::::: */
  14327.       ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
  14328.         .kw_or_val_present = TRUE;
  14329.       ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
  14330.         .kw_present = TRUE;
  14331.       ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS]
  14332.         .value_present = FALSE;
  14333.       ffestp_file.open.open_spec[FFESTP_openixNOSPANBLOCKS].kw
  14334.         = ffelex_token_use (t);
  14335.       return (ffelexHandler) ffestb_R9048_;
  14336.  
  14337.     case FFESTR_openORGANIZATION:
  14338.       ffestb_local_.open.ix = FFESTP_openixORGANIZATION;
  14339.       ffestb_local_.open.left = FALSE;
  14340.       ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
  14341.       break;
  14342.  
  14343.     case FFESTR_openPAD:
  14344.       ffestb_local_.open.ix = FFESTP_openixPAD;
  14345.       ffestb_local_.open.left = FALSE;
  14346.       ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
  14347.       break;
  14348.  
  14349.     case FFESTR_openPOSITION:
  14350.       ffestb_local_.open.ix = FFESTP_openixPOSITION;
  14351.       ffestb_local_.open.left = FALSE;
  14352.       ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
  14353.       break;
  14354.  
  14355.     case FFESTR_openREADONLY:
  14356.       if (ffestp_file.open.open_spec[FFESTP_openixREADONLY]
  14357.           .kw_or_val_present)
  14358.         goto bad;        /* :::::::::::::::::::: */
  14359.       ffestp_file.open.open_spec[FFESTP_openixREADONLY]
  14360.         .kw_or_val_present = TRUE;
  14361.       ffestp_file.open.open_spec[FFESTP_openixREADONLY]
  14362.         .kw_present = TRUE;
  14363.       ffestp_file.open.open_spec[FFESTP_openixREADONLY]
  14364.         .value_present = FALSE;
  14365.       ffestp_file.open.open_spec[FFESTP_openixREADONLY].kw
  14366.         = ffelex_token_use (t);
  14367.       return (ffelexHandler) ffestb_R9048_;
  14368.  
  14369.     case FFESTR_openRECL:
  14370.     case FFESTR_openRECORDSIZE:
  14371.       ffestb_local_.open.ix = FFESTP_openixRECL;
  14372.       ffestb_local_.open.left = FALSE;
  14373.       ffestb_local_.open.context = FFEEXPR_contextFILENUM;
  14374.       break;
  14375.  
  14376.     case FFESTR_openRECORDTYPE:
  14377.       ffestb_local_.open.ix = FFESTP_openixRECORDTYPE;
  14378.       ffestb_local_.open.left = FALSE;
  14379.       ffestb_local_.open.context = FFEEXPR_contextFILECHAR;
  14380.       break;
  14381.  
  14382.     case FFESTR_openSHARED:
  14383.       if (ffestp_file.open.open_spec[FFESTP_openixSHARED]
  14384.           .kw_or_val_present)
  14385.         goto bad;        /* :::::::::::::::::::: */
  14386.       ffestp_file.open.open_spec[FFESTP_openixSHARED]
  14387.         .kw_or_val_present = TRUE;
  14388.       ffestp_file.open.open_spec[FFESTP_openixSHARED]
  14389.         .kw_present = TRUE;
  14390.       ffestp_file.open.open_spec[FFESTP_openixSHARED]
  14391.         .value_present = FALSE;
  14392.       ffestp_file.open.open_spec[FFESTP_openixSHARED].kw
  14393.         = ffelex_token_use (t);
  14394.       return (ffelexHandler) ffestb_R9048_;
  14395.  
  14396.     case FFESTR_openSTATUS:
  14397.     case FFESTR_openTYPE:
  14398.       ffestb_local_.open.ix = FFESTP_openixSTATUS;
  14399.       ffestb_local_.open.left = FALSE;
  14400.       ffestb_local_.open.context = FFEEXPR_contextFILEDFCHAR;
  14401.       break;
  14402.  
  14403.     case FFESTR_openUNIT:
  14404.       ffestb_local_.open.ix = FFESTP_openixUNIT;
  14405.       ffestb_local_.open.left = FALSE;
  14406.       ffestb_local_.open.context = FFEEXPR_contextFILENUM;
  14407.       break;
  14408.  
  14409.     case FFESTR_openUSEROPEN:
  14410.       ffestb_local_.open.ix = FFESTP_openixUSEROPEN;
  14411.       ffestb_local_.open.left = TRUE;
  14412.       ffestb_local_.open.context = FFEEXPR_contextFILEEXTFUNC;
  14413.       break;
  14414.  
  14415.     default:
  14416.       goto bad;        /* :::::::::::::::::::: */
  14417.     }
  14418.       if (ffestp_file.open.open_spec[ffestb_local_.open.ix]
  14419.       .kw_or_val_present)
  14420.     break;            /* Can't specify a keyword twice! */
  14421.       ffestp_file.open.open_spec[ffestb_local_.open.ix]
  14422.     .kw_or_val_present = TRUE;
  14423.       ffestp_file.open.open_spec[ffestb_local_.open.ix]
  14424.     .kw_present = TRUE;
  14425.       ffestp_file.open.open_spec[ffestb_local_.open.ix]
  14426.     .value_present = FALSE;
  14427.       ffestp_file.open.open_spec[ffestb_local_.open.ix].value_is_label
  14428.     = ffestb_local_.open.label;
  14429.       ffestp_file.open.open_spec[ffestb_local_.open.ix].kw
  14430.     = ffelex_token_use (t);
  14431.       return (ffelexHandler) ffestb_R9045_;
  14432.  
  14433.     default:
  14434.       break;
  14435.     }
  14436.  
  14437. bad:                /* :::::::::::::::::::: */
  14438.   ffestb_subr_kill_open_ ();
  14439.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
  14440.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14441. }
  14442.  
  14443. /* ffestb_R9045_ -- "OPEN" OPEN_PAREN [external-file-unit COMMA] NAME
  14444.  
  14445.    return ffestb_R9045_;  // to lexer
  14446.  
  14447.    Make sure EQUALS here, send next token to expression handler.  */
  14448.  
  14449. static ffelexHandler
  14450. ffestb_R9045_ (ffelexToken t)
  14451. {
  14452.   switch (ffelex_token_type (t))
  14453.     {
  14454.     case FFELEX_typeEQUALS:
  14455.       ffesta_confirmed ();
  14456.       if (ffestb_local_.open.label)
  14457.     return (ffelexHandler) ffestb_R9047_;
  14458.       if (ffestb_local_.open.left)
  14459.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  14460.                         ffestb_local_.open.context,
  14461.                         (ffeexprCallback) ffestb_R9046_);
  14462.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  14463.                       ffestb_local_.open.context,
  14464.                       (ffeexprCallback) ffestb_R9046_);
  14465.  
  14466.     default:
  14467.       break;
  14468.     }
  14469.  
  14470.   ffestb_subr_kill_open_ ();
  14471.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
  14472.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14473. }
  14474.  
  14475. /* ffestb_R9046_ -- "OPEN" OPEN_PAREN ... NAME EQUALS expr
  14476.  
  14477.    (ffestb_R9046_)  // to expression handler
  14478.  
  14479.    Handle COMMA or CLOSE_PAREN here.  */
  14480.  
  14481. static ffelexHandler
  14482. ffestb_R9046_ (ffelexToken ft, ffebld expr, ffelexToken t)
  14483. {
  14484.   switch (ffelex_token_type (t))
  14485.     {
  14486.     case FFELEX_typeCOMMA:
  14487.     case FFELEX_typeCLOSE_PAREN:
  14488.       if (expr == NULL)
  14489.     break;
  14490.       ffestp_file.open.open_spec[ffestb_local_.open.ix].value_present
  14491.     = TRUE;
  14492.       ffestp_file.open.open_spec[ffestb_local_.open.ix].value
  14493.     = ffelex_token_use (ft);
  14494.       ffestp_file.open.open_spec[ffestb_local_.open.ix].u.expr = expr;
  14495.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  14496.     return (ffelexHandler) ffestb_R9044_;
  14497.       return (ffelexHandler) ffestb_R9049_;
  14498.  
  14499.     default:
  14500.       break;
  14501.     }
  14502.  
  14503.   ffestb_subr_kill_open_ ();
  14504.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
  14505.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14506. }
  14507.  
  14508. /* ffestb_R9047_ -- "OPEN" OPEN_PAREN ... NAME EQUALS
  14509.  
  14510.    return ffestb_R9047_;  // to lexer
  14511.  
  14512.    Handle NUMBER for label here.  */
  14513.  
  14514. static ffelexHandler
  14515. ffestb_R9047_ (ffelexToken t)
  14516. {
  14517.   switch (ffelex_token_type (t))
  14518.     {
  14519.     case FFELEX_typeNUMBER:
  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 (t);
  14524.       return (ffelexHandler) ffestb_R9048_;
  14525.  
  14526.     default:
  14527.       break;
  14528.     }
  14529.  
  14530.   ffestb_subr_kill_open_ ();
  14531.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
  14532.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14533. }
  14534.  
  14535. /* ffestb_R9048_ -- "OPEN" OPEN_PAREN ... NAME EQUALS NUMBER
  14536.  
  14537.    return ffestb_R9048_;  // to lexer
  14538.  
  14539.    Handle COMMA or CLOSE_PAREN here.  */
  14540.  
  14541. static ffelexHandler
  14542. ffestb_R9048_ (ffelexToken t)
  14543. {
  14544.   switch (ffelex_token_type (t))
  14545.     {
  14546.     case FFELEX_typeCOMMA:
  14547.       return (ffelexHandler) ffestb_R9044_;
  14548.  
  14549.     case FFELEX_typeCLOSE_PAREN:
  14550.       return (ffelexHandler) ffestb_R9049_;
  14551.  
  14552.     default:
  14553.       break;
  14554.     }
  14555.  
  14556.   ffestb_subr_kill_open_ ();
  14557.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
  14558.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14559. }
  14560.  
  14561. /* ffestb_R9049_ -- "OPEN" OPEN_PAREN ... CLOSE_PAREN
  14562.  
  14563.    return ffestb_R9049_;  // to lexer
  14564.  
  14565.    Handle EOS or SEMICOLON here.  */
  14566.  
  14567. static ffelexHandler
  14568. ffestb_R9049_ (ffelexToken t)
  14569. {
  14570.   switch (ffelex_token_type (t))
  14571.     {
  14572.     case FFELEX_typeEOS:
  14573.     case FFELEX_typeSEMICOLON:
  14574.       ffesta_confirmed ();
  14575.       if (!ffesta_is_inhibited ())
  14576.     ffestc_R904 ();
  14577.       ffestb_subr_kill_open_ ();
  14578.       return (ffelexHandler) ffesta_zero (t);
  14579.  
  14580.     default:
  14581.       break;
  14582.     }
  14583.  
  14584.   ffestb_subr_kill_open_ ();
  14585.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "OPEN", t);
  14586.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14587. }
  14588.  
  14589. /* ffestb_R907 -- Parse a CLOSE statement
  14590.  
  14591.    return ffestb_R907;    // to lexer
  14592.  
  14593.    Make sure the statement has a valid form for a CLOSE statement.
  14594.    If it does, implement the statement.     */
  14595.  
  14596. ffelexHandler
  14597. ffestb_R907 (ffelexToken t)
  14598. {
  14599.   ffestpCloseIx ix;
  14600.  
  14601.   switch (ffelex_token_type (ffesta_tokens[0]))
  14602.     {
  14603.     case FFELEX_typeNAME:
  14604.       if (ffesta_first_kw != FFESTR_firstCLOSE)
  14605.     goto bad_0;        /* :::::::::::::::::::: */
  14606.       break;
  14607.  
  14608.     case FFELEX_typeNAMES:
  14609.       if (ffesta_first_kw != FFESTR_firstCLOSE)
  14610.     goto bad_0;        /* :::::::::::::::::::: */
  14611.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlCLOSE)
  14612.     goto bad_0;        /* :::::::::::::::::::: */
  14613.       break;
  14614.  
  14615.     default:
  14616.       goto bad_0;        /* :::::::::::::::::::: */
  14617.     }
  14618.  
  14619.   switch (ffelex_token_type (t))
  14620.     {
  14621.     case FFELEX_typeOPEN_PAREN:
  14622.       break;
  14623.  
  14624.     case FFELEX_typeEOS:
  14625.     case FFELEX_typeSEMICOLON:
  14626.     case FFELEX_typeCOMMA:
  14627.     case FFELEX_typeCOLONCOLON:
  14628.       ffesta_confirmed ();    /* Error, but clearly intended. */
  14629.       goto bad_1;        /* :::::::::::::::::::: */
  14630.  
  14631.     default:
  14632.       goto bad_1;        /* :::::::::::::::::::: */
  14633.     }
  14634.  
  14635.   for (ix = 0; ix < FFESTP_closeix; ++ix)
  14636.     ffestp_file.close.close_spec[ix].kw_or_val_present = FALSE;
  14637.  
  14638.   return (ffelexHandler) ffestb_R9071_;
  14639.  
  14640. bad_0:                /* :::::::::::::::::::: */
  14641.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", ffesta_tokens[0]);
  14642.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14643.  
  14644. bad_1:                /* :::::::::::::::::::: */
  14645.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
  14646.   return (ffelexHandler) ffelex_swallow_tokens (t,
  14647.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  14648. }
  14649.  
  14650. /* ffestb_R9071_ -- "CLOSE" OPEN_PAREN
  14651.  
  14652.    return ffestb_R9071_;  // to lexer
  14653.  
  14654.    Handle expr construct (not NAME=expr construct) here.  */
  14655.  
  14656. static ffelexHandler
  14657. ffestb_R9071_ (ffelexToken t)
  14658. {
  14659.   switch (ffelex_token_type (t))
  14660.     {
  14661.     case FFELEX_typeNAME:
  14662.       ffesta_tokens[1] = ffelex_token_use (t);
  14663.       return (ffelexHandler) ffestb_R9072_;
  14664.  
  14665.     default:
  14666.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  14667.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9073_)))
  14668.     (t);
  14669.     }
  14670. }
  14671.  
  14672. /* ffestb_R9072_ -- "CLOSE" OPEN_PAREN NAME
  14673.  
  14674.    return ffestb_R9072_;  // to lexer
  14675.  
  14676.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  14677.    token thru expression handler.  */
  14678.  
  14679. static ffelexHandler
  14680. ffestb_R9072_ (ffelexToken t)
  14681. {
  14682.   ffelexHandler next;
  14683.   ffelexToken nt;
  14684.  
  14685.   switch (ffelex_token_type (t))
  14686.     {
  14687.     case FFELEX_typeEQUALS:
  14688.       nt = ffesta_tokens[1];
  14689.       next = (ffelexHandler) ffestb_R9074_ (nt);
  14690.       ffelex_token_kill (nt);
  14691.       return (ffelexHandler) (*next) (t);
  14692.  
  14693.     default:
  14694.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  14695.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9073_)))
  14696.     (ffesta_tokens[1]);
  14697.       ffelex_token_kill (ffesta_tokens[1]);
  14698.       return (ffelexHandler) (*next) (t);
  14699.     }
  14700. }
  14701.  
  14702. /* ffestb_R9073_ -- "CLOSE" OPEN_PAREN expr
  14703.  
  14704.    (ffestb_R9073_)  // to expression handler
  14705.  
  14706.    Handle COMMA or CLOSE_PAREN here.  */
  14707.  
  14708. static ffelexHandler
  14709. ffestb_R9073_ (ffelexToken ft, ffebld expr, ffelexToken t)
  14710. {
  14711.   switch (ffelex_token_type (t))
  14712.     {
  14713.     case FFELEX_typeCOMMA:
  14714.     case FFELEX_typeCLOSE_PAREN:
  14715.       if (expr == NULL)
  14716.     break;
  14717.       ffestp_file.close.close_spec[FFESTP_closeixUNIT].kw_or_val_present
  14718.     = TRUE;
  14719.       ffestp_file.close.close_spec[FFESTP_closeixUNIT].kw_present = FALSE;
  14720.       ffestp_file.close.close_spec[FFESTP_closeixUNIT].value_present = TRUE;
  14721.       ffestp_file.close.close_spec[FFESTP_closeixUNIT].value_is_label
  14722.     = FALSE;
  14723.       ffestp_file.close.close_spec[FFESTP_closeixUNIT].value
  14724.     = ffelex_token_use (ft);
  14725.       ffestp_file.close.close_spec[FFESTP_closeixUNIT].u.expr = expr;
  14726.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  14727.     return (ffelexHandler) ffestb_R9074_;
  14728.       return (ffelexHandler) ffestb_R9079_;
  14729.  
  14730.     default:
  14731.       break;
  14732.     }
  14733.  
  14734.   ffestb_subr_kill_close_ ();
  14735.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
  14736.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14737. }
  14738.  
  14739. /* ffestb_R9074_ -- "CLOSE" OPEN_PAREN [external-file-unit COMMA]
  14740.  
  14741.    return ffestb_R9074_;  // to lexer
  14742.  
  14743.    Handle expr construct (not NAME=expr construct) here.  */
  14744.  
  14745. static ffelexHandler
  14746. ffestb_R9074_ (ffelexToken t)
  14747. {
  14748.   ffestrGenio kw;
  14749.  
  14750.   ffestb_local_.close.label = FALSE;
  14751.  
  14752.   switch (ffelex_token_type (t))
  14753.     {
  14754.     case FFELEX_typeNAME:
  14755.       kw = ffestr_genio (t);
  14756.       switch (kw)
  14757.     {
  14758.     case FFESTR_genioERR:
  14759.       ffestb_local_.close.ix = FFESTP_closeixERR;
  14760.       ffestb_local_.close.label = TRUE;
  14761.       break;
  14762.  
  14763.     case FFESTR_genioIOSTAT:
  14764.       ffestb_local_.close.ix = FFESTP_closeixIOSTAT;
  14765.       ffestb_local_.close.left = TRUE;
  14766.       ffestb_local_.close.context = FFEEXPR_contextFILEINT;
  14767.       break;
  14768.  
  14769.     case FFESTR_genioSTATUS:
  14770.     case FFESTR_genioDISP:
  14771.     case FFESTR_genioDISPOSE:
  14772.       ffestb_local_.close.ix = FFESTP_closeixSTATUS;
  14773.       ffestb_local_.close.left = FALSE;
  14774.       ffestb_local_.close.context = FFEEXPR_contextFILEDFCHAR;
  14775.       break;
  14776.  
  14777.     case FFESTR_genioUNIT:
  14778.       ffestb_local_.close.ix = FFESTP_closeixUNIT;
  14779.       ffestb_local_.close.left = FALSE;
  14780.       ffestb_local_.close.context = FFEEXPR_contextFILENUM;
  14781.       break;
  14782.  
  14783.     default:
  14784.       goto bad;        /* :::::::::::::::::::: */
  14785.     }
  14786.       if (ffestp_file.close.close_spec[ffestb_local_.close.ix]
  14787.       .kw_or_val_present)
  14788.     break;            /* Can't specify a keyword twice! */
  14789.       ffestp_file.close.close_spec[ffestb_local_.close.ix]
  14790.     .kw_or_val_present = TRUE;
  14791.       ffestp_file.close.close_spec[ffestb_local_.close.ix]
  14792.     .kw_present = TRUE;
  14793.       ffestp_file.close.close_spec[ffestb_local_.close.ix]
  14794.     .value_present = FALSE;
  14795.       ffestp_file.close.close_spec[ffestb_local_.close.ix].value_is_label
  14796.     = ffestb_local_.close.label;
  14797.       ffestp_file.close.close_spec[ffestb_local_.close.ix].kw
  14798.     = ffelex_token_use (t);
  14799.       return (ffelexHandler) ffestb_R9075_;
  14800.  
  14801.     default:
  14802.       break;
  14803.     }
  14804.  
  14805. bad:                /* :::::::::::::::::::: */
  14806.   ffestb_subr_kill_close_ ();
  14807.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
  14808.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14809. }
  14810.  
  14811. /* ffestb_R9075_ -- "CLOSE" OPEN_PAREN [external-file-unit COMMA] NAME
  14812.  
  14813.    return ffestb_R9075_;  // to lexer
  14814.  
  14815.    Make sure EQUALS here, send next token to expression handler.  */
  14816.  
  14817. static ffelexHandler
  14818. ffestb_R9075_ (ffelexToken t)
  14819. {
  14820.   switch (ffelex_token_type (t))
  14821.     {
  14822.     case FFELEX_typeEQUALS:
  14823.       ffesta_confirmed ();
  14824.       if (ffestb_local_.close.label)
  14825.     return (ffelexHandler) ffestb_R9077_;
  14826.       if (ffestb_local_.close.left)
  14827.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  14828.                         ffestb_local_.close.context,
  14829.                         (ffeexprCallback) ffestb_R9076_);
  14830.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  14831.                       ffestb_local_.close.context,
  14832.                       (ffeexprCallback) ffestb_R9076_);
  14833.  
  14834.     default:
  14835.       break;
  14836.     }
  14837.  
  14838.   ffestb_subr_kill_close_ ();
  14839.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
  14840.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14841. }
  14842.  
  14843. /* ffestb_R9076_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS expr
  14844.  
  14845.    (ffestb_R9076_)  // to expression handler
  14846.  
  14847.    Handle COMMA or CLOSE_PAREN here.  */
  14848.  
  14849. static ffelexHandler
  14850. ffestb_R9076_ (ffelexToken ft, ffebld expr, ffelexToken t)
  14851. {
  14852.   switch (ffelex_token_type (t))
  14853.     {
  14854.     case FFELEX_typeCOMMA:
  14855.     case FFELEX_typeCLOSE_PAREN:
  14856.       if (expr == NULL)
  14857.     break;
  14858.       ffestp_file.close.close_spec[ffestb_local_.close.ix].value_present
  14859.     = TRUE;
  14860.       ffestp_file.close.close_spec[ffestb_local_.close.ix].value
  14861.     = ffelex_token_use (ft);
  14862.       ffestp_file.close.close_spec[ffestb_local_.close.ix].u.expr = expr;
  14863.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  14864.     return (ffelexHandler) ffestb_R9074_;
  14865.       return (ffelexHandler) ffestb_R9079_;
  14866.  
  14867.     default:
  14868.       break;
  14869.     }
  14870.  
  14871.   ffestb_subr_kill_close_ ();
  14872.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
  14873.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14874. }
  14875.  
  14876. /* ffestb_R9077_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS
  14877.  
  14878.    return ffestb_R9077_;  // to lexer
  14879.  
  14880.    Handle NUMBER for label here.  */
  14881.  
  14882. static ffelexHandler
  14883. ffestb_R9077_ (ffelexToken t)
  14884. {
  14885.   switch (ffelex_token_type (t))
  14886.     {
  14887.     case FFELEX_typeNUMBER:
  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 (t);
  14892.       return (ffelexHandler) ffestb_R9078_;
  14893.  
  14894.     default:
  14895.       break;
  14896.     }
  14897.  
  14898.   ffestb_subr_kill_close_ ();
  14899.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
  14900.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14901. }
  14902.  
  14903. /* ffestb_R9078_ -- "CLOSE" OPEN_PAREN ... NAME EQUALS NUMBER
  14904.  
  14905.    return ffestb_R9078_;  // to lexer
  14906.  
  14907.    Handle COMMA or CLOSE_PAREN here.  */
  14908.  
  14909. static ffelexHandler
  14910. ffestb_R9078_ (ffelexToken t)
  14911. {
  14912.   switch (ffelex_token_type (t))
  14913.     {
  14914.     case FFELEX_typeCOMMA:
  14915.       return (ffelexHandler) ffestb_R9074_;
  14916.  
  14917.     case FFELEX_typeCLOSE_PAREN:
  14918.       return (ffelexHandler) ffestb_R9079_;
  14919.  
  14920.     default:
  14921.       break;
  14922.     }
  14923.  
  14924.   ffestb_subr_kill_close_ ();
  14925.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
  14926.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14927. }
  14928.  
  14929. /* ffestb_R9079_ -- "CLOSE" OPEN_PAREN ... CLOSE_PAREN
  14930.  
  14931.    return ffestb_R9079_;  // to lexer
  14932.  
  14933.    Handle EOS or SEMICOLON here.  */
  14934.  
  14935. static ffelexHandler
  14936. ffestb_R9079_ (ffelexToken t)
  14937. {
  14938.   switch (ffelex_token_type (t))
  14939.     {
  14940.     case FFELEX_typeEOS:
  14941.     case FFELEX_typeSEMICOLON:
  14942.       ffesta_confirmed ();
  14943.       if (!ffesta_is_inhibited ())
  14944.     ffestc_R907 ();
  14945.       ffestb_subr_kill_close_ ();
  14946.       return (ffelexHandler) ffesta_zero (t);
  14947.  
  14948.     default:
  14949.       break;
  14950.     }
  14951.  
  14952.   ffestb_subr_kill_close_ ();
  14953.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "CLOSE", t);
  14954.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  14955. }
  14956.  
  14957. /* ffestb_R909 -- Parse the READ statement
  14958.  
  14959.    return ffestb_R909;    // to lexer
  14960.  
  14961.    Make sure the statement has a valid form for the READ
  14962.    statement.  If it does, implement the statement.  */
  14963.  
  14964. ffelexHandler
  14965. ffestb_R909 (ffelexToken t)
  14966. {
  14967.   ffelexHandler next;
  14968.   ffestpReadIx ix;
  14969.  
  14970.   switch (ffelex_token_type (ffesta_tokens[0]))
  14971.     {
  14972.     case FFELEX_typeNAME:
  14973.       if (ffesta_first_kw != FFESTR_firstREAD)
  14974.     goto bad_0;        /* :::::::::::::::::::: */
  14975.       switch (ffelex_token_type (t))
  14976.     {
  14977.     case FFELEX_typeCOMMA:
  14978.     case FFELEX_typeCOLONCOLON:
  14979.     case FFELEX_typeEOS:
  14980.     case FFELEX_typeSEMICOLON:
  14981.       ffesta_confirmed ();    /* Error, but clearly intended. */
  14982.       goto bad_1;        /* :::::::::::::::::::: */
  14983.  
  14984.     case FFELEX_typeEQUALS:
  14985.     case FFELEX_typePOINTS:
  14986.     case FFELEX_typeCOLON:
  14987.       goto bad_1;        /* :::::::::::::::::::: */
  14988.  
  14989.     case FFELEX_typeNAME:
  14990.     case FFELEX_typeNUMBER:
  14991.       ffesta_confirmed ();
  14992.       break;
  14993.  
  14994.     case FFELEX_typeOPEN_PAREN:
  14995.       for (ix = 0; ix < FFESTP_readix; ++ix)
  14996.         ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
  14997.       ffesta_tokens[1] = ffelex_token_use (t);
  14998.       return (ffelexHandler) ffestb_R9092_;
  14999.  
  15000.     default:
  15001.       break;
  15002.     }
  15003.  
  15004.       for (ix = 0; ix < FFESTP_readix; ++ix)
  15005.     ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
  15006.       return (ffelexHandler) (*((ffelexHandler)
  15007.                 ffeexpr_rhs (ffesta_output_pool,
  15008.         FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9091_)))
  15009.     (t);
  15010.  
  15011.     case FFELEX_typeNAMES:
  15012.       if (ffesta_first_kw != FFESTR_firstREAD)
  15013.     goto bad_0;        /* :::::::::::::::::::: */
  15014.       switch (ffelex_token_type (t))
  15015.     {
  15016.     case FFELEX_typeEOS:
  15017.     case FFELEX_typeSEMICOLON:
  15018.     case FFELEX_typeCOMMA:
  15019.       ffesta_confirmed ();
  15020.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREAD)
  15021.         break;
  15022.       goto bad_1;        /* :::::::::::::::::::: */
  15023.  
  15024.     case FFELEX_typeCOLONCOLON:
  15025.       ffesta_confirmed ();    /* Error, but clearly intended. */
  15026.       goto bad_1;        /* :::::::::::::::::::: */
  15027.  
  15028.     case FFELEX_typeEQUALS:
  15029.     case FFELEX_typePOINTS:
  15030.     case FFELEX_typeCOLON:
  15031.       goto bad_1;        /* :::::::::::::::::::: */
  15032.  
  15033.     case FFELEX_typeOPEN_PAREN:
  15034.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREAD)
  15035.         break;
  15036.  
  15037.       for (ix = 0; ix < FFESTP_readix; ++ix)
  15038.         ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
  15039.       ffesta_tokens[1] = ffelex_token_use (t);
  15040.       return (ffelexHandler) ffestb_R9092_;
  15041.  
  15042.     default:
  15043.       break;
  15044.     }
  15045.       for (ix = 0; ix < FFESTP_readix; ++ix)
  15046.     ffestp_file.read.read_spec[ix].kw_or_val_present = FALSE;
  15047.       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  15048.          FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9091_);
  15049.       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
  15050.                            FFESTR_firstlREAD);
  15051.       if (next == NULL)
  15052.     return (ffelexHandler) ffelex_swallow_tokens (t,
  15053.                            (ffelexHandler) ffesta_zero);
  15054.       return (ffelexHandler) (*next) (t);
  15055.  
  15056.     default:
  15057.       goto bad_0;        /* :::::::::::::::::::: */
  15058.     }
  15059.  
  15060. bad_0:                /* :::::::::::::::::::: */
  15061.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", ffesta_tokens[0]);
  15062.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15063.  
  15064. bad_1:                /* :::::::::::::::::::: */
  15065.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
  15066.   return (ffelexHandler) ffelex_swallow_tokens (t,
  15067.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  15068. }
  15069.  
  15070. /* ffestb_R9091_ -- "READ" expr
  15071.  
  15072.    (ffestb_R9091_)  // to expression handler
  15073.  
  15074.    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
  15075.  
  15076. static ffelexHandler
  15077. ffestb_R9091_ (ffelexToken ft, ffebld expr, ffelexToken t)
  15078. {
  15079.   switch (ffelex_token_type (t))
  15080.     {
  15081.     case FFELEX_typeEOS:
  15082.     case FFELEX_typeSEMICOLON:
  15083.     case FFELEX_typeCOMMA:
  15084.       ffesta_confirmed ();
  15085.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
  15086.     = TRUE;
  15087.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
  15088.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
  15089.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
  15090.     = (expr == NULL);
  15091.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
  15092.     = ffelex_token_use (ft);
  15093.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
  15094.       if (!ffesta_is_inhibited ())
  15095.     ffestc_R909_start (TRUE);
  15096.       ffestb_subr_kill_read_ ();
  15097.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  15098.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  15099.                         ffestc_context_iolist (),
  15100.                       (ffeexprCallback) ffestb_R90914_);
  15101.       if (!ffesta_is_inhibited ())
  15102.     ffestc_R909_finish ();
  15103.       return (ffelexHandler) ffesta_zero (t);
  15104.  
  15105.     default:
  15106.       break;
  15107.     }
  15108.  
  15109.   ffestb_subr_kill_read_ ();
  15110.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
  15111.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15112. }
  15113.  
  15114. /* ffestb_R9092_ -- "READ" OPEN_PAREN
  15115.  
  15116.    return ffestb_R9092_;  // to lexer
  15117.  
  15118.    Handle expr construct (not NAME=expr construct) here.  */
  15119.  
  15120. static ffelexHandler
  15121. ffestb_R9092_ (ffelexToken t)
  15122. {
  15123.   ffelexToken nt;
  15124.   ffelexHandler next;
  15125.  
  15126.   switch (ffelex_token_type (t))
  15127.     {
  15128.     case FFELEX_typeNAME:
  15129.       ffesta_tokens[2] = ffelex_token_use (t);
  15130.       return (ffelexHandler) ffestb_R9093_;
  15131.  
  15132.     default:
  15133.       nt = ffesta_tokens[1];
  15134.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  15135.         FFEEXPR_contextFILEUNITAMBIG, (ffeexprCallback) ffestb_R9094_)))
  15136.     (nt);
  15137.       ffelex_token_kill (nt);
  15138.       return (ffelexHandler) (*next) (t);
  15139.     }
  15140. }
  15141.  
  15142. /* ffestb_R9093_ -- "READ" OPEN_PAREN NAME
  15143.  
  15144.    return ffestb_R9093_;  // to lexer
  15145.  
  15146.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  15147.    token thru expression handler.  */
  15148.  
  15149. static ffelexHandler
  15150. ffestb_R9093_ (ffelexToken t)
  15151. {
  15152.   ffelexHandler next;
  15153.   ffelexToken nt;
  15154.   ffelexToken ot;
  15155.  
  15156.   switch (ffelex_token_type (t))
  15157.     {
  15158.     case FFELEX_typeEQUALS:
  15159.       ffelex_token_kill (ffesta_tokens[1]);
  15160.       nt = ffesta_tokens[2];
  15161.       next = (ffelexHandler) ffestb_R9098_ (nt);
  15162.       ffelex_token_kill (nt);
  15163.       return (ffelexHandler) (*next) (t);
  15164.  
  15165.     default:
  15166.       nt = ffesta_tokens[1];
  15167.       ot = ffesta_tokens[2];
  15168.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  15169.         FFEEXPR_contextFILEUNITAMBIG, (ffeexprCallback) ffestb_R9094_)))
  15170.     (nt);
  15171.       ffelex_token_kill (nt);
  15172.       next = (ffelexHandler) (*next) (ot);
  15173.       ffelex_token_kill (ot);
  15174.       return (ffelexHandler) (*next) (t);
  15175.     }
  15176. }
  15177.  
  15178. /* ffestb_R9094_ -- "READ" OPEN_PAREN expr [CLOSE_PAREN]
  15179.  
  15180.    (ffestb_R9094_)  // to expression handler
  15181.  
  15182.    Handle COMMA or EOS/SEMICOLON here.
  15183.  
  15184.    15-Feb-91  JCB  1.1
  15185.       Use new ffeexpr mechanism whereby the expr is encased in an opITEM if
  15186.       ffeexpr decided it was an item in a control list (hence a unit
  15187.       specifier), or a format specifier otherwise.  */
  15188.  
  15189. static ffelexHandler
  15190. ffestb_R9094_ (ffelexToken ft, ffebld expr, ffelexToken t)
  15191. {
  15192.   if (expr == NULL)
  15193.     goto bad;            /* :::::::::::::::::::: */
  15194.  
  15195.   if (ffebld_op (expr) != FFEBLD_opITEM)
  15196.     {
  15197.       switch (ffelex_token_type (t))
  15198.     {
  15199.     case FFELEX_typeCOMMA:
  15200.     case FFELEX_typeEOS:
  15201.     case FFELEX_typeSEMICOLON:
  15202.       ffesta_confirmed ();
  15203.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
  15204.         = TRUE;
  15205.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
  15206.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
  15207.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
  15208.         = FALSE;
  15209.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
  15210.         = ffelex_token_use (ft);
  15211.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
  15212.       if (!ffesta_is_inhibited ())
  15213.         ffestc_R909_start (TRUE);
  15214.       ffestb_subr_kill_read_ ();
  15215.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  15216.         return (ffelexHandler)
  15217.           ffeexpr_lhs (ffesta_output_pool,
  15218.                ffestc_context_iolist (),
  15219.                (ffeexprCallback) ffestb_R90914_);
  15220.       if (!ffesta_is_inhibited ())
  15221.         ffestc_R909_finish ();
  15222.       return (ffelexHandler) ffesta_zero (t);
  15223.  
  15224.     default:
  15225.       goto bad;        /* :::::::::::::::::::: */
  15226.     }
  15227.     }
  15228.  
  15229.   expr = ffebld_head (expr);
  15230.  
  15231.   if (expr == NULL)
  15232.     goto bad;            /* :::::::::::::::::::: */
  15233.  
  15234.   switch (ffelex_token_type (t))
  15235.     {
  15236.     case FFELEX_typeCOMMA:
  15237.     case FFELEX_typeCLOSE_PAREN:
  15238.       ffestp_file.read.read_spec[FFESTP_readixUNIT].kw_or_val_present
  15239.     = TRUE;
  15240.       ffestp_file.read.read_spec[FFESTP_readixUNIT].kw_present = FALSE;
  15241.       ffestp_file.read.read_spec[FFESTP_readixUNIT].value_present = TRUE;
  15242.       ffestp_file.read.read_spec[FFESTP_readixUNIT].value_is_label
  15243.     = FALSE;
  15244.       ffestp_file.read.read_spec[FFESTP_readixUNIT].value
  15245.     = ffelex_token_use (ft);
  15246.       ffestp_file.read.read_spec[FFESTP_readixUNIT].u.expr = expr;
  15247.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  15248.     return (ffelexHandler) ffestb_R9095_;
  15249.       return (ffelexHandler) ffestb_R90913_;
  15250.  
  15251.     default:
  15252.       break;
  15253.     }
  15254.  
  15255. bad:                /* :::::::::::::::::::: */
  15256.   ffestb_subr_kill_read_ ();
  15257.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
  15258.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15259. }
  15260.  
  15261. /* ffestb_R9095_ -- "READ" OPEN_PAREN expr COMMA
  15262.  
  15263.    return ffestb_R9095_;  // to lexer
  15264.  
  15265.    Handle expr construct (not NAME=expr construct) here.  */
  15266.  
  15267. static ffelexHandler
  15268. ffestb_R9095_ (ffelexToken t)
  15269. {
  15270.   switch (ffelex_token_type (t))
  15271.     {
  15272.     case FFELEX_typeNAME:
  15273.       ffesta_tokens[1] = ffelex_token_use (t);
  15274.       return (ffelexHandler) ffestb_R9096_;
  15275.  
  15276.     default:
  15277.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  15278.         FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9097_)))
  15279.     (t);
  15280.     }
  15281. }
  15282.  
  15283. /* ffestb_R9096_ -- "READ" OPEN_PAREN expr COMMA NAME
  15284.  
  15285.    return ffestb_R9096_;  // to lexer
  15286.  
  15287.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  15288.    token thru expression handler.  */
  15289.  
  15290. static ffelexHandler
  15291. ffestb_R9096_ (ffelexToken t)
  15292. {
  15293.   ffelexHandler next;
  15294.   ffelexToken nt;
  15295.  
  15296.   switch (ffelex_token_type (t))
  15297.     {
  15298.     case FFELEX_typeEQUALS:
  15299.       nt = ffesta_tokens[1];
  15300.       next = (ffelexHandler) ffestb_R9098_ (nt);
  15301.       ffelex_token_kill (nt);
  15302.       return (ffelexHandler) (*next) (t);
  15303.  
  15304.     default:
  15305.       nt = ffesta_tokens[1];
  15306.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  15307.         FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9097_)))
  15308.     (nt);
  15309.       ffelex_token_kill (nt);
  15310.       return (ffelexHandler) (*next) (t);
  15311.     }
  15312. }
  15313.  
  15314. /* ffestb_R9097_ -- "READ" OPEN_PAREN expr COMMA expr
  15315.  
  15316.    (ffestb_R9097_)  // to expression handler
  15317.  
  15318.    Handle COMMA or CLOSE_PAREN here.  */
  15319.  
  15320. static ffelexHandler
  15321. ffestb_R9097_ (ffelexToken ft, ffebld expr, ffelexToken t)
  15322. {
  15323.   switch (ffelex_token_type (t))
  15324.     {
  15325.     case FFELEX_typeCOMMA:
  15326.     case FFELEX_typeCLOSE_PAREN:
  15327.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_or_val_present
  15328.     = TRUE;
  15329.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].kw_present = FALSE;
  15330.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_present = TRUE;
  15331.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value_is_label
  15332.     = (expr == NULL);
  15333.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].value
  15334.     = ffelex_token_use (ft);
  15335.       ffestp_file.read.read_spec[FFESTP_readixFORMAT].u.expr = expr;
  15336.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  15337.     return (ffelexHandler) ffestb_R9098_;
  15338.       return (ffelexHandler) ffestb_R90913_;
  15339.  
  15340.     default:
  15341.       break;
  15342.     }
  15343.  
  15344.   ffestb_subr_kill_read_ ();
  15345.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
  15346.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15347. }
  15348.  
  15349. /* ffestb_R9098_ -- "READ" OPEN_PAREN [external-file-unit COMMA [format
  15350.            COMMA]]
  15351.  
  15352.    return ffestb_R9098_;  // to lexer
  15353.  
  15354.    Handle expr construct (not NAME=expr construct) here.  */
  15355.  
  15356. static ffelexHandler
  15357. ffestb_R9098_ (ffelexToken t)
  15358. {
  15359.   ffestrGenio kw;
  15360.  
  15361.   ffestb_local_.read.label = FALSE;
  15362.  
  15363.   switch (ffelex_token_type (t))
  15364.     {
  15365.     case FFELEX_typeNAME:
  15366.       kw = ffestr_genio (t);
  15367.       switch (kw)
  15368.     {
  15369.     case FFESTR_genioADVANCE:
  15370.       ffestb_local_.read.ix = FFESTP_readixADVANCE;
  15371.       ffestb_local_.read.left = FALSE;
  15372.       ffestb_local_.read.context = FFEEXPR_contextFILEDFCHAR;
  15373.       break;
  15374.  
  15375.     case FFESTR_genioEOR:
  15376.       ffestb_local_.read.ix = FFESTP_readixEOR;
  15377.       ffestb_local_.read.label = TRUE;
  15378.       break;
  15379.  
  15380.     case FFESTR_genioERR:
  15381.       ffestb_local_.read.ix = FFESTP_readixERR;
  15382.       ffestb_local_.read.label = TRUE;
  15383.       break;
  15384.  
  15385.     case FFESTR_genioEND:
  15386.       ffestb_local_.read.ix = FFESTP_readixEND;
  15387.       ffestb_local_.read.label = TRUE;
  15388.       break;
  15389.  
  15390.     case FFESTR_genioFMT:
  15391.       ffestb_local_.read.ix = FFESTP_readixFORMAT;
  15392.       ffestb_local_.read.left = FALSE;
  15393.       ffestb_local_.read.context = FFEEXPR_contextFILEFORMAT;
  15394.       break;
  15395.  
  15396.     case FFESTR_genioIOSTAT:
  15397.       ffestb_local_.read.ix = FFESTP_readixIOSTAT;
  15398.       ffestb_local_.read.left = TRUE;
  15399.       ffestb_local_.read.context = FFEEXPR_contextFILEINT;
  15400.       break;
  15401.  
  15402.     case FFESTR_genioKEY:
  15403.     case FFESTR_genioKEYEQ:
  15404.       ffestb_local_.read.ix = FFESTP_readixKEYEQ;
  15405.       ffestb_local_.read.left = FALSE;
  15406.       ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
  15407.       break;
  15408.  
  15409.     case FFESTR_genioKEYGE:
  15410.       ffestb_local_.read.ix = FFESTP_readixKEYGE;
  15411.       ffestb_local_.read.left = FALSE;
  15412.       ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
  15413.       break;
  15414.  
  15415.     case FFESTR_genioKEYGT:
  15416.       ffestb_local_.read.ix = FFESTP_readixKEYGT;
  15417.       ffestb_local_.read.left = FALSE;
  15418.       ffestb_local_.read.context = FFEEXPR_contextFILENUMCHAR;
  15419.       break;
  15420.  
  15421.     case FFESTR_genioKEYID:
  15422.       ffestb_local_.read.ix = FFESTP_readixKEYID;
  15423.       ffestb_local_.read.left = FALSE;
  15424.       ffestb_local_.read.context = FFEEXPR_contextFILENUM;
  15425.       break;
  15426.  
  15427.     case FFESTR_genioNML:
  15428.       ffestb_local_.read.ix = FFESTP_readixFORMAT;
  15429.       ffestb_local_.read.left = TRUE;
  15430.       ffestb_local_.read.context = FFEEXPR_contextFILENAMELIST;
  15431.       break;
  15432.  
  15433.     case FFESTR_genioNULLS:
  15434.       ffestb_local_.read.ix = FFESTP_readixNULLS;
  15435.       ffestb_local_.read.left = TRUE;
  15436.       ffestb_local_.read.context = FFEEXPR_contextFILEINT;
  15437.       break;
  15438.  
  15439.     case FFESTR_genioREC:
  15440.       ffestb_local_.read.ix = FFESTP_readixREC;
  15441.       ffestb_local_.read.left = FALSE;
  15442.       ffestb_local_.read.context = FFEEXPR_contextFILENUM;
  15443.       break;
  15444.  
  15445.     case FFESTR_genioSIZE:
  15446.       ffestb_local_.read.ix = FFESTP_readixSIZE;
  15447.       ffestb_local_.read.left = TRUE;
  15448.       ffestb_local_.read.context = FFEEXPR_contextFILEINT;
  15449.       break;
  15450.  
  15451.     case FFESTR_genioUNIT:
  15452.       ffestb_local_.read.ix = FFESTP_readixUNIT;
  15453.       ffestb_local_.read.left = FALSE;
  15454.       ffestb_local_.read.context = FFEEXPR_contextFILEUNIT;
  15455.       break;
  15456.  
  15457.     default:
  15458.       goto bad;        /* :::::::::::::::::::: */
  15459.     }
  15460.       if (ffestp_file.read.read_spec[ffestb_local_.read.ix]
  15461.       .kw_or_val_present)
  15462.     break;            /* Can't specify a keyword twice! */
  15463.       ffestp_file.read.read_spec[ffestb_local_.read.ix]
  15464.     .kw_or_val_present = TRUE;
  15465.       ffestp_file.read.read_spec[ffestb_local_.read.ix]
  15466.     .kw_present = TRUE;
  15467.       ffestp_file.read.read_spec[ffestb_local_.read.ix]
  15468.     .value_present = FALSE;
  15469.       ffestp_file.read.read_spec[ffestb_local_.read.ix].value_is_label
  15470.     = ffestb_local_.read.label;
  15471.       ffestp_file.read.read_spec[ffestb_local_.read.ix].kw
  15472.     = ffelex_token_use (t);
  15473.       return (ffelexHandler) ffestb_R9099_;
  15474.  
  15475.     default:
  15476.       break;
  15477.     }
  15478.  
  15479. bad:                /* :::::::::::::::::::: */
  15480.   ffestb_subr_kill_read_ ();
  15481.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
  15482.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15483. }
  15484.  
  15485. /* ffestb_R9099_ -- "READ" OPEN_PAREN [external-file-unit COMMA [format
  15486.            COMMA]] NAME
  15487.  
  15488.    return ffestb_R9099_;  // to lexer
  15489.  
  15490.    Make sure EQUALS here, send next token to expression handler.  */
  15491.  
  15492. static ffelexHandler
  15493. ffestb_R9099_ (ffelexToken t)
  15494. {
  15495.   switch (ffelex_token_type (t))
  15496.     {
  15497.     case FFELEX_typeEQUALS:
  15498.       ffesta_confirmed ();
  15499.       if (ffestb_local_.read.label)
  15500.     return (ffelexHandler) ffestb_R90911_;
  15501.       if (ffestb_local_.read.left)
  15502.     return (ffelexHandler)
  15503.       ffeexpr_lhs (ffesta_output_pool,
  15504.                ffestb_local_.read.context,
  15505.                (ffeexprCallback) ffestb_R90910_);
  15506.       return (ffelexHandler)
  15507.     ffeexpr_rhs (ffesta_output_pool,
  15508.              ffestb_local_.read.context,
  15509.              (ffeexprCallback) ffestb_R90910_);
  15510.  
  15511.     default:
  15512.       break;
  15513.     }
  15514.  
  15515.   ffestb_subr_kill_read_ ();
  15516.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
  15517.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15518. }
  15519.  
  15520. /* ffestb_R90910_ -- "READ" OPEN_PAREN ... NAME EQUALS expr
  15521.  
  15522.    (ffestb_R90910_)  // to expression handler
  15523.  
  15524.    Handle COMMA or CLOSE_PAREN here.  */
  15525.  
  15526. static ffelexHandler
  15527. ffestb_R90910_ (ffelexToken ft, ffebld expr, ffelexToken t)
  15528. {
  15529.   switch (ffelex_token_type (t))
  15530.     {
  15531.     case FFELEX_typeCOMMA:
  15532.     case FFELEX_typeCLOSE_PAREN:
  15533.       if (expr == NULL)
  15534.     if (ffestb_local_.read.context == FFEEXPR_contextFILEFORMAT)
  15535.       ffestp_file.read.read_spec[ffestb_local_.read.ix]
  15536.         .value_is_label = TRUE;
  15537.     else
  15538.       break;
  15539.       ffestp_file.read.read_spec[ffestb_local_.read.ix].value_present
  15540.     = TRUE;
  15541.       ffestp_file.read.read_spec[ffestb_local_.read.ix].value
  15542.     = ffelex_token_use (ft);
  15543.       ffestp_file.read.read_spec[ffestb_local_.read.ix].u.expr = expr;
  15544.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  15545.     return (ffelexHandler) ffestb_R9098_;
  15546.       return (ffelexHandler) ffestb_R90913_;
  15547.  
  15548.     default:
  15549.       break;
  15550.     }
  15551.  
  15552.   ffestb_subr_kill_read_ ();
  15553.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
  15554.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15555. }
  15556.  
  15557. /* ffestb_R90911_ -- "READ" OPEN_PAREN ... NAME EQUALS
  15558.  
  15559.    return ffestb_R90911_;  // to lexer
  15560.  
  15561.    Handle NUMBER for label here.  */
  15562.  
  15563. static ffelexHandler
  15564. ffestb_R90911_ (ffelexToken t)
  15565. {
  15566.   switch (ffelex_token_type (t))
  15567.     {
  15568.     case FFELEX_typeNUMBER:
  15569.       ffestp_file.read.read_spec[ffestb_local_.read.ix].value_present
  15570.     = TRUE;
  15571.       ffestp_file.read.read_spec[ffestb_local_.read.ix].value
  15572.     = ffelex_token_use (t);
  15573.       return (ffelexHandler) ffestb_R90912_;
  15574.  
  15575.     default:
  15576.       break;
  15577.     }
  15578.  
  15579.   ffestb_subr_kill_read_ ();
  15580.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
  15581.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15582. }
  15583.  
  15584. /* ffestb_R90912_ -- "READ" OPEN_PAREN ... NAME EQUALS NUMBER
  15585.  
  15586.    return ffestb_R90912_;  // to lexer
  15587.  
  15588.    Handle COMMA or CLOSE_PAREN here.  */
  15589.  
  15590. static ffelexHandler
  15591. ffestb_R90912_ (ffelexToken t)
  15592. {
  15593.   switch (ffelex_token_type (t))
  15594.     {
  15595.     case FFELEX_typeCOMMA:
  15596.       return (ffelexHandler) ffestb_R9098_;
  15597.  
  15598.     case FFELEX_typeCLOSE_PAREN:
  15599.       return (ffelexHandler) ffestb_R90913_;
  15600.  
  15601.     default:
  15602.       break;
  15603.     }
  15604.  
  15605.   ffestb_subr_kill_read_ ();
  15606.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
  15607.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15608. }
  15609.  
  15610. /* ffestb_R90913_ -- "READ" OPEN_PAREN ... CLOSE_PAREN
  15611.  
  15612.    return ffestb_R90913_;  // to lexer
  15613.  
  15614.    Handle EOS or SEMICOLON here.
  15615.  
  15616.    15-Feb-91  JCB  1.1
  15617.       Fix to allow implied-DO construct here (OPEN_PAREN) -- actually,
  15618.       don't presume knowledge of what an initial token in an lhs context
  15619.       is going to be, let ffeexpr_lhs handle that as much as possible.    */
  15620.  
  15621. static ffelexHandler
  15622. ffestb_R90913_ (ffelexToken t)
  15623. {
  15624.   switch (ffelex_token_type (t))
  15625.     {
  15626.     case FFELEX_typeEOS:
  15627.     case FFELEX_typeSEMICOLON:
  15628.       ffesta_confirmed ();
  15629.       if (!ffesta_is_inhibited ())
  15630.     {
  15631.       ffestc_R909_start (FALSE);
  15632.       ffestc_R909_finish ();
  15633.     }
  15634.       ffestb_subr_kill_read_ ();
  15635.       return (ffelexHandler) ffesta_zero (t);
  15636.  
  15637.     default:
  15638.       break;
  15639.     }
  15640.  
  15641.   /* If token isn't NAME or OPEN_PAREN, ffeexpr_lhs will ultimately whine
  15642.      about it, so leave it up to that code. */
  15643.  
  15644.   ffesta_confirmed ();
  15645.   if (!ffesta_is_inhibited ())
  15646.     ffestc_R909_start (FALSE);
  15647.   ffestb_subr_kill_read_ ();
  15648.  
  15649.   /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.     (f2c
  15650.      provides this extension, as do other compilers, supposedly.) */
  15651.  
  15652.   if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
  15653.     return (ffelexHandler)
  15654.       ffeexpr_lhs (ffesta_output_pool,
  15655.            ffestc_context_iolist (),
  15656.            (ffeexprCallback) ffestb_R90914_);
  15657.  
  15658.   return (ffelexHandler) (*((ffelexHandler)
  15659.                 ffeexpr_lhs (ffesta_output_pool,
  15660.                      ffestc_context_iolist (),
  15661.                      (ffeexprCallback) ffestb_R90914_)))
  15662.     (t);
  15663. }
  15664.  
  15665. /* ffestb_R90914_ -- "READ(...)" expr
  15666.  
  15667.    (ffestb_R90914_)  // to expression handler
  15668.  
  15669.    Handle COMMA or EOS/SEMICOLON here.    */
  15670.  
  15671. static ffelexHandler
  15672. ffestb_R90914_ (ffelexToken ft, ffebld expr, ffelexToken t)
  15673. {
  15674.   switch (ffelex_token_type (t))
  15675.     {
  15676.     case FFELEX_typeCOMMA:
  15677.       if (expr == NULL)
  15678.     break;
  15679.       if (!ffesta_is_inhibited ())
  15680.     ffestc_R909_item (expr, ft);
  15681.       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  15682.                       ffestc_context_iolist (),
  15683.                       (ffeexprCallback) ffestb_R90914_);
  15684.  
  15685.     case FFELEX_typeEOS:
  15686.     case FFELEX_typeSEMICOLON:
  15687.       if (expr == NULL)
  15688.     break;
  15689.       if (!ffesta_is_inhibited ())
  15690.     {
  15691.       ffestc_R909_item (expr, ft);
  15692.       ffestc_R909_finish ();
  15693.     }
  15694.       return (ffelexHandler) ffesta_zero (t);
  15695.  
  15696.     default:
  15697.       break;
  15698.     }
  15699.  
  15700.   if (!ffesta_is_inhibited ())
  15701.     ffestc_R909_finish ();
  15702.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "READ", t);
  15703.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15704. }
  15705.  
  15706. /* ffestb_R910 -- Parse the WRITE statement
  15707.  
  15708.    return ffestb_R910;    // to lexer
  15709.  
  15710.    Make sure the statement has a valid form for the WRITE
  15711.    statement.  If it does, implement the statement.  */
  15712.  
  15713. ffelexHandler
  15714. ffestb_R910 (ffelexToken t)
  15715. {
  15716.   ffestpWriteIx ix;
  15717.  
  15718.   switch (ffelex_token_type (ffesta_tokens[0]))
  15719.     {
  15720.     case FFELEX_typeNAME:
  15721.       if (ffesta_first_kw != FFESTR_firstWRITE)
  15722.     goto bad_0;        /* :::::::::::::::::::: */
  15723.       switch (ffelex_token_type (t))
  15724.     {
  15725.     case FFELEX_typeCOMMA:
  15726.     case FFELEX_typeCOLONCOLON:
  15727.     case FFELEX_typeEOS:
  15728.     case FFELEX_typeSEMICOLON:
  15729.     case FFELEX_typeNAME:
  15730.     case FFELEX_typeNUMBER:
  15731.       ffesta_confirmed ();    /* Error, but clearly intended. */
  15732.       goto bad_1;        /* :::::::::::::::::::: */
  15733.  
  15734.     default:
  15735.       goto bad_1;        /* :::::::::::::::::::: */
  15736.  
  15737.     case FFELEX_typeOPEN_PAREN:
  15738.       for (ix = 0; ix < FFESTP_writeix; ++ix)
  15739.         ffestp_file.write.write_spec[ix].kw_or_val_present = FALSE;
  15740.       return (ffelexHandler) ffestb_R9101_;
  15741.     }
  15742.  
  15743.     case FFELEX_typeNAMES:
  15744.       if (ffesta_first_kw != FFESTR_firstWRITE)
  15745.     goto bad_0;        /* :::::::::::::::::::: */
  15746.       switch (ffelex_token_type (t))
  15747.     {
  15748.     case FFELEX_typeEOS:
  15749.     case FFELEX_typeSEMICOLON:
  15750.     case FFELEX_typeCOMMA:
  15751.     case FFELEX_typeCOLONCOLON:
  15752.       ffesta_confirmed ();    /* Error, but clearly intended. */
  15753.       goto bad_1;        /* :::::::::::::::::::: */
  15754.  
  15755.     default:
  15756.       goto bad_1;        /* :::::::::::::::::::: */
  15757.  
  15758.     case FFELEX_typeOPEN_PAREN:
  15759.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlWRITE)
  15760.         goto bad_0;        /* :::::::::::::::::::: */
  15761.  
  15762.       for (ix = 0; ix < FFESTP_writeix; ++ix)
  15763.         ffestp_file.write.write_spec[ix].kw_or_val_present = FALSE;
  15764.       return (ffelexHandler) ffestb_R9101_;
  15765.     }
  15766.  
  15767.     default:
  15768.       goto bad_0;        /* :::::::::::::::::::: */
  15769.     }
  15770.  
  15771. bad_0:                /* :::::::::::::::::::: */
  15772.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", ffesta_tokens[0]);
  15773.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15774.  
  15775. bad_1:                /* :::::::::::::::::::: */
  15776.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
  15777.   return (ffelexHandler) ffelex_swallow_tokens (t,
  15778.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  15779. }
  15780.  
  15781. /* ffestb_R9101_ -- "WRITE" OPEN_PAREN
  15782.  
  15783.    return ffestb_R9101_;  // to lexer
  15784.  
  15785.    Handle expr construct (not NAME=expr construct) here.  */
  15786.  
  15787. static ffelexHandler
  15788. ffestb_R9101_ (ffelexToken t)
  15789. {
  15790.   switch (ffelex_token_type (t))
  15791.     {
  15792.     case FFELEX_typeNAME:
  15793.       ffesta_tokens[1] = ffelex_token_use (t);
  15794.       return (ffelexHandler) ffestb_R9102_;
  15795.  
  15796.     default:
  15797.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  15798.          FFEEXPR_contextFILEUNIT, (ffeexprCallback) ffestb_R9103_)))
  15799.     (t);
  15800.     }
  15801. }
  15802.  
  15803. /* ffestb_R9102_ -- "WRITE" OPEN_PAREN NAME
  15804.  
  15805.    return ffestb_R9102_;  // to lexer
  15806.  
  15807.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  15808.    token thru expression handler.  */
  15809.  
  15810. static ffelexHandler
  15811. ffestb_R9102_ (ffelexToken t)
  15812. {
  15813.   ffelexHandler next;
  15814.   ffelexToken nt;
  15815.  
  15816.   switch (ffelex_token_type (t))
  15817.     {
  15818.     case FFELEX_typeEQUALS:
  15819.       nt = ffesta_tokens[1];
  15820.       next = (ffelexHandler) ffestb_R9107_ (nt);
  15821.       ffelex_token_kill (nt);
  15822.       return (ffelexHandler) (*next) (t);
  15823.  
  15824.     default:
  15825.       nt = ffesta_tokens[1];
  15826.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  15827.          FFEEXPR_contextFILEUNIT, (ffeexprCallback) ffestb_R9103_)))
  15828.     (nt);
  15829.       ffelex_token_kill (nt);
  15830.       return (ffelexHandler) (*next) (t);
  15831.     }
  15832. }
  15833.  
  15834. /* ffestb_R9103_ -- "WRITE" OPEN_PAREN expr [CLOSE_PAREN]
  15835.  
  15836.    (ffestb_R9103_)  // to expression handler
  15837.  
  15838.    Handle COMMA or EOS/SEMICOLON here.    */
  15839.  
  15840. static ffelexHandler
  15841. ffestb_R9103_ (ffelexToken ft, ffebld expr, ffelexToken t)
  15842. {
  15843.   switch (ffelex_token_type (t))
  15844.     {
  15845.     case FFELEX_typeCOMMA:
  15846.     case FFELEX_typeCLOSE_PAREN:
  15847.       if (expr == NULL)
  15848.     break;
  15849.       ffestp_file.write.write_spec[FFESTP_writeixUNIT].kw_or_val_present
  15850.     = TRUE;
  15851.       ffestp_file.write.write_spec[FFESTP_writeixUNIT].kw_present = FALSE;
  15852.       ffestp_file.write.write_spec[FFESTP_writeixUNIT].value_present = TRUE;
  15853.       ffestp_file.write.write_spec[FFESTP_writeixUNIT].value_is_label
  15854.     = FALSE;
  15855.       ffestp_file.write.write_spec[FFESTP_writeixUNIT].value
  15856.     = ffelex_token_use (ft);
  15857.       ffestp_file.write.write_spec[FFESTP_writeixUNIT].u.expr = expr;
  15858.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  15859.     return (ffelexHandler) ffestb_R9104_;
  15860.       return (ffelexHandler) ffestb_R91012_;
  15861.  
  15862.     default:
  15863.       break;
  15864.     }
  15865.  
  15866.   ffestb_subr_kill_write_ ();
  15867.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
  15868.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15869. }
  15870.  
  15871. /* ffestb_R9104_ -- "WRITE" OPEN_PAREN expr COMMA
  15872.  
  15873.    return ffestb_R9104_;  // to lexer
  15874.  
  15875.    Handle expr construct (not NAME=expr construct) here.  */
  15876.  
  15877. static ffelexHandler
  15878. ffestb_R9104_ (ffelexToken t)
  15879. {
  15880.   switch (ffelex_token_type (t))
  15881.     {
  15882.     case FFELEX_typeNAME:
  15883.       ffesta_tokens[1] = ffelex_token_use (t);
  15884.       return (ffelexHandler) ffestb_R9105_;
  15885.  
  15886.     default:
  15887.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  15888.         FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9106_)))
  15889.     (t);
  15890.     }
  15891. }
  15892.  
  15893. /* ffestb_R9105_ -- "WRITE" OPEN_PAREN expr COMMA NAME
  15894.  
  15895.    return ffestb_R9105_;  // to lexer
  15896.  
  15897.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  15898.    token thru expression handler.  */
  15899.  
  15900. static ffelexHandler
  15901. ffestb_R9105_ (ffelexToken t)
  15902. {
  15903.   ffelexHandler next;
  15904.   ffelexToken nt;
  15905.  
  15906.   switch (ffelex_token_type (t))
  15907.     {
  15908.     case FFELEX_typeEQUALS:
  15909.       nt = ffesta_tokens[1];
  15910.       next = (ffelexHandler) ffestb_R9107_ (nt);
  15911.       ffelex_token_kill (nt);
  15912.       return (ffelexHandler) (*next) (t);
  15913.  
  15914.     default:
  15915.       nt = ffesta_tokens[1];
  15916.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  15917.         FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9106_)))
  15918.     (nt);
  15919.       ffelex_token_kill (nt);
  15920.       return (ffelexHandler) (*next) (t);
  15921.     }
  15922. }
  15923.  
  15924. /* ffestb_R9106_ -- "WRITE" OPEN_PAREN expr COMMA expr
  15925.  
  15926.    (ffestb_R9106_)  // to expression handler
  15927.  
  15928.    Handle COMMA or CLOSE_PAREN here.  */
  15929.  
  15930. static ffelexHandler
  15931. ffestb_R9106_ (ffelexToken ft, ffebld expr, ffelexToken t)
  15932. {
  15933.   switch (ffelex_token_type (t))
  15934.     {
  15935.     case FFELEX_typeCOMMA:
  15936.     case FFELEX_typeCLOSE_PAREN:
  15937.       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].kw_or_val_present
  15938.     = TRUE;
  15939.       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].kw_present = FALSE;
  15940.       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value_present = TRUE;
  15941.       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value_is_label
  15942.     = (expr == NULL);
  15943.       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].value
  15944.     = ffelex_token_use (ft);
  15945.       ffestp_file.write.write_spec[FFESTP_writeixFORMAT].u.expr = expr;
  15946.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  15947.     return (ffelexHandler) ffestb_R9107_;
  15948.       return (ffelexHandler) ffestb_R91012_;
  15949.  
  15950.     default:
  15951.       break;
  15952.     }
  15953.  
  15954.   ffestb_subr_kill_write_ ();
  15955.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
  15956.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  15957. }
  15958.  
  15959. /* ffestb_R9107_ -- "WRITE" OPEN_PAREN [external-file-unit COMMA [format
  15960.            COMMA]]
  15961.  
  15962.    return ffestb_R9107_;  // to lexer
  15963.  
  15964.    Handle expr construct (not NAME=expr construct) here.  */
  15965.  
  15966. static ffelexHandler
  15967. ffestb_R9107_ (ffelexToken t)
  15968. {
  15969.   ffestrGenio kw;
  15970.  
  15971.   ffestb_local_.write.label = FALSE;
  15972.  
  15973.   switch (ffelex_token_type (t))
  15974.     {
  15975.     case FFELEX_typeNAME:
  15976.       kw = ffestr_genio (t);
  15977.       switch (kw)
  15978.     {
  15979.     case FFESTR_genioADVANCE:
  15980.       ffestb_local_.write.ix = FFESTP_writeixADVANCE;
  15981.       ffestb_local_.write.left = FALSE;
  15982.       ffestb_local_.write.context = FFEEXPR_contextFILEDFCHAR;
  15983.       break;
  15984.  
  15985.     case FFESTR_genioEOR:
  15986.       ffestb_local_.write.ix = FFESTP_writeixEOR;
  15987.       ffestb_local_.write.label = TRUE;
  15988.       break;
  15989.  
  15990.     case FFESTR_genioERR:
  15991.       ffestb_local_.write.ix = FFESTP_writeixERR;
  15992.       ffestb_local_.write.label = TRUE;
  15993.       break;
  15994.  
  15995.     case FFESTR_genioFMT:
  15996.       ffestb_local_.write.ix = FFESTP_writeixFORMAT;
  15997.       ffestb_local_.write.left = FALSE;
  15998.       ffestb_local_.write.context = FFEEXPR_contextFILEFORMAT;
  15999.       break;
  16000.  
  16001.     case FFESTR_genioIOSTAT:
  16002.       ffestb_local_.write.ix = FFESTP_writeixIOSTAT;
  16003.       ffestb_local_.write.left = TRUE;
  16004.       ffestb_local_.write.context = FFEEXPR_contextFILEINT;
  16005.       break;
  16006.  
  16007.     case FFESTR_genioNML:
  16008.       ffestb_local_.write.ix = FFESTP_writeixFORMAT;
  16009.       ffestb_local_.write.left = TRUE;
  16010.       ffestb_local_.write.context = FFEEXPR_contextFILENAMELIST;
  16011.       break;
  16012.  
  16013.     case FFESTR_genioREC:
  16014.       ffestb_local_.write.ix = FFESTP_writeixREC;
  16015.       ffestb_local_.write.left = FALSE;
  16016.       ffestb_local_.write.context = FFEEXPR_contextFILENUM;
  16017.       break;
  16018.  
  16019.     case FFESTR_genioUNIT:
  16020.       ffestb_local_.write.ix = FFESTP_writeixUNIT;
  16021.       ffestb_local_.write.left = FALSE;
  16022.       ffestb_local_.write.context = FFEEXPR_contextFILEUNIT;
  16023.       break;
  16024.  
  16025.     default:
  16026.       goto bad;        /* :::::::::::::::::::: */
  16027.     }
  16028.       if (ffestp_file.write.write_spec[ffestb_local_.write.ix]
  16029.       .kw_or_val_present)
  16030.     break;            /* Can't specify a keyword twice! */
  16031.       ffestp_file.write.write_spec[ffestb_local_.write.ix]
  16032.     .kw_or_val_present = TRUE;
  16033.       ffestp_file.write.write_spec[ffestb_local_.write.ix]
  16034.     .kw_present = TRUE;
  16035.       ffestp_file.write.write_spec[ffestb_local_.write.ix]
  16036.     .value_present = FALSE;
  16037.       ffestp_file.write.write_spec[ffestb_local_.write.ix].value_is_label
  16038.     = ffestb_local_.write.label;
  16039.       ffestp_file.write.write_spec[ffestb_local_.write.ix].kw
  16040.     = ffelex_token_use (t);
  16041.       return (ffelexHandler) ffestb_R9108_;
  16042.  
  16043.     default:
  16044.       break;
  16045.     }
  16046.  
  16047. bad:                /* :::::::::::::::::::: */
  16048.   ffestb_subr_kill_write_ ();
  16049.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
  16050.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16051. }
  16052.  
  16053. /* ffestb_R9108_ -- "WRITE" OPEN_PAREN [external-file-unit COMMA [format
  16054.            COMMA]] NAME
  16055.  
  16056.    return ffestb_R9108_;  // to lexer
  16057.  
  16058.    Make sure EQUALS here, send next token to expression handler.  */
  16059.  
  16060. static ffelexHandler
  16061. ffestb_R9108_ (ffelexToken t)
  16062. {
  16063.   switch (ffelex_token_type (t))
  16064.     {
  16065.     case FFELEX_typeEQUALS:
  16066.       ffesta_confirmed ();
  16067.       if (ffestb_local_.write.label)
  16068.     return (ffelexHandler) ffestb_R91010_;
  16069.       if (ffestb_local_.write.left)
  16070.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  16071.                         ffestb_local_.write.context,
  16072.                         (ffeexprCallback) ffestb_R9109_);
  16073.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  16074.                       ffestb_local_.write.context,
  16075.                       (ffeexprCallback) ffestb_R9109_);
  16076.  
  16077.     default:
  16078.       break;
  16079.     }
  16080.  
  16081.   ffestb_subr_kill_write_ ();
  16082.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
  16083.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16084. }
  16085.  
  16086. /* ffestb_R9109_ -- "WRITE" OPEN_PAREN ... NAME EQUALS expr
  16087.  
  16088.    (ffestb_R9109_)  // to expression handler
  16089.  
  16090.    Handle COMMA or CLOSE_PAREN here.  */
  16091.  
  16092. static ffelexHandler
  16093. ffestb_R9109_ (ffelexToken ft, ffebld expr, ffelexToken t)
  16094. {
  16095.   switch (ffelex_token_type (t))
  16096.     {
  16097.     case FFELEX_typeCOMMA:
  16098.     case FFELEX_typeCLOSE_PAREN:
  16099.       if (expr == NULL)
  16100.     if (ffestb_local_.write.context == FFEEXPR_contextFILEFORMAT)
  16101.       ffestp_file.write.write_spec[ffestb_local_.write.ix]
  16102.         .value_is_label = TRUE;
  16103.     else
  16104.       break;
  16105.       ffestp_file.write.write_spec[ffestb_local_.write.ix].value_present
  16106.     = TRUE;
  16107.       ffestp_file.write.write_spec[ffestb_local_.write.ix].value
  16108.     = ffelex_token_use (ft);
  16109.       ffestp_file.write.write_spec[ffestb_local_.write.ix].u.expr = expr;
  16110.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  16111.     return (ffelexHandler) ffestb_R9107_;
  16112.       return (ffelexHandler) ffestb_R91012_;
  16113.  
  16114.     default:
  16115.       break;
  16116.     }
  16117.  
  16118.   ffestb_subr_kill_write_ ();
  16119.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
  16120.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16121. }
  16122.  
  16123. /* ffestb_R91010_ -- "WRITE" OPEN_PAREN ... NAME EQUALS
  16124.  
  16125.    return ffestb_R91010_;  // to lexer
  16126.  
  16127.    Handle NUMBER for label here.  */
  16128.  
  16129. static ffelexHandler
  16130. ffestb_R91010_ (ffelexToken t)
  16131. {
  16132.   switch (ffelex_token_type (t))
  16133.     {
  16134.     case FFELEX_typeNUMBER:
  16135.       ffestp_file.write.write_spec[ffestb_local_.write.ix].value_present
  16136.     = TRUE;
  16137.       ffestp_file.write.write_spec[ffestb_local_.write.ix].value
  16138.     = ffelex_token_use (t);
  16139.       return (ffelexHandler) ffestb_R91011_;
  16140.  
  16141.     default:
  16142.       break;
  16143.     }
  16144.  
  16145.   ffestb_subr_kill_write_ ();
  16146.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
  16147.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16148. }
  16149.  
  16150. /* ffestb_R91011_ -- "WRITE" OPEN_PAREN ... NAME EQUALS NUMBER
  16151.  
  16152.    return ffestb_R91011_;  // to lexer
  16153.  
  16154.    Handle COMMA or CLOSE_PAREN here.  */
  16155.  
  16156. static ffelexHandler
  16157. ffestb_R91011_ (ffelexToken t)
  16158. {
  16159.   switch (ffelex_token_type (t))
  16160.     {
  16161.     case FFELEX_typeCOMMA:
  16162.       return (ffelexHandler) ffestb_R9107_;
  16163.  
  16164.     case FFELEX_typeCLOSE_PAREN:
  16165.       return (ffelexHandler) ffestb_R91012_;
  16166.  
  16167.     default:
  16168.       break;
  16169.     }
  16170.  
  16171.   ffestb_subr_kill_write_ ();
  16172.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
  16173.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16174. }
  16175.  
  16176. /* ffestb_R91012_ -- "WRITE" OPEN_PAREN ... CLOSE_PAREN
  16177.  
  16178.    return ffestb_R91012_;  // to lexer
  16179.  
  16180.    Handle EOS or SEMICOLON here.  */
  16181.  
  16182. static ffelexHandler
  16183. ffestb_R91012_ (ffelexToken t)
  16184. {
  16185.   switch (ffelex_token_type (t))
  16186.     {
  16187.     case FFELEX_typeEOS:
  16188.     case FFELEX_typeSEMICOLON:
  16189.       ffesta_confirmed ();
  16190.       if (!ffesta_is_inhibited ())
  16191.     {
  16192.       ffestc_R910_start ();
  16193.       ffestc_R910_finish ();
  16194.     }
  16195.       ffestb_subr_kill_write_ ();
  16196.       return (ffelexHandler) ffesta_zero (t);
  16197.  
  16198.     default:
  16199.       ffesta_confirmed ();
  16200.       if (!ffesta_is_inhibited ())
  16201.     ffestc_R910_start ();
  16202.       ffestb_subr_kill_write_ ();
  16203.  
  16204.       /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
  16205.          (f2c provides this extension, as do other compilers, supposedly.) */
  16206.  
  16207.       if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
  16208.     return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  16209.         ffestc_context_iolist (), (ffeexprCallback) ffestb_R91013_);
  16210.  
  16211.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  16212.            ffestc_context_iolist (), (ffeexprCallback) ffestb_R91013_)))
  16213.     (t);
  16214.  
  16215.     case FFELEX_typeEQUALS:
  16216.     case FFELEX_typePOINTS:
  16217.       break;
  16218.     }
  16219.  
  16220.   ffestb_subr_kill_write_ ();
  16221.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
  16222.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16223. }
  16224.  
  16225. /* ffestb_R91013_ -- "WRITE(...)" expr
  16226.  
  16227.    (ffestb_R91013_)  // to expression handler
  16228.  
  16229.    Handle COMMA or EOS/SEMICOLON here.    */
  16230.  
  16231. static ffelexHandler
  16232. ffestb_R91013_ (ffelexToken ft, ffebld expr, ffelexToken t)
  16233. {
  16234.   switch (ffelex_token_type (t))
  16235.     {
  16236.     case FFELEX_typeCOMMA:
  16237.       if (expr == NULL)
  16238.     break;
  16239.       if (!ffesta_is_inhibited ())
  16240.     ffestc_R910_item (expr, ft);
  16241.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  16242.         ffestc_context_iolist (), (ffeexprCallback) ffestb_R91013_);
  16243.  
  16244.     case FFELEX_typeEOS:
  16245.     case FFELEX_typeSEMICOLON:
  16246.       if (expr == NULL)
  16247.     break;
  16248.       if (!ffesta_is_inhibited ())
  16249.     {
  16250.       ffestc_R910_item (expr, ft);
  16251.       ffestc_R910_finish ();
  16252.     }
  16253.       return (ffelexHandler) ffesta_zero (t);
  16254.  
  16255.     default:
  16256.       break;
  16257.     }
  16258.  
  16259.   if (!ffesta_is_inhibited ())
  16260.     ffestc_R910_finish ();
  16261.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "WRITE", t);
  16262.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16263. }
  16264.  
  16265. /* ffestb_R911 -- Parse the PRINT statement
  16266.  
  16267.    return ffestb_R911;    // to lexer
  16268.  
  16269.    Make sure the statement has a valid form for the PRINT
  16270.    statement.  If it does, implement the statement.  */
  16271.  
  16272. ffelexHandler
  16273. ffestb_R911 (ffelexToken t)
  16274. {
  16275.   ffelexHandler next;
  16276.   ffestpPrintIx ix;
  16277.  
  16278.   switch (ffelex_token_type (ffesta_tokens[0]))
  16279.     {
  16280.     case FFELEX_typeNAME:
  16281.       if (ffesta_first_kw != FFESTR_firstPRINT)
  16282.     goto bad_0;        /* :::::::::::::::::::: */
  16283.       switch (ffelex_token_type (t))
  16284.     {
  16285.     case FFELEX_typeCOMMA:
  16286.     case FFELEX_typeCOLONCOLON:
  16287.     case FFELEX_typeEOS:
  16288.     case FFELEX_typeSEMICOLON:
  16289.       ffesta_confirmed ();    /* Error, but clearly intended. */
  16290.       goto bad_1;        /* :::::::::::::::::::: */
  16291.  
  16292.     case FFELEX_typeEQUALS:
  16293.     case FFELEX_typePOINTS:
  16294.     case FFELEX_typeCOLON:
  16295.       goto bad_1;        /* :::::::::::::::::::: */
  16296.  
  16297.     case FFELEX_typeNAME:
  16298.     case FFELEX_typeNUMBER:
  16299.       ffesta_confirmed ();
  16300.       break;
  16301.  
  16302.     default:
  16303.       break;
  16304.     }
  16305.  
  16306.       for (ix = 0; ix < FFESTP_printix; ++ix)
  16307.     ffestp_file.print.print_spec[ix].kw_or_val_present = FALSE;
  16308.       return (ffelexHandler) (*((ffelexHandler)
  16309.                 ffeexpr_rhs (ffesta_output_pool,
  16310.         FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9111_)))
  16311.     (t);
  16312.  
  16313.     case FFELEX_typeNAMES:
  16314.       if (ffesta_first_kw != FFESTR_firstPRINT)
  16315.     goto bad_0;        /* :::::::::::::::::::: */
  16316.       switch (ffelex_token_type (t))
  16317.     {
  16318.     case FFELEX_typeEOS:
  16319.     case FFELEX_typeSEMICOLON:
  16320.     case FFELEX_typeCOMMA:
  16321.       ffesta_confirmed ();
  16322.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlPRINT)
  16323.         break;
  16324.       goto bad_1;        /* :::::::::::::::::::: */
  16325.  
  16326.     case FFELEX_typeCOLONCOLON:
  16327.       ffesta_confirmed ();    /* Error, but clearly intended. */
  16328.       goto bad_1;        /* :::::::::::::::::::: */
  16329.  
  16330.     case FFELEX_typeEQUALS:
  16331.     case FFELEX_typePOINTS:
  16332.     case FFELEX_typeCOLON:
  16333.       goto bad_1;        /* :::::::::::::::::::: */
  16334.  
  16335.     default:
  16336.       break;
  16337.     }
  16338.       for (ix = 0; ix < FFESTP_printix; ++ix)
  16339.     ffestp_file.print.print_spec[ix].kw_or_val_present = FALSE;
  16340.       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  16341.          FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_R9111_);
  16342.       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
  16343.                            FFESTR_firstlPRINT);
  16344.       if (next == NULL)
  16345.     return (ffelexHandler) ffelex_swallow_tokens (t,
  16346.                            (ffelexHandler) ffesta_zero);
  16347.       return (ffelexHandler) (*next) (t);
  16348.  
  16349.     default:
  16350.       goto bad_0;        /* :::::::::::::::::::: */
  16351.     }
  16352.  
  16353. bad_0:                /* :::::::::::::::::::: */
  16354.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", ffesta_tokens[0]);
  16355.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16356.  
  16357. bad_1:                /* :::::::::::::::::::: */
  16358.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
  16359.   return (ffelexHandler) ffelex_swallow_tokens (t,
  16360.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  16361. }
  16362.  
  16363. /* ffestb_R9111_ -- "PRINT" expr
  16364.  
  16365.    (ffestb_R9111_)  // to expression handler
  16366.  
  16367.    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
  16368.  
  16369. static ffelexHandler
  16370. ffestb_R9111_ (ffelexToken ft, ffebld expr, ffelexToken t)
  16371. {
  16372.   switch (ffelex_token_type (t))
  16373.     {
  16374.     case FFELEX_typeEOS:
  16375.     case FFELEX_typeSEMICOLON:
  16376.     case FFELEX_typeCOMMA:
  16377.       ffesta_confirmed ();
  16378.       ffestp_file.print.print_spec[FFESTP_printixFORMAT].kw_or_val_present
  16379.     = TRUE;
  16380.       ffestp_file.print.print_spec[FFESTP_printixFORMAT].kw_present = FALSE;
  16381.       ffestp_file.print.print_spec[FFESTP_printixFORMAT].value_present = TRUE;
  16382.       ffestp_file.print.print_spec[FFESTP_printixFORMAT].value_is_label
  16383.     = (expr == NULL);
  16384.       ffestp_file.print.print_spec[FFESTP_printixFORMAT].value
  16385.     = ffelex_token_use (ft);
  16386.       ffestp_file.print.print_spec[FFESTP_printixFORMAT].u.expr = expr;
  16387.       if (!ffesta_is_inhibited ())
  16388.     ffestc_R911_start ();
  16389.       ffestb_subr_kill_print_ ();
  16390.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  16391.     return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  16392.             FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R9112_);
  16393.       if (!ffesta_is_inhibited ())
  16394.     ffestc_R911_finish ();
  16395.       return (ffelexHandler) ffesta_zero (t);
  16396.  
  16397.     default:
  16398.       break;
  16399.     }
  16400.  
  16401.   ffestb_subr_kill_print_ ();
  16402.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
  16403.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16404. }
  16405.  
  16406. /* ffestb_R9112_ -- "PRINT" expr COMMA expr
  16407.  
  16408.    (ffestb_R9112_)  // to expression handler
  16409.  
  16410.    Handle COMMA or EOS/SEMICOLON here.    */
  16411.  
  16412. static ffelexHandler
  16413. ffestb_R9112_ (ffelexToken ft, ffebld expr, ffelexToken t)
  16414. {
  16415.   switch (ffelex_token_type (t))
  16416.     {
  16417.     case FFELEX_typeCOMMA:
  16418.       if (expr == NULL)
  16419.     break;
  16420.       if (!ffesta_is_inhibited ())
  16421.     ffestc_R911_item (expr, ft);
  16422.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  16423.             FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R9112_);
  16424.  
  16425.     case FFELEX_typeEOS:
  16426.     case FFELEX_typeSEMICOLON:
  16427.       if (expr == NULL)
  16428.     break;
  16429.       if (!ffesta_is_inhibited ())
  16430.     {
  16431.       ffestc_R911_item (expr, ft);
  16432.       ffestc_R911_finish ();
  16433.     }
  16434.       return (ffelexHandler) ffesta_zero (t);
  16435.  
  16436.     default:
  16437.       break;
  16438.     }
  16439.  
  16440.   if (!ffesta_is_inhibited ())
  16441.     ffestc_R911_finish ();
  16442.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PRINT", t);
  16443.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16444. }
  16445.  
  16446. /* ffestb_R923 -- Parse an INQUIRE statement
  16447.  
  16448.    return ffestb_R923;    // to lexer
  16449.  
  16450.    Make sure the statement has a valid form for an INQUIRE statement.
  16451.    If it does, implement the statement.     */
  16452.  
  16453. ffelexHandler
  16454. ffestb_R923 (ffelexToken t)
  16455. {
  16456.   ffestpInquireIx ix;
  16457.  
  16458.   switch (ffelex_token_type (ffesta_tokens[0]))
  16459.     {
  16460.     case FFELEX_typeNAME:
  16461.       if (ffesta_first_kw != FFESTR_firstINQUIRE)
  16462.     goto bad_0;        /* :::::::::::::::::::: */
  16463.       break;
  16464.  
  16465.     case FFELEX_typeNAMES:
  16466.       if (ffesta_first_kw != FFESTR_firstINQUIRE)
  16467.     goto bad_0;        /* :::::::::::::::::::: */
  16468.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlINQUIRE)
  16469.     goto bad_0;        /* :::::::::::::::::::: */
  16470.       break;
  16471.  
  16472.     default:
  16473.       goto bad_0;        /* :::::::::::::::::::: */
  16474.     }
  16475.  
  16476.   switch (ffelex_token_type (t))
  16477.     {
  16478.     case FFELEX_typeOPEN_PAREN:
  16479.       break;
  16480.  
  16481.     case FFELEX_typeEOS:
  16482.     case FFELEX_typeSEMICOLON:
  16483.     case FFELEX_typeCOMMA:
  16484.     case FFELEX_typeCOLONCOLON:
  16485.       ffesta_confirmed ();    /* Error, but clearly intended. */
  16486.       goto bad_1;        /* :::::::::::::::::::: */
  16487.  
  16488.     default:
  16489.       goto bad_1;        /* :::::::::::::::::::: */
  16490.     }
  16491.  
  16492.   for (ix = 0; ix < FFESTP_inquireix; ++ix)
  16493.     ffestp_file.inquire.inquire_spec[ix].kw_or_val_present = FALSE;
  16494.  
  16495.   ffestb_local_.inquire.may_be_iolength = TRUE;
  16496.   return (ffelexHandler) ffestb_R9231_;
  16497.  
  16498. bad_0:                /* :::::::::::::::::::: */
  16499.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", ffesta_tokens[0]);
  16500.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16501.  
  16502. bad_1:                /* :::::::::::::::::::: */
  16503.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
  16504.   return (ffelexHandler) ffelex_swallow_tokens (t,
  16505.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  16506. }
  16507.  
  16508. /* ffestb_R9231_ -- "INQUIRE" OPEN_PAREN
  16509.  
  16510.    return ffestb_R9231_;  // to lexer
  16511.  
  16512.    Handle expr construct (not NAME=expr construct) here.  */
  16513.  
  16514. static ffelexHandler
  16515. ffestb_R9231_ (ffelexToken t)
  16516. {
  16517.   switch (ffelex_token_type (t))
  16518.     {
  16519.     case FFELEX_typeNAME:
  16520.       ffesta_tokens[1] = ffelex_token_use (t);
  16521.       return (ffelexHandler) ffestb_R9232_;
  16522.  
  16523.     default:
  16524.       ffestb_local_.inquire.may_be_iolength = FALSE;
  16525.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  16526.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9233_)))
  16527.     (t);
  16528.     }
  16529. }
  16530.  
  16531. /* ffestb_R9232_ -- "INQUIRE" OPEN_PAREN NAME
  16532.  
  16533.    return ffestb_R9232_;  // to lexer
  16534.  
  16535.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  16536.    token thru expression handler.  */
  16537.  
  16538. static ffelexHandler
  16539. ffestb_R9232_ (ffelexToken t)
  16540. {
  16541.   ffelexHandler next;
  16542.   ffelexToken nt;
  16543.  
  16544.   switch (ffelex_token_type (t))
  16545.     {
  16546.     case FFELEX_typeEQUALS:
  16547.       nt = ffesta_tokens[1];
  16548.       next = (ffelexHandler) ffestb_R9234_ (nt);
  16549.       ffelex_token_kill (nt);
  16550.       return (ffelexHandler) (*next) (t);
  16551.  
  16552.     default:
  16553.       ffestb_local_.inquire.may_be_iolength = FALSE;
  16554.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  16555.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_R9233_)))
  16556.     (ffesta_tokens[1]);
  16557.       ffelex_token_kill (ffesta_tokens[1]);
  16558.       return (ffelexHandler) (*next) (t);
  16559.     }
  16560. }
  16561.  
  16562. /* ffestb_R9233_ -- "INQUIRE" OPEN_PAREN expr
  16563.  
  16564.    (ffestb_R9233_)  // to expression handler
  16565.  
  16566.    Handle COMMA or CLOSE_PAREN here.  */
  16567.  
  16568. static ffelexHandler
  16569. ffestb_R9233_ (ffelexToken ft, ffebld expr, ffelexToken t)
  16570. {
  16571.   switch (ffelex_token_type (t))
  16572.     {
  16573.     case FFELEX_typeCOMMA:
  16574.     case FFELEX_typeCLOSE_PAREN:
  16575.       if (expr == NULL)
  16576.     break;
  16577.       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].kw_or_val_present
  16578.     = TRUE;
  16579.       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].kw_present = FALSE;
  16580.       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value_present = TRUE;
  16581.       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value_is_label
  16582.     = FALSE;
  16583.       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].value
  16584.     = ffelex_token_use (ft);
  16585.       ffestp_file.inquire.inquire_spec[FFESTP_inquireixUNIT].u.expr = expr;
  16586.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  16587.     return (ffelexHandler) ffestb_R9234_;
  16588.       return (ffelexHandler) ffestb_R9239_;
  16589.  
  16590.     default:
  16591.       break;
  16592.     }
  16593.  
  16594.   ffestb_subr_kill_inquire_ ();
  16595.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
  16596.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16597. }
  16598.  
  16599. /* ffestb_R9234_ -- "INQUIRE" OPEN_PAREN [external-file-unit COMMA]
  16600.  
  16601.    return ffestb_R9234_;  // to lexer
  16602.  
  16603.    Handle expr construct (not NAME=expr construct) here.  */
  16604.  
  16605. static ffelexHandler
  16606. ffestb_R9234_ (ffelexToken t)
  16607. {
  16608.   ffestrInquire kw;
  16609.  
  16610.   ffestb_local_.inquire.label = FALSE;
  16611.  
  16612.   switch (ffelex_token_type (t))
  16613.     {
  16614.     case FFELEX_typeNAME:
  16615.       kw = ffestr_inquire (t);
  16616.       if (kw != FFESTR_inquireIOLENGTH)
  16617.     ffestb_local_.inquire.may_be_iolength = FALSE;
  16618.       switch (kw)
  16619.     {
  16620.     case FFESTR_inquireACCESS:
  16621.       ffestb_local_.inquire.ix = FFESTP_inquireixACCESS;
  16622.       ffestb_local_.inquire.left = TRUE;
  16623.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16624.       break;
  16625.  
  16626.     case FFESTR_inquireACTION:
  16627.       ffestb_local_.inquire.ix = FFESTP_inquireixACTION;
  16628.       ffestb_local_.inquire.left = TRUE;
  16629.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16630.       break;
  16631.  
  16632.     case FFESTR_inquireBLANK:
  16633.       ffestb_local_.inquire.ix = FFESTP_inquireixBLANK;
  16634.       ffestb_local_.inquire.left = TRUE;
  16635.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16636.       break;
  16637.  
  16638.     case FFESTR_inquireCARRIAGECONTROL:
  16639.       ffestb_local_.inquire.ix = FFESTP_inquireixCARRIAGECONTROL;
  16640.       ffestb_local_.inquire.left = TRUE;
  16641.       ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
  16642.       break;
  16643.  
  16644.     case FFESTR_inquireDEFAULTFILE:
  16645.       ffestb_local_.inquire.ix = FFESTP_inquireixDEFAULTFILE;
  16646.       ffestb_local_.inquire.left = FALSE;
  16647.       ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
  16648.       break;
  16649.  
  16650.     case FFESTR_inquireDELIM:
  16651.       ffestb_local_.inquire.ix = FFESTP_inquireixDELIM;
  16652.       ffestb_local_.inquire.left = TRUE;
  16653.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16654.       break;
  16655.  
  16656.     case FFESTR_inquireDIRECT:
  16657.       ffestb_local_.inquire.ix = FFESTP_inquireixDIRECT;
  16658.       ffestb_local_.inquire.left = TRUE;
  16659.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16660.       break;
  16661.  
  16662.     case FFESTR_inquireERR:
  16663.       ffestb_local_.inquire.ix = FFESTP_inquireixERR;
  16664.       ffestb_local_.inquire.label = TRUE;
  16665.       break;
  16666.  
  16667.     case FFESTR_inquireEXIST:
  16668.       ffestb_local_.inquire.ix = FFESTP_inquireixEXIST;
  16669.       ffestb_local_.inquire.left = TRUE;
  16670.       ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
  16671.       break;
  16672.  
  16673.     case FFESTR_inquireFILE:
  16674.       ffestb_local_.inquire.ix = FFESTP_inquireixFILE;
  16675.       ffestb_local_.inquire.left = FALSE;
  16676.       ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
  16677.       break;
  16678.  
  16679.     case FFESTR_inquireFORM:
  16680.       ffestb_local_.inquire.ix = FFESTP_inquireixFORM;
  16681.       ffestb_local_.inquire.left = TRUE;
  16682.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16683.       break;
  16684.  
  16685.     case FFESTR_inquireFORMATTED:
  16686.       ffestb_local_.inquire.ix = FFESTP_inquireixFORMATTED;
  16687.       ffestb_local_.inquire.left = TRUE;
  16688.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16689.       break;
  16690.  
  16691.     case FFESTR_inquireIOLENGTH:
  16692.       if (!ffestb_local_.inquire.may_be_iolength)
  16693.         goto bad;        /* :::::::::::::::::::: */
  16694.       ffestb_local_.inquire.ix = FFESTP_inquireixIOLENGTH;
  16695.       ffestb_local_.inquire.left = TRUE;
  16696.       ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
  16697.       break;
  16698.  
  16699.     case FFESTR_inquireIOSTAT:
  16700.       ffestb_local_.inquire.ix = FFESTP_inquireixIOSTAT;
  16701.       ffestb_local_.inquire.left = TRUE;
  16702.       ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
  16703.       break;
  16704.  
  16705.     case FFESTR_inquireKEYED:
  16706.       ffestb_local_.inquire.ix = FFESTP_inquireixKEYED;
  16707.       ffestb_local_.inquire.left = TRUE;
  16708.       ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
  16709.       break;
  16710.  
  16711.     case FFESTR_inquireNAME:
  16712.       ffestb_local_.inquire.ix = FFESTP_inquireixNAME;
  16713.       ffestb_local_.inquire.left = TRUE;
  16714.       ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
  16715.       break;
  16716.  
  16717.     case FFESTR_inquireNAMED:
  16718.       ffestb_local_.inquire.ix = FFESTP_inquireixNAMED;
  16719.       ffestb_local_.inquire.left = TRUE;
  16720.       ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
  16721.       break;
  16722.  
  16723.     case FFESTR_inquireNEXTREC:
  16724.       ffestb_local_.inquire.ix = FFESTP_inquireixNEXTREC;
  16725.       ffestb_local_.inquire.left = TRUE;
  16726.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFINT;
  16727.       break;
  16728.  
  16729.     case FFESTR_inquireNUMBER:
  16730.       ffestb_local_.inquire.ix = FFESTP_inquireixNUMBER;
  16731.       ffestb_local_.inquire.left = TRUE;
  16732.       ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
  16733.       break;
  16734.  
  16735.     case FFESTR_inquireOPENED:
  16736.       ffestb_local_.inquire.ix = FFESTP_inquireixOPENED;
  16737.       ffestb_local_.inquire.left = TRUE;
  16738.       ffestb_local_.inquire.context = FFEEXPR_contextFILELOG;
  16739.       break;
  16740.  
  16741.     case FFESTR_inquireORGANIZATION:
  16742.       ffestb_local_.inquire.ix = FFESTP_inquireixORGANIZATION;
  16743.       ffestb_local_.inquire.left = TRUE;
  16744.       ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
  16745.       break;
  16746.  
  16747.     case FFESTR_inquirePAD:
  16748.       ffestb_local_.inquire.ix = FFESTP_inquireixPAD;
  16749.       ffestb_local_.inquire.left = TRUE;
  16750.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16751.       break;
  16752.  
  16753.     case FFESTR_inquirePOSITION:
  16754.       ffestb_local_.inquire.ix = FFESTP_inquireixPOSITION;
  16755.       ffestb_local_.inquire.left = TRUE;
  16756.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16757.       break;
  16758.  
  16759.     case FFESTR_inquireREAD:
  16760.       ffestb_local_.inquire.ix = FFESTP_inquireixREAD;
  16761.       ffestb_local_.inquire.left = TRUE;
  16762.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16763.       break;
  16764.  
  16765.     case FFESTR_inquireREADWRITE:
  16766.       ffestb_local_.inquire.ix = FFESTP_inquireixREADWRITE;
  16767.       ffestb_local_.inquire.left = TRUE;
  16768.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16769.       break;
  16770.  
  16771.     case FFESTR_inquireRECL:
  16772.       ffestb_local_.inquire.ix = FFESTP_inquireixRECL;
  16773.       ffestb_local_.inquire.left = TRUE;
  16774.       ffestb_local_.inquire.context = FFEEXPR_contextFILEINT;
  16775.       break;
  16776.  
  16777.     case FFESTR_inquireRECORDTYPE:
  16778.       ffestb_local_.inquire.ix = FFESTP_inquireixRECORDTYPE;
  16779.       ffestb_local_.inquire.left = TRUE;
  16780.       ffestb_local_.inquire.context = FFEEXPR_contextFILECHAR;
  16781.       break;
  16782.  
  16783.     case FFESTR_inquireSEQUENTIAL:
  16784.       ffestb_local_.inquire.ix = FFESTP_inquireixSEQUENTIAL;
  16785.       ffestb_local_.inquire.left = TRUE;
  16786.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16787.       break;
  16788.  
  16789.     case FFESTR_inquireUNFORMATTED:
  16790.       ffestb_local_.inquire.ix = FFESTP_inquireixUNFORMATTED;
  16791.       ffestb_local_.inquire.left = TRUE;
  16792.       ffestb_local_.inquire.context = FFEEXPR_contextFILEDFCHAR;
  16793.       break;
  16794.  
  16795.     case FFESTR_inquireUNIT:
  16796.       ffestb_local_.inquire.ix = FFESTP_inquireixUNIT;
  16797.       ffestb_local_.inquire.left = FALSE;
  16798.       ffestb_local_.inquire.context = FFEEXPR_contextFILENUM;
  16799.       break;
  16800.  
  16801.     default:
  16802.       goto bad;        /* :::::::::::::::::::: */
  16803.     }
  16804.       if (ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
  16805.       .kw_or_val_present)
  16806.     break;            /* Can't specify a keyword twice! */
  16807.       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
  16808.     .kw_or_val_present = TRUE;
  16809.       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
  16810.     .kw_present = TRUE;
  16811.       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix]
  16812.     .value_present = FALSE;
  16813.       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_is_label
  16814.     = ffestb_local_.inquire.label;
  16815.       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].kw
  16816.     = ffelex_token_use (t);
  16817.       return (ffelexHandler) ffestb_R9235_;
  16818.  
  16819.     default:
  16820.       break;
  16821.     }
  16822.  
  16823. bad:                /* :::::::::::::::::::: */
  16824.   ffestb_subr_kill_inquire_ ();
  16825.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
  16826.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16827. }
  16828.  
  16829. /* ffestb_R9235_ -- "INQUIRE" OPEN_PAREN [external-file-unit COMMA] NAME
  16830.  
  16831.    return ffestb_R9235_;  // to lexer
  16832.  
  16833.    Make sure EQUALS here, send next token to expression handler.  */
  16834.  
  16835. static ffelexHandler
  16836. ffestb_R9235_ (ffelexToken t)
  16837. {
  16838.   switch (ffelex_token_type (t))
  16839.     {
  16840.     case FFELEX_typeEQUALS:
  16841.       ffesta_confirmed ();
  16842.       if (ffestb_local_.inquire.label)
  16843.     return (ffelexHandler) ffestb_R9237_;
  16844.       if (ffestb_local_.inquire.left)
  16845.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  16846.                         ffestb_local_.inquire.context,
  16847.                         (ffeexprCallback) ffestb_R9236_);
  16848.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  16849.                       ffestb_local_.inquire.context,
  16850.                       (ffeexprCallback) ffestb_R9236_);
  16851.  
  16852.     default:
  16853.       break;
  16854.     }
  16855.  
  16856.   ffestb_subr_kill_inquire_ ();
  16857.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
  16858.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16859. }
  16860.  
  16861. /* ffestb_R9236_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS expr
  16862.  
  16863.    (ffestb_R9236_)  // to expression handler
  16864.  
  16865.    Handle COMMA or CLOSE_PAREN here.  */
  16866.  
  16867. static ffelexHandler
  16868. ffestb_R9236_ (ffelexToken ft, ffebld expr, ffelexToken t)
  16869. {
  16870.   switch (ffelex_token_type (t))
  16871.     {
  16872.     case FFELEX_typeCOMMA:
  16873.       if (ffestb_local_.inquire.ix == FFESTP_inquireixIOLENGTH)
  16874.     break;            /* IOLENGTH=expr must be followed by
  16875.                    CLOSE_PAREN. */
  16876.       /* Fall through. */
  16877.     case FFELEX_typeCLOSE_PAREN:
  16878.       if (expr == NULL)
  16879.     break;
  16880.       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_present
  16881.     = TRUE;
  16882.       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value
  16883.     = ffelex_token_use (ft);
  16884.       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].u.expr = expr;
  16885.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  16886.     return (ffelexHandler) ffestb_R9234_;
  16887.       if (ffestb_local_.inquire.ix == FFESTP_inquireixIOLENGTH)
  16888.     return (ffelexHandler) ffestb_R92310_;
  16889.       return (ffelexHandler) ffestb_R9239_;
  16890.  
  16891.     default:
  16892.       break;
  16893.     }
  16894.  
  16895.   ffestb_subr_kill_inquire_ ();
  16896.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
  16897.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16898. }
  16899.  
  16900. /* ffestb_R9237_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS
  16901.  
  16902.    return ffestb_R9237_;  // to lexer
  16903.  
  16904.    Handle NUMBER for label here.  */
  16905.  
  16906. static ffelexHandler
  16907. ffestb_R9237_ (ffelexToken t)
  16908. {
  16909.   switch (ffelex_token_type (t))
  16910.     {
  16911.     case FFELEX_typeNUMBER:
  16912.       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value_present
  16913.     = TRUE;
  16914.       ffestp_file.inquire.inquire_spec[ffestb_local_.inquire.ix].value
  16915.     = ffelex_token_use (t);
  16916.       return (ffelexHandler) ffestb_R9238_;
  16917.  
  16918.     default:
  16919.       break;
  16920.     }
  16921.  
  16922.   ffestb_subr_kill_inquire_ ();
  16923.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
  16924.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16925. }
  16926.  
  16927. /* ffestb_R9238_ -- "INQUIRE" OPEN_PAREN ... NAME EQUALS NUMBER
  16928.  
  16929.    return ffestb_R9238_;  // to lexer
  16930.  
  16931.    Handle COMMA or CLOSE_PAREN here.  */
  16932.  
  16933. static ffelexHandler
  16934. ffestb_R9238_ (ffelexToken t)
  16935. {
  16936.   switch (ffelex_token_type (t))
  16937.     {
  16938.     case FFELEX_typeCOMMA:
  16939.       return (ffelexHandler) ffestb_R9234_;
  16940.  
  16941.     case FFELEX_typeCLOSE_PAREN:
  16942.       return (ffelexHandler) ffestb_R9239_;
  16943.  
  16944.     default:
  16945.       break;
  16946.     }
  16947.  
  16948.   ffestb_subr_kill_inquire_ ();
  16949.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
  16950.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16951. }
  16952.  
  16953. /* ffestb_R9239_ -- "INQUIRE" OPEN_PAREN ... CLOSE_PAREN
  16954.  
  16955.    return ffestb_R9239_;  // to lexer
  16956.  
  16957.    Handle EOS or SEMICOLON here.  */
  16958.  
  16959. static ffelexHandler
  16960. ffestb_R9239_ (ffelexToken t)
  16961. {
  16962.   switch (ffelex_token_type (t))
  16963.     {
  16964.     case FFELEX_typeEOS:
  16965.     case FFELEX_typeSEMICOLON:
  16966.       ffesta_confirmed ();
  16967.       if (!ffesta_is_inhibited ())
  16968.     ffestc_R923A ();
  16969.       ffestb_subr_kill_inquire_ ();
  16970.       return (ffelexHandler) ffesta_zero (t);
  16971.  
  16972.     default:
  16973.       break;
  16974.     }
  16975.  
  16976.   ffestb_subr_kill_inquire_ ();
  16977.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
  16978.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  16979. }
  16980.  
  16981. /* ffestb_R92310_ -- "INQUIRE(IOLENGTH=expr)"
  16982.  
  16983.    return ffestb_R92310_;  // to lexer
  16984.  
  16985.    Make sure EOS or SEMICOLON not here; begin R923B processing and expect
  16986.    output IO list.  */
  16987.  
  16988. static ffelexHandler
  16989. ffestb_R92310_ (ffelexToken t)
  16990. {
  16991.   switch (ffelex_token_type (t))
  16992.     {
  16993.     case FFELEX_typeEOS:
  16994.     case FFELEX_typeSEMICOLON:
  16995.       break;
  16996.  
  16997.     default:
  16998.       ffesta_confirmed ();
  16999.       if (!ffesta_is_inhibited ())
  17000.     ffestc_R923B_start ();
  17001.       ffestb_subr_kill_inquire_ ();
  17002.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17003.           FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R92311_)))
  17004.     (t);
  17005.     }
  17006.  
  17007.   ffestb_subr_kill_inquire_ ();
  17008.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
  17009.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17010. }
  17011.  
  17012. /* ffestb_R92311_ -- "INQUIRE(IOLENGTH=expr)" expr
  17013.  
  17014.    (ffestb_R92311_)  // to expression handler
  17015.  
  17016.    Handle COMMA or EOS/SEMICOLON here.    */
  17017.  
  17018. static ffelexHandler
  17019. ffestb_R92311_ (ffelexToken ft, ffebld expr, ffelexToken t)
  17020. {
  17021.   switch (ffelex_token_type (t))
  17022.     {
  17023.     case FFELEX_typeCOMMA:
  17024.       if (expr == NULL)
  17025.     break;
  17026.       if (!ffesta_is_inhibited ())
  17027.     ffestc_R923B_item (expr, ft);
  17028.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17029.            FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_R92311_);
  17030.  
  17031.     case FFELEX_typeEOS:
  17032.     case FFELEX_typeSEMICOLON:
  17033.       if (expr == NULL)
  17034.     break;
  17035.       if (!ffesta_is_inhibited ())
  17036.     {
  17037.       ffestc_R923B_item (expr, ft);
  17038.       ffestc_R923B_finish ();
  17039.     }
  17040.       return (ffelexHandler) ffesta_zero (t);
  17041.  
  17042.     default:
  17043.       break;
  17044.     }
  17045.  
  17046.   if (!ffesta_is_inhibited ())
  17047.     ffestc_R923B_finish ();
  17048.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "INQUIRE", t);
  17049.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17050. }
  17051.  
  17052. /* ffestb_V018 -- Parse the REWRITE statement
  17053.  
  17054.    return ffestb_V018;    // to lexer
  17055.  
  17056.    Make sure the statement has a valid form for the REWRITE
  17057.    statement.  If it does, implement the statement.  */
  17058.  
  17059. #if FFESTR_VXT
  17060. ffelexHandler
  17061. ffestb_V018 (ffelexToken t)
  17062. {
  17063.   ffestpRewriteIx ix;
  17064.  
  17065.   switch (ffelex_token_type (ffesta_tokens[0]))
  17066.     {
  17067.     case FFELEX_typeNAME:
  17068.       if (ffesta_first_kw != FFESTR_firstREWRITE)
  17069.     goto bad_0;        /* :::::::::::::::::::: */
  17070.       switch (ffelex_token_type (t))
  17071.     {
  17072.     case FFELEX_typeCOMMA:
  17073.     case FFELEX_typeCOLONCOLON:
  17074.     case FFELEX_typeEOS:
  17075.     case FFELEX_typeSEMICOLON:
  17076.     case FFELEX_typeNAME:
  17077.     case FFELEX_typeNUMBER:
  17078.       ffesta_confirmed ();    /* Error, but clearly intended. */
  17079.       goto bad_1;        /* :::::::::::::::::::: */
  17080.  
  17081.     default:
  17082.       goto bad_1;        /* :::::::::::::::::::: */
  17083.  
  17084.     case FFELEX_typeOPEN_PAREN:
  17085.       for (ix = 0; ix < FFESTP_rewriteix; ++ix)
  17086.         ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present = FALSE;
  17087.       return (ffelexHandler) ffestb_V0181_;
  17088.     }
  17089.  
  17090.     case FFELEX_typeNAMES:
  17091.       if (ffesta_first_kw != FFESTR_firstREWRITE)
  17092.     goto bad_0;        /* :::::::::::::::::::: */
  17093.       switch (ffelex_token_type (t))
  17094.     {
  17095.     case FFELEX_typeEOS:
  17096.     case FFELEX_typeSEMICOLON:
  17097.     case FFELEX_typeCOMMA:
  17098.     case FFELEX_typeCOLONCOLON:
  17099.       ffesta_confirmed ();    /* Error, but clearly intended. */
  17100.       goto bad_1;        /* :::::::::::::::::::: */
  17101.  
  17102.     default:
  17103.       goto bad_1;        /* :::::::::::::::::::: */
  17104.  
  17105.     case FFELEX_typeOPEN_PAREN:
  17106.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlREWRITE)
  17107.         goto bad_0;        /* :::::::::::::::::::: */
  17108.  
  17109.       for (ix = 0; ix < FFESTP_rewriteix; ++ix)
  17110.         ffestp_file.rewrite.rewrite_spec[ix].kw_or_val_present = FALSE;
  17111.       return (ffelexHandler) ffestb_V0181_;
  17112.     }
  17113.  
  17114.     default:
  17115.       goto bad_0;        /* :::::::::::::::::::: */
  17116.     }
  17117.  
  17118. bad_0:                /* :::::::::::::::::::: */
  17119.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", ffesta_tokens[0]);
  17120.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17121.  
  17122. bad_1:                /* :::::::::::::::::::: */
  17123.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
  17124.   return (ffelexHandler) ffelex_swallow_tokens (t,
  17125.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  17126. }
  17127.  
  17128. /* ffestb_V0181_ -- "REWRITE" OPEN_PAREN
  17129.  
  17130.    return ffestb_V0181_;  // to lexer
  17131.  
  17132.    Handle expr construct (not NAME=expr construct) here.  */
  17133.  
  17134. static ffelexHandler
  17135. ffestb_V0181_ (ffelexToken t)
  17136. {
  17137.   switch (ffelex_token_type (t))
  17138.     {
  17139.     case FFELEX_typeNAME:
  17140.       ffesta_tokens[1] = ffelex_token_use (t);
  17141.       return (ffelexHandler) ffestb_V0182_;
  17142.  
  17143.     default:
  17144.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17145.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0183_)))
  17146.     (t);
  17147.     }
  17148. }
  17149.  
  17150. /* ffestb_V0182_ -- "REWRITE" OPEN_PAREN NAME
  17151.  
  17152.    return ffestb_V0182_;  // to lexer
  17153.  
  17154.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  17155.    token thru expression handler.  */
  17156.  
  17157. static ffelexHandler
  17158. ffestb_V0182_ (ffelexToken t)
  17159. {
  17160.   ffelexHandler next;
  17161.   ffelexToken nt;
  17162.  
  17163.   switch (ffelex_token_type (t))
  17164.     {
  17165.     case FFELEX_typeEQUALS:
  17166.       nt = ffesta_tokens[1];
  17167.       next = (ffelexHandler) ffestb_V0187_ (nt);
  17168.       ffelex_token_kill (nt);
  17169.       return (ffelexHandler) (*next) (t);
  17170.  
  17171.     default:
  17172.       nt = ffesta_tokens[1];
  17173.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17174.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0183_)))
  17175.     (nt);
  17176.       ffelex_token_kill (nt);
  17177.       return (ffelexHandler) (*next) (t);
  17178.     }
  17179. }
  17180.  
  17181. /* ffestb_V0183_ -- "REWRITE" OPEN_PAREN expr [CLOSE_PAREN]
  17182.  
  17183.    (ffestb_V0183_)  // to expression handler
  17184.  
  17185.    Handle COMMA or EOS/SEMICOLON here.    */
  17186.  
  17187. static ffelexHandler
  17188. ffestb_V0183_ (ffelexToken ft, ffebld expr, ffelexToken t)
  17189. {
  17190.   switch (ffelex_token_type (t))
  17191.     {
  17192.     case FFELEX_typeCOMMA:
  17193.     case FFELEX_typeCLOSE_PAREN:
  17194.       if (expr == NULL)
  17195.     break;
  17196.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].kw_or_val_present
  17197.     = TRUE;
  17198.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].kw_present = FALSE;
  17199.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value_present = TRUE;
  17200.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value_is_label
  17201.     = FALSE;
  17202.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].value
  17203.     = ffelex_token_use (ft);
  17204.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixUNIT].u.expr = expr;
  17205.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  17206.     return (ffelexHandler) ffestb_V0184_;
  17207.       return (ffelexHandler) ffestb_V01812_;
  17208.  
  17209.     default:
  17210.       break;
  17211.     }
  17212.  
  17213.   ffestb_subr_kill_rewrite_ ();
  17214.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
  17215.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17216. }
  17217.  
  17218. /* ffestb_V0184_ -- "REWRITE" OPEN_PAREN expr COMMA
  17219.  
  17220.    return ffestb_V0184_;  // to lexer
  17221.  
  17222.    Handle expr construct (not NAME=expr construct) here.  */
  17223.  
  17224. static ffelexHandler
  17225. ffestb_V0184_ (ffelexToken t)
  17226. {
  17227.   switch (ffelex_token_type (t))
  17228.     {
  17229.     case FFELEX_typeNAME:
  17230.       ffesta_tokens[1] = ffelex_token_use (t);
  17231.       return (ffelexHandler) ffestb_V0185_;
  17232.  
  17233.     default:
  17234.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17235.            FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_V0186_)))
  17236.     (t);
  17237.     }
  17238. }
  17239.  
  17240. /* ffestb_V0185_ -- "REWRITE" OPEN_PAREN expr COMMA NAME
  17241.  
  17242.    return ffestb_V0185_;  // to lexer
  17243.  
  17244.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  17245.    token thru expression handler.  */
  17246.  
  17247. static ffelexHandler
  17248. ffestb_V0185_ (ffelexToken t)
  17249. {
  17250.   ffelexHandler next;
  17251.   ffelexToken nt;
  17252.  
  17253.   switch (ffelex_token_type (t))
  17254.     {
  17255.     case FFELEX_typeEQUALS:
  17256.       nt = ffesta_tokens[1];
  17257.       next = (ffelexHandler) ffestb_V0187_ (nt);
  17258.       ffelex_token_kill (nt);
  17259.       return (ffelexHandler) (*next) (t);
  17260.  
  17261.     default:
  17262.       nt = ffesta_tokens[1];
  17263.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17264.            FFEEXPR_contextFILEFORMAT, (ffeexprCallback) ffestb_V0186_)))
  17265.     (nt);
  17266.       ffelex_token_kill (nt);
  17267.       return (ffelexHandler) (*next) (t);
  17268.     }
  17269. }
  17270.  
  17271. /* ffestb_V0186_ -- "REWRITE" OPEN_PAREN expr COMMA expr
  17272.  
  17273.    (ffestb_V0186_)  // to expression handler
  17274.  
  17275.    Handle COMMA or CLOSE_PAREN here.  */
  17276.  
  17277. static ffelexHandler
  17278. ffestb_V0186_ (ffelexToken ft, ffebld expr, ffelexToken t)
  17279. {
  17280.   switch (ffelex_token_type (t))
  17281.     {
  17282.     case FFELEX_typeCOMMA:
  17283.     case FFELEX_typeCLOSE_PAREN:
  17284.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].kw_or_val_present
  17285.     = TRUE;
  17286.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].kw_present = FALSE;
  17287.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value_present = TRUE;
  17288.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value_is_label
  17289.     = (expr == NULL);
  17290.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].value
  17291.     = ffelex_token_use (ft);
  17292.       ffestp_file.rewrite.rewrite_spec[FFESTP_rewriteixFMT].u.expr = expr;
  17293.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  17294.     return (ffelexHandler) ffestb_V0187_;
  17295.       return (ffelexHandler) ffestb_V01812_;
  17296.  
  17297.     default:
  17298.       break;
  17299.     }
  17300.  
  17301.   ffestb_subr_kill_rewrite_ ();
  17302.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
  17303.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17304. }
  17305.  
  17306. /* ffestb_V0187_ -- "REWRITE" OPEN_PAREN [external-file-unit COMMA [format
  17307.            COMMA]]
  17308.  
  17309.    return ffestb_V0187_;  // to lexer
  17310.  
  17311.    Handle expr construct (not NAME=expr construct) here.  */
  17312.  
  17313. static ffelexHandler
  17314. ffestb_V0187_ (ffelexToken t)
  17315. {
  17316.   ffestrGenio kw;
  17317.  
  17318.   ffestb_local_.rewrite.label = FALSE;
  17319.  
  17320.   switch (ffelex_token_type (t))
  17321.     {
  17322.     case FFELEX_typeNAME:
  17323.       kw = ffestr_genio (t);
  17324.       switch (kw)
  17325.     {
  17326.     case FFESTR_genioERR:
  17327.       ffestb_local_.rewrite.ix = FFESTP_rewriteixERR;
  17328.       ffestb_local_.rewrite.label = TRUE;
  17329.       break;
  17330.  
  17331.     case FFESTR_genioFMT:
  17332.       ffestb_local_.rewrite.ix = FFESTP_rewriteixFMT;
  17333.       ffestb_local_.rewrite.left = FALSE;
  17334.       ffestb_local_.rewrite.context = FFEEXPR_contextFILEFORMAT;
  17335.       break;
  17336.  
  17337.     case FFESTR_genioIOSTAT:
  17338.       ffestb_local_.rewrite.ix = FFESTP_rewriteixIOSTAT;
  17339.       ffestb_local_.rewrite.left = TRUE;
  17340.       ffestb_local_.rewrite.context = FFEEXPR_contextFILEINT;
  17341.       break;
  17342.  
  17343.     case FFESTR_genioUNIT:
  17344.       ffestb_local_.rewrite.ix = FFESTP_rewriteixUNIT;
  17345.       ffestb_local_.rewrite.left = FALSE;
  17346.       ffestb_local_.rewrite.context = FFEEXPR_contextFILENUM;
  17347.       break;
  17348.  
  17349.     default:
  17350.       goto bad;        /* :::::::::::::::::::: */
  17351.     }
  17352.       if (ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
  17353.       .kw_or_val_present)
  17354.     break;            /* Can't specify a keyword twice! */
  17355.       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
  17356.     .kw_or_val_present = TRUE;
  17357.       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
  17358.     .kw_present = TRUE;
  17359.       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
  17360.     .value_present = FALSE;
  17361.       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_is_label
  17362.     = ffestb_local_.rewrite.label;
  17363.       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].kw
  17364.     = ffelex_token_use (t);
  17365.       return (ffelexHandler) ffestb_V0188_;
  17366.  
  17367.     default:
  17368.       break;
  17369.     }
  17370.  
  17371. bad:                /* :::::::::::::::::::: */
  17372.   ffestb_subr_kill_rewrite_ ();
  17373.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
  17374.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17375. }
  17376.  
  17377. /* ffestb_V0188_ -- "REWRITE" OPEN_PAREN [external-file-unit COMMA [format
  17378.            COMMA]] NAME
  17379.  
  17380.    return ffestb_V0188_;  // to lexer
  17381.  
  17382.    Make sure EQUALS here, send next token to expression handler.  */
  17383.  
  17384. static ffelexHandler
  17385. ffestb_V0188_ (ffelexToken t)
  17386. {
  17387.   switch (ffelex_token_type (t))
  17388.     {
  17389.     case FFELEX_typeEQUALS:
  17390.       ffesta_confirmed ();
  17391.       if (ffestb_local_.rewrite.label)
  17392.     return (ffelexHandler) ffestb_V01810_;
  17393.       if (ffestb_local_.rewrite.left)
  17394.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  17395.                         ffestb_local_.rewrite.context,
  17396.                         (ffeexprCallback) ffestb_V0189_);
  17397.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17398.                       ffestb_local_.rewrite.context,
  17399.                       (ffeexprCallback) ffestb_V0189_);
  17400.  
  17401.     default:
  17402.       break;
  17403.     }
  17404.  
  17405.   ffestb_subr_kill_rewrite_ ();
  17406.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
  17407.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17408. }
  17409.  
  17410. /* ffestb_V0189_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS expr
  17411.  
  17412.    (ffestb_V0189_)  // to expression handler
  17413.  
  17414.    Handle COMMA or CLOSE_PAREN here.  */
  17415.  
  17416. static ffelexHandler
  17417. ffestb_V0189_ (ffelexToken ft, ffebld expr, ffelexToken t)
  17418. {
  17419.   switch (ffelex_token_type (t))
  17420.     {
  17421.     case FFELEX_typeCOMMA:
  17422.     case FFELEX_typeCLOSE_PAREN:
  17423.       if (expr == NULL)
  17424.     if (ffestb_local_.rewrite.context == FFEEXPR_contextFILEFORMAT)
  17425.       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix]
  17426.         .value_is_label = TRUE;
  17427.     else
  17428.       break;
  17429.       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_present
  17430.     = TRUE;
  17431.       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value
  17432.     = ffelex_token_use (ft);
  17433.       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].u.expr = expr;
  17434.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  17435.     return (ffelexHandler) ffestb_V0187_;
  17436.       return (ffelexHandler) ffestb_V01812_;
  17437.  
  17438.     default:
  17439.       break;
  17440.     }
  17441.  
  17442.   ffestb_subr_kill_rewrite_ ();
  17443.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
  17444.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17445. }
  17446.  
  17447. /* ffestb_V01810_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS
  17448.  
  17449.    return ffestb_V01810_;  // to lexer
  17450.  
  17451.    Handle NUMBER for label here.  */
  17452.  
  17453. static ffelexHandler
  17454. ffestb_V01810_ (ffelexToken t)
  17455. {
  17456.   switch (ffelex_token_type (t))
  17457.     {
  17458.     case FFELEX_typeNUMBER:
  17459.       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value_present
  17460.     = TRUE;
  17461.       ffestp_file.rewrite.rewrite_spec[ffestb_local_.rewrite.ix].value
  17462.     = ffelex_token_use (t);
  17463.       return (ffelexHandler) ffestb_V01811_;
  17464.  
  17465.     default:
  17466.       break;
  17467.     }
  17468.  
  17469.   ffestb_subr_kill_rewrite_ ();
  17470.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
  17471.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17472. }
  17473.  
  17474. /* ffestb_V01811_ -- "REWRITE" OPEN_PAREN ... NAME EQUALS NUMBER
  17475.  
  17476.    return ffestb_V01811_;  // to lexer
  17477.  
  17478.    Handle COMMA or CLOSE_PAREN here.  */
  17479.  
  17480. static ffelexHandler
  17481. ffestb_V01811_ (ffelexToken t)
  17482. {
  17483.   switch (ffelex_token_type (t))
  17484.     {
  17485.     case FFELEX_typeCOMMA:
  17486.       return (ffelexHandler) ffestb_V0187_;
  17487.  
  17488.     case FFELEX_typeCLOSE_PAREN:
  17489.       return (ffelexHandler) ffestb_V01812_;
  17490.  
  17491.     default:
  17492.       break;
  17493.     }
  17494.  
  17495.   ffestb_subr_kill_rewrite_ ();
  17496.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
  17497.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17498. }
  17499.  
  17500. /* ffestb_V01812_ -- "REWRITE" OPEN_PAREN ... CLOSE_PAREN
  17501.  
  17502.    return ffestb_V01812_;  // to lexer
  17503.  
  17504.    Handle EOS or SEMICOLON here.  */
  17505.  
  17506. static ffelexHandler
  17507. ffestb_V01812_ (ffelexToken t)
  17508. {
  17509.   switch (ffelex_token_type (t))
  17510.     {
  17511.     case FFELEX_typeEOS:
  17512.     case FFELEX_typeSEMICOLON:
  17513.       ffesta_confirmed ();
  17514.       if (!ffesta_is_inhibited ())
  17515.     {
  17516.       ffestc_V018_start ();
  17517.       ffestc_V018_finish ();
  17518.     }
  17519.       ffestb_subr_kill_rewrite_ ();
  17520.       return (ffelexHandler) ffesta_zero (t);
  17521.  
  17522.     case FFELEX_typeNAME:
  17523.     case FFELEX_typeOPEN_PAREN:
  17524.     case FFELEX_typeCOMMA:
  17525.       ffesta_confirmed ();
  17526.       if (!ffesta_is_inhibited ())
  17527.     ffestc_V018_start ();
  17528.       ffestb_subr_kill_rewrite_ ();
  17529.  
  17530.       /* EXTENSION: Allow an optional preceding COMMA here if not pedantic.
  17531.          (f2c provides this extension, as do other compilers, supposedly.) */
  17532.  
  17533.       if (!ffe_is_pedantic () && (ffelex_token_type (t) == FFELEX_typeCOMMA))
  17534.     return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17535.            FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_);
  17536.  
  17537.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17538.           FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_)))
  17539.     (t);
  17540.  
  17541.     default:
  17542.       break;
  17543.     }
  17544.  
  17545.   ffestb_subr_kill_rewrite_ ();
  17546.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
  17547.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17548. }
  17549.  
  17550. /* ffestb_V01813_ -- "REWRITE(...)" expr
  17551.  
  17552.    (ffestb_V01813_)  // to expression handler
  17553.  
  17554.    Handle COMMA or EOS/SEMICOLON here.    */
  17555.  
  17556. static ffelexHandler
  17557. ffestb_V01813_ (ffelexToken ft, ffebld expr, ffelexToken t)
  17558. {
  17559.   switch (ffelex_token_type (t))
  17560.     {
  17561.     case FFELEX_typeCOMMA:
  17562.       if (expr == NULL)
  17563.     break;
  17564.       if (!ffesta_is_inhibited ())
  17565.     ffestc_V018_item (expr, ft);
  17566.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17567.            FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V01813_);
  17568.  
  17569.     case FFELEX_typeEOS:
  17570.     case FFELEX_typeSEMICOLON:
  17571.       if (expr == NULL)
  17572.     break;
  17573.       if (!ffesta_is_inhibited ())
  17574.     {
  17575.       ffestc_V018_item (expr, ft);
  17576.       ffestc_V018_finish ();
  17577.     }
  17578.       return (ffelexHandler) ffesta_zero (t);
  17579.  
  17580.     default:
  17581.       break;
  17582.     }
  17583.  
  17584.   if (!ffesta_is_inhibited ())
  17585.     ffestc_V018_finish ();
  17586.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "REWRITE", t);
  17587.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17588. }
  17589.  
  17590. /* ffestb_V019 -- Parse the ACCEPT statement
  17591.  
  17592.    return ffestb_V019;    // to lexer
  17593.  
  17594.    Make sure the statement has a valid form for the ACCEPT
  17595.    statement.  If it does, implement the statement.  */
  17596.  
  17597. ffelexHandler
  17598. ffestb_V019 (ffelexToken t)
  17599. {
  17600.   ffelexHandler next;
  17601.   ffestpAcceptIx ix;
  17602.  
  17603.   switch (ffelex_token_type (ffesta_tokens[0]))
  17604.     {
  17605.     case FFELEX_typeNAME:
  17606.       if (ffesta_first_kw != FFESTR_firstACCEPT)
  17607.     goto bad_0;        /* :::::::::::::::::::: */
  17608.       switch (ffelex_token_type (t))
  17609.     {
  17610.     case FFELEX_typeCOMMA:
  17611.     case FFELEX_typeCOLONCOLON:
  17612.     case FFELEX_typeEOS:
  17613.     case FFELEX_typeSEMICOLON:
  17614.       ffesta_confirmed ();    /* Error, but clearly intended. */
  17615.       goto bad_1;        /* :::::::::::::::::::: */
  17616.  
  17617.     case FFELEX_typeEQUALS:
  17618.     case FFELEX_typePOINTS:
  17619.     case FFELEX_typeCOLON:
  17620.       goto bad_1;        /* :::::::::::::::::::: */
  17621.  
  17622.     case FFELEX_typeNAME:
  17623.     case FFELEX_typeNUMBER:
  17624.       ffesta_confirmed ();
  17625.       break;
  17626.  
  17627.     default:
  17628.       break;
  17629.     }
  17630.  
  17631.       for (ix = 0; ix < FFESTP_acceptix; ++ix)
  17632.     ffestp_file.accept.accept_spec[ix].kw_or_val_present = FALSE;
  17633.       return (ffelexHandler) (*((ffelexHandler)
  17634.                 ffeexpr_rhs (ffesta_output_pool,
  17635.         FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0191_)))
  17636.     (t);
  17637.  
  17638.     case FFELEX_typeNAMES:
  17639.       if (ffesta_first_kw != FFESTR_firstACCEPT)
  17640.     goto bad_0;        /* :::::::::::::::::::: */
  17641.       switch (ffelex_token_type (t))
  17642.     {
  17643.     case FFELEX_typeEOS:
  17644.     case FFELEX_typeSEMICOLON:
  17645.     case FFELEX_typeCOMMA:
  17646.       ffesta_confirmed ();
  17647.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlACCEPT)
  17648.         break;
  17649.       goto bad_1;        /* :::::::::::::::::::: */
  17650.  
  17651.     case FFELEX_typeCOLONCOLON:
  17652.       ffesta_confirmed ();    /* Error, but clearly intended. */
  17653.       goto bad_1;        /* :::::::::::::::::::: */
  17654.  
  17655.     case FFELEX_typeEQUALS:
  17656.     case FFELEX_typePOINTS:
  17657.     case FFELEX_typeCOLON:
  17658.       goto bad_1;        /* :::::::::::::::::::: */
  17659.  
  17660.     default:
  17661.       break;
  17662.     }
  17663.       for (ix = 0; ix < FFESTP_acceptix; ++ix)
  17664.     ffestp_file.accept.accept_spec[ix].kw_or_val_present = FALSE;
  17665.       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17666.          FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0191_);
  17667.       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
  17668.                            FFESTR_firstlACCEPT);
  17669.       if (next == NULL)
  17670.     return (ffelexHandler) ffelex_swallow_tokens (t,
  17671.                            (ffelexHandler) ffesta_zero);
  17672.       return (ffelexHandler) (*next) (t);
  17673.  
  17674.     default:
  17675.       goto bad_0;        /* :::::::::::::::::::: */
  17676.     }
  17677.  
  17678. bad_0:                /* :::::::::::::::::::: */
  17679.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", ffesta_tokens[0]);
  17680.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17681.  
  17682. bad_1:                /* :::::::::::::::::::: */
  17683.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
  17684.   return (ffelexHandler) ffelex_swallow_tokens (t,
  17685.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  17686. }
  17687.  
  17688. /* ffestb_V0191_ -- "ACCEPT" expr
  17689.  
  17690.    (ffestb_V0191_)  // to expression handler
  17691.  
  17692.    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
  17693.  
  17694. static ffelexHandler
  17695. ffestb_V0191_ (ffelexToken ft, ffebld expr, ffelexToken t)
  17696. {
  17697.   switch (ffelex_token_type (t))
  17698.     {
  17699.     case FFELEX_typeEOS:
  17700.     case FFELEX_typeSEMICOLON:
  17701.     case FFELEX_typeCOMMA:
  17702.       ffesta_confirmed ();
  17703.       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].kw_or_val_present
  17704.     = TRUE;
  17705.       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].kw_present = FALSE;
  17706.       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value_present = TRUE;
  17707.       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value_is_label
  17708.     = (expr == NULL);
  17709.       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].value
  17710.     = ffelex_token_use (ft);
  17711.       ffestp_file.accept.accept_spec[FFESTP_acceptixFORMAT].u.expr = expr;
  17712.       if (!ffesta_is_inhibited ())
  17713.     ffestc_V019_start ();
  17714.       ffestb_subr_kill_accept_ ();
  17715.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  17716.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  17717.                         FFEEXPR_contextIOLIST,
  17718.                         (ffeexprCallback) ffestb_V0192_);
  17719.       if (!ffesta_is_inhibited ())
  17720.     ffestc_V019_finish ();
  17721.       return (ffelexHandler) ffesta_zero (t);
  17722.  
  17723.     default:
  17724.       break;
  17725.     }
  17726.  
  17727.   ffestb_subr_kill_accept_ ();
  17728.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
  17729.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17730. }
  17731.  
  17732. /* ffestb_V0192_ -- "ACCEPT" expr COMMA expr
  17733.  
  17734.    (ffestb_V0192_)  // to expression handler
  17735.  
  17736.    Handle COMMA or EOS/SEMICOLON here.    */
  17737.  
  17738. static ffelexHandler
  17739. ffestb_V0192_ (ffelexToken ft, ffebld expr, ffelexToken t)
  17740. {
  17741.   switch (ffelex_token_type (t))
  17742.     {
  17743.     case FFELEX_typeCOMMA:
  17744.       if (expr == NULL)
  17745.     break;
  17746.       if (!ffesta_is_inhibited ())
  17747.     ffestc_V019_item (expr, ft);
  17748.       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  17749.                       FFEEXPR_contextIOLIST,
  17750.                       (ffeexprCallback) ffestb_V0192_);
  17751.  
  17752.     case FFELEX_typeEOS:
  17753.     case FFELEX_typeSEMICOLON:
  17754.       if (expr == NULL)
  17755.     break;
  17756.       if (!ffesta_is_inhibited ())
  17757.     {
  17758.       ffestc_V019_item (expr, ft);
  17759.       ffestc_V019_finish ();
  17760.     }
  17761.       return (ffelexHandler) ffesta_zero (t);
  17762.  
  17763.     default:
  17764.       break;
  17765.     }
  17766.  
  17767.   if (!ffesta_is_inhibited ())
  17768.     ffestc_V019_finish ();
  17769.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "ACCEPT", t);
  17770.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17771. }
  17772.  
  17773. #endif
  17774. /* ffestb_V020 -- Parse the TYPE statement
  17775.  
  17776.    return ffestb_V020;    // to lexer
  17777.  
  17778.    Make sure the statement has a valid form for the TYPE
  17779.    statement.  If it does, implement the statement.  */
  17780.  
  17781. ffelexHandler
  17782. ffestb_V020 (ffelexToken t)
  17783. {
  17784.   ffeTokenLength i;
  17785.   char *p;
  17786.   ffelexHandler next;
  17787.   ffestpTypeIx ix;
  17788.  
  17789.   switch (ffelex_token_type (ffesta_tokens[0]))
  17790.     {
  17791.     case FFELEX_typeNAME:
  17792.       if (ffesta_first_kw != FFESTR_firstTYPE)
  17793.     goto bad_0;        /* :::::::::::::::::::: */
  17794.       switch (ffelex_token_type (t))
  17795.     {
  17796.     case FFELEX_typeCOLONCOLON:
  17797.     case FFELEX_typeEOS:
  17798.     case FFELEX_typeSEMICOLON:
  17799.       ffesta_confirmed ();    /* Error, but clearly intended. */
  17800.       goto bad_1;        /* :::::::::::::::::::: */
  17801.  
  17802.     case FFELEX_typeEQUALS:
  17803.     case FFELEX_typePOINTS:
  17804.     case FFELEX_typeCOLON:
  17805.     case FFELEX_typeCOMMA:    /* Because "TYPE,PUBLIC::A" is ambiguous with
  17806.                    '90. */
  17807.       goto bad_1;        /* :::::::::::::::::::: */
  17808.  
  17809.     case FFELEX_typeNUMBER:
  17810.       ffesta_confirmed ();
  17811.       break;
  17812.  
  17813.     case FFELEX_typeNAME:    /* Because TYPE A is ambiguous with '90. */
  17814.     default:
  17815.       break;
  17816.     }
  17817.  
  17818.       for (ix = 0; ix < FFESTP_typeix; ++ix)
  17819.     ffestp_file.type.type_spec[ix].kw_or_val_present = FALSE;
  17820.       return (ffelexHandler) (*((ffelexHandler)
  17821.                 ffeexpr_rhs (ffesta_output_pool,
  17822.         FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0201_)))
  17823.     (t);
  17824.  
  17825.     case FFELEX_typeNAMES:
  17826.       if (ffesta_first_kw != FFESTR_firstTYPE)
  17827.     goto bad_0;        /* :::::::::::::::::::: */
  17828.       switch (ffelex_token_type (t))
  17829.     {
  17830.     case FFELEX_typeEOS:
  17831.     case FFELEX_typeSEMICOLON:
  17832.     case FFELEX_typeCOMMA:
  17833.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlTYPE)
  17834.         break;
  17835.       goto bad_1;        /* :::::::::::::::::::: */
  17836.  
  17837.     case FFELEX_typeCOLONCOLON:
  17838.       ffesta_confirmed ();    /* Error, but clearly intended. */
  17839.       goto bad_1;        /* :::::::::::::::::::: */
  17840.  
  17841.     case FFELEX_typeOPEN_PAREN:
  17842.       if (ffelex_token_length (ffesta_tokens[0]) == FFESTR_firstlTYPE)
  17843.         break;        /* Else might be assignment/stmtfuncdef. */
  17844.       goto bad_1;        /* :::::::::::::::::::: */
  17845.  
  17846.     case FFELEX_typeEQUALS:
  17847.     case FFELEX_typePOINTS:
  17848.     case FFELEX_typeCOLON:
  17849.       goto bad_1;        /* :::::::::::::::::::: */
  17850.  
  17851.     default:
  17852.       break;
  17853.     }
  17854.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlTYPE);
  17855.       if (isdigit (*p))
  17856.     ffesta_confirmed ();    /* Else might be '90 TYPE statement. */
  17857.       for (ix = 0; ix < FFESTP_typeix; ++ix)
  17858.     ffestp_file.type.type_spec[ix].kw_or_val_present = FALSE;
  17859.       next = (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17860.          FFEEXPR_contextFILEFORMATNML, (ffeexprCallback) ffestb_V0201_);
  17861.       next = (ffelexHandler) ffelex_splice_tokens (next, ffesta_tokens[0],
  17862.                            FFESTR_firstlTYPE);
  17863.       if (next == NULL)
  17864.     return (ffelexHandler) ffelex_swallow_tokens (t,
  17865.                            (ffelexHandler) ffesta_zero);
  17866.       return (ffelexHandler) (*next) (t);
  17867.  
  17868.     default:
  17869.       goto bad_0;        /* :::::::::::::::::::: */
  17870.     }
  17871.  
  17872. bad_0:                /* :::::::::::::::::::: */
  17873.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", ffesta_tokens[0]);
  17874.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17875.  
  17876. bad_1:                /* :::::::::::::::::::: */
  17877.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
  17878.   return (ffelexHandler) ffelex_swallow_tokens (t,
  17879.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  17880. }
  17881.  
  17882. /* ffestb_V0201_ -- "TYPE" expr
  17883.  
  17884.    (ffestb_V0201_)  // to expression handler
  17885.  
  17886.    Make sure the next token is a COMMA or EOS/SEMICOLON.  */
  17887.  
  17888. static ffelexHandler
  17889. ffestb_V0201_ (ffelexToken ft, ffebld expr, ffelexToken t)
  17890. {
  17891.   bool comma = TRUE;
  17892.  
  17893.   switch (ffelex_token_type (t))
  17894.     {
  17895.     case FFELEX_typeEOS:
  17896.     case FFELEX_typeSEMICOLON:
  17897.       if (!ffe_is_vxt_not_90 () && (expr != NULL)
  17898.       && (ffebld_op (expr) == FFEBLD_opSYMTER))
  17899.     break;
  17900.       comma = FALSE;
  17901.       /* Fall through. */
  17902.     case FFELEX_typeCOMMA:
  17903.       if (!ffe_is_vxt_not_90 () && comma && (expr != NULL)
  17904.       && (ffebld_op (expr) == FFEBLD_opPAREN)
  17905.       && (ffebld_op (ffebld_left (expr)) == FFEBLD_opSYMTER))
  17906.     break;
  17907.       ffesta_confirmed ();
  17908.       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].kw_or_val_present
  17909.     = TRUE;
  17910.       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].kw_present = FALSE;
  17911.       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value_present = TRUE;
  17912.       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value_is_label
  17913.     = (expr == NULL);
  17914.       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].value
  17915.     = ffelex_token_use (ft);
  17916.       ffestp_file.type.type_spec[FFESTP_typeixFORMAT].u.expr = expr;
  17917.       if (!ffesta_is_inhibited ())
  17918.     ffestc_V020_start ();
  17919.       ffestb_subr_kill_type_ ();
  17920.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  17921.     return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17922.             FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V0202_);
  17923.       if (!ffesta_is_inhibited ())
  17924.     ffestc_V020_finish ();
  17925.       return (ffelexHandler) ffesta_zero (t);
  17926.  
  17927.     default:
  17928.       break;
  17929.     }
  17930.  
  17931.   ffestb_subr_kill_type_ ();
  17932.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
  17933.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17934. }
  17935.  
  17936. /* ffestb_V0202_ -- "TYPE" expr COMMA expr
  17937.  
  17938.    (ffestb_V0202_)  // to expression handler
  17939.  
  17940.    Handle COMMA or EOS/SEMICOLON here.    */
  17941.  
  17942. static ffelexHandler
  17943. ffestb_V0202_ (ffelexToken ft, ffebld expr, ffelexToken t)
  17944. {
  17945.   switch (ffelex_token_type (t))
  17946.     {
  17947.     case FFELEX_typeCOMMA:
  17948.       if (expr == NULL)
  17949.     break;
  17950.       if (!ffesta_is_inhibited ())
  17951.     ffestc_V020_item (expr, ft);
  17952.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  17953.             FFEEXPR_contextIOLIST, (ffeexprCallback) ffestb_V0202_);
  17954.  
  17955.     case FFELEX_typeEOS:
  17956.     case FFELEX_typeSEMICOLON:
  17957.       if (expr == NULL)
  17958.     break;
  17959.       if (!ffesta_is_inhibited ())
  17960.     {
  17961.       ffestc_V020_item (expr, ft);
  17962.       ffestc_V020_finish ();
  17963.     }
  17964.       return (ffelexHandler) ffesta_zero (t);
  17965.  
  17966.     default:
  17967.       break;
  17968.     }
  17969.  
  17970.   if (!ffesta_is_inhibited ())
  17971.     ffestc_V020_finish ();
  17972.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "TYPE I/O", t);
  17973.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  17974. }
  17975.  
  17976. /* ffestb_V021 -- Parse a DELETE statement
  17977.  
  17978.    return ffestb_V021;    // to lexer
  17979.  
  17980.    Make sure the statement has a valid form for a DELETE statement.
  17981.    If it does, implement the statement.     */
  17982.  
  17983. #if FFESTR_VXT
  17984. ffelexHandler
  17985. ffestb_V021 (ffelexToken t)
  17986. {
  17987.   ffestpDeleteIx ix;
  17988.  
  17989.   switch (ffelex_token_type (ffesta_tokens[0]))
  17990.     {
  17991.     case FFELEX_typeNAME:
  17992.       if (ffesta_first_kw != FFESTR_firstDELETE)
  17993.     goto bad_0;        /* :::::::::::::::::::: */
  17994.       break;
  17995.  
  17996.     case FFELEX_typeNAMES:
  17997.       if (ffesta_first_kw != FFESTR_firstDELETE)
  17998.     goto bad_0;        /* :::::::::::::::::::: */
  17999.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlDELETE)
  18000.     goto bad_0;        /* :::::::::::::::::::: */
  18001.       break;
  18002.  
  18003.     default:
  18004.       goto bad_0;        /* :::::::::::::::::::: */
  18005.     }
  18006.  
  18007.   switch (ffelex_token_type (t))
  18008.     {
  18009.     case FFELEX_typeOPEN_PAREN:
  18010.       break;
  18011.  
  18012.     case FFELEX_typeEOS:
  18013.     case FFELEX_typeSEMICOLON:
  18014.     case FFELEX_typeCOMMA:
  18015.     case FFELEX_typeCOLONCOLON:
  18016.       ffesta_confirmed ();    /* Error, but clearly intended. */
  18017.       goto bad_1;        /* :::::::::::::::::::: */
  18018.  
  18019.     default:
  18020.       goto bad_1;        /* :::::::::::::::::::: */
  18021.     }
  18022.  
  18023.   for (ix = 0; ix < FFESTP_deleteix; ++ix)
  18024.     ffestp_file.delete.delete_spec[ix].kw_or_val_present = FALSE;
  18025.  
  18026.   return (ffelexHandler) ffestb_V0211_;
  18027.  
  18028. bad_0:                /* :::::::::::::::::::: */
  18029.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", ffesta_tokens[0]);
  18030.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18031.  
  18032. bad_1:                /* :::::::::::::::::::: */
  18033.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
  18034.   return (ffelexHandler) ffelex_swallow_tokens (t,
  18035.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  18036. }
  18037.  
  18038. /* ffestb_V0211_ -- "DELETE" OPEN_PAREN
  18039.  
  18040.    return ffestb_V0211_;  // to lexer
  18041.  
  18042.    Handle expr construct (not NAME=expr construct) here.  */
  18043.  
  18044. static ffelexHandler
  18045. ffestb_V0211_ (ffelexToken t)
  18046. {
  18047.   switch (ffelex_token_type (t))
  18048.     {
  18049.     case FFELEX_typeNAME:
  18050.       ffesta_tokens[1] = ffelex_token_use (t);
  18051.       return (ffelexHandler) ffestb_V0212_;
  18052.  
  18053.     default:
  18054.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  18055.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0213_)))
  18056.     (t);
  18057.     }
  18058. }
  18059.  
  18060. /* ffestb_V0212_ -- "DELETE" OPEN_PAREN NAME
  18061.  
  18062.    return ffestb_V0212_;  // to lexer
  18063.  
  18064.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  18065.    token thru expression handler.  */
  18066.  
  18067. static ffelexHandler
  18068. ffestb_V0212_ (ffelexToken t)
  18069. {
  18070.   ffelexHandler next;
  18071.   ffelexToken nt;
  18072.  
  18073.   switch (ffelex_token_type (t))
  18074.     {
  18075.     case FFELEX_typeEQUALS:
  18076.       nt = ffesta_tokens[1];
  18077.       next = (ffelexHandler) ffestb_V0214_ (nt);
  18078.       ffelex_token_kill (nt);
  18079.       return (ffelexHandler) (*next) (t);
  18080.  
  18081.     default:
  18082.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  18083.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0213_)))
  18084.     (ffesta_tokens[1]);
  18085.       ffelex_token_kill (ffesta_tokens[1]);
  18086.       return (ffelexHandler) (*next) (t);
  18087.     }
  18088. }
  18089.  
  18090. /* ffestb_V0213_ -- "DELETE" OPEN_PAREN expr
  18091.  
  18092.    (ffestb_V0213_)  // to expression handler
  18093.  
  18094.    Handle COMMA or DELETE_PAREN here.  */
  18095.  
  18096. static ffelexHandler
  18097. ffestb_V0213_ (ffelexToken ft, ffebld expr, ffelexToken t)
  18098. {
  18099.   switch (ffelex_token_type (t))
  18100.     {
  18101.     case FFELEX_typeCOMMA:
  18102.     case FFELEX_typeCLOSE_PAREN:
  18103.       if (expr == NULL)
  18104.     break;
  18105.       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].kw_or_val_present
  18106.     = TRUE;
  18107.       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].kw_present = FALSE;
  18108.       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value_present = TRUE;
  18109.       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value_is_label
  18110.     = FALSE;
  18111.       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].value
  18112.     = ffelex_token_use (ft);
  18113.       ffestp_file.delete.delete_spec[FFESTP_deleteixUNIT].u.expr = expr;
  18114.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  18115.     return (ffelexHandler) ffestb_V0214_;
  18116.       return (ffelexHandler) ffestb_V0219_;
  18117.  
  18118.     default:
  18119.       break;
  18120.     }
  18121.  
  18122.   ffestb_subr_kill_delete_ ();
  18123.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
  18124.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18125. }
  18126.  
  18127. /* ffestb_V0214_ -- "DELETE" OPEN_PAREN [external-file-unit COMMA]
  18128.  
  18129.    return ffestb_V0214_;  // to lexer
  18130.  
  18131.    Handle expr construct (not NAME=expr construct) here.  */
  18132.  
  18133. static ffelexHandler
  18134. ffestb_V0214_ (ffelexToken t)
  18135. {
  18136.   ffestrGenio kw;
  18137.  
  18138.   ffestb_local_.delete.label = FALSE;
  18139.  
  18140.   switch (ffelex_token_type (t))
  18141.     {
  18142.     case FFELEX_typeNAME:
  18143.       kw = ffestr_genio (t);
  18144.       switch (kw)
  18145.     {
  18146.     case FFESTR_genioERR:
  18147.       ffestb_local_.delete.ix = FFESTP_deleteixERR;
  18148.       ffestb_local_.delete.label = TRUE;
  18149.       break;
  18150.  
  18151.     case FFESTR_genioIOSTAT:
  18152.       ffestb_local_.delete.ix = FFESTP_deleteixIOSTAT;
  18153.       ffestb_local_.delete.left = TRUE;
  18154.       ffestb_local_.delete.context = FFEEXPR_contextFILEINT;
  18155.       break;
  18156.  
  18157.     case FFESTR_genioREC:
  18158.       ffestb_local_.delete.ix = FFESTP_deleteixREC;
  18159.       ffestb_local_.delete.left = FALSE;
  18160.       ffestb_local_.delete.context = FFEEXPR_contextFILENUM;
  18161.       break;
  18162.  
  18163.     case FFESTR_genioUNIT:
  18164.       ffestb_local_.delete.ix = FFESTP_deleteixUNIT;
  18165.       ffestb_local_.delete.left = FALSE;
  18166.       ffestb_local_.delete.context = FFEEXPR_contextFILENUM;
  18167.       break;
  18168.  
  18169.     default:
  18170.       goto bad;        /* :::::::::::::::::::: */
  18171.     }
  18172.       if (ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
  18173.       .kw_or_val_present)
  18174.     break;            /* Can't specify a keyword twice! */
  18175.       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
  18176.     .kw_or_val_present = TRUE;
  18177.       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
  18178.     .kw_present = TRUE;
  18179.       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix]
  18180.     .value_present = FALSE;
  18181.       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_is_label
  18182.     = ffestb_local_.delete.label;
  18183.       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].kw
  18184.     = ffelex_token_use (t);
  18185.       return (ffelexHandler) ffestb_V0215_;
  18186.  
  18187.     default:
  18188.       break;
  18189.     }
  18190.  
  18191. bad:                /* :::::::::::::::::::: */
  18192.   ffestb_subr_kill_delete_ ();
  18193.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
  18194.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18195. }
  18196.  
  18197. /* ffestb_V0215_ -- "DELETE" OPEN_PAREN [external-file-unit COMMA] NAME
  18198.  
  18199.    return ffestb_V0215_;  // to lexer
  18200.  
  18201.    Make sure EQUALS here, send next token to expression handler.  */
  18202.  
  18203. static ffelexHandler
  18204. ffestb_V0215_ (ffelexToken t)
  18205. {
  18206.   switch (ffelex_token_type (t))
  18207.     {
  18208.     case FFELEX_typeEQUALS:
  18209.       ffesta_confirmed ();
  18210.       if (ffestb_local_.delete.label)
  18211.     return (ffelexHandler) ffestb_V0217_;
  18212.       if (ffestb_local_.delete.left)
  18213.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  18214.                         ffestb_local_.delete.context,
  18215.                         (ffeexprCallback) ffestb_V0216_);
  18216.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  18217.          ffestb_local_.delete.context, (ffeexprCallback) ffestb_V0216_);
  18218.  
  18219.     default:
  18220.       break;
  18221.     }
  18222.  
  18223.   ffestb_subr_kill_delete_ ();
  18224.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
  18225.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18226. }
  18227.  
  18228. /* ffestb_V0216_ -- "DELETE" OPEN_PAREN ... NAME EQUALS expr
  18229.  
  18230.    (ffestb_V0216_)  // to expression handler
  18231.  
  18232.    Handle COMMA or CLOSE_PAREN here.  */
  18233.  
  18234. static ffelexHandler
  18235. ffestb_V0216_ (ffelexToken ft, ffebld expr, ffelexToken t)
  18236. {
  18237.   switch (ffelex_token_type (t))
  18238.     {
  18239.     case FFELEX_typeCOMMA:
  18240.     case FFELEX_typeCLOSE_PAREN:
  18241.       if (expr == NULL)
  18242.     break;
  18243.       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_present
  18244.     = TRUE;
  18245.       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value
  18246.     = ffelex_token_use (ft);
  18247.       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].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_V0217_ -- "DELETE" OPEN_PAREN ... NAME EQUALS
  18262.  
  18263.    return ffestb_V0217_;  // to lexer
  18264.  
  18265.    Handle NUMBER for label here.  */
  18266.  
  18267. static ffelexHandler
  18268. ffestb_V0217_ (ffelexToken t)
  18269. {
  18270.   switch (ffelex_token_type (t))
  18271.     {
  18272.     case FFELEX_typeNUMBER:
  18273.       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value_present
  18274.     = TRUE;
  18275.       ffestp_file.delete.delete_spec[ffestb_local_.delete.ix].value
  18276.     = ffelex_token_use (t);
  18277.       return (ffelexHandler) ffestb_V0218_;
  18278.  
  18279.     default:
  18280.       break;
  18281.     }
  18282.  
  18283.   ffestb_subr_kill_delete_ ();
  18284.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
  18285.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18286. }
  18287.  
  18288. /* ffestb_V0218_ -- "DELETE" OPEN_PAREN ... NAME EQUALS NUMBER
  18289.  
  18290.    return ffestb_V0218_;  // to lexer
  18291.  
  18292.    Handle COMMA or CLOSE_PAREN here.  */
  18293.  
  18294. static ffelexHandler
  18295. ffestb_V0218_ (ffelexToken t)
  18296. {
  18297.   switch (ffelex_token_type (t))
  18298.     {
  18299.     case FFELEX_typeCOMMA:
  18300.       return (ffelexHandler) ffestb_V0214_;
  18301.  
  18302.     case FFELEX_typeCLOSE_PAREN:
  18303.       return (ffelexHandler) ffestb_V0219_;
  18304.  
  18305.     default:
  18306.       break;
  18307.     }
  18308.  
  18309.   ffestb_subr_kill_delete_ ();
  18310.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
  18311.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18312. }
  18313.  
  18314. /* ffestb_V0219_ -- "DELETE" OPEN_PAREN ... CLOSE_PAREN
  18315.  
  18316.    return ffestb_V0219_;  // to lexer
  18317.  
  18318.    Handle EOS or SEMICOLON here.  */
  18319.  
  18320. static ffelexHandler
  18321. ffestb_V0219_ (ffelexToken t)
  18322. {
  18323.   switch (ffelex_token_type (t))
  18324.     {
  18325.     case FFELEX_typeEOS:
  18326.     case FFELEX_typeSEMICOLON:
  18327.       ffesta_confirmed ();
  18328.       if (!ffesta_is_inhibited ())
  18329.     ffestc_V021 ();
  18330.       ffestb_subr_kill_delete_ ();
  18331.       return (ffelexHandler) ffesta_zero (t);
  18332.  
  18333.     default:
  18334.       break;
  18335.     }
  18336.  
  18337.   ffestb_subr_kill_delete_ ();
  18338.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "DELETE", t);
  18339.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18340. }
  18341.  
  18342. /* ffestb_V026 -- Parse a FIND statement
  18343.  
  18344.    return ffestb_V026;    // to lexer
  18345.  
  18346.    Make sure the statement has a valid form for a FIND statement.
  18347.    If it does, implement the statement.     */
  18348.  
  18349. ffelexHandler
  18350. ffestb_V026 (ffelexToken t)
  18351. {
  18352.   ffestpFindIx ix;
  18353.  
  18354.   switch (ffelex_token_type (ffesta_tokens[0]))
  18355.     {
  18356.     case FFELEX_typeNAME:
  18357.       if (ffesta_first_kw != FFESTR_firstFIND)
  18358.     goto bad_0;        /* :::::::::::::::::::: */
  18359.       break;
  18360.  
  18361.     case FFELEX_typeNAMES:
  18362.       if (ffesta_first_kw != FFESTR_firstFIND)
  18363.     goto bad_0;        /* :::::::::::::::::::: */
  18364.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlFIND)
  18365.     goto bad_0;        /* :::::::::::::::::::: */
  18366.       break;
  18367.  
  18368.     default:
  18369.       goto bad_0;        /* :::::::::::::::::::: */
  18370.     }
  18371.  
  18372.   switch (ffelex_token_type (t))
  18373.     {
  18374.     case FFELEX_typeOPEN_PAREN:
  18375.       break;
  18376.  
  18377.     case FFELEX_typeEOS:
  18378.     case FFELEX_typeSEMICOLON:
  18379.     case FFELEX_typeCOMMA:
  18380.     case FFELEX_typeCOLONCOLON:
  18381.       ffesta_confirmed ();    /* Error, but clearly intended. */
  18382.       goto bad_1;        /* :::::::::::::::::::: */
  18383.  
  18384.     default:
  18385.       goto bad_1;        /* :::::::::::::::::::: */
  18386.     }
  18387.  
  18388.   for (ix = 0; ix < FFESTP_findix; ++ix)
  18389.     ffestp_file.find.find_spec[ix].kw_or_val_present = FALSE;
  18390.  
  18391.   return (ffelexHandler) ffestb_V0261_;
  18392.  
  18393. bad_0:                /* :::::::::::::::::::: */
  18394.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", ffesta_tokens[0]);
  18395.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18396.  
  18397. bad_1:                /* :::::::::::::::::::: */
  18398.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
  18399.   return (ffelexHandler) ffelex_swallow_tokens (t,
  18400.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  18401. }
  18402.  
  18403. /* ffestb_V0261_ -- "FIND" OPEN_PAREN
  18404.  
  18405.    return ffestb_V0261_;  // to lexer
  18406.  
  18407.    Handle expr construct (not NAME=expr construct) here.  */
  18408.  
  18409. static ffelexHandler
  18410. ffestb_V0261_ (ffelexToken t)
  18411. {
  18412.   switch (ffelex_token_type (t))
  18413.     {
  18414.     case FFELEX_typeNAME:
  18415.       ffesta_tokens[1] = ffelex_token_use (t);
  18416.       return (ffelexHandler) ffestb_V0262_;
  18417.  
  18418.     default:
  18419.       return (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  18420.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0263_)))
  18421.     (t);
  18422.     }
  18423. }
  18424.  
  18425. /* ffestb_V0262_ -- "FIND" OPEN_PAREN NAME
  18426.  
  18427.    return ffestb_V0262_;  // to lexer
  18428.  
  18429.    If EQUALS here, go to states that handle it.     Else, send NAME and this
  18430.    token thru expression handler.  */
  18431.  
  18432. static ffelexHandler
  18433. ffestb_V0262_ (ffelexToken t)
  18434. {
  18435.   ffelexHandler next;
  18436.   ffelexToken nt;
  18437.  
  18438.   switch (ffelex_token_type (t))
  18439.     {
  18440.     case FFELEX_typeEQUALS:
  18441.       nt = ffesta_tokens[1];
  18442.       next = (ffelexHandler) ffestb_V0264_ (nt);
  18443.       ffelex_token_kill (nt);
  18444.       return (ffelexHandler) (*next) (t);
  18445.  
  18446.     default:
  18447.       next = (ffelexHandler) (*((ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  18448.           FFEEXPR_contextFILENUM, (ffeexprCallback) ffestb_V0263_)))
  18449.     (ffesta_tokens[1]);
  18450.       ffelex_token_kill (ffesta_tokens[1]);
  18451.       return (ffelexHandler) (*next) (t);
  18452.     }
  18453. }
  18454.  
  18455. /* ffestb_V0263_ -- "FIND" OPEN_PAREN expr
  18456.  
  18457.    (ffestb_V0263_)  // to expression handler
  18458.  
  18459.    Handle COMMA or FIND_PAREN here.  */
  18460.  
  18461. static ffelexHandler
  18462. ffestb_V0263_ (ffelexToken ft, ffebld expr, ffelexToken t)
  18463. {
  18464.   switch (ffelex_token_type (t))
  18465.     {
  18466.     case FFELEX_typeCOMMA:
  18467.     case FFELEX_typeCLOSE_PAREN:
  18468.       if (expr == NULL)
  18469.     break;
  18470.       ffestp_file.find.find_spec[FFESTP_findixUNIT].kw_or_val_present
  18471.     = TRUE;
  18472.       ffestp_file.find.find_spec[FFESTP_findixUNIT].kw_present = FALSE;
  18473.       ffestp_file.find.find_spec[FFESTP_findixUNIT].value_present = TRUE;
  18474.       ffestp_file.find.find_spec[FFESTP_findixUNIT].value_is_label
  18475.     = FALSE;
  18476.       ffestp_file.find.find_spec[FFESTP_findixUNIT].value
  18477.     = ffelex_token_use (ft);
  18478.       ffestp_file.find.find_spec[FFESTP_findixUNIT].u.expr = expr;
  18479.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  18480.     return (ffelexHandler) ffestb_V0264_;
  18481.       return (ffelexHandler) ffestb_V0269_;
  18482.  
  18483.     default:
  18484.       break;
  18485.     }
  18486.  
  18487.   ffestb_subr_kill_find_ ();
  18488.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
  18489.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18490. }
  18491.  
  18492. /* ffestb_V0264_ -- "FIND" OPEN_PAREN [external-file-unit COMMA]
  18493.  
  18494.    return ffestb_V0264_;  // to lexer
  18495.  
  18496.    Handle expr construct (not NAME=expr construct) here.  */
  18497.  
  18498. static ffelexHandler
  18499. ffestb_V0264_ (ffelexToken t)
  18500. {
  18501.   ffestrGenio kw;
  18502.  
  18503.   ffestb_local_.find.label = FALSE;
  18504.  
  18505.   switch (ffelex_token_type (t))
  18506.     {
  18507.     case FFELEX_typeNAME:
  18508.       kw = ffestr_genio (t);
  18509.       switch (kw)
  18510.     {
  18511.     case FFESTR_genioERR:
  18512.       ffestb_local_.find.ix = FFESTP_findixERR;
  18513.       ffestb_local_.find.label = TRUE;
  18514.       break;
  18515.  
  18516.     case FFESTR_genioIOSTAT:
  18517.       ffestb_local_.find.ix = FFESTP_findixIOSTAT;
  18518.       ffestb_local_.find.left = TRUE;
  18519.       ffestb_local_.find.context = FFEEXPR_contextFILEINT;
  18520.       break;
  18521.  
  18522.     case FFESTR_genioREC:
  18523.       ffestb_local_.find.ix = FFESTP_findixREC;
  18524.       ffestb_local_.find.left = FALSE;
  18525.       ffestb_local_.find.context = FFEEXPR_contextFILENUM;
  18526.       break;
  18527.  
  18528.     case FFESTR_genioUNIT:
  18529.       ffestb_local_.find.ix = FFESTP_findixUNIT;
  18530.       ffestb_local_.find.left = FALSE;
  18531.       ffestb_local_.find.context = FFEEXPR_contextFILENUM;
  18532.       break;
  18533.  
  18534.     default:
  18535.       goto bad;        /* :::::::::::::::::::: */
  18536.     }
  18537.       if (ffestp_file.find.find_spec[ffestb_local_.find.ix]
  18538.       .kw_or_val_present)
  18539.     break;            /* Can't specify a keyword twice! */
  18540.       ffestp_file.find.find_spec[ffestb_local_.find.ix]
  18541.     .kw_or_val_present = TRUE;
  18542.       ffestp_file.find.find_spec[ffestb_local_.find.ix]
  18543.     .kw_present = TRUE;
  18544.       ffestp_file.find.find_spec[ffestb_local_.find.ix]
  18545.     .value_present = FALSE;
  18546.       ffestp_file.find.find_spec[ffestb_local_.find.ix].value_is_label
  18547.     = ffestb_local_.find.label;
  18548.       ffestp_file.find.find_spec[ffestb_local_.find.ix].kw
  18549.     = ffelex_token_use (t);
  18550.       return (ffelexHandler) ffestb_V0265_;
  18551.  
  18552.     default:
  18553.       break;
  18554.     }
  18555.  
  18556. bad:                /* :::::::::::::::::::: */
  18557.   ffestb_subr_kill_find_ ();
  18558.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
  18559.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18560. }
  18561.  
  18562. /* ffestb_V0265_ -- "FIND" OPEN_PAREN [external-file-unit COMMA] NAME
  18563.  
  18564.    return ffestb_V0265_;  // to lexer
  18565.  
  18566.    Make sure EQUALS here, send next token to expression handler.  */
  18567.  
  18568. static ffelexHandler
  18569. ffestb_V0265_ (ffelexToken t)
  18570. {
  18571.   switch (ffelex_token_type (t))
  18572.     {
  18573.     case FFELEX_typeEQUALS:
  18574.       ffesta_confirmed ();
  18575.       if (ffestb_local_.find.label)
  18576.     return (ffelexHandler) ffestb_V0267_;
  18577.       if (ffestb_local_.find.left)
  18578.     return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  18579.                         ffestb_local_.find.context,
  18580.                         (ffeexprCallback) ffestb_V0266_);
  18581.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  18582.                       ffestb_local_.find.context,
  18583.                       (ffeexprCallback) ffestb_V0266_);
  18584.  
  18585.     default:
  18586.       break;
  18587.     }
  18588.  
  18589.   ffestb_subr_kill_find_ ();
  18590.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
  18591.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18592. }
  18593.  
  18594. /* ffestb_V0266_ -- "FIND" OPEN_PAREN ... NAME EQUALS expr
  18595.  
  18596.    (ffestb_V0266_)  // to expression handler
  18597.  
  18598.    Handle COMMA or CLOSE_PAREN here.  */
  18599.  
  18600. static ffelexHandler
  18601. ffestb_V0266_ (ffelexToken ft, ffebld expr, ffelexToken t)
  18602. {
  18603.   switch (ffelex_token_type (t))
  18604.     {
  18605.     case FFELEX_typeCOMMA:
  18606.     case FFELEX_typeCLOSE_PAREN:
  18607.       if (expr == NULL)
  18608.     break;
  18609.       ffestp_file.find.find_spec[ffestb_local_.find.ix].value_present
  18610.     = TRUE;
  18611.       ffestp_file.find.find_spec[ffestb_local_.find.ix].value
  18612.     = ffelex_token_use (ft);
  18613.       ffestp_file.find.find_spec[ffestb_local_.find.ix].u.expr = expr;
  18614.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  18615.     return (ffelexHandler) ffestb_V0264_;
  18616.       return (ffelexHandler) ffestb_V0269_;
  18617.  
  18618.     default:
  18619.       break;
  18620.     }
  18621.  
  18622.   ffestb_subr_kill_find_ ();
  18623.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
  18624.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18625. }
  18626.  
  18627. /* ffestb_V0267_ -- "FIND" OPEN_PAREN ... NAME EQUALS
  18628.  
  18629.    return ffestb_V0267_;  // to lexer
  18630.  
  18631.    Handle NUMBER for label here.  */
  18632.  
  18633. static ffelexHandler
  18634. ffestb_V0267_ (ffelexToken t)
  18635. {
  18636.   switch (ffelex_token_type (t))
  18637.     {
  18638.     case FFELEX_typeNUMBER:
  18639.       ffestp_file.find.find_spec[ffestb_local_.find.ix].value_present
  18640.     = TRUE;
  18641.       ffestp_file.find.find_spec[ffestb_local_.find.ix].value
  18642.     = ffelex_token_use (t);
  18643.       return (ffelexHandler) ffestb_V0268_;
  18644.  
  18645.     default:
  18646.       break;
  18647.     }
  18648.  
  18649.   ffestb_subr_kill_find_ ();
  18650.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
  18651.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18652. }
  18653.  
  18654. /* ffestb_V0268_ -- "FIND" OPEN_PAREN ... NAME EQUALS NUMBER
  18655.  
  18656.    return ffestb_V0268_;  // to lexer
  18657.  
  18658.    Handle COMMA or CLOSE_PAREN here.  */
  18659.  
  18660. static ffelexHandler
  18661. ffestb_V0268_ (ffelexToken t)
  18662. {
  18663.   switch (ffelex_token_type (t))
  18664.     {
  18665.     case FFELEX_typeCOMMA:
  18666.       return (ffelexHandler) ffestb_V0264_;
  18667.  
  18668.     case FFELEX_typeCLOSE_PAREN:
  18669.       return (ffelexHandler) ffestb_V0269_;
  18670.  
  18671.     default:
  18672.       break;
  18673.     }
  18674.  
  18675.   ffestb_subr_kill_find_ ();
  18676.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
  18677.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18678. }
  18679.  
  18680. /* ffestb_V0269_ -- "FIND" OPEN_PAREN ... CLOSE_PAREN
  18681.  
  18682.    return ffestb_V0269_;  // to lexer
  18683.  
  18684.    Handle EOS or SEMICOLON here.  */
  18685.  
  18686. static ffelexHandler
  18687. ffestb_V0269_ (ffelexToken t)
  18688. {
  18689.   switch (ffelex_token_type (t))
  18690.     {
  18691.     case FFELEX_typeEOS:
  18692.     case FFELEX_typeSEMICOLON:
  18693.       ffesta_confirmed ();
  18694.       if (!ffesta_is_inhibited ())
  18695.     ffestc_V026 ();
  18696.       ffestb_subr_kill_find_ ();
  18697.       return (ffelexHandler) ffesta_zero (t);
  18698.  
  18699.     default:
  18700.       break;
  18701.     }
  18702.  
  18703.   ffestb_subr_kill_find_ ();
  18704.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FIND", t);
  18705.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18706. }
  18707.  
  18708. #endif
  18709. /* ffestb_dimlist -- Parse the ALLOCATABLE/POINTER/TARGET statement
  18710.  
  18711.    return ffestb_dimlist;  // to lexer
  18712.  
  18713.    Make sure the statement has a valid form for the ALLOCATABLE/POINTER/
  18714.    TARGET statement.  If it does, implement the statement.  */
  18715.  
  18716. #if FFESTR_F90
  18717. ffelexHandler
  18718. ffestb_dimlist (ffelexToken t)
  18719. {
  18720.   ffeTokenLength i;
  18721.   char *p;
  18722.   ffelexToken nt;
  18723.   ffelexHandler next;
  18724.  
  18725.   switch (ffelex_token_type (ffesta_tokens[0]))
  18726.     {
  18727.     case FFELEX_typeNAME:
  18728.       switch (ffelex_token_type (t))
  18729.     {
  18730.     case FFELEX_typeCOMMA:
  18731.     case FFELEX_typeEOS:
  18732.     case FFELEX_typeSEMICOLON:
  18733.       ffesta_confirmed ();    /* Error, but clearly intended. */
  18734.       goto bad_1;        /* :::::::::::::::::::: */
  18735.  
  18736.     default:
  18737.       goto bad_1;        /* :::::::::::::::::::: */
  18738.  
  18739.     case FFELEX_typeCOLONCOLON:
  18740.       ffesta_confirmed ();
  18741.       if (!ffesta_is_inhibited ())
  18742.         {
  18743.           switch (ffesta_first_kw)
  18744.         {
  18745.         case FFESTR_firstALLOCATABLE:
  18746.           ffestc_R525_start ();
  18747.           break;
  18748.  
  18749.         case FFESTR_firstPOINTER:
  18750.           ffestc_R526_start ();
  18751.           break;
  18752.  
  18753.         case FFESTR_firstTARGET:
  18754.           ffestc_R527_start ();
  18755.           break;
  18756.  
  18757.         default:
  18758.           assert (FALSE);
  18759.         }
  18760.         }
  18761.       ffestb_local_.dimlist.started = TRUE;
  18762.       return (ffelexHandler) ffestb_dimlist1_;
  18763.  
  18764.     case FFELEX_typeNAME:
  18765.       ffesta_confirmed ();
  18766.       if (!ffesta_is_inhibited ())
  18767.         {
  18768.           switch (ffesta_first_kw)
  18769.         {
  18770.         case FFESTR_firstALLOCATABLE:
  18771.           ffestc_R525_start ();
  18772.           break;
  18773.  
  18774.         case FFESTR_firstPOINTER:
  18775.           ffestc_R526_start ();
  18776.           break;
  18777.  
  18778.         case FFESTR_firstTARGET:
  18779.           ffestc_R527_start ();
  18780.           break;
  18781.  
  18782.         default:
  18783.           assert (FALSE);
  18784.         }
  18785.         }
  18786.       ffestb_local_.dimlist.started = TRUE;
  18787.       return (ffelexHandler) ffestb_dimlist1_ (t);
  18788.     }
  18789.  
  18790.     case FFELEX_typeNAMES:
  18791.       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.dimlist.len);
  18792.       switch (ffelex_token_type (t))
  18793.     {
  18794.     default:
  18795.       goto bad_1;        /* :::::::::::::::::::: */
  18796.  
  18797.     case FFELEX_typeEOS:
  18798.     case FFELEX_typeSEMICOLON:
  18799.     case FFELEX_typeCOMMA:
  18800.       ffesta_confirmed ();
  18801.       if (!ffesrc_is_name_init (*p))
  18802.         goto bad_i;        /* :::::::::::::::::::: */
  18803.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  18804.       if (!ffesta_is_inhibited ())
  18805.         {
  18806.           switch (ffesta_first_kw)
  18807.         {
  18808.         case FFESTR_firstALLOCATABLE:
  18809.           ffestc_R525_start ();
  18810.           break;
  18811.  
  18812.         case FFESTR_firstPOINTER:
  18813.           ffestc_R526_start ();
  18814.           break;
  18815.  
  18816.         case FFESTR_firstTARGET:
  18817.           ffestc_R527_start ();
  18818.           break;
  18819.  
  18820.         default:
  18821.           assert (FALSE);
  18822.         }
  18823.         }
  18824.       ffestb_local_.dimlist.started = TRUE;
  18825.       next = (ffelexHandler) ffestb_dimlist1_ (nt);
  18826.       ffelex_token_kill (nt);
  18827.       return (ffelexHandler) (*next) (t);
  18828.  
  18829.     case FFELEX_typeCOLONCOLON:
  18830.       ffesta_confirmed ();
  18831.       if (*p != '\0')
  18832.         goto bad_i;        /* :::::::::::::::::::: */
  18833.       if (!ffesta_is_inhibited ())
  18834.         {
  18835.           switch (ffesta_first_kw)
  18836.         {
  18837.         case FFESTR_firstALLOCATABLE:
  18838.           ffestc_R525_start ();
  18839.           break;
  18840.  
  18841.         case FFESTR_firstPOINTER:
  18842.           ffestc_R526_start ();
  18843.           break;
  18844.  
  18845.         case FFESTR_firstTARGET:
  18846.           ffestc_R527_start ();
  18847.           break;
  18848.  
  18849.         default:
  18850.           assert (FALSE);
  18851.         }
  18852.         }
  18853.       ffestb_local_.dimlist.started = TRUE;
  18854.       return (ffelexHandler) ffestb_dimlist1_;
  18855.  
  18856.     case FFELEX_typeOPEN_PAREN:
  18857.       if (!ffesrc_is_name_init (*p))
  18858.         goto bad_i;        /* :::::::::::::::::::: */
  18859.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  18860.       ffestb_local_.dimlist.started = FALSE;
  18861.       next = (ffelexHandler) ffestb_dimlist1_ (nt);
  18862.       ffelex_token_kill (nt);
  18863.       return (ffelexHandler) (*next) (t);
  18864.     }
  18865.  
  18866.     default:
  18867.       goto bad_0;        /* :::::::::::::::::::: */
  18868.     }
  18869.  
  18870. bad_0:                /* :::::::::::::::::::: */
  18871.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, ffesta_tokens[0]);
  18872.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18873.  
  18874. bad_1:                /* :::::::::::::::::::: */
  18875.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
  18876.   return (ffelexHandler) ffelex_swallow_tokens (t,
  18877.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  18878.  
  18879. bad_i:                /* :::::::::::::::::::: */
  18880.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, ffesta_tokens[0], i, t);
  18881.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18882. }
  18883.  
  18884. /* ffestb_dimlist1_ -- "ALLOCATABLE/POINTER/TARGET" [COLONCOLON]
  18885.  
  18886.    return ffestb_dimlist1_;  // to lexer
  18887.  
  18888.    Handle NAME.     */
  18889.  
  18890. static ffelexHandler
  18891. ffestb_dimlist1_ (ffelexToken t)
  18892. {
  18893.   switch (ffelex_token_type (t))
  18894.     {
  18895.     case FFELEX_typeNAME:
  18896.       ffesta_tokens[1] = ffelex_token_use (t);
  18897.       return (ffelexHandler) ffestb_dimlist2_;
  18898.  
  18899.     default:
  18900.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
  18901.       break;
  18902.     }
  18903.  
  18904.   if (!ffesta_is_inhibited ())
  18905.     {
  18906.       switch (ffesta_first_kw)
  18907.     {
  18908.     case FFESTR_firstALLOCATABLE:
  18909.       ffestc_R525_finish ();
  18910.       break;
  18911.  
  18912.     case FFESTR_firstPOINTER:
  18913.       ffestc_R526_finish ();
  18914.       break;
  18915.  
  18916.     case FFESTR_firstTARGET:
  18917.       ffestc_R527_finish ();
  18918.       break;
  18919.  
  18920.     default:
  18921.       assert (FALSE);
  18922.     }
  18923.     }
  18924.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  18925. }
  18926.  
  18927. /* ffestb_dimlist2_ -- "ALLOCATABLE/POINTER/TARGET" ... NAME
  18928.  
  18929.    return ffestb_dimlist2_;  // to lexer
  18930.  
  18931.    Handle OPEN_PAREN.  */
  18932.  
  18933. static ffelexHandler
  18934. ffestb_dimlist2_ (ffelexToken t)
  18935. {
  18936.   switch (ffelex_token_type (t))
  18937.     {
  18938.     case FFELEX_typeOPEN_PAREN:
  18939.       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
  18940.       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_dimlist3_;
  18941.       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
  18942.       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLIST;
  18943. #ifdef FFECOM_dimensionsMAX
  18944.       ffestb_subrargs_.dim_list.ndims = 0;
  18945. #endif
  18946.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  18947.         FFEEXPR_contextDIMLIST, (ffeexprCallback) ffestb_subr_dimlist_);
  18948.  
  18949.     case FFELEX_typeCOMMA:
  18950.       ffesta_confirmed ();
  18951.       if (!ffesta_is_inhibited ())
  18952.     {
  18953.       if (!ffestb_local_.dimlist.started)
  18954.         {
  18955.           switch (ffesta_first_kw)
  18956.         {
  18957.         case FFESTR_firstALLOCATABLE:
  18958.           ffestc_R525_start ();
  18959.           break;
  18960.  
  18961.         case FFESTR_firstPOINTER:
  18962.           ffestc_R526_start ();
  18963.           break;
  18964.  
  18965.         case FFESTR_firstTARGET:
  18966.           ffestc_R527_start ();
  18967.           break;
  18968.  
  18969.         default:
  18970.           assert (FALSE);
  18971.         }
  18972.           ffestb_local_.dimlist.started = TRUE;
  18973.         }
  18974.       switch (ffesta_first_kw)
  18975.         {
  18976.         case FFESTR_firstALLOCATABLE:
  18977.           ffestc_R525_item (ffesta_tokens[1], NULL);
  18978.           break;
  18979.  
  18980.         case FFESTR_firstPOINTER:
  18981.           ffestc_R526_item (ffesta_tokens[1], NULL);
  18982.           break;
  18983.  
  18984.         case FFESTR_firstTARGET:
  18985.           ffestc_R527_item (ffesta_tokens[1], NULL);
  18986.           break;
  18987.  
  18988.         default:
  18989.           assert (FALSE);
  18990.         }
  18991.     }
  18992.       ffelex_token_kill (ffesta_tokens[1]);
  18993.       return (ffelexHandler) ffestb_dimlist4_;
  18994.  
  18995.     case FFELEX_typeEOS:
  18996.     case FFELEX_typeSEMICOLON:
  18997.       ffesta_confirmed ();
  18998.       if (!ffesta_is_inhibited ())
  18999.     {
  19000.       if (!ffestb_local_.dimlist.started)
  19001.         {
  19002.           switch (ffesta_first_kw)
  19003.         {
  19004.         case FFESTR_firstALLOCATABLE:
  19005.           ffestc_R525_start ();
  19006.           break;
  19007.  
  19008.         case FFESTR_firstPOINTER:
  19009.           ffestc_R526_start ();
  19010.           break;
  19011.  
  19012.         case FFESTR_firstTARGET:
  19013.           ffestc_R527_start ();
  19014.           break;
  19015.  
  19016.         default:
  19017.           assert (FALSE);
  19018.         }
  19019.         }
  19020.       switch (ffesta_first_kw)
  19021.         {
  19022.         case FFESTR_firstALLOCATABLE:
  19023.           ffestc_R525_item (ffesta_tokens[1], NULL);
  19024.           ffestc_R525_finish ();
  19025.           break;
  19026.  
  19027.         case FFESTR_firstPOINTER:
  19028.           ffestc_R526_item (ffesta_tokens[1], NULL);
  19029.           ffestc_R526_finish ();
  19030.           break;
  19031.  
  19032.         case FFESTR_firstTARGET:
  19033.           ffestc_R527_item (ffesta_tokens[1], NULL);
  19034.           ffestc_R527_finish ();
  19035.           break;
  19036.  
  19037.         default:
  19038.           assert (FALSE);
  19039.         }
  19040.     }
  19041.       ffelex_token_kill (ffesta_tokens[1]);
  19042.       return (ffelexHandler) ffesta_zero (t);
  19043.  
  19044.     default:
  19045.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
  19046.       break;
  19047.     }
  19048.  
  19049.   if (!ffesta_is_inhibited ())
  19050.     {
  19051.       switch (ffesta_first_kw)
  19052.     {
  19053.     case FFESTR_firstALLOCATABLE:
  19054.       ffestc_R525_finish ();
  19055.       break;
  19056.  
  19057.     case FFESTR_firstPOINTER:
  19058.       ffestc_R526_finish ();
  19059.       break;
  19060.  
  19061.     case FFESTR_firstTARGET:
  19062.       ffestc_R527_finish ();
  19063.       break;
  19064.  
  19065.     default:
  19066.       assert (FALSE);
  19067.     }
  19068.     }
  19069.   ffelex_token_kill (ffesta_tokens[1]);
  19070.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19071. }
  19072.  
  19073. /* ffestb_dimlist3_ -- "ALLOCATABLE/POINTER/TARGET" ... NAME OPEN_PAREN
  19074.                dimlist CLOSE_PAREN
  19075.  
  19076.    return ffestb_dimlist3_;  // to lexer
  19077.  
  19078.    Handle COMMA or EOS/SEMICOLON.  */
  19079.  
  19080. static ffelexHandler
  19081. ffestb_dimlist3_ (ffelexToken t)
  19082. {
  19083.   if (!ffestb_subrargs_.dim_list.ok)
  19084.     goto bad;            /* :::::::::::::::::::: */
  19085.  
  19086.   switch (ffelex_token_type (t))
  19087.     {
  19088.     case FFELEX_typeCOMMA:
  19089.       ffesta_confirmed ();
  19090.       if (!ffesta_is_inhibited ())
  19091.     {
  19092.       if (!ffestb_local_.dimlist.started)
  19093.         {
  19094.           switch (ffesta_first_kw)
  19095.         {
  19096.         case FFESTR_firstALLOCATABLE:
  19097.           ffestc_R525_start ();
  19098.           break;
  19099.  
  19100.         case FFESTR_firstPOINTER:
  19101.           ffestc_R526_start ();
  19102.           break;
  19103.  
  19104.         case FFESTR_firstTARGET:
  19105.           ffestc_R527_start ();
  19106.           break;
  19107.  
  19108.         default:
  19109.           assert (FALSE);
  19110.         }
  19111.           ffestb_local_.dimlist.started = TRUE;
  19112.         }
  19113.       switch (ffesta_first_kw)
  19114.         {
  19115.         case FFESTR_firstALLOCATABLE:
  19116.           ffestc_R525_item (ffesta_tokens[1],
  19117.                 ffestb_subrargs_.dim_list.dims);
  19118.           break;
  19119.  
  19120.         case FFESTR_firstPOINTER:
  19121.           ffestc_R526_item (ffesta_tokens[1],
  19122.                 ffestb_subrargs_.dim_list.dims);
  19123.           break;
  19124.  
  19125.         case FFESTR_firstTARGET:
  19126.           ffestc_R527_item (ffesta_tokens[1],
  19127.                 ffestb_subrargs_.dim_list.dims);
  19128.           break;
  19129.  
  19130.         default:
  19131.           assert (FALSE);
  19132.         }
  19133.     }
  19134.       ffelex_token_kill (ffesta_tokens[1]);
  19135.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  19136.       return (ffelexHandler) ffestb_dimlist4_;
  19137.  
  19138.     case FFELEX_typeEOS:
  19139.     case FFELEX_typeSEMICOLON:
  19140.       ffesta_confirmed ();
  19141.       if (!ffesta_is_inhibited ())
  19142.     {
  19143.       if (!ffestb_local_.dimlist.started)
  19144.         {
  19145.           switch (ffesta_first_kw)
  19146.         {
  19147.         case FFESTR_firstALLOCATABLE:
  19148.           ffestc_R525_start ();
  19149.           break;
  19150.  
  19151.         case FFESTR_firstPOINTER:
  19152.           ffestc_R526_start ();
  19153.           break;
  19154.  
  19155.         case FFESTR_firstTARGET:
  19156.           ffestc_R527_start ();
  19157.           break;
  19158.  
  19159.         default:
  19160.           assert (FALSE);
  19161.         }
  19162.         }
  19163.       switch (ffesta_first_kw)
  19164.         {
  19165.         case FFESTR_firstALLOCATABLE:
  19166.           ffestc_R525_item (ffesta_tokens[1],
  19167.                 ffestb_subrargs_.dim_list.dims);
  19168.           ffestc_R525_finish ();
  19169.           break;
  19170.  
  19171.         case FFESTR_firstPOINTER:
  19172.           ffestc_R526_item (ffesta_tokens[1],
  19173.                 ffestb_subrargs_.dim_list.dims);
  19174.           ffestc_R526_finish ();
  19175.           break;
  19176.  
  19177.         case FFESTR_firstTARGET:
  19178.           ffestc_R527_item (ffesta_tokens[1],
  19179.                 ffestb_subrargs_.dim_list.dims);
  19180.           ffestc_R527_finish ();
  19181.           break;
  19182.  
  19183.         default:
  19184.           assert (FALSE);
  19185.         }
  19186.     }
  19187.       ffelex_token_kill (ffesta_tokens[1]);
  19188.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  19189.       return (ffelexHandler) ffesta_zero (t);
  19190.  
  19191.     default:
  19192.       break;
  19193.     }
  19194.  
  19195. bad:                /* :::::::::::::::::::: */
  19196.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
  19197.   if (ffestb_local_.dimlist.started && !ffesta_is_inhibited ())
  19198.     {
  19199.       switch (ffesta_first_kw)
  19200.     {
  19201.     case FFESTR_firstALLOCATABLE:
  19202.       ffestc_R525_finish ();
  19203.       break;
  19204.  
  19205.     case FFESTR_firstPOINTER:
  19206.       ffestc_R526_finish ();
  19207.       break;
  19208.  
  19209.     case FFESTR_firstTARGET:
  19210.       ffestc_R527_finish ();
  19211.       break;
  19212.  
  19213.     default:
  19214.       assert (FALSE);
  19215.     }
  19216.     }
  19217.   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  19218.   ffelex_token_kill (ffesta_tokens[1]);
  19219.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19220. }
  19221.  
  19222. /* ffestb_dimlist4_ -- "ALLOCATABLE/POINTER/TARGET" ... COMMA
  19223.  
  19224.    return ffestb_dimlist4_;  // to lexer
  19225.  
  19226.    Make sure we don't have EOS or SEMICOLON.  */
  19227.  
  19228. static ffelexHandler
  19229. ffestb_dimlist4_ (ffelexToken t)
  19230. {
  19231.   switch (ffelex_token_type (t))
  19232.     {
  19233.     case FFELEX_typeEOS:
  19234.     case FFELEX_typeSEMICOLON:
  19235.       if (!ffesta_is_inhibited ())
  19236.     {
  19237.       switch (ffesta_first_kw)
  19238.         {
  19239.         case FFESTR_firstALLOCATABLE:
  19240.           ffestc_R525_finish ();
  19241.           break;
  19242.  
  19243.         case FFESTR_firstPOINTER:
  19244.           ffestc_R526_finish ();
  19245.           break;
  19246.  
  19247.         case FFESTR_firstTARGET:
  19248.           ffestc_R527_finish ();
  19249.           break;
  19250.  
  19251.         default:
  19252.           assert (FALSE);
  19253.         }
  19254.     }
  19255.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dimlist.badname, t);
  19256.       return (ffelexHandler) ffesta_zero (t);
  19257.  
  19258.     default:
  19259.       return (ffelexHandler) ffestb_dimlist1_ (t);
  19260.     }
  19261. }
  19262.  
  19263. #endif
  19264. /* ffestb_dummy -- Parse an ENTRY/FUNCTION/SUBROUTINE statement
  19265.  
  19266.    return ffestb_dummy;     // to lexer
  19267.  
  19268.    Make sure the statement has a valid form for an ENTRY/FUNCTION/SUBROUTINE
  19269.    statement.  If it does, implement the statement.  */
  19270.  
  19271. ffelexHandler
  19272. ffestb_dummy (ffelexToken t)
  19273. {
  19274.   ffeTokenLength i;
  19275.   char *p;
  19276.  
  19277.   switch (ffelex_token_type (ffesta_tokens[0]))
  19278.     {
  19279.     case FFELEX_typeNAME:
  19280.       switch (ffelex_token_type (t))
  19281.     {
  19282.     case FFELEX_typeEOS:
  19283.     case FFELEX_typeSEMICOLON:
  19284.     case FFELEX_typeCOMMA:
  19285.     case FFELEX_typeCOLONCOLON:
  19286.       ffesta_confirmed ();    /* Error, but clearly intended. */
  19287.       goto bad_1;        /* :::::::::::::::::::: */
  19288.  
  19289.     default:
  19290.       goto bad_1;        /* :::::::::::::::::::: */
  19291.  
  19292.     case FFELEX_typeNAME:
  19293.       break;
  19294.     }
  19295.  
  19296.       ffesta_confirmed ();
  19297.       ffesta_tokens[1] = ffelex_token_use (t);
  19298.       ffestb_local_.decl.recursive = NULL;
  19299.       ffestb_local_.dummy.badname = ffestb_args.dummy.badname;
  19300.       ffestb_local_.dummy.is_subr = ffestb_args.dummy.is_subr;
  19301.       ffestb_local_.dummy.first_kw = ffesta_first_kw;
  19302.       return (ffelexHandler) ffestb_dummy1_;
  19303.  
  19304.     case FFELEX_typeNAMES:
  19305.       switch (ffelex_token_type (t))
  19306.     {
  19307.     case FFELEX_typeCOMMA:
  19308.     case FFELEX_typeCOLONCOLON:
  19309.       ffesta_confirmed ();    /* Error, but clearly intended. */
  19310.       goto bad_1;        /* :::::::::::::::::::: */
  19311.  
  19312.     default:
  19313.       goto bad_1;        /* :::::::::::::::::::: */
  19314.  
  19315.     case FFELEX_typeEOS:
  19316.     case FFELEX_typeSEMICOLON:
  19317.       ffesta_confirmed ();
  19318.       break;
  19319.  
  19320.     case FFELEX_typeOPEN_PAREN:
  19321.       break;
  19322.     }
  19323.       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.dummy.len);
  19324.       if (!ffesrc_is_name_init (*p))
  19325.     goto bad_i;        /* :::::::::::::::::::: */
  19326.       ffesta_tokens[1]
  19327.     = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  19328.       ffestb_local_.decl.recursive = NULL;
  19329.       ffestb_local_.dummy.badname = ffestb_args.dummy.badname;
  19330.       ffestb_local_.dummy.is_subr = ffestb_args.dummy.is_subr;
  19331.       ffestb_local_.dummy.first_kw = ffesta_first_kw;
  19332.       return (ffelexHandler) ffestb_dummy1_ (t);
  19333.  
  19334.     default:
  19335.       goto bad_0;        /* :::::::::::::::::::: */
  19336.     }
  19337.  
  19338. bad_0:                /* :::::::::::::::::::: */
  19339.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, ffesta_tokens[0]);
  19340.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19341.  
  19342. bad_1:                /* :::::::::::::::::::: */
  19343.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, t);
  19344.   return (ffelexHandler) ffelex_swallow_tokens (t,
  19345.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  19346.  
  19347. bad_i:                /* :::::::::::::::::::: */
  19348.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.dummy.badname, ffesta_tokens[0], i, t);
  19349.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19350. }
  19351.  
  19352. /* ffestb_dummy1_ -- "ENTRY/FUNCTION/SUBROUTINE" NAME
  19353.  
  19354.    return ffestb_dummy1_;  // to lexer
  19355.  
  19356.    Make sure the next token is an EOS, SEMICOLON, or OPEN_PAREN.  In the
  19357.    former case, just implement a null arg list, else get the arg list and
  19358.    then implement.  */
  19359.  
  19360. static ffelexHandler
  19361. ffestb_dummy1_ (ffelexToken t)
  19362. {
  19363.   switch (ffelex_token_type (t))
  19364.     {
  19365.     case FFELEX_typeEOS:
  19366.     case FFELEX_typeSEMICOLON:
  19367.       if (ffestb_local_.dummy.first_kw == FFESTR_firstFUNCTION)
  19368.     {
  19369.       ffesta_confirmed ();    /* Later, not if typename w/o RECURSIVE. */
  19370.       break;        /* Produce an error message, need that open
  19371.                    paren. */
  19372.     }
  19373.       ffesta_confirmed ();
  19374.       if (!ffesta_is_inhibited ())
  19375.     {            /* Pretend as though we got a truly NULL
  19376.                    list. */
  19377.       ffestb_subrargs_.name_list.args = NULL;
  19378.       ffestb_subrargs_.name_list.ok = TRUE;
  19379.       ffestb_subrargs_.name_list.close_paren = ffelex_token_use (t);
  19380.       return (ffelexHandler) ffestb_dummy2_ (t);
  19381.     }
  19382.       if (ffestb_local_.decl.recursive != NULL)
  19383.     ffelex_token_kill (ffestb_local_.decl.recursive);
  19384.       ffelex_token_kill (ffesta_tokens[1]);
  19385.       return (ffelexHandler) ffesta_zero (t);
  19386.  
  19387.     case FFELEX_typeOPEN_PAREN:
  19388.       ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
  19389.       ffestb_subrargs_.name_list.handler = (ffelexHandler) ffestb_dummy2_;
  19390.       ffestb_subrargs_.name_list.is_subr = ffestb_local_.dummy.is_subr;
  19391.       ffestb_subrargs_.name_list.names = FALSE;
  19392.       return (ffelexHandler) ffestb_subr_name_list_;
  19393.  
  19394.     default:
  19395.       break;
  19396.     }
  19397.  
  19398.   if (ffestb_local_.decl.recursive != NULL)
  19399.     ffelex_token_kill (ffestb_local_.decl.recursive);
  19400.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_local_.dummy.badname, t);
  19401.   ffelex_token_kill (ffesta_tokens[1]);
  19402.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19403. }
  19404.  
  19405. /* ffestb_dummy2_ -- <dummy-keyword> NAME OPEN_PAREN arg-list CLOSE_PAREN
  19406.  
  19407.    return ffestb_dummy2_;  // to lexer
  19408.  
  19409.    Make sure the statement has a valid form for a dummy-def statement.    If it
  19410.    does, implement the statement.  */
  19411.  
  19412. static ffelexHandler
  19413. ffestb_dummy2_ (ffelexToken t)
  19414. {
  19415.   if (!ffestb_subrargs_.name_list.ok)
  19416.     goto bad;            /* :::::::::::::::::::: */
  19417.  
  19418.   switch (ffelex_token_type (t))
  19419.     {
  19420.     case FFELEX_typeEOS:
  19421.     case FFELEX_typeSEMICOLON:
  19422.       ffesta_confirmed ();
  19423.       if (!ffesta_is_inhibited ())
  19424.     {
  19425.       switch (ffestb_local_.dummy.first_kw)
  19426.         {
  19427.         case FFESTR_firstFUNCTION:
  19428.           ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
  19429.             ffestb_subrargs_.name_list.close_paren, FFESTP_typeNone,
  19430.         NULL, NULL, NULL, NULL, ffestb_local_.decl.recursive, NULL);
  19431.           break;
  19432.  
  19433.         case FFESTR_firstSUBROUTINE:
  19434.           ffestc_R1223 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
  19435.                 ffestb_subrargs_.name_list.close_paren,
  19436.                 ffestb_local_.decl.recursive);
  19437.           break;
  19438.  
  19439.         case FFESTR_firstENTRY:
  19440.           ffestc_R1226 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
  19441.                 ffestb_subrargs_.name_list.close_paren);
  19442.           break;
  19443.  
  19444.         default:
  19445.           assert (FALSE);
  19446.         }
  19447.     }
  19448.       ffelex_token_kill (ffesta_tokens[1]);
  19449.       if (ffestb_local_.decl.recursive != NULL)
  19450.     ffelex_token_kill (ffestb_local_.decl.recursive);
  19451.       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
  19452.       if (ffestb_subrargs_.name_list.args != NULL)
  19453.     ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
  19454.       return (ffelexHandler) ffesta_zero (t);
  19455.  
  19456.     case FFELEX_typeNAME:
  19457.       ffesta_confirmed ();
  19458.       if ((ffestb_local_.dummy.first_kw != FFESTR_firstFUNCTION)
  19459.       || (ffestr_other (t) != FFESTR_otherRESULT))
  19460.     break;
  19461.       ffestb_local_.decl.type = FFESTP_typeNone;
  19462.       ffestb_local_.decl.kind = NULL;
  19463.       ffestb_local_.decl.kindt = NULL;
  19464.       ffestb_local_.decl.len = NULL;
  19465.       ffestb_local_.decl.lent = NULL;
  19466.       return (ffelexHandler) ffestb_decl_funcname_6_;
  19467.  
  19468.     default:
  19469.       break;
  19470.     }
  19471.  
  19472. bad:                /* :::::::::::::::::::: */
  19473.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_local_.dummy.badname, t);
  19474.   ffelex_token_kill (ffesta_tokens[1]);
  19475.   if (ffestb_local_.decl.recursive != NULL)
  19476.     ffelex_token_kill (ffestb_local_.decl.recursive);
  19477.   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
  19478.   if (ffestb_subrargs_.name_list.args != NULL)
  19479.     ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
  19480.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19481. }
  19482.  
  19483. /* ffestb_R524 -- Parse the DIMENSION statement
  19484.  
  19485.    return ffestb_R524;    // to lexer
  19486.  
  19487.    Make sure the statement has a valid form for the DIMENSION statement.  If
  19488.    it does, implement the statement.  */
  19489.  
  19490. ffelexHandler
  19491. ffestb_R524 (ffelexToken t)
  19492. {
  19493.   ffeTokenLength i;
  19494.   char *p;
  19495.   ffelexToken nt;
  19496.   ffelexHandler next;
  19497.  
  19498.   switch (ffelex_token_type (ffesta_tokens[0]))
  19499.     {
  19500.     case FFELEX_typeNAME:
  19501.       switch (ffelex_token_type (t))
  19502.     {
  19503.     case FFELEX_typeCOMMA:
  19504.     case FFELEX_typeCOLONCOLON:
  19505.     case FFELEX_typeEOS:
  19506.     case FFELEX_typeSEMICOLON:
  19507.       ffesta_confirmed ();    /* Error, but clearly intended. */
  19508.       goto bad_1;        /* :::::::::::::::::::: */
  19509.  
  19510.     default:
  19511.       goto bad_1;        /* :::::::::::::::::::: */
  19512.  
  19513.     case FFELEX_typeNAME:
  19514.       ffesta_confirmed ();
  19515.       if (!ffesta_is_inhibited ())
  19516.         ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
  19517.       ffestb_local_.dimension.started = TRUE;
  19518.       return (ffelexHandler) ffestb_R5241_ (t);
  19519.     }
  19520.  
  19521.     case FFELEX_typeNAMES:
  19522.       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.R524.len);
  19523.       switch (ffelex_token_type (t))
  19524.     {
  19525.     default:
  19526.       goto bad_1;        /* :::::::::::::::::::: */
  19527.  
  19528.     case FFELEX_typeEOS:
  19529.     case FFELEX_typeSEMICOLON:
  19530.     case FFELEX_typeCOMMA:
  19531.     case FFELEX_typeCOLONCOLON:
  19532.       ffesta_confirmed ();
  19533.       goto bad_1;        /* :::::::::::::::::::: */
  19534.  
  19535.     case FFELEX_typeOPEN_PAREN:
  19536.       break;
  19537.     }
  19538.  
  19539.       /* Here, we have at least one char after "DIMENSION" and t is
  19540.          OPEN_PAREN. */
  19541.  
  19542.       if (!ffesrc_is_name_init (*p))
  19543.     goto bad_i;        /* :::::::::::::::::::: */
  19544.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  19545.       ffestb_local_.dimension.started = FALSE;
  19546.       next = (ffelexHandler) ffestb_R5241_ (nt);
  19547.       ffelex_token_kill (nt);
  19548.       return (ffelexHandler) (*next) (t);
  19549.  
  19550.     default:
  19551.       goto bad_0;        /* :::::::::::::::::::: */
  19552.     }
  19553.  
  19554. bad_0:                /* :::::::::::::::::::: */
  19555.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, ffesta_tokens[0]);
  19556.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19557.  
  19558. bad_1:                /* :::::::::::::::::::: */
  19559.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
  19560.   return (ffelexHandler) ffelex_swallow_tokens (t,
  19561.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  19562.  
  19563. bad_i:                /* :::::::::::::::::::: */
  19564.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, ffesta_tokens[0], i, t);
  19565.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19566. }
  19567.  
  19568. /* ffestb_R5241_ -- "DIMENSION"
  19569.  
  19570.    return ffestb_R5241_;  // to lexer
  19571.  
  19572.    Handle NAME.     */
  19573.  
  19574. static ffelexHandler
  19575. ffestb_R5241_ (ffelexToken t)
  19576. {
  19577.   switch (ffelex_token_type (t))
  19578.     {
  19579.     case FFELEX_typeNAME:
  19580.       ffesta_tokens[1] = ffelex_token_use (t);
  19581.       return (ffelexHandler) ffestb_R5242_;
  19582.  
  19583.     default:
  19584.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
  19585.       break;
  19586.     }
  19587.  
  19588.   if (!ffesta_is_inhibited ())
  19589.     ffestc_R524_finish ();
  19590.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19591. }
  19592.  
  19593. /* ffestb_R5242_ -- "DIMENSION" ... NAME
  19594.  
  19595.    return ffestb_R5242_;  // to lexer
  19596.  
  19597.    Handle OPEN_PAREN.  */
  19598.  
  19599. static ffelexHandler
  19600. ffestb_R5242_ (ffelexToken t)
  19601. {
  19602.   switch (ffelex_token_type (t))
  19603.     {
  19604.     case FFELEX_typeOPEN_PAREN:
  19605.       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
  19606.       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_R5243_;
  19607.       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
  19608.       ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
  19609.     ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
  19610. #ifdef FFECOM_dimensionsMAX
  19611.       ffestb_subrargs_.dim_list.ndims = 0;
  19612. #endif
  19613.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  19614.                       ffestb_subrargs_.dim_list.ctx,
  19615.                     (ffeexprCallback) ffestb_subr_dimlist_);
  19616.  
  19617.     default:
  19618.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
  19619.       break;
  19620.     }
  19621.  
  19622.   if (!ffesta_is_inhibited ())
  19623.     ffestc_R524_finish ();
  19624.   ffelex_token_kill (ffesta_tokens[1]);
  19625.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19626. }
  19627.  
  19628. /* ffestb_R5243_ -- "DIMENSION" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
  19629.  
  19630.    return ffestb_R5243_;  // to lexer
  19631.  
  19632.    Handle COMMA or EOS/SEMICOLON.  */
  19633.  
  19634. static ffelexHandler
  19635. ffestb_R5243_ (ffelexToken t)
  19636. {
  19637.   if (!ffestb_subrargs_.dim_list.ok)
  19638.     goto bad;            /* :::::::::::::::::::: */
  19639.  
  19640.   switch (ffelex_token_type (t))
  19641.     {
  19642.     case FFELEX_typeCOMMA:
  19643.       ffesta_confirmed ();
  19644.       if (!ffesta_is_inhibited ())
  19645.     {
  19646.       if (!ffestb_local_.dimension.started)
  19647.         {
  19648.           ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
  19649.           ffestb_local_.dimension.started = TRUE;
  19650.         }
  19651.       ffestc_R524_item (ffesta_tokens[1],
  19652.                 ffestb_subrargs_.dim_list.dims);
  19653.     }
  19654.       ffelex_token_kill (ffesta_tokens[1]);
  19655.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  19656.       return (ffelexHandler) ffestb_R5244_;
  19657.  
  19658.     case FFELEX_typeEOS:
  19659.     case FFELEX_typeSEMICOLON:
  19660.       ffesta_confirmed ();
  19661.       if (!ffesta_is_inhibited ())
  19662.     {
  19663.       if (!ffestb_local_.dimension.started)
  19664.         {
  19665.           ffestc_R524_start (ffesta_first_kw == FFESTR_firstVIRTUAL);
  19666.           ffestb_local_.dimension.started = TRUE;
  19667.         }
  19668.       ffestc_R524_item (ffesta_tokens[1],
  19669.                 ffestb_subrargs_.dim_list.dims);
  19670.       ffestc_R524_finish ();
  19671.     }
  19672.       ffelex_token_kill (ffesta_tokens[1]);
  19673.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  19674.       return (ffelexHandler) ffesta_zero (t);
  19675.  
  19676.     default:
  19677.       break;
  19678.     }
  19679.  
  19680. bad:                /* :::::::::::::::::::: */
  19681.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
  19682.   if (ffestb_local_.dimension.started && !ffesta_is_inhibited ())
  19683.     ffestc_R524_finish ();
  19684.   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  19685.   ffelex_token_kill (ffesta_tokens[1]);
  19686.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19687. }
  19688.  
  19689. /* ffestb_R5244_ -- "DIMENSION" ... COMMA
  19690.  
  19691.    return ffestb_R5244_;  // to lexer
  19692.  
  19693.    Make sure we don't have EOS or SEMICOLON.  */
  19694.  
  19695. static ffelexHandler
  19696. ffestb_R5244_ (ffelexToken t)
  19697. {
  19698.   switch (ffelex_token_type (t))
  19699.     {
  19700.     case FFELEX_typeEOS:
  19701.     case FFELEX_typeSEMICOLON:
  19702.       if (!ffesta_is_inhibited ())
  19703.     ffestc_R524_finish ();
  19704.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, ffestb_args.R524.badname, t);
  19705.       return (ffelexHandler) ffesta_zero (t);
  19706.  
  19707.     default:
  19708.       return (ffelexHandler) ffestb_R5241_ (t);
  19709.     }
  19710. }
  19711.  
  19712. /* ffestb_R547 -- Parse the COMMON statement
  19713.  
  19714.    return ffestb_R547;    // to lexer
  19715.  
  19716.    Make sure the statement has a valid form for the COMMON statement.  If it
  19717.    does, implement the statement.  */
  19718.  
  19719. ffelexHandler
  19720. ffestb_R547 (ffelexToken t)
  19721. {
  19722.   ffeTokenLength i;
  19723.   char *p;
  19724.   ffelexToken nt;
  19725.   ffelexHandler next;
  19726.  
  19727.   switch (ffelex_token_type (ffesta_tokens[0]))
  19728.     {
  19729.     case FFELEX_typeNAME:
  19730.       if (ffesta_first_kw != FFESTR_firstCOMMON)
  19731.     goto bad_0;        /* :::::::::::::::::::: */
  19732.       switch (ffelex_token_type (t))
  19733.     {
  19734.     case FFELEX_typeCOMMA:
  19735.     case FFELEX_typeCOLONCOLON:
  19736.     case FFELEX_typeEOS:
  19737.     case FFELEX_typeSEMICOLON:
  19738.       ffesta_confirmed ();    /* Error, but clearly intended. */
  19739.       goto bad_1;        /* :::::::::::::::::::: */
  19740.  
  19741.     default:
  19742.       goto bad_1;        /* :::::::::::::::::::: */
  19743.  
  19744.     case FFELEX_typeNAME:
  19745.     case FFELEX_typeSLASH:
  19746.     case FFELEX_typeCONCAT:
  19747.       ffesta_confirmed ();
  19748.       if (!ffesta_is_inhibited ())
  19749.         ffestc_R547_start ();
  19750.       ffestb_local_.common.started = TRUE;
  19751.       return (ffelexHandler) ffestb_R5471_ (t);
  19752.     }
  19753.  
  19754.     case FFELEX_typeNAMES:
  19755.       if (ffesta_first_kw != FFESTR_firstCOMMON)
  19756.     goto bad_0;        /* :::::::::::::::::::: */
  19757.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCOMMON);
  19758.       switch (ffelex_token_type (t))
  19759.     {
  19760.     default:
  19761.       goto bad_1;        /* :::::::::::::::::::: */
  19762.  
  19763.     case FFELEX_typeEOS:
  19764.     case FFELEX_typeSEMICOLON:
  19765.     case FFELEX_typeCOMMA:
  19766.     case FFELEX_typeCOLONCOLON:
  19767.       ffesta_confirmed ();
  19768.       break;
  19769.  
  19770.     case FFELEX_typeSLASH:
  19771.     case FFELEX_typeCONCAT:
  19772.       ffesta_confirmed ();
  19773.       if (*p != '\0')
  19774.         break;
  19775.       if (!ffesta_is_inhibited ())
  19776.         ffestc_R547_start ();
  19777.       ffestb_local_.common.started = TRUE;
  19778.       return (ffelexHandler) ffestb_R5471_ (t);
  19779.  
  19780.     case FFELEX_typeOPEN_PAREN:
  19781.       break;
  19782.     }
  19783.  
  19784.       /* Here, we have at least one char after "COMMON" and t is COMMA,
  19785.          EOS/SEMICOLON, OPEN_PAREN, SLASH, or CONCAT. */
  19786.  
  19787.       if (!ffesrc_is_name_init (*p))
  19788.     goto bad_i;        /* :::::::::::::::::::: */
  19789.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  19790.       if (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN)
  19791.     ffestb_local_.common.started = FALSE;
  19792.       else
  19793.     {
  19794.       if (!ffesta_is_inhibited ())
  19795.         ffestc_R547_start ();
  19796.       ffestb_local_.common.started = TRUE;
  19797.     }
  19798.       next = (ffelexHandler) ffestb_R5471_ (nt);
  19799.       ffelex_token_kill (nt);
  19800.       return (ffelexHandler) (*next) (t);
  19801.  
  19802.     default:
  19803.       goto bad_0;        /* :::::::::::::::::::: */
  19804.     }
  19805.  
  19806. bad_0:                /* :::::::::::::::::::: */
  19807.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", ffesta_tokens[0]);
  19808.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19809.  
  19810. bad_1:                /* :::::::::::::::::::: */
  19811.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
  19812.   return (ffelexHandler) ffelex_swallow_tokens (t,
  19813.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  19814.  
  19815. bad_i:                /* :::::::::::::::::::: */
  19816.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "COMMON", ffesta_tokens[0], i, t);
  19817.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19818. }
  19819.  
  19820. /* ffestb_R5471_ -- "COMMON"
  19821.  
  19822.    return ffestb_R5471_;  // to lexer
  19823.  
  19824.    Handle NAME, SLASH, or CONCAT.  */
  19825.  
  19826. static ffelexHandler
  19827. ffestb_R5471_ (ffelexToken t)
  19828. {
  19829.   switch (ffelex_token_type (t))
  19830.     {
  19831.     case FFELEX_typeNAME:
  19832.       return (ffelexHandler) ffestb_R5474_ (t);
  19833.  
  19834.     case FFELEX_typeSLASH:
  19835.       return (ffelexHandler) ffestb_R5472_;
  19836.  
  19837.     case FFELEX_typeCONCAT:
  19838.       if (!ffesta_is_inhibited ())
  19839.     ffestc_R547_item_cblock (NULL);
  19840.       return (ffelexHandler) ffestb_R5474_;
  19841.  
  19842.     default:
  19843.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
  19844.       break;
  19845.     }
  19846.  
  19847.   if (!ffesta_is_inhibited ())
  19848.     ffestc_R547_finish ();
  19849.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19850. }
  19851.  
  19852. /* ffestb_R5472_ -- "COMMON" SLASH
  19853.  
  19854.    return ffestb_R5472_;  // to lexer
  19855.  
  19856.    Handle NAME.     */
  19857.  
  19858. static ffelexHandler
  19859. ffestb_R5472_ (ffelexToken t)
  19860. {
  19861.   switch (ffelex_token_type (t))
  19862.     {
  19863.     case FFELEX_typeNAME:
  19864.       ffesta_tokens[1] = ffelex_token_use (t);
  19865.       return (ffelexHandler) ffestb_R5473_;
  19866.  
  19867.     case FFELEX_typeSLASH:
  19868.       if (!ffesta_is_inhibited ())
  19869.     ffestc_R547_item_cblock (NULL);
  19870.       return (ffelexHandler) ffestb_R5474_;
  19871.  
  19872.     default:
  19873.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
  19874.       break;
  19875.     }
  19876.  
  19877.   if (!ffesta_is_inhibited ())
  19878.     ffestc_R547_finish ();
  19879.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19880. }
  19881.  
  19882. /* ffestb_R5473_ -- "COMMON" SLASH NAME
  19883.  
  19884.    return ffestb_R5473_;  // to lexer
  19885.  
  19886.    Handle SLASH.  */
  19887.  
  19888. static ffelexHandler
  19889. ffestb_R5473_ (ffelexToken t)
  19890. {
  19891.   switch (ffelex_token_type (t))
  19892.     {
  19893.     case FFELEX_typeSLASH:
  19894.       if (!ffesta_is_inhibited ())
  19895.     ffestc_R547_item_cblock (ffesta_tokens[1]);
  19896.       ffelex_token_kill (ffesta_tokens[1]);
  19897.       return (ffelexHandler) ffestb_R5474_;
  19898.  
  19899.     default:
  19900.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
  19901.       break;
  19902.     }
  19903.  
  19904.   if (!ffesta_is_inhibited ())
  19905.     ffestc_R547_finish ();
  19906.   ffelex_token_kill (ffesta_tokens[1]);
  19907.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19908. }
  19909.  
  19910. /* ffestb_R5474_ -- "COMMON" [SLASH NAME SLASH] or "COMMON" CONCAT
  19911.  
  19912.    return ffestb_R5474_;  // to lexer
  19913.  
  19914.    Handle NAME.     */
  19915.  
  19916. static ffelexHandler
  19917. ffestb_R5474_ (ffelexToken t)
  19918. {
  19919.   switch (ffelex_token_type (t))
  19920.     {
  19921.     case FFELEX_typeNAME:
  19922.       ffesta_tokens[1] = ffelex_token_use (t);
  19923.       return (ffelexHandler) ffestb_R5475_;
  19924.  
  19925.     default:
  19926.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
  19927.       break;
  19928.     }
  19929.  
  19930.   if (!ffesta_is_inhibited ())
  19931.     ffestc_R547_finish ();
  19932.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19933. }
  19934.  
  19935. /* ffestb_R5475_ -- "COMMON" ... NAME
  19936.  
  19937.    return ffestb_R5475_;  // to lexer
  19938.  
  19939.    Handle OPEN_PAREN.  */
  19940.  
  19941. static ffelexHandler
  19942. ffestb_R5475_ (ffelexToken t)
  19943. {
  19944.   switch (ffelex_token_type (t))
  19945.     {
  19946.     case FFELEX_typeOPEN_PAREN:
  19947.       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
  19948.       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_R5476_;
  19949.       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
  19950.       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
  19951. #ifdef FFECOM_dimensionsMAX
  19952.       ffestb_subrargs_.dim_list.ndims = 0;
  19953. #endif
  19954.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  19955.       FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
  19956.  
  19957.     case FFELEX_typeCOMMA:
  19958.       if (!ffesta_is_inhibited ())
  19959.     ffestc_R547_item_object (ffesta_tokens[1], NULL);
  19960.       ffelex_token_kill (ffesta_tokens[1]);
  19961.       return (ffelexHandler) ffestb_R5477_;
  19962.  
  19963.     case FFELEX_typeSLASH:
  19964.     case FFELEX_typeCONCAT:
  19965.       if (!ffesta_is_inhibited ())
  19966.     ffestc_R547_item_object (ffesta_tokens[1], NULL);
  19967.       ffelex_token_kill (ffesta_tokens[1]);
  19968.       return (ffelexHandler) ffestb_R5471_ (t);
  19969.  
  19970.     case FFELEX_typeEOS:
  19971.     case FFELEX_typeSEMICOLON:
  19972.       if (!ffesta_is_inhibited ())
  19973.     {
  19974.       ffestc_R547_item_object (ffesta_tokens[1], NULL);
  19975.       ffestc_R547_finish ();
  19976.     }
  19977.       ffelex_token_kill (ffesta_tokens[1]);
  19978.       return (ffelexHandler) ffesta_zero (t);
  19979.  
  19980.     default:
  19981.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
  19982.       break;
  19983.     }
  19984.  
  19985.   if (!ffesta_is_inhibited ())
  19986.     ffestc_R547_finish ();
  19987.   ffelex_token_kill (ffesta_tokens[1]);
  19988.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  19989. }
  19990.  
  19991. /* ffestb_R5476_ -- "COMMON" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
  19992.  
  19993.    return ffestb_R5476_;  // to lexer
  19994.  
  19995.    Handle COMMA, SLASH, CONCAT, EOS/SEMICOLON.    */
  19996.  
  19997. static ffelexHandler
  19998. ffestb_R5476_ (ffelexToken t)
  19999. {
  20000.   if (!ffestb_subrargs_.dim_list.ok)
  20001.     goto bad;            /* :::::::::::::::::::: */
  20002.  
  20003.   switch (ffelex_token_type (t))
  20004.     {
  20005.     case FFELEX_typeCOMMA:
  20006.       ffesta_confirmed ();
  20007.       if (!ffesta_is_inhibited ())
  20008.     {
  20009.       if (!ffestb_local_.common.started)
  20010.         {
  20011.           ffestc_R547_start ();
  20012.           ffestb_local_.common.started = TRUE;
  20013.         }
  20014.       ffestc_R547_item_object (ffesta_tokens[1],
  20015.                    ffestb_subrargs_.dim_list.dims);
  20016.     }
  20017.       ffelex_token_kill (ffesta_tokens[1]);
  20018.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  20019.       return (ffelexHandler) ffestb_R5477_;
  20020.  
  20021.     case FFELEX_typeSLASH:
  20022.     case FFELEX_typeCONCAT:
  20023.       ffesta_confirmed ();
  20024.       if (!ffesta_is_inhibited ())
  20025.     {
  20026.       if (!ffestb_local_.common.started)
  20027.         {
  20028.           ffestc_R547_start ();
  20029.           ffestb_local_.common.started = TRUE;
  20030.         }
  20031.       ffestc_R547_item_object (ffesta_tokens[1],
  20032.                    ffestb_subrargs_.dim_list.dims);
  20033.     }
  20034.       ffelex_token_kill (ffesta_tokens[1]);
  20035.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  20036.       return (ffelexHandler) ffestb_R5471_ (t);
  20037.  
  20038.     case FFELEX_typeEOS:
  20039.     case FFELEX_typeSEMICOLON:
  20040.       ffesta_confirmed ();
  20041.       if (!ffesta_is_inhibited ())
  20042.     {
  20043.       if (!ffestb_local_.common.started)
  20044.         ffestc_R547_start ();
  20045.       ffestc_R547_item_object (ffesta_tokens[1],
  20046.                    ffestb_subrargs_.dim_list.dims);
  20047.       ffestc_R547_finish ();
  20048.     }
  20049.       ffelex_token_kill (ffesta_tokens[1]);
  20050.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  20051.       return (ffelexHandler) ffesta_zero (t);
  20052.  
  20053.     default:
  20054.       break;
  20055.     }
  20056.  
  20057. bad:                /* :::::::::::::::::::: */
  20058.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
  20059.   if (ffestb_local_.common.started && !ffesta_is_inhibited ())
  20060.     ffestc_R547_finish ();
  20061.   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  20062.   ffelex_token_kill (ffesta_tokens[1]);
  20063.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20064. }
  20065.  
  20066. /* ffestb_R5477_ -- "COMMON" ... COMMA
  20067.  
  20068.    return ffestb_R5477_;  // to lexer
  20069.  
  20070.    Make sure we don't have EOS or SEMICOLON.  */
  20071.  
  20072. static ffelexHandler
  20073. ffestb_R5477_ (ffelexToken t)
  20074. {
  20075.   switch (ffelex_token_type (t))
  20076.     {
  20077.     case FFELEX_typeEOS:
  20078.     case FFELEX_typeSEMICOLON:
  20079.       if (!ffesta_is_inhibited ())
  20080.     ffestc_R547_finish ();
  20081.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "COMMON", t);
  20082.       return (ffelexHandler) ffesta_zero (t);
  20083.  
  20084.     default:
  20085.       return (ffelexHandler) ffestb_R5471_ (t);
  20086.     }
  20087. }
  20088.  
  20089. /* ffestb_R624 -- Parse a NULLIFY statement
  20090.  
  20091.    return ffestb_R624;    // to lexer
  20092.  
  20093.    Make sure the statement has a valid form for a NULLIFY
  20094.    statement.  If it does, implement the statement.
  20095.  
  20096.    31-May-90  JCB  2.0
  20097.       Rewrite to produce a list of expressions rather than just names; this
  20098.       eases semantic checking, putting it in expression handling where that
  20099.       kind of thing gets done anyway, and makes it easier to support more
  20100.       flexible extensions to Fortran 90 like NULLIFY(FOO%BAR).    */
  20101.  
  20102. #if FFESTR_F90
  20103. ffelexHandler
  20104. ffestb_R624 (ffelexToken t)
  20105. {
  20106.   switch (ffelex_token_type (ffesta_tokens[0]))
  20107.     {
  20108.     case FFELEX_typeNAME:
  20109.       if (ffesta_first_kw != FFESTR_firstNULLIFY)
  20110.     goto bad_0;        /* :::::::::::::::::::: */
  20111.       break;
  20112.  
  20113.     case FFELEX_typeNAMES:
  20114.       if (ffesta_first_kw != FFESTR_firstNULLIFY)
  20115.     goto bad_0;        /* :::::::::::::::::::: */
  20116.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlNULLIFY)
  20117.     goto bad_0;        /* :::::::::::::::::::: */
  20118.       break;
  20119.  
  20120.     default:
  20121.       goto bad_0;        /* :::::::::::::::::::: */
  20122.     }
  20123.  
  20124.   switch (ffelex_token_type (t))
  20125.     {
  20126.     case FFELEX_typeOPEN_PAREN:
  20127.       break;
  20128.  
  20129.     case FFELEX_typeEOS:
  20130.     case FFELEX_typeSEMICOLON:
  20131.     case FFELEX_typeCOMMA:
  20132.     case FFELEX_typeCOLONCOLON:
  20133.     case FFELEX_typeNAME:
  20134.       ffesta_confirmed ();    /* Error, but clearly intended. */
  20135.       goto bad_1;        /* :::::::::::::::::::: */
  20136.  
  20137.     default:
  20138.       goto bad_1;        /* :::::::::::::::::::: */
  20139.     }
  20140.  
  20141.   ffestb_local_.R624.exprs = ffestt_exprlist_create ();
  20142.   return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  20143.                       FFEEXPR_contextNULLIFY,
  20144.                       (ffeexprCallback) ffestb_R6241_);
  20145.  
  20146. bad_0:                /* :::::::::::::::::::: */
  20147.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", ffesta_tokens[0]);
  20148.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20149.  
  20150. bad_1:                /* :::::::::::::::::::: */
  20151.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
  20152.   return (ffelexHandler) ffelex_swallow_tokens (t,
  20153.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  20154. }
  20155.  
  20156. /* ffestb_R6241_ -- "NULLIFY" OPEN_PAREN expr
  20157.  
  20158.    return ffestb_R6241_;  // to lexer
  20159.  
  20160.    Make sure the statement has a valid form for a NULLIFY statement.  If it
  20161.    does, implement the statement.
  20162.  
  20163.    31-May-90  JCB  2.0
  20164.       Rewrite to produce a list of expressions rather than just names; this
  20165.       eases semantic checking, putting it in expression handling where that
  20166.       kind of thing gets done anyway, and makes it easier to support more
  20167.       flexible extensions to Fortran 90 like NULLIFY(FOO%BAR).    */
  20168.  
  20169. static ffelexHandler
  20170. ffestb_R6241_ (ffelexToken ft, ffebld expr, ffelexToken t)
  20171. {
  20172.   switch (ffelex_token_type (t))
  20173.     {
  20174.     case FFELEX_typeCLOSE_PAREN:
  20175.       if (expr == NULL)
  20176.     break;
  20177.       ffestt_exprlist_append (ffestb_local_.R624.exprs, expr,
  20178.                   ffelex_token_use (t));
  20179.       return (ffelexHandler) ffestb_R6242_;
  20180.  
  20181.     case FFELEX_typeCOMMA:
  20182.       if (expr == NULL)
  20183.     break;
  20184.       ffestt_exprlist_append (ffestb_local_.R624.exprs, expr,
  20185.                   ffelex_token_use (t));
  20186.       return (ffelexHandler) ffeexpr_lhs (ffesta_output_pool,
  20187.                       FFEEXPR_contextNULLIFY,
  20188.                       (ffeexprCallback) ffestb_R6241_);
  20189.  
  20190.     default:
  20191.       break;
  20192.     }
  20193.  
  20194.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
  20195.   ffestt_exprlist_kill (ffestb_local_.R624.exprs);
  20196.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20197. }
  20198.  
  20199. /* ffestb_R6242_ -- "NULLIFY" OPEN_PAREN expr-list CLOSE_PAREN
  20200.  
  20201.    return ffestb_R6242_;  // to lexer
  20202.  
  20203.    Make sure the statement has a valid form for a NULLIFY statement.  If it
  20204.    does, implement the statement.  */
  20205.  
  20206. static ffelexHandler
  20207. ffestb_R6242_ (ffelexToken t)
  20208. {
  20209.   switch (ffelex_token_type (t))
  20210.     {
  20211.     case FFELEX_typeEOS:
  20212.     case FFELEX_typeSEMICOLON:
  20213.       ffesta_confirmed ();
  20214.       if (!ffesta_is_inhibited ())
  20215.     ffestc_R624 (ffestb_local_.R624.exprs);
  20216.       ffestt_exprlist_kill (ffestb_local_.R624.exprs);
  20217.       return (ffelexHandler) ffesta_zero (t);
  20218.  
  20219.     default:
  20220.       break;
  20221.     }
  20222.  
  20223.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "NULLIFY", t);
  20224.   ffestt_exprlist_kill (ffestb_local_.R624.exprs);
  20225.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20226. }
  20227.  
  20228. #endif
  20229. /* ffestb_R1229 -- Parse a STMTFUNCTION statement
  20230.  
  20231.    return ffestb_R1229;     // to lexer
  20232.  
  20233.    Make sure the statement has a valid form for a STMTFUNCTION
  20234.    statement.  If it does, implement the statement.  */
  20235.  
  20236. ffelexHandler
  20237. ffestb_R1229 (ffelexToken t)
  20238. {
  20239.   switch (ffelex_token_type (ffesta_tokens[0]))
  20240.     {
  20241.     case FFELEX_typeNAME:
  20242.     case FFELEX_typeNAMES:
  20243.       break;
  20244.  
  20245.     default:
  20246.       goto bad_0;        /* :::::::::::::::::::: */
  20247.     }
  20248.  
  20249.   switch (ffelex_token_type (t))
  20250.     {
  20251.     case FFELEX_typeOPEN_PAREN:
  20252.       break;
  20253.  
  20254.     case FFELEX_typeEOS:
  20255.     case FFELEX_typeSEMICOLON:
  20256.     case FFELEX_typeCOMMA:
  20257.     case FFELEX_typeCOLONCOLON:
  20258.     case FFELEX_typeNAME:
  20259.       ffesta_confirmed ();    /* Error, but clearly intended. */
  20260.       goto bad_1;        /* :::::::::::::::::::: */
  20261.  
  20262.     default:
  20263.       goto bad_1;        /* :::::::::::::::::::: */
  20264.     }
  20265.  
  20266.   ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
  20267.   ffestb_subrargs_.name_list.handler = (ffelexHandler) ffestb_R12291_;
  20268.   ffestb_subrargs_.name_list.is_subr = FALSE;    /* No "*" items in list! */
  20269.   ffestb_subrargs_.name_list.names = TRUE;    /* In case "IF(FOO)CALL
  20270.                            FOO...". */
  20271.   return (ffelexHandler) ffestb_subr_name_list_;
  20272.  
  20273. bad_0:                /* :::::::::::::::::::: */
  20274.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "statement-function-definition", ffesta_tokens[0]);
  20275.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20276.  
  20277. bad_1:                /* :::::::::::::::::::: */
  20278.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "statement-function-definition", t);
  20279.   return (ffelexHandler) ffelex_swallow_tokens (t,
  20280.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  20281. }
  20282.  
  20283. /* ffestb_R12291_ -- "STMTFUNCTION" OPEN_PAREN dummy-name-list CLOSE_PAREN
  20284.  
  20285.    return ffestb_R12291_;  // to lexer
  20286.  
  20287.    Make sure the statement has a valid form for a STMTFUNCTION statement.  If
  20288.    it does, implement the statement.  */
  20289.  
  20290. static ffelexHandler
  20291. ffestb_R12291_ (ffelexToken t)
  20292. {
  20293.   ffelex_set_names (FALSE);
  20294.  
  20295.   if (!ffestb_subrargs_.name_list.ok)
  20296.     goto bad;            /* :::::::::::::::::::: */
  20297.  
  20298.   switch (ffelex_token_type (t))
  20299.     {
  20300.     case FFELEX_typeEQUALS:
  20301.       ffesta_confirmed ();
  20302.       if (!ffesta_is_inhibited ())
  20303.     ffestc_R1229_start (ffesta_tokens[0],
  20304.                 ffestb_subrargs_.name_list.args,
  20305.                 ffestb_subrargs_.name_list.close_paren);
  20306.       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
  20307.       ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
  20308.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  20309.          FFEEXPR_contextSFUNCDEF, (ffeexprCallback) ffestb_R12292_);
  20310.  
  20311.     default:
  20312.       break;
  20313.     }
  20314.  
  20315. bad:                /* :::::::::::::::::::: */
  20316.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "statement-function-definition", t);
  20317.   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
  20318.   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
  20319.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20320. }
  20321.  
  20322. /* ffestb_R12292_ -- "STMTFUNCTION" OPEN_PAREN dummy-name-list CLOSE_PAREN
  20323.              EQUALS expr
  20324.  
  20325.    (ffestb_R12292_)  // to expression handler
  20326.  
  20327.    Make sure the statement has a valid form for a STMTFUNCTION statement.  If
  20328.    it does, implement the statement.  */
  20329.  
  20330. static ffelexHandler
  20331. ffestb_R12292_ (ffelexToken ft, ffebld expr, ffelexToken t)
  20332. {
  20333.   if (expr == NULL)
  20334.     goto bad;            /* :::::::::::::::::::: */
  20335.  
  20336.   switch (ffelex_token_type (t))
  20337.     {
  20338.     case FFELEX_typeEOS:
  20339.     case FFELEX_typeSEMICOLON:
  20340.       if (!ffesta_is_inhibited ())
  20341.     ffestc_R1229_finish (expr, ft);
  20342.       return (ffelexHandler) ffesta_zero (t);
  20343.  
  20344.     default:
  20345.       break;
  20346.     }
  20347.  
  20348. bad:                /* :::::::::::::::::::: */
  20349.   ffestc_R1229_finish (NULL, NULL);
  20350.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "statement-function-definition", t);
  20351.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20352. }
  20353.  
  20354. /* ffestb_decl_chartype -- Parse the CHARACTER statement
  20355.  
  20356.    return ffestb_decl_chartype;     // to lexer
  20357.  
  20358.    Make sure the statement has a valid form for the CHARACTER statement.  If
  20359.    it does, implement the statement.  */
  20360.  
  20361. ffelexHandler
  20362. ffestb_decl_chartype (ffelexToken t)
  20363. {
  20364.   ffeTokenLength i;
  20365.   char *p;
  20366.  
  20367.   ffestb_local_.decl.type = FFESTP_typeCHARACTER;
  20368.   ffestb_local_.decl.recursive = NULL;
  20369.   ffestb_local_.decl.parameter = FALSE;    /* No PARAMETER attribute seen. */
  20370.   ffestb_local_.decl.coloncolon = FALSE;    /* No COLONCOLON seen. */
  20371.  
  20372.   switch (ffelex_token_type (ffesta_tokens[0]))
  20373.     {
  20374.     case FFELEX_typeNAME:
  20375.       if (ffesta_first_kw != FFESTR_firstCHRCTR)
  20376.     goto bad_0;        /* :::::::::::::::::::: */
  20377.       switch (ffelex_token_type (t))
  20378.     {
  20379.     case FFELEX_typeEOS:
  20380.     case FFELEX_typeSEMICOLON:
  20381.       ffesta_confirmed ();    /* Error, but clearly intended. */
  20382.       goto bad_1;        /* :::::::::::::::::::: */
  20383.  
  20384.     default:
  20385.       goto bad_1;        /* :::::::::::::::::::: */
  20386.  
  20387.     case FFELEX_typeCOMMA:
  20388.       ffesta_confirmed ();
  20389.       if (!ffesta_is_inhibited ())
  20390.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20391.                    NULL, NULL, NULL, NULL);
  20392.       return (ffelexHandler) ffestb_decl_attrs_;
  20393.  
  20394.     case FFELEX_typeCOLONCOLON:
  20395.       ffestb_local_.decl.coloncolon = TRUE;
  20396.       ffesta_confirmed ();
  20397.       if (!ffesta_is_inhibited ())
  20398.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20399.                    NULL, NULL, NULL, NULL);
  20400.       return (ffelexHandler) ffestb_decl_ents_;
  20401.  
  20402.     case FFELEX_typeASTERISK:
  20403.       ffesta_confirmed ();
  20404.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_chartype1_;
  20405.       ffestb_local_.decl.badname = "TYPEDECL";
  20406.       return (ffelexHandler) ffestb_decl_starlen_;
  20407.  
  20408.     case FFELEX_typeOPEN_PAREN:
  20409.       ffestb_local_.decl.kind = NULL;
  20410.       ffestb_local_.decl.kindt = NULL;
  20411.       ffestb_local_.decl.len = NULL;
  20412.       ffestb_local_.decl.lent = NULL;
  20413.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
  20414.       ffestb_local_.decl.badname = "_TYPEDECL";
  20415.       return (ffelexHandler) ffestb_decl_typeparams_;
  20416.  
  20417.     case FFELEX_typeNAME:
  20418.       ffesta_confirmed ();
  20419.       ffestb_local_.decl.kind = NULL;
  20420.       ffestb_local_.decl.kindt = NULL;
  20421.       ffestb_local_.decl.len = NULL;
  20422.       ffestb_local_.decl.lent = NULL;
  20423.       return (ffelexHandler) ffestb_decl_entsp_ (t);
  20424.     }
  20425.  
  20426.     case FFELEX_typeNAMES:
  20427.       if (ffesta_first_kw != FFESTR_firstCHRCTR)
  20428.     goto bad_0;        /* :::::::::::::::::::: */
  20429.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlCHRCTR);
  20430.       switch (ffelex_token_type (t))
  20431.     {
  20432.     default:
  20433.       goto bad_1;        /* :::::::::::::::::::: */
  20434.  
  20435.     case FFELEX_typeEOS:
  20436.     case FFELEX_typeSEMICOLON:
  20437.       ffesta_confirmed ();
  20438.       break;
  20439.  
  20440.     case FFELEX_typeCOMMA:
  20441.       ffesta_confirmed ();
  20442.       if (*p != '\0')
  20443.         break;
  20444.       if (!ffesta_is_inhibited ())
  20445.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20446.                    NULL, NULL, NULL, NULL);
  20447.       return (ffelexHandler) ffestb_decl_attrs_;
  20448.  
  20449.     case FFELEX_typeCOLONCOLON:
  20450.       ffestb_local_.decl.coloncolon = TRUE;
  20451.       ffesta_confirmed ();
  20452.       if (*p != '\0')
  20453.         goto bad_i;        /* :::::::::::::::::::: */
  20454.       if (!ffesta_is_inhibited ())
  20455.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20456.                    NULL, NULL, NULL, NULL);
  20457.       return (ffelexHandler) ffestb_decl_ents_;
  20458.  
  20459.     case FFELEX_typeASTERISK:
  20460.       ffesta_confirmed ();
  20461.       if (*p != '\0')
  20462.         break;
  20463.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_chartype1_;
  20464.       ffestb_local_.decl.badname = "TYPEDECL";
  20465.       return (ffelexHandler) ffestb_decl_starlen_;
  20466.  
  20467.     case FFELEX_typeSLASH:
  20468.       ffesta_confirmed ();
  20469.       if (*p != '\0')
  20470.         break;
  20471.       goto bad_1;        /* :::::::::::::::::::: */
  20472.  
  20473.     case FFELEX_typeOPEN_PAREN:
  20474.       if (*p != '\0')
  20475.         break;
  20476.       ffestb_local_.decl.kind = NULL;
  20477.       ffestb_local_.decl.kindt = NULL;
  20478.       ffestb_local_.decl.len = NULL;
  20479.       ffestb_local_.decl.lent = NULL;
  20480.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
  20481.       ffestb_local_.decl.badname = "TYPEDECL";
  20482.       return (ffelexHandler) ffestb_decl_typeparams_;
  20483.     }
  20484.       if (!ffesrc_is_name_init (*p))
  20485.     goto bad_i;        /* :::::::::::::::::::: */
  20486.       ffestb_local_.decl.kind = NULL;
  20487.       ffestb_local_.decl.kindt = NULL;
  20488.       ffestb_local_.decl.len = NULL;
  20489.       ffestb_local_.decl.lent = NULL;
  20490.       ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
  20491.       return (ffelexHandler) ffestb_decl_entsp_2_ (t);
  20492.  
  20493.     default:
  20494.       goto bad_0;        /* :::::::::::::::::::: */
  20495.     }
  20496.  
  20497. bad_0:                /* :::::::::::::::::::: */
  20498.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
  20499.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20500.  
  20501. bad_1:                /* :::::::::::::::::::: */
  20502.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  20503.   return (ffelexHandler) ffelex_swallow_tokens (t,
  20504.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  20505.  
  20506. bad_i:                /* :::::::::::::::::::: */
  20507.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
  20508.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20509. }
  20510.  
  20511. /* ffestb_decl_chartype1_ -- "CHARACTER" ASTERISK char-length
  20512.  
  20513.    return ffestb_decl_chartype1_;  // to lexer
  20514.  
  20515.    Handle COMMA, COLONCOLON, or anything else.    */
  20516.  
  20517. static ffelexHandler
  20518. ffestb_decl_chartype1_ (ffelexToken t)
  20519. {
  20520.   ffelex_set_names (FALSE);
  20521.  
  20522.   switch (ffelex_token_type (t))
  20523.     {
  20524.     case FFELEX_typeCOLONCOLON:
  20525.       ffestb_local_.decl.coloncolon = TRUE;
  20526.       /* Fall through. */
  20527.     case FFELEX_typeCOMMA:
  20528.       ffesta_confirmed ();
  20529.       if (!ffesta_is_inhibited ())
  20530.     ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20531.            NULL, NULL, ffestb_local_.decl.len, ffestb_local_.decl.lent);
  20532.       if (ffestb_local_.decl.lent != NULL)
  20533.     ffelex_token_kill (ffestb_local_.decl.lent);
  20534.       return (ffelexHandler) ffestb_decl_ents_;
  20535.  
  20536.     default:
  20537.       return (ffelexHandler) ffestb_decl_entsp_ (t);
  20538.     }
  20539. }
  20540.  
  20541. /* ffestb_decl_dbltype -- Parse the DOUBLEPRECISION/DOUBLECOMPLEX statement
  20542.  
  20543.    return ffestb_decl_dbltype;    // to lexer
  20544.  
  20545.    Make sure the statement has a valid form for the DOUBLEPRECISION/
  20546.    DOUBLECOMPLEX statement.  If it does, implement the statement.  */
  20547.  
  20548. ffelexHandler
  20549. ffestb_decl_dbltype (ffelexToken t)
  20550. {
  20551.   ffeTokenLength i;
  20552.   char *p;
  20553.  
  20554.   ffestb_local_.decl.type = ffestb_args.decl.type;
  20555.   ffestb_local_.decl.recursive = NULL;
  20556.   ffestb_local_.decl.parameter = FALSE;    /* No PARAMETER attribute seen. */
  20557.   ffestb_local_.decl.coloncolon = FALSE;    /* No COLONCOLON seen. */
  20558.  
  20559.   switch (ffelex_token_type (ffesta_tokens[0]))
  20560.     {
  20561.     case FFELEX_typeNAME:
  20562.       switch (ffelex_token_type (t))
  20563.     {
  20564.     case FFELEX_typeEOS:
  20565.     case FFELEX_typeSEMICOLON:
  20566.       ffesta_confirmed ();    /* Error, but clearly intended. */
  20567.       goto bad_1;        /* :::::::::::::::::::: */
  20568.  
  20569.     default:
  20570.       goto bad_1;        /* :::::::::::::::::::: */
  20571.  
  20572.     case FFELEX_typeCOMMA:
  20573.       ffesta_confirmed ();
  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 (!ffesta_is_inhibited ())
  20583.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20584.                    NULL, NULL, NULL, NULL);
  20585.       return (ffelexHandler) ffestb_decl_ents_;
  20586.  
  20587.     case FFELEX_typeNAME:
  20588.       ffesta_confirmed ();
  20589.       ffestb_local_.decl.kind = NULL;
  20590.       ffestb_local_.decl.kindt = NULL;
  20591.       ffestb_local_.decl.len = NULL;
  20592.       ffestb_local_.decl.lent = NULL;
  20593.       return (ffelexHandler) ffestb_decl_entsp_ (t);
  20594.     }
  20595.  
  20596.     case FFELEX_typeNAMES:
  20597.       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.decl.len);
  20598.       switch (ffelex_token_type (t))
  20599.     {
  20600.     default:
  20601.       goto bad_1;        /* :::::::::::::::::::: */
  20602.  
  20603.     case FFELEX_typeEOS:
  20604.     case FFELEX_typeSEMICOLON:
  20605.       ffesta_confirmed ();
  20606.       break;
  20607.  
  20608.     case FFELEX_typeCOMMA:
  20609.       ffesta_confirmed ();
  20610.       if (*p != '\0')
  20611.         break;
  20612.       if (!ffesta_is_inhibited ())
  20613.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20614.                    NULL, NULL, NULL, NULL);
  20615.       return (ffelexHandler) ffestb_decl_attrs_;
  20616.  
  20617.     case FFELEX_typeCOLONCOLON:
  20618.       ffestb_local_.decl.coloncolon = TRUE;
  20619.       ffesta_confirmed ();
  20620.       if (*p != '\0')
  20621.         goto bad_i;        /* :::::::::::::::::::: */
  20622.       if (!ffesta_is_inhibited ())
  20623.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20624.                    NULL, NULL, NULL, NULL);
  20625.       return (ffelexHandler) ffestb_decl_ents_;
  20626.  
  20627.     case FFELEX_typeSLASH:
  20628.       ffesta_confirmed ();
  20629.       if (*p != '\0')
  20630.         break;
  20631.       goto bad_1;        /* :::::::::::::::::::: */
  20632.  
  20633.     case FFELEX_typeOPEN_PAREN:
  20634.       if (*p != '\0')
  20635.         break;
  20636.       goto bad_1;        /* :::::::::::::::::::: */
  20637.     }
  20638.       if (!ffesrc_is_name_init (*p))
  20639.     goto bad_i;        /* :::::::::::::::::::: */
  20640.       ffestb_local_.decl.kind = NULL;
  20641.       ffestb_local_.decl.kindt = NULL;
  20642.       ffestb_local_.decl.len = NULL;
  20643.       ffestb_local_.decl.lent = NULL;
  20644.       ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
  20645.       return (ffelexHandler) ffestb_decl_entsp_2_ (t);
  20646.  
  20647.     default:
  20648.       goto bad_0;        /* :::::::::::::::::::: */
  20649.     }
  20650.  
  20651. bad_0:                /* :::::::::::::::::::: */
  20652.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
  20653.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20654.  
  20655. bad_1:                /* :::::::::::::::::::: */
  20656.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  20657.   return (ffelexHandler) ffelex_swallow_tokens (t,
  20658.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  20659.  
  20660. bad_i:                /* :::::::::::::::::::: */
  20661.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
  20662.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20663. }
  20664.  
  20665. /* ffestb_decl_double -- Parse the DOUBLE PRECISION/DOUBLE COMPLEX statement
  20666.  
  20667.    return ffestb_decl_double;  // to lexer
  20668.  
  20669.    Make sure the statement has a valid form for the DOUBLE PRECISION/
  20670.    DOUBLE COMPLEX statement.  If it does, implement the statement.  */
  20671.  
  20672. ffelexHandler
  20673. ffestb_decl_double (ffelexToken t)
  20674. {
  20675.   ffestb_local_.decl.recursive = NULL;
  20676.   ffestb_local_.decl.parameter = FALSE;    /* No PARAMETER attribute seen. */
  20677.   ffestb_local_.decl.coloncolon = FALSE;    /* No COLONCOLON seen. */
  20678.  
  20679.   switch (ffelex_token_type (ffesta_tokens[0]))
  20680.     {
  20681.     case FFELEX_typeNAME:
  20682.       if (ffesta_first_kw != FFESTR_firstDBL)
  20683.     goto bad_0;        /* :::::::::::::::::::: */
  20684.       switch (ffelex_token_type (t))
  20685.     {
  20686.     case FFELEX_typeEOS:
  20687.     case FFELEX_typeSEMICOLON:
  20688.     case FFELEX_typeCOMMA:
  20689.     case FFELEX_typeCOLONCOLON:
  20690.       ffesta_confirmed ();    /* Error, but clearly intended. */
  20691.       goto bad_1;        /* :::::::::::::::::::: */
  20692.  
  20693.     default:
  20694.       goto bad_1;        /* :::::::::::::::::::: */
  20695.  
  20696.     case FFELEX_typeNAME:
  20697.       ffesta_confirmed ();
  20698.       switch (ffestr_second (t))
  20699.         {
  20700.         case FFESTR_secondCOMPLEX:
  20701.           ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
  20702.           break;
  20703.  
  20704.         case FFESTR_secondPRECISION:
  20705.           ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
  20706.           break;
  20707.  
  20708.         default:
  20709.           goto bad_1;    /* :::::::::::::::::::: */
  20710.         }
  20711.       ffestb_local_.decl.kind = NULL;
  20712.       ffestb_local_.decl.kindt = NULL;
  20713.       ffestb_local_.decl.len = NULL;
  20714.       ffestb_local_.decl.lent = NULL;
  20715.       return (ffelexHandler) ffestb_decl_attrsp_;
  20716.     }
  20717.  
  20718.     default:
  20719.       goto bad_0;        /* :::::::::::::::::::: */
  20720.     }
  20721.  
  20722. bad_0:                /* :::::::::::::::::::: */
  20723.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
  20724.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20725.  
  20726. bad_1:                /* :::::::::::::::::::: */
  20727.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  20728.   return (ffelexHandler) ffelex_swallow_tokens (t,
  20729.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  20730. }
  20731.  
  20732. /* ffestb_decl_gentype -- Parse the INTEGER/REAL/COMPLEX/LOGICAL statement
  20733.  
  20734.    return ffestb_decl_gentype;    // to lexer
  20735.  
  20736.    Make sure the statement has a valid form for the INTEGER/REAL/COMPLEX/
  20737.    LOGICAL statement.  If it does, implement the statement.  */
  20738.  
  20739. ffelexHandler
  20740. ffestb_decl_gentype (ffelexToken t)
  20741. {
  20742.   ffeTokenLength i;
  20743.   char *p;
  20744.  
  20745.   ffestb_local_.decl.type = ffestb_args.decl.type;
  20746.   ffestb_local_.decl.recursive = NULL;
  20747.   ffestb_local_.decl.parameter = FALSE;    /* No PARAMETER attribute seen. */
  20748.   ffestb_local_.decl.coloncolon = FALSE;    /* No COLONCOLON seen. */
  20749.  
  20750.   switch (ffelex_token_type (ffesta_tokens[0]))
  20751.     {
  20752.     case FFELEX_typeNAME:
  20753.       switch (ffelex_token_type (t))
  20754.     {
  20755.     case FFELEX_typeEOS:
  20756.     case FFELEX_typeSEMICOLON:
  20757.       ffesta_confirmed ();    /* Error, but clearly intended. */
  20758.       goto bad_1;        /* :::::::::::::::::::: */
  20759.  
  20760.     default:
  20761.       goto bad_1;        /* :::::::::::::::::::: */
  20762.  
  20763.     case FFELEX_typeCOMMA:
  20764.       ffesta_confirmed ();
  20765.       if (!ffesta_is_inhibited ())
  20766.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20767.                    NULL, NULL, NULL, NULL);
  20768.       return (ffelexHandler) ffestb_decl_attrs_;
  20769.  
  20770.     case FFELEX_typeCOLONCOLON:
  20771.       ffestb_local_.decl.coloncolon = TRUE;
  20772.       ffesta_confirmed ();
  20773.       if (!ffesta_is_inhibited ())
  20774.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20775.                    NULL, NULL, NULL, NULL);
  20776.       return (ffelexHandler) ffestb_decl_ents_;
  20777.  
  20778.     case FFELEX_typeASTERISK:
  20779.       ffesta_confirmed ();
  20780.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
  20781.       ffestb_local_.decl.badname = "TYPEDECL";
  20782.       return (ffelexHandler) ffestb_decl_starkind_;
  20783.  
  20784.     case FFELEX_typeOPEN_PAREN:
  20785.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
  20786.       ffestb_local_.decl.badname = "TYPEDECL";
  20787.       return (ffelexHandler) ffestb_decl_kindparam_;
  20788.  
  20789.     case FFELEX_typeNAME:
  20790.       ffesta_confirmed ();
  20791.       ffestb_local_.decl.kind = NULL;
  20792.       ffestb_local_.decl.kindt = NULL;
  20793.       ffestb_local_.decl.len = NULL;
  20794.       ffestb_local_.decl.lent = NULL;
  20795.       return (ffelexHandler) ffestb_decl_entsp_ (t);
  20796.     }
  20797.  
  20798.     case FFELEX_typeNAMES:
  20799.       p = ffelex_token_text (ffesta_tokens[0]) + (i = ffestb_args.decl.len);
  20800.       switch (ffelex_token_type (t))
  20801.     {
  20802.     default:
  20803.       goto bad_1;        /* :::::::::::::::::::: */
  20804.  
  20805.     case FFELEX_typeEOS:
  20806.     case FFELEX_typeSEMICOLON:
  20807.       ffesta_confirmed ();
  20808.       break;
  20809.  
  20810.     case FFELEX_typeCOMMA:
  20811.       ffesta_confirmed ();
  20812.       if (*p != '\0')
  20813.         break;
  20814.       if (!ffesta_is_inhibited ())
  20815.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20816.                    NULL, NULL, NULL, NULL);
  20817.       return (ffelexHandler) ffestb_decl_attrs_;
  20818.  
  20819.     case FFELEX_typeCOLONCOLON:
  20820.       ffestb_local_.decl.coloncolon = TRUE;
  20821.       ffesta_confirmed ();
  20822.       if (*p != '\0')
  20823.         goto bad_i;        /* :::::::::::::::::::: */
  20824.       if (!ffesta_is_inhibited ())
  20825.         ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  20826.                    NULL, NULL, NULL, NULL);
  20827.       return (ffelexHandler) ffestb_decl_ents_;
  20828.  
  20829.     case FFELEX_typeSLASH:
  20830.       ffesta_confirmed ();
  20831.       if (*p != '\0')
  20832.         break;
  20833.       goto bad_1;        /* :::::::::::::::::::: */
  20834.  
  20835.     case FFELEX_typeASTERISK:
  20836.       ffesta_confirmed ();
  20837.       if (*p != '\0')
  20838.         break;
  20839.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
  20840.       ffestb_local_.decl.badname = "TYPEDECL";
  20841.       return (ffelexHandler) ffestb_decl_starkind_;
  20842.  
  20843.     case FFELEX_typeOPEN_PAREN:
  20844.       if (*p != '\0')
  20845.         break;
  20846.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
  20847.       ffestb_local_.decl.badname = "TYPEDECL";
  20848.       return (ffelexHandler) ffestb_decl_kindparam_;
  20849.     }
  20850.       if (!ffesrc_is_name_init (*p))
  20851.     goto bad_i;        /* :::::::::::::::::::: */
  20852.       ffestb_local_.decl.kind = NULL;
  20853.       ffestb_local_.decl.kindt = NULL;
  20854.       ffestb_local_.decl.len = NULL;
  20855.       ffestb_local_.decl.lent = NULL;
  20856.       ffesta_tokens[1] = ffelex_token_names_from_names (ffesta_tokens[0], i, 0);
  20857.       return (ffelexHandler) ffestb_decl_entsp_2_ (t);
  20858.  
  20859.     default:
  20860.       goto bad_0;        /* :::::::::::::::::::: */
  20861.     }
  20862.  
  20863. bad_0:                /* :::::::::::::::::::: */
  20864.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
  20865.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20866.  
  20867. bad_1:                /* :::::::::::::::::::: */
  20868.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  20869.   return (ffelexHandler) ffelex_swallow_tokens (t,
  20870.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  20871.  
  20872. bad_i:                /* :::::::::::::::::::: */
  20873.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0], i, t);
  20874.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  20875. }
  20876.  
  20877. /* ffestb_decl_recursive -- Parse the RECURSIVE FUNCTION statement
  20878.  
  20879.    return ffestb_decl_recursive;  // to lexer
  20880.  
  20881.    Make sure the statement has a valid form for the RECURSIVE FUNCTION
  20882.    statement.  If it does, implement the statement.  */
  20883.  
  20884. #if FFESTR_F90
  20885. ffelexHandler
  20886. ffestb_decl_recursive (ffelexToken t)
  20887. {
  20888.   ffeTokenLength i;
  20889.   char *p;
  20890.   ffelexToken nt;
  20891.   ffelexToken ot;
  20892.   ffelexHandler next;
  20893.   bool needfunc;
  20894.  
  20895.   switch (ffelex_token_type (ffesta_tokens[0]))
  20896.     {
  20897.     case FFELEX_typeNAME:
  20898.       if (ffesta_first_kw != FFESTR_firstRECURSIVE)
  20899.     goto bad_0;        /* :::::::::::::::::::: */
  20900.       switch (ffelex_token_type (t))
  20901.     {
  20902.     case FFELEX_typeEOS:
  20903.     case FFELEX_typeSEMICOLON:
  20904.     case FFELEX_typeCOMMA:
  20905.     case FFELEX_typeCOLONCOLON:
  20906.       ffesta_confirmed ();    /* Error, but clearly intended. */
  20907.       goto bad_1;        /* :::::::::::::::::::: */
  20908.  
  20909.     default:
  20910.       goto bad_1;        /* :::::::::::::::::::: */
  20911.  
  20912.     case FFELEX_typeNAME:
  20913.       break;
  20914.     }
  20915.       ffesta_confirmed ();
  20916.       ffestb_local_.decl.recursive = ffelex_token_use (ffesta_tokens[0]);
  20917.       switch (ffesta_second_kw)
  20918.     {
  20919.     case FFESTR_secondINTEGER:
  20920.       ffestb_local_.decl.type = FFESTP_typeINTEGER;
  20921.       return (ffelexHandler) ffestb_decl_recursive1_;
  20922.  
  20923.     case FFESTR_secondREAL:
  20924.       ffestb_local_.decl.type = FFESTP_typeREAL;
  20925.       return (ffelexHandler) ffestb_decl_recursive1_;
  20926.  
  20927.     case FFESTR_secondCOMPLEX:
  20928.       ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
  20929.       return (ffelexHandler) ffestb_decl_recursive1_;
  20930.  
  20931.     case FFESTR_secondLOGICAL:
  20932.       ffestb_local_.decl.type = FFESTP_typeLOGICAL;
  20933.       return (ffelexHandler) ffestb_decl_recursive1_;
  20934.  
  20935.     case FFESTR_secondCHARACTER:
  20936.       ffestb_local_.decl.type = FFESTP_typeCHARACTER;
  20937.       return (ffelexHandler) ffestb_decl_recursive1_;
  20938.  
  20939.     case FFESTR_secondDOUBLE:
  20940.       return (ffelexHandler) ffestb_decl_recursive2_;
  20941.  
  20942.     case FFESTR_secondDOUBLEPRECISION:
  20943.       ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
  20944.       ffestb_local_.decl.kind = NULL;
  20945.       ffestb_local_.decl.kindt = NULL;
  20946.       ffestb_local_.decl.len = NULL;
  20947.       ffestb_local_.decl.lent = NULL;
  20948.       return (ffelexHandler) ffestb_decl_func_;
  20949.  
  20950.     case FFESTR_secondDOUBLECOMPLEX:
  20951.       ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
  20952.       ffestb_local_.decl.kind = NULL;
  20953.       ffestb_local_.decl.kindt = NULL;
  20954.       ffestb_local_.decl.len = NULL;
  20955.       ffestb_local_.decl.lent = NULL;
  20956.       return (ffelexHandler) ffestb_decl_func_;
  20957.  
  20958.     case FFESTR_secondTYPE:
  20959.       ffestb_local_.decl.type = FFESTP_typeTYPE;
  20960.       return (ffelexHandler) ffestb_decl_recursive3_;
  20961.  
  20962.     case FFESTR_secondFUNCTION:
  20963.       ffestb_local_.dummy.first_kw = FFESTR_firstFUNCTION;
  20964.       ffestb_local_.dummy.badname = "FUNCTION";
  20965.       ffestb_local_.dummy.is_subr = FALSE;
  20966.       return (ffelexHandler) ffestb_decl_recursive4_;
  20967.  
  20968.     case FFESTR_secondSUBROUTINE:
  20969.       ffestb_local_.dummy.first_kw = FFESTR_firstSUBROUTINE;
  20970.       ffestb_local_.dummy.badname = "SUBROUTINE";
  20971.       ffestb_local_.dummy.is_subr = TRUE;
  20972.       return (ffelexHandler) ffestb_decl_recursive4_;
  20973.  
  20974.     default:
  20975.       ffelex_token_kill (ffestb_local_.decl.recursive);
  20976.       goto bad_1;        /* :::::::::::::::::::: */
  20977.     }
  20978.  
  20979.     case FFELEX_typeNAMES:
  20980.       if (ffesta_first_kw != FFESTR_firstRECURSIVE)
  20981.     goto bad_0;        /* :::::::::::::::::::: */
  20982.       switch (ffelex_token_type (t))
  20983.     {
  20984.     case FFELEX_typeCOMMA:
  20985.     case FFELEX_typeCOLONCOLON:
  20986.     case FFELEX_typeASTERISK:
  20987.     case FFELEX_typeSEMICOLON:
  20988.     case FFELEX_typeEOS:
  20989.       ffesta_confirmed ();
  20990.       break;
  20991.  
  20992.     default:
  20993.       break;
  20994.     }
  20995.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlRECURSIVE);
  20996.       if (!ffesrc_is_name_init (*p))
  20997.     goto bad_0;        /* :::::::::::::::::::: */
  20998.       ffestb_local_.decl.recursive
  20999.     = ffelex_token_name_from_names (ffesta_tokens[0], 0,
  21000.                     FFESTR_firstlRECURSIVE);
  21001.       nt = ffelex_token_names_from_names (ffesta_tokens[0],
  21002.                       FFESTR_firstlRECURSIVE, 0);
  21003.       switch (ffestr_first (nt))
  21004.     {
  21005.     case FFESTR_firstINTGR:
  21006.       p = ffelex_token_text (nt) + (i = FFESTR_firstlINTGR);
  21007.       ffestb_local_.decl.type = FFESTP_typeINTEGER;
  21008.       needfunc = FALSE;
  21009.       goto typefunc;    /* :::::::::::::::::::: */
  21010.  
  21011.     case FFESTR_firstREAL:
  21012.       p = ffelex_token_text (nt) + (i = FFESTR_firstlREAL);
  21013.       ffestb_local_.decl.type = FFESTP_typeREAL;
  21014.       needfunc = FALSE;
  21015.       goto typefunc;    /* :::::::::::::::::::: */
  21016.  
  21017.     case FFESTR_firstCMPLX:
  21018.       p = ffelex_token_text (nt) + (i = FFESTR_firstlCMPLX);
  21019.       ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
  21020.       needfunc = FALSE;
  21021.       goto typefunc;    /* :::::::::::::::::::: */
  21022.  
  21023.     case FFESTR_firstLGCL:
  21024.       p = ffelex_token_text (nt) + (i = FFESTR_firstlLGCL);
  21025.       ffestb_local_.decl.type = FFESTP_typeLOGICAL;
  21026.       needfunc = FALSE;
  21027.       goto typefunc;    /* :::::::::::::::::::: */
  21028.  
  21029.     case FFESTR_firstCHRCTR:
  21030.       p = ffelex_token_text (nt) + (i = FFESTR_firstlCHRCTR);
  21031.       ffestb_local_.decl.type = FFESTP_typeCHARACTER;
  21032.       needfunc = FALSE;
  21033.       goto typefunc;    /* :::::::::::::::::::: */
  21034.  
  21035.     case FFESTR_firstDBLPRCSN:
  21036.       p = ffelex_token_text (nt) + (i = FFESTR_firstlDBLPRCSN);
  21037.       ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
  21038.       needfunc = TRUE;
  21039.       goto typefunc;    /* :::::::::::::::::::: */
  21040.  
  21041.     case FFESTR_firstDBLCMPLX:
  21042.       p = ffelex_token_text (nt) + (i = FFESTR_firstlDBLCMPLX);
  21043.       ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
  21044.       needfunc = TRUE;
  21045.       goto typefunc;    /* :::::::::::::::::::: */
  21046.  
  21047.     case FFESTR_firstTYPE:
  21048.       p = ffelex_token_text (nt) + (i = FFESTR_firstlTYPE);
  21049.       ffestb_local_.decl.type = FFESTP_typeTYPE;
  21050.       next = (ffelexHandler) ffestb_decl_recursive3_;
  21051.       break;
  21052.  
  21053.     case FFESTR_firstFUNCTION:
  21054.       p = ffelex_token_text (nt) + (i = FFESTR_firstlFUNCTION);
  21055.       ffestb_local_.dummy.first_kw = FFESTR_firstFUNCTION;
  21056.       ffestb_local_.dummy.badname = "FUNCTION";
  21057.       ffestb_local_.dummy.is_subr = FALSE;
  21058.       next = (ffelexHandler) ffestb_decl_recursive4_;
  21059.       break;
  21060.  
  21061.     case FFESTR_firstSUBROUTINE:
  21062.       p = ffelex_token_text (nt) + (i = FFESTR_firstlSUBROUTINE);
  21063.       ffestb_local_.dummy.first_kw = FFESTR_firstSUBROUTINE;
  21064.       ffestb_local_.dummy.badname = "SUBROUTINE";
  21065.       ffestb_local_.dummy.is_subr = TRUE;
  21066.       next = (ffelexHandler) ffestb_decl_recursive4_;
  21067.       break;
  21068.  
  21069.     default:
  21070.       ffelex_token_kill (ffestb_local_.decl.recursive);
  21071.       ffelex_token_kill (nt);
  21072.       goto bad_1;        /* :::::::::::::::::::: */
  21073.     }
  21074.       if (*p == '\0')
  21075.     {
  21076.       ffelex_token_kill (nt);
  21077.       return (ffelexHandler) (*next) (t);
  21078.     }
  21079.       if (!ffesrc_is_name_init (*p))
  21080.     goto bad_i;        /* :::::::::::::::::::: */
  21081.       ot = ffelex_token_name_from_names (nt, i, 0);
  21082.       ffelex_token_kill (nt);
  21083.       next = (ffelexHandler) (*next) (ot);
  21084.       ffelex_token_kill (ot);
  21085.       return (ffelexHandler) (*next) (t);
  21086.  
  21087.     default:
  21088.       goto bad_0;        /* :::::::::::::::::::: */
  21089.     }
  21090.  
  21091. typefunc:            /* :::::::::::::::::::: */
  21092.   if (*p == '\0')
  21093.     {
  21094.       ffelex_token_kill (nt);
  21095.       if (needfunc)        /* DOUBLE PRECISION or DOUBLE COMPLEX? */
  21096.     {
  21097.       ffelex_token_kill (ffestb_local_.decl.recursive);
  21098.       goto bad_1;        /* :::::::::::::::::::: */
  21099.     }
  21100.       return (ffelexHandler) ffestb_decl_recursive1_ (t);
  21101.     }
  21102.   if (!ffesrc_is_name_init (*p))
  21103.     goto bad_i;            /* :::::::::::::::::::: */
  21104.   ot = ffelex_token_names_from_names (nt, i, 0);
  21105.   ffelex_token_kill (nt);
  21106.   if (ffestr_first (ot) != FFESTR_firstFUNCTION)
  21107.     goto bad_o;            /* :::::::::::::::::::: */
  21108.   p = ffelex_token_text (ot) + (i = FFESTR_firstlFUNCTION);
  21109.   if (!ffesrc_is_name_init (*p))
  21110.     goto bad_i;            /* :::::::::::::::::::: */
  21111.   ffesta_tokens[1] = ffelex_token_name_from_names (ot, i, 0);
  21112.   ffelex_token_kill (ot);
  21113.   ffestb_local_.decl.kind = NULL;
  21114.   ffestb_local_.decl.kindt = NULL;
  21115.   ffestb_local_.decl.len = NULL;
  21116.   ffestb_local_.decl.lent = NULL;
  21117.   return (ffelexHandler) ffestb_decl_funcname_1_ (t);
  21118.  
  21119. bad_0:                /* :::::::::::::::::::: */
  21120.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ffesta_tokens[0]);
  21121.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21122.  
  21123. bad_1:                /* :::::::::::::::::::: */
  21124.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  21125.   return (ffelexHandler) ffelex_swallow_tokens (t,
  21126.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  21127.  
  21128. bad_i:                /* :::::::::::::::::::: */
  21129.   ffelex_token_kill (ffestb_local_.decl.recursive);
  21130.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "type-declaration", nt, i, t);
  21131.   ffelex_token_kill (nt);
  21132.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21133.  
  21134. bad_o:                /* :::::::::::::::::::: */
  21135.   ffelex_token_kill (ffestb_local_.decl.recursive);
  21136.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ot);
  21137.   ffelex_token_kill (ot);
  21138.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21139. }
  21140.  
  21141. /* ffestb_decl_recursive1_ -- "RECURSIVE" generic-type
  21142.  
  21143.    return ffestb_decl_recursive1_;  // to lexer
  21144.  
  21145.    Handle ASTERISK, OPEN_PAREN, or NAME.  */
  21146.  
  21147. static ffelexHandler
  21148. ffestb_decl_recursive1_ (ffelexToken t)
  21149. {
  21150.   switch (ffelex_token_type (t))
  21151.     {
  21152.     case FFELEX_typeASTERISK:
  21153.       ffesta_confirmed ();
  21154.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
  21155.       ffestb_local_.decl.badname = "TYPEFUNC";
  21156.       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
  21157.     return (ffelexHandler) ffestb_decl_starlen_;
  21158.       return (ffelexHandler) ffestb_decl_starkind_;
  21159.  
  21160.     case FFELEX_typeOPEN_PAREN:
  21161.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
  21162.       ffestb_local_.decl.badname = "TYPEFUNC";
  21163.       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
  21164.     {
  21165.       ffestb_local_.decl.kind = NULL;
  21166.       ffestb_local_.decl.kindt = NULL;
  21167.       ffestb_local_.decl.len = NULL;
  21168.       ffestb_local_.decl.lent = NULL;
  21169.       return (ffelexHandler) ffestb_decl_typeparams_;
  21170.     }
  21171.       return (ffelexHandler) ffestb_decl_kindparam_;
  21172.  
  21173.     case FFELEX_typeNAME:
  21174.       ffestb_local_.decl.kind = NULL;
  21175.       ffestb_local_.decl.kindt = NULL;
  21176.       ffestb_local_.decl.len = NULL;
  21177.       ffestb_local_.decl.lent = NULL;
  21178.       return (ffelexHandler) ffestb_decl_func_ (t);
  21179.  
  21180.     default:
  21181.       break;
  21182.     }
  21183.  
  21184.   if (ffestb_local_.decl.recursive != NULL)
  21185.     ffelex_token_kill (ffestb_local_.decl.recursive);
  21186.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  21187.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21188. }
  21189.  
  21190. /* ffestb_decl_recursive2_ -- "RECURSIVE" "DOUBLE"
  21191.  
  21192.    return ffestb_decl_recursive2_;  // to lexer
  21193.  
  21194.    Handle NAME.     */
  21195.  
  21196. static ffelexHandler
  21197. ffestb_decl_recursive2_ (ffelexToken t)
  21198. {
  21199.   switch (ffelex_token_type (t))
  21200.     {
  21201.     case FFELEX_typeNAME:
  21202.       switch (ffestr_second (t))
  21203.     {
  21204.     case FFESTR_secondPRECISION:
  21205.       ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
  21206.       break;
  21207.  
  21208.     case FFESTR_secondCOMPLEX:
  21209.       ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
  21210.       break;
  21211.  
  21212.     default:
  21213.       goto bad;        /* :::::::::::::::::::: */
  21214.     }
  21215.       ffestb_local_.decl.kind = NULL;
  21216.       ffestb_local_.decl.kindt = NULL;
  21217.       ffestb_local_.decl.len = NULL;
  21218.       ffestb_local_.decl.lent = NULL;
  21219.       return (ffelexHandler) ffestb_decl_func_;
  21220.  
  21221.     default:
  21222.       break;
  21223.     }
  21224.  
  21225. bad:                /* :::::::::::::::::::: */
  21226.   if (ffestb_local_.decl.recursive != NULL)
  21227.     ffelex_token_kill (ffestb_local_.decl.recursive);
  21228.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  21229.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21230. }
  21231.  
  21232. /* ffestb_decl_recursive3_ -- "RECURSIVE" "TYPE"
  21233.  
  21234.    return ffestb_decl_recursive3_;  // to lexer
  21235.  
  21236.    Handle OPEN_PAREN.  */
  21237.  
  21238. static ffelexHandler
  21239. ffestb_decl_recursive3_ (ffelexToken t)
  21240. {
  21241.   switch (ffelex_token_type (t))
  21242.     {
  21243.     case FFELEX_typeOPEN_PAREN:
  21244.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_func_;
  21245.       ffestb_local_.decl.badname = "TYPEFUNC";
  21246.       return (ffelexHandler) ffestb_decl_typetype1_;
  21247.  
  21248.     default:
  21249.       break;
  21250.     }
  21251.  
  21252.   if (ffestb_local_.decl.recursive != NULL)
  21253.     ffelex_token_kill (ffestb_local_.decl.recursive);
  21254.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  21255.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21256. }
  21257.  
  21258. /* ffestb_decl_recursive4_ -- "RECURSIVE" "FUNCTION/SUBROUTINE"
  21259.  
  21260.    return ffestb_decl_recursive4_;  // to lexer
  21261.  
  21262.    Handle OPEN_PAREN.  */
  21263.  
  21264. static ffelexHandler
  21265. ffestb_decl_recursive4_ (ffelexToken t)
  21266. {
  21267.   switch (ffelex_token_type (t))
  21268.     {
  21269.     case FFELEX_typeNAME:
  21270.       ffesta_tokens[1] = ffelex_token_use (t);
  21271.       return (ffelexHandler) ffestb_dummy1_;
  21272.  
  21273.     default:
  21274.       break;
  21275.     }
  21276.  
  21277.   if (ffestb_local_.decl.recursive != NULL)
  21278.     ffelex_token_kill (ffestb_local_.decl.recursive);
  21279.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  21280.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21281. }
  21282.  
  21283. #endif
  21284. /* ffestb_decl_typetype -- Parse the R426/R501/R1219 TYPE statement
  21285.  
  21286.    return ffestb_decl_typetype;     // to lexer
  21287.  
  21288.    Make sure the statement has a valid form for the TYPE statement.  If it
  21289.    does, implement the statement.  */
  21290.  
  21291. #if FFESTR_F90
  21292. ffelexHandler
  21293. ffestb_decl_typetype (ffelexToken t)
  21294. {
  21295.   switch (ffelex_token_type (ffesta_tokens[0]))
  21296.     {
  21297.     case FFELEX_typeNAME:
  21298.       if (ffesta_first_kw != FFESTR_firstTYPE)
  21299.     goto bad_0;        /* :::::::::::::::::::: */
  21300.       break;
  21301.  
  21302.     case FFELEX_typeNAMES:
  21303.       if (ffesta_first_kw != FFESTR_firstTYPE)
  21304.     goto bad_0;        /* :::::::::::::::::::: */
  21305.       if (ffelex_token_length (ffesta_tokens[0]) != FFESTR_firstlTYPE)
  21306.     goto bad_0;        /* :::::::::::::::::::: */
  21307.       break;
  21308.  
  21309.     default:
  21310.       goto bad_0;        /* :::::::::::::::::::: */
  21311.     }
  21312.  
  21313.   switch (ffelex_token_type (t))
  21314.     {
  21315.     case FFELEX_typeOPEN_PAREN:
  21316.       break;
  21317.  
  21318.     case FFELEX_typeEOS:
  21319.     case FFELEX_typeSEMICOLON:
  21320.     case FFELEX_typeCOLONCOLON:/* Not COMMA: R424 "TYPE,PUBLIC::A". */
  21321.       ffesta_confirmed ();    /* Error, but clearly intended. */
  21322.       goto bad_1;        /* :::::::::::::::::::: */
  21323.  
  21324.     default:
  21325.       goto bad_1;        /* :::::::::::::::::::: */
  21326.     }
  21327.  
  21328.   ffestb_local_.decl.recursive = NULL;
  21329.   ffestb_local_.decl.parameter = FALSE;    /* No PARAMETER attribute seen. */
  21330.   ffestb_local_.decl.coloncolon = FALSE;    /* No COLONCOLON seen. */
  21331.  
  21332.   ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_attrsp_;
  21333.   ffestb_local_.decl.badname = "type-declaration";
  21334.   return (ffelexHandler) ffestb_decl_typetype1_;
  21335.  
  21336. bad_0:                /* :::::::::::::::::::: */
  21337.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", ffesta_tokens[0]);
  21338.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21339.  
  21340. bad_1:                /* :::::::::::::::::::: */
  21341.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  21342.   return (ffelexHandler) ffelex_swallow_tokens (t,
  21343.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  21344. }
  21345.  
  21346. #endif
  21347. /* ffestb_decl_attrs_ -- "type" [type parameters] COMMA
  21348.  
  21349.    return ffestb_decl_attrs_;  // to lexer
  21350.  
  21351.    Handle NAME of an attribute.     */
  21352.  
  21353. static ffelexHandler
  21354. ffestb_decl_attrs_ (ffelexToken t)
  21355. {
  21356.   switch (ffelex_token_type (t))
  21357.     {
  21358.     case FFELEX_typeNAME:
  21359.       switch (ffestr_first (t))
  21360.     {
  21361. #if FFESTR_F90
  21362.     case FFESTR_firstALLOCATABLE:
  21363.       if (!ffesta_is_inhibited ())
  21364.         ffestc_decl_attrib (FFESTP_attribALLOCATABLE, t,
  21365.                 FFESTR_otherNone, NULL);
  21366.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21367. #endif
  21368.  
  21369.     case FFESTR_firstDIMENSION:
  21370.       ffesta_tokens[1] = ffelex_token_use (t);
  21371.       return (ffelexHandler) ffestb_decl_attrs_1_;
  21372.  
  21373.     case FFESTR_firstEXTERNAL:
  21374.       if (!ffesta_is_inhibited ())
  21375.         ffestc_decl_attrib (FFESTP_attribEXTERNAL, t,
  21376.                 FFESTR_otherNone, NULL);
  21377.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21378.  
  21379. #if FFESTR_F90
  21380.     case FFESTR_firstINTENT:
  21381.       ffesta_tokens[1] = ffelex_token_use (t);
  21382.       return (ffelexHandler) ffestb_decl_attrs_3_;
  21383. #endif
  21384.  
  21385.     case FFESTR_firstINTRINSIC:
  21386.       if (!ffesta_is_inhibited ())
  21387.         ffestc_decl_attrib (FFESTP_attribINTRINSIC, t,
  21388.                 FFESTR_otherNone, NULL);
  21389.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21390.  
  21391. #if FFESTR_F90
  21392.     case FFESTR_firstOPTIONAL:
  21393.       if (!ffesta_is_inhibited ())
  21394.         ffestc_decl_attrib (FFESTP_attribOPTIONAL, t,
  21395.                 FFESTR_otherNone, NULL);
  21396.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21397. #endif
  21398.  
  21399.     case FFESTR_firstPARAMETER:
  21400.       ffestb_local_.decl.parameter = TRUE;
  21401.       if (!ffesta_is_inhibited ())
  21402.         ffestc_decl_attrib (FFESTP_attribPARAMETER, t,
  21403.                 FFESTR_otherNone, NULL);
  21404.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21405.  
  21406. #if FFESTR_F90
  21407.     case FFESTR_firstPOINTER:
  21408.       if (!ffesta_is_inhibited ())
  21409.         ffestc_decl_attrib (FFESTP_attribPOINTER, t,
  21410.                 FFESTR_otherNone, NULL);
  21411.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21412. #endif
  21413.  
  21414. #if FFESTR_F90
  21415.     case FFESTR_firstPRIVATE:
  21416.       if (!ffesta_is_inhibited ())
  21417.         ffestc_decl_attrib (FFESTP_attribPRIVATE, t,
  21418.                 FFESTR_otherNone, NULL);
  21419.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21420.  
  21421.     case FFESTR_firstPUBLIC:
  21422.       if (!ffesta_is_inhibited ())
  21423.         ffestc_decl_attrib (FFESTP_attribPUBLIC, t,
  21424.                 FFESTR_otherNone, NULL);
  21425.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21426. #endif
  21427.  
  21428.     case FFESTR_firstSAVE:
  21429.       if (!ffesta_is_inhibited ())
  21430.         ffestc_decl_attrib (FFESTP_attribSAVE, t,
  21431.                 FFESTR_otherNone, NULL);
  21432.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21433.  
  21434. #if FFESTR_F90
  21435.     case FFESTR_firstTARGET:
  21436.       if (!ffesta_is_inhibited ())
  21437.         ffestc_decl_attrib (FFESTP_attribTARGET, t,
  21438.                 FFESTR_otherNone, NULL);
  21439.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21440. #endif
  21441.  
  21442.     default:
  21443.       ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
  21444.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21445.     }
  21446.       break;
  21447.  
  21448.     default:
  21449.       break;
  21450.     }
  21451.  
  21452.   if (!ffesta_is_inhibited ())
  21453.     ffestc_decl_finish ();
  21454.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  21455.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21456. }
  21457.  
  21458. /* ffestb_decl_attrs_1_ -- "type" [type parameters] ",DIMENSION"
  21459.  
  21460.    return ffestb_decl_attrs_1_;     // to lexer
  21461.  
  21462.    Handle OPEN_PAREN.  */
  21463.  
  21464. static ffelexHandler
  21465. ffestb_decl_attrs_1_ (ffelexToken t)
  21466. {
  21467.   switch (ffelex_token_type (t))
  21468.     {
  21469.     case FFELEX_typeOPEN_PAREN:
  21470.       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
  21471.       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_decl_attrs_2_;
  21472.       ffestb_subrargs_.dim_list.pool = ffesta_scratch_pool;
  21473.       ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
  21474.     ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
  21475. #ifdef FFECOM_dimensionsMAX
  21476.       ffestb_subrargs_.dim_list.ndims = 0;
  21477. #endif
  21478.       return (ffelexHandler) ffeexpr_rhs (ffesta_scratch_pool,
  21479.                       ffestb_subrargs_.dim_list.ctx,
  21480.                     (ffeexprCallback) ffestb_subr_dimlist_);
  21481.  
  21482.     case FFELEX_typeCOMMA:
  21483.     case FFELEX_typeCOLONCOLON:
  21484.       ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, ffesta_tokens[1]);
  21485.       ffelex_token_kill (ffesta_tokens[1]);
  21486.       return (ffelexHandler) ffestb_decl_attrs_7_ (t);
  21487.  
  21488.     default:
  21489.       break;
  21490.     }
  21491.  
  21492.   if (!ffesta_is_inhibited ())
  21493.     ffestc_decl_finish ();
  21494.   ffelex_token_kill (ffesta_tokens[1]);
  21495.   ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
  21496.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21497. }
  21498.  
  21499. /* ffestb_decl_attrs_2_ -- "type" [type parameters] ",DIMENSION" OPEN_PAREN
  21500.               dimlist CLOSE_PAREN
  21501.  
  21502.    return ffestb_decl_attrs_2_;     // to lexer
  21503.  
  21504.    Handle COMMA or COLONCOLON.    */
  21505.  
  21506. static ffelexHandler
  21507. ffestb_decl_attrs_2_ (ffelexToken t)
  21508. {
  21509.   if (!ffestb_subrargs_.dim_list.ok)
  21510.     goto bad;            /* :::::::::::::::::::: */
  21511.  
  21512.   switch (ffelex_token_type (t))
  21513.     {
  21514.     case FFELEX_typeCOMMA:
  21515.     case FFELEX_typeCOLONCOLON:
  21516.       if (!ffesta_is_inhibited ())
  21517.     ffestc_decl_attrib (FFESTP_attribDIMENSION, ffesta_tokens[1],
  21518.               FFESTR_otherNone, ffestb_subrargs_.dim_list.dims);
  21519.       ffelex_token_kill (ffesta_tokens[1]);
  21520.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  21521.       return (ffelexHandler) ffestb_decl_attrs_7_ (t);
  21522.  
  21523.     default:
  21524.       break;
  21525.     }
  21526.  
  21527. bad:                /* :::::::::::::::::::: */
  21528.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  21529.   if (!ffesta_is_inhibited ())
  21530.     ffestc_decl_finish ();
  21531.   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  21532.   ffelex_token_kill (ffesta_tokens[1]);
  21533.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21534. }
  21535.  
  21536. /* ffestb_decl_attrs_3_ -- "type" [type parameters] ",INTENT"
  21537.  
  21538.    return ffestb_decl_attrs_3_;     // to lexer
  21539.  
  21540.    Handle OPEN_PAREN.  */
  21541.  
  21542. #if FFESTR_F90
  21543. static ffelexHandler
  21544. ffestb_decl_attrs_3_ (ffelexToken t)
  21545. {
  21546.   switch (ffelex_token_type (t))
  21547.     {
  21548.     case FFELEX_typeOPEN_PAREN:
  21549.       return (ffelexHandler) ffestb_decl_attrs_4_;
  21550.  
  21551.     case FFELEX_typeCOMMA:
  21552.     case FFELEX_typeCOLONCOLON:
  21553.       ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, ffesta_tokens[1]);
  21554.       ffelex_token_kill (ffesta_tokens[1]);
  21555.       return (ffelexHandler) ffestb_decl_attrs_7_ (t);
  21556.  
  21557.     default:
  21558.       break;
  21559.     }
  21560.  
  21561.   if (!ffesta_is_inhibited ())
  21562.     ffestc_decl_finish ();
  21563.   ffelex_token_kill (ffesta_tokens[1]);
  21564.   ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
  21565.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21566. }
  21567.  
  21568. /* ffestb_decl_attrs_4_ -- "type" [type parameters] ",INTENT" OPEN_PAREN
  21569.  
  21570.    return ffestb_decl_attrs_4_;     // to lexer
  21571.  
  21572.    Handle NAME.     */
  21573.  
  21574. static ffelexHandler
  21575. ffestb_decl_attrs_4_ (ffelexToken t)
  21576. {
  21577.   switch (ffelex_token_type (t))
  21578.     {
  21579.     case FFELEX_typeNAME:
  21580.       ffestb_local_.decl.kw = ffestr_other (t);
  21581.       switch (ffestb_local_.decl.kw)
  21582.     {
  21583.     case FFESTR_otherIN:
  21584.       return (ffelexHandler) ffestb_decl_attrs_5_;
  21585.  
  21586.     case FFESTR_otherINOUT:
  21587.       return (ffelexHandler) ffestb_decl_attrs_6_;
  21588.  
  21589.     case FFESTR_otherOUT:
  21590.       return (ffelexHandler) ffestb_decl_attrs_6_;
  21591.  
  21592.     default:
  21593.       ffestb_local_.decl.kw = FFESTR_otherNone;
  21594.       ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
  21595.       return (ffelexHandler) ffestb_decl_attrs_5_;
  21596.     }
  21597.       break;
  21598.  
  21599.     default:
  21600.       break;
  21601.     }
  21602.  
  21603.   if (!ffesta_is_inhibited ())
  21604.     ffestc_decl_finish ();
  21605.   ffelex_token_kill (ffesta_tokens[1]);
  21606.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  21607.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21608. }
  21609.  
  21610. /* ffestb_decl_attrs_5_ -- "type" [type parameters] ",INTENT" OPEN_PAREN "IN"
  21611.  
  21612.    return ffestb_decl_attrs_5_;     // to lexer
  21613.  
  21614.    Handle NAME or CLOSE_PAREN.    */
  21615.  
  21616. static ffelexHandler
  21617. ffestb_decl_attrs_5_ (ffelexToken t)
  21618. {
  21619.   switch (ffelex_token_type (t))
  21620.     {
  21621.     case FFELEX_typeNAME:
  21622.       switch (ffestr_other (t))
  21623.     {
  21624.     case FFESTR_otherOUT:
  21625.       if (ffestb_local_.decl.kw != FFESTR_otherNone)
  21626.         ffestb_local_.decl.kw = FFESTR_otherINOUT;
  21627.       return (ffelexHandler) ffestb_decl_attrs_6_;
  21628.  
  21629.     default:
  21630.       if (ffestb_local_.decl.kw != FFESTR_otherNone)
  21631.         {
  21632.           ffestb_local_.decl.kw = FFESTR_otherNone;
  21633.           ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_ATTR, t);
  21634.         }
  21635.       return (ffelexHandler) ffestb_decl_attrs_5_;
  21636.     }
  21637.       break;
  21638.  
  21639.     case FFELEX_typeCLOSE_PAREN:
  21640.       return (ffelexHandler) ffestb_decl_attrs_6_ (t);
  21641.  
  21642.     default:
  21643.       break;
  21644.     }
  21645.  
  21646.   if (!ffesta_is_inhibited ())
  21647.     ffestc_decl_finish ();
  21648.   ffelex_token_kill (ffesta_tokens[1]);
  21649.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  21650.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21651. }
  21652.  
  21653. /* ffestb_decl_attrs_6_ -- "type" [type parameters] ",INTENT" OPEN_PAREN "IN"
  21654.               ["OUT"]
  21655.  
  21656.    return ffestb_decl_attrs_6_;     // to lexer
  21657.  
  21658.    Handle CLOSE_PAREN.    */
  21659.  
  21660. static ffelexHandler
  21661. ffestb_decl_attrs_6_ (ffelexToken t)
  21662. {
  21663.   switch (ffelex_token_type (t))
  21664.     {
  21665.     case FFELEX_typeCLOSE_PAREN:
  21666.       if ((ffestb_local_.decl.kw != FFESTR_otherNone)
  21667.       && !ffesta_is_inhibited ())
  21668.     ffestc_decl_attrib (FFESTP_attribINTENT, ffesta_tokens[1],
  21669.                 ffestb_local_.decl.kw, NULL);
  21670.       ffelex_token_kill (ffesta_tokens[1]);
  21671.       return (ffelexHandler) ffestb_decl_attrs_7_;
  21672.  
  21673.     default:
  21674.       break;
  21675.     }
  21676.  
  21677.   if (!ffesta_is_inhibited ())
  21678.     ffestc_decl_finish ();
  21679.   ffelex_token_kill (ffesta_tokens[1]);
  21680.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  21681.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21682. }
  21683.  
  21684. #endif
  21685. /* ffestb_decl_attrs_7_ -- "type" [type parameters] attribute
  21686.  
  21687.    return ffestb_decl_attrs_7_;     // to lexer
  21688.  
  21689.    Handle COMMA (another attribute) or COLONCOLON (entities).  */
  21690.  
  21691. static ffelexHandler
  21692. ffestb_decl_attrs_7_ (ffelexToken t)
  21693. {
  21694.   switch (ffelex_token_type (t))
  21695.     {
  21696.     case FFELEX_typeCOMMA:
  21697.       return (ffelexHandler) ffestb_decl_attrs_;
  21698.  
  21699.     case FFELEX_typeCOLONCOLON:
  21700.       ffestb_local_.decl.coloncolon = TRUE;
  21701.       return (ffelexHandler) ffestb_decl_ents_;
  21702.  
  21703.     default:
  21704.       break;
  21705.     }
  21706.  
  21707.   if (!ffesta_is_inhibited ())
  21708.     ffestc_decl_finish ();
  21709.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  21710.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21711. }
  21712.  
  21713. /* ffestb_decl_attrsp_ -- "type" [type parameters]
  21714.  
  21715.    return ffestb_decl_attrsp_;    // to lexer
  21716.  
  21717.    Handle COMMA (meaning we have attributes), COLONCOLON (meaning we have
  21718.    no attributes but entities), or go to entsp to see about functions or
  21719.    entities.  */
  21720.  
  21721. static ffelexHandler
  21722. ffestb_decl_attrsp_ (ffelexToken t)
  21723. {
  21724.   ffelex_set_names (FALSE);
  21725.  
  21726.   switch (ffelex_token_type (t))
  21727.     {
  21728.     case FFELEX_typeCOMMA:
  21729.       ffesta_confirmed ();
  21730.       if (!ffesta_is_inhibited ())
  21731.     ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  21732.                ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
  21733.                ffestb_local_.decl.len, ffestb_local_.decl.lent);
  21734.       if (ffestb_local_.decl.kindt != NULL)
  21735.     ffelex_token_kill (ffestb_local_.decl.kindt);
  21736.       if (ffestb_local_.decl.lent != NULL)
  21737.     ffelex_token_kill (ffestb_local_.decl.lent);
  21738.       return (ffelexHandler) ffestb_decl_attrs_;
  21739.  
  21740.     case FFELEX_typeCOLONCOLON:
  21741.       ffestb_local_.decl.coloncolon = TRUE;
  21742.       ffesta_confirmed ();
  21743.       if (!ffesta_is_inhibited ())
  21744.     ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  21745.                ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
  21746.                ffestb_local_.decl.len, ffestb_local_.decl.lent);
  21747.       if (ffestb_local_.decl.kindt != NULL)
  21748.     ffelex_token_kill (ffestb_local_.decl.kindt);
  21749.       if (ffestb_local_.decl.lent != NULL)
  21750.     ffelex_token_kill (ffestb_local_.decl.lent);
  21751.       return (ffelexHandler) ffestb_decl_ents_;
  21752.  
  21753.     default:
  21754.       return (ffelexHandler) ffestb_decl_entsp_ (t);
  21755.     }
  21756. }
  21757.  
  21758. /* ffestb_decl_ents_ -- "type" [type parameters] [attributes "::"]
  21759.  
  21760.    return ffestb_decl_ents_;  // to lexer
  21761.  
  21762.    Handle NAME of an entity.  */
  21763.  
  21764. static ffelexHandler
  21765. ffestb_decl_ents_ (ffelexToken t)
  21766. {
  21767.   switch (ffelex_token_type (t))
  21768.     {
  21769.     case FFELEX_typeNAME:
  21770.       ffesta_tokens[1] = ffelex_token_use (t);
  21771.       return (ffelexHandler) ffestb_decl_ents_1_;
  21772.  
  21773.     default:
  21774.       break;
  21775.     }
  21776.  
  21777.   if (!ffesta_is_inhibited ())
  21778.     ffestc_decl_finish ();
  21779.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  21780.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21781. }
  21782.  
  21783. /* ffestb_decl_ents_1_ -- "type" [type parameters] [attributes "::"] NAME
  21784.  
  21785.    return ffestb_decl_ents_1_;    // to lexer
  21786.  
  21787.    Handle ASTERISK, OPEN_PAREN, EQUALS, SLASH, COMMA, or EOS/SEMICOLON.     */
  21788.  
  21789. static ffelexHandler
  21790. ffestb_decl_ents_1_ (ffelexToken t)
  21791. {
  21792.   switch (ffelex_token_type (t))
  21793.     {
  21794.     case FFELEX_typeCOMMA:
  21795.       if (!ffesta_is_inhibited ())
  21796.     ffestc_decl_item (ffesta_tokens[1], NULL, NULL, NULL, NULL, NULL, NULL,
  21797.               NULL, FALSE);
  21798.       ffelex_token_kill (ffesta_tokens[1]);
  21799.       return (ffelexHandler) ffestb_decl_ents_;
  21800.  
  21801.     case FFELEX_typeEOS:
  21802.     case FFELEX_typeSEMICOLON:
  21803.       if (!ffesta_is_inhibited ())
  21804.     {
  21805.       ffestc_decl_item (ffesta_tokens[1], NULL, NULL, NULL, NULL, NULL, NULL,
  21806.                 NULL, FALSE);
  21807.       ffestc_decl_finish ();
  21808.     }
  21809.       ffelex_token_kill (ffesta_tokens[1]);
  21810.       return (ffelexHandler) ffesta_zero (t);
  21811.  
  21812.     case FFELEX_typeASTERISK:
  21813.       ffestb_local_.decl.len = NULL;
  21814.       ffestb_local_.decl.lent = NULL;
  21815.       return (ffelexHandler) ffestb_decl_ents_2_;
  21816.  
  21817.     case FFELEX_typeOPEN_PAREN:
  21818.       ffestb_local_.decl.kind = NULL;
  21819.       ffestb_local_.decl.kindt = NULL;
  21820.       ffestb_local_.decl.len = NULL;
  21821.       ffestb_local_.decl.lent = NULL;
  21822.       return (ffelexHandler) ffestb_decl_ents_3_ (t);
  21823.  
  21824.     case FFELEX_typeEQUALS:
  21825.     case FFELEX_typeSLASH:
  21826.       ffestb_local_.decl.kind = NULL;
  21827.       ffestb_local_.decl.kindt = NULL;
  21828.       ffestb_subrargs_.dim_list.dims = NULL;
  21829.       ffestb_local_.decl.len = NULL;
  21830.       ffestb_local_.decl.lent = NULL;
  21831.       return (ffelexHandler) ffestb_decl_ents_7_ (t);
  21832.  
  21833.     default:
  21834.       break;
  21835.     }
  21836.  
  21837.   if (!ffesta_is_inhibited ())
  21838.     ffestc_decl_finish ();
  21839.   ffelex_token_kill (ffesta_tokens[1]);
  21840.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  21841.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21842. }
  21843.  
  21844. /* ffestb_decl_ents_2_ -- "type" [type parameters] [attributes "::"] NAME
  21845.              ASTERISK
  21846.  
  21847.    return ffestb_decl_ents_2_;    // to lexer
  21848.  
  21849.    Handle NUMBER or OPEN_PAREN.     */
  21850.  
  21851. static ffelexHandler
  21852. ffestb_decl_ents_2_ (ffelexToken t)
  21853. {
  21854.   switch (ffelex_token_type (t))
  21855.     {
  21856.     case FFELEX_typeNUMBER:
  21857.       if (ffestb_local_.decl.type != FFESTP_typeCHARACTER)
  21858.     {
  21859.       ffestb_local_.decl.kind = NULL;
  21860.       ffestb_local_.decl.kindt = ffelex_token_use (t);
  21861.       return (ffelexHandler) ffestb_decl_ents_3_;
  21862.     }
  21863.       /* Fall through. *//* (CHARACTER's *n is always a len spec. */
  21864.     case FFELEX_typeOPEN_PAREN:/* "*(" is after the (omitted)
  21865.                    "(array-spec)". */
  21866.       ffestb_local_.decl.kind = NULL;
  21867.       ffestb_local_.decl.kindt = NULL;
  21868.       ffestb_subrargs_.dim_list.dims = NULL;
  21869.       return (ffelexHandler) ffestb_decl_ents_5_ (t);
  21870.  
  21871.     default:
  21872.       break;
  21873.     }
  21874.  
  21875.   if (!ffesta_is_inhibited ())
  21876.     ffestc_decl_finish ();
  21877.   ffelex_token_kill (ffesta_tokens[1]);
  21878.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  21879.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21880. }
  21881.  
  21882. /* ffestb_decl_ents_3_ -- "type" [type parameters] [attributes "::"] NAME
  21883.              [ASTERISK NUMBER]
  21884.  
  21885.    return ffestb_decl_ents_3_;    // to lexer
  21886.  
  21887.    Handle ASTERISK, OPEN_PAREN, EQUALS, SLASH, COMMA, or EOS/SEMICOLON.     */
  21888.  
  21889. static ffelexHandler
  21890. ffestb_decl_ents_3_ (ffelexToken t)
  21891. {
  21892.   switch (ffelex_token_type (t))
  21893.     {
  21894.     case FFELEX_typeCOMMA:
  21895.       if (!ffesta_is_inhibited ())
  21896.     ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
  21897.          ffestb_local_.decl.kindt, NULL, NULL, NULL, NULL, NULL, FALSE);
  21898.       ffelex_token_kill (ffesta_tokens[1]);
  21899.       if (ffestb_local_.decl.kindt != NULL)
  21900.     ffelex_token_kill (ffestb_local_.decl.kindt);
  21901.       return (ffelexHandler) ffestb_decl_ents_;
  21902.  
  21903.     case FFELEX_typeEOS:
  21904.     case FFELEX_typeSEMICOLON:
  21905.       if (!ffesta_is_inhibited ())
  21906.     {
  21907.       ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
  21908.          ffestb_local_.decl.kindt, NULL, NULL, NULL, NULL, NULL, FALSE);
  21909.       ffestc_decl_finish ();
  21910.     }
  21911.       ffelex_token_kill (ffesta_tokens[1]);
  21912.       if (ffestb_local_.decl.kindt != NULL)
  21913.     ffelex_token_kill (ffestb_local_.decl.kindt);
  21914.       return (ffelexHandler) ffesta_zero (t);
  21915.  
  21916.     case FFELEX_typeASTERISK:
  21917.       ffestb_subrargs_.dim_list.dims = NULL;
  21918.       return (ffelexHandler) ffestb_decl_ents_5_;
  21919.  
  21920.     case FFELEX_typeOPEN_PAREN:
  21921.       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
  21922.       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_decl_ents_4_;
  21923.       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
  21924.       ffestb_subrargs_.dim_list.ctx = ffesta_is_entry_valid
  21925.     ? FFEEXPR_contextDIMLIST : FFEEXPR_contextDIMLISTCOMMON;
  21926. #ifdef FFECOM_dimensionsMAX
  21927.       ffestb_subrargs_.dim_list.ndims = 0;
  21928. #endif
  21929.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  21930.                       ffestb_subrargs_.dim_list.ctx,
  21931.                     (ffeexprCallback) ffestb_subr_dimlist_);
  21932.  
  21933.     case FFELEX_typeEQUALS:
  21934.     case FFELEX_typeSLASH:
  21935.       ffestb_local_.decl.kind = NULL;
  21936.       ffestb_local_.decl.kindt = NULL;
  21937.       ffestb_subrargs_.dim_list.dims = NULL;
  21938.       ffestb_local_.decl.len = NULL;
  21939.       ffestb_local_.decl.lent = NULL;
  21940.       return (ffelexHandler) ffestb_decl_ents_7_ (t);
  21941.  
  21942.     default:
  21943.       break;
  21944.     }
  21945.  
  21946.   if (!ffesta_is_inhibited ())
  21947.     ffestc_decl_finish ();
  21948.   ffelex_token_kill (ffesta_tokens[1]);
  21949.   if (ffestb_local_.decl.kindt != NULL)
  21950.     ffelex_token_kill (ffestb_local_.decl.kindt);
  21951.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  21952.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  21953. }
  21954.  
  21955. /* ffestb_decl_ents_4_ -- "type" [type parameters] [attributes "::"] NAME
  21956.              [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
  21957.  
  21958.    return ffestb_decl_ents_4_;    // to lexer
  21959.  
  21960.    Handle ASTERISK, EQUALS, SLASH, COMMA, or EOS/SEMICOLON.  */
  21961.  
  21962. static ffelexHandler
  21963. ffestb_decl_ents_4_ (ffelexToken t)
  21964. {
  21965.   ffelexToken nt;
  21966.  
  21967.   if (!ffestb_subrargs_.dim_list.ok)
  21968.     goto bad;            /* :::::::::::::::::::: */
  21969.  
  21970.   if (ffelex_token_type (ffesta_tokens[1]) == FFELEX_typeNAMES)
  21971.     {
  21972.       switch (ffelex_token_type (t))
  21973.     {
  21974.     case FFELEX_typeCOMMA:
  21975.     case FFELEX_typeEOS:
  21976.     case FFELEX_typeSEMICOLON:
  21977.     case FFELEX_typeASTERISK:
  21978.     case FFELEX_typeSLASH:    /* But NOT FFELEX_typeEQUALS. */
  21979.     case FFELEX_typeCOLONCOLON:    /* Actually an error. */
  21980.       break;        /* Confirm and handle. */
  21981.  
  21982.     default:        /* Perhaps EQUALS, as in
  21983.                    INTEGERFUNCTIONX(A)=B. */
  21984.       goto bad;        /* :::::::::::::::::::: */
  21985.     }
  21986.       ffesta_confirmed ();
  21987.       if (!ffesta_is_inhibited ())
  21988.     {
  21989.       nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
  21990.       ffelex_token_kill (ffesta_tokens[1]);
  21991.       ffesta_tokens[1] = nt;
  21992.       ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  21993.                  NULL, NULL, NULL, NULL);
  21994.     }
  21995.     }
  21996.  
  21997.   switch (ffelex_token_type (t))
  21998.     {
  21999.     case FFELEX_typeCOMMA:
  22000.       if (!ffesta_is_inhibited ())
  22001.     ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
  22002.            ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
  22003.         ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
  22004.               FALSE);
  22005.       ffelex_token_kill (ffesta_tokens[1]);
  22006.       if (ffestb_local_.decl.kindt != NULL)
  22007.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22008.       if (ffestb_local_.decl.lent != NULL)
  22009.     ffelex_token_kill (ffestb_local_.decl.lent);
  22010.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22011.       return (ffelexHandler) ffestb_decl_ents_;
  22012.  
  22013.     case FFELEX_typeEOS:
  22014.     case FFELEX_typeSEMICOLON:
  22015.       if (!ffesta_is_inhibited ())
  22016.     {
  22017.       ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
  22018.            ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
  22019.         ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
  22020.                 FALSE);
  22021.       ffestc_decl_finish ();
  22022.     }
  22023.       ffelex_token_kill (ffesta_tokens[1]);
  22024.       if (ffestb_local_.decl.kindt != NULL)
  22025.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22026.       if (ffestb_local_.decl.lent != NULL)
  22027.     ffelex_token_kill (ffestb_local_.decl.lent);
  22028.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22029.       return (ffelexHandler) ffesta_zero (t);
  22030.  
  22031.     case FFELEX_typeASTERISK:
  22032.       if (ffestb_local_.decl.lent != NULL)
  22033.     break;            /* Can't specify "*length" twice. */
  22034.       return (ffelexHandler) ffestb_decl_ents_5_;
  22035.  
  22036.     case FFELEX_typeEQUALS:
  22037.     case FFELEX_typeSLASH:
  22038.       return (ffelexHandler) ffestb_decl_ents_7_ (t);
  22039.  
  22040.     default:
  22041.       break;
  22042.     }
  22043.  
  22044. bad:                /* :::::::::::::::::::: */
  22045.   if ((ffelex_token_type (ffesta_tokens[1]) != FFELEX_typeNAMES)
  22046.       && !ffesta_is_inhibited ())
  22047.     ffestc_decl_finish ();
  22048.   ffelex_token_kill (ffesta_tokens[1]);
  22049.   if (ffestb_local_.decl.kindt != NULL)
  22050.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22051.   if (ffestb_local_.decl.lent != NULL)
  22052.     ffelex_token_kill (ffestb_local_.decl.lent);
  22053.   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22054.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  22055.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22056. }
  22057.  
  22058. /* ffestb_decl_ents_5_ -- "type" [type parameters] [attributes "::"] NAME
  22059.              [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
  22060.              ASTERISK
  22061.  
  22062.    return ffestb_decl_ents_5_;    // to lexer
  22063.  
  22064.    Handle NUMBER or OPEN_PAREN.     */
  22065.  
  22066. static ffelexHandler
  22067. ffestb_decl_ents_5_ (ffelexToken t)
  22068. {
  22069.   switch (ffelex_token_type (t))
  22070.     {
  22071.     case FFELEX_typeNUMBER:
  22072.       ffestb_local_.decl.len = NULL;
  22073.       ffestb_local_.decl.lent = ffelex_token_use (t);
  22074.       return (ffelexHandler) ffestb_decl_ents_7_;
  22075.  
  22076.     case FFELEX_typeOPEN_PAREN:
  22077.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  22078.        FFEEXPR_contextCHARACTERSIZE, (ffeexprCallback) ffestb_decl_ents_6_);
  22079.  
  22080.     default:
  22081.       break;
  22082.     }
  22083.  
  22084.   if (!ffesta_is_inhibited ())
  22085.     ffestc_decl_finish ();
  22086.   ffelex_token_kill (ffesta_tokens[1]);
  22087.   if (ffestb_local_.decl.kindt != NULL)
  22088.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22089.   if (ffestb_subrargs_.dim_list.dims != NULL)
  22090.     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22091.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  22092.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22093. }
  22094.  
  22095. /* ffestb_decl_ents_6_ -- "type" [type parameters] [attributes "::"] NAME
  22096.              [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
  22097.              ASTERISK OPEN_PAREN expr
  22098.  
  22099.    (ffestb_decl_ents_6_)  // to expression handler
  22100.  
  22101.    Handle CLOSE_PAREN.    */
  22102.  
  22103. static ffelexHandler
  22104. ffestb_decl_ents_6_ (ffelexToken ft, ffebld expr, ffelexToken t)
  22105. {
  22106.   switch (ffelex_token_type (t))
  22107.     {
  22108.     case FFELEX_typeCLOSE_PAREN:
  22109.       if (expr == NULL)
  22110.     break;
  22111.       ffestb_local_.decl.len = expr;
  22112.       ffestb_local_.decl.lent = ffelex_token_use (ft);
  22113.       return (ffelexHandler) ffestb_decl_ents_7_;
  22114.  
  22115.     default:
  22116.       break;
  22117.     }
  22118.  
  22119.   if (!ffesta_is_inhibited ())
  22120.     ffestc_decl_finish ();
  22121.   ffelex_token_kill (ffesta_tokens[1]);
  22122.   if (ffestb_local_.decl.kindt != NULL)
  22123.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22124.   if (ffestb_subrargs_.dim_list.dims != NULL)
  22125.     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22126.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  22127.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22128. }
  22129.  
  22130. /* ffestb_decl_ents_7_ -- "type" [type parameters] [attributes "::"] NAME
  22131.              [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
  22132.              [ASTERISK charlength]
  22133.  
  22134.    return ffestb_decl_ents_7_;    // to lexer
  22135.  
  22136.    Handle EQUALS, SLASH, COMMA, or EOS/SEMICOLON.  */
  22137.  
  22138. static ffelexHandler
  22139. ffestb_decl_ents_7_ (ffelexToken t)
  22140. {
  22141.   switch (ffelex_token_type (t))
  22142.     {
  22143.     case FFELEX_typeCOMMA:
  22144.       if (!ffesta_is_inhibited ())
  22145.     ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
  22146.            ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
  22147.         ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
  22148.               FALSE);
  22149.       ffelex_token_kill (ffesta_tokens[1]);
  22150.       if (ffestb_local_.decl.kindt != NULL)
  22151.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22152.       if (ffestb_subrargs_.dim_list.dims != NULL)
  22153.     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22154.       if (ffestb_local_.decl.lent != NULL)
  22155.     ffelex_token_kill (ffestb_local_.decl.lent);
  22156.       return (ffelexHandler) ffestb_decl_ents_;
  22157.  
  22158.     case FFELEX_typeEOS:
  22159.     case FFELEX_typeSEMICOLON:
  22160.       if (!ffesta_is_inhibited ())
  22161.     {
  22162.       ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
  22163.            ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
  22164.         ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
  22165.                 FALSE);
  22166.       ffestc_decl_finish ();
  22167.     }
  22168.       ffelex_token_kill (ffesta_tokens[1]);
  22169.       if (ffestb_local_.decl.kindt != NULL)
  22170.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22171.       if (ffestb_subrargs_.dim_list.dims != NULL)
  22172.     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22173.       if (ffestb_local_.decl.lent != NULL)
  22174.     ffelex_token_kill (ffestb_local_.decl.lent);
  22175.       return (ffelexHandler) ffesta_zero (t);
  22176.  
  22177.     case FFELEX_typeEQUALS:
  22178.       if (!ffestb_local_.decl.coloncolon)
  22179.     ffesta_ffebad_1t (FFEBAD_INVALID_TYPEDECL_INIT, t);
  22180.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  22181.              ffestb_local_.decl.parameter ? FFEEXPR_contextPARAMETER
  22182.        : FFEEXPR_contextINITVAL, (ffeexprCallback) ffestb_decl_ents_8_);
  22183.  
  22184.     case FFELEX_typeSLASH:
  22185.       if (!ffesta_is_inhibited ())
  22186.     {
  22187.       ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
  22188.            ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
  22189.         ffestb_local_.decl.len, ffestb_local_.decl.lent, NULL, NULL,
  22190.                 TRUE);
  22191.       ffestc_decl_itemstartvals ();
  22192.     }
  22193.       ffelex_token_kill (ffesta_tokens[1]);
  22194.       if (ffestb_local_.decl.kindt != NULL)
  22195.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22196.       if (ffestb_subrargs_.dim_list.dims != NULL)
  22197.     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22198.       if (ffestb_local_.decl.lent != NULL)
  22199.     ffelex_token_kill (ffestb_local_.decl.lent);
  22200.       return (ffelexHandler) ffeexpr_rhs
  22201.     (ffesta_output_pool, FFEEXPR_contextDATA,
  22202.      (ffeexprCallback) ffestb_decl_ents_9_);
  22203.  
  22204.     default:
  22205.       break;
  22206.     }
  22207.  
  22208.   if (!ffesta_is_inhibited ())
  22209.     ffestc_decl_finish ();
  22210.   ffelex_token_kill (ffesta_tokens[1]);
  22211.   if (ffestb_local_.decl.kindt != NULL)
  22212.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22213.   if (ffestb_subrargs_.dim_list.dims != NULL)
  22214.     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22215.   if (ffestb_local_.decl.lent != NULL)
  22216.     ffelex_token_kill (ffestb_local_.decl.lent);
  22217.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  22218.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22219. }
  22220.  
  22221. /* ffestb_decl_ents_8_ -- "type" [type parameters] [attributes "::"] NAME
  22222.              [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
  22223.              [ASTERISK charlength] EQUALS expr
  22224.  
  22225.    (ffestb_decl_ents_8_)  // to expression handler
  22226.  
  22227.    Handle COMMA or EOS/SEMICOLON.  */
  22228.  
  22229. static ffelexHandler
  22230. ffestb_decl_ents_8_ (ffelexToken ft, ffebld expr, ffelexToken t)
  22231. {
  22232.   switch (ffelex_token_type (t))
  22233.     {
  22234.     case FFELEX_typeCOMMA:
  22235.       if (expr == NULL)
  22236.     break;
  22237.       if (!ffesta_is_inhibited ())
  22238.     ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
  22239.            ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
  22240.           ffestb_local_.decl.len, ffestb_local_.decl.lent, expr, ft,
  22241.               FALSE);
  22242.       ffelex_token_kill (ffesta_tokens[1]);
  22243.       if (ffestb_local_.decl.kindt != NULL)
  22244.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22245.       if (ffestb_subrargs_.dim_list.dims != NULL)
  22246.     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22247.       if (ffestb_local_.decl.lent != NULL)
  22248.     ffelex_token_kill (ffestb_local_.decl.lent);
  22249.       return (ffelexHandler) ffestb_decl_ents_;
  22250.  
  22251.     case FFELEX_typeEOS:
  22252.     case FFELEX_typeSEMICOLON:
  22253.       if (!ffesta_is_inhibited ())
  22254.     {
  22255.       ffestc_decl_item (ffesta_tokens[1], ffestb_local_.decl.kind,
  22256.            ffestb_local_.decl.kindt, ffestb_subrargs_.dim_list.dims,
  22257.           ffestb_local_.decl.len, ffestb_local_.decl.lent, expr, ft,
  22258.                 FALSE);
  22259.       ffestc_decl_finish ();
  22260.     }
  22261.       ffelex_token_kill (ffesta_tokens[1]);
  22262.       if (ffestb_local_.decl.kindt != NULL)
  22263.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22264.       if (ffestb_subrargs_.dim_list.dims != NULL)
  22265.     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22266.       if (ffestb_local_.decl.lent != NULL)
  22267.     ffelex_token_kill (ffestb_local_.decl.lent);
  22268.       return (ffelexHandler) ffesta_zero (t);
  22269.  
  22270.     default:
  22271.       break;
  22272.     }
  22273.  
  22274.   if (!ffesta_is_inhibited ())
  22275.     ffestc_decl_finish ();
  22276.   ffelex_token_kill (ffesta_tokens[1]);
  22277.   if (ffestb_local_.decl.kindt != NULL)
  22278.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22279.   if (ffestb_subrargs_.dim_list.dims != NULL)
  22280.     ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  22281.   if (ffestb_local_.decl.lent != NULL)
  22282.     ffelex_token_kill (ffestb_local_.decl.lent);
  22283.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  22284.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22285. }
  22286.  
  22287. /* ffestb_decl_ents_9_ -- "type" ... SLASH expr
  22288.  
  22289.    (ffestb_decl_ents_9_)  // to expression handler
  22290.  
  22291.    Handle ASTERISK, COMMA, or SLASH.  */
  22292.  
  22293. static ffelexHandler
  22294. ffestb_decl_ents_9_ (ffelexToken ft, ffebld expr, ffelexToken t)
  22295. {
  22296.   switch (ffelex_token_type (t))
  22297.     {
  22298.     case FFELEX_typeCOMMA:
  22299.       if (expr == NULL)
  22300.     break;
  22301.       if (!ffesta_is_inhibited ())
  22302.     ffestc_decl_itemvalue (NULL, NULL, expr, ft);
  22303.       return (ffelexHandler) ffeexpr_rhs
  22304.     (ffesta_output_pool, FFEEXPR_contextDATA,
  22305.      (ffeexprCallback) ffestb_decl_ents_9_);
  22306.  
  22307.     case FFELEX_typeASTERISK:
  22308.       if (expr == NULL)
  22309.     break;
  22310.       ffestb_local_.decl.expr = expr;
  22311.       ffesta_tokens[1] = ffelex_token_use (ft);
  22312.       return (ffelexHandler) ffeexpr_rhs
  22313.     (ffesta_output_pool, FFEEXPR_contextDATA,
  22314.      (ffeexprCallback) ffestb_decl_ents_10_);
  22315.  
  22316.     case FFELEX_typeSLASH:
  22317.       if (expr == NULL)
  22318.     break;
  22319.       if (!ffesta_is_inhibited ())
  22320.     {
  22321.       ffestc_decl_itemvalue (NULL, NULL, expr, ft);
  22322.       ffestc_decl_itemendvals (t);
  22323.     }
  22324.       return (ffelexHandler) ffestb_decl_ents_11_;
  22325.  
  22326.     default:
  22327.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  22328.       break;
  22329.     }
  22330.  
  22331.   if (!ffesta_is_inhibited ())
  22332.     {
  22333.       ffestc_decl_itemendvals (t);
  22334.       ffestc_decl_finish ();
  22335.     }
  22336.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22337. }
  22338.  
  22339. /* ffestb_decl_ents_10_ -- "type" ... SLASH expr ASTERISK expr
  22340.  
  22341.    (ffestb_decl_ents_10_)  // to expression handler
  22342.  
  22343.    Handle COMMA or SLASH.  */
  22344.  
  22345. static ffelexHandler
  22346. ffestb_decl_ents_10_ (ffelexToken ft, ffebld expr, ffelexToken t)
  22347. {
  22348.   switch (ffelex_token_type (t))
  22349.     {
  22350.     case FFELEX_typeCOMMA:
  22351.       if (expr == NULL)
  22352.     break;
  22353.       if (!ffesta_is_inhibited ())
  22354.     ffestc_decl_itemvalue (ffestb_local_.decl.expr, ffesta_tokens[1],
  22355.                    expr, ft);
  22356.       ffelex_token_kill (ffesta_tokens[1]);
  22357.       return (ffelexHandler) ffeexpr_rhs
  22358.     (ffesta_output_pool, FFEEXPR_contextDATA,
  22359.      (ffeexprCallback) ffestb_decl_ents_9_);
  22360.  
  22361.     case FFELEX_typeSLASH:
  22362.       if (expr == NULL)
  22363.     break;
  22364.       if (!ffesta_is_inhibited ())
  22365.     {
  22366.       ffestc_decl_itemvalue (ffestb_local_.decl.expr, ffesta_tokens[1],
  22367.                  expr, ft);
  22368.       ffestc_decl_itemendvals (t);
  22369.     }
  22370.       ffelex_token_kill (ffesta_tokens[1]);
  22371.       return (ffelexHandler) ffestb_decl_ents_11_;
  22372.  
  22373.     default:
  22374.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  22375.       break;
  22376.     }
  22377.  
  22378.   if (!ffesta_is_inhibited ())
  22379.     {
  22380.       ffestc_decl_itemendvals (t);
  22381.       ffestc_decl_finish ();
  22382.     }
  22383.   ffelex_token_kill (ffesta_tokens[1]);
  22384.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22385. }
  22386.  
  22387. /* ffestb_decl_ents_11_ -- "type" [type parameters] [attributes "::"] NAME
  22388.              [ASTERISK NUMBER] [OPEN_PAREN dimlist CLOSE_PAREN]
  22389.              [ASTERISK charlength] SLASH initvals SLASH
  22390.  
  22391.    return ffestb_decl_ents_11_;     // to lexer
  22392.  
  22393.    Handle COMMA or EOS/SEMICOLON.  */
  22394.  
  22395. static ffelexHandler
  22396. ffestb_decl_ents_11_ (ffelexToken t)
  22397. {
  22398.   switch (ffelex_token_type (t))
  22399.     {
  22400.     case FFELEX_typeCOMMA:
  22401.       return (ffelexHandler) ffestb_decl_ents_;
  22402.  
  22403.     case FFELEX_typeEOS:
  22404.     case FFELEX_typeSEMICOLON:
  22405.       if (!ffesta_is_inhibited ())
  22406.     ffestc_decl_finish ();
  22407.       return (ffelexHandler) ffesta_zero (t);
  22408.  
  22409.     default:
  22410.       break;
  22411.     }
  22412.  
  22413.   if (!ffesta_is_inhibited ())
  22414.     ffestc_decl_finish ();
  22415.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  22416.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22417. }
  22418.  
  22419. /* ffestb_decl_entsp_ -- "type" [type parameters]
  22420.  
  22421.    return ffestb_decl_entsp_;  // to lexer
  22422.  
  22423.    Handle NAME or NAMES beginning either an entity (object) declaration or
  22424.    a function definition..  */
  22425.  
  22426. static ffelexHandler
  22427. ffestb_decl_entsp_ (ffelexToken t)
  22428. {
  22429.   switch (ffelex_token_type (t))
  22430.     {
  22431.     case FFELEX_typeNAME:
  22432.       ffesta_confirmed ();
  22433.       ffesta_tokens[1] = ffelex_token_use (t);
  22434.       return (ffelexHandler) ffestb_decl_entsp_1_;
  22435.  
  22436.     case FFELEX_typeNAMES:
  22437.       ffesta_confirmed ();
  22438.       ffesta_tokens[1] = ffelex_token_use (t);
  22439.       return (ffelexHandler) ffestb_decl_entsp_2_;
  22440.  
  22441.     default:
  22442.       break;
  22443.     }
  22444.  
  22445.   if (ffestb_local_.decl.kindt != NULL)
  22446.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22447.   if (ffestb_local_.decl.lent != NULL)
  22448.     ffelex_token_kill (ffestb_local_.decl.lent);
  22449.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "type-declaration", t);
  22450.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22451. }
  22452.  
  22453. /* ffestb_decl_entsp_1_ -- "type" [type parameters] NAME
  22454.  
  22455.    return ffestb_decl_entsp_1_;     // to lexer
  22456.  
  22457.    If we get another NAME token here, then the previous one must be
  22458.    "RECURSIVE" or "FUNCTION" and we handle it accordingly.  Otherwise,
  22459.    we send the previous and current token through to _ents_.  */
  22460.  
  22461. static ffelexHandler
  22462. ffestb_decl_entsp_1_ (ffelexToken t)
  22463. {
  22464.   switch (ffelex_token_type (t))
  22465.     {
  22466.     case FFELEX_typeNAME:
  22467.       switch (ffestr_first (ffesta_tokens[1]))
  22468.     {
  22469. #if FFESTR_F90
  22470.     case FFESTR_firstRECURSIVE:
  22471.       if (ffestr_first (t) != FFESTR_firstFUNCTION)
  22472.         {
  22473.           ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  22474.           break;
  22475.         }
  22476.       ffestb_local_.decl.recursive = ffesta_tokens[1];
  22477.       return (ffelexHandler) ffestb_decl_funcname_;
  22478. #endif
  22479.  
  22480.     case FFESTR_firstFUNCTION:
  22481.       ffelex_token_kill (ffesta_tokens[1]);
  22482.       return (ffelexHandler) ffestb_decl_funcname_ (t);
  22483.  
  22484.     default:
  22485.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", ffesta_tokens[1]);
  22486.       break;
  22487.     }
  22488.       break;
  22489.  
  22490.     default:
  22491.       if ((ffelex_token_type (ffesta_tokens[1]) != FFELEX_typeNAMES)
  22492.       && !ffesta_is_inhibited ())
  22493.     ffestc_decl_start (ffestb_local_.decl.type, ffesta_tokens[0],
  22494.                ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
  22495.                ffestb_local_.decl.len, ffestb_local_.decl.lent);
  22496.       if (ffestb_local_.decl.kindt != NULL)
  22497.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22498.       if (ffestb_local_.decl.lent != NULL)
  22499.     ffelex_token_kill (ffestb_local_.decl.lent);
  22500.       /* NAME/NAMES token already in ffesta_tokens[1]. */
  22501.       return (ffelexHandler) ffestb_decl_ents_1_ (t);
  22502.     }
  22503.  
  22504.   if (ffestb_local_.decl.kindt != NULL)
  22505.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22506.   if (ffestb_local_.decl.lent != NULL)
  22507.     ffelex_token_kill (ffestb_local_.decl.lent);
  22508.   ffelex_token_kill (ffesta_tokens[1]);
  22509.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22510. }
  22511.  
  22512. /* ffestb_decl_entsp_2_ -- "type" [type parameters] NAMES
  22513.  
  22514.    return ffestb_decl_entsp_2_;     // to lexer
  22515.  
  22516.    If we get an ASTERISK or OPEN_PAREN here, then if the previous NAMES
  22517.    begins with "FUNCTION" or "RECURSIVEFUNCTION" and is followed by a
  22518.    first-name-char, we have a possible syntactically ambiguous situation.
  22519.    Otherwise, we have a straightforward situation just as if we went
  22520.    through _entsp_1_ instead of here.  */
  22521.  
  22522. static ffelexHandler
  22523. ffestb_decl_entsp_2_ (ffelexToken t)
  22524. {
  22525.   ffelexToken nt;
  22526.   bool asterisk_ok;
  22527.   char *p;
  22528.   ffeTokenLength i;
  22529.  
  22530.   switch (ffelex_token_type (t))
  22531.     {
  22532.     case FFELEX_typeASTERISK:
  22533.       ffesta_confirmed ();
  22534.       switch (ffestb_local_.decl.type)
  22535.     {
  22536.     case FFESTP_typeINTEGER:
  22537.     case FFESTP_typeREAL:
  22538.     case FFESTP_typeCOMPLEX:
  22539.     case FFESTP_typeLOGICAL:
  22540.       asterisk_ok = (ffestb_local_.decl.kindt == NULL);
  22541.       break;
  22542.  
  22543.     case FFESTP_typeCHARACTER:
  22544.       asterisk_ok = (ffestb_local_.decl.lent == NULL);
  22545.       break;
  22546.  
  22547.     default:
  22548.       asterisk_ok = FALSE;
  22549.       break;
  22550.     }
  22551.       switch (ffestr_first (ffesta_tokens[1]))
  22552.     {
  22553. #if FFESTR_F90
  22554.     case FFESTR_firstRECURSIVEFNCTN:
  22555.       if (!asterisk_ok)
  22556.         break;        /* For our own convenience, treat as non-FN
  22557.                    stmt. */
  22558.       p = ffelex_token_text (ffesta_tokens[1])
  22559.         + (i = FFESTR_firstlRECURSIVEFNCTN);
  22560.       if (!ffesrc_is_name_init (*p))
  22561.         break;
  22562.       ffestb_local_.decl.recursive
  22563.         = ffelex_token_name_from_names (ffesta_tokens[1], 0,
  22564.                         FFESTR_firstlRECURSIVEFNCTN);
  22565.       ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
  22566.                         FFESTR_firstlRECURSIVEFNCTN, 0);
  22567.       return (ffelexHandler) ffestb_decl_entsp_3_;
  22568. #endif
  22569.  
  22570.     case FFESTR_firstFUNCTION:
  22571.       if (!asterisk_ok)
  22572.         break;        /* For our own convenience, treat as non-FN
  22573.                    stmt. */
  22574.       p = ffelex_token_text (ffesta_tokens[1])
  22575.         + (i = FFESTR_firstlFUNCTION);
  22576.       if (!ffesrc_is_name_init (*p))
  22577.         break;
  22578.       ffestb_local_.decl.recursive = NULL;
  22579.       ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
  22580.                           FFESTR_firstlFUNCTION, 0);
  22581.       return (ffelexHandler) ffestb_decl_entsp_3_;
  22582.  
  22583.     default:
  22584.       break;
  22585.     }
  22586.       break;
  22587.  
  22588.     case FFELEX_typeOPEN_PAREN:
  22589.       ffestb_local_.decl.aster_after = FALSE;
  22590.       switch (ffestr_first (ffesta_tokens[1]))
  22591.     {
  22592. #if FFESTR_F90
  22593.     case FFESTR_firstRECURSIVEFNCTN:
  22594.       p = ffelex_token_text (ffesta_tokens[1])
  22595.         + (i = FFESTR_firstlRECURSIVEFNCTN);
  22596.       if (!ffesrc_is_name_init (*p))
  22597.         break;
  22598.       ffestb_local_.decl.recursive
  22599.         = ffelex_token_name_from_names (ffesta_tokens[1], 0,
  22600.                         FFESTR_firstlRECURSIVEFNCTN);
  22601.       ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
  22602.                         FFESTR_firstlRECURSIVEFNCTN, 0);
  22603.       return (ffelexHandler) ffestb_decl_entsp_5_ (t);
  22604. #endif
  22605.  
  22606.     case FFESTR_firstFUNCTION:
  22607.       p = ffelex_token_text (ffesta_tokens[1])
  22608.         + (i = FFESTR_firstlFUNCTION);
  22609.       if (!ffesrc_is_name_init (*p))
  22610.         break;
  22611.       ffestb_local_.decl.recursive = NULL;
  22612.       ffesta_tokens[2] = ffelex_token_name_from_names (ffesta_tokens[1],
  22613.                           FFESTR_firstlFUNCTION, 0);
  22614.       return (ffelexHandler) ffestb_decl_entsp_5_ (t);
  22615.  
  22616.     default:
  22617.       break;
  22618.     }
  22619.       if ((ffestb_local_.decl.kindt != NULL)
  22620.       || (ffestb_local_.decl.lent != NULL))
  22621.     break;            /* Have kind/len type param, definitely not
  22622.                    assignment stmt. */
  22623.       return (ffelexHandler) ffestb_decl_entsp_1_ (t);
  22624.  
  22625.     default:
  22626.       break;
  22627.     }
  22628.  
  22629.   nt = ffelex_token_name_from_names (ffesta_tokens[1], 0, 0);
  22630.   ffelex_token_kill (ffesta_tokens[1]);
  22631.   ffesta_tokens[1] = nt;    /* Change NAMES to NAME. */
  22632.   return (ffelexHandler) ffestb_decl_entsp_1_ (t);
  22633. }
  22634.  
  22635. /* ffestb_decl_entsp_3_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  22636.                  NAME ASTERISK
  22637.  
  22638.    return ffestb_decl_entsp_3_;     // to lexer
  22639.  
  22640.    Handle NUMBER or OPEN_PAREN.     */
  22641.  
  22642. static ffelexHandler
  22643. ffestb_decl_entsp_3_ (ffelexToken t)
  22644. {
  22645.   ffestb_local_.decl.aster_after = TRUE;
  22646.  
  22647.   switch (ffelex_token_type (t))
  22648.     {
  22649.     case FFELEX_typeNUMBER:
  22650.       switch (ffestb_local_.decl.type)
  22651.     {
  22652.     case FFESTP_typeINTEGER:
  22653.     case FFESTP_typeREAL:
  22654.     case FFESTP_typeCOMPLEX:
  22655.     case FFESTP_typeLOGICAL:
  22656.       ffestb_local_.decl.kindt = ffelex_token_use (t);
  22657.       break;
  22658.  
  22659.     case FFESTP_typeCHARACTER:
  22660.       ffestb_local_.decl.lent = ffelex_token_use (t);
  22661.       break;
  22662.  
  22663.     default:
  22664.       assert (FALSE);
  22665.     }
  22666.       return (ffelexHandler) ffestb_decl_entsp_5_;
  22667.  
  22668.     case FFELEX_typeOPEN_PAREN:
  22669.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  22670.                       FFEEXPR_contextCHARACTERSIZE,
  22671.                     (ffeexprCallback) ffestb_decl_entsp_4_);
  22672.  
  22673.     default:
  22674.       break;
  22675.     }
  22676.  
  22677.   if (ffestb_local_.decl.recursive != NULL)
  22678.     ffelex_token_kill (ffestb_local_.decl.recursive);
  22679.   if (ffestb_local_.decl.kindt != NULL)
  22680.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22681.   if (ffestb_local_.decl.lent != NULL)
  22682.     ffelex_token_kill (ffestb_local_.decl.lent);
  22683.   ffelex_token_kill (ffesta_tokens[1]);
  22684.   ffelex_token_kill (ffesta_tokens[2]);
  22685.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  22686.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22687. }
  22688.  
  22689. /* ffestb_decl_entsp_4_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  22690.                  NAME ASTERISK OPEN_PAREN expr
  22691.  
  22692.    (ffestb_decl_entsp_4_)  // to expression handler
  22693.  
  22694.    Allow only CLOSE_PAREN; and deal with character-length expression.  */
  22695.  
  22696. static ffelexHandler
  22697. ffestb_decl_entsp_4_ (ffelexToken ft, ffebld expr, ffelexToken t)
  22698. {
  22699.   switch (ffelex_token_type (t))
  22700.     {
  22701.     case FFELEX_typeCLOSE_PAREN:
  22702.       if (expr == NULL)
  22703.     break;
  22704.       switch (ffestb_local_.decl.type)
  22705.     {
  22706.     case FFESTP_typeCHARACTER:
  22707.       ffestb_local_.decl.len = expr;
  22708.       ffestb_local_.decl.lent = ffelex_token_use (ft);
  22709.       break;
  22710.  
  22711.     default:
  22712.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  22713.       break;
  22714.     }
  22715.       return (ffelexHandler) ffestb_decl_entsp_5_;
  22716.  
  22717.     default:
  22718.       break;
  22719.     }
  22720.  
  22721.   if (ffestb_local_.decl.recursive != NULL)
  22722.     ffelex_token_kill (ffestb_local_.decl.recursive);
  22723.   if (ffestb_local_.decl.kindt != NULL)
  22724.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22725.   if (ffestb_local_.decl.lent != NULL)
  22726.     ffelex_token_kill (ffestb_local_.decl.lent);
  22727.   ffelex_token_kill (ffesta_tokens[1]);
  22728.   ffelex_token_kill (ffesta_tokens[2]);
  22729.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  22730.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22731. }
  22732.  
  22733. /* ffestb_decl_entsp_5_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  22734.                  NAME [type parameter]
  22735.  
  22736.    return ffestb_decl_entsp_5_;     // to lexer
  22737.  
  22738.    Make sure the next token is an OPEN_PAREN.  Get the arg list or dimension
  22739.    list.  If it can't be an arg list, or if the CLOSE_PAREN is followed by
  22740.    something other than EOS/SEMICOLON or NAME, then treat as dimension list
  22741.    and handle statement as an R426/R501.  If it can't be a dimension list, or
  22742.    if the CLOSE_PAREN is followed by NAME, treat as an arg list and handle
  22743.    statement as an R1219.  If it can be either an arg list or a dimension
  22744.    list and if the CLOSE_PAREN is followed by EOS/SEMICOLON, ask FFESTC
  22745.    whether to treat the statement as an R426/R501 or an R1219 and act
  22746.    accordingly.     */
  22747.  
  22748. static ffelexHandler
  22749. ffestb_decl_entsp_5_ (ffelexToken t)
  22750. {
  22751.   switch (ffelex_token_type (t))
  22752.     {
  22753.     case FFELEX_typeOPEN_PAREN:
  22754.       if (ffestb_local_.decl.aster_after && (ffestb_local_.decl.len != NULL))
  22755.     {            /* "CHARACTER[RECURSIVE]FUNCTIONxyz*(len-expr)
  22756.                    (..." must be a function-stmt, since the
  22757.                    (len-expr) cannot precede (array-spec) in
  22758.                    an object declaration but can precede
  22759.                    (name-list) in a function stmt. */
  22760.       ffelex_token_kill (ffesta_tokens[1]);
  22761.       ffesta_tokens[1] = ffesta_tokens[2];
  22762.       return (ffelexHandler) ffestb_decl_funcname_4_ (t);
  22763.     }
  22764.       ffestb_local_.decl.toklist = ffestt_tokenlist_create ();
  22765.       ffestb_local_.decl.empty = TRUE;
  22766.       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
  22767.       return (ffelexHandler) ffestb_decl_entsp_6_;
  22768.  
  22769.     default:
  22770.       break;
  22771.     }
  22772.  
  22773.   ffesta_confirmed ();        /* We've seen an ASTERISK, so even EQUALS
  22774.                    confirmed. */
  22775.   assert (ffestb_local_.decl.aster_after);
  22776.   ffestb_subr_ambig_to_ents_ ();
  22777.   ffestb_subrargs_.dim_list.dims = NULL;
  22778.   return (ffelexHandler) ffestb_decl_ents_7_ (t);
  22779. }
  22780.  
  22781. /* ffestb_decl_entsp_6_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  22782.                  NAME [type parameter] OPEN_PAREN
  22783.  
  22784.    return ffestb_decl_entsp_6_;     // to lexer
  22785.  
  22786.    If CLOSE_PAREN, we definitely have an R1219 function-stmt, since
  22787.    the notation "name()" is invalid for a declaration.    */
  22788.  
  22789. static ffelexHandler
  22790. ffestb_decl_entsp_6_ (ffelexToken t)
  22791. {
  22792.   ffelexHandler next;
  22793.  
  22794.   switch (ffelex_token_type (t))
  22795.     {
  22796.     case FFELEX_typeCLOSE_PAREN:
  22797.       if (!ffestb_local_.decl.empty)
  22798.     {            /* Trailing comma, just a warning for
  22799.                    stmt func def, so allow ambiguity. */
  22800.       ffestt_tokenlist_append (ffestb_local_.decl.toklist,
  22801.                    ffelex_token_use (t));
  22802.       return (ffelexHandler) ffestb_decl_entsp_8_;
  22803.     }
  22804.       ffelex_token_kill (ffesta_tokens[1]);
  22805.       ffesta_tokens[1] = ffesta_tokens[2];
  22806.       next = (ffelexHandler) ffestt_tokenlist_handle
  22807.     (ffestb_local_.decl.toklist, (ffelexHandler) ffestb_decl_funcname_4_);
  22808.       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  22809.       return (ffelexHandler) (*next) (t);
  22810.  
  22811.     case FFELEX_typeNAME:
  22812.       ffestb_local_.decl.empty = FALSE;
  22813.       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
  22814.       return (ffelexHandler) ffestb_decl_entsp_7_;
  22815.  
  22816.     case FFELEX_typeEQUALS:
  22817.     case FFELEX_typePOINTS:
  22818.     case FFELEX_typePERCENT:
  22819.     case FFELEX_typePERIOD:
  22820.       if ((ffestb_local_.decl.kindt != NULL)
  22821.       || (ffestb_local_.decl.lent != NULL))
  22822.     break;            /* type(params)name or type*val name, either
  22823.                    way confirmed. */
  22824.       return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
  22825.  
  22826.     default:
  22827.       break;
  22828.     }
  22829.  
  22830.   ffesta_confirmed ();
  22831.   ffestb_subr_ambig_to_ents_ ();
  22832.   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
  22833.                        (ffelexHandler) ffestb_decl_ents_3_);
  22834.   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  22835.   return (ffelexHandler) (*next) (t);
  22836. }
  22837.  
  22838. /* ffestb_decl_entsp_7_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  22839.                  NAME [type parameter] OPEN_PAREN NAME
  22840.  
  22841.    return ffestb_decl_entsp_7_;     // to lexer
  22842.  
  22843.    Expect COMMA or CLOSE_PAREN to remain ambiguous, else not an R1219
  22844.    function-stmt.  */
  22845.  
  22846. static ffelexHandler
  22847. ffestb_decl_entsp_7_ (ffelexToken t)
  22848. {
  22849.   ffelexHandler next;
  22850.  
  22851.   switch (ffelex_token_type (t))
  22852.     {
  22853.     case FFELEX_typeCLOSE_PAREN:
  22854.       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
  22855.       return (ffelexHandler) ffestb_decl_entsp_8_;
  22856.  
  22857.     case FFELEX_typeCOMMA:
  22858.       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
  22859.       return (ffelexHandler) ffestb_decl_entsp_6_;
  22860.  
  22861.     case FFELEX_typeEQUALS:
  22862.     case FFELEX_typePOINTS:
  22863.     case FFELEX_typePERCENT:
  22864.     case FFELEX_typePERIOD:
  22865.       if ((ffestb_local_.decl.kindt != NULL)
  22866.       || (ffestb_local_.decl.lent != NULL))
  22867.     break;            /* type(params)name or type*val name, either
  22868.                    way confirmed. */
  22869.       return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
  22870.  
  22871.     default:
  22872.       break;
  22873.     }
  22874.  
  22875.   ffesta_confirmed ();
  22876.   ffestb_subr_ambig_to_ents_ ();
  22877.   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
  22878.                        (ffelexHandler) ffestb_decl_ents_3_);
  22879.   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  22880.   return (ffelexHandler) (*next) (t);
  22881. }
  22882.  
  22883. /* ffestb_decl_entsp_8_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  22884.                  NAME [type parameter] OPEN_PAREN name-list
  22885.                  CLOSE_PAREN
  22886.  
  22887.    return ffestb_decl_entsp_8_;     // to lexer
  22888.  
  22889.    If EOS/SEMICOLON, situation remains ambiguous, ask FFESTC to resolve
  22890.    it.    If NAME (must be "RESULT", but that is checked later on),
  22891.    definitely an R1219 function-stmt.  Anything else, handle as entity decl.  */
  22892.  
  22893. static ffelexHandler
  22894. ffestb_decl_entsp_8_ (ffelexToken t)
  22895. {
  22896.   ffelexHandler next;
  22897.  
  22898.   switch (ffelex_token_type (t))
  22899.     {
  22900.     case FFELEX_typeEOS:
  22901.     case FFELEX_typeSEMICOLON:
  22902.       ffesta_confirmed ();
  22903.       if (ffestc_is_decl_not_R1219 ())
  22904.     break;
  22905.       /* Fall through. */
  22906.     case FFELEX_typeNAME:
  22907.       ffesta_confirmed ();
  22908.       ffelex_token_kill (ffesta_tokens[1]);
  22909.       ffesta_tokens[1] = ffesta_tokens[2];
  22910.       next = (ffelexHandler) ffestt_tokenlist_handle
  22911.     (ffestb_local_.decl.toklist, (ffelexHandler) ffestb_decl_funcname_4_);
  22912.       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  22913.       return (ffelexHandler) (*next) (t);
  22914.  
  22915.     case FFELEX_typeEQUALS:
  22916.     case FFELEX_typePOINTS:
  22917.     case FFELEX_typePERCENT:
  22918.     case FFELEX_typePERIOD:
  22919.       if ((ffestb_local_.decl.kindt != NULL)
  22920.       || (ffestb_local_.decl.lent != NULL))
  22921.     break;            /* type(params)name or type*val name, either
  22922.                    way confirmed. */
  22923.       return (ffelexHandler) ffestb_subr_ambig_nope_ (t);
  22924.  
  22925.     default:
  22926.       break;
  22927.     }
  22928.  
  22929.   ffesta_confirmed ();
  22930.   ffestb_subr_ambig_to_ents_ ();
  22931.   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
  22932.                        (ffelexHandler) ffestb_decl_ents_3_);
  22933.   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  22934.   return (ffelexHandler) (*next) (t);
  22935. }
  22936.  
  22937. /* ffestb_decl_func_ -- ["type" [type parameters]] RECURSIVE
  22938.  
  22939.    return ffestb_decl_func_;  // to lexer
  22940.  
  22941.    Handle "FUNCTION".  */
  22942.  
  22943. #if FFESTR_F90
  22944. static ffelexHandler
  22945. ffestb_decl_func_ (ffelexToken t)
  22946. {
  22947.   char *p;
  22948.   ffeTokenLength i;
  22949.  
  22950.   ffelex_set_names (FALSE);
  22951.  
  22952.   switch (ffelex_token_type (t))
  22953.     {
  22954.     case FFELEX_typeNAME:
  22955.       if (ffestr_first (t) != FFESTR_firstFUNCTION)
  22956.     break;
  22957.       return (ffelexHandler) ffestb_decl_funcname_;
  22958.  
  22959.     case FFELEX_typeNAMES:
  22960.       ffesta_confirmed ();
  22961.       if (ffestr_first (t) != FFESTR_firstFUNCTION)
  22962.     break;
  22963.       p = ffelex_token_text (t) + (i = FFESTR_firstlFUNCTION);
  22964.       if (*p == '\0')
  22965.     break;
  22966.       if (!ffesrc_is_name_init (*p))
  22967.     goto bad_i;        /* :::::::::::::::::::: */
  22968.       ffesta_tokens[1] = ffelex_token_name_from_names (t, i, 0);
  22969.       return (ffelexHandler) ffestb_decl_funcname_1_;
  22970.  
  22971.     default:
  22972.       break;
  22973.     }
  22974.  
  22975.   if (ffestb_local_.decl.recursive != NULL)
  22976.     ffelex_token_kill (ffestb_local_.decl.recursive);
  22977.   if (ffestb_local_.decl.kindt != NULL)
  22978.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22979.   if (ffestb_local_.decl.lent != NULL)
  22980.     ffelex_token_kill (ffestb_local_.decl.lent);
  22981.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  22982.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22983.  
  22984. bad_i:                /* :::::::::::::::::::: */
  22985.   if (ffestb_local_.decl.recursive != NULL)
  22986.     ffelex_token_kill (ffestb_local_.decl.recursive);
  22987.   if (ffestb_local_.decl.kindt != NULL)
  22988.     ffelex_token_kill (ffestb_local_.decl.kindt);
  22989.   if (ffestb_local_.decl.lent != NULL)
  22990.     ffelex_token_kill (ffestb_local_.decl.lent);
  22991.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t, i, NULL);
  22992.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  22993. }
  22994.  
  22995. #endif
  22996. /* ffestb_decl_funcname_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  22997.  
  22998.    return ffestb_decl_funcname_;  // to lexer
  22999.  
  23000.    Handle NAME of a function.  */
  23001.  
  23002. static ffelexHandler
  23003. ffestb_decl_funcname_ (ffelexToken t)
  23004. {
  23005.   switch (ffelex_token_type (t))
  23006.     {
  23007.     case FFELEX_typeNAME:
  23008.       ffesta_tokens[1] = ffelex_token_use (t);
  23009.       return (ffelexHandler) ffestb_decl_funcname_1_;
  23010.  
  23011.     default:
  23012.       break;
  23013.     }
  23014.  
  23015.   if (ffestb_local_.decl.recursive != NULL)
  23016.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23017.   if (ffestb_local_.decl.kindt != NULL)
  23018.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23019.   if (ffestb_local_.decl.lent != NULL)
  23020.     ffelex_token_kill (ffestb_local_.decl.lent);
  23021.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23022.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23023. }
  23024.  
  23025. /* ffestb_decl_funcname_1_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  23026.                  NAME
  23027.  
  23028.    return ffestb_decl_funcname_1_;  // to lexer
  23029.  
  23030.    Handle ASTERISK or OPEN_PAREN.  */
  23031.  
  23032. static ffelexHandler
  23033. ffestb_decl_funcname_1_ (ffelexToken t)
  23034. {
  23035.   switch (ffelex_token_type (t))
  23036.     {
  23037.     case FFELEX_typeASTERISK:
  23038.       return (ffelexHandler) ffestb_decl_funcname_2_;
  23039.  
  23040.     case FFELEX_typeOPEN_PAREN:
  23041.       return (ffelexHandler) ffestb_decl_funcname_4_ (t);
  23042.  
  23043.     default:
  23044.       break;
  23045.     }
  23046.  
  23047.   if (ffestb_local_.decl.recursive != NULL)
  23048.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23049.   if (ffestb_local_.decl.kindt != NULL)
  23050.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23051.   if (ffestb_local_.decl.lent != NULL)
  23052.     ffelex_token_kill (ffestb_local_.decl.lent);
  23053.   ffelex_token_kill (ffesta_tokens[1]);
  23054.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23055.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23056. }
  23057.  
  23058. /* ffestb_decl_funcname_2_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  23059.                  NAME ASTERISK
  23060.  
  23061.    return ffestb_decl_funcname_2_;  // to lexer
  23062.  
  23063.    Handle NUMBER or OPEN_PAREN.     */
  23064.  
  23065. static ffelexHandler
  23066. ffestb_decl_funcname_2_ (ffelexToken t)
  23067. {
  23068.   switch (ffelex_token_type (t))
  23069.     {
  23070.     case FFELEX_typeNUMBER:
  23071.       switch (ffestb_local_.decl.type)
  23072.     {
  23073.     case FFESTP_typeINTEGER:
  23074.     case FFESTP_typeREAL:
  23075.     case FFESTP_typeCOMPLEX:
  23076.     case FFESTP_typeLOGICAL:
  23077.       if (ffestb_local_.decl.kindt == NULL)
  23078.         ffestb_local_.decl.kindt = ffelex_token_use (t);
  23079.       else
  23080.         ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23081.       break;
  23082.  
  23083.     case FFESTP_typeCHARACTER:
  23084.       if (ffestb_local_.decl.lent == NULL)
  23085.         ffestb_local_.decl.lent = ffelex_token_use (t);
  23086.       else
  23087.         ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23088.       break;
  23089.  
  23090.     default:
  23091.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23092.       break;
  23093.     }
  23094.       return (ffelexHandler) ffestb_decl_funcname_4_;
  23095.  
  23096.     case FFELEX_typeOPEN_PAREN:
  23097.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  23098.                       FFEEXPR_contextCHARACTERSIZE,
  23099.                  (ffeexprCallback) ffestb_decl_funcname_3_);
  23100.  
  23101.     default:
  23102.       break;
  23103.     }
  23104.  
  23105.   if (ffestb_local_.decl.recursive != NULL)
  23106.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23107.   if (ffestb_local_.decl.kindt != NULL)
  23108.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23109.   if (ffestb_local_.decl.lent != NULL)
  23110.     ffelex_token_kill (ffestb_local_.decl.lent);
  23111.   ffelex_token_kill (ffesta_tokens[1]);
  23112.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23113.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23114. }
  23115.  
  23116. /* ffestb_decl_funcname_3_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  23117.                  NAME ASTERISK OPEN_PAREN expr
  23118.  
  23119.    (ffestb_decl_funcname_3_)  // to expression handler
  23120.  
  23121.    Allow only CLOSE_PAREN; and deal with character-length expression.  */
  23122.  
  23123. static ffelexHandler
  23124. ffestb_decl_funcname_3_ (ffelexToken ft, ffebld expr, ffelexToken t)
  23125. {
  23126.   switch (ffelex_token_type (t))
  23127.     {
  23128.     case FFELEX_typeCLOSE_PAREN:
  23129.       if (expr == NULL)
  23130.     break;
  23131.       switch (ffestb_local_.decl.type)
  23132.     {
  23133.     case FFESTP_typeCHARACTER:
  23134.       if (ffestb_local_.decl.lent == NULL)
  23135.         {
  23136.           ffestb_local_.decl.len = expr;
  23137.           ffestb_local_.decl.lent = ffelex_token_use (ft);
  23138.         }
  23139.       else
  23140.         ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23141.       break;
  23142.  
  23143.     default:
  23144.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23145.       break;
  23146.     }
  23147.       return (ffelexHandler) ffestb_decl_funcname_4_;
  23148.  
  23149.     default:
  23150.       break;
  23151.     }
  23152.  
  23153.   if (ffestb_local_.decl.recursive != NULL)
  23154.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23155.   if (ffestb_local_.decl.kindt != NULL)
  23156.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23157.   if (ffestb_local_.decl.lent != NULL)
  23158.     ffelex_token_kill (ffestb_local_.decl.lent);
  23159.   ffelex_token_kill (ffesta_tokens[1]);
  23160.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23161.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23162. }
  23163.  
  23164. /* ffestb_decl_funcname_4_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  23165.                  NAME [type parameter]
  23166.  
  23167.    return ffestb_decl_funcname_4_;  // to lexer
  23168.  
  23169.    Make sure the next token is an OPEN_PAREN.  Get the arg list and
  23170.    then implement.  */
  23171.  
  23172. static ffelexHandler
  23173. ffestb_decl_funcname_4_ (ffelexToken t)
  23174. {
  23175.   switch (ffelex_token_type (t))
  23176.     {
  23177.     case FFELEX_typeOPEN_PAREN:
  23178.       ffestb_subrargs_.name_list.args = ffestt_tokenlist_create ();
  23179.       ffestb_subrargs_.name_list.handler
  23180.     = (ffelexHandler) ffestb_decl_funcname_5_;
  23181.       ffestb_subrargs_.name_list.is_subr = FALSE;
  23182.       ffestb_subrargs_.name_list.names = FALSE;
  23183.       return (ffelexHandler) ffestb_subr_name_list_;
  23184.  
  23185.     default:
  23186.       break;
  23187.     }
  23188.  
  23189.   if (ffestb_local_.decl.recursive != NULL)
  23190.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23191.   if (ffestb_local_.decl.kindt != NULL)
  23192.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23193.   if (ffestb_local_.decl.lent != NULL)
  23194.     ffelex_token_kill (ffestb_local_.decl.lent);
  23195.   ffelex_token_kill (ffesta_tokens[1]);
  23196.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23197.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23198. }
  23199.  
  23200. /* ffestb_decl_funcname_5_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  23201.                  NAME [type parameter] OPEN_PAREN arg-list
  23202.                  CLOSE_PAREN
  23203.  
  23204.    return ffestb_decl_funcname_5_;  // to lexer
  23205.  
  23206.    Must have EOS/SEMICOLON or "RESULT" here.  */
  23207.  
  23208. static ffelexHandler
  23209. ffestb_decl_funcname_5_ (ffelexToken t)
  23210. {
  23211.   if (!ffestb_subrargs_.name_list.ok)
  23212.     goto bad;            /* :::::::::::::::::::: */
  23213.  
  23214.   switch (ffelex_token_type (t))
  23215.     {
  23216.     case FFELEX_typeEOS:
  23217.     case FFELEX_typeSEMICOLON:
  23218.       ffesta_confirmed ();
  23219.       if (!ffesta_is_inhibited ())
  23220.     ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
  23221.         ffestb_subrargs_.name_list.close_paren, ffestb_local_.decl.type,
  23222.               ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
  23223.               ffestb_local_.decl.len, ffestb_local_.decl.lent,
  23224.               ffestb_local_.decl.recursive, NULL);
  23225.       if (ffestb_local_.decl.recursive != NULL)
  23226.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23227.       if (ffestb_local_.decl.kindt != NULL)
  23228.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23229.       if (ffestb_local_.decl.lent != NULL)
  23230.     ffelex_token_kill (ffestb_local_.decl.lent);
  23231.       ffelex_token_kill (ffesta_tokens[1]);
  23232.       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
  23233.       ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
  23234.       return (ffelexHandler) ffesta_zero (t);
  23235.  
  23236.     case FFELEX_typeNAME:
  23237.       if (ffestr_other (t) != FFESTR_otherRESULT)
  23238.     break;
  23239.       return (ffelexHandler) ffestb_decl_funcname_6_;
  23240.  
  23241.     default:
  23242.       break;
  23243.     }
  23244.  
  23245. bad:                /* :::::::::::::::::::: */
  23246.   if (ffestb_local_.decl.recursive != NULL)
  23247.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23248.   if (ffestb_local_.decl.kindt != NULL)
  23249.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23250.   if (ffestb_local_.decl.lent != NULL)
  23251.     ffelex_token_kill (ffestb_local_.decl.lent);
  23252.   ffelex_token_kill (ffesta_tokens[1]);
  23253.   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
  23254.   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
  23255.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23256.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23257. }
  23258.  
  23259. /* ffestb_decl_funcname_6_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  23260.                  NAME [type parameter] OPEN_PAREN arglist
  23261.                  CLOSE_PAREN "RESULT"
  23262.  
  23263.    return ffestb_decl_funcname_6_;  // to lexer
  23264.  
  23265.    Make sure the next token is an OPEN_PAREN.  */
  23266.  
  23267. static ffelexHandler
  23268. ffestb_decl_funcname_6_ (ffelexToken t)
  23269. {
  23270.   switch (ffelex_token_type (t))
  23271.     {
  23272.     case FFELEX_typeOPEN_PAREN:
  23273.       return (ffelexHandler) ffestb_decl_funcname_7_;
  23274.  
  23275.     default:
  23276.       break;
  23277.     }
  23278.  
  23279.   if (ffestb_local_.decl.recursive != NULL)
  23280.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23281.   if (ffestb_local_.decl.kindt != NULL)
  23282.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23283.   if (ffestb_local_.decl.lent != NULL)
  23284.     ffelex_token_kill (ffestb_local_.decl.lent);
  23285.   ffelex_token_kill (ffesta_tokens[1]);
  23286.   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
  23287.   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
  23288.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23289.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23290. }
  23291.  
  23292. /* ffestb_decl_funcname_7_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  23293.                  NAME [type parameter] OPEN_PAREN arglist
  23294.                  CLOSE_PAREN "RESULT" OPEN_PAREN
  23295.  
  23296.    return ffestb_decl_funcname_7_;  // to lexer
  23297.  
  23298.    Make sure the next token is a NAME.    */
  23299.  
  23300. static ffelexHandler
  23301. ffestb_decl_funcname_7_ (ffelexToken t)
  23302. {
  23303.   switch (ffelex_token_type (t))
  23304.     {
  23305.     case FFELEX_typeNAME:
  23306.       ffesta_tokens[2] = ffelex_token_use (t);
  23307.       return (ffelexHandler) ffestb_decl_funcname_8_;
  23308.  
  23309.     default:
  23310.       break;
  23311.     }
  23312.  
  23313.   if (ffestb_local_.decl.recursive != NULL)
  23314.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23315.   if (ffestb_local_.decl.kindt != NULL)
  23316.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23317.   if (ffestb_local_.decl.lent != NULL)
  23318.     ffelex_token_kill (ffestb_local_.decl.lent);
  23319.   ffelex_token_kill (ffesta_tokens[1]);
  23320.   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
  23321.   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
  23322.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23323.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23324. }
  23325.  
  23326. /* ffestb_decl_funcname_8_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  23327.                  NAME [type parameter] OPEN_PAREN arglist
  23328.                  CLOSE_PAREN "RESULT" OPEN_PAREN NAME
  23329.  
  23330.    return ffestb_decl_funcname_8_;  // to lexer
  23331.  
  23332.    Make sure the next token is a CLOSE_PAREN.  */
  23333.  
  23334. static ffelexHandler
  23335. ffestb_decl_funcname_8_ (ffelexToken t)
  23336. {
  23337.   switch (ffelex_token_type (t))
  23338.     {
  23339.     case FFELEX_typeCLOSE_PAREN:
  23340.       return (ffelexHandler) ffestb_decl_funcname_9_;
  23341.  
  23342.     default:
  23343.       break;
  23344.     }
  23345.  
  23346.   if (ffestb_local_.decl.recursive != NULL)
  23347.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23348.   if (ffestb_local_.decl.kindt != NULL)
  23349.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23350.   if (ffestb_local_.decl.lent != NULL)
  23351.     ffelex_token_kill (ffestb_local_.decl.lent);
  23352.   ffelex_token_kill (ffesta_tokens[1]);
  23353.   ffelex_token_kill (ffesta_tokens[2]);
  23354.   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
  23355.   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
  23356.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23357.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23358. }
  23359.  
  23360. /* ffestb_decl_funcname_9_ -- "type" [type parameters] [RECURSIVE] FUNCTION
  23361.                  NAME [type parameter] OPEN_PAREN arg-list
  23362.                  CLOSE_PAREN "RESULT" OPEN_PAREN NAME CLOSE_PAREN
  23363.  
  23364.    return ffestb_decl_funcname_9_;  // to lexer
  23365.  
  23366.    Must have EOS/SEMICOLON here.  */
  23367.  
  23368. static ffelexHandler
  23369. ffestb_decl_funcname_9_ (ffelexToken t)
  23370. {
  23371.   switch (ffelex_token_type (t))
  23372.     {
  23373.     case FFELEX_typeEOS:
  23374.     case FFELEX_typeSEMICOLON:
  23375.       if (!ffesta_is_inhibited ())
  23376.     ffestc_R1219 (ffesta_tokens[1], ffestb_subrargs_.name_list.args,
  23377.         ffestb_subrargs_.name_list.close_paren, ffestb_local_.decl.type,
  23378.               ffestb_local_.decl.kind, ffestb_local_.decl.kindt,
  23379.               ffestb_local_.decl.len, ffestb_local_.decl.lent,
  23380.               ffestb_local_.decl.recursive, ffesta_tokens[2]);
  23381.       if (ffestb_local_.decl.recursive != NULL)
  23382.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23383.       if (ffestb_local_.decl.kindt != NULL)
  23384.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23385.       if (ffestb_local_.decl.lent != NULL)
  23386.     ffelex_token_kill (ffestb_local_.decl.lent);
  23387.       ffelex_token_kill (ffesta_tokens[1]);
  23388.       ffelex_token_kill (ffesta_tokens[2]);
  23389.       ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
  23390.       ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
  23391.       return (ffelexHandler) ffesta_zero (t);
  23392.  
  23393.     default:
  23394.       break;
  23395.     }
  23396.  
  23397.   if (ffestb_local_.decl.recursive != NULL)
  23398.     ffelex_token_kill (ffestb_local_.decl.recursive);
  23399.   if (ffestb_local_.decl.kindt != NULL)
  23400.     ffelex_token_kill (ffestb_local_.decl.kindt);
  23401.   if (ffestb_local_.decl.lent != NULL)
  23402.     ffelex_token_kill (ffestb_local_.decl.lent);
  23403.   ffelex_token_kill (ffesta_tokens[1]);
  23404.   ffelex_token_kill (ffesta_tokens[2]);
  23405.   ffelex_token_kill (ffestb_subrargs_.name_list.close_paren);
  23406.   ffestt_tokenlist_kill (ffestb_subrargs_.name_list.args);
  23407.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "FUNCTION", t);
  23408.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23409. }
  23410.  
  23411. /* ffestb_V003 -- Parse the STRUCTURE statement
  23412.  
  23413.    return ffestb_V003;    // to lexer
  23414.  
  23415.    Make sure the statement has a valid form for the STRUCTURE statement.
  23416.    If it does, implement the statement.     */
  23417.  
  23418. #if FFESTR_VXT
  23419. ffelexHandler
  23420. ffestb_V003 (ffelexToken t)
  23421. {
  23422.   ffeTokenLength i;
  23423.   char *p;
  23424.   ffelexToken nt;
  23425.   ffelexHandler next;
  23426.  
  23427.   switch (ffelex_token_type (ffesta_tokens[0]))
  23428.     {
  23429.     case FFELEX_typeNAME:
  23430.       if (ffesta_first_kw != FFESTR_firstSTRUCTURE)
  23431.     goto bad_0;        /* :::::::::::::::::::: */
  23432.       switch (ffelex_token_type (t))
  23433.     {
  23434.     case FFELEX_typeCOMMA:
  23435.     case FFELEX_typeCOLONCOLON:
  23436.     case FFELEX_typeEOS:
  23437.     case FFELEX_typeSEMICOLON:
  23438.       ffesta_confirmed ();    /* Error, but clearly intended. */
  23439.       goto bad_1;        /* :::::::::::::::::::: */
  23440.  
  23441.     default:
  23442.       goto bad_1;        /* :::::::::::::::::::: */
  23443.  
  23444.     case FFELEX_typeNAME:
  23445.       ffesta_confirmed ();
  23446.       if (!ffesta_is_inhibited ())
  23447.         ffestc_V003_start (NULL);
  23448.       ffestb_local_.structure.started = TRUE;
  23449.       return (ffelexHandler) ffestb_V0034_ (t);
  23450.  
  23451.     case FFELEX_typeSLASH:
  23452.       ffesta_confirmed ();
  23453.       return (ffelexHandler) ffestb_V0031_;
  23454.     }
  23455.  
  23456.     case FFELEX_typeNAMES:
  23457.       if (ffesta_first_kw != FFESTR_firstSTRUCTURE)
  23458.     goto bad_0;        /* :::::::::::::::::::: */
  23459.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlSTRUCTURE);
  23460.       switch (ffelex_token_type (t))
  23461.     {
  23462.     default:
  23463.       goto bad_1;        /* :::::::::::::::::::: */
  23464.  
  23465.     case FFELEX_typeEOS:
  23466.     case FFELEX_typeSEMICOLON:
  23467.     case FFELEX_typeCOMMA:
  23468.     case FFELEX_typeCOLONCOLON:
  23469.       ffesta_confirmed ();
  23470.       break;
  23471.  
  23472.     case FFELEX_typeSLASH:
  23473.       ffesta_confirmed ();
  23474.       if (*p != '\0')
  23475.         goto bad_1;        /* :::::::::::::::::::: */
  23476.       return (ffelexHandler) ffestb_V0031_;
  23477.  
  23478.     case FFELEX_typeOPEN_PAREN:
  23479.       break;
  23480.     }
  23481.  
  23482.       /* Here, we have at least one char after "STRUCTURE" and t is COMMA,
  23483.          EOS/SEMICOLON, or OPEN_PAREN. */
  23484.  
  23485.       if (!ffesrc_is_name_init (*p))
  23486.     goto bad_i;        /* :::::::::::::::::::: */
  23487.       nt = ffelex_token_name_from_names (ffesta_tokens[0], i, 0);
  23488.       if (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN)
  23489.     ffestb_local_.structure.started = FALSE;
  23490.       else
  23491.     {
  23492.       if (!ffesta_is_inhibited ())
  23493.         ffestc_V003_start (NULL);
  23494.       ffestb_local_.structure.started = TRUE;
  23495.     }
  23496.       next = (ffelexHandler) ffestb_V0034_ (nt);
  23497.       ffelex_token_kill (nt);
  23498.       return (ffelexHandler) (*next) (t);
  23499.  
  23500.     default:
  23501.       goto bad_0;        /* :::::::::::::::::::: */
  23502.     }
  23503.  
  23504. bad_0:                /* :::::::::::::::::::: */
  23505.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", ffesta_tokens[0]);
  23506.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23507.  
  23508. bad_1:                /* :::::::::::::::::::: */
  23509.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
  23510.   return (ffelexHandler) ffelex_swallow_tokens (t,
  23511.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  23512.  
  23513. bad_i:                /* :::::::::::::::::::: */
  23514.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", ffesta_tokens[0], i, t);
  23515.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23516. }
  23517.  
  23518. /* ffestb_V0031_ -- "STRUCTURE" SLASH
  23519.  
  23520.    return ffestb_V0031_;  // to lexer
  23521.  
  23522.    Handle NAME.     */
  23523.  
  23524. static ffelexHandler
  23525. ffestb_V0031_ (ffelexToken t)
  23526. {
  23527.   switch (ffelex_token_type (t))
  23528.     {
  23529.     case FFELEX_typeNAME:
  23530.       ffesta_tokens[1] = ffelex_token_use (t);
  23531.       return (ffelexHandler) ffestb_V0032_;
  23532.  
  23533.     default:
  23534.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
  23535.       break;
  23536.     }
  23537.  
  23538.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23539. }
  23540.  
  23541. /* ffestb_V0032_ -- "STRUCTURE" SLASH NAME
  23542.  
  23543.    return ffestb_V0032_;  // to lexer
  23544.  
  23545.    Handle SLASH.  */
  23546.  
  23547. static ffelexHandler
  23548. ffestb_V0032_ (ffelexToken t)
  23549. {
  23550.   switch (ffelex_token_type (t))
  23551.     {
  23552.     case FFELEX_typeSLASH:
  23553.       if (!ffesta_is_inhibited ())
  23554.     ffestc_V003_start (ffesta_tokens[1]);
  23555.       ffestb_local_.structure.started = TRUE;
  23556.       ffelex_token_kill (ffesta_tokens[1]);
  23557.       return (ffelexHandler) ffestb_V0033_;
  23558.  
  23559.     default:
  23560.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
  23561.       break;
  23562.     }
  23563.  
  23564.   ffelex_token_kill (ffesta_tokens[1]);
  23565.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23566. }
  23567.  
  23568. /* ffestb_V0033_ -- "STRUCTURE" SLASH NAME SLASH
  23569.  
  23570.    return ffestb_V0033_;  // to lexer
  23571.  
  23572.    Handle NAME or EOS/SEMICOLON.  */
  23573.  
  23574. static ffelexHandler
  23575. ffestb_V0033_ (ffelexToken t)
  23576. {
  23577.   switch (ffelex_token_type (t))
  23578.     {
  23579.     case FFELEX_typeNAME:
  23580.       return (ffelexHandler) ffestb_V0034_ (t);
  23581.  
  23582.     case FFELEX_typeEOS:
  23583.     case FFELEX_typeSEMICOLON:
  23584.       if (!ffesta_is_inhibited ())
  23585.     ffestc_V003_finish ();
  23586.       return (ffelexHandler) ffesta_zero (t);
  23587.  
  23588.     default:
  23589.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
  23590.       break;
  23591.     }
  23592.  
  23593.   ffelex_token_kill (ffesta_tokens[1]);
  23594.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23595. }
  23596.  
  23597. /* ffestb_V0034_ -- "STRUCTURE" [SLASH NAME SLASH]
  23598.  
  23599.    return ffestb_V0034_;  // to lexer
  23600.  
  23601.    Handle NAME.     */
  23602.  
  23603. static ffelexHandler
  23604. ffestb_V0034_ (ffelexToken t)
  23605. {
  23606.   switch (ffelex_token_type (t))
  23607.     {
  23608.     case FFELEX_typeNAME:
  23609.       ffesta_tokens[1] = ffelex_token_use (t);
  23610.       return (ffelexHandler) ffestb_V0035_;
  23611.  
  23612.     default:
  23613.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
  23614.       break;
  23615.     }
  23616.  
  23617.   if (!ffesta_is_inhibited ())
  23618.     ffestc_V003_finish ();
  23619.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23620. }
  23621.  
  23622. /* ffestb_V0035_ -- "STRUCTURE" ... NAME
  23623.  
  23624.    return ffestb_V0035_;  // to lexer
  23625.  
  23626.    Handle OPEN_PAREN.  */
  23627.  
  23628. static ffelexHandler
  23629. ffestb_V0035_ (ffelexToken t)
  23630. {
  23631.   switch (ffelex_token_type (t))
  23632.     {
  23633.     case FFELEX_typeOPEN_PAREN:
  23634.       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
  23635.       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_V0036_;
  23636.       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
  23637.       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
  23638. #ifdef FFECOM_dimensionsMAX
  23639.       ffestb_subrargs_.dim_list.ndims = 0;
  23640. #endif
  23641.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  23642.       FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
  23643.  
  23644.     case FFELEX_typeCOMMA:
  23645.       if (!ffesta_is_inhibited ())
  23646.     ffestc_V003_item (ffesta_tokens[1], NULL);
  23647.       ffelex_token_kill (ffesta_tokens[1]);
  23648.       return (ffelexHandler) ffestb_V0034_;
  23649.  
  23650.     case FFELEX_typeEOS:
  23651.     case FFELEX_typeSEMICOLON:
  23652.       if (!ffesta_is_inhibited ())
  23653.     {
  23654.       ffestc_V003_item (ffesta_tokens[1], NULL);
  23655.       ffestc_V003_finish ();
  23656.     }
  23657.       ffelex_token_kill (ffesta_tokens[1]);
  23658.       return (ffelexHandler) ffesta_zero (t);
  23659.  
  23660.     default:
  23661.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
  23662.       break;
  23663.     }
  23664.  
  23665.   if (!ffesta_is_inhibited ())
  23666.     ffestc_V003_finish ();
  23667.   ffelex_token_kill (ffesta_tokens[1]);
  23668.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23669. }
  23670.  
  23671. /* ffestb_V0036_ -- "STRUCTURE" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
  23672.  
  23673.    return ffestb_V0036_;  // to lexer
  23674.  
  23675.    Handle COMMA or EOS/SEMICOLON.  */
  23676.  
  23677. static ffelexHandler
  23678. ffestb_V0036_ (ffelexToken t)
  23679. {
  23680.   if (!ffestb_subrargs_.dim_list.ok)
  23681.     goto bad;            /* :::::::::::::::::::: */
  23682.  
  23683.   switch (ffelex_token_type (t))
  23684.     {
  23685.     case FFELEX_typeCOMMA:
  23686.       ffesta_confirmed ();
  23687.       if (!ffesta_is_inhibited ())
  23688.     {
  23689.       if (!ffestb_local_.structure.started)
  23690.         {
  23691.           ffestc_V003_start (NULL);
  23692.           ffestb_local_.structure.started = TRUE;
  23693.         }
  23694.       ffestc_V003_item (ffesta_tokens[1],
  23695.                 ffestb_subrargs_.dim_list.dims);
  23696.     }
  23697.       ffelex_token_kill (ffesta_tokens[1]);
  23698.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  23699.       return (ffelexHandler) ffestb_V0034_;
  23700.  
  23701.     case FFELEX_typeEOS:
  23702.     case FFELEX_typeSEMICOLON:
  23703.       ffesta_confirmed ();
  23704.       if (!ffesta_is_inhibited ())
  23705.     {
  23706.       if (!ffestb_local_.structure.started)
  23707.         ffestc_V003_start (NULL);
  23708.       ffestc_V003_item (ffesta_tokens[1],
  23709.                 ffestb_subrargs_.dim_list.dims);
  23710.       ffestc_V003_finish ();
  23711.     }
  23712.       ffelex_token_kill (ffesta_tokens[1]);
  23713.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  23714.       return (ffelexHandler) ffesta_zero (t);
  23715.  
  23716.     default:
  23717.       break;
  23718.     }
  23719.  
  23720. bad:                /* :::::::::::::::::::: */
  23721.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "STRUCTURE", t);
  23722.   if (ffestb_local_.structure.started && !ffesta_is_inhibited ())
  23723.     ffestc_V003_finish ();
  23724.   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  23725.   ffelex_token_kill (ffesta_tokens[1]);
  23726.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23727. }
  23728.  
  23729. /* ffestb_V016 -- Parse the RECORD statement
  23730.  
  23731.    return ffestb_V016;    // to lexer
  23732.  
  23733.    Make sure the statement has a valid form for the RECORD statement.  If it
  23734.    does, implement the statement.  */
  23735.  
  23736. ffelexHandler
  23737. ffestb_V016 (ffelexToken t)
  23738. {
  23739.   char *p;
  23740.   ffeTokenLength i;
  23741.  
  23742.   switch (ffelex_token_type (ffesta_tokens[0]))
  23743.     {
  23744.     case FFELEX_typeNAME:
  23745.       if (ffesta_first_kw != FFESTR_firstRECORD)
  23746.     goto bad_0;        /* :::::::::::::::::::: */
  23747.       break;
  23748.  
  23749.     case FFELEX_typeNAMES:
  23750.       if (ffesta_first_kw != FFESTR_firstRECORD)
  23751.     goto bad_0;        /* :::::::::::::::::::: */
  23752.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlRECORD);
  23753.       if (*p != '\0')
  23754.     goto bad_i;        /* :::::::::::::::::::: */
  23755.       break;
  23756.  
  23757.     default:
  23758.       goto bad_0;        /* :::::::::::::::::::: */
  23759.     }
  23760.  
  23761.   switch (ffelex_token_type (t))
  23762.     {
  23763.     case FFELEX_typeCOMMA:
  23764.     case FFELEX_typeEOS:
  23765.     case FFELEX_typeSEMICOLON:
  23766.     case FFELEX_typeCOLONCOLON:
  23767.       ffesta_confirmed ();    /* Error, but clearly intended. */
  23768.       goto bad_1;        /* :::::::::::::::::::: */
  23769.  
  23770.     default:
  23771.       goto bad_1;        /* :::::::::::::::::::: */
  23772.  
  23773.     case FFELEX_typeSLASH:
  23774.       break;
  23775.     }
  23776.  
  23777.   ffesta_confirmed ();
  23778.   if (!ffesta_is_inhibited ())
  23779.     ffestc_V016_start ();
  23780.   return (ffelexHandler) ffestb_V0161_;
  23781.  
  23782. bad_0:                /* :::::::::::::::::::: */
  23783.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", ffesta_tokens[0]);
  23784.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23785.  
  23786. bad_1:                /* :::::::::::::::::::: */
  23787.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
  23788.   return (ffelexHandler) ffelex_swallow_tokens (t,
  23789.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  23790.  
  23791. bad_i:                /* :::::::::::::::::::: */
  23792.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "RECORD", ffesta_tokens[0], i, t);
  23793.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23794. }
  23795.  
  23796. /* ffestb_V0161_ -- "RECORD" SLASH
  23797.  
  23798.    return ffestb_V0161_;  // to lexer
  23799.  
  23800.    Handle NAME.     */
  23801.  
  23802. static ffelexHandler
  23803. ffestb_V0161_ (ffelexToken t)
  23804. {
  23805.   switch (ffelex_token_type (t))
  23806.     {
  23807.     case FFELEX_typeNAME:
  23808.       if (!ffesta_is_inhibited ())
  23809.     ffestc_V016_item_structure (t);
  23810.       return (ffelexHandler) ffestb_V0162_;
  23811.  
  23812.     default:
  23813.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
  23814.       break;
  23815.     }
  23816.  
  23817.   if (!ffesta_is_inhibited ())
  23818.     ffestc_V016_finish ();
  23819.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23820. }
  23821.  
  23822. /* ffestb_V0162_ -- "RECORD" SLASH NAME
  23823.  
  23824.    return ffestb_V0162_;  // to lexer
  23825.  
  23826.    Handle SLASH.  */
  23827.  
  23828. static ffelexHandler
  23829. ffestb_V0162_ (ffelexToken t)
  23830. {
  23831.   switch (ffelex_token_type (t))
  23832.     {
  23833.     case FFELEX_typeSLASH:
  23834.       return (ffelexHandler) ffestb_V0163_;
  23835.  
  23836.     default:
  23837.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
  23838.       break;
  23839.     }
  23840.  
  23841.   if (!ffesta_is_inhibited ())
  23842.     ffestc_V016_finish ();
  23843.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23844. }
  23845.  
  23846. /* ffestb_V0163_ -- "RECORD" SLASH NAME SLASH
  23847.  
  23848.    return ffestb_V0163_;  // to lexer
  23849.  
  23850.    Handle NAME.     */
  23851.  
  23852. static ffelexHandler
  23853. ffestb_V0163_ (ffelexToken t)
  23854. {
  23855.   switch (ffelex_token_type (t))
  23856.     {
  23857.     case FFELEX_typeNAME:
  23858.       ffesta_tokens[1] = ffelex_token_use (t);
  23859.       return (ffelexHandler) ffestb_V0164_;
  23860.  
  23861.     default:
  23862.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
  23863.       break;
  23864.     }
  23865.  
  23866.   if (!ffesta_is_inhibited ())
  23867.     ffestc_V016_finish ();
  23868.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23869. }
  23870.  
  23871. /* ffestb_V0164_ -- "RECORD" ... NAME
  23872.  
  23873.    return ffestb_V0164_;  // to lexer
  23874.  
  23875.    Handle OPEN_PAREN.  */
  23876.  
  23877. static ffelexHandler
  23878. ffestb_V0164_ (ffelexToken t)
  23879. {
  23880.   switch (ffelex_token_type (t))
  23881.     {
  23882.     case FFELEX_typeOPEN_PAREN:
  23883.       ffestb_subrargs_.dim_list.dims = ffestt_dimlist_create ();
  23884.       ffestb_subrargs_.dim_list.handler = (ffelexHandler) ffestb_V0165_;
  23885.       ffestb_subrargs_.dim_list.pool = ffesta_output_pool;
  23886.       ffestb_subrargs_.dim_list.ctx = FFEEXPR_contextDIMLISTCOMMON;
  23887. #ifdef FFECOM_dimensionsMAX
  23888.       ffestb_subrargs_.dim_list.ndims = 0;
  23889. #endif
  23890.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  23891.       FFEEXPR_contextDIMLISTCOMMON, (ffeexprCallback) ffestb_subr_dimlist_);
  23892.  
  23893.     case FFELEX_typeCOMMA:
  23894.       if (!ffesta_is_inhibited ())
  23895.     ffestc_V016_item_object (ffesta_tokens[1], NULL);
  23896.       ffelex_token_kill (ffesta_tokens[1]);
  23897.       return (ffelexHandler) ffestb_V0166_;
  23898.  
  23899.     case FFELEX_typeEOS:
  23900.     case FFELEX_typeSEMICOLON:
  23901.       if (!ffesta_is_inhibited ())
  23902.     {
  23903.       ffestc_V016_item_object (ffesta_tokens[1], NULL);
  23904.       ffestc_V016_finish ();
  23905.     }
  23906.       ffelex_token_kill (ffesta_tokens[1]);
  23907.       return (ffelexHandler) ffesta_zero (t);
  23908.  
  23909.     default:
  23910.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
  23911.       break;
  23912.     }
  23913.  
  23914.   if (!ffesta_is_inhibited ())
  23915.     ffestc_V016_finish ();
  23916.   ffelex_token_kill (ffesta_tokens[1]);
  23917.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23918. }
  23919.  
  23920. /* ffestb_V0165_ -- "RECORD" ... NAME OPEN_PAREN dimlist CLOSE_PAREN
  23921.  
  23922.    return ffestb_V0165_;  // to lexer
  23923.  
  23924.    Handle COMMA or EOS/SEMICOLON.  */
  23925.  
  23926. static ffelexHandler
  23927. ffestb_V0165_ (ffelexToken t)
  23928. {
  23929.   if (!ffestb_subrargs_.dim_list.ok)
  23930.     goto bad;            /* :::::::::::::::::::: */
  23931.  
  23932.   switch (ffelex_token_type (t))
  23933.     {
  23934.     case FFELEX_typeCOMMA:
  23935.       if (!ffesta_is_inhibited ())
  23936.     ffestc_V016_item_object (ffesta_tokens[1],
  23937.                  ffestb_subrargs_.dim_list.dims);
  23938.       ffelex_token_kill (ffesta_tokens[1]);
  23939.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  23940.       return (ffelexHandler) ffestb_V0166_;
  23941.  
  23942.     case FFELEX_typeEOS:
  23943.     case FFELEX_typeSEMICOLON:
  23944.       if (!ffesta_is_inhibited ())
  23945.     {
  23946.       ffestc_V016_item_object (ffesta_tokens[1],
  23947.                    ffestb_subrargs_.dim_list.dims);
  23948.       ffestc_V016_finish ();
  23949.     }
  23950.       ffelex_token_kill (ffesta_tokens[1]);
  23951.       ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  23952.       return (ffelexHandler) ffesta_zero (t);
  23953.  
  23954.     default:
  23955.       break;
  23956.     }
  23957.  
  23958. bad:                /* :::::::::::::::::::: */
  23959.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
  23960.   if (ffestb_local_.structure.started && !ffesta_is_inhibited ())
  23961.     ffestc_V016_finish ();
  23962.   ffestt_dimlist_kill (ffestb_subrargs_.dim_list.dims);
  23963.   ffelex_token_kill (ffesta_tokens[1]);
  23964.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23965. }
  23966.  
  23967. /* ffestb_V0166_ -- "RECORD" SLASH NAME SLASH NAME [OPEN_PAREN dimlist
  23968.             CLOSE_PAREN] COMMA
  23969.  
  23970.    return ffestb_V0166_;  // to lexer
  23971.  
  23972.    Handle NAME or SLASH.  */
  23973.  
  23974. static ffelexHandler
  23975. ffestb_V0166_ (ffelexToken t)
  23976. {
  23977.   switch (ffelex_token_type (t))
  23978.     {
  23979.     case FFELEX_typeNAME:
  23980.       ffesta_tokens[1] = ffelex_token_use (t);
  23981.       return (ffelexHandler) ffestb_V0164_;
  23982.  
  23983.     case FFELEX_typeSLASH:
  23984.       return (ffelexHandler) ffestb_V0161_;
  23985.  
  23986.     default:
  23987.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "RECORD", t);
  23988.       break;
  23989.     }
  23990.  
  23991.   if (!ffesta_is_inhibited ())
  23992.     ffestc_V016_finish ();
  23993.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  23994. }
  23995.  
  23996. #endif
  23997. /* ffestb_V027 -- Parse the VXT PARAMETER statement
  23998.  
  23999.    return ffestb_V027;    // to lexer
  24000.  
  24001.    Make sure the statement has a valid form for the VXT PARAMETER statement.
  24002.    If it does, implement the statement.     */
  24003.  
  24004. ffelexHandler
  24005. ffestb_V027 (ffelexToken t)
  24006. {
  24007.   char *p;
  24008.   ffeTokenLength i;
  24009.  
  24010.   switch (ffelex_token_type (ffesta_tokens[0]))
  24011.     {
  24012.     case FFELEX_typeNAME:
  24013.       if (ffesta_first_kw != FFESTR_firstPARAMETER)
  24014.     goto bad_0;        /* :::::::::::::::::::: */
  24015.       switch (ffelex_token_type (t))
  24016.     {
  24017.     case FFELEX_typeNAME:
  24018.       break;
  24019.  
  24020.     default:
  24021.       goto bad_1;        /* :::::::::::::::::::: */
  24022.     }
  24023.       ffesta_confirmed ();
  24024.       ffestb_local_.vxtparam.started = TRUE;
  24025.       if (!ffesta_is_inhibited ())
  24026.     ffestc_V027_start ();
  24027.       ffesta_tokens[1] = ffelex_token_use (t);
  24028.       return (ffelexHandler) ffestb_V0271_;
  24029.  
  24030.     case FFELEX_typeNAMES:
  24031.       if (ffesta_first_kw != FFESTR_firstPARAMETER)
  24032.     goto bad_0;        /* :::::::::::::::::::: */
  24033.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlPARAMETER);
  24034.       switch (ffelex_token_type (t))
  24035.     {
  24036.     case FFELEX_typeEQUALS:
  24037.       break;
  24038.  
  24039.     default:
  24040.       goto bad_1;        /* :::::::::::::::::::: */
  24041.     }
  24042.       if (!ffesrc_is_name_init (*p))
  24043.     goto bad_i;        /* :::::::::::::::::::: */
  24044.       ffestb_local_.vxtparam.started = FALSE;
  24045.       ffesta_tokens[1] = ffelex_token_name_from_names (ffesta_tokens[0], i,
  24046.                                0);
  24047.       return (ffelexHandler) ffestb_V0271_ (t);
  24048.  
  24049.     default:
  24050.       goto bad_0;        /* :::::::::::::::::::: */
  24051.     }
  24052.  
  24053. bad_0:                /* :::::::::::::::::::: */
  24054.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0]);
  24055.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24056.  
  24057. bad_1:                /* :::::::::::::::::::: */
  24058.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
  24059.   return (ffelexHandler) ffelex_swallow_tokens (t,
  24060.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  24061.  
  24062. bad_i:                /* :::::::::::::::::::: */
  24063.   ffesta_ffebad_1sp (FFEBAD_INVALID_STMT_FORM, "PARAMETER", ffesta_tokens[0], i, t);
  24064.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24065. }
  24066.  
  24067. /* ffestb_V0271_ -- "PARAMETER" NAME
  24068.  
  24069.    return ffestb_V0271_;  // to lexer
  24070.  
  24071.    Handle EQUALS.  */
  24072.  
  24073. static ffelexHandler
  24074. ffestb_V0271_ (ffelexToken t)
  24075. {
  24076.   switch (ffelex_token_type (t))
  24077.     {
  24078.     case FFELEX_typeEQUALS:
  24079.       return (ffelexHandler) ffeexpr_rhs (ffesta_output_pool,
  24080.          FFEEXPR_contextPARAMETER, (ffeexprCallback) ffestb_V0272_);
  24081.  
  24082.     default:
  24083.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
  24084.       break;
  24085.     }
  24086.  
  24087.   ffelex_token_kill (ffesta_tokens[1]);
  24088.   if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
  24089.     ffestc_V027_finish ();
  24090.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24091. }
  24092.  
  24093. /* ffestb_V0272_ -- "PARAMETER" NAME EQUALS expr
  24094.  
  24095.    (ffestb_V0272_)  // to expression handler
  24096.  
  24097.    Handle COMMA or EOS/SEMICOLON.  */
  24098.  
  24099. static ffelexHandler
  24100. ffestb_V0272_ (ffelexToken ft, ffebld expr, ffelexToken t)
  24101. {
  24102.   switch (ffelex_token_type (t))
  24103.     {
  24104.     case FFELEX_typeEOS:
  24105.     case FFELEX_typeSEMICOLON:
  24106.       if (!ffestb_local_.vxtparam.started)
  24107.     {
  24108.       if (ffestc_is_let_not_V027 ())
  24109.         break;        /* Not a valid VXTPARAMETER stmt. */
  24110.       ffesta_confirmed ();
  24111.       if (!ffesta_is_inhibited ())
  24112.         ffestc_V027_start ();
  24113.       ffestb_local_.vxtparam.started = TRUE;
  24114.     }
  24115.       if (expr == NULL)
  24116.     break;
  24117.       if (!ffesta_is_inhibited ())
  24118.     {
  24119.       ffestc_V027_item (ffesta_tokens[1], expr, ft);
  24120.       ffestc_V027_finish ();
  24121.     }
  24122.       ffelex_token_kill (ffesta_tokens[1]);
  24123.       return (ffelexHandler) ffesta_zero (t);
  24124.  
  24125.     case FFELEX_typeCOMMA:
  24126.       ffesta_confirmed ();
  24127.       if (!ffestb_local_.vxtparam.started)
  24128.     {
  24129.       if (!ffesta_is_inhibited ())
  24130.         ffestc_V027_start ();
  24131.       ffestb_local_.vxtparam.started = TRUE;
  24132.     }
  24133.       if (expr == NULL)
  24134.     break;
  24135.       if (!ffesta_is_inhibited ())
  24136.     ffestc_V027_item (ffesta_tokens[1], expr, ft);
  24137.       ffelex_token_kill (ffesta_tokens[1]);
  24138.       return (ffelexHandler) ffestb_V0273_;
  24139.  
  24140.     default:
  24141.       break;
  24142.     }
  24143.  
  24144.   ffelex_token_kill (ffesta_tokens[1]);
  24145.   if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
  24146.     ffestc_V027_finish ();
  24147.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
  24148.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24149. }
  24150.  
  24151. /* ffestb_V0273_ -- "PARAMETER" NAME EQUALS expr COMMA
  24152.  
  24153.    return ffestb_V0273_;  // to lexer
  24154.  
  24155.    Handle NAME.     */
  24156.  
  24157. static ffelexHandler
  24158. ffestb_V0273_ (ffelexToken t)
  24159. {
  24160.   switch (ffelex_token_type (t))
  24161.     {
  24162.     case FFELEX_typeNAME:
  24163.       ffesta_tokens[1] = ffelex_token_use (t);
  24164.       return (ffelexHandler) ffestb_V0271_;
  24165.  
  24166.     default:
  24167.       ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "PARAMETER", t);
  24168.       break;
  24169.     }
  24170.  
  24171.   if (ffestb_local_.vxtparam.started && !ffesta_is_inhibited ())
  24172.     ffestc_V027_finish ();
  24173.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24174. }
  24175.  
  24176. /* ffestb_decl_R539 -- Parse the IMPLICIT FUNCTION statement
  24177.  
  24178.    return ffestb_decl_R539;  // to lexer
  24179.  
  24180.    Make sure the statement has a valid form for the IMPLICIT
  24181.    statement.  If it does, implement the statement.  */
  24182.  
  24183. ffelexHandler
  24184. ffestb_decl_R539 (ffelexToken t)
  24185. {
  24186.   ffeTokenLength i;
  24187.   char *p;
  24188.   ffelexToken nt;
  24189.   ffestrSecond kw;
  24190.  
  24191.   ffestb_local_.decl.recursive = NULL;
  24192.  
  24193.   switch (ffelex_token_type (ffesta_tokens[0]))
  24194.     {
  24195.     case FFELEX_typeNAME:
  24196.       if (ffesta_first_kw != FFESTR_firstIMPLICIT)
  24197.     goto bad_0;        /* :::::::::::::::::::: */
  24198.       switch (ffelex_token_type (t))
  24199.     {
  24200.     case FFELEX_typeEOS:
  24201.     case FFELEX_typeSEMICOLON:
  24202.     case FFELEX_typeCOMMA:
  24203.     case FFELEX_typeCOLONCOLON:
  24204.       ffesta_confirmed ();    /* Error, but clearly intended. */
  24205.       goto bad_1;        /* :::::::::::::::::::: */
  24206.  
  24207.     default:
  24208.       goto bad_1;        /* :::::::::::::::::::: */
  24209.  
  24210.     case FFELEX_typeNAME:
  24211.       break;
  24212.     }
  24213.       ffesta_confirmed ();
  24214.       ffestb_local_.decl.imp_started = FALSE;
  24215.       switch (ffesta_second_kw)
  24216.     {
  24217.     case FFESTR_secondINTEGER:
  24218.       ffestb_local_.decl.type = FFESTP_typeINTEGER;
  24219.       return (ffelexHandler) ffestb_decl_R5391_;
  24220.  
  24221.     case FFESTR_secondREAL:
  24222.       ffestb_local_.decl.type = FFESTP_typeREAL;
  24223.       return (ffelexHandler) ffestb_decl_R5391_;
  24224.  
  24225.     case FFESTR_secondCOMPLEX:
  24226.       ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
  24227.       return (ffelexHandler) ffestb_decl_R5391_;
  24228.  
  24229.     case FFESTR_secondLOGICAL:
  24230.       ffestb_local_.decl.type = FFESTP_typeLOGICAL;
  24231.       return (ffelexHandler) ffestb_decl_R5391_;
  24232.  
  24233.     case FFESTR_secondCHARACTER:
  24234.       ffestb_local_.decl.type = FFESTP_typeCHARACTER;
  24235.       return (ffelexHandler) ffestb_decl_R5391_;
  24236.  
  24237.     case FFESTR_secondDOUBLE:
  24238.       return (ffelexHandler) ffestb_decl_R5392_;
  24239.  
  24240.     case FFESTR_secondDOUBLEPRECISION:
  24241.       ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
  24242.       ffestb_local_.decl.kind = NULL;
  24243.       ffestb_local_.decl.kindt = NULL;
  24244.       ffestb_local_.decl.len = NULL;
  24245.       ffestb_local_.decl.lent = NULL;
  24246.       return (ffelexHandler) ffestb_decl_R539letters_;
  24247.  
  24248.     case FFESTR_secondDOUBLECOMPLEX:
  24249.       ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
  24250.       ffestb_local_.decl.kind = NULL;
  24251.       ffestb_local_.decl.kindt = NULL;
  24252.       ffestb_local_.decl.len = NULL;
  24253.       ffestb_local_.decl.lent = NULL;
  24254.       return (ffelexHandler) ffestb_decl_R539letters_;
  24255.  
  24256.     case FFESTR_secondNONE:
  24257.       return (ffelexHandler) ffestb_decl_R5394_;
  24258.  
  24259. #if FFESTR_F90
  24260.     case FFESTR_secondTYPE:
  24261.       ffestb_local_.decl.type = FFESTP_typeTYPE;
  24262.       return (ffelexHandler) ffestb_decl_R5393_;
  24263. #endif
  24264.  
  24265.     default:
  24266.       goto bad_1;        /* :::::::::::::::::::: */
  24267.     }
  24268.  
  24269.     case FFELEX_typeNAMES:
  24270.       if (ffesta_first_kw != FFESTR_firstIMPLICIT)
  24271.     goto bad_0;        /* :::::::::::::::::::: */
  24272.       switch (ffelex_token_type (t))
  24273.     {
  24274.     case FFELEX_typeCOMMA:
  24275.     case FFELEX_typeCOLONCOLON:
  24276.     case FFELEX_typeASTERISK:
  24277.     case FFELEX_typeSEMICOLON:
  24278.     case FFELEX_typeEOS:
  24279.       ffesta_confirmed ();
  24280.       break;
  24281.  
  24282.     case FFELEX_typeOPEN_PAREN:
  24283.       break;
  24284.  
  24285.     default:
  24286.       goto bad_1;        /* :::::::::::::::::::: */
  24287.     }
  24288.       p = ffelex_token_text (ffesta_tokens[0]) + (i = FFESTR_firstlIMPLICIT);
  24289.       if (!ffesrc_is_name_init (*p))
  24290.     goto bad_0;        /* :::::::::::::::::::: */
  24291.       ffestb_local_.decl.imp_started = FALSE;
  24292.       nt = ffelex_token_name_from_names (ffesta_tokens[0],
  24293.                      FFESTR_firstlIMPLICIT, 0);
  24294.       kw = ffestr_second (nt);
  24295.       ffelex_token_kill (nt);
  24296.       switch (kw)
  24297.     {
  24298.     case FFESTR_secondINTEGER:
  24299.       ffestb_local_.decl.type = FFESTP_typeINTEGER;
  24300.       return (ffelexHandler) ffestb_decl_R5391_ (t);
  24301.  
  24302.     case FFESTR_secondREAL:
  24303.       ffestb_local_.decl.type = FFESTP_typeREAL;
  24304.       return (ffelexHandler) ffestb_decl_R5391_ (t);
  24305.  
  24306.     case FFESTR_secondCOMPLEX:
  24307.       ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
  24308.       return (ffelexHandler) ffestb_decl_R5391_ (t);
  24309.  
  24310.     case FFESTR_secondLOGICAL:
  24311.       ffestb_local_.decl.type = FFESTP_typeLOGICAL;
  24312.       return (ffelexHandler) ffestb_decl_R5391_ (t);
  24313.  
  24314.     case FFESTR_secondCHARACTER:
  24315.       ffestb_local_.decl.type = FFESTP_typeCHARACTER;
  24316.       return (ffelexHandler) ffestb_decl_R5391_ (t);
  24317.  
  24318.     case FFESTR_secondDOUBLEPRECISION:
  24319.       ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
  24320.       ffestb_local_.decl.kind = NULL;
  24321.       ffestb_local_.decl.kindt = NULL;
  24322.       ffestb_local_.decl.len = NULL;
  24323.       ffestb_local_.decl.lent = NULL;
  24324.       return (ffelexHandler) ffestb_decl_R539letters_ (t);
  24325.  
  24326.     case FFESTR_secondDOUBLECOMPLEX:
  24327.       ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
  24328.       ffestb_local_.decl.kind = NULL;
  24329.       ffestb_local_.decl.kindt = NULL;
  24330.       ffestb_local_.decl.len = NULL;
  24331.       ffestb_local_.decl.lent = NULL;
  24332.       return (ffelexHandler) ffestb_decl_R539letters_ (t);
  24333.  
  24334.     case FFESTR_secondNONE:
  24335.       return (ffelexHandler) ffestb_decl_R5394_ (t);
  24336.  
  24337. #if FFESTR_F90
  24338.     case FFESTR_secondTYPE:
  24339.       ffestb_local_.decl.type = FFESTP_typeTYPE;
  24340.       return (ffelexHandler) ffestb_decl_R5393_ (t);
  24341. #endif
  24342.  
  24343.     default:
  24344.       goto bad_1;        /* :::::::::::::::::::: */
  24345.     }
  24346.  
  24347.     default:
  24348.       goto bad_0;        /* :::::::::::::::::::: */
  24349.     }
  24350.  
  24351. bad_0:                /* :::::::::::::::::::: */
  24352.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", ffesta_tokens[0]);
  24353.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24354.  
  24355. bad_1:                /* :::::::::::::::::::: */
  24356.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  24357.   return (ffelexHandler) ffelex_swallow_tokens (t,
  24358.                         (ffelexHandler) ffesta_zero);    /* Invalid second token. */
  24359. }
  24360.  
  24361. /* ffestb_decl_R5391_ -- "IMPLICIT" generic-type
  24362.  
  24363.    return ffestb_decl_R5391_;  // to lexer
  24364.  
  24365.    Handle ASTERISK or OPEN_PAREN.  */
  24366.  
  24367. static ffelexHandler
  24368. ffestb_decl_R5391_ (ffelexToken t)
  24369. {
  24370.   switch (ffelex_token_type (t))
  24371.     {
  24372.     case FFELEX_typeASTERISK:
  24373.       ffesta_confirmed ();
  24374.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
  24375.       ffestb_local_.decl.badname = "IMPLICIT";
  24376.       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
  24377.     return (ffelexHandler) ffestb_decl_starlen_;
  24378.       return (ffelexHandler) ffestb_decl_starkind_;
  24379.  
  24380.     case FFELEX_typeOPEN_PAREN:
  24381.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
  24382.       ffestb_local_.decl.badname = "IMPLICIT";
  24383.       ffestb_local_.decl.kind = NULL;
  24384.       ffestb_local_.decl.kindt = NULL;
  24385.       ffestb_local_.decl.len = NULL;
  24386.       ffestb_local_.decl.lent = NULL;
  24387.       if (ffestb_local_.decl.type == FFESTP_typeCHARACTER)
  24388.     ffestb_local_.decl.imp_handler
  24389.       = (ffelexHandler) ffestb_decl_typeparams_;
  24390.       else
  24391.     ffestb_local_.decl.imp_handler
  24392.       = (ffelexHandler) ffestb_decl_kindparam_;
  24393.       return (ffelexHandler) ffestb_decl_R539maybe_ (t);
  24394.  
  24395.     default:
  24396.       break;
  24397.     }
  24398.  
  24399.   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
  24400.     ffestc_R539finish ();
  24401.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  24402.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24403. }
  24404.  
  24405. /* ffestb_decl_R5392_ -- "IMPLICIT" "DOUBLE"
  24406.  
  24407.    return ffestb_decl_R5392_;  // to lexer
  24408.  
  24409.    Handle NAME.     */
  24410.  
  24411. static ffelexHandler
  24412. ffestb_decl_R5392_ (ffelexToken t)
  24413. {
  24414.   switch (ffelex_token_type (t))
  24415.     {
  24416.     case FFELEX_typeNAME:
  24417.       switch (ffestr_second (t))
  24418.     {
  24419.     case FFESTR_secondPRECISION:
  24420.       ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
  24421.       break;
  24422.  
  24423.     case FFESTR_secondCOMPLEX:
  24424.       ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
  24425.       break;
  24426.  
  24427.     default:
  24428.       goto bad;        /* :::::::::::::::::::: */
  24429.     }
  24430.       ffestb_local_.decl.kind = NULL;
  24431.       ffestb_local_.decl.kindt = NULL;
  24432.       ffestb_local_.decl.len = NULL;
  24433.       ffestb_local_.decl.lent = NULL;
  24434.       return (ffelexHandler) ffestb_decl_R539letters_;
  24435.  
  24436.     default:
  24437.       break;
  24438.     }
  24439.  
  24440. bad:                /* :::::::::::::::::::: */
  24441.   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
  24442.     ffestc_R539finish ();
  24443.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  24444.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24445. }
  24446.  
  24447. /* ffestb_decl_R5393_ -- "IMPLICIT" "TYPE"
  24448.  
  24449.    return ffestb_decl_R5393_;  // to lexer
  24450.  
  24451.    Handle OPEN_PAREN.  */
  24452.  
  24453. #if FFESTR_F90
  24454. static ffelexHandler
  24455. ffestb_decl_R5393_ (ffelexToken t)
  24456. {
  24457.   switch (ffelex_token_type (t))
  24458.     {
  24459.     case FFELEX_typeOPEN_PAREN:
  24460.       ffestb_local_.decl.handler = (ffelexHandler) ffestb_decl_R539letters_;
  24461.       ffestb_local_.decl.badname = "IMPLICIT";
  24462.       return (ffelexHandler) ffestb_decl_typetype1_;
  24463.  
  24464.     default:
  24465.       break;
  24466.     }
  24467.  
  24468.   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
  24469.     ffestc_R539finish ();
  24470.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  24471.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24472. }
  24473.  
  24474. #endif
  24475. /* ffestb_decl_R5394_ -- "IMPLICIT" "NONE"
  24476.  
  24477.    return ffestb_decl_R5394_;  // to lexer
  24478.  
  24479.    Handle EOS/SEMICOLON.  */
  24480.  
  24481. static ffelexHandler
  24482. ffestb_decl_R5394_ (ffelexToken t)
  24483. {
  24484.   switch (ffelex_token_type (t))
  24485.     {
  24486.     case FFELEX_typeEOS:
  24487.     case FFELEX_typeSEMICOLON:
  24488.       ffesta_confirmed ();
  24489.       if (!ffesta_is_inhibited ())
  24490.     ffestc_R539 ();        /* IMPLICIT NONE. */
  24491.       return (ffelexHandler) ffesta_zero (t);
  24492.  
  24493.     default:
  24494.       break;
  24495.     }
  24496.  
  24497.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  24498.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24499. }
  24500.  
  24501. /* ffestb_decl_R5395_ -- "IMPLICIT" implicit-spec-list COMMA
  24502.  
  24503.    return ffestb_decl_R5395_;  // to lexer
  24504.  
  24505.    Handle NAME for next type-spec.  */
  24506.  
  24507. static ffelexHandler
  24508. ffestb_decl_R5395_ (ffelexToken t)
  24509. {
  24510.   switch (ffelex_token_type (t))
  24511.     {
  24512.     case FFELEX_typeNAME:
  24513.       switch (ffestr_second (t))
  24514.     {
  24515.     case FFESTR_secondINTEGER:
  24516.       ffestb_local_.decl.type = FFESTP_typeINTEGER;
  24517.       return (ffelexHandler) ffestb_decl_R5391_;
  24518.  
  24519.     case FFESTR_secondREAL:
  24520.       ffestb_local_.decl.type = FFESTP_typeREAL;
  24521.       return (ffelexHandler) ffestb_decl_R5391_;
  24522.  
  24523.     case FFESTR_secondCOMPLEX:
  24524.       ffestb_local_.decl.type = FFESTP_typeCOMPLEX;
  24525.       return (ffelexHandler) ffestb_decl_R5391_;
  24526.  
  24527.     case FFESTR_secondLOGICAL:
  24528.       ffestb_local_.decl.type = FFESTP_typeLOGICAL;
  24529.       return (ffelexHandler) ffestb_decl_R5391_;
  24530.  
  24531.     case FFESTR_secondCHARACTER:
  24532.       ffestb_local_.decl.type = FFESTP_typeCHARACTER;
  24533.       return (ffelexHandler) ffestb_decl_R5391_;
  24534.  
  24535.     case FFESTR_secondDOUBLE:
  24536.       return (ffelexHandler) ffestb_decl_R5392_;
  24537.  
  24538.     case FFESTR_secondDOUBLEPRECISION:
  24539.       ffestb_local_.decl.type = FFESTP_typeDBLPRCSN;
  24540.       ffestb_local_.decl.kind = NULL;
  24541.       ffestb_local_.decl.kindt = NULL;
  24542.       ffestb_local_.decl.len = NULL;
  24543.       ffestb_local_.decl.lent = NULL;
  24544.       return (ffelexHandler) ffestb_decl_R539letters_;
  24545.  
  24546.     case FFESTR_secondDOUBLECOMPLEX:
  24547.       ffestb_local_.decl.type = FFESTP_typeDBLCMPLX;
  24548.       ffestb_local_.decl.kind = NULL;
  24549.       ffestb_local_.decl.kindt = NULL;
  24550.       ffestb_local_.decl.len = NULL;
  24551.       ffestb_local_.decl.lent = NULL;
  24552.       return (ffelexHandler) ffestb_decl_R539letters_;
  24553.  
  24554. #if FFESTR_F90
  24555.     case FFESTR_secondTYPE:
  24556.       ffestb_local_.decl.type = FFESTP_typeTYPE;
  24557.       return (ffelexHandler) ffestb_decl_R5393_;
  24558. #endif
  24559.  
  24560.     default:
  24561.       break;
  24562.     }
  24563.       break;
  24564.  
  24565.     default:
  24566.       break;
  24567.     }
  24568.  
  24569.   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
  24570.     ffestc_R539finish ();
  24571.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  24572.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24573. }
  24574.  
  24575. /* ffestb_decl_R539letters_ -- "IMPLICIT" type-spec
  24576.  
  24577.    return ffestb_decl_R539letters_;  // to lexer
  24578.  
  24579.    Handle OPEN_PAREN.  */
  24580.  
  24581. static ffelexHandler
  24582. ffestb_decl_R539letters_ (ffelexToken t)
  24583. {
  24584.   ffelex_set_names (FALSE);
  24585.  
  24586.   switch (ffelex_token_type (t))
  24587.     {
  24588.     case FFELEX_typeOPEN_PAREN:
  24589.       ffestb_local_.decl.imps = ffestt_implist_create ();
  24590.       return (ffelexHandler) ffestb_decl_R539letters_1_;
  24591.  
  24592.     default:
  24593.       break;
  24594.     }
  24595.  
  24596.   if (ffestb_local_.decl.kindt != NULL)
  24597.     ffelex_token_kill (ffestb_local_.decl.kindt);
  24598.   if (ffestb_local_.decl.lent != NULL)
  24599.     ffelex_token_kill (ffestb_local_.decl.lent);
  24600.   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
  24601.     ffestc_R539finish ();
  24602.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  24603.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24604. }
  24605.  
  24606. /* ffestb_decl_R539letters_1_ -- "IMPLICIT" type-spec OPEN_PAREN
  24607.  
  24608.    return ffestb_decl_R539letters_1_;  // to lexer
  24609.  
  24610.    Handle NAME.     */
  24611.  
  24612. static ffelexHandler
  24613. ffestb_decl_R539letters_1_ (ffelexToken t)
  24614. {
  24615.   switch (ffelex_token_type (t))
  24616.     {
  24617.     case FFELEX_typeNAME:
  24618.       if (ffelex_token_length (t) != 1)
  24619.     break;
  24620.       ffesta_tokens[1] = ffelex_token_use (t);
  24621.       return (ffelexHandler) ffestb_decl_R539letters_2_;
  24622.  
  24623.     default:
  24624.       break;
  24625.     }
  24626.  
  24627.   ffestt_implist_kill (ffestb_local_.decl.imps);
  24628.   if (ffestb_local_.decl.kindt != NULL)
  24629.     ffelex_token_kill (ffestb_local_.decl.kindt);
  24630.   if (ffestb_local_.decl.lent != NULL)
  24631.     ffelex_token_kill (ffestb_local_.decl.lent);
  24632.   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
  24633.     ffestc_R539finish ();
  24634.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  24635.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24636. }
  24637.  
  24638. /* ffestb_decl_R539letters_2_ -- "IMPLICIT" type-spec OPEN_PAREN NAME
  24639.  
  24640.    return ffestb_decl_R539letters_2_;  // to lexer
  24641.  
  24642.    Handle COMMA or MINUS.  */
  24643.  
  24644. static ffelexHandler
  24645. ffestb_decl_R539letters_2_ (ffelexToken t)
  24646. {
  24647.   switch (ffelex_token_type (t))
  24648.     {
  24649.     case FFELEX_typeCOMMA:
  24650.       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
  24651.       return (ffelexHandler) ffestb_decl_R539letters_1_;
  24652.  
  24653.     case FFELEX_typeCLOSE_PAREN:
  24654.       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
  24655.       return (ffelexHandler) ffestb_decl_R539letters_5_;
  24656.  
  24657.     case FFELEX_typeMINUS:
  24658.       return (ffelexHandler) ffestb_decl_R539letters_3_;
  24659.  
  24660.     default:
  24661.       break;
  24662.     }
  24663.  
  24664.   ffelex_token_kill (ffesta_tokens[1]);
  24665.   ffestt_implist_kill (ffestb_local_.decl.imps);
  24666.   if (ffestb_local_.decl.kindt != NULL)
  24667.     ffelex_token_kill (ffestb_local_.decl.kindt);
  24668.   if (ffestb_local_.decl.lent != NULL)
  24669.     ffelex_token_kill (ffestb_local_.decl.lent);
  24670.   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
  24671.     ffestc_R539finish ();
  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_R539letters_3_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
  24677.  
  24678.    return ffestb_decl_R539letters_3_;  // to lexer
  24679.  
  24680.    Handle NAME.     */
  24681.  
  24682. static ffelexHandler
  24683. ffestb_decl_R539letters_3_ (ffelexToken t)
  24684. {
  24685.   switch (ffelex_token_type (t))
  24686.     {
  24687.     case FFELEX_typeNAME:
  24688.       if (ffelex_token_length (t) != 1)
  24689.     break;
  24690.       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1],
  24691.                  ffelex_token_use (t));
  24692.       return (ffelexHandler) ffestb_decl_R539letters_4_;
  24693.  
  24694.     default:
  24695.       break;
  24696.     }
  24697.  
  24698.   ffelex_token_kill (ffesta_tokens[1]);
  24699.   ffestt_implist_kill (ffestb_local_.decl.imps);
  24700.   if (ffestb_local_.decl.kindt != NULL)
  24701.     ffelex_token_kill (ffestb_local_.decl.kindt);
  24702.   if (ffestb_local_.decl.lent != NULL)
  24703.     ffelex_token_kill (ffestb_local_.decl.lent);
  24704.   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
  24705.     ffestc_R539finish ();
  24706.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  24707.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24708. }
  24709.  
  24710. /* ffestb_decl_R539letters_4_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
  24711.                  NAME
  24712.  
  24713.    return ffestb_decl_R539letters_4_;  // to lexer
  24714.  
  24715.    Handle COMMA or CLOSE_PAREN.     */
  24716.  
  24717. static ffelexHandler
  24718. ffestb_decl_R539letters_4_ (ffelexToken t)
  24719. {
  24720.   switch (ffelex_token_type (t))
  24721.     {
  24722.     case FFELEX_typeCOMMA:
  24723.       return (ffelexHandler) ffestb_decl_R539letters_1_;
  24724.  
  24725.     case FFELEX_typeCLOSE_PAREN:
  24726.       return (ffelexHandler) ffestb_decl_R539letters_5_;
  24727.  
  24728.     default:
  24729.       break;
  24730.     }
  24731.  
  24732.   ffestt_implist_kill (ffestb_local_.decl.imps);
  24733.   if (ffestb_local_.decl.kindt != NULL)
  24734.     ffelex_token_kill (ffestb_local_.decl.kindt);
  24735.   if (ffestb_local_.decl.lent != NULL)
  24736.     ffelex_token_kill (ffestb_local_.decl.lent);
  24737.   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
  24738.     ffestc_R539finish ();
  24739.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  24740.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24741. }
  24742.  
  24743. /* ffestb_decl_R539letters_5_ -- "IMPLICIT" type-spec OPEN_PAREN
  24744.                  letter-spec-list CLOSE_PAREN
  24745.  
  24746.    return ffestb_decl_R539letters_5_;  // to lexer
  24747.  
  24748.    Handle COMMA or EOS/SEMICOLON.  */
  24749.  
  24750. static ffelexHandler
  24751. ffestb_decl_R539letters_5_ (ffelexToken t)
  24752. {
  24753.   switch (ffelex_token_type (t))
  24754.     {
  24755.     case FFELEX_typeCOMMA:
  24756.     case FFELEX_typeEOS:
  24757.     case FFELEX_typeSEMICOLON:
  24758.       if (!ffestb_local_.decl.imp_started)
  24759.     {
  24760.       ffestb_local_.decl.imp_started = TRUE;
  24761.       ffesta_confirmed ();
  24762.       if (!ffesta_is_inhibited ())
  24763.         ffestc_R539start ();
  24764.     }
  24765.       if (!ffesta_is_inhibited ())
  24766.     ffestc_R539item (ffestb_local_.decl.type, ffestb_local_.decl.kind,
  24767.              ffestb_local_.decl.kindt, ffestb_local_.decl.len,
  24768.              ffestb_local_.decl.lent, ffestb_local_.decl.imps);
  24769.       if (ffestb_local_.decl.kindt != NULL)
  24770.     ffelex_token_kill (ffestb_local_.decl.kindt);
  24771.       if (ffestb_local_.decl.lent != NULL)
  24772.     ffelex_token_kill (ffestb_local_.decl.lent);
  24773.       ffestt_implist_kill (ffestb_local_.decl.imps);
  24774.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  24775.     return (ffelexHandler) ffestb_decl_R5395_;
  24776.       if (!ffesta_is_inhibited ())
  24777.     ffestc_R539finish ();
  24778.       return (ffelexHandler) ffesta_zero (t);
  24779.  
  24780.     default:
  24781.       break;
  24782.     }
  24783.  
  24784.   ffestt_implist_kill (ffestb_local_.decl.imps);
  24785.   if (ffestb_local_.decl.kindt != NULL)
  24786.     ffelex_token_kill (ffestb_local_.decl.kindt);
  24787.   if (ffestb_local_.decl.lent != NULL)
  24788.     ffelex_token_kill (ffestb_local_.decl.lent);
  24789.   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
  24790.     ffestc_R539finish ();
  24791.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  24792.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  24793. }
  24794.  
  24795. /* ffestb_decl_R539maybe_ -- "IMPLICIT" generic-type-spec
  24796.  
  24797.    return ffestb_decl_R539maybe_;  // to lexer
  24798.  
  24799.    Handle OPEN_PAREN.  */
  24800.  
  24801. static ffelexHandler
  24802. ffestb_decl_R539maybe_ (ffelexToken t)
  24803. {
  24804.   assert (ffelex_token_type (t) == FFELEX_typeOPEN_PAREN);
  24805.   ffestb_local_.decl.imps = ffestt_implist_create ();
  24806.   ffestb_local_.decl.toklist = ffestt_tokenlist_create ();
  24807.   ffestb_local_.decl.imp_seen_comma
  24808.     = (ffestb_local_.decl.type != FFESTP_typeCHARACTER);
  24809.   return (ffelexHandler) ffestb_decl_R539maybe_1_;
  24810. }
  24811.  
  24812. /* ffestb_decl_R539maybe_1_ -- "IMPLICIT" generic-type-spec OPEN_PAREN
  24813.  
  24814.    return ffestb_decl_R539maybe_1_;  // to lexer
  24815.  
  24816.    Handle NAME.     */
  24817.  
  24818. static ffelexHandler
  24819. ffestb_decl_R539maybe_1_ (ffelexToken t)
  24820. {
  24821.   ffelexHandler next;
  24822.  
  24823.   switch (ffelex_token_type (t))
  24824.     {
  24825.     case FFELEX_typeNAME:
  24826.       if (ffelex_token_length (t) != 1)
  24827.     break;
  24828.       ffesta_tokens[1] = ffelex_token_use (t);
  24829.       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
  24830.       return (ffelexHandler) ffestb_decl_R539maybe_2_;
  24831.  
  24832.     default:
  24833.       break;
  24834.     }
  24835.  
  24836.   ffestt_implist_kill (ffestb_local_.decl.imps);
  24837.   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
  24838.                 (ffelexHandler) ffestb_local_.decl.imp_handler);
  24839.   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  24840.   return (ffelexHandler) (*next) (t);
  24841. }
  24842.  
  24843. /* ffestb_decl_R539maybe_2_ -- "IMPLICIT" generic-type-spec OPEN_PAREN NAME
  24844.  
  24845.    return ffestb_decl_R539maybe_2_;  // to lexer
  24846.  
  24847.    Handle COMMA or MINUS.  */
  24848.  
  24849. static ffelexHandler
  24850. ffestb_decl_R539maybe_2_ (ffelexToken t)
  24851. {
  24852.   ffelexHandler next;
  24853.  
  24854.   switch (ffelex_token_type (t))
  24855.     {
  24856.     case FFELEX_typeCOMMA:
  24857.       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
  24858.       if (ffestb_local_.decl.imp_seen_comma)
  24859.     {
  24860.       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  24861.       return (ffelexHandler) ffestb_decl_R539letters_1_;
  24862.     }
  24863.       ffestb_local_.decl.imp_seen_comma = TRUE;
  24864.       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
  24865.       return (ffelexHandler) ffestb_decl_R539maybe_1_;
  24866.  
  24867.     case FFELEX_typeCLOSE_PAREN:
  24868.       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1], NULL);
  24869.       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
  24870.       return (ffelexHandler) ffestb_decl_R539maybe_5_;
  24871.  
  24872.     case FFELEX_typeMINUS:
  24873.       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
  24874.       return (ffelexHandler) ffestb_decl_R539maybe_3_;
  24875.  
  24876.     default:
  24877.       break;
  24878.     }
  24879.  
  24880.   ffelex_token_kill (ffesta_tokens[1]);
  24881.   ffestt_implist_kill (ffestb_local_.decl.imps);
  24882.   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
  24883.                 (ffelexHandler) ffestb_local_.decl.imp_handler);
  24884.   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  24885.   return (ffelexHandler) (*next) (t);
  24886. }
  24887.  
  24888. /* ffestb_decl_R539maybe_3_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
  24889.  
  24890.    return ffestb_decl_R539maybe_3_;  // to lexer
  24891.  
  24892.    Handle NAME.     */
  24893.  
  24894. static ffelexHandler
  24895. ffestb_decl_R539maybe_3_ (ffelexToken t)
  24896. {
  24897.   ffelexHandler next;
  24898.  
  24899.   switch (ffelex_token_type (t))
  24900.     {
  24901.     case FFELEX_typeNAME:
  24902.       if (ffelex_token_length (t) != 1)
  24903.     break;
  24904.       ffestt_implist_append (ffestb_local_.decl.imps, ffesta_tokens[1],
  24905.                  ffelex_token_use (t));
  24906.       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
  24907.       return (ffelexHandler) ffestb_decl_R539maybe_4_;
  24908.  
  24909.     default:
  24910.       break;
  24911.     }
  24912.  
  24913.   ffelex_token_kill (ffesta_tokens[1]);
  24914.   ffestt_implist_kill (ffestb_local_.decl.imps);
  24915.   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
  24916.                 (ffelexHandler) ffestb_local_.decl.imp_handler);
  24917.   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  24918.   return (ffelexHandler) (*next) (t);
  24919. }
  24920.  
  24921. /* ffestb_decl_R539maybe_4_ -- "IMPLICIT" type-spec OPEN_PAREN NAME MINUS
  24922.                  NAME
  24923.  
  24924.    return ffestb_decl_R539maybe_4_;  // to lexer
  24925.  
  24926.    Handle COMMA or CLOSE_PAREN.     */
  24927.  
  24928. static ffelexHandler
  24929. ffestb_decl_R539maybe_4_ (ffelexToken t)
  24930. {
  24931.   ffelexHandler next;
  24932.  
  24933.   switch (ffelex_token_type (t))
  24934.     {
  24935.     case FFELEX_typeCOMMA:
  24936.       if (ffestb_local_.decl.imp_seen_comma)
  24937.     {
  24938.       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  24939.       return (ffelexHandler) ffestb_decl_R539letters_1_;
  24940.     }
  24941.       ffestb_local_.decl.imp_seen_comma = TRUE;
  24942.       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
  24943.       return (ffelexHandler) ffestb_decl_R539maybe_1_;
  24944.  
  24945.     case FFELEX_typeCLOSE_PAREN:
  24946.       ffestt_tokenlist_append (ffestb_local_.decl.toklist, ffelex_token_use (t));
  24947.       return (ffelexHandler) ffestb_decl_R539maybe_5_;
  24948.  
  24949.     default:
  24950.       break;
  24951.     }
  24952.  
  24953.   ffestt_implist_kill (ffestb_local_.decl.imps);
  24954.   next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
  24955.                 (ffelexHandler) ffestb_local_.decl.imp_handler);
  24956.   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  24957.   return (ffelexHandler) (*next) (t);
  24958. }
  24959.  
  24960. /* ffestb_decl_R539maybe_5_ -- "IMPLICIT" type-spec OPEN_PAREN
  24961.                  letter-spec-list CLOSE_PAREN
  24962.  
  24963.    return ffestb_decl_R539maybe_5_;  // to lexer
  24964.  
  24965.    Handle COMMA or EOS/SEMICOLON.  */
  24966.  
  24967. static ffelexHandler
  24968. ffestb_decl_R539maybe_5_ (ffelexToken t)
  24969. {
  24970.   ffelexHandler next;
  24971.  
  24972.   switch (ffelex_token_type (t))
  24973.     {
  24974.     case FFELEX_typeCOMMA:
  24975.     case FFELEX_typeEOS:
  24976.     case FFELEX_typeSEMICOLON:
  24977.       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  24978.       if (!ffestb_local_.decl.imp_started)
  24979.     {
  24980.       ffestb_local_.decl.imp_started = TRUE;
  24981.       ffesta_confirmed ();
  24982.       if (!ffesta_is_inhibited ())
  24983.         ffestc_R539start ();
  24984.     }
  24985.       if (!ffesta_is_inhibited ())
  24986.     ffestc_R539item (ffestb_local_.decl.type, ffestb_local_.decl.kind,
  24987.              ffestb_local_.decl.kindt, ffestb_local_.decl.len,
  24988.              ffestb_local_.decl.lent, ffestb_local_.decl.imps);
  24989.       if (ffestb_local_.decl.kindt != NULL)
  24990.     ffelex_token_kill (ffestb_local_.decl.kindt);
  24991.       if (ffestb_local_.decl.lent != NULL)
  24992.     ffelex_token_kill (ffestb_local_.decl.lent);
  24993.       ffestt_implist_kill (ffestb_local_.decl.imps);
  24994.       if (ffelex_token_type (t) == FFELEX_typeCOMMA)
  24995.     return (ffelexHandler) ffestb_decl_R5395_;
  24996.       if (!ffesta_is_inhibited ())
  24997.     ffestc_R539finish ();
  24998.       return (ffelexHandler) ffesta_zero (t);
  24999.  
  25000.     case FFELEX_typeOPEN_PAREN:
  25001.       ffesta_confirmed ();
  25002.       ffestt_implist_kill (ffestb_local_.decl.imps);
  25003.       next = (ffelexHandler) ffestt_tokenlist_handle (ffestb_local_.decl.toklist,
  25004.                 (ffelexHandler) ffestb_local_.decl.imp_handler);
  25005.       ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  25006.       return (ffelexHandler) (*next) (t);
  25007.  
  25008.     default:
  25009.       break;
  25010.     }
  25011.  
  25012.   ffestt_implist_kill (ffestb_local_.decl.imps);
  25013.   ffestt_tokenlist_kill (ffestb_local_.decl.toklist);
  25014.   if (ffestb_local_.decl.kindt != NULL)
  25015.     ffelex_token_kill (ffestb_local_.decl.kindt);
  25016.   if (ffestb_local_.decl.lent != NULL)
  25017.     ffelex_token_kill (ffestb_local_.decl.lent);
  25018.   if (ffestb_local_.decl.imp_started && !ffesta_is_inhibited ())
  25019.     ffestc_R539finish ();
  25020.   ffesta_ffebad_1st (FFEBAD_INVALID_STMT_FORM, "IMPLICIT", t);
  25021.   return (ffelexHandler) ffelex_swallow_tokens (t, (ffelexHandler) ffesta_zero);
  25022. }
  25023.