matiec: comparison stage1_2/iec

equal deleted inserted replaced

-:f53ea4c8621c
+:e984cfdf3b10
 * e.g.:  TIME#55d_4h_56m
 *       We would like to return to bison the tokens 'TIME' '#' '55d' '_' '4h' '_' '56m'
 *       Unfortunately, flex will join '_' and '4h' to create a legal {identifier} '_4h',
 *       and return that identifier instead! So, we added this state!
 *
-* There is a main state machine...
+* The ignore_pou_state state is only used when bison says it is doing the pre-parsing.
+* During pre-parsing, the main state machine will only transition between
+* INITIAL and ignore_pou_state, and from here back to INITIAL. All other
+* transitions are inhibited. This inhibition is actually just enforced by making
+* sure that the INITIAL ---> ignore_pou_state transition is tested before all other
+* transitions coming out of INITIAL state. All other transitions are unaffected, as they
+* never get a chance to be evaluated when bison is doing pre-parsing.
+* Pre-parsing is a first quick scan through the whole input source code simply
+* to determine the list of POUs and datatypes that will be defined in that
+* code. Basically, the objective is to fill up the previously_declared_xxxxx
+* maps, without processing the code itself. Once these maps have been filled up,
+* bison will throw away the AST (abstract syntax tree) created up to that point,
+* and scan through the same source code again, but this time creating a correct AST.
+* This pre-scan allows the source code to reference POUs and datatypes that are
+* only declared after they are used!
 *
+*
+* Here is a main state machine...
+*                                                                         --+
+*                                                                           |  these states are
+*              +------------> get_pou_name_state  ----> ignore_pou_state    |  only active
+*              |                                            |               |  when bison is
+*              |  ------------------------------------------+               |  doing the
+*              |  |                                                         |  pre-parsing!!
+*              |  v                                                       --+
 *       +---> INITIAL <-------> config
 *       |        \
 *       |        V
 *       |   header_state
 *       |        |
 *      - The transitions form sfc to body will be decided by bison, which will
 *        tell flex to do the transition by calling cmd_goto_body_state().
 *
 *
 * Possible state changes are:
+*   INITIAL -> goto(ignore_pou_state)
+*               (This transition state is only used when bison says it is doing the pre-parsing.)
+*               (This transition takes precedence over all other transitions!)
+*               (when a FUNCTION, FUNCTION_BLOCK, PROGRAM or CONFIGURATION is found)
+*
 *   INITIAL -> goto(config_state)
 *                (when a CONFIGURATION is found)
 *
 *   INITIAL -> goto(header_state)
 *               (when a FUNCTION, FUNCTION_BLOCK, or PROGRAM is found)
+*
 *   header_state -> goto(vardecl_list_state)
 *               (When the first VAR token is found, i.e. at begining of first VAR .. END_VAR declaration)
 *
 *  vardecl_list_state -> push current state (vardecl_list_state), and goto(vardecl_state)
 *                (when a VAR token is found)
 *                     (when a END_FUNCTION, END_FUNCTION_BLOCK, END_PROGRAM,
 *                      END_ACTION or END_TRANSITION is found)
 *   sfc_state     -> pop() to vardecl_list_state
 *                     (when a END_FUNCTION, END_FUNCTION_BLOCK, or END_PROGRAM is found)
 *
+*   ignore_pou_state   -> goto(INITIAL)
+*                         (when a END_FUNCTION, END_FUNCTION_BLOCK, END_PROGRAM or END_CONFIGURATION is found)
 *   vardecl_list_state -> goto(INITIAL)
-*                     (when a END_FUNCTION, END_FUNCTION_BLOCK, or END_PROGRAM is found)
+*                         (when a END_FUNCTION, END_FUNCTION_BLOCK, or END_PROGRAM is found)
-*   config_state  -> goto(INITIAL)
+*   config_state       -> goto(INITIAL)
-*                     (when a END_CONFIGURATION is found)
+*                         (when a END_CONFIGURATION is found)
 *
 *
 *   sfc_state     -> push current state(sfc_state); goto(body_state)
 *                     (when parsing an action. This transition is requested by bison)
 *   sfc_state     -> push current state(sfc_state); goto(sfc_qualifier_state)
 *
 * There is another secondary state machine for parsing comments, another for file_includes,
 * and yet another for time literals.
 */
+/* Bison is in the pre-parsing stage, and we are parsing a POU. Ignore everything up to the end of the POU! */
+%x ignore_pou_state
+%x get_pou_name_state
 /* we are parsing a configuration. */
 %s config_state
 /* Inside a configuration, we are parsing a task initialisation parameters */
 	 *       FUNCTION_BLOCKs that do not have at least one VAR_END before the body_state.
 	 *       If the code has an error, and no VAR_END before the body, we will simply
 	 *       continue in the <vardecl_state> state, untill the end of the FUNCTION, FUNCTION_BLOCK
 	 *       or PROGAM.
 	 */
-FUNCTION				BEGIN(header_state); return FUNCTION;
-FUNCTION_BLOCK				BEGIN(header_state); return FUNCTION_BLOCK;
+FUNCTION{st_whitespace} 		if (get_preparse_state()) BEGIN(get_pou_name_state); else BEGIN(header_state); return FUNCTION;
-PROGRAM					BEGIN(header_state); return PROGRAM;
+FUNCTION_BLOCK{st_whitespace}		if (get_preparse_state()) BEGIN(get_pou_name_state); else BEGIN(header_state); return FUNCTION_BLOCK;
-CONFIGURATION				BEGIN(config_state); return CONFIGURATION;
+PROGRAM{st_whitespace}			if (get_preparse_state()) BEGIN(get_pou_name_state); else BEGIN(header_state); return PROGRAM;
+CONFIGURATION{st_whitespace}		if (get_preparse_state()) BEGIN(get_pou_name_state); else BEGIN(config_state); return CONFIGURATION;
+}
+<get_pou_name_state>{
+{identifier}			BEGIN(ignore_pou_state); yylval.ID=strdup(yytext); return identifier_token;
+.				BEGIN(ignore_pou_state); unput_text(0);
+}
+<ignore_pou_state>{
+END_FUNCTION			unput_text(0); BEGIN(INITIAL);
+END_FUNCTION_BLOCK		unput_text(0); BEGIN(INITIAL);
+END_PROGRAM			unput_text(0); BEGIN(INITIAL);
+END_CONFIGURATION		unput_text(0); BEGIN(INITIAL);
+.|\n				{}/* Ignore text inside POU! (including the '\n' character!)) */
 }
 	/* INITIAL -> body_state */
 	/* required if the function, program, etc.. has no VAR block! */
 	/* We comment it out since the standard does not allow this.  */
 	/* The whitespace */
 <INITIAL,header_state,config_state,body_state,vardecl_list_state,vardecl_state,st_state,sfc_state,task_init_state,sfc_qualifier_state>{st_whitespace}	/* Eat any whitespace */
 <il_state>{il_whitespace}		/* Eat any whitespace */
 	/* The comments */
-<body_state,vardecl_list_state>{comment_beg}		yy_push_state(comment_state);
+<get_pou_name_state,ignore_pou_state,body_state,vardecl_list_state>{comment_beg}		yy_push_state(comment_state);
 {comment_beg}						yy_push_state(comment_state);
 <comment_state>{
 {comment_beg}						{if (get_opt_nested_comments()) yy_push_state(comment_state);}
 {comment_end}						yy_pop_state();
 .							/* Ignore text inside comment! */

changeset 952	e984cfdf3b10
parent 948	543f8319bdf8
child 1010	242907849850