1 /*

     2  * (c) 2003 Mario de Sousa

     3  *

     4  * Offered to the public under the terms of the GNU General Public License

     5  * as published by the Free Software Foundation; either version 2 of the

     6  * License, or (at your option) any later version.

     7  *

     8  * This program is distributed in the hope that it will be useful, but

     9  * WITHOUT ANY WARRANTY; without even the implied warranty of

    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11  * Public License for more details.

    12  *

    13  * This code is made available on the understanding that it will not be

    14  * used in safety-critical situations without a full and competent review.

    15  */

    16 

    17 /*

    18  * An IEC 61131-3 IL and ST compiler.

    19  *

    20  * Based on the

    21  * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    22  *

    23  */

    24 

    25 

    26 /*

    27  * Function call parameter iterator.

    28  *

    29  * This is part of the 4th stage that generates

    30  * a c++ source program equivalent to the IL and ST

    31  * code.

    32  */

    33 

    34 

    35 //#include <stdio.h>  /* required for NULL */

    36 //#include <string>

    37 //#include <iostream>

    38 

    39 //#include "../../util/symtable.hh"

    40 

    41 //#include "generate_c.hh"

    42 

    43 

    44 

    45 

    46 /* given a function_body_c, iterate through each

    47  * function in/out/inout parameter, returning the name

    48  * of each parameter...

    49  */

    50 class function_call_iterator_c : public iterator_visitor_c {

    51   private:

    52     symbol_c *start_symbol;

    53     int next_fcall, fcall_count;

    54     //identifier_c *current_fcall_name;

    55     symbol_c *current_fcall_name;

    56     //function_invocation_c *current_finvocation;

    57     symbol_c *current_finvocation;

    58 

    59   public:

    60     /* initialise the iterator object.

    61      * We must be given a reference to the function declaration

    62      * that will be analysed...

    63      */

    64     function_call_iterator_c(symbol_c *symbol) {

    65       this->start_symbol = symbol;

    66       next_fcall = fcall_count = 0;

    67       current_finvocation = NULL;

    68       current_fcall_name = NULL;

    69     }

    70 

    71     /* Skip to the next function call. After object creation,

    72      * the object references _before_ the first, so

    73      * this function must be called once to get the object to

    74      * reference the first function call...

    75      *

    76      * Returns the function_invocation_c!

    77      */

    78     //function_invocation_c *next(void) {TRACE("function_call_iterator_c::next(): called ");

    79     symbol_c *next(void) {TRACE("function_call_iterator_c::next(): called ");

    80       fcall_count = 0;

    81       next_fcall++;

    82       current_finvocation = NULL;

    83       current_fcall_name = NULL;

    84 

    85       start_symbol->accept(*this);

    86       return current_finvocation;

    87     }

    88 

    89     /* Returns the name of the currently referenced function invocation */

    90     identifier_c *fname(void) {

    91       identifier_c *identifier = dynamic_cast<identifier_c *>(current_fcall_name);

    92       if (identifier == NULL) ERROR;

    93       return identifier;

    94     }

    95 

    96 

    97 /***************************************/

    98 /* B.3 - Language ST (Structured Text) */

    99 /***************************************/

   100 /***********************/

   101 /* B 3.1 - Expressions */

   102 /***********************/

   103   void *visit(function_invocation_c *symbol) {

   104     fcall_count++;

   105     if (next_fcall == fcall_count) {

   106       current_finvocation = symbol;

   107       current_fcall_name = symbol->function_name;

   108     }

   109     return NULL;

   110   }

   111 

   112 

   113 

   114 /****************************************/

   115 /* B.2 - Language IL (Instruction List) */

   116 /****************************************/

   117 /***********************************/

   118 /* B 2.1 Instructions and Operands */

   119 /***********************************/

   120 

   121 /* | function_name [il_operand_list] */

   122 // SYM_REF2(il_function_call_c, function_name, il_operand_list)

   123   void *visit(il_function_call_c *symbol) {

   124     fcall_count++;

   125     if (next_fcall == fcall_count) {

   126       current_finvocation = symbol;

   127       current_fcall_name = symbol->function_name;

   128     }

   129     return NULL;

   130   }

   131 

   132 

   133 

   134 /* | function_name '(' eol_list [il_param_list] ')' */

   135 // SYM_REF2(il_formal_funct_call_c, function_name, il_param_list)

   136   void *visit(il_formal_funct_call_c *symbol) {

   137     fcall_count++;

   138     if (next_fcall == fcall_count) {

   139       current_finvocation = symbol;

   140       current_fcall_name = symbol->function_name;

   141     }

   142     return NULL;

   143   }

   144 

   145 

   146 };

   147 

   148 

   149 

   150