stage4/generate_c/generate_c_st.cc
author mjsousa
Sun, 13 Jul 2014 12:26:58 +0100
changeset 909 8b2a31dea131
parent 897 8c3e91c385f5
child 911 ef3347dbfa0c
permissions -rwxr-xr-x
Add support for REF_TO derived datatypes (along with datatype verification)
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
     1
/*
279
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
     2
 *  matiec - a compiler for the programming languages defined in IEC 61131-3
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
     3
 *
279
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
     4
 *  Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
     5
 *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
     6
 *
279
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
     7
 *  This program is free software: you can redistribute it and/or modify
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
     8
 *  it under the terms of the GNU General Public License as published by
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
     9
 *  the Free Software Foundation, either version 3 of the License, or
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
    10
 *  (at your option) any later version.
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
    11
 *
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
    12
 *  This program is distributed in the hope that it will be useful,
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
    13
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
    14
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
    15
 *  GNU General Public License for more details.
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
    16
 *
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
    17
 *  You should have received a copy of the GNU General Public License
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
    18
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    19
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    20
 * This code is made available on the understanding that it will not be
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    21
 * used in safety-critical situations without a full and competent review.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    22
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    23
 * Based on the
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    24
 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    25
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    26
 */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    27
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    28
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    29
/*
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    30
 * Conversion of st statements (i.e. ST code).
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    31
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    32
 * This is part of the 4th stage that generates
279
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 258
diff changeset
    33
 * a C source program equivalent to the IL and ST, or SFC
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    34
 * code.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    35
 */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    36
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    37
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
    38
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
    39
#include "../../util/strdup.hh"
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
    40
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    41
/***********************************************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    42
/***********************************************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    43
/***********************************************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    44
/***********************************************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    45
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    46
861
443e8243f289 Code cleanup (part 3): generate_c_typedecl_c is no longer needed for code generation in POUS.c It is now only needed for datatype declaration in POUS.h
mjsousa
parents: 855
diff changeset
    47
class generate_c_st_c: public generate_c_base_c {
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    48
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    49
  public:
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    50
    typedef enum {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    51
      expression_vg,
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
    52
      complextype_base_vg,
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
    53
      complextype_suffix_vg,
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    54
      fparam_output_vg
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    55
    } variablegeneration_t;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    56
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
    57
    typedef enum {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
    58
      single_cg,
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
    59
      subrange_cg,
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
    60
      none_cg
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
    61
    } casegeneration_t;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
    62
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    63
  private:
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    64
    /* When calling a function block, we must first find it's type,
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    65
     * by searching through the declarations of the variables currently
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    66
     * in scope.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    67
     * This class does just that...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    68
     * A new class is instantiated whenever we begin generating the code
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    69
     * for a function block type declaration, or a program declaration.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    70
     * This object instance will then later be called while the
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    71
     * function block's or the program's body is being handled.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    72
     *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    73
     * Note that functions cannot contain calls to function blocks,
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    74
     * so we do not create an object instance when handling
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    75
     * a function declaration.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    76
     */
863
06820d03a433 Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents: 854
diff changeset
    77
    search_fb_instance_decl_c    *search_fb_instance_decl;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    78
    search_varfb_instance_type_c *search_varfb_instance_type;
505
21be0f2f242d Removing code from search_varfb_instance_type_c (use search_var_instance_decl_c instead).
Mario de Sousa <msousa@fe.up.pt>
parents: 503
diff changeset
    79
    search_var_instance_decl_c   *search_var_instance_decl;
863
06820d03a433 Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents: 854
diff changeset
    80
    
06820d03a433 Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents: 854
diff changeset
    81
    symbol_c *scope_;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    82
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
    83
    symbol_c* current_array_type;
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
    84
    symbol_c* current_param_type;
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
    85
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    86
    int fcall_number;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    87
    symbol_c *fbname;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    88
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
    89
    bool first_subrange_case_list;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
    90
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    91
    variablegeneration_t wanted_variablegeneration;
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
    92
    casegeneration_t wanted_casegeneration;
145
72ae82e65dbc Adding support for ouput variables in functions
lbessard
parents: 130
diff changeset
    93
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    94
  public:
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    95
    generate_c_st_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL)
861
443e8243f289 Code cleanup (part 3): generate_c_typedecl_c is no longer needed for code generation in POUS.c It is now only needed for datatype declaration in POUS.h
mjsousa
parents: 855
diff changeset
    96
    : generate_c_base_c(s4o_ptr) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
    97
      search_fb_instance_decl    = new search_fb_instance_decl_c   (scope);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    98
      search_varfb_instance_type = new search_varfb_instance_type_c(scope);
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
    99
      search_var_instance_decl   = new search_var_instance_decl_c  (scope);
863
06820d03a433 Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents: 854
diff changeset
   100
      scope_ = scope;
505
21be0f2f242d Removing code from search_varfb_instance_type_c (use search_var_instance_decl_c instead).
Mario de Sousa <msousa@fe.up.pt>
parents: 503
diff changeset
   101
      
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   102
      this->set_variable_prefix(variable_prefix);
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   103
      current_array_type = NULL;
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   104
      current_param_type = NULL;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   105
      fcall_number = 0;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   106
      fbname = name;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   107
      wanted_variablegeneration = expression_vg;
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   108
      wanted_casegeneration = none_cg;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   109
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   110
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   111
    virtual ~generate_c_st_c(void) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   112
      delete search_fb_instance_decl;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   113
      delete search_varfb_instance_type;
505
21be0f2f242d Removing code from search_varfb_instance_type_c (use search_var_instance_decl_c instead).
Mario de Sousa <msousa@fe.up.pt>
parents: 503
diff changeset
   114
      delete search_var_instance_decl;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   115
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   116
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   117
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   118
  public:
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   119
    void generate(statement_list_c *stl) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   120
      stl->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   121
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   122
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   123
  private:
531
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   124
    
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   125
    
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   126
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   127
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   128
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   129
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   130
void *print_getter(symbol_c *symbol) {
863
06820d03a433 Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents: 854
diff changeset
   131
  unsigned int vartype = analyse_variable_c::first_nonfb_vardecltype(symbol, scope_);
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   132
  if (wanted_variablegeneration == fparam_output_vg) {
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   133
    if (vartype == search_var_instance_decl_c::external_vt) {
854
13d0b67de111 Code cleanup: move datatype analysis to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents: 852
diff changeset
   134
      if (!get_datatype_info_c::is_type_valid    (symbol->datatype)) ERROR;
13d0b67de111 Code cleanup: move datatype analysis to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents: 852
diff changeset
   135
      if ( get_datatype_info_c::is_function_block(symbol->datatype))
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   136
        s4o.print(GET_EXTERNAL_FB_BY_REF);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   137
      else
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   138
        s4o.print(GET_EXTERNAL_BY_REF);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   139
    }
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   140
    else if (vartype == search_var_instance_decl_c::located_vt)
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   141
      s4o.print(GET_LOCATED_BY_REF);
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   142
    else
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   143
      s4o.print(GET_VAR_BY_REF);
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   144
  }
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   145
  else {
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   146
    if (vartype == search_var_instance_decl_c::external_vt) {
854
13d0b67de111 Code cleanup: move datatype analysis to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents: 852
diff changeset
   147
      if (!get_datatype_info_c::is_type_valid    (symbol->datatype)) ERROR;
13d0b67de111 Code cleanup: move datatype analysis to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents: 852
diff changeset
   148
      if ( get_datatype_info_c::is_function_block(symbol->datatype))
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   149
        s4o.print(GET_EXTERNAL_FB);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   150
      else
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   151
        s4o.print(GET_EXTERNAL);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   152
    }
503
e1e7c7678c44 Edit formating and delete unused code.
Mario de Sousa <msousa@fe.up.pt>
parents: 498
diff changeset
   153
    else if (vartype == search_var_instance_decl_c::located_vt)
e1e7c7678c44 Edit formating and delete unused code.
Mario de Sousa <msousa@fe.up.pt>
parents: 498
diff changeset
   154
      s4o.print(GET_LOCATED);
e1e7c7678c44 Edit formating and delete unused code.
Mario de Sousa <msousa@fe.up.pt>
parents: 498
diff changeset
   155
    else
e1e7c7678c44 Edit formating and delete unused code.
Mario de Sousa <msousa@fe.up.pt>
parents: 498
diff changeset
   156
      s4o.print(GET_VAR);
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   157
  }
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   158
  
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   159
  variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration;
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   160
  s4o.print("(");
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   161
  print_variable_prefix();  
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   162
  wanted_variablegeneration = complextype_base_vg;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   163
  symbol->accept(*this);
851
2c59c2b8fca4 Fix bug/issue #33 (correctly access struct/array variables declared inside a FB -> r:=FB1.FB2.struct1.array1[3] )
Mario de Sousa <msousa@fe.up.pt>
parents: 800
diff changeset
   164
  s4o.print(",");
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   165
  wanted_variablegeneration = complextype_suffix_vg;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   166
  symbol->accept(*this);
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   167
  s4o.print(")");
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   168
  wanted_variablegeneration = old_wanted_variablegeneration;
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   169
  return NULL;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   170
}
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   171
852
efb44e892582 Fix bug: allow use, as lvalues, structures/arrays inside FBs (e.g. fb1.struct1.r := 33.3).
Mario de Sousa <msousa@fe.up.pt>
parents: 851
diff changeset
   172
