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 / st.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  16KB  |  545 lines
  1. /* st.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.       The high-level input level to statement handling for the rest of the
  26.       FFE.  ffest_first is the first state for the lexer to invoke to start
  27.       a statement.  A statement normally starts with a NUMBER token (to indicate
  28.       a label def) followed by a NAME token (to indicate what kind of statement
  29.       it is), though of course the NUMBER token may be omitted.     ffest_first
  30.       gathers the first NAME token and returns a state of ffest_second_,
  31.       where the trailing underscore means "internal to ffest" and thus outside
  32.       users should not depend on this.    ffest_second_ then looks at the second
  33.       token in conjunction with the first, decides what possible statements are
  34.       meant, and tries each possible statement in turn, from most likely to
  35.       least likely.  A successful attempt currently is recorded, and further
  36.       successful attempts by other possibilities raise an assertion error in
  37.       ffest_confirmed (this is to detect ambiguities).    A failure in an
  38.       attempt is signaled by calling ffest_ffebad_start; this results in the
  39.       next token sent by ffest_save_ (the intermediary when more than one
  40.       possible statement exists) being EOS to shut down processing and the next
  41.       possibility tried.
  42.  
  43.       When all possibilities have been tried, the successful one is retried with
  44.       inhibition turned off (FALSE) as reported by ffest_is_inhibited().  If
  45.       there is no successful one, the first one is retried so the user gets to
  46.       see the error messages.
  47.  
  48.       In the future, after syntactic bugs have been reasonably shaken out and
  49.       ambiguities thus detected, the first successful possibility will be
  50.       enabled (inhibited goes FALSE) as soon as it confirms success by calling
  51.       ffest_confirmed, thus retrying the possibility will not be necessary.
  52.  
  53.       The only complication in all this is that expression handling is
  54.       happening while possibilities are inhibited.  It is up to the expression
  55.       handler, conceptually, to not make any changes to its knowledge base for
  56.       variable names and so on when inhibited that cannot be undone if
  57.       the current possibility fails (shuts down via ffest_ffebad_start).  In
  58.       fact, this business is handled not be ffeexpr, but by lower levels.
  59.  
  60.       ffesta functions serve only to provide information used in syntactic
  61.       processing of possible statements, and thus may not make changes to the
  62.       knowledge base for variables and such.
  63.  
  64.       ffestb functions perform the syntactic analysis for possible statements,
  65.       and thus again may not make changes to the knowledge base except under the
  66.       auspices of ffeexpr and its subordinates, changes which can be undone when
  67.       necessary.
  68.  
  69.       ffestc functions perform the semantic analysis for the chosen statement,
  70.       and thus may change the knowledge base as necessary since they are invoked
  71.       by ffestb functions only after a given statement is confirmed and
  72.       enabled.    Note, however, that a few ffestc functions (identified by
  73.       their statement names rather than grammar numbers) indicate valid forms
  74.       that are, outside of any context, ambiguous, such as ELSE WHERE and
  75.       PRIVATE; these functions should make a quick decision as to what is
  76.       intended and dispatch to the appropriate specific ffestc function.
  77.  
  78.       ffestd functions actually implement statements.  When called, the
  79.       statement is considered valid and is either an executable statement or
  80.       a nonexecutable statement with direct-output results.  For example, CALL,
  81.       GOTO, and assignment statements pass through ffestd because they are
  82.       executable; DATA statements pass through because they map directly to the
  83.       output file (or at least might so map); ENTRY statements also pass through
  84.       because they essentially affect code generation in an immediate way;
  85.       whereas INTEGER, SAVE, and SUBROUTINE statements do not go through
  86.       ffestd functions because they merely update the knowledge base.
  87.  
  88.    Modifications:
  89. */
  90.  
  91. /* Include files. */
  92.  
  93. #include "proj.h"
  94. #include "st.h"
  95. #include "bad.h"
  96. #include "lex.h"
  97. #include "sta.h"
  98. #include "stb.h"
  99. #include "stc.h"
  100. #include "std.h"
  101. #include "ste.h"
  102. #include "stp.h"
  103. #include "str.h"
  104. #include "sts.h"
  105. #include "stt.h"
  106. #include "stu.h"
  107. #include "stv.h"
  108. #include "stw.h"
  109.  
  110. /* Externals defined here. */
  111.  
  112.  
  113. /* Simple definitions and enumerations. */
  114.  
  115.  
  116. /* Internal typedefs. */
  117.  
  118.  
  119. /* Private include files. */
  120.  
  121.  
  122. /* Internal structure definitions. */
  123.  
  124.  
  125. /* Static objects accessed by functions in this module. */
  126.  
  127.  
  128. /* Static functions (internal). */
  129.  
  130.  
  131. /* Internal macros. */
  132.  
  133.  
  134. /* ffest_confirmed -- Confirm current possibility as only one
  135.  
  136.    ffest_confirmed();
  137.  
  138.    Sets the confirmation flag.    During debugging for ambiguous constructs,
  139.    asserts that the confirmation flag for a previous possibility has not
  140.    yet been set.  */
  141.  
  142. void
  143. ffest_confirmed ()
  144. {
  145.   ffesta_confirmed ();
  146. }
  147.  
  148. /* ffest_eof -- End of (non-INCLUDEd) source file
  149.  
  150.    ffest_eof();
  151.  
  152.    Call after piping tokens through ffest_first, where the most recent
  153.    token sent through must be EOS.
  154.  
  155.    20-Feb-91  JCB  1.1
  156.       Put new EOF token in ffesta_tokens[0], not NULL, because too much
  157.       code expects something there for error reporting and the like.  Also,
  158.       do basically the same things ffest_second and ffesta_zero do for
  159.       processing a statement (make and destroy pools, et cetera).  */
  160.  
  161. void
  162. ffest_eof ()
  163. {
  164.   ffesta_eof ();
  165. }
  166.  
  167. /* ffest_ffebad_here_current_stmt -- ffebad_here with ptr to current stmt
  168.  
  169.    ffest_ffebad_here_current_stmt(0);
  170.  
  171.    Outsiders can call this fn if they have no more convenient place to
  172.    point to (via a token or pair of ffewhere objects) and they know a
  173.    current, useful statement is being evaluted by ffest (i.e. they are
  174.    being called from ffestb, ffestc, ffestd, ... functions).  */
  175.  
  176. void
  177. ffest_ffebad_here_current_stmt (ffebadIndex i)
  178. {
  179.   ffesta_ffebad_here_current_stmt (i);
  180. }
  181.  
  182. /* ffest_ffebad_here_doiter -- Calls ffebad_here with ptr to DO iter var
  183.  
  184.    ffesymbol s;
  185.    // call ffebad_start first, of course.
  186.    ffest_ffebad_here_doiter(0,s);
  187.    // call ffebad_finish afterwards, naturally.
  188.  
  189.    Searches the stack of blocks backwards for a DO loop that has s
  190.    as its iteration variable, then calls ffebad_here with pointers to
  191.    that particular reference to the variable.  Crashes if the DO loop
  192.    can't be found.  */
  193.  
  194. void
  195. ffest_ffebad_here_doiter (ffebadIndex i, ffesymbol s)
  196. {
  197.   ffestc_ffebad_here_doiter (i, s);
  198. }
  199.  
  200. /* ffest_ffebad_start -- Start a possibly inhibited error report
  201.  
  202.    if (ffest_ffebad_start(FFEBAD_SOME_ERROR))
  203.        {
  204.        ffebad_here, ffebad_string ...;
  205.        ffebad_finish();
  206.        }
  207.  
  208.    Call if the error might indicate that ffest is evaluating the wrong
  209.    statement form, instead of calling ffebad_start directly.  If ffest
  210.    is choosing between forms, it will return FALSE, send an EOS/SEMICOLON
  211.    token through as the next token (if the current one isn't already one
  212.    of those), and try another possible form.  Otherwise, ffebad_start is
  213.    called with the argument and TRUE returned.    */
  214.  
  215. bool
  216. ffest_ffebad_start (ffebad errnum)
  217. {
  218.   return ffesta_ffebad_start (errnum);
  219. }
  220.  
  221. /* ffest_first -- Parse the first token in a statement
  222.  
  223.    return ffest_first;    // to lexer.  */
  224.  
  225. ffelexHandler
  226. ffest_first (ffelexToken t)
  227. {
  228.   return ffesta_first (t);
  229. }
  230.  
  231. /* ffest_init_0 -- Initialize for entire image invocation
  232.  
  233.    ffest_init_0();
  234.  
  235.    Call just once per invocation of the compiler (not once per invocation
  236.    of the front end).
  237.  
  238.    Gets memory for the list of possibles once and for all, since this
  239.    list never gets larger than a certain size (FFEST_maxPOSSIBLES_)
  240.    and is not particularly large.  Initializes the array of pointers to
  241.    this list.  Initializes the executable and nonexecutable lists.  */
  242.  
  243. void
  244. ffest_init_0 ()
  245. {
  246.   ffesta_init_0 ();
  247.   ffestb_init_0 ();
  248.   ffestc_init_0 ();
  249.   ffestd_init_0 ();
  250.   ffeste_init_0 ();
  251.   ffestp_init_0 ();
  252.   ffestr_init_0 ();
  253.   ffests_init_0 ();
  254.   ffestt_init_0 ();
  255.   ffestu_init_0 ();
  256.   ffestv_init_0 ();
  257.   ffestw_init_0 ();
  258. }
  259.  
  260. /* ffest_init_1 -- Initialize for entire image invocation
  261.  
  262.    ffest_init_1();
  263.  
  264.    Call just once per invocation of the compiler (not once per invocation
  265.    of the front end).
  266.  
  267.    Gets memory for the list of possibles once and for all, since this
  268.    list never gets larger than a certain size (FFEST_maxPOSSIBLES_)
  269.    and is not particularly large.  Initializes the array of pointers to
  270.    this list.  Initializes the executable and nonexecutable lists.  */
  271.  
  272. void
  273. ffest_init_1 ()
  274. {
  275.   ffesta_init_1 ();
  276.   ffestb_init_1 ();
  277.   ffestc_init_1 ();
  278.   ffestd_init_1 ();
  279.   ffeste_init_1 ();
  280.   ffestp_init_1 ();
  281.   ffestr_init_1 ();
  282.   ffests_init_1 ();
  283.   ffestt_init_1 ();
  284.   ffestu_init_1 ();
  285.   ffestv_init_1 ();
  286.   ffestw_init_1 ();
  287. }
  288.  
  289. /* ffest_init_2 -- Initialize for entire image invocation
  290.  
  291.    ffest_init_2();
  292.  
  293.    Call just once per invocation of the compiler (not once per invocation
  294.    of the front end).
  295.  
  296.    Gets memory for the list of possibles once and for all, since this
  297.    list never gets larger than a certain size (FFEST_maxPOSSIBLES_)
  298.    and is not particularly large.  Initializes the array of pointers to
  299.    this list.  Initializes the executable and nonexecutable lists.  */
  300.  
  301. void
  302. ffest_init_2 ()
  303. {
  304.   ffesta_init_2 ();
  305.   ffestb_init_2 ();
  306.   ffestc_init_2 ();
  307.   ffestd_init_2 ();
  308.   ffeste_init_2 ();
  309.   ffestp_init_2 ();
  310.   ffestr_init_2 ();
  311.   ffests_init_2 ();
  312.   ffestt_init_2 ();
  313.   ffestu_init_2 ();
  314.   ffestv_init_2 ();
  315.   ffestw_init_2 ();
  316. }
  317.  
  318. /* ffest_init_3 -- Initialize for any program unit
  319.  
  320.    ffest_init_3();  */
  321.  
  322. void
  323. ffest_init_3 ()
  324. {
  325.   ffesta_init_3 ();
  326.   ffestb_init_3 ();
  327.   ffestc_init_3 ();
  328.   ffestd_init_3 ();
  329.   ffeste_init_3 ();
  330.   ffestp_init_3 ();
  331.   ffestr_init_3 ();
  332.   ffests_init_3 ();
  333.   ffestt_init_3 ();
  334.   ffestu_init_3 ();
  335.   ffestv_init_3 ();
  336.   ffestw_init_3 ();
  337.  
  338.   ffestw_display_state ();
  339. }
  340.  
  341. /* ffest_init_4 -- Initialize for statement functions
  342.  
  343.    ffest_init_4();  */
  344.  
  345. void
  346. ffest_init_4 ()
  347. {
  348.   ffesta_init_4 ();
  349.   ffestb_init_4 ();
  350.   ffestc_init_4 ();
  351.   ffestd_init_4 ();
  352.   ffeste_init_4 ();
  353.   ffestp_init_4 ();
  354.   ffestr_init_4 ();
  355.   ffests_init_4 ();
  356.   ffestt_init_4 ();
  357.   ffestu_init_4 ();
  358.   ffestv_init_4 ();
  359.   ffestw_init_4 ();
  360. }
  361.  
  362. /* Test whether ENTRY statement is valid.
  363.  
  364.    Returns TRUE if current program unit is known to be FUNCTION or SUBROUTINE.
  365.    Else returns FALSE.  */
  366.  
  367. bool
  368. ffest_is_entry_valid ()
  369. {
  370.   return ffesta_is_entry_valid;
  371. }
  372.  
  373. /* ffest_is_inhibited -- Test whether the current possibility is inhibited
  374.  
  375.    if (!ffest_is_inhibited())
  376.        // implement the statement.
  377.  
  378.    Just make sure the current possibility has been confirmed.  If anyone
  379.    really needs to test whether the current possibility is inhibited prior
  380.    to confirming it, that indicates a need to begin statement processing
  381.    before it is certain that the given possibility is indeed the statement
  382.    to be processed.  As of this writing, there does not appear to be such
  383.    a need.  If there is, then when confirming a statement would normally
  384.    immediately disable the inhibition (whereas currently we leave the
  385.    confirmed statement disabled until we've tried the other possibilities,
  386.    to check for ambiguities), we must check to see if the possibility has
  387.    already tested for inhibition prior to confirmation and, if so, maintain
  388.    inhibition until the end of the statement (which may be forced right
  389.    away) and then rerun the entire statement from the beginning.  Otherwise,
  390.    initial calls to ffestb functions won't have been made, but subsequent
  391.    calls (after confirmation) will, which is wrong.  Of course, this all
  392.    applies only to those statements implemented via multiple calls to
  393.    ffestb, although if a statement requiring only a single ffestb call
  394.    tested for inhibition prior to confirmation, it would likely mean that
  395.    the ffestb call would be completely dropped without this mechanism.    */
  396.  
  397. bool
  398. ffest_is_inhibited ()
  399. {
  400.   return ffesta_is_inhibited ();
  401. }
  402.  
  403. /* ffest_seen_first_exec -- Test whether first executable stmt has been seen
  404.  
  405.    if (ffest_seen_first_exec())
  406.        // No more spec stmts can be seen.
  407.  
  408.    In a case where, say, the first statement is PARAMETER(A)=B, FALSE
  409.    will be returned while the PARAMETER statement is being run, and TRUE
  410.    will be returned if it doesn't confirm and the assignment statement
  411.    is being run.  */
  412.  
  413. bool
  414. ffest_seen_first_exec ()
  415. {
  416.   return ffesta_seen_first_exec;
  417. }
  418.  
  419. /* ffest_sym_end_transition -- Update symbol info just before end of unit
  420.  
  421.    ffesymbol s;
  422.    ffest_sym_end_transition(s);     */
  423.  
  424. ffesymbol
  425. ffest_sym_end_transition (ffesymbol s)
  426. {
  427.   return ffestu_sym_end_transition (s);
  428. }
  429.  
  430. /* ffest_sym_exec_transition -- Update symbol just before first exec stmt
  431.  
  432.    ffesymbol s;
  433.    ffest_sym_exec_transition(s);  */
  434.  
  435. ffesymbol
  436. ffest_sym_exec_transition (ffesymbol s)
  437. {
  438.   return ffestu_sym_exec_transition (s);
  439. }
  440.  
  441. /* ffest_terminate_0 -- Terminate for entire image invocation
  442.  
  443.    ffest_terminate_0();     */
  444.  
  445. void
  446. ffest_terminate_0 ()
  447. {
  448.   ffesta_terminate_0 ();
  449.   ffestb_terminate_0 ();
  450.   ffestc_terminate_0 ();
  451.   ffestd_terminate_0 ();
  452.   ffeste_terminate_0 ();
  453.   ffestp_terminate_0 ();
  454.   ffestr_terminate_0 ();
  455.   ffests_terminate_0 ();
  456.   ffestt_terminate_0 ();
  457.   ffestu_terminate_0 ();
  458.   ffestv_terminate_0 ();
  459.   ffestw_terminate_0 ();
  460. }
  461.  
  462. /* ffest_terminate_1 -- Terminate for source file
  463.  
  464.    ffest_terminate_1();     */
  465.  
  466. void
  467. ffest_terminate_1 ()
  468. {
  469.   ffesta_terminate_1 ();
  470.   ffestb_terminate_1 ();
  471.   ffestc_terminate_1 ();
  472.   ffestd_terminate_1 ();
  473.   ffeste_terminate_1 ();
  474.   ffestp_terminate_1 ();
  475.   ffestr_terminate_1 ();
  476.   ffests_terminate_1 ();
  477.   ffestt_terminate_1 ();
  478.   ffestu_terminate_1 ();
  479.   ffestv_terminate_1 ();
  480.   ffestw_terminate_1 ();
  481. }
  482.  
  483. /* ffest_terminate_2 -- Terminate for outer program unit
  484.  
  485.    ffest_terminate_2();     */
  486.  
  487. void
  488. ffest_terminate_2 ()
  489. {
  490.   ffesta_terminate_2 ();
  491.   ffestb_terminate_2 ();
  492.   ffestc_terminate_2 ();
  493.   ffestd_terminate_2 ();
  494.   ffeste_terminate_2 ();
  495.   ffestp_terminate_2 ();
  496.   ffestr_terminate_2 ();
  497.   ffests_terminate_2 ();
  498.   ffestt_terminate_2 ();
  499.   ffestu_terminate_2 ();
  500.   ffestv_terminate_2 ();
  501.   ffestw_terminate_2 ();
  502. }
  503.  
  504. /* ffest_terminate_3 -- Terminate for any program unit
  505.  
  506.    ffest_terminate_3();     */
  507.  
  508. void
  509. ffest_terminate_3 ()
  510. {
  511.   ffesta_terminate_3 ();
  512.   ffestb_terminate_3 ();
  513.   ffestc_terminate_3 ();
  514.   ffestd_terminate_3 ();
  515.   ffeste_terminate_3 ();
  516.   ffestp_terminate_3 ();
  517.   ffestr_terminate_3 ();
  518.   ffests_terminate_3 ();
  519.   ffestt_terminate_3 ();
  520.   ffestu_terminate_3 ();
  521.   ffestv_terminate_3 ();
  522.   ffestw_terminate_3 ();
  523. }
  524.  
  525. /* ffest_terminate_4 -- Terminate for statement functions
  526.  
  527.    ffest_terminate_4();     */
  528.  
  529. void
  530. ffest_terminate_4 ()
  531. {
  532.   ffesta_terminate_4 ();
  533.   ffestb_terminate_4 ();
  534.   ffestc_terminate_4 ();
  535.   ffestd_terminate_4 ();
  536.   ffeste_terminate_4 ();
  537.   ffestp_terminate_4 ();
  538.   ffestr_terminate_4 ();
  539.   ffests_terminate_4 ();
  540.   ffestt_terminate_4 ();
  541.   ffestu_terminate_4 ();
  542.   ffestv_terminate_4 ();
  543.   ffestw_terminate_4 ();
  544. }
  545.