matiec: comparison stage4/generate_c/generate_c

equal deleted inserted replaced

-:90782e241346
+:d7d92b2f87e9
 class generate_c_il_c: public generate_c_typedecl_c, il_default_variable_visitor_c {
+public:
+typedef enum {
+expression_vg,
+assignment_vg,
+complextype_base_vg,
+complextype_suffix_vg,
+fparam_output_vg
+} variablegeneration_t;
 private:
 /* When compiling il code, it becomes necessary to determine the
 * data type of il operands. To do this, we must first find the
 * il operand's declaration, within the scope of the function block
 * or function currently being processed.
 * of the boolean data type to keep as a reference of the current
 * data type.
 * The following object is it...
 */
 bool_type_name_c bool_type;
+lint_type_name_c lint_type;
+lword_type_name_c lword_type;
+lreal_type_name_c lreal_type;
 /* the data type of the IL default variable... */
 #define IL_DEFVAR_T VAR_LEADER "IL_DEFVAR_T"
 /* The name of the IL default variable... */
 #define IL_DEFVAR   VAR_LEADER "IL_DEFVAR"
 search_varfb_instance_type_c *search_varfb_instance_type;
 search_base_type_c search_base_type;
-bool current_param_is_pointer;
+symbol_c* current_array_type;
+symbol_c* current_param_type;
+int fcall_number;
+symbol_c *fbname;
+variablegeneration_t wanted_variablegeneration;
 public:
-generate_c_il_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL)
+generate_c_il_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL)
 : generate_c_typedecl_c(s4o_ptr),
 default_variable_name(IL_DEFVAR, NULL),
 default_variable_back_name(IL_DEFVAR_BACK, NULL)
 {
 search_expression_type = new search_expression_type_c(scope);
 search_fb_instance_decl = new search_fb_instance_decl_c(scope);
 search_varfb_instance_type = new search_varfb_instance_type_c(scope);
 current_operand = NULL;
 current_operand_type = NULL;
 il_default_variable_init_value = NULL;
-current_param_is_pointer = false;
+current_array_type = NULL;
+current_param_type = NULL;
+fcall_number = 0;
+fbname = name;
+wanted_variablegeneration = expression_vg;
 this->set_variable_prefix(variable_prefix);
 }
 virtual ~generate_c_il_c(void) {
 delete search_fb_instance_decl;
 s4o.print(") ");
 }
 else {ERROR;}
 }
