972 {disable_code_generation_pragma}               return disable_code_generation_pragma_token;

   971 	/* NOTE: In the vardecl_list_state we only process the pragmas between two consecutive VAR .. END_VAR blocks.

   973 {enable_code_generation_pragma}                return enable_code_generation_pragma_token;

   972 	 *       We do not process any pragmas trailing after the last END_VAR. We leave that to the body_state.

   974 <body_state,vardecl_list_state>{disable_code_generation_pragma}   return disable_code_generation_pragma_token;

   973 	 *       This is because the pragmas are stored in a statement_list or instruction_list (in bison),

   975 <body_state,vardecl_list_state>{enable_code_generation_pragma}    return enable_code_generation_pragma_token;

   974 	 *       but these lists must start with the special tokens start_IL_body_token/start_ST_body_token.

   976 

   975 	 *       This means that these special tokens must be generated (by the body_state) before processing

   976 	 *       the pragme => we cannot process the trailing pragmas in the vardecl_list_state state.

   977 	 */

   978 {disable_code_generation_pragma}				return disable_code_generation_pragma_token;

   979 {enable_code_generation_pragma}					return enable_code_generation_pragma_token;

   980 <vardecl_list_state>{disable_code_generation_pragma}/(VAR)	return disable_code_generation_pragma_token; 

   981 <vardecl_list_state>{enable_code_generation_pragma}/(VAR)	return enable_code_generation_pragma_token;  

   982 <body_state>{disable_code_generation_pragma}			append_bodystate_buffer(yytext); /* in body state we do not process any tokens, we simply store them for later processing! */

   983 <body_state>{enable_code_generation_pragma}			append_bodystate_buffer(yytext); /* in body state we do not process any tokens, we simply store them for later processing! */

   985 <body_state,vardecl_list_state>{pragma} {/* return the pragmma without the enclosing '{' and '}' */

   993 <vardecl_list_state>{pragma}/(VAR) {/* return the pragmma without the enclosing '{' and '}' */

  1073 	/* NOTE: how about functions that do not declare variables, and go directly to the body_state???

  1081 FUNCTION{st_whitespace} 		if (get_preparse_state()) BEGIN(get_pou_name_state); else {BEGIN(header_state);/* printf("\nChanging to header_state\n"); */} return FUNCTION;

  1082 FUNCTION_BLOCK{st_whitespace}		if (get_preparse_state()) BEGIN(get_pou_name_state); else {BEGIN(header_state);/* printf("\nChanging to header_state\n"); */} return FUNCTION_BLOCK;

  1083 PROGRAM{st_whitespace}			if (get_preparse_state()) BEGIN(get_pou_name_state); else {BEGIN(header_state);/* printf("\nChanging to header_state\n"); */} return PROGRAM;

  1084 CONFIGURATION{st_whitespace}		if (get_preparse_state()) BEGIN(get_pou_name_state); else {BEGIN(config_state);/* printf("\nChanging to config_state\n"); */} return CONFIGURATION;

  1085 }

  1086 

  1087 <get_pou_name_state>{

  1088 {identifier}			BEGIN(ignore_pou_state); yylval.ID=strdup(yytext); return identifier_token;

  1089 .				BEGIN(ignore_pou_state); unput_text(0);

  1090 }

  1091 

  1092 <ignore_pou_state>{

  1093 END_FUNCTION			unput_text(0); BEGIN(INITIAL);

  1094 END_FUNCTION_BLOCK		unput_text(0); BEGIN(INITIAL);

  1095 END_PROGRAM			unput_text(0); BEGIN(INITIAL);

  1096 END_CONFIGURATION		unput_text(0); BEGIN(INITIAL);

  1097 .|\n				{}/* Ignore text inside POU! (including the '\n' character!)) */

  1098 }

  1099 

  1100 

  1101 	/* header_state -> (vardecl_list_state) */

  1102 	/* NOTE: This transition assumes that all POUs with code (Function, FB, and Program) will always contain

  1103 	 *       at least one VAR_XXX block.

  1104 	 *      How about functions that do not declare variables, and go directly to the body_state???

  1087 	 *       continue in the <vardecl_state> state, untill the end of the FUNCTION, FUNCTION_BLOCK

  1118 	 *       continue in the <vardecl_state> state, until the end of the FUNCTION, FUNCTION_BLOCK

  1134 VAR_ACCESS			unput_text(0); BEGIN(vardecl_list_state);

  1143 VAR_ACCESS			unput_text(0); /* printf("\nChanging to vardecl_list_state\n") */; BEGIN(vardecl_list_state);

  1150 END_FUNCTION			unput_text(0); BEGIN(INITIAL); 

  1159 END_FUNCTION			unput_text(0); BEGIN(INITIAL);

  1151 END_FUNCTION_BLOCK		unput_text(0); BEGIN(INITIAL); 

  1160 END_FUNCTION_BLOCK		unput_text(0); BEGIN(INITIAL);

  1152 END_PROGRAM			unput_text(0); BEGIN(INITIAL); 

  1161 END_PROGRAM			unput_text(0); BEGIN(INITIAL);

  1153 

  1162 

  1154 .				unput_text(0); yy_push_state(body_state); /* anything else, just change to body_state! */

  1163 .				unput_text(0); yy_push_state(body_state); //printf("\nChanging to body_state\n");/* anything else, just change to body_state! */

  1166 INITIAL_STEP			unput_text(0); BEGIN(sfc_state); 

  1175 {st_whitespace}			{/* In body state we do not process any tokens,

  1167 

  1176 				  * we simply store them for later processing!

  1168 {qualified_identifier}		unput_text(0); BEGIN(st_state); /* will always be followed by '[' for an array access, or ':=' as the left hand of an assignment statement */

  1177 				  * NOTE: all whitespace in the begining

  1169 {direct_variable_standard}	unput_text(0); BEGIN(st_state); /* will always be followed by ':=' as the left hand of an assignment statement */

  1178 				  * of body_state must be removed so we can

  1170 

  1179 				  * detect ':=' in the beginning of TRANSACTION

  1171 RETURN				unput_text(0); BEGIN(st_state);

  1180 				  * conditions preceded by whitespace.

  1172 IF				unput_text(0); BEGIN(st_state);

  1181 				  * => only add to bodystate_buffer when not in beginning.

  1173 CASE				unput_text(0); BEGIN(st_state);

  1182 				  */

  1174 FOR				unput_text(0); BEGIN(st_state);

  1183 				  if (!isempty_bodystate_buffer()) 

  1175 WHILE				unput_text(0); BEGIN(st_state);

  1184 				    append_bodystate_buffer(yytext); 

  1176 EXIT				unput_text(0); BEGIN(st_state);

  1185 				}

  1177 REPEAT				unput_text(0); BEGIN(st_state);

  1186 	/* 'INITIAL_STEP' always used in beginning of SFCs !! */

  1178 

  1187 INITIAL_STEP			{ if (isempty_bodystate_buffer())	{unput_text(0); BEGIN(sfc_state);}

  1179 	/* ':=' occurs only in transitions, and not Function or FB bodies! */

  1188 				  else					{append_bodystate_buffer(yytext);}

  1180 :=				unput_text(0); BEGIN(st_state);

  1189 				}

  1181 

  1190  

  1182 {identifier}	{int token = get_identifier_token(yytext);

  1191 	/* ':=', at the very beginning of a 'body', occurs only in transitions and not Function, FB, or Program bodies! */

  1183 		 if ((token == prev_declared_fb_name_token) || (token == prev_declared_variable_name_token)) {

  1192 :=				{ if (isempty_bodystate_buffer())	{unput_text(0); BEGIN(st_state);} /* We do _not_ return a start_ST_body_token here, as bison does not expect it! */

  1184 		   /* the code has a call to a function block OR has an assingment with a variable as the lvalue */

  1193 				  else				 	{append_bodystate_buffer(yytext);}

  1185 		   unput_text(0); BEGIN(st_state);

  1194 				}

  1186 		 } else

  1195  

  1187  		 if (token == prev_declared_derived_function_name_token) {

  1196 	/* check if ';' occurs before an END_FUNCTION, END_FUNCTION_BLOCK, END_PROGRAM or END_ACTION. (If true => we are parsing ST; If false => parsing IL). */

  1188 		   /* the code has a call to a function - must be IL */

  1197 END_ACTION			| /* execute the next rule's action, i.e. fall-through! */

  1189 		   unput_text(0); BEGIN(il_state);

  1198 END_FUNCTION			|

  1190 		 } else {

  1199 END_FUNCTION_BLOCK		|

  1191 		   /* Might be a lable in IL, or a bug in ST/IL code. We jump to IL */

  1200 END_PROGRAM			{ append_bodystate_buffer(yytext); unput_bodystate_buffer(); BEGIN(il_state); /*printf("returning start_IL_body_token\n");*/ return start_IL_body_token;}

  1192 		   unput_text(0); BEGIN(il_state);

  1201 .|\n				{ append_bodystate_buffer(yytext);

  1193 		 }

  1202 				  if (strcmp(yytext, ";") == 0)

  1194 		}

  1203 				    {unput_bodystate_buffer(); BEGIN(st_state); /*printf("returning start_ST_body_token\n");*/ return start_ST_body_token;}

  1195 

  1204 				}

  1196 .		unput_text(0); BEGIN(il_state); /* Don't know what it could be. This is most likely a bug. Let's just to a random state... */

  1205 	/* The following rules are not really necessary. They just make compilation faster in case the ST Statement List starts with one fot he following... */

  1206 RETURN				| /* execute the next rule's action, i.e. fall-through! */

  1207 IF				|

  1208 CASE				|

  1209 FOR				|

  1210 WHILE				|

  1211 EXIT				|

  1212 REPEAT				{ if (isempty_bodystate_buffer())	{unput_text(0); BEGIN(st_state); return start_ST_body_token;}

  1213 				  else				 	{append_bodystate_buffer(yytext);}

  1214 				}

  1215 

  1228 <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 */

  1246 <INITIAL,header_state,config_state,vardecl_list_state,vardecl_state,st_state,sfc_state,task_init_state,sfc_qualifier_state>{st_whitespace}	/* Eat any whitespace */

  1483 FUNCTION	return FUNCTION;	/* Keyword */

  1517 	/* Note: The following END_FUNCTION rule includes a BEGIN(INITIAL); command.

  1484 END_FUNCTION	return END_FUNCTION;	/* Keyword */

  1518 	 *       This is necessary in case the input program being parsed has syntax errors that force

  1485 VAR		return VAR;		/* Keyword */

  1519 	 *       flex's main state machine to never change to the il_state or the st_state

  1486 CONSTANT	return CONSTANT;	/* Keyword */

  1520 	 *       after changing to the body_state.

  1521 	 *       Ths BEGIN(INITIAL) command forces the flex state machine to re-synchronise with 

  1522 	 *       the input stream even in the presence of buggy code!

  1523 	 */

  1524 FUNCTION			return FUNCTION;			/* Keyword */

  1525 END_FUNCTION	BEGIN(INITIAL);	return END_FUNCTION;			/* Keyword */  /* see Note above */

  1526 VAR				return VAR;				/* Keyword */

  1527 CONSTANT			return CONSTANT;			/* Keyword */

  1492 FUNCTION_BLOCK		return FUNCTION_BLOCK;		/* Keyword */

  1533 	/* Note: The following END_FUNCTION_BLOCK rule includes a BEGIN(INITIAL); command.

  1493 END_FUNCTION_BLOCK	return END_FUNCTION_BLOCK;	/* Keyword */

  1534 	 *       This is necessary in case the input program being parsed has syntax errors that force

  1494 VAR_TEMP		return VAR_TEMP;		/* Keyword */

  1535 	 *       flex's main state machine to never change to the il_state or the st_state

  1495 VAR			return VAR;			/* Keyword */

  1536 	 *       after changing to the body_state.

  1496 NON_RETAIN		return NON_RETAIN;		/* Keyword */

  1537 	 *       Ths BEGIN(INITIAL) command forces the flex state machine to re-synchronise with 

  1497 END_VAR			return END_VAR;			/* Keyword */

  1538 	 *       the input stream even in the presence of buggy code!

  1539 	 */

  1540 FUNCTION_BLOCK				return FUNCTION_BLOCK;		/* Keyword */

  1541 END_FUNCTION_BLOCK	BEGIN(INITIAL);	return END_FUNCTION_BLOCK;	/* Keyword */  /* see Note above */

  1542 VAR_TEMP				return VAR_TEMP;		/* Keyword */

  1543 VAR					return VAR;			/* Keyword */

  1544 NON_RETAIN				return NON_RETAIN;		/* Keyword */

  1545 END_VAR					return END_VAR;			/* Keyword */

  1503 PROGRAM		return PROGRAM;			/* Keyword */

  1551 	/* Note: The following END_PROGRAM rule includes a BEGIN(INITIAL); command.

  1504 END_PROGRAM	return END_PROGRAM;		/* Keyword */

  1552 	 *       This is necessary in case the input program being parsed has syntax errors that force

  1553 	 *       flex's main state machine to never change to the il_state or the st_state

  1554 	 *       after changing to the body_state.

  1555 	 *       Ths BEGIN(INITIAL) command forces the flex state machine to re-synchronise with 

  1556 	 *       the input stream even in the presence of buggy code!

  1557 	 */

  1558 PROGRAM				return PROGRAM;				/* Keyword */

  1559 END_PROGRAM	BEGIN(INITIAL);	return END_PROGRAM;			/* Keyword */  /* see Note above */

  1552 CONFIGURATION		return CONFIGURATION;		/* Keyword */

  1607 	/* Note: The following END_CONFIGURATION rule will never get to be used, as we have

  1553 END_CONFIGURATION	return END_CONFIGURATION;	/* Keyword */

  1608 	 *       another identical rule above (closer to the rules handling the transitions

  1554 TASK			return TASK;			/* Keyword */

  1609 	 *       of the main state machine) that will always execute before this one.

  1555 RESOURCE		return RESOURCE;		/* Keyword */

  1610 	 * Note: The following END_CONFIGURATION rule includes a BEGIN(INITIAL); command.

  1556 ON			return ON;			/* Keyword */

  1611 	 *       This is nt strictly necessary, but I place it here so it follwos the same

  1557 END_RESOURCE		return END_RESOURCE;		/* Keyword */

  1612 	 *       pattern used in END_FUNCTION, END_PROGRAM, and END_FUNCTION_BLOCK

  1558 VAR_CONFIG		return VAR_CONFIG;		/* Keyword */

  1613 	 */

  1559 VAR_ACCESS		return VAR_ACCESS;		/* Keyword */

  1614 CONFIGURATION				return CONFIGURATION;		/* Keyword */

  1560 END_VAR			return END_VAR;			/* Keyword */

  1615 END_CONFIGURATION	BEGIN(INITIAL); return END_CONFIGURATION;	/* Keyword */   /* see 2 Notes above! */

  1561 WITH			return WITH;			/* Keyword */

  1616 TASK					return TASK;			/* Keyword */

  1562 PROGRAM			return PROGRAM;			/* Keyword */

  1617 RESOURCE				return RESOURCE;		/* Keyword */

  1563 RETAIN			return RETAIN;			/* Keyword */

  1618 ON					return ON;			/* Keyword */

  1564 NON_RETAIN		return NON_RETAIN;		/* Keyword */

  1619 END_RESOURCE				return END_RESOURCE;		/* Keyword */

  1565 READ_WRITE		return READ_WRITE;		/* Keyword */

  1620 VAR_CONFIG				return VAR_CONFIG;		/* Keyword */

  1566 READ_ONLY		return READ_ONLY;		/* Keyword */

  1621 VAR_ACCESS				return VAR_ACCESS;		/* Keyword */

  1622 END_VAR					return END_VAR;			/* Keyword */

  1623 WITH					return WITH;			/* Keyword */

  1624 PROGRAM					return PROGRAM;			/* Keyword */

  1625 RETAIN					return RETAIN;			/* Keyword */

  1626 NON_RETAIN				return NON_RETAIN;		/* Keyword */

  1627 READ_WRITE				return READ_WRITE;		/* Keyword */

  1628 READ_ONLY				return READ_ONLY;		/* Keyword */