matiec: comparison stage3/constant

equal deleted inserted replaced

-:cd7fa00ad774
+:544ff4dff04f
 #endif
 constant_folding_c::constant_folding_c(symbol_c *symbol) {
+fixed_init_value_ = false;
+function_pou_ = false;
 error_count = 0;
 warning_found = false;
 current_display_error_level = 0;
 il_operand = NULL;
 search_varfb_instance_type = NULL;
 }
 /*********************/
 /* B 1.4 - Variables */
 /*********************/
-#if DO_CONSTANT_PROPAGATION__
+// #if DO_CONSTANT_PROPAGATION__
 void *constant_folding_c::visit(symbolic_variable_c *symbol) {
 	std::string varName = get_var_name_c::get_name(symbol->var_name)->value;
 	if (values.count(varName) > 0)
 		symbol->const_value = values[varName];
 	return NULL;
 }
-#endif  // DO_CONSTANT_PROPAGATION__
+// #endif  // DO_CONSTANT_PROPAGATION__
 void *constant_folding_c::visit(symbolic_constant_c *symbol) {
 	std::string varName = get_var_name_c::get_name(symbol->var_name)->value;
 	if (values.count(varName) > 0)
 		symbol->const_value = values[varName];
 if (NULL != global_var_decl) global_var_decl->const_value = init_value->const_value;  // Note that each external variable declaration has its own datatype specification, so we can set this symbol's const_value too!
 return 0;
 }
+void *constant_folding_c::handle_var_decl(symbol_c *var_list, bool fixed_init_value) {
+fixed_init_value_ = fixed_init_value;
+var_list->accept(*this);
+fixed_init_value_ = false;
+return NULL;
+}
 void *constant_folding_c::handle_var_list_decl(symbol_c *var_list, symbol_c *type_decl) {
 type_decl->accept(*this);  // Do constant folding of the initial value, and literals in subranges! (we will probably be doing this multiple times for the same init value, but this is safe as the cvalue is idem-potent)
 symbol_c *init_value = type_initial_value_c::get(type_decl);
 if (NULL == init_value)   return NULL; // this is probably a FB datatype, for which no initial value exists! Do nothing and return.
 for (int i = 0; i < list->n; i++) {
 token_c *var_name = dynamic_cast<token_c *>(list->elements[i]);
 if (NULL == var_name) {
 if (NULL != dynamic_cast<extensible_input_parameter_c *>(list->elements[i]))
 continue; // this is an extensible standard function. Ignore this variable, and continue!
-debug_c::print(list->elements[i]);
+// debug_c::print(list->elements[i]);
 ERROR;
 }
-std::string varName = var_name->value;
-values[varName] = init_value->const_value;
 list->elements[i]->const_value = init_value->const_value;
+if (fixed_init_value_) {
+std::string varName = var_name->value;
+values[varName] = init_value->const_value;
+}
 }
 return NULL;
 }
-/* | var1_list ',' variable_name */
-//SYM_LIST(var1_list_c)           // Not needed!
 //SYM_REF0(constant_option_c)     // Not needed!
 //SYM_REF0(retain_option_c)       // Not needed!
 //SYM_REF0(non_retain_option_c)   // Not needed!
+bool constant_folding_c::is_constant(symbol_c *option) {return (NULL != dynamic_cast<constant_option_c *>(option));}
+bool constant_folding_c::is_retain  (symbol_c *option) {return (NULL != dynamic_cast<  retain_option_c *>(option));}
+/* | var1_list ',' variable_name */
+//SYM_LIST(var1_list_c)           // Not needed!
 /* spec_init is one of the following...
 *    simple_spec_init_c *
 *    subrange_spec_init_c *
 *    enumerated_spec_init_c *
 void *constant_folding_c::visit(var1_init_decl_c *symbol) {return handle_var_list_decl(symbol->var1_list, symbol->spec_init);}
 /* | [var1_list ','] variable_name integer '..' */
 /* NOTE: This is an extension to the standard!!! */
 //SYM_REF2(extensible_input_parameter_c, var_name, first_index)          // Not needed!
 /* var1_list ':' array_spec_init */
 //SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)            // We do not yet handle arrays!
 /*  var1_list ':' initialized_structure */
 //SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure) // We do not yet handle structures!
 /* fb_name_list ':' function_block_type_name ASSIGN structure_initialization */
 //SYM_REF2(fb_name_decl_c, fb_name_list, fb_spec_init)                   // We do not yet handle FBs!
 /* fb_name_list ',' fb_name */
 //SYM_LIST(fb_name_list_c)                                               // Not needed!
 /* VAR_INPUT [option] input_declaration_list END_VAR */
 /* option -> the RETAIN/NON_RETAIN/<NULL> directive... */
 //SYM_REF3(input_declarations_c, option, input_declaration_list, method) // Not needed since we inherit from iterator_visitor_c!
-// NOTE: Input variables can take any initial value, so we can not set the const_value annotation => we do NOT call handle_var_list_decl() !!!
+// NOTE: Input variables can take any initial value, so we can not set the const_value annotation => we set fixed_init_value to false !!!
 //       We must still visit it iteratively, to set the const_value of all literals in the type declarations.