+void BYTE_operator_result_type(void) {
+if (search_expression_type->is_literal_integer_type(this->default_variable_name.current_type)) {
+if (search_expression_type->is_literal_integer_type(this->current_operand_type))
+this->default_variable_name.current_type = &(this->lword_type);
+else
+this->default_variable_name.current_type = this->current_operand_type;
+}
+else if (search_expression_type->is_literal_integer_type(this->current_operand_type))
+	  this->current_operand_type = this->default_variable_name.current_type;
+}
+void NUM_operator_result_type(void) {
+if (search_expression_type->is_literal_real_type(this->default_variable_name.current_type)) {
+if (search_expression_type->is_literal_integer_type(this->current_operand_type) ||
+search_expression_type->is_literal_real_type(this->current_operand_type))
+this->default_variable_name.current_type = &(this->lreal_type);
+else
+this->default_variable_name.current_type = this->current_operand_type;
+}
+else if (search_expression_type->is_literal_integer_type(this->default_variable_name.current_type)) {
+if (search_expression_type->is_literal_integer_type(this->current_operand_type))
+this->default_variable_name.current_type = &(this->lint_type);
+else if (search_expression_type->is_literal_real_type(this->current_operand_type))
+this->default_variable_name.current_type = &(this->lreal_type);
+else
+this->default_variable_name.current_type = this->current_operand_type;
+}
+else if (search_expression_type->is_literal_integer_type(this->current_operand_type) ||
+search_expression_type->is_literal_real_type(this->current_operand_type))
+this->current_operand_type = this->default_variable_name.current_type;
+}
+void *print_getter(symbol_c *symbol) {
+unsigned int vartype = search_varfb_instance_type->get_vartype(symbol);
+if (wanted_variablegeneration == fparam_output_vg) {
+	if (vartype == search_var_instance_decl_c::external_vt)
+s4o.print(GET_EXTERNAL_BY_REF);
+else if (vartype == search_var_instance_decl_c::located_vt)
+s4o.print(GET_LOCATED_BY_REF);
+else
+s4o.print(GET_VAR_BY_REF);
+}
+else {
+	if (vartype == search_var_instance_decl_c::external_vt)
+	  s4o.print(GET_EXTERNAL);
+	else if (vartype == search_var_instance_decl_c::located_vt)
+	  s4o.print(GET_LOCATED);
+	else
+	  s4o.print(GET_VAR);
+}
+s4o.print("(");
+variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration;
+wanted_variablegeneration = complextype_base_vg;
+symbol->accept(*this);
+if (search_varfb_instance_type->type_is_complex())
+s4o.print(",");
+wanted_variablegeneration = complextype_suffix_vg;
+symbol->accept(*this);
+s4o.print(")");
+wanted_variablegeneration = old_wanted_variablegeneration;
+return NULL;
+}
+void *print_setter(symbol_c* symbol,
+		symbol_c* type,
+		symbol_c* value,
+		symbol_c* fb_symbol = NULL,
+		symbol_c* fb_value = NULL,
+		bool negative = false) {
+unsigned int vartype = search_varfb_instance_type->get_vartype(symbol);
+if (vartype == search_var_instance_decl_c::external_vt) {
+symbolic_variable_c *variable = dynamic_cast<symbolic_variable_c *>(symbol);
+/* TODO Find a solution for forcing global complex variables */
+if (variable != NULL) {
+s4o.print(SET_EXTERNAL);
+s4o.print("(");
+variable->var_name->accept(*this);
+s4o.print(",");
+}
+else {
+s4o.print(SET_COMPLEX_EXTERNAL);
+s4o.print("(");
+}
+}
+else {
+if (vartype == search_var_instance_decl_c::located_vt)
+s4o.print(SET_LOCATED);
+else
+s4o.print(SET_VAR);
+s4o.print("(");
+}
+if (fb_symbol != NULL) {
+print_variable_prefix();
+fb_symbol->accept(*this);
+s4o.print(".");
+}
+else
+wanted_variablegeneration = complextype_base_vg;
+symbol->accept(*this);
+s4o.print(",");
+if (negative) {
+	    if (search_expression_type->is_bool_type(this->current_operand_type))
+		  s4o.print("!");
+	    else
+		  s4o.print("~");
+}
+wanted_variablegeneration = expression_vg;
+print_check_function(type, value, fb_value);
+if (search_varfb_instance_type->type_is_complex()) {
+s4o.print(",");
+wanted_variablegeneration = complextype_suffix_vg;
+symbol->accept(*this);
+}
+s4o.print(")");
+wanted_variablegeneration = expression_vg;
+return NULL;
+}
 public:
 void *visit(il_default_variable_c *symbol) {
 //s4o.print("il_default_variable_c VISITOR!!\n");
 symbol->var_name->accept(*this);
 if (NULL != symbol->current_type) {
 s4o.print(".");
-symbol->current_type->accept(*this);
+if (search_expression_type->is_literal_integer_type(symbol->current_type))
+this->lint_type.accept(*this);
+else if (search_expression_type->is_literal_real_type(this->default_variable_name.current_type))
+this->lreal_type.accept(*this);
+else
+symbol->current_type->accept(*this);
 s4o.print("var");
 }
 return NULL;
 }
 /*********************/
 /* B 1.4 - Variables */
 /*********************/
 void *visit(symbolic_variable_c *symbol) {
-unsigned int vartype = search_varfb_instance_type->get_vartype(symbol);
+unsigned int vartype;
-if (!current_param_is_pointer && (vartype == search_var_instance_decl_c::external_vt || vartype == search_var_instance_decl_c::located_vt)) {
+if (wanted_variablegeneration == complextype_base_vg)
-s4o.print("*(");
+	generate_c_base_c::visit(symbol);
-generate_c_base_c::visit(symbol);
+else if (wanted_variablegeneration == complextype_suffix_vg)
-s4o.print(")");
+	return NULL;
-}
+else if (this->is_variable_prefix_null()) {
-else if (current_param_is_pointer && vartype != search_var_instance_decl_c::external_vt && vartype != search_var_instance_decl_c::located_vt) {
+	vartype = search_varfb_instance_type->get_vartype(symbol);
-s4o.print("&(");
+if (wanted_variablegeneration == fparam_output_vg) {
-generate_c_base_c::visit(symbol);
+s4o.print("&(");
-s4o.print(")");
+generate_c_base_c::visit(symbol);
-}
+s4o.print(")");
-else {
+}
-generate_c_base_c::visit(symbol);
+else {
-}
+generate_c_base_c::visit(symbol);
+}
+}
+else
+print_getter(symbol);
 return NULL;
 }
 /********************************************/
 /* B.1.4.1   Directly Represented Variables */
 // direct_variable: direct_variable_token   {$$ = new direct_variable_c($1);};
 void *visit(direct_variable_c *symbol) {
 TRACE("direct_variable_c");
 /* Do not use print_token() as it will change everything into uppercase */
 if (strlen(symbol->value) == 0) ERROR;
-if (!current_param_is_pointer) {
+if (this->is_variable_prefix_null()) {
-s4o.print("*(");
+if (wanted_variablegeneration != fparam_output_vg)
+	  s4o.print("*(");
+}
+else {
+switch (wanted_variablegeneration) {
+case expression_vg:
+	    s4o.print(GET_LOCATED);
+	    s4o.print("(");
+	    break;
+case fparam_output_vg:
+s4o.print(GET_LOCATED_BY_REF);
+s4o.print("(");
+break;
+default:
+break;
+}
 }
 this->print_variable_prefix();
 s4o.printlocation(symbol->value + 1);
-if (!current_param_is_pointer) {
+if ((this->is_variable_prefix_null() && wanted_variablegeneration != fparam_output_vg) ||
+	  wanted_variablegeneration != assignment_vg)
 s4o.print(")");
-}
+return NULL;
-return NULL;
+}
-}
+/*************************************/
+/* B.1.4.2   Multi-element Variables */
+/*************************************/
+// SYM_REF2(structured_variable_c, record_variable, field_selector)
+void *visit(structured_variable_c *symbol) {
+TRACE("structured_variable_c");
+switch (wanted_variablegeneration) {
+case complextype_base_vg:
+symbol->record_variable->accept(*this);
+break;
+case complextype_suffix_vg:
+symbol->record_variable->accept(*this);
+s4o.print(".");
+symbol->field_selector->accept(*this);
+break;
+default:
+if (this->is_variable_prefix_null()) {
+	symbol->record_variable->accept(*this);
+	s4o.print(".");
+	symbol->field_selector->accept(*this);
+}
+else
+	print_getter(symbol);
+break;
+}
+return NULL;
+}
+/*  subscripted_variable '[' subscript_list ']' */
+//SYM_REF2(array_variable_c, subscripted_variable, subscript_list)
+void *visit(array_variable_c *symbol) {
+switch (wanted_variablegeneration) {
+case complextype_base_vg:
+symbol->subscripted_variable->accept(*this);
+break;
+case complextype_suffix_vg:
+symbol->subscripted_variable->accept(*this);
+current_array_type = search_varfb_instance_type->get_rawtype(symbol->subscripted_variable);
+if (current_array_type == NULL) ERROR;
+s4o.print(".table");
+symbol->subscript_list->accept(*this);
+current_array_type = NULL;
+break;
+default:
+if (this->is_variable_prefix_null()) {
+symbol->subscripted_variable->accept(*this);
+current_array_type = search_varfb_instance_type->get_rawtype(symbol->subscripted_variable);
+if (current_array_type == NULL) ERROR;
+s4o.print(".table");
+symbol->subscript_list->accept(*this);
+current_array_type = NULL;
+}
+else
+	print_getter(symbol);
+break;
+}
+return NULL;
+}
+/* subscript_list ',' subscript */
+void *visit(subscript_list_c *symbol) {
+for (int i =  0; i < symbol->n; i++) {
+s4o.print("[__");
+current_array_type->accept(*this);
+s4o.print("_TRANSIDX");
+print_integer(i);
+s4o.print("(");
+symbol->elements[i]->accept(*this);
+s4o.print(")]");
+}
+return NULL;
+}
+/******************************************/
+/* B 1.4.3 - Declaration & Initialisation */
+/******************************************/
+/* helper symbol for structure_initialization */
+/* structure_element_initialization_list ',' structure_element_initialization */
+void *visit(structure_element_initialization_list_c *symbol) {
+generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);
+structure_initialization->init_structure_default(this->current_param_type);
+structure_initialization->init_structure_values(symbol);
+delete structure_initialization;
+return NULL;
+}
+/* helper symbol for array_initialization */
+/* array_initial_elements_list ',' array_initial_elements */
+void *visit(array_initial_elements_list_c *symbol) {
+generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);
+array_initialization->init_array_size(this->current_param_type);
+array_initialization->init_array_values(symbol);
+delete array_initialization;
+return NULL;
+}
 /****************************************/
 /* B.2 - Language IL (Instruction List) */
 /****************************************/
 /***********************************/
 /* Declare the default variable, that will store the result of the IL operations... */
 s4o.print(s4o.indent_spaces);
 s4o.print(IL_DEFVAR_T);
 s4o.print(" ");
 this->default_variable_name.accept(*this);
