matiec: comparison stage4/generate_c/generate_c

equal deleted inserted replaced

-:b826f13c260e
+:7a11f9e9e703
 * a C source program equivalent to the IL and ST, or SFC
 * code.
 */
+#include "../../util/strdup.hh"
 /***********************************************************************/
 /***********************************************************************/
 /***********************************************************************/
 /***********************************************************************/
 symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);
 if (!search_expression_type->is_same_type(left_type, right_type))
 ERROR;
 if (search_expression_type->is_time_type(left_type) ||
 search_expression_type->is_string_type(left_type))
-return print_compare_function("__eq_", left_type, symbol->l_exp, symbol->r_exp);
+return print_compare_function("EQ_", left_type, symbol->l_exp, symbol->r_exp);
 return print_binary_expression(symbol->l_exp, symbol->r_exp, " == ");
 }
 void *visit(notequ_expression_c *symbol) {
 symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);
 symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);
 if (!search_expression_type->is_same_type(left_type, right_type))
 ERROR;
 if (search_expression_type->is_time_type(left_type) ||
 search_expression_type->is_string_type(left_type))
-return print_compare_function("__ne_", left_type, symbol->l_exp, symbol->r_exp);
+return print_compare_function("NE_", left_type, symbol->l_exp, symbol->r_exp);
 return print_binary_expression(symbol->l_exp, symbol->r_exp, " != ");
 }
 void *visit(lt_expression_c *symbol) {
 symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);
 symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);
 if (!search_expression_type->is_same_type(left_type, right_type))
 ERROR;
 if (search_expression_type->is_time_type(left_type) ||
 search_expression_type->is_string_type(left_type))
-return print_compare_function("__lt_", left_type, symbol->l_exp, symbol->r_exp);
+return print_compare_function("LT_", left_type, symbol->l_exp, symbol->r_exp);
 if (!search_base_type.type_is_enumerated(left_type))
 return print_binary_expression(symbol->l_exp, symbol->r_exp, " < ");
 ERROR;
 return NULL;
 }
 symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);
 if (!search_expression_type->is_same_type(left_type, right_type))
 ERROR;
 if (search_expression_type->is_time_type(left_type) ||
 search_expression_type->is_string_type(left_type))
-return print_compare_function("__gt_", left_type, symbol->l_exp, symbol->r_exp);
+return print_compare_function("GT_", left_type, symbol->l_exp, symbol->r_exp);
 if (!search_base_type.type_is_enumerated(left_type))
 return print_binary_expression(symbol->l_exp, symbol->r_exp, " > ");
 ERROR;
 return NULL;
 }
 symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);
 if (!search_expression_type->is_same_type(left_type, right_type))
 ERROR;
 if (search_expression_type->is_time_type(left_type) ||
 search_expression_type->is_string_type(left_type))
-return print_compare_function("__le_", left_type, symbol->l_exp, symbol->r_exp);
+return print_compare_function("LE_", left_type, symbol->l_exp, symbol->r_exp);
 if (!search_base_type.type_is_enumerated(left_type))
 return print_binary_expression(symbol->l_exp, symbol->r_exp, " <= ");
 ERROR;
 return NULL;
 }
 symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);
 if (!search_expression_type->is_same_type(left_type, right_type))
 ERROR;
 if (search_expression_type->is_time_type(left_type) ||
 search_expression_type->is_string_type(left_type))
-return print_compare_function("__ge_", left_type, symbol->l_exp, symbol->r_exp);
+return print_compare_function("GE_", left_type, symbol->l_exp, symbol->r_exp);
 if (!search_base_type.type_is_enumerated(left_type))
 return print_binary_expression(symbol->l_exp, symbol->r_exp, " >= ");
 ERROR;
 return NULL;
 }
 symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);
 	symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);
 	if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||
 (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||
 (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)))
