matiec: comparison stage4/generate_c/generate_c

equal deleted inserted replaced

-:b826f13c260e
+:7a11f9e9e703
 while ((function_call = fc_iterator.next()) != NULL) {
 	function_call->accept(*this);
 }
 }
 void generate_inline(symbol_c *function_name,
 symbol_c *function_type_prefix,
 symbol_c *function_type_suffix,
-std::list<FUNCTION_PARAM*> param_list) {
+std::list<FUNCTION_PARAM*> param_list,
+function_declaration_c *f_decl = NULL) {
 std::list<FUNCTION_PARAM*>::iterator pt;
 fcall_number++;
 function_type_prefix = search_expression_type->default_literal_type(function_type_prefix);
 if (function_type_suffix) {
 function_type_prefix->accept(*this);
 s4o.print(" __");
 fbname->accept(*this);
 s4o.print("_");
 function_name->accept(*this);
+if (f_decl != NULL) {
+printf("generate_inline(): calling print_function_parameter_data_types_c !!!!!!!!!!!!!!!!!!!!!!\n");
+print_function_parameter_data_types_c overloaded_func_suf(&s4o);
+f_decl->accept(overloaded_func_suf);
+}
 if (function_type_suffix) {
-	function_type_suffix->accept(*this);
+function_type_suffix->accept(*this);
 }
 s4o.print_integer(fcall_number);
 s4o.print("(");
 s4o.indent_right();
 PARAM_NAME->accept(*this);
 s4o.print(",\n" + s4o.indent_spaces);
 }
 }
 fbname->accept(*this);
-	  s4o.print(" *");
+s4o.print(" *");
-	  s4o.print(FB_FUNCTION_PARAM);
+s4o.print(FB_FUNCTION_PARAM);
-	  s4o.indent_left();
+s4o.indent_left();
-	  s4o.print(")\n" + s4o.indent_spaces);
+s4o.print(")\n" + s4o.indent_spaces);
-	  s4o.print("{\n");
+s4o.print("{\n");
 s4o.indent_right();
 s4o.print(s4o.indent_spaces);
 function_type_prefix->accept(*this);
 s4o.print(" "),
 s4o.print(INLINE_RESULT_TEMP_VAR);
 s4o.print(";\n");
-	  PARAM_LIST_ITERATOR() {
+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) {
-		  s4o.print(s4o.indent_spaces);
+s4o.print(s4o.indent_spaces);
-		  PARAM_TYPE->accept(*this);
+PARAM_TYPE->accept(*this);
 s4o.print(" ");
 s4o.print(TEMP_VAR);
 PARAM_NAME->accept(*this);
 s4o.print(" = ");
 print_check_function(PARAM_TYPE, PARAM_VALUE);
 s4o.print(";\n");
-		}
+}
-	  }
+}
-	  s4o.print(s4o.indent_spaces + INLINE_RESULT_TEMP_VAR),
+s4o.print(s4o.indent_spaces + INLINE_RESULT_TEMP_VAR),
-			  s4o.print(" = ");
+s4o.print(" = ");
-	  function_name->accept(*this);
+function_name->accept(*this);
-	  if (function_type_suffix)
+if (f_decl != NULL) {
+printf("generate_inline(): calling print_function_parameter_data_types_c !!!!!!!!!!!!!!!!!!!!!!\n");
+print_function_parameter_data_types_c overloaded_func_suf(&s4o);
+f_decl->accept(overloaded_func_suf);
+}
+if (function_type_suffix)
 function_type_suffix->accept(*this);