efb44e892582 Fix bug: allow use, as lvalues, structures/arrays inside FBs (e.g. fb1.struct1.r := 33.3).
Mario de Sousa <msousa@fe.up.pt>
parents: 851
diff changeset
   173
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   174
void *print_setter(symbol_c* symbol,
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   175
        symbol_c* type,
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   176
        symbol_c* value,
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   177
        symbol_c* fb_symbol = NULL,
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   178
        symbol_c* fb_value = NULL) {
888
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   179
 
405
7b5d67d1aeef Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents: 399
diff changeset
   180
  if (fb_symbol == NULL) {
863
06820d03a433 Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents: 854
diff changeset
   181
    unsigned int vartype = analyse_variable_c::first_nonfb_vardecltype(symbol, scope_);
889
5f380b99e95e Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents: 888
diff changeset
   182
    symbol_c *first_nonfb = analyse_variable_c::find_first_nonfb(symbol);
5f380b99e95e Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents: 888
diff changeset
   183
    if (first_nonfb == NULL) ERROR;
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   184
    if (vartype == search_var_instance_decl_c::external_vt) {
889
5f380b99e95e Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents: 888
diff changeset
   185
      if (!get_datatype_info_c::is_type_valid    (first_nonfb->datatype)) ERROR;
5f380b99e95e Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents: 888
diff changeset
   186
      if ( get_datatype_info_c::is_function_block(first_nonfb->datatype)) // handle situation where we are copying a complete fb -> fb1.fb2.fb3 := fb4 (and fb3 is external!)
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   187
        s4o.print(SET_EXTERNAL_FB);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   188
      else
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   189
        s4o.print(SET_EXTERNAL);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   190
    }
405
7b5d67d1aeef Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents: 399
diff changeset
   191
    else if (vartype == search_var_instance_decl_c::located_vt)
7b5d67d1aeef Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents: 399
diff changeset
   192
      s4o.print(SET_LOCATED);
7b5d67d1aeef Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents: 399
diff changeset
   193
    else
7b5d67d1aeef Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents: 399
diff changeset
   194
      s4o.print(SET_VAR);
7b5d67d1aeef Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents: 399
diff changeset
   195
  }
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   196
  else {
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   197
    unsigned int vartype = search_var_instance_decl->get_vartype(fb_symbol);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   198
    if (vartype == search_var_instance_decl_c::external_vt)
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   199
      s4o.print(SET_EXTERNAL_FB);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   200
    else
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   201
      s4o.print(SET_VAR);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   202
  }
392
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 387
diff changeset
   203
  s4o.print("(");
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   204
  
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   205
  if (fb_symbol != NULL) {
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   206
    print_variable_prefix();
888
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   207
    // It is my (MJS) conviction that by this time the following will always be true...
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   208
    //   wanted_variablegeneration == expression_vg;
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   209
    fb_symbol->accept(*this);
392
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 387
diff changeset
   210
    s4o.print(".,");
888
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   211
    symbol->accept(*this);
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   212
    s4o.print(",");
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   213
    s4o.print(",");    
897
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   214
  } else {
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   215
    print_variable_prefix();
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   216
    s4o.print(",");    
888
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   217
    wanted_variablegeneration = complextype_base_vg;
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   218
    symbol->accept(*this);
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   219
    s4o.print(",");
885
b2604fc6d25c Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents: 877
diff changeset
   220
    wanted_variablegeneration = complextype_suffix_vg;
b2604fc6d25c Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents: 877
diff changeset
   221
    symbol->accept(*this);
888
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   222
    s4o.print(",");
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   223
  }
885
b2604fc6d25c Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents: 877
diff changeset
   224
  wanted_variablegeneration = expression_vg;
b2604fc6d25c Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents: 877
diff changeset
   225
  print_check_function(type, value, fb_value);
b2604fc6d25c Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents: 877
diff changeset
   226
  s4o.print(")");
b2604fc6d25c Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents: 877
diff changeset
   227
  wanted_variablegeneration = expression_vg;
b2604fc6d25c Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents: 877
diff changeset
   228
  return NULL;
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   229
}
146
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 145
diff changeset
   230
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   231
/********************************/
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   232
/* B 1.3.3 - Derived data types */
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   233
/********************************/
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   234
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   235
/*  signed_integer DOTDOT signed_integer */
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   236
void *visit(subrange_c *symbol) {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   237
  switch (wanted_casegeneration) {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   238
    case subrange_cg:
376
7dcbd8418771 Making case statement code generated safer
laurent
parents: 375
diff changeset
   239
      s4o.print("__case_expression >= ");
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   240
      symbol->lower_limit->accept(*this);
376
7dcbd8418771 Making case statement code generated safer
laurent
parents: 375
diff changeset
   241
      s4o.print(" && __case_expression <= ");
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   242
      symbol->upper_limit->accept(*this);
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   243
      break;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   244
    default:
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   245
      symbol->lower_limit->accept(*this);
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   246
      break;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   247
  }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   248
  return NULL;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   249
}
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   250
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   251
/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   252
void *visit(array_specification_c *symbol) {
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   253
  symbol->non_generic_type_name->accept(*this);
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   254
  return NULL;
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   255
}
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   256
800
2481fffe6e58 Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents: 793
diff changeset
   257
/*  enumerated_type_name ':' enumerated_spec_init */
2481fffe6e58 Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents: 793
diff changeset
   258
void *visit(enumerated_type_declaration_c *symbol) {
2481fffe6e58 Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents: 793
diff changeset
   259
  symbol->enumerated_type_name->accept(*this);
2481fffe6e58 Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents: 793
diff changeset
   260
  return NULL;
2481fffe6e58 Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents: 793
diff changeset
   261
}
2481fffe6e58 Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents: 793
diff changeset
   262
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   263
/*********************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   264
/* B 1.4 - Variables */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   265
/*********************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   266
void *visit(symbolic_variable_c *symbol) {
382
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   267
  switch (wanted_variablegeneration) {
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   268
    case complextype_base_vg:
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   269
      symbol->var_name->accept(*this); //generate_c_base_c::visit(symbol);
382
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   270
      break;
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   271
    case complextype_suffix_vg:
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   272
      break;
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   273
    default:
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   274
      if (this->is_variable_prefix_null()) {
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   275
        if (wanted_variablegeneration == fparam_output_vg) {
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   276
          s4o.print("&(");
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   277
          generate_c_base_c::visit(symbol);
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   278
          s4o.print(")");
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   279
        }
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   280
        else {
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   281
          generate_c_base_c::visit(symbol);
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   282
        }
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   283
      }
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   284
      else
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   285
        print_getter(symbol);
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   286
      break;
ac6dfec701c9 Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents: 377
diff changeset
   287
  }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   288
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   289
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   290
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   291
/********************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   292
/* B.1.4.1   Directly Represented Variables */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   293
/********************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   294
// direct_variable: direct_variable_token   {$$ = new direct_variable_c($1);};
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   295
void *visit(direct_variable_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   296
  TRACE("direct_variable_c");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   297
  /* Do not use print_token() as it will change everything into uppercase */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   298
  if (strlen(symbol->value) == 0) ERROR;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   299
  if (this->is_variable_prefix_null()) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   300
    if (wanted_variablegeneration != fparam_output_vg)
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   301
      s4o.print("*(");
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   302
  }
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   303
  else {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   304
    switch (wanted_variablegeneration) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   305
      case expression_vg:
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   306
        s4o.print(GET_LOCATED);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   307
        s4o.print("(");
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   308
        break;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   309
      case fparam_output_vg:
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   310
        s4o.print(GET_LOCATED_BY_REF);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   311
        s4o.print("(");
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   312
        break;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   313
      default:
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   314
        break;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   315
    }
