laurent@219: /*
laurent@219:  * (c) 2007 Mario de Sousa and Laurent Bessard
laurent@219:  *
laurent@219:  * Offered to the public under the terms of the GNU General Public License
laurent@219:  * as published by the Free Software Foundation; either version 2 of the
laurent@219:  * License, or (at your option) any later version.
laurent@219:  *
laurent@219:  * This program is distributed in the hope that it will be useful, but
laurent@219:  * WITHOUT ANY WARRANTY; without even the implied warranty of
laurent@219:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
laurent@219:  * Public License for more details.
laurent@219:  *
laurent@219:  * This code is made available on the understanding that it will not be
laurent@219:  * used in safety-critical situations without a full and competent review.
laurent@219:  */
laurent@219: 
laurent@219: /*
laurent@219:  * An IEC 61131-3 IL and ST compiler.
laurent@219:  *
laurent@219:  * Based on the
laurent@219:  * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)
laurent@219:  *
laurent@219:  */
laurent@219: 
laurent@219: /*
laurent@219:  * This is one of the versions available for the 4th stage.
laurent@219:  *
laurent@219:  * This 4th stage generates a c++ source program equivalent
laurent@219:  * to the IL and ST code.
laurent@219:  */
laurent@219: 
laurent@219: 
laurent@219: #define INLINE_RESULT_TEMP_VAR "__res"
laurent@219: 
laurent@219: class generate_c_inline_c: public generate_c_typedecl_c {
laurent@219: 
laurent@221:   public:
laurent@221:     typedef enum {
laurent@221:       expression_vg,
berem@228:       assignment_vg,
berem@228:       complextype_base_vg,
berem@228:       complextype_suffix_vg
laurent@221:     } variablegeneration_t;
laurent@221: 
laurent@219:   private:
laurent@219: 
laurent@219:     /* The name of the IL default variable... */
laurent@219: 	#define IL_DEFVAR   VAR_LEADER "IL_DEFVAR"
laurent@219: 	/* The name of the variable used to pass the result of a
laurent@219: 	 * parenthesised instruction list to the immediately preceding
laurent@219: 	 * scope ...
laurent@219: 	 */
laurent@219: 	il_default_variable_c default_variable_name;
laurent@219: 
berem@228: 	symbol_c* current_array_type;
berem@228: 
laurent@219: 	int fcall_number;
laurent@219: 	symbol_c *fbname;
laurent@219: 
laurent@219:     search_expression_type_c *search_expression_type;
laurent@219: 
laurent@219:     search_varfb_instance_type_c *search_varfb_instance_type;
laurent@219: 
laurent@219:     search_base_type_c search_base_type;
laurent@219: 
laurent@221:     variablegeneration_t wanted_variablegeneration;
laurent@221: 
laurent@219:   public:
laurent@219:     generate_c_inline_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL)
laurent@219:     : generate_c_typedecl_c(s4o_ptr),
laurent@219:       default_variable_name(IL_DEFVAR, NULL)
laurent@219:     {
laurent@219:       search_expression_type = new search_expression_type_c(scope);
laurent@219:       search_varfb_instance_type = new search_varfb_instance_type_c(scope);
laurent@219:       this->set_variable_prefix(variable_prefix);
laurent@219:       fcall_number = 0;
laurent@219:       fbname = name;
laurent@221:       wanted_variablegeneration = expression_vg;
laurent@219:     }
laurent@219: 
laurent@219:     virtual ~generate_c_inline_c(void) {
laurent@219:       delete search_varfb_instance_type;
laurent@219:     }
laurent@219: 
laurent@219:     void *generate_inline(symbol_c *function_name,
laurent@219:     		symbol_c *return_data_type,
laurent@219:     		std::list<FUNCTION_PARAM*> param_list) {
laurent@219:       std::list<FUNCTION_PARAM*>::iterator pt;
laurent@219: 
laurent@219:       fcall_number++;
laurent@219: 
laurent@219:       s4o.print(s4o.indent_spaces);
laurent@219:       s4o.print("inline ");
laurent@219:       return_data_type->accept(*this);
laurent@219:       s4o.print(" __");
laurent@219:       fbname->accept(*this);
laurent@219:       s4o.print("_");
laurent@219:       function_name->accept(*this);
laurent@219:       s4o.print_integer(fcall_number);
laurent@219:       s4o.print("(");
laurent@219:       s4o.indent_right();
laurent@219: 
laurent@219:       PARAM_LIST_ITERATOR() {
laurent@219:         if (PARAM_DIRECTION == function_param_iterator_c::direction_in) {
laurent@219:           PARAM_TYPE->accept(*this);
laurent@219:           s4o.print(" ");
laurent@219:           PARAM_NAME->accept(*this);
laurent@219:           s4o.print(",\n" + s4o.indent_spaces);
laurent@219:         }
laurent@219:       }
laurent@219:       fbname->accept(*this);
laurent@219: 	  s4o.print(" *");
laurent@219: 	  s4o.print(FB_FUNCTION_PARAM);
laurent@219: 	  s4o.indent_left();
laurent@219: 	  s4o.print(")\n" + s4o.indent_spaces);
laurent@219: 	  s4o.print("{\n");
laurent@219:       s4o.indent_right();
laurent@219: 
laurent@219:       s4o.print(s4o.indent_spaces);
laurent@219:       return_data_type->accept(*this);
laurent@219:       s4o.print(" "),
laurent@219:       s4o.print(INLINE_RESULT_TEMP_VAR);
laurent@219:       s4o.print(";\n");
laurent@219: 
laurent@219: 	  PARAM_LIST_ITERATOR() {
laurent@219: 		if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||
laurent@219: 		     PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&
laurent@219: 		    PARAM_VALUE != NULL) {
laurent@219: 		  s4o.print(s4o.indent_spaces);
laurent@219: 		  PARAM_TYPE->accept(*this);
laurent@219:           s4o.print(" ");
laurent@219:           s4o.print(TEMP_VAR);
laurent@219:           PARAM_NAME->accept(*this);
laurent@219:           s4o.print(" = ");
laurent@219:           print_check_function(PARAM_TYPE, PARAM_VALUE);
laurent@219:           s4o.print(";\n");
laurent@219: 		}
laurent@219: 	  }
laurent@219: 
laurent@219: 	  s4o.print(s4o.indent_spaces + INLINE_RESULT_TEMP_VAR),
laurent@219: 			  s4o.print(" = ");
laurent@219: 	  function_name->accept(*this);
laurent@219: 	  s4o.print("(");
laurent@219: 	  s4o.indent_right();
laurent@219: 
laurent@219: 	  PARAM_LIST_ITERATOR() {
laurent@219: 		if (pt != param_list.begin())
laurent@219: 		  s4o.print(",\n" + s4o.indent_spaces);
laurent@219: 		if (PARAM_DIRECTION == function_param_iterator_c::direction_in)
laurent@219: 		  PARAM_NAME->accept(*this);
laurent@219: 		else if (PARAM_VALUE != NULL){
laurent@219:           s4o.print("&");
laurent@219:           s4o.print(TEMP_VAR);
laurent@219:           PARAM_NAME->accept(*this);
laurent@219:         }
laurent@219: 		else {
laurent@219: 		  s4o.print("NULL");
laurent@219: 		}
laurent@219: 	  }
laurent@219: 	  s4o.print(");\n");
laurent@219: 	  s4o.indent_left();
laurent@219: 
laurent@219: 	  PARAM_LIST_ITERATOR() {
laurent@219:         if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||
laurent@219:         	 PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&
laurent@219:         	PARAM_VALUE != NULL) {
laurent@219: 
laurent@219:           s4o.print(s4o.indent_spaces);
berem@228:           print_setter(PARAM_VALUE, PARAM_TYPE, PARAM_NAME);
berem@228:           s4o.print(";\n");
laurent@219: 		}
laurent@219: 	  }
laurent@219: 	  s4o.print(s4o.indent_spaces + "return ");
laurent@219: 	  s4o.print(INLINE_RESULT_TEMP_VAR);
laurent@219: 	  s4o.print(";\n");
laurent@219: 
laurent@219:       s4o.indent_left();
laurent@219:       s4o.print(s4o.indent_spaces + "}\n\n");
laurent@219: 
laurent@219:       return NULL;
laurent@219:     }
laurent@219: 
laurent@219:   private:
laurent@219: 
berem@228:     void *print_getter(symbol_c *symbol) {
berem@228:       unsigned int vartype = search_varfb_instance_type->get_vartype(symbol);
berem@228:       if (vartype == search_var_instance_decl_c::external_vt)
berem@228:     	s4o.print(GET_EXTERNAL);
berem@228:       else if (vartype == search_var_instance_decl_c::located_vt)
berem@228:     	s4o.print(GET_LOCATED);
berem@228:       else
berem@228:     	s4o.print(GET_VAR);
berem@228:       s4o.print("(");
berem@228: 
berem@228:       wanted_variablegeneration = complextype_base_vg;
berem@228:       symbol->accept(*this);
berem@228:       if (search_varfb_instance_type->type_is_complex())
berem@228:     	s4o.print(",");
berem@228:       wanted_variablegeneration = complextype_suffix_vg;
berem@228:       symbol->accept(*this);
berem@228:       s4o.print(")");
berem@228:       wanted_variablegeneration = expression_vg;
berem@228:       return NULL;
berem@228:     }
berem@228: 
berem@228:     void *print_setter(symbol_c* symbol,
berem@228:     		symbol_c* type,
berem@228:     		symbol_c* value) {
berem@228:       unsigned int vartype = search_varfb_instance_type->get_vartype(symbol);
laurent@231:       if (vartype == search_var_instance_decl_c::external_vt) {
laurent@231:         symbolic_variable_c *variable = dynamic_cast<symbolic_variable_c *>(symbol);
laurent@231:         /* TODO Find a solution for forcing global complex variables */
laurent@231:         if (variable != NULL) {
laurent@231:           s4o.print(SET_EXTERNAL);
laurent@231:           s4o.print("(");
laurent@231:           variable->var_name->accept(*this);
laurent@231:           s4o.print(",");
laurent@231:         }
laurent@231:         else {
laurent@231:           s4o.print(SET_COMPLEX_EXTERNAL);
laurent@231:           s4o.print("(");
laurent@231:         }
laurent@231:       }
laurent@231:       else {
laurent@231:         if (vartype == search_var_instance_decl_c::located_vt)
laurent@231:           s4o.print(SET_LOCATED);
laurent@231:         else
laurent@231:           s4o.print(SET_VAR);
laurent@231:         s4o.print("(");
laurent@231:       }
berem@228: 
berem@228:       wanted_variablegeneration = complextype_base_vg;
berem@228:       symbol->accept(*this);
berem@228:       s4o.print(",");
berem@228:       wanted_variablegeneration = expression_vg;
berem@228:       print_check_function(type, value, NULL, true);
berem@228:       if (search_varfb_instance_type->type_is_complex()) {
berem@228:         s4o.print(",");
berem@228:         wanted_variablegeneration = complextype_suffix_vg;
berem@228:         symbol->accept(*this);
berem@228:       }
berem@228:       s4o.print(")");
berem@228:       wanted_variablegeneration = expression_vg;
berem@228:       return NULL;
berem@228:     }
berem@228: 
laurent@219:     /*********************/
laurent@219:     /* B 1.4 - Variables */
laurent@219:     /*********************/
laurent@219:     void *visit(symbolic_variable_c *symbol) {
berem@228:       unsigned int vartype;
berem@228:       if (wanted_variablegeneration == complextype_base_vg)
berem@228:         generate_c_base_c::visit(symbol);
berem@228:       else if (wanted_variablegeneration == complextype_suffix_vg)
berem@228:         return NULL;
berem@228:       else if (wanted_variablegeneration == expression_vg) {
berem@228: 	    vartype = search_varfb_instance_type->get_vartype(symbol);
laurent@221: 	    if (vartype == search_var_instance_decl_c::external_vt) {
laurent@221: 		  s4o.print(GET_EXTERNAL);
laurent@221: 		  s4o.print("(");
laurent@221: 		  symbol->var_name->accept(*this);
laurent@221: 	    }
laurent@221: 	    else {
laurent@221: 		  if (vartype == search_var_instance_decl_c::located_vt)
laurent@221: 		    s4o.print(GET_LOCATED);
laurent@221: 		  else
laurent@221: 		    s4o.print(GET_VAR);
laurent@221: 		  s4o.print("(");
laurent@221: 		  generate_c_base_c::visit(symbol);
laurent@221: 	    }
laurent@221: 	    s4o.print(")");
laurent@219:       }
laurent@221:       else
laurent@219:         generate_c_base_c::visit(symbol);
laurent@219:       return NULL;
laurent@219:     }
laurent@219: 
laurent@219:     /********************************************/
laurent@219:     /* B.1.4.1   Directly Represented Variables */
laurent@219:     /********************************************/
laurent@219:     // direct_variable: direct_variable_token   {$$ = new direct_variable_c($1);};
laurent@219:     void *visit(direct_variable_c *symbol) {
laurent@219:       TRACE("direct_variable_c");
laurent@219:       /* Do not use print_token() as it will change everything into uppercase */
laurent@219:       if (strlen(symbol->value) == 0) ERROR;
laurent@219:       s4o.print(GET_LOCATED);
laurent@219:       s4o.print("(");
laurent@219:       this->print_variable_prefix();
laurent@219:       s4o.printlocation(symbol->value + 1);
laurent@219:       s4o.print(")");
laurent@219:       return NULL;
laurent@219:     }
laurent@219: 
berem@228:     /*************************************/
berem@228:     /* B.1.4.2   Multi-element Variables */
berem@228:     /*************************************/
berem@228: 
berem@228:     // SYM_REF2(structured_variable_c, record_variable, field_selector)
berem@228:     void *visit(structured_variable_c *symbol) {
berem@228:       TRACE("structured_variable_c");
berem@228:       switch (wanted_variablegeneration) {
berem@228:         case complextype_base_vg:
berem@228:           symbol->record_variable->accept(*this);
berem@228:           break;
berem@228:         case complextype_suffix_vg:
berem@228:           symbol->record_variable->accept(*this);
berem@228:           s4o.print(".");
berem@228:           symbol->field_selector->accept(*this);
berem@228:           break;
berem@228:         default:
berem@228:           if (this->is_variable_prefix_null()) {
berem@228:         	symbol->record_variable->accept(*this);
berem@228:         	s4o.print(".");
berem@228:         	symbol->field_selector->accept(*this);
berem@228:           }
berem@228:           else
berem@228:         	print_getter(symbol);
berem@228:           break;
berem@228:       }
berem@228:       return NULL;
berem@228:     }
berem@228: 
berem@228:     /*  subscripted_variable '[' subscript_list ']' */
berem@228:     //SYM_REF2(array_variable_c, subscripted_variable, subscript_list)
berem@228:     void *visit(array_variable_c *symbol) {
berem@228:       switch (wanted_variablegeneration) {
berem@228:         case complextype_base_vg:
berem@228:           symbol->subscripted_variable->accept(*this);
berem@228:           break;
berem@228:         case complextype_suffix_vg:
berem@228:           current_array_type = search_varfb_instance_type->get_rawtype(symbol->subscripted_variable);
berem@228:           symbol->subscripted_variable->accept(*this);
berem@228:           if (current_array_type != NULL) {
berem@228:             symbol->subscript_list->accept(*this);
berem@228:             current_array_type = NULL;
berem@228:           }
berem@228:           break;
berem@228:         default:
berem@228:           if (this->is_variable_prefix_null()) {
berem@228:         	current_array_type = search_varfb_instance_type->get_rawtype(symbol->subscripted_variable);
berem@228:         	symbol->subscripted_variable->accept(*this);
berem@228:         	if (current_array_type != NULL) {
berem@228:         	  symbol->subscript_list->accept(*this);
berem@228:         	  current_array_type = NULL;
berem@228:         	}
berem@228:           }
berem@228:           else
berem@228:         	print_getter(symbol);
berem@228:           break;
berem@228:       }
berem@228:       return NULL;
berem@228:     }
berem@228: 
laurent@219:     /****************************************/
laurent@219:     /* B.2 - Language IL (Instruction List) */
laurent@219:     /****************************************/
laurent@219: 
laurent@219:     /***********************************/
laurent@219:     /* B 2.1 Instructions and Operands */
laurent@219:     /***********************************/
laurent@219: 
laurent@219:     void *visit(il_function_call_c *symbol) {
laurent@219: 	  function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name);
laurent@219: 
laurent@219: 	  if (f_decl != function_symtable.end_value()) {
laurent@219: 		DECLARE_PARAM_LIST()
laurent@219: 		bool has_output_params = false;
laurent@219: 
laurent@219: 		/* determine the base data type returned by the function being called... */
laurent@219: 		search_base_type_c search_base_type;
laurent@219: 		symbol_c *return_data_type = (symbol_c *)f_decl->type_name->accept(search_base_type);
laurent@219: 		if (NULL == return_data_type) ERROR;
laurent@219: 
laurent@219: 		/* loop through each function parameter, find the value we should pass
laurent@219: 		 * to it, and then output the c equivalent...
laurent@219: 		 */
laurent@219: 
laurent@219: 		function_param_iterator_c fp_iterator(f_decl);
laurent@219: 		identifier_c *param_name;
laurent@219: 		function_call_param_iterator_c function_call_param_iterator(symbol);
laurent@219: 		for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
laurent@219: 		  symbol_c *param_type = fp_iterator.param_type();
laurent@219: 		  if (param_type == NULL) ERROR;
laurent@219: 
laurent@219: 		  function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
laurent@219: 
laurent@219: 		  symbol_c *param_value = NULL;
laurent@219: 
laurent@219: 		  /* if it is the first parameter, semantics specifies that we should
laurent@219: 		   * get the value off the IL default variable!
laurent@219: 		   */
laurent@233: 		  if (1 == i)
laurent@233: 		    param_value = &this->default_variable_name;
laurent@219: 
laurent@219: 		  /* Get the value from a foo(<param_name> = <param_value>) style call */
laurent@219: 		  /* NOTE: the following line of code is not required in this case, but it doesn't
laurent@219: 		   * harm to leave it in, as in the case of a non-formal syntax function call,
laurent@219: 		   * it will always return NULL.
laurent@219: 		   * We leave it in in case we later decide to merge this part of the code together
laurent@219: 		   * with the function calling code in generate_c_st_c, which does require
laurent@219: 		   * the following line...
laurent@219: 		   */
laurent@219: 		  if (param_value == NULL)
laurent@219: 			param_value = function_call_param_iterator.search_f(param_name);
laurent@219: 
laurent@219: 		  /* Get the value from a foo(<param_value>) style call */
laurent@233:           if (param_value == NULL) {
laurent@233:             param_value = function_call_param_iterator.next_nf();
laurent@233:             if (param_value != NULL && fp_iterator.is_en_eno_param_implicit()) ERROR;
laurent@233:           }
laurent@219: 
laurent@219: 		  if (param_value == NULL && param_direction == function_param_iterator_c::direction_in) {
laurent@219: 			/* No value given for parameter, so we must use the default... */
laurent@219: 			/* First check whether default value specified in function declaration...*/
laurent@219: 			param_value = fp_iterator.default_value();
laurent@219: 		  }
laurent@219: 
laurent@219: 		  ADD_PARAM_LIST(param_name, param_value, param_type, fp_iterator.param_direction())
laurent@219: 		} /* for(...) */
laurent@219: 
laurent@233: 		if (function_call_param_iterator.next_nf() != NULL) ERROR;
laurent@233: 
laurent@219: 		PARAM_LIST_ITERATOR() {
laurent@219: 			if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||
laurent@219: 				 PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&
laurent@219: 				PARAM_VALUE != NULL) {
laurent@219: 			  has_output_params = true;
laurent@219: 			}
laurent@219: 		}
laurent@219: 
laurent@219: 	    if (has_output_params)
laurent@219: 	      generate_inline(symbol->function_name, return_data_type, param_list);
laurent@219: 
laurent@219: 	    CLEAR_PARAM_LIST()
laurent@219: 	  }
laurent@219: 	  return NULL;
laurent@219:     }
laurent@219: 
laurent@219:     void *visit(il_formal_funct_call_c *symbol) {
laurent@219: 	  function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name);
laurent@219: 
laurent@219: 	  if (f_decl != function_symtable.end_value()) {
laurent@219: 		DECLARE_PARAM_LIST()
laurent@219: 		bool has_output_params = false;
laurent@219: 
laurent@219: 		/* determine the base data type returned by the function being called... */
laurent@219: 		search_base_type_c search_base_type;
laurent@219: 		symbol_c *return_data_type = (symbol_c *)f_decl->type_name->accept(search_base_type);
laurent@219: 		if (NULL == return_data_type) ERROR;
laurent@219: 
laurent@219: 		/* loop through each function parameter, find the value we should pass
laurent@219: 		 * to it, and then output the c equivalent...
laurent@219: 		 */
laurent@219: 
laurent@219: 		function_param_iterator_c fp_iterator(f_decl);
laurent@219: 		identifier_c *param_name;
laurent@219: 		function_call_param_iterator_c function_call_param_iterator(symbol);
laurent@219: 		for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
laurent@219: 		  symbol_c *param_type = fp_iterator.param_type();
laurent@219: 		  if (param_type == NULL) ERROR;
laurent@219: 
laurent@219: 		  function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
laurent@219: 
laurent@219: 
laurent@219: 		  symbol_c *param_value = NULL;
laurent@219: 
laurent@219: 		  /* Get the value from a foo(<param_name> = <param_value>) style call */
laurent@219: 		  if (param_value == NULL)
laurent@219: 			param_value = function_call_param_iterator.search_f(param_name);
laurent@219: 
laurent@219: 		  /* Get the value from a foo(<param_value>) style call */
laurent@219: 		  /* NOTE: the following line of code is not required in this case, but it doesn't
laurent@219: 		   * harm to leave it in, as in the case of a formal syntax function call,
laurent@219: 		   * it will always return NULL.
laurent@219: 		   * We leave it in in case we later decide to merge this part of the code together
laurent@219: 		   * with the function calling code in generate_c_st_c, which does require
laurent@219: 		   * the following line...
laurent@219: 		   */
laurent@233: 		  if (param_value == NULL) {
laurent@233:             param_value = function_call_param_iterator.next_nf();
laurent@233:             if (param_value != NULL && fp_iterator.is_en_eno_param_implicit()) ERROR;
laurent@233:           }
laurent@219: 
laurent@219: 		  if (param_value == NULL) {
laurent@219: 			/* No value given for parameter, so we must use the default... */
laurent@219: 			/* First check whether default value specified in function declaration...*/
laurent@219: 			param_value = fp_iterator.default_value();
laurent@219: 		  }
laurent@219: 
laurent@219: 		  ADD_PARAM_LIST(param_name, param_value, param_type, fp_iterator.param_direction())
laurent@219: 		}
laurent@219: 
laurent@233: 		if (function_call_param_iterator.next_nf() != NULL) ERROR;
laurent@233: 
laurent@219: 		PARAM_LIST_ITERATOR() {
laurent@219:       	  if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||
laurent@219:       		   PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&
laurent@219:       	      PARAM_VALUE != NULL) {
laurent@219:       	    has_output_params = true;
laurent@219:       	  }
laurent@219:         }
laurent@219: 
laurent@219:         if (has_output_params)
laurent@219: 	      generate_inline(symbol->function_name, return_data_type, param_list);
laurent@219: 
laurent@219:         CLEAR_PARAM_LIST()
laurent@219: 	  }
laurent@219:       return NULL;
laurent@219:     }
laurent@219: 
laurent@219:     /***************************************/
laurent@219:     /* B.3 - Language ST (Structured Text) */
laurent@219:     /***************************************/
laurent@219:     /***********************/
laurent@219:     /* B 3.1 - Expressions */
laurent@219:     /***********************/
laurent@219: 
laurent@219:     void *visit(function_invocation_c *symbol) {
laurent@219:       function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name);
laurent@219: 
laurent@219:       if (f_decl != function_symtable.end_value()) {
laurent@219:     	DECLARE_PARAM_LIST()
laurent@219:     	bool has_output_params = false;
laurent@219: 
laurent@219:     	symbol_c *parameter_assignment_list = NULL;
laurent@219: 	    if (NULL != symbol->   formal_param_list) parameter_assignment_list = symbol->   formal_param_list;
laurent@219: 	    if (NULL != symbol->nonformal_param_list) parameter_assignment_list = symbol->nonformal_param_list;
laurent@219: 	    if (NULL == parameter_assignment_list) ERROR;
laurent@219: 
laurent@219: 	    /* determine the base data type returned by the function being called... */
laurent@219: 		search_base_type_c search_base_type;
laurent@219: 		symbol_c *return_data_type = (symbol_c *)f_decl->type_name->accept(search_base_type);
laurent@219: 		if (NULL == return_data_type) ERROR;
laurent@219: 
laurent@219:     	/* loop through each function parameter, find the value we should pass
laurent@219:          * to it, and then output the c equivalent...
laurent@219:          */
laurent@219:         function_param_iterator_c fp_iterator(f_decl);
laurent@219:         identifier_c *param_name;
laurent@219:         function_call_param_iterator_c function_call_param_iterator(symbol);
laurent@219:         for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
laurent@233:           symbol_c *param_type = fp_iterator.param_type();
laurent@233:           if (param_type == NULL) ERROR;
laurent@219: 
laurent@219:           function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
laurent@219: 
laurent@219:           /* Get the value from a foo(<param_name> = <param_value>) style call */
laurent@219:           symbol_c *param_value = function_call_param_iterator.search_f(param_name);
laurent@219: 
laurent@219:           /* Get the value from a foo(<param_value>) style call */
laurent@233:           if (param_value == NULL) {
laurent@219:             param_value = function_call_param_iterator.next_nf();
laurent@233:             if (param_value != NULL && fp_iterator.is_en_eno_param_implicit()) ERROR;
laurent@233:           }
laurent@219: 
laurent@219:           if (param_value == NULL && param_direction == function_param_iterator_c::direction_in) {
laurent@219:             /* No value given for parameter, so we must use the default... */
laurent@219:             /* First check whether default value specified in function declaration...*/
laurent@219:             param_value = fp_iterator.default_value();
laurent@219:           }
laurent@219: 
laurent@219:           ADD_PARAM_LIST(param_name, param_value, param_type, param_direction)
laurent@219:         } /* for(...) */
laurent@219:         // symbol->parameter_assignment->accept(*this);
laurent@219: 
laurent@233:         if (function_call_param_iterator.next_nf() != NULL) ERROR;
laurent@233: 
laurent@219:         PARAM_LIST_ITERATOR() {
laurent@219:       	  if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||
laurent@219:       			PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&
laurent@219:               PARAM_VALUE != NULL) {
laurent@219:       	    has_output_params = true;
laurent@219:       	  }
laurent@219:         }
laurent@219: 
laurent@219:         if (has_output_params)
laurent@219: 	      generate_inline(symbol->function_name, return_data_type, param_list);
laurent@219: 
laurent@219:         CLEAR_PARAM_LIST()
laurent@219:       }
laurent@219: 	  return NULL;
laurent@219:     }
laurent@219: 
laurent@219: };  /* generate_c_inline_c */
laurent@219: 
laurent@219: 
laurent@219: /***********************************************************************/
laurent@219: /***********************************************************************/
laurent@219: /***********************************************************************/
laurent@219: /***********************************************************************/
laurent@219: 
laurent@219: 
laurent@219: class generate_c_inlinefcall_c: public iterator_visitor_c {
laurent@219: 
laurent@219:   private:
laurent@219: 	generate_c_inline_c *generate_c_inline;
laurent@219: 
laurent@219:   public:
laurent@219: 	generate_c_inlinefcall_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL) {
laurent@219: 	  generate_c_inline = new generate_c_inline_c(s4o_ptr, name, scope, variable_prefix);
laurent@219: 	}
laurent@219: 
laurent@219: 	virtual ~generate_c_inlinefcall_c(void) {
laurent@219: 	  delete generate_c_inline;
laurent@219: 	}
laurent@219: 
laurent@219:   private:
laurent@219: 
laurent@219: 	void *visit(function_invocation_c *symbol) {
laurent@219: 	  return symbol->accept(*generate_c_inline);
laurent@219: 	}
laurent@219: 
laurent@219: 	void *visit(il_function_call_c *symbol) {
laurent@219: 	  return symbol->accept(*generate_c_inline);
laurent@219: 	}
laurent@219: 
laurent@219: 	void *visit(il_formal_funct_call_c *symbol) {
laurent@219: 	  return symbol->accept(*generate_c_inline);
laurent@219: 	}
laurent@219: }; /* generate_c_inlinefcall_c */
laurent@219: 
laurent@219: 
laurent@219: