matiec: comparison absyntax_utils/function_param

equal deleted inserted replaced

-:aad38592bdde
+:c0bda77b37a0
 * function in/out/inout parameter, returning the name
 * of each parameter...function_param_iterator_c
 */
+#include "function_param_iterator.hh"  /* no longer required, aready included by absyntax_utils.hh */
-#include "absyntax_utils.hh"  /* required for extract_integer() */
+#include "spec_init_separator.hh"  /* no longer required, aready included by absyntax_utils.hh */
-// #include "function_param_iterator.hh"  /* no longer required, aready included by absyntax_utils.hh */
-// #include "spec_init_separator.hh"  /* no longer required, aready included by absyntax_utils.hh */
 #include <stdlib.h>  /* required for strtol() */
 #include <string.h>
 #include <strings.h>
+#include <limits> // required for std::numeric_limits< XXX >::max()
+#include <errno.h> // required for errno
+#include "../main.hh" // required for ERROR() and ERROR_MSG() macros.
 //#define DEBUG
 #ifdef DEBUG
 #define TRACE(classname) printf("\n____%s____\n",classname);
 #else
 #define TRACE(classname)
 #endif
-#define ERROR error_exit(__FILE__,__LINE__)
-/* function defined in main.cc */
-extern void error_exit(const char *file_name, int line_no);
+/* NOTE: The following function is not really needed, as we could get the value that constant_folding_c determined for this
+*       integer. Remember that currently constant_folding_c runs before this class is ever used/called!
+*       However, I (Mario) do not currently feel it would be a good idea to restrict the use of this
+*       abstract syntax utility to only after the constant_folding_c has had a chance to fill in the constant value
+*       of this symbol.
+*       For this reason only, I have opted to let this abstract syntax utility have its own private copy of the
+*       extract_integer() function.
+*       Another aspect that makes this OK is that this function will only be used to extract the integer value of the
+*       index for the first extensible paramater (examples follow shortly). Since this is an extension to IEC 61131-3
+*       that we created to allow us to handle extensible functions with very little hard coding, it is OK if we
+*       impose extra/different limits on how an integer may be legally be formated in this case. This will also
+*       only show up in code that describes the interface to the standard function of IEC 61131-3, which the user
+*       will not ever get to see. We write that IEC 61131-3 code ourselves!
+*
+*      Example of source code we will be parsing and analysing:
+*
+*      FUNCTION ADD : REAL VAR_INPUT IN 1 .. : REAL; END_VAR RETURN; END_FUNCTION
+*                                      ^^^
+*
+*      FUNCTION MUX : REAL VAR_INPUT K : USINT; IN 0 .. : REAL; END_VAR RETURN; END_FUNCTION
+*                                                 ^^^
+*
+*      Basically, currently this will only be either a '0' or a '1' !!
+*/
+/* NOTE: it must ignore underscores! */
+static int extract_first_index_value(symbol_c *sym) {
+std::string str = "";
+integer_c *integer;
+long int ret;
+if ((integer = dynamic_cast<integer_c *>(sym)) == NULL) ERROR;
+for(unsigned int i = 0; i < strlen(integer->value); i++)
+if (integer->value[i] != '_')  str += integer->value[i];
+errno = 0; // since strtoXX() may legally return 0, we must set errno to 0 to detect errors correctly!
+ret = strtol(str.c_str(), NULL, 10);
+if (errno != 0) ERROR;
+if (ret < 0) ERROR; // the following code assumes that the first index will never be negative!
+if (ret > std::numeric_limits< int >::max()) ERROR; // output of this function is only an int!!
+return ret;
+}
 /* compare the name of two __extensible__ function parameters.
 * The usual use case is to have one of the parameters as used
 symbol_c *sym = list->elements[i];
 extensible_input_parameter_c *extensible_parameter = dynamic_cast<extensible_input_parameter_c *>(sym);
 if (extensible_parameter != NULL) {
 sym = extensible_parameter->var_name;
 current_param_is_extensible = true;
-_first_extensible_param_index = extract_integer(extensible_parameter->first_index);
+_first_extensible_param_index = extract_first_index_value(extensible_parameter->first_index);
 }
 identifier_c *variable_name = dynamic_cast<identifier_c *>(sym);
 if (variable_name == NULL) ERROR;
 if (!current_param_is_extensible)
 case search_op:
 extensible_input_parameter_c *extensible_parameter = dynamic_cast<extensible_input_parameter_c *>(var_name);
 if (extensible_parameter != NULL) {
 var_name = extensible_parameter->var_name;
 current_param_is_extensible = true;
-_first_extensible_param_index = extract_integer(extensible_parameter->first_index);
+_first_extensible_param_index = extract_first_index_value(extensible_parameter->first_index);
 }
 identifier_c *variable_name = dynamic_cast<identifier_c *>(var_name);
 if (variable_name == NULL) ERROR;
 if (!current_param_is_extensible)
 void function_param_iterator_c::reset(void) {
 next_param = param_count = 0;
 _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() */
 }
 /* initialise the iterator object.
 * We must be given a reference to one of the following
 /* do some consistency checks... */
 function_declaration_c       * f_decl = dynamic_cast<function_declaration_c       *>(pou_decl);
 function_block_declaration_c *fb_decl = dynamic_cast<function_block_declaration_c *>(pou_decl);
 program_declaration_c        * p_decl = dynamic_cast<program_declaration_c        *>(pou_decl);