145
72ae82e65dbc Adding support for ouput variables in functions
lbessard
parents: 130
diff changeset
   316
  }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   317
  this->print_variable_prefix();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   318
  s4o.printlocation(symbol->value + 1);
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   319
  if (( this->is_variable_prefix_null() && (wanted_variablegeneration != fparam_output_vg)) ||
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   320
      (!this->is_variable_prefix_null() && (wanted_variablegeneration == expression_vg   )) ||
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   321
      (!this->is_variable_prefix_null() && (wanted_variablegeneration == fparam_output_vg)))
145
72ae82e65dbc Adding support for ouput variables in functions
lbessard
parents: 130
diff changeset
   322
    s4o.print(")");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   323
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   324
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   325
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   326
/*************************************/
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   327
/* B.1.4.2   Multi-element Variables */
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   328
/*************************************/
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   329
221
c6aed7e5f070 Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents: 220
diff changeset
   330
// SYM_REF2(structured_variable_c, record_variable, field_selector)
c6aed7e5f070 Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents: 220
diff changeset
   331
void *visit(structured_variable_c *symbol) {
c6aed7e5f070 Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents: 220
diff changeset
   332
  TRACE("structured_variable_c");
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   333
  switch (wanted_variablegeneration) {
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   334
    case complextype_base_vg:
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   335
      symbol->record_variable->accept(*this);
897
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   336
      /* NOTE: The following test includes a special case for SFC Steps. They are currently mapped onto a C data structure
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   337
       *        that does not follow the standard IEC_<typename> pattern used for user defined structure datatypes 
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   338
       *        (i.e. it does not include the 'values' and 'flag' structure 
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   339
       *        elements that are tested by __GET_VAR and __SET_VAR acessor macros defined in acessor.h). However, the
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   340
       *        STEP.T and STEP.X elements of this step structure are of the IEC_BOOL and IEC_TIME datatypes, and are 
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   341
       *        actually structures that do have the 'value' and 'flags' elements. So, it is safe to say that any  variable
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   342
       *        that is a STEPname is not of a complex type, as its .T and .X elements are and can later be safely accessed
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   343
       *        using the __SET_VAR and __GET_VAR macros.
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   344
       * 
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   345
       *        For the above reason, a STEP must be handled as a FB, i.e. it does NOT contain the 'flags' and 'value' elements!
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   346
       */
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   347
      if (   get_datatype_info_c::is_function_block(symbol->record_variable->datatype)
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   348
          || get_datatype_info_c::is_sfc_step      (symbol->record_variable->datatype)) {
889
5f380b99e95e Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents: 888
diff changeset
   349
        if (NULL == symbol->record_variable->scope) ERROR;
5f380b99e95e Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents: 888
diff changeset
   350
        search_var_instance_decl_c search_var_instance_decl(symbol->record_variable->scope);
5f380b99e95e Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents: 888
diff changeset
   351
        if (search_var_instance_decl_c::external_vt == search_var_instance_decl.get_vartype(get_var_name_c::get_last_field(symbol->record_variable)))
5f380b99e95e Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents: 888
diff changeset
   352
          s4o.print("->");
5f380b99e95e Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents: 888
diff changeset
   353
        else  
5f380b99e95e Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents: 888
diff changeset
   354
          s4o.print(".");
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   355
        symbol->field_selector->accept(*this);
410
c6486bd97392 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 406
diff changeset
   356
      }
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   357
      break;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   358
    case complextype_suffix_vg:
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   359
      symbol->record_variable->accept(*this);
897
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   360
      // the following condition MUST be a negation of the above condition used in the 'case complextype_base_vg:'
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   361
      if (!(   get_datatype_info_c::is_function_block(symbol->record_variable->datatype)     // if the record variable is not a FB... 
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   362
            || get_datatype_info_c::is_sfc_step      (symbol->record_variable->datatype))) { // ...nor an SFC step name, then it will certainly be a structure!
410
c6486bd97392 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 406
diff changeset
   363
        s4o.print(".");
c6486bd97392 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 406
diff changeset
   364
        symbol->field_selector->accept(*this);
c6486bd97392 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 406
diff changeset
   365
      }
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   366
      break;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   367
    default:
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   368
      if (this->is_variable_prefix_null()) {
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   369
        symbol->record_variable->accept(*this);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   370
        s4o.print(".");
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   371
        symbol->field_selector->accept(*this);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   372
      }
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   373
      else
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   374
        print_getter(symbol);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   375
      break;
221
c6aed7e5f070 Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents: 220
diff changeset
   376
  }
c6aed7e5f070 Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents: 220
diff changeset
   377
  return NULL;
c6aed7e5f070 Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents: 220
diff changeset
   378
}
c6aed7e5f070 Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents: 220
diff changeset
   379
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   380
/*  subscripted_variable '[' subscript_list ']' */
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   381
//SYM_REF2(array_variable_c, subscripted_variable, subscript_list)
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   382
void *visit(array_variable_c *symbol) {
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   383
  switch (wanted_variablegeneration) {
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   384
    case complextype_base_vg:
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   385
      symbol->subscripted_variable->accept(*this);
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   386
      break;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   387
    case complextype_suffix_vg:
238
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   388
      symbol->subscripted_variable->accept(*this);
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   389
417
d48f53715f77 Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents: 392
diff changeset
   390
      current_array_type = search_varfb_instance_type->get_basetype_decl(symbol->subscripted_variable);
238
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   391
      if (current_array_type == NULL) ERROR;
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   392
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   393
      s4o.print(".table");
298
022a874149ce Fixing code generation of array indexes in Function Blocks.
Mario de Sousa <msousa@fe.up.pt>
parents: 283
diff changeset
   394
      wanted_variablegeneration = expression_vg;
238
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   395
      symbol->subscript_list->accept(*this);
298
022a874149ce Fixing code generation of array indexes in Function Blocks.
Mario de Sousa <msousa@fe.up.pt>
parents: 283
diff changeset
   396
      wanted_variablegeneration = complextype_suffix_vg;
238
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   397
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   398
      current_array_type = NULL;
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   399
      break;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   400
    default:
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   401
      if (this->is_variable_prefix_null()) {
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   402
        symbol->subscripted_variable->accept(*this);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   403
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   404
        current_array_type = search_varfb_instance_type->get_basetype_decl(symbol->subscripted_variable);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   405
        if (current_array_type == NULL) ERROR;
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   406
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   407
        s4o.print(".table");
238
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   408
        symbol->subscript_list->accept(*this);
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   409
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   410
        current_array_type = NULL;
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   411
      }
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   412
      else
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   413
        print_getter(symbol);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   414
      break;
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   415
  }
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   416
  return NULL;
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   417
}
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   418
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   419
/* subscript_list ',' subscript */
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   420
void *visit(subscript_list_c *symbol) {
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   421
  array_dimension_iterator_c* array_dimension_iterator = new array_dimension_iterator_c(current_array_type);
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   422
  for (int i =  0; i < symbol->n; i++) {
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   423
    symbol_c* dimension = array_dimension_iterator->next();
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   424
    if (dimension == NULL) ERROR;
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   425
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   426
    s4o.print("[(");
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   427
    symbol->elements[i]->accept(*this);
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   428
    s4o.print(") - (");
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   429
    dimension->accept(*this);
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   430
    s4o.print(")]");
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   431
  }
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   432
  delete array_dimension_iterator;
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   433
  return NULL;
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   434
}
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   435
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   436
/******************************************/
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   437
/* B 1.4.3 - Declaration & Initialisation */
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   438
/******************************************/
237
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   439
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   440
/* helper symbol for structure_initialization */
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   441
/* structure_element_initialization_list ',' structure_element_initialization */
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   442
void *visit(structure_element_initialization_list_c *symbol) {
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   443
  generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o);
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   444
  structure_initialization->init_structure_default(this->current_param_type);
237
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   445
  structure_initialization->init_structure_values(symbol);
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   446
  delete structure_initialization;
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   447
  return NULL;
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   448
}
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   449
237
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   450
/* helper symbol for array_initialization */
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   451
/* array_initial_elements_list ',' array_initial_elements */
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   452
void *visit(array_initial_elements_list_c *symbol) {
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   453
  generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o);
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   454
  array_initialization->init_array_size(this->current_param_type);
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   455
  array_initialization->init_array_values(symbol);
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   456
  delete array_initialization;
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   457
  return NULL;
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   458
}
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   459
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   460
/***************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   461
/* B.3 - Language ST (Structured Text) */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   462
/***************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   463
/***********************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   464
/* B 3.1 - Expressions */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   465
/***********************/
873
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   466
void *visit(ref_expression_c *symbol) {
909
8b2a31dea131 Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents: 897
diff changeset
   467
  s4o.print("(");  
8b2a31dea131 Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents: 897
diff changeset
   468
  s4o.print("(IEC_UDINT)");  
873
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   469
  if (this->is_variable_prefix_null()) {  
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   470
    /* For code in FUNCTIONs */
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   471
    s4o.print("&(");  
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   472
    symbol->exp->accept(*this);    
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   473
    s4o.print(")");  
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   474
  } else {
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   475
    /* For code in FBs, and PROGRAMS... */
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   476
    s4o.print("(");  
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   477
    unsigned int vartype = analyse_variable_c::first_nonfb_vardecltype(symbol->exp, scope_);
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   478
    if (vartype == search_var_instance_decl_c::external_vt) {
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   479
      if (!get_datatype_info_c::is_type_valid    (symbol->exp->datatype)) ERROR;
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   480
      if ( get_datatype_info_c::is_function_block(symbol->exp->datatype))
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   481
        s4o.print(GET_EXTERNAL_FB_REF);
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   482
      else
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   483
        s4o.print(GET_EXTERNAL_REF);
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   484
    }
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   485
    else if (vartype == search_var_instance_decl_c::located_vt)
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   486
      s4o.print(GET_LOCATED_REF);
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   487
    else
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   488
      s4o.print(GET_VAR_REF);
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   489
    
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   490
    variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration; 
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   491
    s4o.print("(");
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   492
    wanted_variablegeneration = complextype_base_vg;
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   493
    print_variable_prefix();
873
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   494
    symbol->exp->accept(*this);
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   495
    s4o.print(",");
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   496
    wanted_variablegeneration = complextype_suffix_vg;
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   497
    symbol->exp->accept(*this);
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   498
    s4o.print(")");
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   499
    wanted_variablegeneration = old_wanted_variablegeneration;
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   500
    
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   501
    s4o.print(")");  
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   502
  }
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   503
  s4o.print(")");  
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   504
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   505
  return NULL;
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   506
}
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   507
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   508
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   509
void *visit(or_expression_c *symbol) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   510
  if (get_datatype_info_c::is_BOOL_compatible(symbol->datatype))
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   511
    return print_binary_expression(symbol->l_exp, symbol->r_exp, " || ");
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   512
  if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol->datatype))
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   513
    return print_binary_expression(symbol->l_exp, symbol->r_exp, " | ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   514
  ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   515
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   516
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   517
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   518
void *visit(xor_expression_c *symbol) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   519
  if (get_datatype_info_c::is_BOOL_compatible(symbol->datatype)) {
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   520
    s4o.print("(");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   521
    symbol->l_exp->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   522
    s4o.print(" && !");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   523
    symbol->r_exp->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   524
    s4o.print(") || (!");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   525
    symbol->l_exp->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   526
    s4o.print(" && ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   527
    symbol->r_exp->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   528
    s4o.print(")");
130
a8263f33123f Fixed missing return in XOR operator code gen.
etisserant
parents: 123
diff changeset
   529
    return NULL;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   530
  }
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   531
  if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol->datatype))
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   532
    return print_binary_expression(symbol->l_exp, symbol->r_exp, " ^ ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   533
  ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   534
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   535
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   536
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   537
void *visit(and_expression_c *symbol) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   538
  if (get_datatype_info_c::is_BOOL_compatible(symbol->datatype))
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   539
    return print_binary_expression(symbol->l_exp, symbol->r_exp, " && ");
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   540
  if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol->datatype))
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   541
    return print_binary_expression(symbol->l_exp, symbol->r_exp, " & ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   542
  ERROR;
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   543
return NULL;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   544
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   545
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   546
void *visit(equ_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   547
  if (get_datatype_info_c::is_TIME_compatible      (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   548
      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   549
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   550
    return print_compare_function("EQ_", symbol->l_exp->datatype, symbol->l_exp, symbol->r_exp);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   551
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " == ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   552
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   553
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   554
void *visit(notequ_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   555
  if (get_datatype_info_c::is_TIME_compatible      (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   556
      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   557
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   558
    return print_compare_function("NE_", symbol->l_exp->datatype, symbol->l_exp, symbol->r_exp);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   559
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " != ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   560
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   561
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   562
void *visit(lt_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   563
  if (get_datatype_info_c::is_TIME_compatible      (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   564
      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   565
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   566
    return print_compare_function("LT_", symbol->l_exp->datatype, symbol->l_exp, symbol->r_exp);
653
ea78924a1f60 Deleting datatype checks no longer needed (with a view of making search_expression_type_c redundant).
Mario de Sousa <msousa@fe.up.pt>
parents: 594
diff changeset
   567
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " < ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   568
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   569
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   570
void *visit(gt_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   571
  if (get_datatype_info_c::is_TIME_compatible      (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   572
      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   573
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   574
    return print_compare_function("GT_", symbol->l_exp->datatype, symbol->l_exp, symbol->r_exp);
653
ea78924a1f60 Deleting datatype checks no longer needed (with a view of making search_expression_type_c redundant).
Mario de Sousa <msousa@fe.up.pt>
parents: 594
diff changeset
   575
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " > ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   576
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   577
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   578
void *visit(le_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   579
  if (get_datatype_info_c::is_TIME_compatible      (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   580
      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   581
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   582
    return print_compare_function("LE_", symbol->l_exp->datatype, symbol->l_exp, symbol->r_exp);
653
ea78924a1f60 Deleting datatype checks no longer needed (with a view of making search_expression_type_c redundant).
Mario de Sousa <msousa@fe.up.pt>
parents: 594
diff changeset
   583
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " <= ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   584
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   585
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   586
void *visit(ge_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   587
  if (get_datatype_info_c::is_TIME_compatible      (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   588
      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->l_exp->datatype) ||
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   589
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   590
    return print_compare_function("GE_", symbol->l_exp->datatype, symbol->l_exp, symbol->r_exp);
653
ea78924a1f60 Deleting datatype checks no longer needed (with a view of making search_expression_type_c redundant).
Mario de Sousa <msousa@fe.up.pt>
parents: 594
diff changeset
   591
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " >= ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   592
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   593
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   594
void *visit(add_expression_c *symbol) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   595
/*
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   596
  symbol_c *left_type  = symbol->l_exp->datatype;
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   597
  symbol_c *right_type = symbol->r_exp->datatype;
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   598
  if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   599
      (typeid(*left_type) == typeid(tod_type_name_c)  && typeid(*right_type) == typeid(time_type_name_c)) ||
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   600
      (typeid(*left_type) == typeid(dt_type_name_c)   && typeid(*right_type) == typeid(time_type_name_c)))
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   601
    return print_binary_function("__time_add", symbol->l_exp, symbol->r_exp);
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   602
*/
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   603
  if (get_datatype_info_c::is_TIME_compatible      (symbol->datatype) ||
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   604
      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->datatype))
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   605
    return print_binary_function("__time_add", symbol->l_exp, symbol->r_exp);
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   606
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " + ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   607
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   608
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   609
void *visit(sub_expression_c *symbol) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   610
/*
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   611
  symbol_c *left_type  = symbol->l_exp->datatype;
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   612
  symbol_c *right_type = symbol->r_exp->datatype;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   613
  if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) ||
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   614
      (typeid(*left_type) == typeid(date_type_name_c) && typeid(*right_type) == typeid(date_type_name_c)) ||
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   615
      (typeid(*left_type) == typeid(tod_type_name_c)  && typeid(*right_type) == typeid(time_type_name_c)) ||
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   616
      (typeid(*left_type) == typeid(tod_type_name_c)  && typeid(*right_type) == typeid(tod_type_name_c))  ||
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   617
      (typeid(*left_type) == typeid(dt_type_name_c)   && typeid(*right_type) == typeid(time_type_name_c)) ||
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   618
      (typeid(*left_type) == typeid(dt_type_name_c)   && typeid(*right_type) == typeid(dt_type_name_c)))
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   619
    return print_binary_function("__time_sub", symbol->l_exp, symbol->r_exp);
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   620
*/  
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   621
  if (get_datatype_info_c::is_TIME_compatible      (symbol->datatype) ||
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   622
      get_datatype_info_c::is_ANY_DATE_compatible  (symbol->datatype))
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   623
    return print_binary_function("__time_sub", symbol->l_exp, symbol->r_exp);
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   624
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " - ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   625
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   626
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   627
void *visit(mul_expression_c *symbol) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   628
/*
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   629
  symbol_c *left_type  = symbol->l_exp->datatype;
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   630
  symbol_c *right_type = symbol->r_exp->datatype;
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   631
  if ((typeid(*left_type) == typeid(time_type_name_c) && get_datatype_info_c::is_ANY_INT_compatible (right_type)) ||
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   632
      (typeid(*left_type) == typeid(time_type_name_c) && get_datatype_info_c::is_ANY_REAL_compatible(right_type)))
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   633
    return print_binary_function("__time_mul", symbol->l_exp, symbol->r_exp);
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   634
*/  
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   635
  if (get_datatype_info_c::is_TIME_compatible      (symbol->datatype))
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   636
    return print_binary_function("__time_mul", symbol->l_exp, symbol->r_exp);
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   637
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " * ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   638
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   639
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   640
void *visit(div_expression_c *symbol) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   641
/*
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   642
  symbol_c *left_type  = symbol->l_exp->datatype;
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   643
  symbol_c *right_type = symbol->r_exp->datatype;
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   644
  if ((typeid(*left_type) == typeid(time_type_name_c) && get_datatype_info_c::is_ANY_INT_compatible (right_type)) ||
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   645
      (typeid(*left_type) == typeid(time_type_name_c) && get_datatype_info_c::is_ANY_REAL_compatible(right_type)))
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   646
    return print_binary_function("__time_div", symbol->l_exp, symbol->r_exp);
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   647
*/
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   648
  if (get_datatype_info_c::is_TIME_compatible      (symbol->datatype))
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   649
    return print_binary_function("__time_div", symbol->l_exp, symbol->r_exp);
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   650
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " / ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   651
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   652
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   653
void *visit(mod_expression_c *symbol) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   654
  s4o.print("((");
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   655
  symbol->r_exp->accept(*this);
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   656
  s4o.print(" == 0)?0:");
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   657
  print_binary_expression(symbol->l_exp, symbol->r_exp, " % ");
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   658
  s4o.print(")");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   659
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   660
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   661
257
90782e241346 Huge change.
Mario de Sousa <msousa@fe.up.pt>
parents: 202
diff changeset
   662
void *visit(power_expression_c *symbol) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   663
  s4o.print("EXPT__LREAL__LREAL__LREAL((BOOL)__BOOL_LITERAL(TRUE),\n");
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   664
  s4o.indent_right();
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   665
  s4o.print(s4o.indent_spaces + "NULL,\n");
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   666
  s4o.print(s4o.indent_spaces + "(LREAL)(");
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   667
  symbol->l_exp->accept(*this);
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   668
  s4o.print("),\n");
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   669
  s4o.print(s4o.indent_spaces + "(LREAL)(");
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   670
  symbol->r_exp->accept(*this);
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   671
  s4o.print("))");
358
a2c4af8f0c18 Add support for '**' (power) operator in ST expressions
Mario de Sousa <msousa@fe.up.pt>
parents: 355
diff changeset
   672
  return NULL;
257
90782e241346 Huge change.
Mario de Sousa <msousa@fe.up.pt>
parents: 202
diff changeset
   673
}
90782e241346 Huge change.
Mario de Sousa <msousa@fe.up.pt>
parents: 202
diff changeset
   674
123
a9b4af71cfa4 Fixed some issues on:
lbessard
parents: 101
diff changeset
   675
void *visit(neg_expression_c *symbol) {
257
90782e241346 Huge change.
Mario de Sousa <msousa@fe.up.pt>
parents: 202
diff changeset
   676
  return print_unary_expression(symbol->exp, " -");
123
a9b4af71cfa4 Fixed some issues on:
lbessard
parents: 101
diff changeset
   677
}
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   678
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   679
void *visit(not_expression_c *symbol) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   680
  return print_unary_expression(symbol->exp, get_datatype_info_c::is_BOOL_compatible(symbol->datatype)?"!":"~");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   681
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   682
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   683
void *visit(function_invocation_c *symbol) {
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   684
  symbol_c* function_name = NULL;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   685
  DECLARE_PARAM_LIST()
202
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   686
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   687
  symbol_c *parameter_assignment_list = NULL;
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   688
  if (NULL != symbol->   formal_param_list) parameter_assignment_list = symbol->   formal_param_list;
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   689
  if (NULL != symbol->nonformal_param_list) parameter_assignment_list = symbol->nonformal_param_list;
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   690
  if (NULL == parameter_assignment_list) ERROR;
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   691
233
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   692
  function_call_param_iterator_c function_call_param_iterator(symbol);
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   693
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   694
  function_declaration_c *f_decl = (function_declaration_c *)symbol->called_function_declaration;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   695
  if (f_decl == NULL) ERROR;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   696
  
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   697
  function_name = symbol->function_name;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   698
  
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   699
  /* loop through each function parameter, find the value we should pass
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   700
   * to it, and then output the c equivalent...
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   701
   */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   702
  function_param_iterator_c fp_iterator(f_decl);
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   703
  identifier_c *param_name;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   704
    /* flag to cirreclty handle calls to extensible standard functions (i.e. functions with variable number of input parameters) */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   705
  bool found_first_extensible_parameter = false;  
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   706
  for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   707
    if (fp_iterator.is_extensible_param() && (!found_first_extensible_parameter)) {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   708
      /* We are calling an extensible function. Before passing the extensible
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   709
       * parameters, we must add a dummy paramater value to tell the called
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   710
       * function how many extensible parameters we will be passing.
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   711
       *
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   712
       * Note that stage 3 has already determined the number of extensible
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   713
       * paramters, and stored that info in the abstract syntax tree. We simply
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   714
       * re-use that value.
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   715
       */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   716
      /* NOTE: we are not freeing the malloc'd memory. This is not really a bug.
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   717
       *       Since we are writing a compiler, which runs to termination quickly,
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   718
       *       we can consider this as just memory required for the compilation process
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   719
       *       that will be free'd when the program terminates.
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   720
       */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   721
      char *tmp = (char *)malloc(32); /* enough space for a call with 10^31 (larger than 2^64) input parameters! */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   722
      if (tmp == NULL) ERROR;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   723
      int res = snprintf(tmp, 32, "%d", symbol->extensible_param_count);
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   724
      if ((res >= 32) || (res < 0)) ERROR;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   725
      identifier_c *param_value = new identifier_c(tmp);
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   726
      uint_type_name_c *param_type  = new uint_type_name_c();
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   727
      identifier_c *param_name = new identifier_c("");
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   728
      ADD_PARAM_LIST(param_name, param_value, param_type, function_param_iterator_c::direction_in)
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   729
      found_first_extensible_parameter = true;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   730
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   731
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   732
    if (fp_iterator.is_extensible_param()) {      
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   733
      /* since we are handling an extensible parameter, we must add the index to the
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   734
       * parameter name so we can go looking for the value passed to the correct
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   735
       * extended parameter (e.g. IN1, IN2, IN3, IN4, ...)
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   736
       */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   737
      char *tmp = (char *)malloc(32); /* enough space for a call with 10^31 (larger than 2^64) input parameters! */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   738
      int res = snprintf(tmp, 32, "%d", fp_iterator.extensible_param_index());
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   739
      if ((res >= 32) || (res < 0)) ERROR;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   740
      param_name = new identifier_c(strdup2(param_name->value, tmp));
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   741
      if (param_name->value == NULL) ERROR;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   742
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   743
    
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   744
    symbol_c *param_type = fp_iterator.param_type();
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   745
    if (param_type == NULL) ERROR;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   746
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   747
    function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   748
    
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   749
    symbol_c *param_value = NULL;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   750
    
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   751
    /* Get the value from a foo(<param_name> = <param_value>) style call */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   752
    if (param_value == NULL)
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   753
      param_value = function_call_param_iterator.search_f(param_name);
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   754
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   755
    /* Get the value from a foo(<param_value>) style call */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   756
    if ((param_value == NULL) && !fp_iterator.is_en_eno_param_implicit()) {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   757
      param_value = function_call_param_iterator.next_nf();
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   758
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   759
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   760
    /* if no more parameter values in function call, and the current parameter
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   761
     * of the function declaration is an extensible parameter, we
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   762
     * have reached the end, and should simply jump out of the for loop.
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   763
     */
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   764
    if ((param_value == NULL) && (fp_iterator.is_extensible_param())) {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   765
      break;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   766
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   767
    
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   768
    if ((param_value == NULL) && (param_direction == function_param_iterator_c::direction_in)) {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   769
      /* No value given for parameter, so we must use the default... */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   770
      /* First check whether default value specified in function declaration...*/
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   771
      param_value = fp_iterator.default_value();
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   772
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   773
    
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   774
    ADD_PARAM_LIST(param_name, param_value, param_type, param_direction)
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   775
  } /* for(...) */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   776
  // symbol->parameter_assignment->accept(*this);
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   777
  
233
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   778
  if (function_call_param_iterator.next_nf() != NULL) ERROR;
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   779
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   780
  bool has_output_params = false;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   781
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   782
  if (!this->is_variable_prefix_null()) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   783
    PARAM_LIST_ITERATOR() {
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   784
      if ((PARAM_DIRECTION == function_param_iterator_c::direction_out ||
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   785
           PARAM_DIRECTION == function_param_iterator_c::direction_inout) &&
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   786
           PARAM_VALUE != NULL) {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   787
        has_output_params = true;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   788
      }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   789
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   790
  }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   791
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   792
  /* Check whether we are calling an overloaded function! */
721
5dc33058e041 Fix counting bug in dsymbtable_c
Mario de Sousa <msousa@fe.up.pt>
parents: 718
diff changeset
   793
  /* (fdecl_mutiplicity > 1)  => calling overloaded function */
5dc33058e041 Fix counting bug in dsymbtable_c
Mario de Sousa <msousa@fe.up.pt>
parents: 718
diff changeset
   794
  int fdecl_mutiplicity =  function_symtable.count(symbol->function_name);
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   795
  if (fdecl_mutiplicity == 0) ERROR;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   796
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   797
  if (has_output_params) {
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   798
    fcall_number++;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   799
    s4o.print("__");
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   800
    fbname->accept(*this);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   801
    s4o.print("_");
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   802
    function_name->accept(*this);
721
5dc33058e041 Fix counting bug in dsymbtable_c
Mario de Sousa <msousa@fe.up.pt>
parents: 718
diff changeset
   803
    if (fdecl_mutiplicity > 1) {
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   804
      /* function being called is overloaded! */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   805
      s4o.print("__");
406
6381589697ff Fix bug with overloaded function due to literal input values
laurent
parents: 405
diff changeset
   806
      print_function_parameter_data_types_c overloaded_func_suf(&s4o);
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   807
      f_decl->accept(overloaded_func_suf);
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   808
    }
594
c8092e909886 Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents: 531
diff changeset
   809
    s4o.print(fcall_number);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   810
  }
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   811
  else {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   812
    function_name->accept(*this);
721
5dc33058e041 Fix counting bug in dsymbtable_c
Mario de Sousa <msousa@fe.up.pt>
parents: 718
diff changeset
   813
    if (fdecl_mutiplicity > 1) {
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   814
      /* function being called is overloaded! */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   815
      s4o.print("__");
406
6381589697ff Fix bug with overloaded function due to literal input values
laurent
parents: 405
diff changeset
   816
      print_function_parameter_data_types_c overloaded_func_suf(&s4o);
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   817
      f_decl->accept(overloaded_func_suf);
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   818
    }
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   819
  }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   820
  s4o.print("(");
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   821
  s4o.indent_right();
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   822
  
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   823
  int nb_param = 0;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   824
  PARAM_LIST_ITERATOR() {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   825
    symbol_c *param_value = PARAM_VALUE;
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   826
    current_param_type = PARAM_TYPE;
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   827
          
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   828
    switch (PARAM_DIRECTION) {
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   829
      case function_param_iterator_c::direction_in:
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   830
        if (nb_param > 0)
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   831
          s4o.print(",\n"+s4o.indent_spaces);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   832
        if (param_value == NULL) {
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   833
          /* If not, get the default value of this variable's type */
762
a3d917474ae4 Small code cleanup.
Mario de Sousa <msousa@fe.up.pt>
parents: 721
diff changeset
   834
          param_value = type_initial_value_c::get(current_param_type);
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   835
        }
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   836
        if (param_value == NULL) ERROR;
216
136d6ae70745 Bug with using non explicit literals as standard library functions input parameters fixed
laurent
parents: 208
diff changeset
   837
        s4o.print("(");
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   838
        if      (get_datatype_info_c::is_ANY_INT_literal(current_param_type))
693
51a2fa6441b9 Prepare to delete search_constant_type_c -> Move the static variables from search_constant_type_c to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents: 668
diff changeset
   839
          get_datatype_info_c::lint_type_name.accept(*this);
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   840
        else if (get_datatype_info_c::is_ANY_REAL_literal(current_param_type))
693
51a2fa6441b9 Prepare to delete search_constant_type_c -> Move the static variables from search_constant_type_c to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents: 668
diff changeset
   841
          get_datatype_info_c::lreal_type_name.accept(*this);
216
136d6ae70745 Bug with using non explicit literals as standard library functions input parameters fixed
laurent
parents: 208
diff changeset
   842
        else
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   843
          current_param_type->accept(*this);
216
136d6ae70745 Bug with using non explicit literals as standard library functions input parameters fixed
laurent
parents: 208
diff changeset
   844
        s4o.print(")");
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   845
        print_check_function(current_param_type, param_value);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   846
        nb_param++;
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   847
        break;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   848
      case function_param_iterator_c::direction_out:
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   849
      case function_param_iterator_c::direction_inout:
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   850
        if (!has_output_params) {
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   851
          if (nb_param > 0)
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   852
            s4o.print(",\n"+s4o.indent_spaces);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   853
          if (param_value == NULL)
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   854
            s4o.print("NULL");
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   855
          else {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   856
            wanted_variablegeneration = fparam_output_vg;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   857
            param_value->accept(*this);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   858
            wanted_variablegeneration = expression_vg;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   859
          }
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   860
          nb_param++;
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   861
        }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   862
        break;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   863
      case function_param_iterator_c::direction_extref:
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   864
        /* TODO! */
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   865
        ERROR;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   866
        break;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   867
    } /* switch */
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   868
  }
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   869
  if (has_output_params) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   870
    if (nb_param > 0)
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   871
      s4o.print(",\n"+s4o.indent_spaces);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   872
    s4o.print(FB_FUNCTION_PARAM);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   873
  }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   874
  s4o.print(")");
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   875
  s4o.indent_left();
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   876
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   877
  CLEAR_PARAM_LIST()
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   878
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   879
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   880
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   881
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   882
/********************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   883
/* B 3.2 Statements */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   884
/********************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   885
void *visit(statement_list_c *symbol) {
877
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   886
  for(int i = 0; i < symbol->n; i++) {
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   887
    print_line_directive(symbol->elements[i]);
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   888
    s4o.print(s4o.indent_spaces);
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   889
    symbol->elements[i]->accept(*this);
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   890
    s4o.print(";\n");
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   891
  }
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   892
  return NULL;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   893
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   894
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   895
/*********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   896
/* B 3.2.1 Assignment Statements */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   897
/*********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   898
void *visit(assignment_statement_c *symbol) {
321
a96399ab57c2 Add better comments, and change name of functions to clarify what they do.
Mario de Sousa <msousa@fe.up.pt>
parents: 309
diff changeset
   899
  symbol_c *left_type = search_varfb_instance_type->get_type_id(symbol->l_exp);
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   900
  
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   901
  if (this->is_variable_prefix_null()) {
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   902
    symbol->l_exp->accept(*this);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   903
    s4o.print(" = ");
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   904
    print_check_function(left_type, symbol->r_exp);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   905
  }
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   906
  else {
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   907
    print_setter(symbol->l_exp, left_type, symbol->r_exp);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   908
  }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   909
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   910
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   911
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   912
/*****************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   913
/* B 3.2.2 Subprogram Control Statements */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   914
/*****************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   915
283
214d3fdee596 fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents: 282
diff changeset
   916
void *visit(return_statement_c *symbol) {
214d3fdee596 fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents: 282
diff changeset
   917
  s4o.print("goto "); s4o.print(END_LABEL);
214d3fdee596 fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents: 282
diff changeset
   918
  return NULL;
214d3fdee596 fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents: 282
diff changeset
   919
}
214d3fdee596 fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents: 282
diff changeset
   920
214d3fdee596 fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents: 282
diff changeset
   921
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   922
/* fb_name '(' [param_assignment_list] ')' */
855
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   923
/*    formal_param_list -> may be NULL ! */
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   924
/* nonformal_param_list -> may be NULL ! */
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   925
/* NOTE: The parameter 'called_fb_declaration'is used to pass data between stage 3 and stage4 (although currently it is not used in stage 4 */
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   926
// SYM_REF3(fb_invocation_c, fb_name, formal_param_list, nonformal_param_list, symbol_c *called_fb_declaration;)
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   927
void *visit(fb_invocation_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   928
  TRACE("fb_invocation_c");
855
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   929
  
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   930
  /* find the declaration of the function block type being called... */
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   931
  symbol_c *fb_decl = symbol->called_fb_declaration;
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   932
  if (fb_decl == NULL) ERROR;
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   933
  /* figure out the name of the function block type of the function block being called... */
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   934
  symbol_c *function_block_type_name = get_datatype_info_c::get_id(fb_decl);
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   935
  if (NULL == function_block_type_name) ERROR;
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   936
  
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   937
  /* loop through each function block parameter, find the value we should pass
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   938
   * to it, and then output the c equivalent...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   939
   */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   940
  function_param_iterator_c fp_iterator(fb_decl);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   941
  identifier_c *param_name;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   942
  function_call_param_iterator_c function_call_param_iterator(symbol);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   943
  for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   944
    function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
160
59d58f5e6caa Adding support for compiling struct data types
lbessard
parents: 149
diff changeset
   945
    
162
60a124678842 Fixed typo in EN/ENO parameters handling for std library functions
etisserant
parents: 160
diff changeset
   946
    /*fprintf(stderr, "param : %s\n", param_name->value);*/
160
59d58f5e6caa Adding support for compiling struct data types
lbessard
parents: 149
diff changeset
   947
    
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   948
    /* Get the value from a foo(<param_name> = <param_value>) style call */
202
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   949
    symbol_c *param_value = function_call_param_iterator.search_f(param_name);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   950
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   951
    /* Get the value from a foo(<param_value>) style call */
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   952
    /* When using the informal invocation style, user can not pass values to EN or ENO parameters if these
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   953
     * were implicitly defined!
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   954
     */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   955
    if ((param_value == NULL) && !fp_iterator.is_en_eno_param_implicit())
202
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   956
      param_value = function_call_param_iterator.next_nf();
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   957
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   958
    symbol_c *param_type = fp_iterator.param_type();
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   959
    if (param_type == NULL) ERROR;
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   960
    
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   961
    /* now output the value assignment */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   962
    if (param_value != NULL)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   963
      if ((param_direction == function_param_iterator_c::direction_in) ||
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   964
          (param_direction == function_param_iterator_c::direction_inout)) {
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   965
        if (this->is_variable_prefix_null()) {
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   966
          symbol->fb_name->accept(*this);
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   967
          s4o.print(".");
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   968
          param_name->accept(*this);
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   969
          s4o.print(" = ");
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   970
          print_check_function(param_type, param_value);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   971
        }
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   972
        else {
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   973
          print_setter(param_name, param_type, param_value, symbol->fb_name);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   974
        }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   975
        s4o.print(";\n" + s4o.indent_spaces);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   976
      }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   977
  } /* for(...) */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   978
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   979
  /* now call the function... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   980
  function_block_type_name->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   981
  s4o.print(FB_FUNCTION_SUFFIX);
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   982
  s4o.print("(");
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   983
  if (search_var_instance_decl->get_vartype(symbol->fb_name) != search_var_instance_decl_c::external_vt)
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   984
    s4o.print("&");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   985
  print_variable_prefix();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   986
  symbol->fb_name->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   987
  s4o.print(")");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   988
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   989
  /* loop through each function parameter, find the variable to which
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   990
   * we should atribute the value of all output or inoutput parameters.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   991
   */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   992
  fp_iterator.reset();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   993
  function_call_param_iterator.reset();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   994
  for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   995
    function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   996
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   997
    /* Get the value from a foo(<param_name> = <param_value>) style call */
202
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   998
    symbol_c *param_value = function_call_param_iterator.search_f(param_name);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   999
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1000
    /* Get the value from a foo(<param_value>) style call */
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1001
    /* When using the informal invocation style, user can not pass values to EN or ENO parameters if these
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1002
     * were implicitly defined!
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1003
     */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1004
    if ((param_value == NULL) && !fp_iterator.is_en_eno_param_implicit())
202
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
  1005
      param_value = function_call_param_iterator.next_nf();
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1006
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1007
    /* now output the value assignment */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1008
    if (param_value != NULL)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1009
      if ((param_direction == function_param_iterator_c::direction_out) ||
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1010
          (param_direction == function_param_iterator_c::direction_inout)) {
321
a96399ab57c2 Add better comments, and change name of functions to clarify what they do.
Mario de Sousa <msousa@fe.up.pt>
parents: 309
diff changeset
  1011
        symbol_c *param_type = search_varfb_instance_type->get_type_id(param_value);
240
f78fa87bb4cb Bugs fixed:
laurent
parents: 238
diff changeset
  1012
        s4o.print(";\n" + s4o.indent_spaces);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1013
        if (this->is_variable_prefix_null()) {
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1014
          param_value->accept(*this);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1015
          s4o.print(" = ");
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1016
          print_check_function(param_type, param_name, symbol->fb_name);
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
  1017
        }
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1018
        else {
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1019
          print_setter(param_value, param_type, param_name, NULL, symbol->fb_name);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1020
        }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1021
      }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1022
  } /* for(...) */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1023
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1024
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1025
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1026
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1027
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1028
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1029
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1030
/* helper symbol for fb_invocation */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1031
/* param_assignment_list ',' param_assignment */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1032
void *visit(param_assignment_list_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1033
  TRACE("param_assignment_list_c");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1034
  /* this should never be called... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1035
  ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1036
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1037
//  return print_list(symbol, "", ", ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1038
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1039
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1040
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1041
void *visit(input_variable_param_assignment_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1042
  TRACE("input_variable_param_assignment_c");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1043
  /* this should never be called... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1044
  ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1045
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1046
/*
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1047
  symbol->variable_name->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1048
  s4o.print(" = ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1049
  symbol->expression->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1050
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1051
*/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1052
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1053
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1054
void *visit(output_variable_param_assignment_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1055
  TRACE("output_variable_param_assignment_c");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1056
  /* this should never be called... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1057
  ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1058
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1059
/*
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1060
  s4o.print(s4o.indent_spaces);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1061
  if (symbol->not_param != NULL)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1062
    symbol->not_param->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1063
  symbol->variable_name->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1064
  s4o.print(" => ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1065
  symbol->variable->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1066
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1067
*/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1068
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1069
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1070
// TODO: the NOT symbol in function (block) calls...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1071
void *visit(not_paramassign_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1072
  TRACE("not_paramassign_c");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1073
  /* this should never be called... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1074
  ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1075
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1076
/*
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1077
  s4o.print("NOT ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1078
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1079
*/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1080
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1081
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1082
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1083
/********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1084
/* B 3.2.3 Selection Statements */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1085
/********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1086
void *visit(if_statement_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1087
  s4o.print("if (");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1088
  symbol->expression->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1089
  s4o.print(") {\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1090
  s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1091
  symbol->statement_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1092
  s4o.indent_left();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1093
  symbol->elseif_statement_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1094
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1095
  if (symbol->else_statement_list != NULL) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1096
    s4o.print(s4o.indent_spaces); s4o.print("} else {\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1097
    s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1098
    symbol->else_statement_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1099
    s4o.indent_left();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1100
  }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1101
  s4o.print(s4o.indent_spaces); s4o.print("}");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1102
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1103
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1104
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1105
/* helper symbol for if_statement */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1106
void *visit(elseif_statement_list_c *symbol) {return print_list(symbol);}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1107
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1108
/* helper symbol for elseif_statement_list */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1109
void *visit(elseif_statement_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1110
  s4o.print(s4o.indent_spaces); s4o.print("} else if (");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1111
  symbol->expression->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1112
  s4o.print(") {\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1113
  s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1114
  symbol->statement_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1115
  s4o.indent_left();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1116
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1117
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1118
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1119
void *visit(case_statement_c *symbol) {
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
  1120
  symbol_c *expression_type = symbol->expression->datatype;
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1121
  s4o.print("{\n");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1122
  s4o.indent_right();
376
7dcbd8418771 Making case statement code generated safer
laurent
parents: 375
diff changeset
  1123
  s4o.print(s4o.indent_spaces);
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
  1124
  if      (get_datatype_info_c::is_ANY_INT_literal(expression_type))
693
51a2fa6441b9 Prepare to delete search_constant_type_c -> Move the static variables from search_constant_type_c to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents: 668
diff changeset
  1125
           get_datatype_info_c::lint_type_name.accept(*this);
668
90b6eb7f1775 Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
  1126
  else if (get_datatype_info_c::is_ANY_REAL_literal(expression_type))
693
51a2fa6441b9 Prepare to delete search_constant_type_c -> Move the static variables from search_constant_type_c to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents: 668
diff changeset
  1127
           get_datatype_info_c::lreal_type_name.accept(*this);
376
7dcbd8418771 Making case statement code generated safer
laurent
parents: 375
diff changeset
  1128
  else
7dcbd8418771 Making case statement code generated safer
laurent
parents: 375
diff changeset
  1129
    expression_type->accept(*this);
7dcbd8418771 Making case statement code generated safer
laurent
parents: 375
diff changeset
  1130
  s4o.print(" __case_expression = ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1131
  symbol->expression->accept(*this);
376
7dcbd8418771 Making case statement code generated safer
laurent
parents: 375
diff changeset
  1132
  s4o.print(";\n" + s4o.indent_spaces + "switch (__case_expression) {\n");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1133
  s4o.indent_right();
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1134
  wanted_casegeneration = single_cg;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1135
  symbol->case_element_list->accept(*this);
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1136
  wanted_casegeneration = subrange_cg;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1137
  s4o.print(s4o.indent_spaces + "default:\n");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1138
  s4o.indent_right();
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1139
  first_subrange_case_list = true;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1140
  symbol->case_element_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1141
  if (symbol->statement_list != NULL) {
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
  1142
    if (!first_subrange_case_list) {
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1143
      s4o.print(s4o.indent_spaces + "else {\n");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1144
      s4o.indent_right();
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
  1145
    }
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1146
    symbol->statement_list->accept(*this);
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1147
    if (!first_subrange_case_list) {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1148
      s4o.indent_left();
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1149
      s4o.print(s4o.indent_spaces + "}\n");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1150
    }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1151
  }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1152
  s4o.print(s4o.indent_spaces + "break;\n");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1153
  s4o.indent_left();
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1154
  wanted_casegeneration = none_cg;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1155
  s4o.indent_left();
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1156
  s4o.print(s4o.indent_spaces + "}\n");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1157
  s4o.indent_left();
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1158
  s4o.print(s4o.indent_spaces + "}");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1159
  return NULL;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1160
}
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1161
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1162
/* helper symbol for case_statement */
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1163
void *visit(case_element_list_c *symbol) {return print_list(symbol);}
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1164
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1165
void *visit(case_element_c *symbol) {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1166
  case_element_iterator_c *case_element_iterator;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1167
  symbol_c* element = NULL;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1168
  bool first_element = true;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1169
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1170
  switch (wanted_casegeneration) {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1171
    case single_cg:
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1172
      case_element_iterator = new case_element_iterator_c(symbol->case_list, case_element_iterator_c::element_single);
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1173
      for (element = case_element_iterator->next(); element != NULL; element = case_element_iterator->next()) {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1174
        if (first_element) first_element = false;
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
  1175
        s4o.print(s4o.indent_spaces + "case ");
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1176
        element->accept(*this);
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1177
        s4o.print(":\n");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1178
      }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1179
      delete case_element_iterator;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1180
      break;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1181
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1182
    case subrange_cg:
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1183
      case_element_iterator = new case_element_iterator_c(symbol->case_list, case_element_iterator_c::element_subrange);
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1184
      for (element = case_element_iterator->next(); element != NULL; element = case_element_iterator->next()) {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1185
        if (first_element) {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1186
          if (first_subrange_case_list) {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1187
            s4o.print(s4o.indent_spaces + "if (");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1188
            first_subrange_case_list = false;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1189
          }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1190
          else {
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
  1191
            s4o.print(s4o.indent_spaces + "else if (");
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1192
          }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1193
          first_element = false;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1194
        }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1195
        else {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1196
          s4o.print(" && ");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1197
        }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1198
        element->accept(*this);
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1199
      }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1200
      delete case_element_iterator;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1201
      if (!first_element) {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1202
        s4o.print(") {\n");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1203
      }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1204
      break;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1205
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1206
    default:
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1207
      break;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1208
  }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1209
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1210
  if (!first_element) {
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1211
    s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1212
    symbol->statement_list->accept(*this);
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1213
    switch (wanted_casegeneration) {
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1214
      case single_cg:
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1215
        s4o.print(s4o.indent_spaces + "break;\n");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1216
        s4o.indent_left();
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1217
        break;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1218
      case subrange_cg:
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
  1219
        s4o.indent_left();
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
  1220
        s4o.print(s4o.indent_spaces + "}\n");
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
  1221
        break;
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1222
      default:
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1223
        break;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1224
    }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1225
  }
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1226
  return NULL;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1227
}
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1228
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1229
/********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1230
/* B 3.2.4 Iteration Statements */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1231
/********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1232
void *visit(for_statement_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1233
  s4o.print("for(");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1234
  symbol->control_variable->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1235
  s4o.print(" = ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1236
  symbol->beg_expression->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1237
  s4o.print("; ");
387
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1238
  if (symbol->by_expression == NULL) {
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1239
    /* increment by 1 */
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1240
    symbol->control_variable->accept(*this);
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1241
    s4o.print(" <= ");
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1242
    symbol->end_expression->accept(*this);
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1243
    s4o.print("; ");
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1244
    symbol->control_variable->accept(*this);
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1245
    s4o.print("++");
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1246
  } else {
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1247
    /* increment by user defined value  */
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1248
    /* The user defined increment value may be negative, in which case
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1249
     * the expression to determine whether we have reached the end of the loop
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1250
     * changes from a '<=' to a '>='.
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1251
     * Since the increment value may change during runtime (remember, it is
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1252
     * an expression, so may contain variables), choosing which test
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1253
     * to use has to be done at runtime.
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1254
     */
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1255
    s4o.print("((");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1256
    symbol->by_expression->accept(*this);
387
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1257
    s4o.print(") > 0)? (");
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1258
    symbol->control_variable->accept(*this);
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1259
    s4o.print(" <= (");
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1260
    symbol->end_expression->accept(*this);
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1261
    s4o.print(")) : (");
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1262
    symbol->control_variable->accept(*this);
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1263
    s4o.print(" >= (");
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1264
    symbol->end_expression->accept(*this);
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1265
    s4o.print(")); ");
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1266
    symbol->control_variable->accept(*this);
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1267
    s4o.print(" += (");
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1268
    symbol->by_expression->accept(*this);
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1269
    s4o.print(")");
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1270
  }
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1271
  s4o.print(")");
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1272
  
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1273
  s4o.print(" {\n");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1274
  s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1275
  symbol->statement_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1276
  s4o.indent_left();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1277
  s4o.print(s4o.indent_spaces); s4o.print("}");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1278
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1279
}
387
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1280
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1281
void *visit(while_statement_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1282
  s4o.print("while (");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1283
  symbol->expression->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1284
  s4o.print(") {\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1285
  s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1286
  symbol->statement_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1287
  s4o.indent_left();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1288
  s4o.print(s4o.indent_spaces); s4o.print("}");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1289
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1290
}
387
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1291
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1292
void *visit(repeat_statement_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1293
  s4o.print("do {\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1294
  s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1295
  symbol->statement_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1296
  s4o.indent_left();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1297
  s4o.print(s4o.indent_spaces); s4o.print("} while(");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1298
  symbol->expression->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1299
  s4o.print(")");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1300
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1301
}
387
db368e53133c Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents: 382
diff changeset
  1302
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents: