matiec: comparison absyntax_utils/function_call_param

equal deleted inserted replaced

-:fde2d08ebaee
+:96d8b6e006f0
 *
 */
 /*
 * Function call parameter iterator.
-* It will iterate through the formal parameters of a function call
+* It will iterate through the non-formal parameters of a function call
 * (i.e. function calls using the foo(<param1>, <param2>, ...) syntax).
-* and/or search through the non-formal parameters of a function call
+* and/or search through the formal parameters of a function call
 * (i.e. function calls using the foo(<name1> = <param1>, <name2> = <param2>, ...) syntax).
 *
 * Calls to function blocks and programs are also supported.
 *
-* Note that calls to next() will only iterate through formal parameters,
+* Note that calls to next_nf() will only iterate through non-formal parameters,
-* and calls to search()  will only serach through non-formal parameters.
+* calls to next_f() will only iterate through formal parameters,
+* and calls to search_f() will only serach through formal parameters.
 */
 #include "function_call_param_iterator.hh"
 void *function_call_param_iterator_c::search_list(list_c *list) {
 switch (current_operation) {
-case iterate_op:
+case iterate_nf_op:
 for(int i = 0; i < list->n; i++) {
 void *res = list->elements[i]->accept(*this);
 if (NULL != res) {
 /* It went through the handle_parameter_assignment() function,
 * and is therefore a parameter assignment (<param> = <value>),
 * and not a simple expression (<value>).
 */
 /* we do nothing... */
 } else {
 param_count++;
-if (param_count == next_param) {
+if (param_count == iterate_nf_next_param) {
 return list->elements[i];
 }
 }
 }
 return NULL;
 break;
-case search_op:
+case iterate_f_op:
+for(int i = 0; i < list->n; i++) {
+void *res = list->elements[i]->accept(*this);
+if (NULL != res) {
+/* It went through the handle_parameter_assignment() function,
+* and is therefore a parameter assignment (<param> = <value>),
+* and not a simple expression (<value>).
+*/
+param_count++;
+if (param_count == iterate_f_next_param) {
+return res;
+}
+} else {
+/* we do nothing... */
+}
+}
+return NULL;
+break;
+case search_f_op:
 for(int i = 0; i < list->n; i++) {
 void *res = list->elements[i]->accept(*this);
 if (res != NULL)
 return res;
 }
 void *function_call_param_iterator_c::handle_parameter_assignment(symbol_c *variable_name, symbol_c *expression) {
 switch (current_operation) {
-case iterate_op:
+case iterate_nf_op:
 /* UGLY HACK -> this will be detected in the search_list() function */
-return (void *)this; /* anything, as long as it is not NULL!! */
+return (void *)variable_name; /* anything, as long as it is not NULL!! */
 break;
-case search_op:
+case iterate_f_op:
+current_value = expression;
+return (void *)variable_name;
+break;
+case search_f_op:
 identifier_c *variable_name2 = dynamic_cast<identifier_c *>(variable_name);
-if (variable_name2 == NULL) {
-en_param_c *en_param = dynamic_cast<en_param_c *>(variable_name);
-if (en_param != NULL)
-variable_name2 = new identifier_c("EN");
-}
-if (variable_name2 == NULL) {
-eno_param_c *eno_param = dynamic_cast<eno_param_c *>(variable_name);
-if (eno_param != NULL)
-variable_name2 = new identifier_c("ENO");
-}
 if (variable_name2 == NULL) ERROR;
 if (strcasecmp(search_param_name->value, variable_name2->value) == 0)
 /* FOUND! This is the same parameter!! */
 return (void *)expression;
 return NULL;
 break;
 }
 /* start off at the first parameter once again... */
 void function_call_param_iterator_c::reset(void) {
-next_param = param_count = 0;
+iterate_nf_next_param = 0;
+iterate_f_next_param  = 0;
+param_count = 0;
 }
 /* initialise the iterator object.
 * We must be given a reference to the function/program/function block call
 * that will be analysed...
 this->f_call = f_call;
 search_param_name = NULL;
 reset();
 }
-/* Skip to the next parameter. After object creation,
+/* Skip to the next formal parameter. After object creation,
 * the object references on parameter _before_ the first, so
 * this function must be called once to get the object to
 * reference the first parameter...
 *
-* Returns whatever is being passed to the parameter!
+* Returns the paramater name to which a value is being passed!
-*/
+* You can determine the value being passed by calling
-symbol_c *function_call_param_iterator_c::next(void) {
+* function_call_param_iterator_c::search_f()
+*/
+symbol_c *function_call_param_iterator_c::next_f(void) {
+current_value = NULL;
 param_count = 0;
-next_param++;
+iterate_f_next_param++;
-current_operation = function_call_param_iterator_c::iterate_op;
+current_operation = function_call_param_iterator_c::iterate_f_op;
 void *res = f_call->accept(*this);
 return (symbol_c *)res;
 }
+/* Skip to the next non-formal parameter. After object creation,
+* the object references on parameter _before_ the first, so
+* this function must be called once to get the object to
+* reference the first parameter...
+*
+* Returns whatever is being passed to the parameter!
+*/
+symbol_c *function_call_param_iterator_c::next_nf(void) {
+current_value = NULL;
+param_count = 0;
+iterate_nf_next_param++;
+current_operation = function_call_param_iterator_c::iterate_nf_op;
+void *res = f_call->accept(*this);
+current_value = (symbol_c *)res;
+return (symbol_c *)res;
+}
 /* Search for the value passed to the parameter named <param_name>...  */
-symbol_c *function_call_param_iterator_c::search(symbol_c *param_name) {
+symbol_c *function_call_param_iterator_c::search_f(symbol_c *param_name) {
+current_value = NULL;
 if (NULL == param_name) ERROR;
 search_param_name = dynamic_cast<identifier_c *>(param_name);
 if (NULL == search_param_name) ERROR;
-current_operation = function_call_param_iterator_c::search_op;
+current_operation = function_call_param_iterator_c::search_f_op;
 void *res = f_call->accept(*this);
+current_value = (symbol_c *)res;
 return (symbol_c *)res;
 }
+/* Returns the value being passed to the current parameter. */
+symbol_c *function_call_param_iterator_c::get_current_value(void) {
+return current_value;
+}
 /********************************/
 /* B 1.7 Configuration elements */
 /********************************/
 // TODO : We do not yet handle a instruction list passed as parameter !!!
 // since we do not yet support it, it is best to simply stop than to fail silently...
 if (NULL != symbol->simple_instr_list) ERROR;
-return handle_parameter_assignment(symbol->il_assign_operator, symbol->il_operand);
+return handle_parameter_assignment((symbol_c *)symbol->il_assign_operator->accept(*this), symbol->il_operand);
 }
 /*  il_assign_out_operator variable */
 // SYM_REF2(il_param_out_assignment_c, il_assign_out_operator, variable);
 void *function_call_param_iterator_c::visit(il_param_out_assignment_c *symbol) {
 /*******************/
 /* B 2.2 Operators */
 /*******************/
+/*  any_identifier ASSIGN */
+// SYM_REF1(il_assign_operator_c, variable_name)
+void *function_call_param_iterator_c::visit(il_assign_operator_c *symbol) {
+TRACE("il_assign_operator_c");
+return (void *)symbol->variable_name;
+}
 /*| [NOT] any_identifier SENDTO */
 // SYM_REF2(il_assign_out_operator_c, option, variable_name)
 void *function_call_param_iterator_c::visit(il_assign_out_operator_c *symbol) {
 TRACE("il_assign_out_operator_c");
 // TODO : Handle not_param !!!
 // we do not yet support it, so it is best to simply stop than to fail silently...
-if (NULL != symbol->option) ERROR;
+// if (NULL != symbol->option) ERROR;
 return (void *)symbol->variable_name;
 }
 /*
 SYM_REF2(function_invocation_c, function_name, parameter_assignment_list)
 */
 void *function_call_param_iterator_c::visit(function_invocation_c *symbol) {
 TRACE("function_invocation_c");
-if ((symbol_c *)symbol == f_call && symbol->parameter_assignment_list != NULL)
+/* If the syntax parser is working correctly, exactly one of the
-return symbol->parameter_assignment_list->accept(*this);
+* following two symbols will be NULL, while the other is != NULL.
-else
+*/
-return NULL;
+if (symbol->   formal_param_list != NULL) return symbol->   formal_param_list->accept(*this);
+if (symbol->nonformal_param_list != NULL) return symbol->nonformal_param_list->accept(*this);
+return NULL;
 }
 /********************/
 /* B 3.2 Statements */
 /* fb_name '(' [param_assignment_list] ')' */
 /* param_assignment_list -> may be NULL ! */
 // SYM_REF2(fb_invocation_c, fb_name, param_assignment_list)
 void *function_call_param_iterator_c::visit(fb_invocation_c *symbol) {
 TRACE("fb_invocation_c");
-if (symbol->param_assignment_list != NULL)
+/* If the syntax parser is working correctly, only one of the
-return symbol->param_assignment_list->accept(*this);
+* following two symbols will be != NULL.
-else
+* However, both may be NULL simultaneously!
-return NULL;
+*/
+if (symbol->   formal_param_list != NULL) return symbol->   formal_param_list->accept(*this);
+if (symbol->nonformal_param_list != NULL) return symbol->nonformal_param_list->accept(*this);
+return NULL;
 }
 /* helper symbol for fb_invocation */
 /* param_assignment_list ',' param_assignment */
 // SYM_LIST(param_assignment_list_c)

changeset 205	96d8b6e006f0
parent 202	da1a8186f86f
child 247	560075ece524