-return print_binary_function("__TIME_ADD", symbol->l_exp, symbol->r_exp);
+return print_binary_function("__time_add", symbol->l_exp, symbol->r_exp);
 if (!search_expression_type->is_same_type(left_type, right_type))
 ERROR;
 if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type))
 return print_binary_expression(symbol->l_exp, symbol->r_exp, " + ");
 ERROR;
 (typeid(*left_type) == typeid(date_type_name_c) && typeid(*right_type) == typeid(date_type_name_c)) ||
 (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||
 (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(tod_type_name_c)) ||
 (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||
 (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(dt_type_name_c)))
-return print_binary_function("__TIME_SUB", symbol->l_exp, symbol->r_exp);
+return print_binary_function("__time_sub", symbol->l_exp, symbol->r_exp);
 if (!search_expression_type->is_same_type(left_type, right_type))
 ERROR;
 if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type))
 return print_binary_expression(symbol->l_exp, symbol->r_exp, " - ");
 ERROR;
 void *visit(mul_expression_c *symbol) {
 symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);
 symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);
 if ((typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_integer_type(right_type)) ||
 (typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_real_type(right_type)))
-return print_binary_function("__TIME_MUL", symbol->l_exp, symbol->r_exp);
+return print_binary_function("__time_mul", symbol->l_exp, symbol->r_exp);
 if (!search_expression_type->is_same_type(left_type, right_type))
 ERROR;
 if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type))
 return print_binary_expression(symbol->l_exp, symbol->r_exp, " * ");
 ERROR;
 void *visit(div_expression_c *symbol) {
 symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);
 symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);
 if ((typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_integer_type(right_type)) ||
 (typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_real_type(right_type)))