-s4o.print(";\n\n");
+s4o.print(";\n");
+s4o.print(s4o.indent_spaces);
+print_backup_variable();
+s4o.print(".INTvar = 0;\n\n");
 print_list(symbol, s4o.indent_spaces, ";\n" + s4o.indent_spaces, ";\n");
+/* label not used by at least one goto result in a warning.
+* To work around this we introduce the useless goto
+* to humour the compiler...
+*/
+s4o.print("\n");
+s4o.print(s4o.indent_spaces);
+s4o.print("/* to humour the compiler, we insert a goto */\n");
+s4o.print(s4o.indent_spaces);
+s4o.print("goto ");
+s4o.print(END_LABEL);
+s4o.print(";\n");
 /* write the label marking the end of the code block */
 /* please see the comment before the RET_operator_c visitor for details... */
 s4o.print("\n");
 s4o.print(s4o.indent_spaces);
 /* | function_name [il_operand_list] */
 // SYM_REF2(il_function_call_c, function_name, il_operand_list)
 void *visit(il_function_call_c *symbol) {
-function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name);
 symbol_c* function_type_prefix = NULL;
 symbol_c* function_name = NULL;
 symbol_c* function_type_suffix = NULL;
-std::list<FUNCTION_PARAM> param_list;
+DECLARE_PARAM_LIST()
-FUNCTION_PARAM *param;
 symbol_c *param_data_type = default_variable_name.current_type;
 symbol_c *return_data_type = NULL;
+function_call_param_iterator_c function_call_param_iterator(symbol);
+function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name);
 if (f_decl == function_symtable.end_value()) {
 function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);
 if (current_function_type == function_none) ERROR;
 return_data_type = (symbol_c *)search_expression_type->compute_standard_function_il(symbol, param_data_type);
 if (NULL == return_data_type) ERROR;
