--- a/absyntax/absyntax.def	Fri Feb 03 10:54:35 2012 +0000
+++ b/absyntax/absyntax.def	Fri Feb 03 14:43:14 2012 +0000
@@ -1099,7 +1099,15 @@
 /* fb_name '(' [param_assignment_list] ')' */
 /*    formal_param_list -> may be NULL ! */
 /* nonformal_param_list -> may be NULL ! */
-SYM_REF3(fb_invocation_c, fb_name, formal_param_list, nonformal_param_list)
+/* NOTES:
+ *    The parameter 'called_fb_declaration'... 
+ *       ...is used to pass data between two passes of stage 3.
+ *       (actually set in fill_candidate_datatypes_c, and used in narrow_candidate_datatypes_c and print_datatypes_error_c).
+ *       This allows fill_candidate_datatypes_c to figure out whether it is a valid FB call,
+ *       and let the other classes handle it aproproately.
+ *       It could also be used in stage 4, if required.
+ */
+SYM_REF3(fb_invocation_c, fb_name, formal_param_list, nonformal_param_list, symbol_c *called_fb_declaration;)
 
 /* helper symbol for fb_invocation */
 /* param_assignment_list ',' param_assignment */

--- a/absyntax_utils/function_param_iterator.cc	Fri Feb 03 10:54:35 2012 +0000
+++ b/absyntax_utils/function_param_iterator.cc	Fri Feb 03 14:43:14 2012 +0000
@@ -206,7 +206,9 @@
   _first_extensible_param_index = -1;
   current_param_is_extensible = false;
   current_param_name = NULL;
-  current_param_type = current_param_default_value = NULL;
+  current_param_type = NULL;
+  current_param_default_value = NULL;
+  last_returned_parameter = NULL; /* the last parameter returned by search() or next() */
 }
 
 
@@ -248,6 +250,7 @@
     return current_param_name;
   }
   
+  last_returned_parameter = NULL; 
   param_count = 0;
   en_eno_param_implicit = false;
   next_param++;
@@ -268,6 +271,7 @@
   if (identifier == NULL)
     ERROR;
   current_param_name = identifier;
+  last_returned_parameter = current_param_name; 
   return current_param_name;
 }
 
@@ -281,6 +285,7 @@
   current_operation = function_param_iterator_c::search_op;
   void *res = f_decl->accept(*this);
   identifier_c *res_param_name = dynamic_cast<identifier_c *>((symbol_c *)res);
+  last_returned_parameter = res_param_name; 
   return res_param_name;
 }
 
@@ -288,28 +293,38 @@
  * or NULL if none is specified in the function declrataion itself.
  */
 symbol_c *function_param_iterator_c::default_value(void) {
+  if (NULL == last_returned_parameter) 
+    return NULL;
   return current_param_default_value;
 }
 
 /* Returns the currently referenced parameter's type name. */
 symbol_c *function_param_iterator_c::param_type(void) {
+  if (NULL == last_returned_parameter) 
+    return NULL;
   return current_param_type;
 }
 
 /* Returns if currently referenced parameter is an implicit defined EN/ENO parameter. */
 bool function_param_iterator_c::is_en_eno_param_implicit(void) {
+  if (NULL == last_returned_parameter) 
+    ERROR;
   return en_eno_param_implicit;
 }
 
 /* Returns if currently referenced parameter is an extensible parameter. */
 /* extensible paramters only occur in some standard functions, e.g. AND(word#34, word#44, word#65); */
 bool function_param_iterator_c::is_extensible_param(void) {
+  if (NULL == last_returned_parameter) 
+    ERROR;
   return current_param_is_extensible;
 }
 
 /* Returns the index of the current extensible parameter. */             
 /* If the current parameter is not an extensible paramter, returns -1 */
 int function_param_iterator_c::extensible_param_index(void) {
+  if (NULL == last_returned_parameter) 
+    ERROR;
   return (current_param_is_extensible? current_extensible_param_index : -1);
 }
 
@@ -323,6 +338,8 @@
  * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT
  */
 function_param_iterator_c::param_direction_t function_param_iterator_c::param_direction(void) {
+  if (NULL == last_returned_parameter) 
+    ERROR;
   return current_param_direction;
 }
 

--- a/absyntax_utils/function_param_iterator.hh	Fri Feb 03 10:54:35 2012 +0000
+++ b/absyntax_utils/function_param_iterator.hh	Fri Feb 03 14:43:14 2012 +0000
@@ -105,7 +105,10 @@
      */
     typedef enum {iterate_op, search_op} operation_t;
     operation_t current_operation;
-
+    
+    /* the last parameter/value returned by search() or next() */
+    symbol_c *last_returned_parameter; 
+    
   private:
     int   cmp_extparam_names(const char* s1, const char* s2);
     void* handle_param_list(list_c *list);

--- a/stage3/fill_candidate_datatypes.cc	Fri Feb 03 10:54:35 2012 +0000
+++ b/stage3/fill_candidate_datatypes.cc	Fri Feb 03 14:43:14 2012 +0000
@@ -67,6 +67,7 @@
 
 
 /* returns true if compatible function/FB invocation, otherwise returns false */
+/* Assumes that the candidate_datatype lists of all the parameters being passed haved already been filled in */
 bool fill_candidate_datatypes_c::match_nonformal_call(symbol_c *f_call, symbol_c *f_decl) {
 	symbol_c *call_param_value,  *param_type;
 	identifier_c *param_name;
@@ -104,6 +105,7 @@
 
 
 /* returns true if compatible function/FB invocation, otherwise returns false */
+/* Assumes that the candidate_datatype lists of all the parameters being passed haved already been filled in */
 bool fill_candidate_datatypes_c::match_formal_call(symbol_c *f_call, symbol_c *f_decl) {
 	symbol_c *call_param_value, *call_param_name, *param_type;
 	symbol_c *verify_duplicate_param;
@@ -130,7 +132,6 @@
 		/* Obtaining the type of the value being passed in the function call */
 		std::vector <symbol_c *>&call_param_types = call_param_value->candidate_datatypes;
 
-
 		/* Find the corresponding parameter in function declaration */
 		param_name = fp_iterator.search(call_param_name);
 		if(param_name == NULL) return false;
@@ -1671,6 +1672,9 @@
 	list_c *parameter_list;
 	list_c *parameter_candidate_datatypes;
 	symbol_c *returned_parameter_type;
+
+	if (debug) std::cout << "function()\n";
+
 	function_symtable_t::iterator lower = function_symtable.lower_bound(symbol->function_name);
 	function_symtable_t::iterator upper = function_symtable.upper_bound(symbol->function_name);
 	/* If the name of the function being called is not found in the function symbol table, then this is an invalid call */
@@ -1683,8 +1687,12 @@
 		parameter_list = (list_c *)symbol->nonformal_param_list;
 	else ERROR;
 	
-	if (debug) std::cout << "function()\n";
+	/* Fill in the candidate_datatypes lists of all the expressions used in the function call parameters */
 	parameter_list->accept(*this);
+
+	/* Look for all compatible function declarations, and add their return datatypes 
+	 * to the candidate_datatype list of this function invocation. 
+	 */
 	for(; lower != upper; lower++) {
 		bool compatible = false;
 		
@@ -1750,8 +1758,9 @@
 void *fill_candidate_datatypes_c::visit(fb_invocation_c *symbol) {
 	bool compatible = false;
 	symbol_c *fb_decl = search_varfb_instance_type->get_basetype_decl(symbol->fb_name);
-	
+	/* Although a call to a non-declared FB is a semantic error, this is currently caught by stage 2! */
 	if (NULL == fb_decl) ERROR;
+
 	if (symbol->   formal_param_list != NULL) {
 		symbol->formal_param_list->accept(*this);
 		compatible = match_formal_call(symbol, fb_decl);
@@ -1760,6 +1769,10 @@
 		symbol->nonformal_param_list->accept(*this);
 		compatible = match_nonformal_call(symbol, fb_decl);
 	}
+
+	if (compatible) 
+		symbol->called_fb_declaration = fb_decl;
+
 	if (debug) std::cout << "FB [] ==> "  << symbol->candidate_datatypes.size() << " result.\n";
 	return NULL;
 }

--- a/stage3/narrow_candidate_datatypes.cc	Fri Feb 03 10:54:35 2012 +0000
+++ b/stage3/narrow_candidate_datatypes.cc	Fri Feb 03 14:43:14 2012 +0000
@@ -84,20 +84,26 @@
 		do {
 			param_name = fp_iterator.next();
 			/* If there is no other parameter declared, then we are passing too many parameters... */
-			/* This error should have been caught in fill_candidate_datatypes_c, but may occur here again when we handle FB invocations! */
-			if(param_name == NULL) return;
+			/* This error should have been caught in fill_candidate_datatypes_c, but may occur here again when we handle FB invocations! 
+			 * In this case, we carry on analysing the code in order to be able to provide relevant error messages
+			 * for that code too!
+			 */
+			if(param_name == NULL) break;
 		} while ((strcmp(param_name->value, "EN") == 0) || (strcmp(param_name->value, "ENO") == 0));
 
 		/* Set the desired datatype for this parameter, and call it recursively. */
+		/* Note that if the call has more parameters than those declared in the function/FB declaration,
+		 * we may be setting this to NULL!
+		 */
 		call_param_value->datatype = base_type(fp_iterator.param_type());
-		if (NULL == call_param_value->datatype) ERROR;
+		if ((NULL != param_name) && (NULL == call_param_value->datatype)) ERROR;
+		if ((NULL == param_name) && (NULL != call_param_value->datatype)) ERROR;
 		call_param_value->accept(*this);
 
-		if (extensible_parameter_highest_index < fp_iterator.extensible_param_index())
-			extensible_parameter_highest_index = fp_iterator.extensible_param_index();
-	}
-	/* call is compatible! */
-
+		if (NULL != param_name) 
+			if (extensible_parameter_highest_index < fp_iterator.extensible_param_index())
+				extensible_parameter_highest_index = fp_iterator.extensible_param_index();
+	}
 	/* In the case of a call to an extensible function, we store the highest index 
 	 * of the extensible parameters this particular call uses, in the symbol_c object
 	 * of the function call itself!
@@ -135,12 +141,19 @@
 		param_name = fp_iterator.search(call_param_name);
 
 		/* Set the desired datatype for this parameter, and call it recursively. */
+		/* NOTE: When handling a FB call, this narrow_formal_call() may be called to analyse
+		 *       an invalid FB call (call with parameters that do not exist on the FB declaration).
+		 *       For this reason, the param_name may come out as NULL!
+		 */
 		call_param_value->datatype = base_type(fp_iterator.param_type());
-		if (NULL == call_param_value->datatype) ERROR;
+		if ((NULL != param_name) && (NULL == call_param_value->datatype)) ERROR;
+		if ((NULL == param_name) && (NULL != call_param_value->datatype)) ERROR;
+
 		call_param_value->accept(*this);
 
-		if (extensible_parameter_highest_index < fp_iterator.extensible_param_index())
-			extensible_parameter_highest_index = fp_iterator.extensible_param_index();
+		if (NULL != param_name) 
+			if (extensible_parameter_highest_index < fp_iterator.extensible_param_index())
+				extensible_parameter_highest_index = fp_iterator.extensible_param_index();
 	}
 	/* call is compatible! */
 