+void *constant_folding_c::visit(input_declarations_c *symbol) {return handle_var_decl(symbol->input_declaration_list, false);}
 /* helper symbol for input_declarations */
 //SYM_LIST(input_declaration_list_c)                                     // Not needed!
 /* VAR_OUTPUT [RETAIN | NON_RETAIN] var_init_decl_list END_VAR */
 /* option -> may be NULL ! */
-//SYM_REF3(output_declarations_c, option, var_init_decl_list, method)    // Not needed since we inherit from iterator_visitor_c!
+//SYM_REF3(output_declarations_c, option, var_init_decl_list, method)
+void *constant_folding_c::visit(output_declarations_c *symbol) {return handle_var_decl(symbol->var_init_decl_list, !is_retain(symbol->option) && function_pou_);}
 /*  VAR_IN_OUT var_declaration_list END_VAR */
-//SYM_REF1(input_output_declarations_c, var_declaration_list)            // Not needed since we inherit from iterator_visitor_c!
+//SYM_REF1(input_output_declarations_c, var_declaration_list)
-// NOTE: Input variables can take any initial value, so we can not set the const_value annotation => we do NOT call handle_var_list_decl() !!!
+// NOTE: Input variables can take any initial value, so we can not set the const_value annotation => we set fixed_init_value to false !!!
 //       We must still visit it iteratively, to set the const_value of all literals in the type declarations.
+void *constant_folding_c::visit(input_output_declarations_c *symbol) {return handle_var_decl(symbol->var_declaration_list, false);}
 /* helper symbol for input_output_declarations */
 /* var_declaration_list var_declaration ';' */
 //SYM_LIST(var_declaration_list_c)                                       // Not needed since we inherit from iterator_visitor_c!
 /*  var1_list ':' array_specification */
 //SYM_REF2(array_var_declaration_c, var1_list, array_specification)      // We do not yet handle arrays!
 /*  var1_list ':' structure_type_name */
 //SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name) // We do not yet handle structures!
 /* VAR [CONSTANT] var_init_decl_list END_VAR */
 /* option -> may be NULL ! */
-//SYM_REF2(var_declarations_c, option, var_init_decl_list)               // Not needed: we inherit from iterator_c
+//SYM_REF2(var_declarations_c, option, var_init_decl_list)
+void *constant_folding_c::visit(var_declarations_c *symbol) {return handle_var_decl(symbol->var_init_decl_list, false);}
 /*  VAR RETAIN var_init_decl_list END_VAR */
 //SYM_REF1(retentive_var_declarations_c, var_init_decl_list)             // Not needed since we inherit from iterator_visitor_c!
-// NOTE: Retentive variables can take any initial value, so we can not set the const_value annotation => we do NOT call handle_var_list_decl() !!!
+// NOTE: Retentive variables can take any initial value, so we can not set the const_value annotation => we set fixed_init_value to false !!!
 //       We must still visit it iteratively, to set the const_value of all literals in the type declarations.
+void *constant_folding_c::visit(retentive_var_declarations_c *symbol) {return handle_var_decl(symbol->var_init_decl_list, false);}
+#if 0
+// TODO
 /*  VAR [CONSTANT|RETAIN|NON_RETAIN] located_var_decl_list END_VAR */
 /* option -> may be NULL ! */
-#if 0
-// TODO
 SYM_REF2(located_var_declarations_c, option, located_var_decl_list)
 /* helper symbol for located_var_declarations */
 /* located_var_decl_list located_var_decl ';' */
 SYM_LIST(located_var_decl_list_c)
 /*  [variable_name] location ':' located_var_spec_init */
 #endif
 /*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */
 /* option -> may be NULL ! */
 // SYM_REF2(external_var_declarations_c, option, external_declaration_list)
-// void *constant_folding_c::visit(external_var_declarations_c *symbol) {} // Not needed: we inherit from iterator_c
+void *constant_folding_c::visit(external_var_declarations_c *symbol) {return handle_var_decl(symbol->external_declaration_list, is_constant(symbol->option));}
 /* helper symbol for external_var_declarations */
 /*| external_declaration_list external_declaration';' */
 // SYM_LIST(external_declaration_list_c)
 // void *constant_folding_c::visit(external_declaration_list_c *symbol) {} // Not needed: we inherit from iterator_c
 /*  global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */
 //SYM_REF2(external_declaration_c, global_var_name, specification)
 void *constant_folding_c::visit(external_declaration_c *symbol) {
 // Note that specification->const_value will have been set by handle_var_extern_global_pair, which is called from declaration_check_c
 symbol->global_var_name->const_value = symbol->specification->const_value;
-std::string varName = get_var_name_c::get_name(symbol->global_var_name)->value;
+if (fixed_init_value_) {
-values[varName] = symbol->specification->const_value;
+std::string varName = get_var_name_c::get_name(symbol->global_var_name)->value;
-// If the datatype specification is a subrange or array, do constant folding of all the literals in that type declaration...
+values[varName] = symbol->specification->const_value;
+}
+// If the datatype specification is a subrange or array, do constant folding of all the literals in that type declaration... (ex: literals in array subrange limits)
 symbol->specification->accept(*this);  // should never get to change the const_value of the symbol->specification symbol (only its children!).
 return NULL;
 }
 /* Visitors related to GLOBAL variables are not really needed,
 /* enumvalue_symtable is filled in by enum_declaration_check_c, during stage3 semantic verification, with a list of all enumerated constants declared inside this POU */
 //SYM_REF4(function_declaration_c, derived_function_name, type_name, var_declarations_list, function_body, enumvalue_symtable_t enumvalue_symtable;)
 void *constant_folding_c::visit(function_declaration_c *symbol) {
 	values.clear(); /* Clear global map */
 	/* Add initial value of all declared variables into Values map. */
+	function_pou_ = true;
 	symbol->var_declarations_list->accept(*this);
+	function_pou_ = false;
 	symbol->function_body->accept(*this);
 	return NULL;
 }
