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 / sta.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  61KB  |  1,827 lines
  1. /* sta.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.       None
  23.  
  24.    Description:
  25.       Analyzes the first two tokens, figures out what statements are
  26.       possible, tries parsing the possible statements by calling on
  27.       the ffestb functions.
  28.  
  29.    Modifications:
  30. */
  31.  
  32. /* Include files. */
  33.  
  34. #include "proj.h"
  35. #include "sta.h"
  36. #include "bad.h"
  37. #include "implic.h"
  38. #include "lex.h"
  39. #include "malloc.h"
  40. #include "stb.h"
  41. #include "stc.h"
  42. #include "std.h"
  43. #include "str.h"
  44. #include "storag.h"
  45. #include "symbol.h"
  46.  
  47. /* Externals defined here. */
  48.  
  49. ffelexToken ffesta_tokens[FFESTA_tokensMAX];    /* For use by a possible. */
  50. ffestrFirst ffesta_first_kw;    /* First NAME(S) looked up. */
  51. ffestrSecond ffesta_second_kw;    /* Second NAME(S) looked up. */
  52. mallocPool ffesta_output_pool;    /* Pool for results of stmt handling. */
  53. mallocPool ffesta_scratch_pool;    /* Pool for stmt scratch handling. */
  54. ffelexToken ffesta_construct_name;
  55. ffelexToken ffesta_label_token;    /* Pending label stuff. */
  56. bool ffesta_seen_first_exec;
  57. bool ffesta_is_entry_valid = FALSE;    /* TRUE only in SUBROUTINE/FUNCTION. */
  58. bool ffesta_line_has_semicolons = FALSE;
  59.  
  60. /* Simple definitions and enumerations. */
  61.  
  62. #define FFESTA_ABORT_ON_CONFIRM_ 1    /* 0=slow, tested way; 1=faster way
  63.                        that might not always work. Here's
  64.                        the old description of what used
  65.                        to not work with ==1: (try
  66.                        "CONTINUE\10
  67.                        FORMAT('hi',I11)\END").  Problem
  68.                        is that the "topology" of the
  69.                        confirmed stmt's tokens with
  70.                        regard to CHARACTER, HOLLERITH,
  71.                        NAME/NAMES/NUMBER tokens (like hex
  72.                        numbers), isn't traced if we abort
  73.                        early, then other stmts might get
  74.                        their grubby hands on those
  75.                        unprocessed tokens and commit them
  76.                        improperly.    Ideal fix is to rerun
  77.                        the confirmed stmt and forget the
  78.                        rest.  */
  79.  
  80. #define FFESTA_maxPOSSIBLES_ 100/* Never more than this # of possibles. */
  81.  
  82. /* Internal typedefs. */
  83.  
  84. typedef struct _ffesta_possible_ *ffestaPossible_;
  85.  
  86. /* Private include files. */
  87.  
  88.  
  89. /* Internal structure definitions. */
  90.  
  91. struct _ffesta_possible_
  92.   {
  93.     ffestaPossible_ next;
  94.     ffestaPossible_ previous;
  95.     ffelexHandler handler;
  96.   };
  97.  
  98. struct _ffesta_possible_root_
  99.   {
  100.     ffestaPossible_ first;
  101.     ffestaPossible_ last;
  102.     ffelexHandler nil;
  103.   };
  104.  
  105. /* Static objects accessed by functions in this module. */
  106.  
  107. static bool ffesta_is_inhibited_ = FALSE;
  108. static ffelexToken ffesta_token_0_;    /* For use by ffest possibility
  109.                        handling. */
  110. static ffestaPossible_ ffesta_possibles_[FFESTA_maxPOSSIBLES_];
  111. static int ffesta_num_possibles_ = 0;    /* Next possibility to use. */
  112. static struct _ffesta_possible_root_ ffesta_possible_nonexecs_;
  113. static struct _ffesta_possible_root_ ffesta_possible_execs_;
  114. static ffestaPossible_ ffesta_current_possible_;
  115. static ffelexHandler ffesta_current_handler_;
  116. static bool ffesta_confirmed_current_ = FALSE;
  117. static bool ffesta_confirmed_other_ = FALSE;
  118. static ffestaPossible_ ffesta_confirmed_possible_;
  119. static bool ffesta_current_shutdown_ = FALSE;
  120. #if !FFESTA_ABORT_ON_CONFIRM_
  121. static bool ffesta_is_two_into_statement_ = FALSE;    /* For IF, WHERE stmts. */
  122. static ffelexToken ffesta_twotokens_1_;    /* For IF, WHERE stmts. */
  123. static ffelexToken ffesta_twotokens_2_;    /* For IF, WHERE stmts. */
  124. #endif
  125. static ffestaPooldisp ffesta_outpooldisp_;    /* After statement dealt
  126.                            with. */
  127. static bool ffesta_inhibit_confirmation_ = FALSE;
  128.  
  129. /* Static functions (internal). */
  130.  
  131. static void ffesta_add_possible_exec_ (ffelexHandler fn);
  132. static void ffesta_add_possible_nonexec_ (ffelexHandler fn);
  133. static bool ffesta_inhibited_exec_transition_ (void);
  134. static void ffesta_reset_possibles_ (void);
  135. static ffelexHandler ffesta_save_ (ffelexToken t);
  136. static ffelexHandler ffesta_second_ (ffelexToken t);
  137. #if !FFESTA_ABORT_ON_CONFIRM_
  138. static ffelexHandler ffesta_send_two_ (ffelexToken t);
  139. #endif
  140.  
  141. /* Internal macros. */
  142.  
  143.  
  144. /* ffesta_add_possible_exec_ -- Add possible executable statement to list
  145.  
  146.    ffelexHandler ffestb_some_executable_stmt_handler_;
  147.    ffesta_add_possible_exec_(ffestb_some_executable_stmt_handler_);
  148.  
  149.    Adds a possible statement to the list of executable statements, with the
  150.    specified statement handler as the recipient of the first token in the
  151.    statement.  */
  152.  
  153. static void
  154. ffesta_add_possible_exec_ (ffelexHandler fn)
  155. {
  156.   ffestaPossible_ p;
  157.  
  158.   assert (ffesta_num_possibles_ < FFESTA_maxPOSSIBLES_);
  159.  
  160.   p = ffesta_possibles_[ffesta_num_possibles_++];
  161.  
  162.   p->next = (ffestaPossible_) &ffesta_possible_execs_.first;
  163.   p->previous = ffesta_possible_execs_.last;
  164.   p->next->previous = p;
  165.   p->previous->next = p;
  166.  
  167.   p->handler = fn;
  168. }
  169.  
  170. /* ffesta_add_possible_nonexec_ -- Add possible nonexecutable statement to list
  171.  
  172.    ffelexHandler ffestb_some_nonexecutable_stmt_handler_;
  173.    ffesta_add_possible_nonexec_(ffestb_some_nonexecutable_stmt_handler_);
  174.  
  175.    Adds a possible statement to the list of nonexecutable statements, with the
  176.    specified statement handler as the recipient of the first token in the
  177.    statement.  */
  178.  
  179. static void
  180. ffesta_add_possible_nonexec_ (ffelexHandler fn)
  181. {
  182.   ffestaPossible_ p;
  183.  
  184.   assert (ffesta_num_possibles_ < FFESTA_maxPOSSIBLES_);
  185.  
  186.   p = ffesta_possibles_[ffesta_num_possibles_++];
  187.  
  188.   p->next = (ffestaPossible_) &ffesta_possible_nonexecs_.first;
  189.   p->previous = ffesta_possible_nonexecs_.last;
  190.   p->next->previous = p;
  191.   p->previous->next = p;
  192.  
  193.   p->handler = fn;
  194. }
  195.  
  196. /* ffesta_inhibited_exec_transition_ -- Do exec transition while inhibited
  197.  
  198.    if (!ffesta_inhibited_exec_transition_())  // couldn't transition...
  199.  
  200.    Invokes ffestc_exec_transition, but first enables ffebad and ffesta and
  201.    afterwards disables them again.  Then returns the result of the invoke.  */
  202.  
  203. static bool
  204. ffesta_inhibited_exec_transition_ ()
  205. {
  206.   bool result;
  207.  
  208.   assert (ffebad_inhibit ());
  209.   assert (ffesta_is_inhibited_);
  210.  
  211.   ffebad_set_inhibit (FALSE);
  212.   ffesta_is_inhibited_ = FALSE;
  213.  
  214.   result = ffestc_exec_transition ();
  215.  
  216.   ffebad_set_inhibit (TRUE);
  217.   ffesta_is_inhibited_ = TRUE;
  218.  
  219.   return result;
  220. }
  221.  
  222. /* ffesta_reset_possibles_ -- Reset (clear) lists of possible statements
  223.  
  224.    ffesta_reset_possibles_();
  225.  
  226.    Clears the lists of executable and nonexecutable statements.     */
  227.  
  228. static void
  229. ffesta_reset_possibles_ ()
  230. {
  231.   ffesta_num_possibles_ = 0;
  232.  
  233.   ffesta_possible_execs_.first = ffesta_possible_execs_.last
  234.     = (ffestaPossible_) &ffesta_possible_execs_.first;
  235.   ffesta_possible_nonexecs_.first = ffesta_possible_nonexecs_.last
  236.     = (ffestaPossible_) &ffesta_possible_nonexecs_.first;
  237. }
  238.  
  239. /* ffesta_save_ -- Save token on list, pass thru to current handler
  240.  
  241.    return ffesta_save_;     // to lexer.
  242.  
  243.    Receives a token from the lexer.  Saves it in the list of tokens.  Calls
  244.    the current handler with the token.
  245.  
  246.    If no shutdown error occurred (via
  247.    ffest_ffebad_start), then if the token was EOS or SEMICOLON, mark the
  248.    current possible as successful and confirmed but try the next possible
  249.    anyway until ambiguities in the form handling are ironed out.  */
  250.  
  251. static ffelexHandler
  252. ffesta_save_ (ffelexToken t)
  253. {
  254.   static ffelexToken *saved_tokens = NULL;    /* A variable-sized array. */
  255.   static unsigned int num_saved_tokens = 0;    /* Number currently saved. */
  256.   static unsigned int max_saved_tokens = 0;    /* Maximum to be saved. */
  257.   unsigned int toknum;        /* Index into saved_tokens array. */
  258.   ffelexToken eos;        /* EOS created on-the-fly for shutdown
  259.                    purposes. */
  260.   ffelexToken t2;        /* Another temporary token (no intersect with
  261.                    eos, btw). */
  262.  
  263.   /* Save the current token. */
  264.  
  265.   if (saved_tokens == NULL)
  266.     {
  267.       saved_tokens
  268.     = (ffelexToken *) malloc_new_ksr (malloc_pool_image (),
  269.                       "FFEST Saved Tokens",
  270.                  (max_saved_tokens = 8) * sizeof (ffelexToken));
  271.       /* Start off with 8. */
  272.     }
  273.   else if (num_saved_tokens >= max_saved_tokens)
  274.     {
  275.       toknum = max_saved_tokens;
  276.       max_saved_tokens <<= 1;    /* Multiply by two. */
  277.       assert (max_saved_tokens > toknum);
  278.       saved_tokens
  279.     = (ffelexToken *) malloc_resize_ksr (malloc_pool_image (),
  280.                          saved_tokens,
  281.                     max_saved_tokens * sizeof (ffelexToken),
  282.                          toknum * sizeof (ffelexToken));
  283.     }
  284.  
  285.   *(saved_tokens + num_saved_tokens++) = ffelex_token_use (t);
  286.  
  287.   /* Transmit the current token to the current handler. */
  288.  
  289.   ffesta_current_handler_ = (ffelexHandler) (*ffesta_current_handler_) (t);
  290.  
  291.   /* See if this possible has been shut down, or confirmed in which case we
  292.      might as well shut it down anyway to save time. */
  293.  
  294.   if ((ffesta_current_shutdown_ || (FFESTA_ABORT_ON_CONFIRM_
  295.                     && ffesta_confirmed_current_))
  296.       && !ffelex_expecting_character ())
  297.     {
  298.       switch (ffelex_token_type (t))
  299.     {
  300.     case FFELEX_typeEOS:
  301.     case FFELEX_typeSEMICOLON:
  302.       break;
  303.  
  304.     default:
  305.       eos = ffelex_token_new_eos (ffelex_token_where_line (t),
  306.                       ffelex_token_where_column (t));
  307.       ffesta_inhibit_confirmation_ = ffesta_current_shutdown_;
  308.       (*ffesta_current_handler_) (eos);
  309.       ffesta_inhibit_confirmation_ = FALSE;
  310.       ffelex_token_kill (eos);
  311.       break;
  312.     }
  313.     }
  314.   else
  315.     {
  316.  
  317.       /* If this is an EOS or SEMICOLON token, switch to next handler, else
  318.          return self as next handler for lexer. */
  319.  
  320.       switch (ffelex_token_type (t))
  321.     {
  322.     case FFELEX_typeEOS:
  323.     case FFELEX_typeSEMICOLON:
  324.       break;
  325.  
  326.     default:
  327.       return (ffelexHandler) ffesta_save_;
  328.     }
  329.     }
  330.  
  331. next_handler:            /* :::::::::::::::::::: */
  332.  
  333.   /* Note that a shutdown also happens after seeing the first two tokens
  334.      after "IF (expr)" or "WHERE (expr)" where a statement follows, even
  335.      though there is no error.    This causes the IF or WHERE form to be
  336.      implemented first before ffest_first is called for the first token in
  337.      the following statement. */
  338.  
  339.   if (ffesta_current_shutdown_)
  340.     ffesta_current_shutdown_ = FALSE;    /* Only after sending EOS! */
  341.   else
  342.     assert (ffesta_confirmed_current_);
  343.  
  344.   if (ffesta_confirmed_current_)
  345.     {
  346.       ffesta_confirmed_current_ = FALSE;
  347.       ffesta_confirmed_other_ = TRUE;
  348.     }
  349.  
  350.   /* Pick next handler. */
  351.  
  352.   ffesta_current_possible_ = ffesta_current_possible_->next;
  353.   ffesta_current_handler_ = ffesta_current_possible_->handler;
  354.   if (ffesta_current_handler_ == NULL)
  355.     {                /* No handler in this list, try exec list if
  356.                    not tried yet. */
  357.       if (ffesta_current_possible_
  358.       == (ffestaPossible_) &ffesta_possible_nonexecs_)
  359.     {
  360.       ffesta_current_possible_ = ffesta_possible_execs_.first;
  361.       ffesta_current_handler_ = ffesta_current_possible_->handler;
  362.     }
  363.       if ((ffesta_current_handler_ == NULL)
  364.       || (!ffesta_seen_first_exec
  365.           && ((ffesta_confirmed_possible_ != NULL)
  366.           || !ffesta_inhibited_exec_transition_ ())))
  367.     /* Don't run execs if:      (decoding the "if" ^^^ up here ^^^) - we
  368.        have no exec handler available, or - we haven't seen the first
  369.        executable statement yet, and - we've confirmed a nonexec
  370.        (otherwise even a nonexec would cause a transition), or - a
  371.        nonexec-to-exec transition can't be made at the statement context
  372.        level (as in an executable statement in the middle of a STRUCTURE
  373.        definition); if it can be made, ffestc_exec_transition makes the
  374.        corresponding transition at the statement state level so
  375.        specification statements are no longer accepted following an
  376.        unrecognized statement.  (Note: it is valid for f_e_t_ to decide
  377.        to always return TRUE by "shrieking" away the statement state
  378.        stack until a transitionable state is reached.  Or it can leave
  379.        the stack as is and return FALSE.)
  380.  
  381.        If we decide not to run execs, enter this block to rerun the
  382.        confirmed statement, if any. */
  383.     {            /* At end of both lists!  Pick confirmed or
  384.                    first possible. */
  385.       ffebad_set_inhibit (FALSE);
  386.       ffesta_is_inhibited_ = FALSE;
  387.       ffesta_confirmed_other_ = FALSE;
  388.       ffesta_tokens[0] = ffesta_token_0_;
  389.       if (ffesta_confirmed_possible_ == NULL)
  390.         {            /* No confirmed success, just use first
  391.                    possible. */
  392.           ffesta_current_possible_ = ffesta_possible_nonexecs_.first;
  393.           ffesta_current_handler_ = ffesta_current_possible_->handler;
  394.           if (ffesta_current_handler_ == NULL)
  395.         {
  396.           ffesta_current_possible_ = ffesta_possible_execs_.first;
  397.           ffesta_current_handler_ = ffesta_current_possible_->handler;
  398.           assert (ffesta_current_handler_ != NULL);
  399.         }
  400.         }
  401.       else
  402.         {            /* Confirmed success, use it. */
  403.           ffesta_current_possible_ = ffesta_confirmed_possible_;
  404.           ffesta_current_handler_ = ffesta_confirmed_possible_->handler;
  405.         }
  406.       ffesta_reset_possibles_ ();
  407.     }
  408.       else
  409.     {            /* Switching from [empty?] list of nonexecs
  410.                    to nonempty list of execs at this point. */
  411.       if (!ffesta_seen_first_exec)
  412.         {            /* Make sure ffestc_exec_transition()
  413.                    returned TRUE, fyi; it should be tested in
  414.                    the if statement that sends us here. */
  415.           ffesta_seen_first_exec = TRUE;
  416.           ffestd_exec_begin ();
  417.         }
  418.       ffesta_tokens[0] = ffelex_token_use (ffesta_token_0_);
  419.       ffesymbol_set_retractable (ffesta_scratch_pool);
  420.     }
  421.     }
  422.   else
  423.     {
  424.       ffesta_tokens[0] = ffelex_token_use (ffesta_token_0_);
  425.       ffesymbol_set_retractable (ffesta_scratch_pool);
  426.     }
  427.  
  428.   /* Send saved tokens to current handler until either shut down or all
  429.      tokens sent. */
  430.  
  431.   for (toknum = 0; toknum < num_saved_tokens; ++toknum)
  432.     {
  433.       t = *(saved_tokens + toknum);
  434.       switch (ffelex_token_type (t))
  435.     {
  436.     case FFELEX_typeCHARACTER:
  437.       ffelex_set_expecting_hollerith (0, '\0',
  438.                       ffewhere_line_unknown (),
  439.                       ffewhere_column_unknown ());
  440.       ffesta_current_handler_
  441.         = (ffelexHandler) (*ffesta_current_handler_) (t);
  442.       break;
  443.  
  444.     case FFELEX_typeNAMES:
  445.       if (ffelex_is_names_expected ())
  446.         ffesta_current_handler_
  447.           = (ffelexHandler) (*ffesta_current_handler_) (t);
  448.       else
  449.         {
  450.           t2 = ffelex_token_name_from_names (t, 0, 0);
  451.           ffesta_current_handler_
  452.         = (ffelexHandler) (*ffesta_current_handler_) (t2);
  453.           ffelex_token_kill (t2);
  454.         }
  455.       break;
  456.  
  457.     default:
  458.       ffesta_current_handler_
  459.         = (ffelexHandler) (*ffesta_current_handler_) (t);
  460.       break;
  461.     }
  462.  
  463.       if (!ffesta_is_inhibited_)
  464.     ffelex_token_kill (t);    /* Won't need this any more. */
  465.  
  466.       /* See if this possible has been shut down. */
  467.  
  468.       else if ((ffesta_current_shutdown_ || (FFESTA_ABORT_ON_CONFIRM_
  469.                          && ffesta_confirmed_current_))
  470.            && !ffelex_expecting_character ())
  471.     {
  472.       switch (ffelex_token_type (t))
  473.         {
  474.         case FFELEX_typeEOS:
  475.         case FFELEX_typeSEMICOLON:
  476.           break;
  477.  
  478.         default:
  479.           eos = ffelex_token_new_eos (ffelex_token_where_line (t),
  480.                       ffelex_token_where_column (t));
  481.           ffesta_inhibit_confirmation_ = ffesta_current_shutdown_;
  482.           (*ffesta_current_handler_) (eos);
  483.           ffesta_inhibit_confirmation_ = FALSE;
  484.           ffelex_token_kill (eos);
  485.           break;
  486.         }
  487.       goto next_handler;    /* :::::::::::::::::::: */
  488.     }
  489.     }
  490.  
  491.   /* Finished sending all the tokens so far.  If still trying possibilities,
  492.      then if we've just sent an EOS or SEMICOLON token through, go to the
  493.      next handler.  Otherwise, return self so we can gather and process more
  494.      tokens. */
  495.  
  496.   if (ffesta_is_inhibited_)
  497.     {
  498.       switch (ffelex_token_type (t))
  499.     {
  500.     case FFELEX_typeEOS:
  501.     case FFELEX_typeSEMICOLON:
  502.       goto next_handler;    /* :::::::::::::::::::: */
  503.  
  504.     default:
  505. #if FFESTA_ABORT_ON_CONFIRM_
  506.       assert (!ffesta_confirmed_other_);    /* Catch ambiguities. */
  507. #endif
  508.       return (ffelexHandler) ffesta_save_;
  509.     }
  510.     }
  511.  
  512.   /* This was the one final possibility, uninhibited, so send the final
  513.      handler it sent. */
  514.  
  515.   num_saved_tokens = 0;
  516. #if !FFESTA_ABORT_ON_CONFIRM_
  517.   if (ffesta_is_two_into_statement_)
  518.     {                /* End of the line for the previous two
  519.                    tokens, resurrect them. */
  520.       ffelexHandler next;
  521.  
  522.       ffesta_is_two_into_statement_ = FALSE;
  523.       next = (ffelexHandler) ffesta_first (ffesta_twotokens_1_);
  524.       ffelex_token_kill (ffesta_twotokens_1_);
  525.       next = (ffelexHandler) (*next) (ffesta_twotokens_2_);
  526.       ffelex_token_kill (ffesta_twotokens_2_);
  527.       return (ffelexHandler) next;
  528.     }
  529. #endif
  530.  
  531.   assert (ffesta_current_handler_ != NULL);
  532.   return (ffelexHandler) ffesta_current_handler_;
  533. }
  534.  
  535. /* ffesta_second_ -- Parse the token after a NAME/NAMES in a statement
  536.  
  537.    return ffesta_second_;  // to lexer.
  538.  
  539.    The second token cannot be a NAMES, since the first token is a NAME or
  540.    NAMES.  If the second token is a NAME, look up its name in the list of
  541.    second names for use by whoever needs it.
  542.  
  543.    Then make a list of all the possible statements this could be, based on
  544.    looking at the first two tokens.  Two lists of possible statements are
  545.    created, one consisting of nonexecutable statements, the other consisting
  546.    of executable statements.
  547.  
  548.    If the total number of possibilities is one, just fire up that
  549.    possibility by calling its handler function, passing the first two
  550.    tokens through it and so on.
  551.  
  552.    Otherwise, start up a process whereby tokens are passed to the first
  553.    possibility on the list until EOS or SEMICOLON is reached or an error
  554.    is detected.     But inhibit any actual reporting of errors; just record
  555.    their existence in the list.     If EOS or SEMICOLON is reached with no
  556.    errors (other than non-form errors happening downstream, such as an
  557.    overflowing value for an integer or a GOTO statement identifying a label
  558.    on a FORMAT statement), then that is the only possible statement.  Rerun
  559.    the statement with error-reporting turned on if any non-form errors were
  560.    generated, otherwise just use its results, then erase the list of tokens
  561.    memorized during the search process.     If a form error occurs, immediately
  562.    cancel that possibility by sending EOS as the next token, remember the
  563.    error code for that possibility, and try the next possibility on the list,
  564.    first sending it the list of tokens memorized while handling the first
  565.    possibility, then continuing on as before.
  566.  
  567.    Ultimately, either the end of the list of possibilities will be reached
  568.    without any successful forms being detected, in which case we pick one
  569.    based on hueristics (usually the first possibility) and rerun it with
  570.    error reporting turned on using the list of memorized tokens so the user
  571.    sees the error, or one of the possibilities will effectively succeed.  */
  572.  
  573. static ffelexHandler
  574. ffesta_second_ (ffelexToken t)
  575. {
  576.   ffelexHandler next;
  577.   bool include_only = FALSE;    /* Initially valid INCLUDE form when TRUE. */
  578.   ffesymbol s;
  579.  
  580.   assert (ffelex_token_type (t) != FFELEX_typeNAMES);
  581.  
  582.   if (ffelex_token_type (t) == FFELEX_typeNAME)
  583.     ffesta_second_kw = ffestr_second (t);
  584.  
  585.   /* Here we use switch on the first keyword name and handle each possible
  586.      recognizable name by looking at the second token, and building the list
  587.      of possible names accordingly.  For now, just put every possible
  588.      statement on the list for ambiguity checking. */
  589.  
  590.   switch (ffesta_first_kw)
  591.     {
  592. #if FFESTR_F90
  593.     case FFESTR_firstALLOCATABLE:
  594.       ffestb_args.dimlist.len = FFESTR_firstlALLOCATABLE;
  595.       ffestb_args.dimlist.badname = "ALLOCATABLE";
  596.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dimlist);
  597.       break;
  598. #endif
  599.  
  600. #if FFESTR_F90
  601.     case FFESTR_firstALLOCATE:
  602.       ffestb_args.heap.len = FFESTR_firstlALLOCATE;
  603.       ffestb_args.heap.badname = "ALLOCATE";
  604.       ffestb_args.heap.ctx = FFEEXPR_contextALLOCATE;
  605.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_heap);
  606.       break;
  607. #endif
  608.  
  609.     case FFESTR_firstBACKSPACE:
  610.       ffestb_args.beru.len = FFESTR_firstlBACKSPACE;
  611.       ffestb_args.beru.badname = "BACKSPACE";
  612.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_beru);
  613.       break;
  614.  
  615.     case FFESTR_firstCMPLX:
  616.       ffestb_args.decl.len = FFESTR_firstlCMPLX;
  617.       ffestb_args.decl.type = FFESTP_typeCOMPLEX;
  618.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_gentype);
  619.       break;
  620.  
  621. #if FFESTR_F90
  622.     case FFESTR_firstDEALLOCATE:
  623.       ffestb_args.heap.len = FFESTR_firstlDEALLOCATE;
  624.       ffestb_args.heap.badname = "DEALLOCATE";
  625.       ffestb_args.heap.ctx = FFEEXPR_contextDEALLOCATE;
  626.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_heap);
  627.       break;
  628. #endif
  629.  
  630. #if FFESTR_VXT
  631.     case FFESTR_firstDECODE:
  632.       ffestb_args.vxtcode.len = FFESTR_firstlDECODE;
  633.       ffestb_args.vxtcode.badname = "DECODE";
  634.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_vxtcode);
  635.       break;
  636. #endif
  637.  
  638.     case FFESTR_firstDIMENSION:
  639.       ffestb_args.R524.len = FFESTR_firstlDIMENSION;
  640.       ffestb_args.R524.badname = "DIMENSION";
  641.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R524);
  642.       break;
  643.  
  644.     case FFESTR_firstDBLCMPLX:
  645.       ffestb_args.decl.len = FFESTR_firstlDBLCMPLX;
  646.       ffestb_args.decl.type = FFESTP_typeDBLCMPLX;
  647.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_dbltype);
  648.       break;
  649.  
  650.     case FFESTR_firstDBLPRCSN:
  651.       ffestb_args.decl.len = FFESTR_firstlDBLPRCSN;
  652.       ffestb_args.decl.type = FFESTP_typeDBLPRCSN;
  653.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_dbltype);
  654.       break;
  655.  
  656.     case FFESTR_firstELSEIF:
  657.       ffestb_args.elsexyz.second = FFESTR_secondIF;
  658.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_elsexyz);
  659.       break;
  660.  
  661. #if FFESTR_F90
  662.     case FFESTR_firstELSEWHERE:
  663.       ffestb_args.elsexyz.second = FFESTR_secondWHERE;
  664.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_elsexyz);
  665.       break;
  666. #endif
  667.  
  668. #if FFESTR_VXT
  669.     case FFESTR_firstENCODE:
  670.       ffestb_args.vxtcode.len = FFESTR_firstlENCODE;
  671.       ffestb_args.vxtcode.badname = "ENCODE";
  672.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_vxtcode);
  673.       break;
  674. #endif
  675.  
  676.     case FFESTR_firstEND:
  677.       if ((ffelex_token_type (ffesta_token_0_) == FFELEX_typeNAMES)
  678.       || (ffelex_token_type (t) != FFELEX_typeNAME))
  679.     ffesta_add_possible_exec_ ((ffelexHandler) ffestb_end);
  680.       else
  681.     {
  682.       switch (ffesta_second_kw)
  683.         {
  684.         case FFESTR_secondBLOCK:
  685.         case FFESTR_secondBLOCKDATA:
  686.         case FFESTR_secondDO:
  687.         case FFESTR_secondFILE:
  688.         case FFESTR_secondFUNCTION:
  689.         case FFESTR_secondIF:
  690. #if FFESTR_F90
  691.         case FFESTR_secondMODULE:
  692. #endif
  693.         case FFESTR_secondPROGRAM:
  694.         case FFESTR_secondSELECT:
  695.         case FFESTR_secondSUBROUTINE:
  696. #if FFESTR_F90
  697.         case FFESTR_secondWHERE:
  698. #endif
  699.           ffesta_add_possible_exec_ ((ffelexHandler) ffestb_end);
  700.           break;
  701.  
  702.         default:
  703.           ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_end);
  704.           break;
  705.         }
  706.     }
  707.       break;
  708.  
  709.     case FFESTR_firstENDBLOCK:
  710.       ffestb_args.endxyz.len = FFESTR_firstlENDBLOCK;
  711.       ffestb_args.endxyz.second = FFESTR_secondBLOCK;
  712.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
  713.       break;
  714.  
  715.     case FFESTR_firstENDBLOCKDATA:
  716.       ffestb_args.endxyz.len = FFESTR_firstlENDBLOCKDATA;
  717.       ffestb_args.endxyz.second = FFESTR_secondBLOCKDATA;
  718.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
  719.       break;
  720.  
  721.     case FFESTR_firstENDDO:
  722.       ffestb_args.endxyz.len = FFESTR_firstlENDDO;
  723.       ffestb_args.endxyz.second = FFESTR_secondDO;
  724.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
  725.       break;
  726.  
  727.     case FFESTR_firstENDFILE:
  728.       ffestb_args.beru.len = FFESTR_firstlENDFILE;
  729.       ffestb_args.beru.badname = "ENDFILE";
  730.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_beru);
  731.       break;
  732.  
  733.     case FFESTR_firstENDFUNCTION:
  734.       ffestb_args.endxyz.len = FFESTR_firstlENDFUNCTION;
  735.       ffestb_args.endxyz.second = FFESTR_secondFUNCTION;
  736.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
  737.       break;
  738.  
  739.     case FFESTR_firstENDIF:
  740.       ffestb_args.endxyz.len = FFESTR_firstlENDIF;
  741.       ffestb_args.endxyz.second = FFESTR_secondIF;
  742.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
  743.       break;
  744.  
  745. #if FFESTR_F90
  746.     case FFESTR_firstENDINTERFACE:
  747.       ffestb_args.endxyz.len = FFESTR_firstlENDINTERFACE;
  748.       ffestb_args.endxyz.second = FFESTR_secondINTERFACE;
  749.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_endxyz);
  750.       break;
  751. #endif
  752.  
  753. #if FFESTR_VXT
  754.     case FFESTR_firstENDMAP:
  755.       ffestb_args.endxyz.len = FFESTR_firstlENDMAP;
  756.       ffestb_args.endxyz.second = FFESTR_secondMAP;
  757.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_endxyz);
  758.       break;
  759. #endif
  760.  
  761. #if FFESTR_F90
  762.     case FFESTR_firstENDMODULE:
  763.       ffestb_args.endxyz.len = FFESTR_firstlENDMODULE;
  764.       ffestb_args.endxyz.second = FFESTR_secondMODULE;
  765.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
  766.       break;
  767. #endif
  768.  
  769.     case FFESTR_firstENDPROGRAM:
  770.       ffestb_args.endxyz.len = FFESTR_firstlENDPROGRAM;
  771.       ffestb_args.endxyz.second = FFESTR_secondPROGRAM;
  772.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
  773.       break;
  774.  
  775.     case FFESTR_firstENDSELECT:
  776.       ffestb_args.endxyz.len = FFESTR_firstlENDSELECT;
  777.       ffestb_args.endxyz.second = FFESTR_secondSELECT;
  778.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
  779.       break;
  780.  
  781. #if FFESTR_VXT
  782.     case FFESTR_firstENDSTRUCTURE:
  783.       ffestb_args.endxyz.len = FFESTR_firstlENDSTRUCTURE;
  784.       ffestb_args.endxyz.second = FFESTR_secondSTRUCTURE;
  785.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_endxyz);
  786.       break;
  787. #endif
  788.  
  789.     case FFESTR_firstENDSUBROUTINE:
  790.       ffestb_args.endxyz.len = FFESTR_firstlENDSUBROUTINE;
  791.       ffestb_args.endxyz.second = FFESTR_secondSUBROUTINE;
  792.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
  793.       break;
  794.  
  795. #if FFESTR_F90
  796.     case FFESTR_firstENDTYPE:
  797.       ffestb_args.endxyz.len = FFESTR_firstlENDTYPE;
  798.       ffestb_args.endxyz.second = FFESTR_secondTYPE;
  799.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_endxyz);
  800.       break;
  801. #endif
  802.  
  803. #if FFESTR_VXT
  804.     case FFESTR_firstENDUNION:
  805.       ffestb_args.endxyz.len = FFESTR_firstlENDUNION;
  806.       ffestb_args.endxyz.second = FFESTR_secondUNION;
  807.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_endxyz);
  808.       break;
  809. #endif
  810.  
  811. #if FFESTR_F90
  812.     case FFESTR_firstENDWHERE:
  813.       ffestb_args.endxyz.len = FFESTR_firstlENDWHERE;
  814.       ffestb_args.endxyz.second = FFESTR_secondWHERE;
  815.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_endxyz);
  816.       break;
  817. #endif
  818.  
  819.     case FFESTR_firstENTRY:
  820.       ffestb_args.dummy.len = FFESTR_firstlENTRY;
  821.       ffestb_args.dummy.badname = "ENTRY";
  822.       ffestb_args.dummy.is_subr = ffestc_is_entry_in_subr ();
  823.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dummy);
  824.       break;
  825.  
  826.     case FFESTR_firstEXTERNAL:
  827.       ffestb_args.varlist.len = FFESTR_firstlEXTERNAL;
  828.       ffestb_args.varlist.badname = "EXTERNAL";
  829.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
  830.       break;
  831.  
  832.       /* WARNING: don't put anything that might cause an item to precede
  833.          FORMAT in the list of possible statements (it's added below) without
  834.          making sure FORMAT still is first.  It has to run with
  835.          ffelex_set_names_pure(TRUE), to make sure the lexer delivers NAMES
  836.          tokens. */
  837.  
  838.     case FFESTR_firstFORMAT:
  839.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R1001);
  840.       break;
  841.  
  842.     case FFESTR_firstFUNCTION:
  843.       ffestb_args.dummy.len = FFESTR_firstlFUNCTION;
  844.       ffestb_args.dummy.badname = "FUNCTION";
  845.       ffestb_args.dummy.is_subr = FALSE;
  846.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dummy);
  847.       break;
  848.  
  849.     case FFESTR_firstINCLUDE:
  850.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_S3P4);
  851.       switch (ffelex_token_type (t))
  852.     {
  853.     case FFELEX_typeNUMBER:
  854.     case FFELEX_typeNAME:
  855.     case FFELEX_typeAPOSTROPHE:
  856.     case FFELEX_typeQUOTE:
  857.       include_only = TRUE;
  858.       break;
  859.  
  860.     default:
  861.       break;
  862.     }
  863.       break;
  864.  
  865.     case FFESTR_firstINTGR:
  866.       ffestb_args.decl.len = FFESTR_firstlINTGR;
  867.       ffestb_args.decl.type = FFESTP_typeINTEGER;
  868.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_gentype);
  869.       break;
  870.  
  871. #if FFESTR_F90
  872.     case FFESTR_firstINTENT:
  873.       ffestb_args.varlist.len = FFESTR_firstlINTENT;
  874.       ffestb_args.varlist.badname = "INTENT";
  875.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
  876.       break;
  877. #endif
  878.  
  879.     case FFESTR_firstINTRINSIC:
  880.       ffestb_args.varlist.len = FFESTR_firstlINTRINSIC;
  881.       ffestb_args.varlist.badname = "INTRINSIC";
  882.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
  883.       break;
  884.  
  885.     case FFESTR_firstLGCL:
  886.       ffestb_args.decl.len = FFESTR_firstlLGCL;
  887.       ffestb_args.decl.type = FFESTP_typeLOGICAL;
  888.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_gentype);
  889.       break;
  890.  
  891. #if FFESTR_F90
  892.     case FFESTR_firstOPTIONAL:
  893.       ffestb_args.varlist.len = FFESTR_firstlOPTIONAL;
  894.       ffestb_args.varlist.badname = "OPTIONAL";
  895.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
  896.       break;
  897. #endif
  898.  
  899.     case FFESTR_firstPAUSE:
  900.       ffestb_args.halt.len = FFESTR_firstlPAUSE;
  901.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_halt);
  902.       break;
  903.  
  904. #if FFESTR_F90
  905.     case FFESTR_firstPOINTER:
  906.       ffestb_args.dimlist.len = FFESTR_firstlPOINTER;
  907.       ffestb_args.dimlist.badname = "POINTER";
  908.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dimlist);
  909.       break;
  910. #endif
  911.  
  912. #if HARD_F90
  913.     case FFESTR_firstPRIVATE:
  914.       ffestb_args.varlist.len = FFESTR_firstlPRIVATE;
  915.       ffestb_args.varlist.badname = "ACCESS";
  916.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
  917.       break;
  918.  
  919.     case FFESTR_firstPUBLIC:
  920.       ffestb_args.varlist.len = FFESTR_firstlPUBLIC;
  921.       ffestb_args.varlist.badname = "ACCESS";
  922.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_varlist);
  923.       break;
  924. #endif
  925.  
  926.     case FFESTR_firstREAL:
  927.       ffestb_args.decl.len = FFESTR_firstlREAL;
  928.       ffestb_args.decl.type = FFESTP_typeREAL;
  929.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_gentype);
  930.       break;
  931.  
  932.     case FFESTR_firstREWIND:
  933.       ffestb_args.beru.len = FFESTR_firstlREWIND;
  934.       ffestb_args.beru.badname = "REWIND";
  935.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_beru);
  936.       break;
  937.  
  938.     case FFESTR_firstSTOP:
  939.       ffestb_args.halt.len = FFESTR_firstlSTOP;
  940.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_halt);
  941.       break;
  942.  
  943.     case FFESTR_firstSUBROUTINE:
  944.       ffestb_args.dummy.len = FFESTR_firstlSUBROUTINE;
  945.       ffestb_args.dummy.badname = "SUBROUTINE";
  946.       ffestb_args.dummy.is_subr = TRUE;
  947.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dummy);
  948.       break;
  949.  
  950. #if FFESTR_F90
  951.     case FFESTR_firstTARGET:
  952.       ffestb_args.dimlist.len = FFESTR_firstlTARGET;
  953.       ffestb_args.dimlist.badname = "TARGET";
  954.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_dimlist);
  955.       break;
  956. #endif
  957.  
  958. #if FFESTR_VXT
  959.     case FFESTR_firstUNLOCK:
  960.       ffestb_args.beru.len = FFESTR_firstlUNLOCK;
  961.       ffestb_args.beru.badname = "UNLOCK";
  962.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_beru);
  963.       break;
  964. #endif
  965.  
  966.     case FFESTR_firstVIRTUAL:
  967.       ffestb_args.R524.len = FFESTR_firstlVIRTUAL;
  968.       ffestb_args.R524.badname = "VIRTUAL";
  969.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R524);
  970.       break;
  971.  
  972.     default:
  973.  
  974.       /* For now, a decent error message for an unconfirmed stmt, rather than
  975.          just whatever is at the top of the list. */
  976.  
  977.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_unimplemented);
  978.       break;
  979.     }
  980.  
  981.   if (!include_only)
  982.     {
  983.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_block);    /* BLOCK. */
  984.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_blockdata);    /* BLOCKDATA. */
  985.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_chartype);    /* CHARACTER. */
  986.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_do);    /* DO. */
  987.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_double);    /* DOUBLE. */
  988.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_dowhile);    /* DOWHILE. */
  989.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_else);    /* ELSE. */
  990.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_goto);    /* GOTO. */
  991.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_if);    /* IF. */
  992. #if FFESTR_F90
  993.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_module);    /* MODULE. */
  994. #endif
  995. #if FFESTR_F90
  996.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_recursive);    /* RECURSIVE. */
  997. #endif
  998. #if FFESTR_F90
  999.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_type);    /* TYPE. */
  1000. #endif
  1001. #if HARD_F90
  1002.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_typetype);    /* TYPE(). */
  1003.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_where);    /* WHERE. */
  1004.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R423B);    /* SEQUENCE. */
  1005. #endif
  1006.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R522);    /* SAVE. */
  1007.       if (ffe_is_pedantic_not_90 ())
  1008.     ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R528);    /* DATA. */
  1009.       else
  1010.     ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R528);    /* DATA. */
  1011.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R537);    /* PARAMETER. */
  1012.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_decl_R539);    /* IMPLICIT. */
  1013.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R542);    /* NAMELIST. */
  1014.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R544);    /* EQUIVALENCE. */
  1015.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R547);    /* COMMON. */
  1016. #if FFESTR_F90
  1017.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R624);    /* NULLIFY. */
  1018. #endif
  1019.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R809);    /* SELECTCASE. */
  1020.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R810);    /* CASE. */
  1021.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R834);    /* CYCLE. */
  1022.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R835);    /* EXIT. */
  1023.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R838);    /* ASSIGN. */
  1024.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R840);    /* Arithmetic IF. */
  1025.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R841);    /* CONTINUE. */
  1026.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R904);    /* OPEN. */
  1027.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R907);    /* CLOSE. */
  1028.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R909);    /* READ. */
  1029.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R910);    /* WRITE. */
  1030.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R911);    /* PRINT. */
  1031.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R923);    /* INQUIRE. */
  1032.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R1102);    /* PROGRAM. */
  1033. #if FFESTR_F90
  1034.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R1107);    /* USE. */
  1035. #endif
  1036. #if FFESTR_F90
  1037.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R1202);    /* INTERFACE. */
  1038. #endif
  1039.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R1212);    /* CALL. */
  1040.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R1227);    /* RETURN. */
  1041. #if FFESTR_F90
  1042.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_R1228);    /* CONTAINS. */
  1043. #endif
  1044. #if FFESTR_VXT
  1045.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V003);    /* STRUCTURE. */
  1046. #endif
  1047. #if FFESTR_VXT
  1048.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V009);    /* UNION. */
  1049. #endif
  1050. #if FFESTR_VXT
  1051.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V012);    /* MAP. */
  1052. #endif
  1053.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V014);    /* VOLATILE. */
  1054. #if FFESTR_VXT
  1055.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V016);    /* RECORD. */
  1056.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V018);    /* REWRITE. */
  1057.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V019);    /* ACCEPT. */
  1058. #endif
  1059.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V020);    /* TYPE. */
  1060. #if FFESTR_VXT
  1061.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V021);    /* DELETE. */
  1062.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V025);    /* DEFINEFILE. */
  1063.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_V026);    /* FIND. */
  1064. #endif
  1065.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_V027);    /* VXT PARAMETER. */
  1066.     }
  1067.   else
  1068.     include_only = FALSE;
  1069.  
  1070.   /* Now check the default cases, which are always "live" (meaning that no
  1071.      other possibility can override them).  These are where the second token
  1072.      is OPEN_PAREN, PERCENT, EQUALS, POINTS, or COLON. */
  1073.  
  1074.   switch (ffelex_token_type (t))
  1075.     {
  1076.     case FFELEX_typeOPEN_PAREN:
  1077.       s = ffesymbol_lookup_local (ffesta_token_0_);
  1078.       if (((s == NULL) || (ffesymbol_dims (s) == NULL))
  1079.       && !ffesta_seen_first_exec)
  1080.     {            /* Not known as array; may be stmt function. */
  1081.       ffesta_add_possible_nonexec_ ((ffelexHandler) ffestb_R1229);
  1082.  
  1083.       /* If the symbol is (or will be due to implicit typing) of
  1084.          CHARACTER type, then the statement might be an assignment
  1085.          statement.     If so, since it can't be a function invocation nor
  1086.          an array element reference, the open paren following the symbol
  1087.          name must be followed by an expression and a colon.  Without the
  1088.          colon (which cannot appear in a stmt function definition), the
  1089.          let stmt rejects.    So CHARACTER_NAME(...)=expr, unlike any other
  1090.          type, is not ambiguous alone. */
  1091.  
  1092.       if (ffeimplic_peek_symbol_type (s,
  1093.                     ffelex_token_text (ffesta_token_0_))
  1094.           == FFEINFO_basictypeCHARACTER)
  1095.         ffesta_add_possible_exec_ ((ffelexHandler) ffestb_let);
  1096.     }
  1097.       else            /* Not statement function if known as an
  1098.                    array. */
  1099.     ffesta_add_possible_exec_ ((ffelexHandler) ffestb_let);
  1100.       break;
  1101.  
  1102. #if FFESTR_F90
  1103.     case FFELEX_typePERCENT:
  1104. #endif
  1105.     case FFELEX_typeEQUALS:
  1106. #if FFESTR_F90
  1107.     case FFELEX_typePOINTS:
  1108. #endif
  1109.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_let);
  1110.       break;
  1111.  
  1112.     case FFELEX_typeCOLON:
  1113.       ffesta_add_possible_exec_ ((ffelexHandler) ffestb_construct);
  1114.       break;
  1115.  
  1116.     default:
  1117.       ;
  1118.     }
  1119.  
  1120.   /* Now see how many possibilities are on the list. */
  1121.  
  1122.   switch (ffesta_num_possibles_)
  1123.     {
  1124.     case 0:            /* None, so invalid statement. */
  1125.     no_stmts:            /* :::::::::::::::::::: */
  1126.       ffesta_tokens[0] = ffesta_token_0_;
  1127.       ffesta_ffebad_2t (FFEBAD_UNREC_STMT, ffesta_token_0_, t);
  1128.       next = (ffelexHandler) ffelex_swallow_tokens (NULL,
  1129.                            (ffelexHandler) ffesta_zero);
  1130.       break;
  1131.  
  1132.     case 1:            /* One, so just do it! */
  1133.       ffesta_tokens[0] = ffesta_token_0_;
  1134.       next = ffesta_possible_execs_.first->handler;
  1135.       if (next == NULL)
  1136.     {            /* Have a nonexec stmt. */
  1137.       next = ffesta_possible_nonexecs_.first->handler;
  1138.       assert (next != NULL);
  1139.     }
  1140.       else if (ffesta_seen_first_exec)
  1141.     ;            /* Have an exec stmt after exec transition. */
  1142.       else if (ffestc_exec_transition ())
  1143.     {            /* Have an exec stmt before the exec
  1144.                    transition AND our statement state allows
  1145.                    such a transition at this point, in which
  1146.                    case f_e_t_ updates that state and returns
  1147.                    TRUE. */
  1148.       ffesta_seen_first_exec = TRUE;
  1149.       ffestd_exec_begin ();
  1150.     }
  1151.       else            /* Can't do exec stmt yet. */
  1152.     goto no_stmts;        /* :::::::::::::::::::: */
  1153.       /* 1 exec stmt only, but not valid in context, so pretend as though
  1154.          statement is unrecognized. */
  1155.       break;
  1156.  
  1157.     default:            /* More than one, so try them in order. */
  1158.       ffesta_confirmed_possible_ = NULL;
  1159.       ffesta_current_possible_ = ffesta_possible_nonexecs_.first;
  1160.       ffesta_current_handler_ = ffesta_current_possible_->handler;
  1161.       if (ffesta_current_handler_ == NULL)
  1162.     {
  1163.       ffesta_current_possible_ = ffesta_possible_execs_.first;
  1164.       ffesta_current_handler_ = ffesta_current_possible_->handler;
  1165.       assert (ffesta_current_handler_ != NULL);
  1166.       if (!ffesta_seen_first_exec)
  1167.         {            /* Need to do exec transition now. */
  1168.           if (ffestc_exec_transition ())
  1169.         {        /* Have an exec stmt before the exec
  1170.                    transition AND our statement state allows
  1171.                    such a transition at this point, in which
  1172.                    case f_e_t_ updates that state and returns
  1173.                    TRUE. */
  1174.           ffesta_seen_first_exec = TRUE;
  1175.           ffestd_exec_begin ();
  1176.         }
  1177.           else
  1178.         goto no_stmts;    /* :::::::::::::::::::: */
  1179.         }
  1180.     }
  1181.       ffesta_tokens[0] = ffelex_token_use (ffesta_token_0_);
  1182.       next = (ffelexHandler) ffesta_save_;
  1183.       ffebad_set_inhibit (TRUE);
  1184.       ffesta_is_inhibited_ = TRUE;
  1185.       break;
  1186.     }
  1187.  
  1188.   ffesta_output_pool
  1189.     = malloc_pool_new ("Statement Output", ffe_pool_program_unit (), 1024);
  1190.   ffesta_scratch_pool
  1191.     = malloc_pool_new ("Statement Scratch", ffe_pool_program_unit (), 1024);
  1192.   ffesta_outpooldisp_ = FFESTA_pooldispDISCARD;
  1193.  
  1194.   if (ffesta_is_inhibited_)
  1195.     ffesymbol_set_retractable (ffesta_scratch_pool);
  1196.  
  1197.   ffelex_set_names (FALSE);    /* Most handlers will want this.  If not,
  1198.                    they have to set it TRUE again (its value
  1199.                    at the beginning of a statement). */
  1200.  
  1201.   return (ffelexHandler) (*next) (t);
  1202. }
  1203.  
  1204. /* ffesta_send_two_ -- Send the two tokens saved by ffesta_two after all
  1205.  
  1206.    return ffesta_send_two_;  // to lexer.
  1207.  
  1208.    Currently, if this function gets called, it means that the two tokens
  1209.    saved by ffesta_two did not have their handlers derailed by
  1210.    ffesta_save_, which probably means they weren't sent by ffesta_save_
  1211.    but directly by the lexer, which probably means the original statement
  1212.    (which should be IF (expr) or WHERE (expr)) somehow evaluated to only
  1213.    one possibility in ffesta_second_ or somebody optimized FFEST to
  1214.    immediately revert to one possibility upon confirmation but forgot to
  1215.    change this function (and thus perhaps the entire resubmission
  1216.    mechanism).    */
  1217.  
  1218. #if !FFESTA_ABORT_ON_CONFIRM_
  1219. static ffelexHandler
  1220. ffesta_send_two_ (ffelexToken t)
  1221. {
  1222.   assert ("what am I doing here?" == NULL);
  1223.   return NULL;
  1224. }
  1225.  
  1226. #endif
  1227. /* ffesta_confirmed -- Confirm current possibility as only one
  1228.  
  1229.    ffesta_confirmed();
  1230.  
  1231.    Sets the confirmation flag.    During debugging for ambiguous constructs,
  1232.    asserts that the confirmation flag for a previous possibility has not
  1233.    yet been set.  */
  1234.  
  1235. void
  1236. ffesta_confirmed ()
  1237. {
  1238.   if (ffesta_inhibit_confirmation_)
  1239.     return;
  1240.   ffesta_confirmed_current_ = TRUE;
  1241.   assert (!ffesta_confirmed_other_
  1242.       || (ffesta_confirmed_possible_ == ffesta_current_possible_));
  1243.   ffesta_confirmed_possible_ = ffesta_current_possible_;
  1244. }
  1245.  
  1246. /* ffesta_eof -- End of (non-INCLUDEd) source file
  1247.  
  1248.    ffesta_eof();
  1249.  
  1250.    Call after piping tokens through ffest_first, where the most recent
  1251.    token sent through must be EOS.
  1252.  
  1253.    20-Feb-91  JCB  1.1
  1254.       Put new EOF token in ffesta_tokens[0], not NULL, because too much
  1255.       code expects something there for error reporting and the like.  Also,
  1256.       do basically the same things ffest_second and ffesta_zero do for
  1257.       processing a statement (make and destroy pools, et cetera).  */
  1258.  
  1259. void
  1260. ffesta_eof ()
  1261. {
  1262.   ffesta_tokens[0] = ffelex_token_new_eof ();
  1263.  
  1264.   ffesta_output_pool
  1265.     = malloc_pool_new ("Statement Output", ffe_pool_program_unit (), 1024);
  1266.   ffesta_scratch_pool
  1267.     = malloc_pool_new ("Statement Scratch", ffe_pool_program_unit (), 1024);
  1268.   ffesta_outpooldisp_ = FFESTA_pooldispDISCARD;
  1269.  
  1270.   ffestc_eof ();
  1271.  
  1272.   if (ffesta_tokens[0] != NULL)
  1273.     ffelex_token_kill (ffesta_tokens[0]);
  1274.  
  1275.   if (ffesta_output_pool != NULL)
  1276.     {
  1277.       if (ffesta_outpooldisp_ == FFESTA_pooldispDISCARD)
  1278.     malloc_pool_kill (ffesta_output_pool);
  1279.       ffesta_output_pool = NULL;
  1280.     }
  1281.  
  1282.   if (ffesta_scratch_pool != NULL)
  1283.     {
  1284.       malloc_pool_kill (ffesta_scratch_pool);
  1285.       ffesta_scratch_pool = NULL;
  1286.     }
  1287.  
  1288.   if (ffesta_label_token != NULL)
  1289.     {
  1290.       ffelex_token_kill (ffesta_label_token);
  1291.       ffesta_label_token = NULL;
  1292.     }
  1293.  
  1294.   if (ffe_is_ffedebug ())
  1295.     {
  1296.       ffestorag_report ();
  1297.       ffesymbol_report_all ();
  1298.     }
  1299. }
  1300.  
  1301. /* ffesta_ffebad_here_current_stmt -- ffebad_here with ptr to current stmt
  1302.  
  1303.    ffesta_ffebad_here_current_stmt(0);
  1304.  
  1305.    Outsiders can call this fn if they have no more convenient place to
  1306.    point to (via a token or pair of ffewhere objects) and they know a
  1307.    current, useful statement is being evaluted by ffest (i.e. they are
  1308.    being called from ffestb, ffestc, ffestd, ... functions).  */
  1309.  
  1310. void
  1311. ffesta_ffebad_here_current_stmt (ffebadIndex i)
  1312. {
  1313.   assert (ffesta_tokens[0] != NULL);
  1314.   ffebad_here (i, ffelex_token_where_line (ffesta_tokens[0]),
  1315.            ffelex_token_where_column (ffesta_tokens[0]));
  1316. }
  1317.  
  1318. /* ffesta_ffebad_start -- Start a possibly inhibited error report
  1319.  
  1320.    if (ffesta_ffebad_start(FFEBAD_SOME_ERROR))
  1321.        {
  1322.        ffebad_here, ffebad_string ...;
  1323.        ffebad_finish();
  1324.        }
  1325.  
  1326.    Call if the error might indicate that ffest is evaluating the wrong
  1327.    statement form, instead of calling ffebad_start directly.  If ffest
  1328.    is choosing between forms, it will return FALSE, send an EOS/SEMICOLON
  1329.    token through as the next token (if the current one isn't already one
  1330.    of those), and try another possible form.  Otherwise, ffebad_start is
  1331.    called with the argument and TRUE returned.    */
  1332.  
  1333. bool
  1334. ffesta_ffebad_start (ffebad errnum)
  1335. {
  1336.   if (!ffesta_is_inhibited_)
  1337.     {
  1338.       ffebad_start (errnum);
  1339.       return TRUE;
  1340.     }
  1341.  
  1342.   if (!ffesta_confirmed_current_)
  1343.     ffesta_current_shutdown_ = TRUE;
  1344.  
  1345.   return FALSE;
  1346. }
  1347.  
  1348. /* ffesta_first -- Parse the first token in a statement
  1349.  
  1350.    return ffesta_first;     // to lexer.  */
  1351.  
  1352. ffelexHandler
  1353. ffesta_first (ffelexToken t)
  1354. {
  1355.   switch (ffelex_token_type (t))
  1356.     {
  1357.     case FFELEX_typeSEMICOLON:
  1358.     case FFELEX_typeEOS:
  1359.       ffesta_tokens[0] = ffelex_token_use (t);
  1360.       if (ffesta_label_token != NULL)
  1361.     {
  1362.       ffebad_start (FFEBAD_LABEL_WITHOUT_STMT);
  1363.       ffebad_here (0, ffelex_token_where_line (ffesta_label_token),
  1364.                ffelex_token_where_column (ffesta_label_token));
  1365.       ffebad_string (ffelex_token_text (ffesta_label_token));
  1366.       ffebad_here (1, ffelex_token_where_line (t), ffelex_token_where_column (t));
  1367.       ffebad_finish ();
  1368.     }
  1369.       return (ffelexHandler) ffesta_zero (t);
  1370.  
  1371.     case FFELEX_typeNAME:
  1372.     case FFELEX_typeNAMES:
  1373.       ffesta_token_0_ = ffelex_token_use (t);
  1374.       ffesta_first_kw = ffestr_first (t);
  1375.       return (ffelexHandler) ffesta_second_;
  1376.  
  1377.     case FFELEX_typeNUMBER:
  1378.       if (ffesta_line_has_semicolons
  1379.       && !ffe_is_free_form ()
  1380.       && ffe_is_pedantic ())
  1381.     {
  1382.       ffebad_start (FFEBAD_LABEL_WRONG_PLACE);
  1383.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  1384.       ffebad_string (ffelex_token_text (t));
  1385.       ffebad_finish ();
  1386.     }
  1387.       if (ffesta_label_token == NULL)
  1388.     {
  1389.       ffesta_label_token = ffelex_token_use (t);
  1390.       return (ffelexHandler) ffesta_first;
  1391.     }
  1392.       else
  1393.     {
  1394.       ffebad_start (FFEBAD_EXTRA_LABEL_DEF);
  1395.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  1396.       ffebad_string (ffelex_token_text (t));
  1397.       ffebad_here (1, ffelex_token_where_line (ffesta_label_token),
  1398.                ffelex_token_where_column (ffesta_label_token));
  1399.       ffebad_string (ffelex_token_text (ffesta_label_token));
  1400.       ffebad_finish ();
  1401.  
  1402.       return (ffelexHandler) ffesta_first;
  1403.     }
  1404.  
  1405.     default:            /* Invalid first token. */
  1406.       ffesta_tokens[0] = ffelex_token_use (t);
  1407.       ffebad_start (FFEBAD_STMT_BEGINS_BAD);
  1408.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  1409.       ffebad_finish ();
  1410.       return (ffelexHandler) ffelex_swallow_tokens (t,
  1411.                            (ffelexHandler) ffesta_zero);
  1412.     }
  1413. }
  1414.  
  1415. /* ffesta_init_0 -- Initialize for entire image invocation
  1416.  
  1417.    ffesta_init_0();
  1418.  
  1419.    Call just once per invocation of the compiler (not once per invocation
  1420.    of the front end).
  1421.  
  1422.    Gets memory for the list of possibles once and for all, since this
  1423.    list never gets larger than a certain size (FFESTA_maxPOSSIBLES_)
  1424.    and is not particularly large.  Initializes the array of pointers to
  1425.    this list.  Initializes the executable and nonexecutable lists.  */
  1426.  
  1427. void
  1428. ffesta_init_0 ()
  1429. {
  1430.   ffestaPossible_ ptr;
  1431.   int i;
  1432.  
  1433.   ptr = (ffestaPossible_) malloc_new_kp (malloc_pool_image (),
  1434.                      "FFEST possibles",
  1435.                      FFESTA_maxPOSSIBLES_
  1436.                      * sizeof (*ptr));
  1437.  
  1438.   for (i = 0; i < FFESTA_maxPOSSIBLES_; ++i)
  1439.     ffesta_possibles_[i] = ptr++;
  1440.  
  1441.   ffesta_possible_execs_.first = ffesta_possible_execs_.last
  1442.     = (ffestaPossible_) &ffesta_possible_execs_.first;
  1443.   ffesta_possible_nonexecs_.first = ffesta_possible_nonexecs_.last
  1444.     = (ffestaPossible_) &ffesta_possible_nonexecs_.first;
  1445.   ffesta_possible_execs_.nil = ffesta_possible_nonexecs_.nil = NULL;
  1446. }
  1447.  
  1448. /* ffesta_init_3 -- Initialize for any program unit
  1449.  
  1450.    ffesta_init_3();  */
  1451.  
  1452. void
  1453. ffesta_init_3 ()
  1454. {
  1455.   ffesta_output_pool = NULL;    /* May be doing this just before reaching */
  1456.   ffesta_scratch_pool = NULL;    /* ffesta_zero or ffesta_two. */
  1457.   /* NOTE: we let the ffe_terminate_2 action of killing the program_unit pool
  1458.      handle the killing of the output and scratch pools for us, which is why
  1459.      we don't have a terminate_3 action to do so. */
  1460.   ffesta_construct_name = NULL;
  1461.   ffesta_label_token = NULL;
  1462.   ffesta_seen_first_exec = FALSE;
  1463. }
  1464.  
  1465. /* ffesta_is_inhibited -- Test whether the current possibility is inhibited
  1466.  
  1467.    if (!ffesta_is_inhibited())
  1468.        // implement the statement.
  1469.  
  1470.    Just make sure the current possibility has been confirmed.  If anyone
  1471.    really needs to test whether the current possibility is inhibited prior
  1472.    to confirming it, that indicates a need to begin statement processing
  1473.    before it is certain that the given possibility is indeed the statement
  1474.    to be processed.  As of this writing, there does not appear to be such
  1475.    a need.  If there is, then when confirming a statement would normally
  1476.    immediately disable the inhibition (whereas currently we leave the
  1477.    confirmed statement disabled until we've tried the other possibilities,
  1478.    to check for ambiguities), we must check to see if the possibility has
  1479.    already tested for inhibition prior to confirmation and, if so, maintain
  1480.    inhibition until the end of the statement (which may be forced right
  1481.    away) and then rerun the entire statement from the beginning.  Otherwise,
  1482.    initial calls to ffestb functions won't have been made, but subsequent
  1483.    calls (after confirmation) will, which is wrong.  Of course, this all
  1484.    applies only to those statements implemented via multiple calls to
  1485.    ffestb, although if a statement requiring only a single ffestb call
  1486.    tested for inhibition prior to confirmation, it would likely mean that
  1487.    the ffestb call would be completely dropped without this mechanism.    */
  1488.  
  1489. bool
  1490. ffesta_is_inhibited ()
  1491. {
  1492.   assert (ffesta_confirmed_current_ || ffesta_inhibit_confirmation_);
  1493.   return ffesta_is_inhibited_;
  1494. }
  1495.  
  1496. /* ffesta_ffebad_1p -- Issue diagnostic with one source character
  1497.  
  1498.    ffelexToken names_token;
  1499.    ffeTokenLength index;
  1500.    ffelexToken next_token;
  1501.    ffesta_ffebad_1p(FFEBAD_SOME_ERROR,names_token,index,next_token);
  1502.  
  1503.    Equivalent to "if (ffest_ffebad_start(FFEBAD_SOME_ERROR))" followed by
  1504.    sending one argument, the location of index with names_token, if TRUE is
  1505.    returned.  If index is equal to the length of names_token, meaning it
  1506.    points to the end of the token, then uses the location in next_token
  1507.    (which should be the token sent by the lexer after it sent names_token)
  1508.    instead.  */
  1509.  
  1510. void
  1511. ffesta_ffebad_1p (ffebad errnum, ffelexToken names_token, ffeTokenLength index,
  1512.           ffelexToken next_token)
  1513. {
  1514.   ffewhereLine line;
  1515.   ffewhereColumn col;
  1516.  
  1517.   assert (index <= ffelex_token_length (names_token));
  1518.  
  1519.   if (ffesta_ffebad_start (errnum))
  1520.     {
  1521.       if (index == ffelex_token_length (names_token))
  1522.     {
  1523.       assert (next_token != NULL);
  1524.       line = ffelex_token_where_line (next_token);
  1525.       col = ffelex_token_where_column (next_token);
  1526.       ffebad_here (0, line, col);
  1527.     }
  1528.       else
  1529.     {
  1530.       ffewhere_set_from_track (&line, &col,
  1531.                    ffelex_token_where_line (names_token),
  1532.                    ffelex_token_where_column (names_token),
  1533.                    ffelex_token_wheretrack (names_token),
  1534.                    index);
  1535.       ffebad_here (0, line, col);
  1536.       ffewhere_line_kill (line);
  1537.       ffewhere_column_kill (col);
  1538.     }
  1539.       ffebad_finish ();
  1540.     }
  1541. }
  1542.  
  1543. void
  1544. ffesta_ffebad_1sp (ffebad errnum, char *s, ffelexToken names_token,
  1545.            ffeTokenLength index, ffelexToken next_token)
  1546. {
  1547.   ffewhereLine line;
  1548.   ffewhereColumn col;
  1549.  
  1550.   assert (index <= ffelex_token_length (names_token));
  1551.  
  1552.   if (ffesta_ffebad_start (errnum))
  1553.     {
  1554.       ffebad_string (s);
  1555.       if (index == ffelex_token_length (names_token))
  1556.     {
  1557.       assert (next_token != NULL);
  1558.       line = ffelex_token_where_line (next_token);
  1559.       col = ffelex_token_where_column (next_token);
  1560.       ffebad_here (0, line, col);
  1561.     }
  1562.       else
  1563.     {
  1564.       ffewhere_set_from_track (&line, &col,
  1565.                    ffelex_token_where_line (names_token),
  1566.                    ffelex_token_where_column (names_token),
  1567.                    ffelex_token_wheretrack (names_token),
  1568.                    index);
  1569.       ffebad_here (0, line, col);
  1570.       ffewhere_line_kill (line);
  1571.       ffewhere_column_kill (col);
  1572.     }
  1573.       ffebad_finish ();
  1574.     }
  1575. }
  1576.  
  1577. void
  1578. ffesta_ffebad_1st (ffebad errnum, char *s, ffelexToken t)
  1579. {
  1580.   if (ffesta_ffebad_start (errnum))
  1581.     {
  1582.       ffebad_string (s);
  1583.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  1584.       ffebad_finish ();
  1585.     }
  1586. }
  1587.  
  1588. /* ffesta_ffebad_1t -- Issue diagnostic with one source token
  1589.  
  1590.    ffelexToken t;
  1591.    ffesta_ffebad_1t(FFEBAD_SOME_ERROR,t);
  1592.  
  1593.    Equivalent to "if (ffesta_ffebad_start(FFEBAD_SOME_ERROR))" followed by
  1594.    sending one argument, the location of the token t, if TRUE is returned.  */
  1595.  
  1596. void
  1597. ffesta_ffebad_1t (ffebad errnum, ffelexToken t)
  1598. {
  1599.   if (ffesta_ffebad_start (errnum))
  1600.     {
  1601.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  1602.       ffebad_finish ();
  1603.     }
  1604. }
  1605.  
  1606. void
  1607. ffesta_ffebad_2st (ffebad errnum, char *s, ffelexToken t1, ffelexToken t2)
  1608. {
  1609.   if (ffesta_ffebad_start (errnum))
  1610.     {
  1611.       ffebad_string (s);
  1612.       ffebad_here (0, ffelex_token_where_line (t1), ffelex_token_where_column (t1));
  1613.       ffebad_here (1, ffelex_token_where_line (t2), ffelex_token_where_column (t2));
  1614.       ffebad_finish ();
  1615.     }
  1616. }
  1617.  
  1618. /* ffesta_ffebad_2t -- Issue diagnostic with two source tokens
  1619.  
  1620.    ffelexToken t1, t2;
  1621.    ffesta_ffebad_2t(FFEBAD_SOME_ERROR,t1,t2);
  1622.  
  1623.    Equivalent to "if (ffesta_ffebad_start(FFEBAD_SOME_ERROR))" followed by
  1624.    sending two argument, the locations of the tokens t1 and t2, if TRUE is
  1625.    returned.  */
  1626.  
  1627. void
  1628. ffesta_ffebad_2t (ffebad errnum, ffelexToken t1, ffelexToken t2)
  1629. {
  1630.   if (ffesta_ffebad_start (errnum))
  1631.     {
  1632.       ffebad_here (0, ffelex_token_where_line (t1), ffelex_token_where_column (t1));
  1633.       ffebad_here (1, ffelex_token_where_line (t2), ffelex_token_where_column (t2));
  1634.       ffebad_finish ();
  1635.     }
  1636. }
  1637.  
  1638. /* ffesta_set_outpooldisp -- Set disposition of statement output pool
  1639.  
  1640.    ffesta_set_outpooldisp(FFESTA_pooldispPRESERVE);  */
  1641.  
  1642. void
  1643. ffesta_set_outpooldisp (ffestaPooldisp d)
  1644. {
  1645.   ffesta_outpooldisp_ = d;
  1646. }
  1647.  
  1648. /* ffesta_two -- Deal with the first two tokens after a swallowed statement
  1649.  
  1650.    return ffesta_two(first_token,second_token);     // to lexer.
  1651.  
  1652.    Like ffesta_zero, except instead of expecting an EOS or SEMICOLON, it
  1653.    expects the first two tokens of a statement that is part of another
  1654.    statement: the first two tokens of statement in "IF (expr) statement" or
  1655.    "WHERE (expr) statement", in particular.  The first token must be a NAME
  1656.    or NAMES, the second can be basically anything.  The statement type MUST
  1657.    be confirmed by now.
  1658.  
  1659.    If we're not inhibited, just handle things as if we were ffesta_zero
  1660.    and saw an EOS just before the two tokens.
  1661.  
  1662.    If we're inhibited, set ffesta_current_shutdown_ to shut down the current
  1663.    statement and continue with other possibilities, then (presumably) come
  1664.    back to this one for real when not inhibited.  */
  1665.  
  1666. ffelexHandler
  1667. ffesta_two (ffelexToken first, ffelexToken second)
  1668. {
  1669. #if FFESTA_ABORT_ON_CONFIRM_
  1670.   ffelexHandler next;
  1671. #endif
  1672.  
  1673.   assert ((ffelex_token_type (first) == FFELEX_typeNAME)
  1674.       || (ffelex_token_type (first) == FFELEX_typeNAMES));
  1675.   assert (ffesta_tokens[0] != NULL);
  1676.  
  1677.   if (ffesta_is_inhibited_)    /* Oh, not really done with statement. */
  1678.     {
  1679.       ffesta_current_shutdown_ = TRUE;
  1680.       /* To catch the EOS on shutdown. */
  1681.       return (ffelexHandler) ffelex_swallow_tokens (second,
  1682.                            (ffelexHandler) ffesta_zero);
  1683.     }
  1684.  
  1685.   ffestw_display_state ();
  1686.  
  1687.   ffelex_token_kill (ffesta_tokens[0]);
  1688.  
  1689.   if (ffesta_output_pool != NULL)
  1690.     {
  1691.       if (ffesta_outpooldisp_ == FFESTA_pooldispDISCARD)
  1692.     malloc_pool_kill (ffesta_output_pool);
  1693.       ffesta_output_pool = NULL;
  1694.     }
  1695.  
  1696.   if (ffesta_scratch_pool != NULL)
  1697.     {
  1698.       malloc_pool_kill (ffesta_scratch_pool);
  1699.       ffesta_scratch_pool = NULL;
  1700.     }
  1701.  
  1702.   ffesta_reset_possibles_ ();
  1703.   ffesta_confirmed_current_ = FALSE;
  1704.  
  1705.   /* What happens here is somewhat interesting.     We effectively derail the
  1706.      line of handlers for these two tokens, the first two in a statement, by
  1707.      setting a flag to TRUE.  This flag tells ffesta_save_ (or, conceivably,
  1708.      the lexer via ffesta_second_'s case 1:, where it has only one possible
  1709.      kind of statement -- someday this will be more likely, i.e. after
  1710.      confirmation causes an immediate switch to only the one context rather
  1711.      than just setting a flag and running through the remaining possibles to
  1712.      look for ambiguities) that the last two tokens it sent did not reach the
  1713.      truly desired targets (ffest_first and ffesta_second_) since that would
  1714.      otherwise attempt to recursively invoke ffesta_save_ in most cases,
  1715.      while the existing ffesta_save_ was still alive and making use of static
  1716.      (nonrecursive) variables.    Instead, ffesta_save_, upon seeing this flag
  1717.      set TRUE, sets it to FALSE and resubmits the two tokens copied here to
  1718.      ffest_first and, presumably, ffesta_second_, kills them, and returns the
  1719.      handler returned by the handler for the second token.  Thus, even though
  1720.      ffesta_save_ is still (likely to be) recursively invoked, the former
  1721.      invocation is past the use of any static variables possibly changed
  1722.      during the first-two-token invocation of the latter invocation. */
  1723.  
  1724. #if FFESTA_ABORT_ON_CONFIRM_
  1725.   /* Shouldn't be in ffesta_save_ at all here. */
  1726.  
  1727.   next = (ffelexHandler) ffesta_first (first);
  1728.   return (ffelexHandler) (*next) (second);
  1729. #else
  1730.   ffesta_twotokens_1_ = ffelex_token_use (first);
  1731.   ffesta_twotokens_2_ = ffelex_token_use (second);
  1732.  
  1733.   ffesta_is_two_into_statement_ = TRUE;
  1734.   return (ffelexHandler) ffesta_send_two_;    /* Shouldn't get called. */
  1735. #endif
  1736. }
  1737.  
  1738. /* ffesta_zero -- Deal with the end of a swallowed statement
  1739.  
  1740.    return ffesta_zero;    // to lexer.
  1741.  
  1742.    NOTICE that this code is COPIED, largely, into a
  1743.    similar function named ffesta_two that gets invoked in place of
  1744.    _zero_ when the end of the statement happens before EOS or SEMICOLON and
  1745.    to tokens into the next statement have been read (as is the case with the
  1746.    logical-IF and WHERE-stmt statements).  So any changes made here should
  1747.    probably be made in _two_ at the same time.    */
  1748.  
  1749. ffelexHandler
  1750. ffesta_zero (ffelexToken t)
  1751. {
  1752.   assert ((ffelex_token_type (t) == FFELEX_typeEOS)
  1753.       || (ffelex_token_type (t) == FFELEX_typeSEMICOLON));
  1754.   assert (ffesta_tokens[0] != NULL);
  1755.  
  1756.   if (ffesta_is_inhibited_)
  1757.     ffesymbol_retract (TRUE);
  1758.   else
  1759.     ffestw_display_state ();
  1760.  
  1761.   /* Do CONTINUE if nothing else.  This is done specifically so that "IF
  1762.      (...) BLAH" causes the same things to happen as if "IF (...) CONTINUE"
  1763.      was done, so that tracking of labels and such works.  (Try a small
  1764.      program like "DO 10 ...", "IF (...) BLAH", "10 CONTINUE", "END".)
  1765.  
  1766.      But it turns out that just testing "!ffesta_confirmed_current_"
  1767.      isn't enough, because then typing "GOTO" instead of "BLAH" above
  1768.      doesn't work -- the statement is confirmed (we know the user
  1769.      attempted a GOTO) but ffestc hasn't seen it.  So, instead, just
  1770.      always tell ffestc to do "any" statement it needs to to reset.  */
  1771.  
  1772.   if (!ffesta_is_inhibited_
  1773.       && ffesta_seen_first_exec)
  1774.     {
  1775.       ffestc_any ();
  1776.     }
  1777.  
  1778.   ffelex_token_kill (ffesta_tokens[0]);
  1779.  
  1780.   if (ffesta_is_inhibited_)    /* Oh, not really done with statement. */
  1781.     return (ffelexHandler) ffesta_zero;    /* Call me again when done! */
  1782.  
  1783.   if (ffesta_output_pool != NULL)
  1784.     {
  1785.       if (ffesta_outpooldisp_ == FFESTA_pooldispDISCARD)
  1786.     malloc_pool_kill (ffesta_output_pool);
  1787.       ffesta_output_pool = NULL;
  1788.     }
  1789.  
  1790.   if (ffesta_scratch_pool != NULL)
  1791.     {
  1792.       malloc_pool_kill (ffesta_scratch_pool);
  1793.       ffesta_scratch_pool = NULL;
  1794.     }
  1795.  
  1796.   ffesta_reset_possibles_ ();
  1797.   ffesta_confirmed_current_ = FALSE;
  1798.  
  1799.   if (ffelex_token_type (t) == FFELEX_typeSEMICOLON)
  1800.     {
  1801.       ffesta_line_has_semicolons = TRUE;
  1802.       if (ffe_is_pedantic_not_90 ())
  1803.     {
  1804.       ffebad_start (FFEBAD_SEMICOLON);
  1805.       ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));
  1806.       ffebad_finish ();
  1807.     }
  1808.     }
  1809.   else
  1810.     ffesta_line_has_semicolons = FALSE;
  1811.  
  1812.   if (ffesta_label_token != NULL)
  1813.     {
  1814.       ffelex_token_kill (ffesta_label_token);
  1815.       ffesta_label_token = NULL;
  1816.     }
  1817.  
  1818.   if (ffe_is_ffedebug ())
  1819.     {
  1820.       ffestorag_report ();
  1821.       ffesymbol_report_all ();
  1822.     }
  1823.  
  1824.   ffelex_set_names (TRUE);
  1825.   return (ffelexHandler) ffesta_first;
  1826. }
  1827.