-function_call_param_iterator_c function_call_param_iterator(symbol);
+symbol_c *en_param_name = (symbol_c *)(new identifier_c("EN"));
 /* Add the value from EN param */
-ADD_PARAM_LIST((symbol_c*)(new boolean_literal_c((symbol_c*)(new bool_type_name_c()), new boolean_true_c())),
+ADD_PARAM_LIST(en_param_name,
+(symbol_c*)(new boolean_literal_c((symbol_c*)(new bool_type_name_c()), new boolean_true_c())),
 (symbol_c*)(new bool_type_name_c()),
 function_param_iterator_c::direction_in)
+symbol_c *eno_param_name = (symbol_c *)(new identifier_c("ENO"));
 /* Add the value from ENO param */
-ADD_PARAM_LIST(NULL, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_out)
+ADD_PARAM_LIST(eno_param_name, NULL, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_out)
 int nb_param = 1;
 if (symbol->il_operand_list != NULL)
 nb_param += ((list_c *)symbol->il_operand_list)->n;
-#define search(x) search_f(x)
-#define next() next_nf()
-//     #define search_constant_type_c::constant_int_type_name  search_expression_type_c::integer
-#define constant_int_type_name  integer
 #include "il_code_gen.c"
-#undef constant_int_type_name
-//     #undef search_constant_type_c::constant_int_type_name
-#undef next
-#undef  search
 }
 else {
 /* determine the base data type returned by the function being called... */
 search_base_type_c search_base_type;
 * to it, and then output the c equivalent...
 */
 function_param_iterator_c fp_iterator(f_decl);
 identifier_c *param_name;
-function_call_param_iterator_c function_call_param_iterator(symbol);
 for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
 symbol_c *param_type = fp_iterator.param_type();
 if (param_type == NULL) ERROR;
 function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
 */
 if (param_value == NULL)
 param_value = function_call_param_iterator.search_f(param_name);
 /* Get the value from a foo(<param_value>) style call */
-if (param_value == NULL)
+if (param_value == NULL) {
 param_value = function_call_param_iterator.next_nf();
+if (param_value != NULL && fp_iterator.is_en_eno_param_implicit()) ERROR;
+}
 if (param_value == NULL && param_direction == function_param_iterator_c::direction_in) {
 /* No value given for parameter, so we must use the default... */
 /* First check whether default value specified in function declaration...*/
 param_value = fp_iterator.default_value();
 }
-ADD_PARAM_LIST(param_value, param_type, fp_iterator.param_direction())
+ADD_PARAM_LIST(param_name, param_value, param_type, fp_iterator.param_direction())
 } /* for(...) */
 }
+if (function_call_param_iterator.next_nf() != NULL) ERROR;
+bool has_output_params = false;
+if (!this->is_variable_prefix_null()) {
+PARAM_LIST_ITERATOR() {
+	  if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||
+		   PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&
+		  PARAM_VALUE != NULL) {
+	    if (!has_output_params) {
+		  has_output_params = true;
+		}
+	  }
+}
+}
 default_variable_name.current_type = return_data_type;
 this->default_variable_name.accept(*this);
 default_variable_name.current_type = param_data_type;
 s4o.print(" = ");
 if (function_type_prefix != NULL) {
 s4o.print("(");
 function_type_prefix->accept(*this);
 s4o.print(")");
 }
-if (function_name != NULL)
+if (has_output_params) {
+	fcall_number++;
+	s4o.print("__");
+fbname->accept(*this);
+s4o.print("_");
 function_name->accept(*this);
-if (function_type_suffix != NULL)
+s4o.print_integer(fcall_number);
-function_type_suffix->accept(*this);
+}
+else {
+if (function_name != NULL)
+	  function_name->accept(*this);
+if (function_type_suffix != NULL)
+	  function_type_suffix->accept(*this);
+}
 s4o.print("(");
 s4o.indent_right();