-return print_binary_function("__TIME_DIV", symbol->l_exp, symbol->r_exp);
+return print_binary_function("__time_div", symbol->l_exp, symbol->r_exp);
 if (!search_expression_type->is_same_type(left_type, right_type))
 ERROR;
 if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type))
 return print_binary_expression(symbol->l_exp, symbol->r_exp, " / ");
 ERROR;
 void *visit(power_expression_c *symbol) {
 symbol_c *left_type = search_expression_type->get_type(symbol->l_exp);
 symbol_c *right_type = search_expression_type->get_type(symbol->r_exp);
 if (search_expression_type->is_real_type(left_type) && search_expression_type->is_num_type(right_type)) {
-	s4o.print("__expt_LREAL((BOOL)__BOOL_LITERAL(TRUE),\n");
+	s4o.print("EXPT__LREAL__LREAL__LREAL((BOOL)__BOOL_LITERAL(TRUE),\n");
 	s4o.indent_right();
 	s4o.print(s4o.indent_spaces + "NULL,\n");
 	s4o.print(s4o.indent_spaces + "(LREAL)(");
 	symbol->l_exp->accept(*this);
 	s4o.print("),\n");
 	symbol->r_exp->accept(*this);
 	s4o.print("))");
 return NULL;
 }
 ERROR;
+return NULL;
 }
 void *visit(neg_expression_c *symbol) {
 return print_unary_expression(symbol->exp, " -");
 }
 ERROR;
 return NULL;
 }
 void *visit(function_invocation_c *symbol) {
-symbol_c* function_type_prefix = NULL;
 symbol_c* function_name = NULL;
-symbol_c* function_type_suffix = NULL;
 DECLARE_PARAM_LIST()
 symbol_c *parameter_assignment_list = NULL;
 if (NULL != symbol->   formal_param_list) parameter_assignment_list = symbol->   formal_param_list;
 if (NULL != symbol->nonformal_param_list) parameter_assignment_list = symbol->nonformal_param_list;
 if (NULL == parameter_assignment_list) ERROR;
 function_call_param_iterator_c function_call_param_iterator(symbol);
-function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name);
+function_declaration_c *f_decl = (function_declaration_c *)symbol->called_function_declaration;
-if (f_decl == function_symtable.end_value()) {
+if (f_decl == NULL) ERROR;
-/* The function called is not in the symtable, so we test if it is a
-* standard function defined in standard */
+function_name = symbol->function_name;
-function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);
+/* loop through each function parameter, find the value we should pass
-if (current_function_type == function_none) ERROR;
+* to it, and then output the c equivalent...
+*/
-symbol_c *function_return_type = search_expression_type->get_type(symbol);
+function_param_iterator_c fp_iterator(f_decl);
+identifier_c *param_name;
-int nb_param = ((list_c *)parameter_assignment_list)->n;
+/* flag to cirreclty handle calls to extensible standard functions (i.e. functions with variable number of input parameters) */
+bool found_first_extensible_parameter = false;
-symbol_c *en_param_name = (symbol_c *)(new identifier_c("EN"));
+for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
-/* Get the value from EN param */
+if (fp_iterator.is_extensible_param() && (!found_first_extensible_parameter)) {
-symbol_c *EN_param_value = function_call_param_iterator.search_f(en_param_name);
+/* We are calling an extensible function. Before passing the extensible
-if (EN_param_value == NULL)
+* parameters, we must add a dummy paramater value to tell the called
-EN_param_value = (symbol_c*)(new boolean_literal_c((symbol_c*)(new bool_type_name_c()), new boolean_true_c()));
+* function how many extensible parameters we will be passing.
-else
+*
-nb_param --;
+* Note that stage 3 has already determined the number of extensible
-ADD_PARAM_LIST(en_param_name, EN_param_value, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_in)
+* paramters, and stored that info in the abstract syntax tree. We simply
+* re-use that value.
-symbol_c *eno_param_name = (symbol_c *)(new identifier_c("ENO"));
+*/
-/* Get the value from ENO param */
+/* NOTE: we are not freeing the malloc'd memory. This is not really a bug.
-symbol_c *ENO_param_value = function_call_param_iterator.search_f(eno_param_name);
+*       Since we are writing a compiler, which runs to termination quickly,
-if (ENO_param_value != NULL)
+*       we can consider this as just memory required for the compilation process
-nb_param --;
+*       that will be free'd when the program terminates.
-ADD_PARAM_LIST(eno_param_name, ENO_param_value, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_out)
+*/
+char *tmp = (char *)malloc(32); /* enough space for a call with 10^31 (larger than 2^64) input parameters! */
-#include "st_code_gen.c"
+if (tmp == NULL) ERROR;
+int res = snprintf(tmp, 32, "%d", symbol->extensible_param_count);
-}
+if ((res >= 32) || (res < 0)) ERROR;
-else {
+identifier_c *param_value = new identifier_c(tmp);
-	function_name = symbol->function_name;
+uint_type_name_c *param_type  = new uint_type_name_c();
+identifier_c *param_name = new identifier_c("");
-	/* loop through each function parameter, find the value we should pass
+ADD_PARAM_LIST(param_name, param_value, param_type, function_param_iterator_c::direction_in)
-* to it, and then output the c equivalent...
+found_first_extensible_parameter = true;
+}
+if (fp_iterator.is_extensible_param()) {
+/* since we are handling an extensible parameter, we must add the index to the
+* parameter name so we can go looking for the value passed to the correct
+* extended parameter (e.g. IN1, IN2, IN3, IN4, ...)
+*/
+char *tmp = (char *)malloc(32); /* enough space for a call with 10^31 (larger than 2^64) input parameters! */
+int res = snprintf(tmp, 32, "%d", fp_iterator.extensible_param_index());
+if ((res >= 32) || (res < 0)) ERROR;
+param_name = new identifier_c(strdup2(param_name->value, tmp));
+if (param_name->value == NULL) ERROR;
+}
+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();
+symbol_c *param_value = NULL;
+/* Get the value from a foo(<param_name> = <param_value>) style call */
+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) && !fp_iterator.is_en_eno_param_implicit()) {
+param_value = function_call_param_iterator.next_nf();
+}
+/* if no more parameter values in function call, and the current parameter
+* of the function declaration is an extensible parameter, we
+* have reached the end, and should simply jump out of the for loop.
 */