@@ -996,15 +1009,38 @@
 void *narrow_candidate_datatypes_c::visit(function_invocation_c *symbol) {
 	int  ext_parm_count;
 
-	/* set the called_function_declaration taking into account the datatype that we need to return */
+	/* set the called_function_declaration. */
 	symbol->called_function_declaration = NULL;
-	for(unsigned int i = 0; i < symbol->candidate_datatypes.size(); i++) {
-		if (is_type_equal(symbol->candidate_datatypes[i], symbol->datatype)) {
-			symbol->called_function_declaration = symbol->candidate_functions[i];
-			break;
-		}
-	}
-	if (NULL == symbol->called_function_declaration) ERROR;
+	if (symbol->candidate_datatypes.size() == 1) {
+		/* If only one possible called function, then that is the function to call!
+		 * In this case we ignore the symbol->datatype value (that may even be NULL).
+		 * This helps in identifying potential errors in the expressions used inside this function call
+		 * even if there is a previous error, allowing us to make a more thorough analysis of the semantics
+		 * of the ST code, and providing as many relevant error messages as possible!
+		 * If symbol->datatype isn't NULL, then this chosen function should be returning the required datatype,
+		 * otherwise we have a bug in our stage3 code!
+		 */
+		symbol->called_function_declaration = symbol->candidate_functions[0];
+		if ((NULL != symbol->datatype) && (!is_type_equal(symbol->candidate_datatypes[0], symbol->datatype)))
+			ERROR;
+	}
+	else {
+		/* set the called_function_declaration taking into account the datatype that we need to return */
+		symbol->called_function_declaration = NULL;
+		for(unsigned int i = 0; i < symbol->candidate_datatypes.size(); i++) {
+			if (is_type_equal(symbol->candidate_datatypes[i], symbol->datatype)) {
+				symbol->called_function_declaration = symbol->candidate_functions[i];
+				break;
+			}
+		}
+	}
+	/* NOTE: If we can't figure out the declaration of the function being called, this is not 
+	 *       necessarily an internal compiler error. It could be because the symbol->datatype is NULL
+	 *       (because the ST code being analysed has an error _before_ this function invocation).
+	 *       However, we don't just give, up, we carry on recursivly analysing the code, so as to be
+	 *       able to print out any error messages related to underlying code that could be partially correct.
+	 */
+	/* if (NULL == symbol->called_function_declaration) ERROR; */
 	
 	if (NULL != symbol->nonformal_param_list)  narrow_nonformal_call(symbol, symbol->called_function_declaration, &ext_parm_count);
 	if (NULL != symbol->   formal_param_list)     narrow_formal_call(symbol, symbol->called_function_declaration, &ext_parm_count);
@@ -1039,7 +1075,16 @@
 /*****************************************/
 
 void *narrow_candidate_datatypes_c::visit(fb_invocation_c *symbol) {
+	/* Note: We do not use the symbol->called_fb_declaration value (set in fill_candidate_datatypes_c)
+	 *       because we try to identify any other datatype errors in the expressions used in the 
+	 *       parameters to the FB call (e.g.  fb_var(var1 * 56 + func(var * 43)) )
+	 *       even it the call to the FB is invalid. 
+	 *       This makes sense because it may be errors in those expressions which are
+	 *       making this an invalid call, so it makes sense to point them out to the user!
+	 */
 	symbol_c *fb_decl = search_varfb_instance_type->get_basetype_decl(symbol->fb_name);
+
+	/* Although a call to a non-declared FB is a semantic error, this is currently caught by stage 2! */
 	if (NULL == fb_decl) ERROR;
 	if (NULL != symbol->nonformal_param_list)  narrow_nonformal_call(symbol, fb_decl);
 	if (NULL != symbol->   formal_param_list)     narrow_formal_call(symbol, fb_decl);