-	  s4o.print("(");
+s4o.print("(");
-	  s4o.indent_right();
+s4o.indent_right();
-	  PARAM_LIST_ITERATOR() {
+PARAM_LIST_ITERATOR() {
-		if (pt != param_list.begin())
+if (pt != param_list.begin())
-		  s4o.print(",\n" + s4o.indent_spaces);
+s4o.print(",\n" + s4o.indent_spaces);
-		if (PARAM_DIRECTION == function_param_iterator_c::direction_in)
+if (PARAM_DIRECTION == function_param_iterator_c::direction_in)
-		  PARAM_NAME->accept(*this);
+PARAM_NAME->accept(*this);
-		else if (PARAM_VALUE != NULL){
+else if (PARAM_VALUE != NULL){
 s4o.print("&");
 s4o.print(TEMP_VAR);
 PARAM_NAME->accept(*this);
-}
+} else {
-		else {
+s4o.print("NULL");
-		  s4o.print("NULL");
+}
-		}
+}
-	  }
+s4o.print(");\n");
-	  s4o.print(");\n");
+s4o.indent_left();
-	  s4o.indent_left();
+PARAM_LIST_ITERATOR() {
-	  PARAM_LIST_ITERATOR() {
 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) {
 s4o.print(s4o.indent_spaces);
 print_setter(PARAM_VALUE, PARAM_TYPE, PARAM_NAME);
 s4o.print(";\n");
-		}
+}
-	  }
+}
-	  s4o.print(s4o.indent_spaces + "return ");
+s4o.print(s4o.indent_spaces + "return ");
-	  s4o.print(INLINE_RESULT_TEMP_VAR);
+s4o.print(INLINE_RESULT_TEMP_VAR);
-	  s4o.print(";\n");
+s4o.print(";\n");
 s4o.indent_left();
 s4o.print(s4o.indent_spaces + "}\n\n");
 }
 return NULL;
 }
 void *visit(il_function_call_c *symbol) {
 symbol_c* function_type_prefix = NULL;
 symbol_c* function_name = NULL;
 symbol_c* function_type_suffix = NULL;
 DECLARE_PARAM_LIST()
 symbol_c *param_data_type = default_variable_name.current_type;
 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;
-function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);
-if (current_function_type == function_none) ERROR;
+/* determine the base data type returned by the function being called... */
+search_base_type_c search_base_type;
-function_type_prefix = (symbol_c *)search_expression_type->compute_standard_function_il(symbol, param_data_type);
+function_type_prefix = (symbol_c *)f_decl->type_name->accept(search_base_type);
-symbol_c *en_param_name = (symbol_c *)(new identifier_c("EN"));
+function_name = symbol->function_name;
-/* Add the value from EN param */
-ADD_PARAM_LIST(en_param_name,
+/* loop through each function parameter, find the value we should pass
-(symbol_c*)(new boolean_literal_c((symbol_c*)(new bool_type_name_c()), new boolean_true_c())),
+* to it, and then output the c equivalent...
-(symbol_c*)(new bool_type_name_c()),
+*/
-function_param_iterator_c::direction_in)
+function_param_iterator_c fp_iterator(f_decl);
-symbol_c *eno_param_name = (symbol_c *)(new identifier_c("ENO"));
+identifier_c *param_name;
-/* Add the value from ENO param */
+/* flag to remember whether we have already used the value stored in the default variable to pass to the first parameter */
-ADD_PARAM_LIST(eno_param_name, NULL, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_out)
+bool used_defvar = false;
+/* flag to cirreclty handle calls to extensible standard functions (i.e. functions with variable number of input parameters) */
-int nb_param = 1;
+bool found_first_extensible_parameter = false;
-if (symbol->il_operand_list != NULL)
+for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
-nb_param += ((list_c *)symbol->il_operand_list)->n;
+if (fp_iterator.is_extensible_param() && (!found_first_extensible_parameter)) {
+/* We are calling an extensible function. Before passing the extensible
-#include "il_code_gen.c"
+* parameters, we must add a dummy paramater value to tell the called
+* function how many extensible parameters we will be passing.
-}
+*
-	  else {
+* Note that stage 3 has already determined the number of extensible
-		function_name = symbol->function_name;
+* paramters, and stored that info in the abstract syntax tree. We simply
+* re-use that value.
-		/* determine the base data type returned by the function being called... */
+*/
-		search_base_type_c search_base_type;
+/* NOTE: we are not freeing the malloc'd memory. This is not really a bug.
-		function_type_prefix = (symbol_c *)f_decl->type_name->accept(search_base_type);
+*       Since we are writing a compiler, which runs to termination quickly,
+*       we can consider this as just memory required for the compilation process
-		/* loop through each function parameter, find the value we should pass
+*       that will be free'd when the program terminates.
-		 * to it, and then output the c equivalent...
+*/
-		 */
+char *tmp = (char *)malloc(32); /* enough space for a call with 10^31 (larger than 2^64) input parameters! */
+if (tmp == NULL) ERROR;
-		function_param_iterator_c fp_iterator(f_decl);
+int res = snprintf(tmp, 32, "%d", symbol->extensible_param_count);
-		identifier_c *param_name;
+if ((res >= 32) || (res < 0)) ERROR;
-		for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
+identifier_c *param_value = new identifier_c(tmp);
-		  symbol_c *param_type = fp_iterator.param_type();
+uint_type_name_c *param_type  = new uint_type_name_c();
-		  if (param_type == NULL) ERROR;
+identifier_c *param_name = new identifier_c("");
+ADD_PARAM_LIST(param_name, param_value, param_type, function_param_iterator_c::direction_in)
-		  function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
+found_first_extensible_parameter = true;
+}
-		  symbol_c *param_value = NULL;
+symbol_c *param_type = fp_iterator.param_type();
-		  /* if it is the first parameter, semantics specifies that we should
+if (param_type == NULL) ERROR;
-		   * get the value off the IL default variable!
-		   */
+function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
-		  if (1 == i)
-		    param_value = &this->default_variable_name;
+symbol_c *param_value = NULL;
-		  /* Get the value from a foo(<param_name> = <param_value>) style call */
+/* Get the value from a foo(<param_name> = <param_value>) style call */
-		  /* NOTE: the following line of code is not required in this case, but it doesn't
+/* NOTE: the following line of code is not required in this case, but it doesn't
-		   * harm to leave it in, as in the case of a non-formal syntax function call,
+* harm to leave it in, as in the case of a non-formal syntax function call,
-		   * it will always return NULL.
+* it will always return NULL.
-		   * We leave it in in case we later decide to merge this part of the code together
+* 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
+* with the function calling code in generate_c_st_c, which does require
-		   * the following line...
+* the following line...
-		   */
+*/
-		  if (param_value == NULL)
+if (param_value == NULL)
-			param_value = function_call_param_iterator.search_f(param_name);
+param_value = function_call_param_iterator.search_f(param_name);
-		  /* Get the value from a foo(<param_value>) style call */
+/* if it is the first parameter in a non-formal function call (which is the
-if (param_value == NULL) {
+* case being handled!), semantics specifies that we should
-param_value = function_call_param_iterator.next_nf();
+* get the value off the IL default variable!
-if (param_value != NULL && fp_iterator.is_en_eno_param_implicit()) ERROR;
+*
-}
+* However, if the parameter is an implicitly defined EN or ENO parameter, we should not
+* use the default variable as a source of data to pass to those parameters!
-		  if (param_value == NULL && param_direction == function_param_iterator_c::direction_in) {
+*/
-			/* No value given for parameter, so we must use the default... */
+if ((param_value == NULL) && (!used_defvar) && !fp_iterator.is_en_eno_param_implicit()) {
-			/* First check whether default value specified in function declaration...*/
+param_value = &this->default_variable_name;
-			param_value = fp_iterator.default_value();
+used_defvar = true;
-		  }
+}
-		  ADD_PARAM_LIST(param_name, param_value, param_type, fp_iterator.param_direction())
+/* Get the value from a foo(<param_value>) style call */
-		} /* for(...) */
+if ((param_value == NULL) && !fp_iterator.is_en_eno_param_implicit()) {
-	  }
+param_value = function_call_param_iterator.next_nf();
+}
-	  if (function_call_param_iterator.next_nf() != NULL) ERROR;
+/* 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.
+*/
+if ((param_value == NULL) && (fp_iterator.is_extensible_param())) {
+break;
+}
+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, fp_iterator.param_direction())
+} /* for(...) */
+if (function_call_param_iterator.next_nf() != NULL) ERROR;
 if (NULL == function_type_prefix) ERROR;
 bool has_output_params = false;
 PARAM_LIST_ITERATOR() {
 PARAM_VALUE != NULL) {
 has_output_params = true;
 }
 }