-std::list<FUNCTION_PARAM>::iterator pt;
+int nb_param = 0;
-for(pt = param_list.begin(); pt != param_list.end(); pt++) {
+PARAM_LIST_ITERATOR() {
-if (pt != param_list.begin())
+symbol_c *param_value = PARAM_VALUE;
-s4o.print(",\n"+s4o.indent_spaces);
+current_param_type = PARAM_TYPE;
-symbol_c *param_value = pt->param_value;
-symbol_c *param_type = pt->param_type;
-switch (pt->param_direction) {
+switch (PARAM_DIRECTION) {
 case function_param_iterator_c::direction_in:
+	if (nb_param > 0)
+	  s4o.print(",\n"+s4o.indent_spaces);
 if (param_value == NULL) {
 /* If not, get the default value of this variable's type */
-param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance());
+param_value = (symbol_c *)current_param_type->accept(*type_initial_value_c::instance());
 }
 if (param_value == NULL) ERROR;
-if (search_base_type.type_is_subrange(param_type)) {
+s4o.print("(");
-s4o.print("__CHECK_");
+if (search_expression_type->is_literal_integer_type(current_param_type))
-param_type->accept(*this);
+search_expression_type->lint_type_name.accept(*this);
-s4o.print("(");
+else if (search_expression_type->is_literal_real_type(current_param_type))
-}
+search_expression_type->lreal_type_name.accept(*this);
-param_value->accept(*this);
+else
-if (search_base_type.type_is_subrange(param_type))
+current_param_type->accept(*this);
 s4o.print(")");
+print_check_function(current_param_type, param_value);
+nb_param++;
 break;
 case function_param_iterator_c::direction_out:
 case function_param_iterator_c::direction_inout:
-current_param_is_pointer = true;
+	if (!has_output_params) {
-if (param_value == NULL) {
+if (nb_param > 0)
-s4o.print("NULL");
+		s4o.print(",\n"+s4o.indent_spaces);
-} else {
+		  if (param_value == NULL) {
-param_value->accept(*this);
+		    s4o.print("NULL");
-}
+		  } else {
-current_param_is_pointer = false;
+		    wanted_variablegeneration = fparam_output_vg;
+		    param_value->accept(*this);
+		    wanted_variablegeneration = expression_vg;
+		  }
+		  nb_param++;
+	}
 break;
 case function_param_iterator_c::direction_extref:
 /* TODO! */
 ERROR;
 break;
 } /* switch */
 }
+if (has_output_params) {
+if (nb_param > 0)
+	  s4o.print(",\n"+s4o.indent_spaces);
+s4o.print(FB_FUNCTION_PARAM);
+}
 s4o.print(")");
 /* the data type returned by the function, and stored in the il default variable... */
 default_variable_name.current_type = return_data_type;
+CLEAR_PARAM_LIST()
 return NULL;
 }
 /* | il_expr_operator '(' [il_operand] eol_list [simple_instr_list] ')' */
 /* now output the value assignment */
 if (param_value != NULL)
 if ((param_direction == function_param_iterator_c::direction_in) ||
 (param_direction == function_param_iterator_c::direction_inout)) {
-symbol->fb_name->accept(*this);
+	if (this->is_variable_prefix_null()) {
-s4o.print(".");
+	  symbol->fb_name->accept(*this);
-param_name->accept(*this);
+s4o.print(".");
-s4o.print(" = ");
+param_name->accept(*this);
-if (search_base_type.type_is_subrange(param_type)) {
+s4o.print(" = ");
-s4o.print("__CHECK_");
+print_check_function(param_type, param_value);
-param_type->accept(*this);
+	}
-s4o.print("(");
+else {
+print_setter(param_name, param_type, param_value, symbol->fb_name);
 }
-param_value->accept(*this);
-if (search_base_type.type_is_subrange(param_type))
-s4o.print(")");
 s4o.print(";\n" + s4o.indent_spaces);
 }
 } /* for(...) */
 /* now call the function... */
 function_block_type_name->accept(*this);
 s4o.print(FB_FUNCTION_SUFFIX);
 s4o.print("(&");
+print_variable_prefix();
 symbol->fb_name->accept(*this);
 s4o.print(")");
 /* loop through each function parameter, find the variable to which
 * we should atribute the value of all output or inoutput parameters.
 /* now output the value assignment */
 if (param_value != NULL)
 if ((param_direction == function_param_iterator_c::direction_out) ||
 (param_direction == function_param_iterator_c::direction_inout)) {
-symbol_c *param_type = search_varfb_instance_type->get_type(param_value, false);
+symbol_c *param_type = search_varfb_instance_type->get_rawtype(param_value);
+s4o.print(";\n" + s4o.indent_spaces);
-s4o.print(";\n"+ s4o.indent_spaces);
+if (this->is_variable_prefix_null()) {
 param_value->accept(*this);
-s4o.print(" = ");
+		  s4o.print(" = ");
-if (search_base_type.type_is_subrange(param_type)) {
+		  print_check_function(param_type, param_name, symbol->fb_name);
-s4o.print("__CHECK_");
+		}
-param_type->accept(*this);
+		else {
-s4o.print("(");
+		  print_setter(param_value, param_type, param_name, NULL, symbol->fb_name);
-}
+		}
-symbol->fb_name->accept(*this);
-s4o.print(".");
-param_name->accept(*this);
-if (search_base_type.type_is_subrange(param_type))
-s4o.print(")");
 }
 } /* for(...) */
 s4o.print(";\n");
 s4o.indent_left();
 /* | function_name '(' eol_list [il_param_list] ')' */
 // SYM_REF2(il_formal_funct_call_c, function_name, il_param_list)
 void *visit(il_formal_funct_call_c *symbol) {
-function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name);
 symbol_c* function_type_prefix = NULL;
 symbol_c* function_name = NULL;
 symbol_c* function_type_suffix = NULL;
-std::list<FUNCTION_PARAM> param_list;
+DECLARE_PARAM_LIST()
-FUNCTION_PARAM *param;
 symbol_c *return_data_type = NULL;
+function_call_param_iterator_c function_call_param_iterator(symbol);
+function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name);
 if (f_decl == function_symtable.end_value()) {
 function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);
 if (current_function_type == function_none) ERROR;
 return_data_type = (symbol_c *)search_expression_type->compute_standard_function_default(NULL, symbol);
 if (NULL == return_data_type) ERROR;
