671 }

   775 	/* The first parameter of a non formal function call in IL will be the 'current value' (i.e. the prev_il_instruction)

   672 

   776 	 * In order to be able to handle this without coding special cases, we will simply prepend that symbol

   673 /* MJS: Manuele, could you please not delete the following 2 lines of comments. They help me understand where this class is used

   777 	 * to the il_operand_list, and remove it later (in the print_datatypes_error_c).

   674  *     and when it is created by bison - syntax parse, and how it can show up in the abstract syntax tree.

   778 	 *

   675  *

   779 	 * However, if no further paramters are given, then il_operand_list will be NULL, and we will

   676  *       Actually, it could be helpful if we could have all the similar comments already present in visit_expression_type_c

   780 	 * need to create a new object to hold the pointer to prev_il_instruction.

   677  *       in the 3 new classes fill/narrow/print candidate datatype 

   781 	 * This change will also be undone later in print_datatypes_error_c.

   678  */

   782 	 */

   783 	if (NULL == symbol->il_operand_list)  symbol->il_operand_list = new il_operand_list_c;

   784 	if (NULL == symbol->il_operand_list)  ERROR;

   785 

   786 	symbol->il_operand_list->accept(*this);

   787 

   788 	if (NULL == prev_il_instruction)      return NULL;

   789 	((list_c *)symbol->il_operand_list)->insert_element(prev_il_instruction, 0);	

   790 

   791 	generic_function_call_t fcall_param = {

   792 	/* fcall_param.function_name               = */ symbol->function_name,

   793 	/* fcall_param.nonformal_operand_list      = */ symbol->il_operand_list,

   794 	/* fcall_param.formal_operand_list         = */ NULL,

   795 	/* fcall_param.candidate_functions         = */ symbol->candidate_functions,

   796 	/* fcall_param.called_function_declaration = */ symbol->called_function_declaration,

   797 	/* fcall_param.extensible_param_count      = */ symbol->extensible_param_count

   798 	};

   799 	handle_function_call(symbol, fcall_param);

   800 

   801 	if (debug) std::cout << "il_function_call_c [" << symbol->candidate_datatypes.size() << "] result.\n";

   802 	return NULL;

   803 }

   804 

   805 

   721 

   851 	symbol->il_param_list->accept(*this);

   852 

   853 	generic_function_call_t fcall_param = {

   854 	/* fcall_param.function_name               = */ symbol->function_name,

   855 	/* fcall_param.nonformal_operand_list      = */ NULL,

   856 	/* fcall_param.formal_operand_list         = */ symbol->il_param_list,

   857 	/* fcall_param.candidate_functions         = */ symbol->candidate_functions,

   858 	/* fcall_param.called_function_declaration = */ symbol->called_function_declaration,

   859 	/* fcall_param.extensible_param_count      = */ symbol->extensible_param_count

   860 	};

   861 	handle_function_call(symbol, fcall_param);

   862 

   863 	if (debug) std::cout << "il_formal_funct_call_c [" << symbol->candidate_datatypes.size() << "] result.\n";

   864 	return NULL;

  1714 	function_declaration_c *f_decl;

  1857 	if      (NULL != symbol->formal_param_list)        symbol->   formal_param_list->accept(*this);

  1715 	list_c *parameter_list;

  1858 	else if (NULL != symbol->nonformal_param_list)     symbol->nonformal_param_list->accept(*this);

  1716 	list_c *parameter_candidate_datatypes;

  1717 	symbol_c *returned_parameter_type;

  1718 

  1719 	if (debug) std::cout << "function()\n";

  1720 

  1721 	function_symtable_t::iterator lower = function_symtable.lower_bound(symbol->function_name);

  1722 	function_symtable_t::iterator upper = function_symtable.upper_bound(symbol->function_name);

  1723 	/* If the name of the function being called is not found in the function symbol table, then this is an invalid call */

  1724 	/* Since the lexical parser already checks for this, then if this occurs then we have an internal compiler error. */

  1725 	if (lower == function_symtable.end()) ERROR;

  1726 	

  1727 	if (NULL != symbol->formal_param_list)

  1728 		parameter_list = (list_c *)symbol->formal_param_list;

  1729 	else if (NULL != symbol->nonformal_param_list)

  1730 		parameter_list = (list_c *)symbol->nonformal_param_list;

  1732 	

  1860 

  1733 	/* Fill in the candidate_datatypes lists of all the expressions used in the function call parameters */

  1861 	generic_function_call_t fcall_param = {

  1734 	parameter_list->accept(*this);

  1862 	/* fcall_param.function_name               = */ symbol->function_name,

  1735 

  1863 	/* fcall_param.nonformal_operand_list      = */ symbol->nonformal_param_list,

  1736 	/* Look for all compatible function declarations, and add their return datatypes 

  1864 	/* fcall_param.formal_operand_list         = */ symbol->formal_param_list,

  1737 	 * to the candidate_datatype list of this function invocation. 

  1865 	/* fcall_param.candidate_functions         = */ symbol->candidate_functions,

  1738 	 *

  1866 	/* fcall_param.called_function_declaration = */ symbol->called_function_declaration,

  1739 	 * If only one function exists, we add its return datatype to the candidate_datatype list,

  1867 	/* fcall_param.extensible_param_count      = */ symbol->extensible_param_count

  1740 	 * even if the parameters passed to it are invalid.

  1868 	};

  1741 	 * This guarantees that the remainder of the expression in which the function call is inserted

  1869 	handle_function_call(symbol, fcall_param);

  1742 	 * is treated as if the function call returns correctly, and therefore does not generate

  1870 

  1743 	 * spurious error messages.

  1871 	if (debug) std::cout << "function_invocation_c [" << symbol->candidate_datatypes.size() << "] result.\n";

  1744 	 * Even if the parameters to the function call are invalid, doing this is still safe, as the 

  1745 	 * expressions inside the function call will themselves have erros and will  guarantee that 

  1746 	 * compilation is aborted in stage3 (in print_datatypes_error_c).

  1747 	 */

  1748 	if (function_symtable.multiplicity(symbol->function_name) == 1) {

  1749 		f_decl = function_symtable.get_value(lower);

  1750 		returned_parameter_type = base_type(f_decl->type_name);

  1751 		symbol->candidate_functions.push_back(f_decl);

  1752 		symbol->candidate_datatypes.push_back(returned_parameter_type);

  1753 	}

  1754 	for(; lower != upper; lower++) {

  1755 		bool compatible = false;

  1756 		

  1757 		f_decl = function_symtable.get_value(lower);

  1758 		/* Check if function declaration in symbol_table is compatible with parameters */

  1759 		if (NULL != symbol->nonformal_param_list)  compatible=match_nonformal_call(symbol, f_decl);

  1760 		if (NULL != symbol->   formal_param_list)  compatible=   match_formal_call(symbol, f_decl);

  1761 		if (compatible) {

  1762 			/* Add the data type returned by the called functions. 

  1763 			 * However, only do this if this data type is not already present in the candidate_datatypes list_c

  1764 			 */

  1765 			unsigned int k;

  1766 			returned_parameter_type = base_type(f_decl->type_name);

  1767 			for(k = 0; k < symbol->candidate_datatypes.size(); k++) {

  1768 				if (is_type_equal(returned_parameter_type, symbol->candidate_datatypes[k]))

  1769 					break;

  1770 			}

  1771 			if (k >= symbol->candidate_datatypes.size()) {

  1772 				symbol->candidate_datatypes.push_back(returned_parameter_type);

  1773 				symbol->candidate_functions.push_back(f_decl);

  1774 			}

  1775 		}

  1776 	}

  1777 	if (debug) std::cout << "end_function() [" << symbol->candidate_datatypes.size() << "] result.\n";