+/* intermediate helper symbol for
+* - function_declaration
+* - function_block_declaration
+* - program_declaration
+*/
+// SYM_LIST(var_declarations_list_c) // Not needed since we inherit from iterator_c
+/* option -> storage method, CONSTANT or <null> */
+// SYM_REF2(function_var_decls_c, option, decl_list)
+// NOTE: function_var_decls_c is only used inside Functions, so it is safe to call with fixed_init_value_ = true
+void *constant_folding_c::visit(function_var_decls_c *symbol) {return handle_var_decl(symbol->decl_list, true);}
+/* intermediate helper symbol for function_var_decls */
+// SYM_LIST(var2_init_decl_list_c) // Not needed since we inherit from iterator_c
 /*****************************/
 /* B 1.5.2 - Function Blocks */
 /*****************************/
 /* enumvalue_symtable is filled in by enum_declaration_check_c, during stage3 semantic verification, with a list of all enumerated constants declared inside this POU */
 //SYM_REF3(function_block_declaration_c, fblock_name, var_declarations, fblock_body, enumvalue_symtable_t enumvalue_symtable;)
 void *constant_folding_c::visit(function_block_declaration_c *symbol) {
 	values.clear(); /* Clear global map */
 	/* Add initial value of all declared variables into Values map. */
+	function_pou_ = false;
 	symbol->var_declarations->accept(*this);
 	symbol->fblock_body->accept(*this);
 	return NULL;
 }
+/*  VAR_TEMP temp_var_decl_list END_VAR */
+// SYM_REF1(temp_var_decls_c, var_decl_list)
+void *constant_folding_c::visit(temp_var_decls_c *symbol) {debug_c::print(symbol); return handle_var_decl(symbol->var_decl_list, true);}
+/* intermediate helper symbol for temp_var_decls */
+// SYM_LIST(temp_var_decls_list_c)
+/*  VAR NON_RETAIN var_init_decl_list END_VAR */
+// SYM_REF1(non_retentive_var_decls_c, var_decl_list)
+// NOTE: non_retentive_var_decls_c is only used inside FBs and Programs, so it is safe to call with fixed_init_value_ = false
+void *constant_folding_c::visit(non_retentive_var_decls_c *symbol) {debug_c::print(symbol); return handle_var_decl(symbol->var_decl_list, false);}
 /**********************/
 /* B 1.5.3 - Programs */
 /**********************/
 /*  PROGRAM program_type_name program_var_declarations_list function_block_body END_PROGRAM */
 //SYM_REF3(program_declaration_c, program_type_name, var_declarations, function_block_body, enumvalue_symtable_t enumvalue_symtable;)
 void *constant_folding_c::visit(program_declaration_c *symbol) {
 	values.clear(); /* Clear global map */
 	/* Add initial value of all declared variables into Values map. */
+	function_pou_ = false;
 	symbol->var_declarations->accept(*this);
 	symbol->function_block_body->accept(*this);
 	return NULL;
 }
 /* TODO: handle function invocations... */
 // void *fill_candidate_datatypes_c::visit(function_invocation_c *symbol) {}
-#if DO_CONSTANT_PROPAGATION__
 /*********************************/
 /* B 3.2.1 Assignment Statements */
 /*********************************/
 void *constant_folding_c::visit(assignment_statement_c *symbol) {
 	std::string varName;
 	symbol->r_exp->accept(*this);
+	symbol->l_exp->accept(*this); // if the lvalue has an array, do contant folding of the array indexes!
 	symbol->l_exp->const_value = symbol->r_exp->const_value;
 	varName = get_var_name_c::get_name(symbol->l_exp)->value;
 	values[varName] = symbol->l_exp->const_value;
+	return NULL;
-	return NULL;
+}
-}
+#if DO_CONSTANT_PROPAGATION__
 /********************************/
 /* B 3.2.3 Selection Statements */
 /********************************/
 void *constant_folding_c::visit(if_statement_c *symbol) {
 	map_values_t values_incoming;

changeset 967	544ff4dff04f
parent 965	c9eeb67ba939
child 968	649e03abbfc1