-if ((NULL == f_decl) && (NULL == fb_decl) && (NULL == p_decl)) ERROR;
+if ((NULL == f_decl) && (NULL == fb_decl) && (NULL == p_decl))
+ERROR;
 /* OK. Now initialise this object... */
 this->f_decl = pou_decl;
 reset();
 }
 if (current_param_is_extensible) {
 current_extensible_param_index++;
 return current_param_name;
 }
+last_returned_parameter = NULL;
 param_count = 0;
 en_eno_param_implicit = false;
 next_param++;
 current_operation = function_param_iterator_c::iterate_op;
 res = f_decl->accept(*this);
 symbol_c *sym = (symbol_c *)res;
 extensible_input_parameter_c *extensible_parameter = dynamic_cast<extensible_input_parameter_c *>(sym);
 if (extensible_parameter != NULL) {
 sym = extensible_parameter->var_name;
 current_param_is_extensible = true;
-_first_extensible_param_index = extract_integer(extensible_parameter->first_index);
+_first_extensible_param_index = extract_first_index_value(extensible_parameter->first_index);
 current_extensible_param_index = _first_extensible_param_index;
 }
 identifier = dynamic_cast<identifier_c *>(sym);
 if (identifier == NULL)
 ERROR;
 current_param_name = identifier;
+last_returned_parameter = current_param_name;
 return current_param_name;
 }
 /* Search for the value passed to the parameter named <param_name>...  */
 identifier_c *function_param_iterator_c::search(symbol_c *param_name) {
 en_eno_param_implicit = false;
 current_param_is_extensible = false;
 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;
 }
+identifier_c *function_param_iterator_c::search(const char *param_name) {
+identifier_c   param_name_id(param_name);
+return search(&param_name_id);
+}
 /* Returns the currently referenced parameter's default value,
 * 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);
 }
 /* Returns the index of the first extensible parameter, or -1 if no extensible parameter found. */
 /* WARNING: Will only return the correct value _after_ an extensible parameter has been found! */
 /* Returns the currently referenced parameter's data passing direction.
 * 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;
 }
 void *function_param_iterator_c::visit(implicit_definition_c *symbol) {
 	en_eno_param_implicit = true;

changeset 625	c0bda77b37a0
parent 596	4efb11e44065
child 662	b1b11dd09a54