+/* Check whether we are calling an overloaded function! */
+/* (fdecl_mutiplicity==2)  => calling overloaded function */
+int fdecl_mutiplicity =  function_symtable.multiplicity(symbol->function_name);
+if (fdecl_mutiplicity == 0) ERROR;
+if (fdecl_mutiplicity == 1)
+/* function being called is NOT overloaded! */
+f_decl = NULL;
 if (has_output_params)
-generate_inline(function_name, function_type_prefix, function_type_suffix, param_list);
+generate_inline(function_name, function_type_prefix, function_type_suffix, param_list, f_decl);
 CLEAR_PARAM_LIST()
 /* the data type resulting from this operation... */
 default_variable_name.current_type = function_type_prefix;
 symbol_c* function_type_suffix = NULL;
 DECLARE_PARAM_LIST()
 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;
-function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);
-if (current_function_type == function_none) ERROR;
+/* determine the base data type returned by the function being called... */
+search_base_type_c search_base_type;
-function_type_prefix = (symbol_c *)search_expression_type->compute_standard_function_default(NULL, symbol);
+function_type_prefix = (symbol_c *)f_decl->type_name->accept(search_base_type);
+if (NULL == function_type_prefix) ERROR;
-int nb_param = 0;
-if (symbol->il_param_list != NULL)
+function_name = symbol->function_name;
-nb_param += ((list_c *)symbol->il_param_list)->n;
+/* loop through each function parameter, find the value we should pass
-symbol_c *en_param_name = (symbol_c *)(new identifier_c("EN"));
+* to it, and then output the c equivalent...
-/* Get the value from EN param */
+*/
-symbol_c *EN_param_value = function_call_param_iterator.search_f(en_param_name);
+function_param_iterator_c fp_iterator(f_decl);
-if (EN_param_value == NULL)
+identifier_c *param_name;
-EN_param_value = (symbol_c*)(new boolean_literal_c((symbol_c*)(new bool_type_name_c()), new boolean_true_c()));
-else
+/* flag to cirreclty handle calls to extensible standard functions (i.e. functions with variable number of input parameters) */
-nb_param --;
+bool found_first_extensible_parameter = false;
-ADD_PARAM_LIST(en_param_name, EN_param_value, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_in)
+for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
+if (fp_iterator.is_extensible_param() && (!found_first_extensible_parameter)) {
-symbol_c *eno_param_name = (symbol_c *)(new identifier_c("ENO"));
+/* We are calling an extensible function. Before passing the extensible
-/* Get the value from ENO param */
+* parameters, we must add a dummy paramater value to tell the called
-symbol_c *ENO_param_value = function_call_param_iterator.search_f(eno_param_name);
+* function how many extensible parameters we will be passing.
-if (ENO_param_value != NULL)
+*
-nb_param --;
+* Note that stage 3 has already determined the number of extensible
-ADD_PARAM_LIST(eno_param_name, ENO_param_value, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_out)
+* paramters, and stored that info in the abstract syntax tree. We simply
+* re-use that value.
-#include "st_code_gen.c"
+*/
+/* NOTE: we are not freeing the malloc'd memory. This is not really a bug.
-}
+*       Since we are writing a compiler, which runs to termination quickly,
-else {
+*       we can consider this as just memory required for the compilation process
-function_name = symbol->function_name;
+*       that will be free'd when the program terminates.
+*/
-		/* determine the base data type returned by the function being called... */
+char *tmp = (char *)malloc(32); /* enough space for a call with 10^31 (larger than 2^64) input parameters! */
-		search_base_type_c search_base_type;
+if (tmp == NULL) ERROR;
-		function_type_prefix = (symbol_c *)f_decl->type_name->accept(search_base_type);
+int res = snprintf(tmp, 32, "%d", symbol->extensible_param_count);
+if ((res >= 32) || (res < 0)) ERROR;
-		/* loop through each function parameter, find the value we should pass
+identifier_c *param_value = new identifier_c(tmp);
-		 * to it, and then output the c equivalent...
+uint_type_name_c *param_type  = new uint_type_name_c();
-		 */
+identifier_c *param_name = new identifier_c("");
+ADD_PARAM_LIST(param_name, param_value, param_type, function_param_iterator_c::direction_in)
-		function_param_iterator_c fp_iterator(f_decl);
+found_first_extensible_parameter = true;
-		identifier_c *param_name;
+}
-		for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
-		  symbol_c *param_type = fp_iterator.param_type();
+if (fp_iterator.is_extensible_param()) {
-		  if (param_type == NULL) ERROR;
+/* 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
-		  function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
+* 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! */
-		  symbol_c *param_value = NULL;
+int res = snprintf(tmp, 32, "%d", fp_iterator.extensible_param_index());
+if ((res >= 32) || (res < 0)) ERROR;
-		  /* Get the value from a foo(<param_name> = <param_value>) style call */
+param_name = new identifier_c(strdup2(param_name->value, tmp));
-		  if (param_value == NULL)
+if (param_name->value == NULL) ERROR;
-			param_value = function_call_param_iterator.search_f(param_name);
+}
-		  /* Get the value from a foo(<param_value>) style call */
+symbol_c *param_type = fp_iterator.param_type();
-		  /* NOTE: the following line of code is not required in this case, but it doesn't
+if (param_type == NULL) ERROR;
-		   * harm to leave it in, as in the case of a formal syntax function call,
-		   * it will always return NULL.
+function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
-		   * 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
+symbol_c *param_value = NULL;
-		   * the following line...
-		   */
+/* Get the value from a foo(<param_name> = <param_value>) style call */
-		  if (param_value == NULL) {
+if (param_value == NULL)
-param_value = function_call_param_iterator.next_nf();
+param_value = function_call_param_iterator.search_f(param_name);
-if (param_value != NULL && fp_iterator.is_en_eno_param_implicit()) ERROR;
-}
+/* Get the value from a foo(<param_value>) style call */
+/* NOTE: the following line of code is not required in this case, but it doesn't
-		  if (param_value == NULL) {
+* harm to leave it in, as in the case of a formal syntax function call,
-			/* No value given for parameter, so we must use the default... */
+* it will always return NULL.
-			/* First check whether default value specified in function declaration...*/
+* We leave it in in case we later decide to merge this part of the code together
-			param_value = fp_iterator.default_value();
+* with the function calling code in generate_c_st_c, which does require
-		  }
+* the following line...
+*/
-		  ADD_PARAM_LIST(param_name, param_value, param_type, fp_iterator.param_direction())
+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.
+*/
+if ((param_value == NULL) && (fp_iterator.is_extensible_param())) {
+break;
+}
+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, fp_iterator.param_direction())
 }
 if (function_call_param_iterator.next_nf() != NULL) ERROR;