-function_param_iterator_c fp_iterator(f_decl);
+if ((param_value == NULL) && (fp_iterator.is_extensible_param())) {
-identifier_c *param_name;
+break;
-for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
+}
-symbol_c *param_type = fp_iterator.param_type();
+if ((param_value == NULL) && (param_direction == function_param_iterator_c::direction_in)) {
-if (param_type == NULL) ERROR;
+/* No value given for parameter, so we must use the default... */
+/* First check whether default value specified in function declaration...*/
-function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
+param_value = fp_iterator.default_value();
+}
-/* Get the value from a foo(<param_name> = <param_value>) style call */
-symbol_c *param_value = function_call_param_iterator.search_f(param_name);
+ADD_PARAM_LIST(param_name, param_value, param_type, param_direction)
+} /* for(...) */
-/* Get the value from a foo(<param_value>) style call */
+// symbol->parameter_assignment->accept(*this);
-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_name, param_value, param_type, param_direction)
-} /* for(...) */
-// symbol->parameter_assignment->accept(*this);
-}
 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 ||
+if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||
-		   PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&
+PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&
-		  PARAM_VALUE != NULL) {
+PARAM_VALUE != NULL) {
-	    if (!has_output_params) {
+has_output_params = true;
-		  has_output_params = true;
+}
-		}
+}
-	  }
+}
-}
-}
+/* Check whether we are calling an overloaded function! */
+/* (fdecl_mutiplicity==2)  => calling overloaded function */
-if (function_type_prefix != NULL) {
+int fdecl_mutiplicity =  function_symtable.multiplicity(symbol->function_name);
-s4o.print("(");
+if (fdecl_mutiplicity == 0) ERROR;
-search_expression_type->default_literal_type(function_type_prefix)->accept(*this);
-s4o.print(")");
-}
-if (function_type_suffix != NULL) {
-	function_type_suffix = search_expression_type->default_literal_type(function_type_suffix);
-}
 if (has_output_params) {
-	fcall_number++;
+fcall_number++;
-	s4o.print("__");
+s4o.print("__");
 fbname->accept(*this);
 s4o.print("_");
 function_name->accept(*this);
-if (function_type_suffix != NULL)
+if (fdecl_mutiplicity == 2) {
-function_type_suffix->accept(*this);
+/* function being called is overloaded! */
+s4o.print("__");
+print_function_parameter_data_types_c overloaded_func_suf(&s4o);
+f_decl->accept(overloaded_func_suf);
+}
 s4o.print_integer(fcall_number);
 }
 else {
 function_name->accept(*this);
-if (function_type_suffix != NULL)
+if (fdecl_mutiplicity == 2) {
-function_type_suffix->accept(*this);
+/* function being called is overloaded! */
+s4o.print("__");
+print_function_parameter_data_types_c overloaded_func_suf(&s4o);
+f_decl->accept(overloaded_func_suf);
+}
 }
 s4o.print("(");
 s4o.indent_right();
 int nb_param = 0;
 /* Get the value from a foo(<param_name> = <param_value>) style call */
 symbol_c *param_value = function_call_param_iterator.search_f(param_name);
 /* Get the value from a foo(<param_value>) style call */
-if (param_value == NULL)
+/* When using the informal invocation style, user can not pass values to EN or ENO parameters if these
+* were implicitly defined!
+*/
+if ((param_value == NULL) && !fp_iterator.is_en_eno_param_implicit())
 param_value = function_call_param_iterator.next_nf();
 symbol_c *param_type = fp_iterator.param_type();
 if (param_type == NULL) ERROR;
 /* Get the value from a foo(<param_name> = <param_value>) style call */
 symbol_c *param_value = function_call_param_iterator.search_f(param_name);
 /* Get the value from a foo(<param_value>) style call */
-if (param_value == NULL)
+/* When using the informal invocation style, user can not pass values to EN or ENO parameters if these
+* were implicitly defined!
+*/
+if ((param_value == NULL) && !fp_iterator.is_en_eno_param_implicit())
 param_value = function_call_param_iterator.next_nf();
 /* now output the value assignment */
 if (param_value != NULL)
 if ((param_direction == function_param_iterator_c::direction_out) ||

changeset 375	7a11f9e9e703
parent 349	b826f13c260e
parent 373	7af3b6bed2dd
child 376	7dcbd8418771