-function_call_param_iterator_c function_call_param_iterator(symbol);
 int nb_param = 0;
 if (symbol->il_param_list != NULL)
 nb_param += ((list_c *)symbol->il_param_list)->n;
-identifier_c en_param_name("EN");
+symbol_c *en_param_name = (symbol_c *)(new identifier_c("EN"));
 /* Get the value from EN param */
-symbol_c *EN_param_value = function_call_param_iterator.search_f(&en_param_name);
+symbol_c *EN_param_value = function_call_param_iterator.search_f(en_param_name);
 if (EN_param_value == NULL)
 EN_param_value = (symbol_c*)(new boolean_literal_c((symbol_c*)(new bool_type_name_c()), new boolean_true_c()));
 else
 nb_param --;
-ADD_PARAM_LIST(EN_param_value, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_in)
+ADD_PARAM_LIST(en_param_name, EN_param_value, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_in)
-identifier_c eno_param_name("EN0");
+symbol_c *eno_param_name = (symbol_c *)(new identifier_c("ENO"));
 /* Get the value from ENO param */
-symbol_c *ENO_param_value = function_call_param_iterator.search_f(&eno_param_name);
+symbol_c *ENO_param_value = function_call_param_iterator.search_f(eno_param_name);
 if (ENO_param_value != NULL)
 nb_param --;
-ADD_PARAM_LIST(ENO_param_value, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_out)
+ADD_PARAM_LIST(eno_param_name, ENO_param_value, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_out)
-#define search(x) search_f(x)
-#define next() next_nf()
-//     #define search_constant_type_c::constant_int_type_name  search_expression_type_c::integer
-#define constant_int_type_name  integer
 #include "st_code_gen.c"
-#undef constant_int_type_name
-//     #undef search_constant_type_c::constant_int_type_name
-#undef next
-#undef  search
 }
 else {
 /* determine the base data type returned by the function being called... */
 search_base_type_c search_base_type;
 * to it, and then output the c equivalent...
 */
 function_param_iterator_c fp_iterator(f_decl);
 identifier_c *param_name;
-function_call_param_iterator_c function_call_param_iterator(symbol);
 for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
 symbol_c *param_type = fp_iterator.param_type();
 if (param_type == NULL) ERROR;
 function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
 * it will always return NULL.
 * We leave it in in case we later decide to merge this part of the code together
 * with the function calling code in generate_c_st_c, which does require
 * the following line...
 */
-if (param_value == NULL)
+if (param_value == NULL) {
 param_value = function_call_param_iterator.next_nf();
+if (param_value != NULL && fp_iterator.is_en_eno_param_implicit()) ERROR;
+}
 if (param_value == NULL) {
 /* No value given for parameter, so we must use the default... */
 /* First check whether default value specified in function declaration...*/
 param_value = fp_iterator.default_value();
 }
-ADD_PARAM_LIST(param_value, param_type, fp_iterator.param_direction())
+ADD_PARAM_LIST(param_name, param_value, param_type, fp_iterator.param_direction())
 }
 }
+if (function_call_param_iterator.next_nf() != NULL) ERROR;
+bool has_output_params = false;
+if (!this->is_variable_prefix_null()) {
+PARAM_LIST_ITERATOR() {
+	  if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||
+		   PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&
+		  PARAM_VALUE != NULL) {
+	    if (!has_output_params) {
+		  has_output_params = true;
+		}
+	  }
+}
+}
 default_variable_name.current_type = return_data_type;
 this->default_variable_name.accept(*this);
 s4o.print(" = ");
 if (function_type_prefix != NULL) {
 s4o.print("(");
 function_type_prefix->accept(*this);
 s4o.print(")");
 }
-if (function_name != NULL)
+if (has_output_params) {
+	fcall_number++;
+	s4o.print("__");
+fbname->accept(*this);
+s4o.print("_");
 function_name->accept(*this);
-if (function_type_suffix != NULL)
+s4o.print_integer(fcall_number);
-function_type_suffix->accept(*this);
+}
+else {
+if (function_name != NULL)
+function_name->accept(*this);
+if (function_type_suffix != NULL)
+function_type_suffix->accept(*this);
+}
 s4o.print("(");
 s4o.indent_right();
-std::list<FUNCTION_PARAM>::iterator pt;
+int nb_param = 0;
-for(pt = param_list.begin(); pt != param_list.end(); pt++) {
+PARAM_LIST_ITERATOR() {
-if (pt != param_list.begin())
+	symbol_c *param_value = PARAM_VALUE;
-s4o.print(",\n"+s4o.indent_spaces);
+	current_param_type = PARAM_TYPE;
-symbol_c *param_value = pt->param_value;
-symbol_c *param_type = pt->param_type;
-switch (pt->param_direction) {
+switch (PARAM_DIRECTION) {
 case function_param_iterator_c::direction_in:
-if (param_value == NULL) {
+	if (nb_param > 0)
+	  s4o.print(",\n"+s4o.indent_spaces);
+	if (param_value == NULL) {
 /* If not, get the default value of this variable's type */
-param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance());
+param_value = (symbol_c *)current_param_type->accept(*type_initial_value_c::instance());
 }
 if (param_value == NULL) ERROR;
-if (search_base_type.type_is_subrange(param_type)) {
+s4o.print("(");
-s4o.print("__CHECK_");
+if (search_expression_type->is_literal_integer_type(current_param_type))
-param_type->accept(*this);
+search_expression_type->lint_type_name.accept(*this);
-s4o.print("(");
+else if (search_expression_type->is_literal_real_type(current_param_type))
-}
+search_expression_type->lreal_type_name.accept(*this);
-param_value->accept(*this);
+else
-if (search_base_type.type_is_subrange(param_type))
+current_param_type->accept(*this);
 s4o.print(")");
-	      break;
+print_check_function(current_param_type, param_value);
+		nb_param++;
+break;
 case function_param_iterator_c::direction_out:
 case function_param_iterator_c::direction_inout:
-current_param_is_pointer = true;
+	if (!has_output_params) {
-if (param_value == NULL) {
+if (nb_param > 0)
-s4o.print("NULL");
+	s4o.print(",\n"+s4o.indent_spaces);
-} else {
+		  if (param_value == NULL) {
-param_value->accept(*this);
+		    s4o.print("NULL");
-}
+		  } else {
-current_param_is_pointer = false;
+		    wanted_variablegeneration = fparam_output_vg;
-	      break;
+		    param_value->accept(*this);
+		    wanted_variablegeneration = expression_vg;
+		  }
+	}
+	    break;
 case function_param_iterator_c::direction_extref:
 /* TODO! */
 ERROR;
 	      break;
 } /* switch */
 } /* for(...) */
+if (has_output_params) {
+if (nb_param > 0)
+s4o.print(",\n"+s4o.indent_spaces);
+s4o.print(FB_FUNCTION_PARAM);
+}
 // symbol->parameter_assignment->accept(*this);
 s4o.print(")");
 /* the data type returned by the function, and stored in the il default variable... */
+CLEAR_PARAM_LIST()
 return NULL;
 }
 /* | il_operand_list ',' il_operand */
 this->current_operand);
 return NULL;
 }
 void *visit(ST_operator_c *symbol)	{
-symbol_c *operand_type = search_varfb_instance_type->get_type(this->current_operand, false);
+symbol_c *operand_type = search_varfb_instance_type->get_rawtype(this->current_operand);
+if (search_expression_type->is_literal_integer_type(this->default_variable_name.current_type) ||
-this->current_operand->accept(*this);
+	  search_expression_type->is_literal_real_type(this->default_variable_name.current_type))
-s4o.print(" = ");
+this->default_variable_name.current_type = this->current_operand_type;
-if (search_base_type.type_is_subrange(operand_type)) {
+if (this->is_variable_prefix_null()) {
-s4o.print("__CHECK_");
+this->current_operand->accept(*this);
-operand_type->accept(*this);
+s4o.print(" = ");
-s4o.print("(");
+print_check_function(operand_type, (symbol_c*)&(this->default_variable_name));
 }
-this->default_variable_name.accept(*this);
+else {
-if (search_base_type.type_is_subrange(operand_type))
+	print_setter(this->current_operand, operand_type, (symbol_c*)&(this->default_variable_name));
-s4o.print(")");
+}
-/* the data type resulting from this operation is unchamged. */
+/* the data type resulting from this operation is unchanged. */
 return NULL;
 }
 void *visit(STN_operator_c *symbol)	{
-symbol_c *operand_type = search_varfb_instance_type->get_type(this->current_operand, false);
+symbol_c *operand_type = search_varfb_instance_type->get_rawtype(this->current_operand);
+if (search_expression_type->is_literal_integer_type(this->default_variable_name.current_type))
-this->current_operand->accept(*this);
+	this->default_variable_name.current_type = this->current_operand_type;
-s4o.print(" = ");
-if (search_base_type.type_is_subrange(operand_type)) {
+if (this->is_variable_prefix_null()) {
-s4o.print("__CHECK_");
+this->current_operand->accept(*this);
-operand_type->accept(*this);
+s4o.print(" = ");
-s4o.print("(");
+if (search_expression_type->is_bool_type(this->current_operand_type))
-}
+s4o.print("!");
-if (search_expression_type->is_bool_type(this->current_operand_type))
+else
-s4o.print("!");
+	  s4o.print("~");
-else
+this->default_variable_name.accept(*this);
-s4o.print("~");
+}
-this->default_variable_name.accept(*this);
+else {
-if (search_base_type.type_is_subrange(operand_type))
+	print_setter(this->current_operand, operand_type, (symbol_c*)&(this->default_variable_name), NULL, NULL, true);
-s4o.print(")");
+}
-/* the data type resulting from this operation is unchamged. */
+/* the data type resulting from this operation is unchanged. */
 return NULL;
 }
 void *visit(NOT_operator_c *symbol)	{
 if ((NULL != this->current_operand) || (NULL != this->current_operand_type)) ERROR;
 void *visit(S_operator_c *symbol)	{
 if ((NULL == this->current_operand) || (NULL == this->current_operand_type)) ERROR;
 C_modifier();
 this->current_operand->accept(*this);
-s4o.print(search_expression_type->is_bool_type(this->current_operand_type)?" = true":" = 1");
+s4o.print(" = __");
+if (search_expression_type->is_bool_type(this->current_operand_type))
+s4o.print("BOOL_LITERAL(TRUE)");
+else if (search_expression_type->is_integer_type(this->current_operand_type)) {
+this->current_operand_type->accept(*this);
+s4o.print("_LITERAL(1)");
+}
+else
+ERROR;
 /* the data type resulting from this operation is unchanged! */
 return NULL;
 }
 void *visit(R_operator_c *symbol)	{
 if ((NULL == this->current_operand) || (NULL == this->current_operand_type)) ERROR;
 C_modifier();
 this->current_operand->accept(*this);
-s4o.print(search_expression_type->is_bool_type(this->current_operand_type)?" = false":" = 0");
+s4o.print(" = __");
+if (search_expression_type->is_bool_type(this->current_operand_type))
+s4o.print("BOOL_LITERAL(FALSE)");
+else if (search_expression_type->is_integer_type(this->current_operand_type)) {
+this->current_operand_type->accept(*this);
+s4o.print("_LITERAL(0)");
+}
+else
+ERROR;
 /* the data type resulting from this operation is unchanged! */
 return NULL;
 }
 void *visit(S1_operator_c *symbol)	{return XXX_CAL_operator("S1", this->current_operand);}
 void *visit(PT_operator_c *symbol)	{return XXX_CAL_operator("PT", this->current_operand);}
 void *visit(AND_operator_c *symbol)	{
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-XXX_operator(&(this->default_variable_name), " &= ", this->current_operand);
+	BYTE_operator_result_type();
+	XXX_operator(&(this->default_variable_name), " &= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
 void *visit(OR_operator_c *symbol)	{
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-XXX_operator(&(this->default_variable_name), " |= ", this->current_operand);
+	BYTE_operator_result_type();
+	XXX_operator(&(this->default_variable_name), " |= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 return NULL;
 }
 void *visit(XOR_operator_c *symbol)	{
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-// '^' is a bit by bit exclusive OR !! Also seems to work with boolean types!
+	BYTE_operator_result_type();
+	// '^' is a bit by bit exclusive OR !! Also seems to work with boolean types!
 XXX_operator(&(this->default_variable_name), " ^= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 else {ERROR;}
 }
 void *visit(ANDN_operator_c *symbol)	{
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-XXX_operator(&(this->default_variable_name),
+	BYTE_operator_result_type();
+	XXX_operator(&(this->default_variable_name),
 search_expression_type->is_bool_type(this->current_operand_type)?" &= !":" &= ~",
 this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 }
 void *visit(ORN_operator_c *symbol)	{
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-XXX_operator(&(this->default_variable_name),
+	BYTE_operator_result_type();
+	XXX_operator(&(this->default_variable_name),
 search_expression_type->is_bool_type(this->current_operand_type)?" |= !":" |= ~",
 this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 }
 void *visit(XORN_operator_c *symbol)	{
 if (search_expression_type->is_binary_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-XXX_operator(&(this->default_variable_name),
+	BYTE_operator_result_type();
+	XXX_operator(&(this->default_variable_name),
 // bit by bit exclusive OR !! Also seems to work with boolean types!
 search_expression_type->is_bool_type(this->current_operand_type)?" ^= !":" ^= ~",
 this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 this->default_variable_name.current_type = this->current_operand_type;
 return NULL;
 }
 if (search_expression_type->is_num_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-XXX_operator(&(this->default_variable_name), " += ", this->current_operand);
+	NUM_operator_result_type();
+	XXX_operator(&(this->default_variable_name), " += ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 return NULL;
 }
 ERROR;
 this->default_variable_name.current_type = this->current_operand_type;
 return NULL;
 }
 if (search_expression_type->is_num_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-XXX_operator(&(this->default_variable_name), " -= ", this->current_operand);
+	NUM_operator_result_type();
+	XXX_operator(&(this->default_variable_name), " -= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 return NULL;
 }
 ERROR;
 /* the data type resulting from this operation... */
 return NULL;
 }
 if (search_expression_type->is_num_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
+	NUM_operator_result_type();
 XXX_operator(&(this->default_variable_name), " *= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 return NULL;
 }
 /* the data type resulting from this operation... */
 return NULL;
 }
 if (search_expression_type->is_num_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-XXX_operator(&(this->default_variable_name), " /= ", this->current_operand);
+	NUM_operator_result_type();
+	XXX_operator(&(this->default_variable_name), " /= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 ERROR;
 return NULL;
 }
 void *visit(MOD_operator_c *symbol)	{
 if (search_expression_type->is_num_type(this->default_variable_name.current_type) &&
 search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) {
-XXX_operator(&(this->default_variable_name), " %= ", this->current_operand);
+	NUM_operator_result_type();
+	XXX_operator(&(this->default_variable_name), " %= ", this->current_operand);
 /* the data type resulting from this operation... */
 this->default_variable_name.current_type = this->current_operand_type;
 }
 ERROR;
 return NULL;

changeset 258	d7d92b2f87e9
parent 240	f78fa87bb4cb
child 279	c0453b7f99df