-if (NULL == function_type_prefix) ERROR;
 bool has_output_params = false;
 PARAM_LIST_ITERATOR() {
 if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||
 PARAM_VALUE != NULL) {
 has_output_params = true;
 }
 }
+/* Check whether we are calling an overloaded function! */
+/* (fdecl_mutiplicity==2)  => calling overloaded function */
+int fdecl_mutiplicity =  function_symtable.multiplicity(symbol->function_name);
+if (fdecl_mutiplicity == 0) ERROR;
+if (fdecl_mutiplicity == 1)
+/* function being called is NOT overloaded! */
+f_decl = NULL;
 if (has_output_params)
-generate_inline(function_name, function_type_prefix, function_type_suffix, param_list);
+generate_inline(function_name, function_type_prefix, function_type_suffix, param_list, f_decl);
 CLEAR_PARAM_LIST()
 /* the data type resulting from this operation... */
 default_variable_name.current_type = function_type_prefix;
 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);
+/* determine the base data type returned by the function being called... */
-if (current_function_type == function_none) ERROR;
+search_base_type_c search_base_type;
+function_type_prefix = (symbol_c *)f_decl->type_name->accept(search_base_type);
-function_type_prefix = search_expression_type->get_type(symbol);
+if (NULL == function_type_prefix) ERROR;
-int nb_param = ((list_c *)parameter_assignment_list)->n;
+/* loop through each function parameter, find the value we should pass
+* to it, and then output the c equivalent...
-symbol_c *en_param_name = (symbol_c *)(new identifier_c("EN"));
+*/
-/* Get the value from EN param */
+function_param_iterator_c fp_iterator(f_decl);
-symbol_c *EN_param_value = function_call_param_iterator.search_f(en_param_name);
+identifier_c *param_name;
-if (EN_param_value == NULL)
+/* flag to cirreclty handle calls to extensible standard functions (i.e. functions with variable number of input parameters) */
-EN_param_value = (symbol_c*)(new boolean_literal_c((symbol_c*)(new bool_type_name_c()), new boolean_true_c()));
+bool found_first_extensible_parameter = false;
-else
+for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
-nb_param --;
+if (fp_iterator.is_extensible_param() && (!found_first_extensible_parameter)) {
-ADD_PARAM_LIST(en_param_name, EN_param_value, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_in)
+/* We are calling an extensible function. Before passing the extensible
+* parameters, we must add a dummy paramater value to tell the called
-symbol_c *eno_param_name = (symbol_c *)(new identifier_c("ENO"));
+* function how many extensible parameters we will be passing.
-/* Get the value from ENO param */
+*
-symbol_c *ENO_param_value = function_call_param_iterator.search_f(eno_param_name);
+* Note that stage 3 has already determined the number of extensible
-if (ENO_param_value != NULL)
+* paramters, and stored that info in the abstract syntax tree. We simply
-nb_param --;
+* re-use that value.
-ADD_PARAM_LIST(eno_param_name, ENO_param_value, (symbol_c*)(new bool_type_name_c()), function_param_iterator_c::direction_out)
+*/
+/* NOTE: we are not freeing the malloc'd memory. This is not really a bug.
-#include "st_code_gen.c"
+*       Since we are writing a compiler, which runs to termination quickly,
+*       we can consider this as just memory required for the compilation process
-}
+*       that will be free'd when the program terminates.
-else {
+*/
-function_name = symbol->function_name;
+char *tmp = (char *)malloc(32); /* enough space for a call with 10^31 (larger than 2^64) input parameters! */
+if (tmp == NULL) ERROR;
-	    /* determine the base data type returned by the function being called... */
+int res = snprintf(tmp, 32, "%d", symbol->extensible_param_count);
-		search_base_type_c search_base_type;
+if ((res >= 32) || (res < 0)) ERROR;
-		function_type_prefix = (symbol_c *)f_decl->type_name->accept(search_base_type);
+identifier_c *param_value = new identifier_c(tmp);
+uint_type_name_c *param_type  = new uint_type_name_c();
-	/* loop through each function parameter, find the value we should pass
+identifier_c *param_name = new identifier_c("");
-* to it, and then output the c equivalent...
+ADD_PARAM_LIST(param_name, param_value, param_type, function_param_iterator_c::direction_in)
+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_type == NULL) ERROR;
+if ((param_value == NULL) && (param_direction == function_param_iterator_c::direction_in)) {
+/* No value given for parameter, so we must use the default... */
-function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
+/* First check whether default value specified in function declaration...*/
+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)
-/* Get the value from a foo(<param_value>) style call */
+} /* for(...) */
-if (param_value == NULL) {
+// symbol->parameter_assignment->accept(*this);
-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;
-if (NULL == function_type_prefix) ERROR;
+bool has_output_params = false;
-	  bool has_output_params = false;
+PARAM_LIST_ITERATOR() {
-	  PARAM_LIST_ITERATOR() {
 if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||
 PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&
 PARAM_VALUE != NULL) {
 has_output_params = true;
 }
 }
+/* Check whether we are calling an overloaded function! */
+/* (fdecl_mutiplicity==2)  => calling overloaded function */
+int fdecl_mutiplicity =  function_symtable.multiplicity(symbol->function_name);
+if (fdecl_mutiplicity == 0) ERROR;
+if (fdecl_mutiplicity == 1)
+/* function being called is NOT overloaded! */
+f_decl = NULL;
 if (has_output_params)
-generate_inline(function_name, function_type_prefix, function_type_suffix, param_list);
+generate_inline(function_name, function_type_prefix, function_type_suffix, param_list, f_decl);
 CLEAR_PARAM_LIST()
 return NULL;
 }

changeset 375	7a11f9e9e703
parent 355	30db860bd3bd
child 380	b78e59ed4269