stage4/generate_c/generate_c_st.cc
author Mario de Sousa <msousa@fe.up.pt>
Sun, 09 Apr 2017 23:43:04 +0100
changeset 1038 036f15e4041d
parent 1026 fe580c0c1911
child 1049 4d7183013481
permissions -rwxr-xr-x
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
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
945
477393b00f95 Add support for relaxed datatype model for array datatypes.
mjsousa
parents: 943
diff changeset
    47
class generate_c_st_c: public generate_c_base_and_typeid_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
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    57
  private:
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    58
    /* When calling a function block, we must first find it's type,
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    59
     * by searching through the declarations of the variables currently
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    60
     * in scope.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    61
     * This class does just that...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    62
     * A new class is instantiated whenever we begin generating the code
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    63
     * for a function block type declaration, or a program declaration.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    64
     * This object instance will then later be called while the
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    65
     * function block's or the program's body is being handled.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    66
     *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    67
     * Note that functions cannot contain calls to function blocks,
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    68
     * so we do not create an object instance when handling
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    69
     * a function declaration.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    70
     */
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
    71
    search_fb_instance_decl_c    *search_fb_instance_decl;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    72
    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
    73
    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
    74
    
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
    75
    symbol_c *scope_;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    76
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
    77
    symbol_c* current_array_type;
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
    78
    symbol_c* current_param_type;
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
    79
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    80
    int fcall_number;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    81
    symbol_c *fbname;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    82
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
    83
    bool first_subrange_case_list;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
    84
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    85
    variablegeneration_t wanted_variablegeneration;
145
72ae82e65dbc Adding support for ouput variables in functions
lbessard
parents: 130
diff changeset
    86
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    87
  public:
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    88
    generate_c_st_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL)
945
477393b00f95 Add support for relaxed datatype model for array datatypes.
mjsousa
parents: 943
diff changeset
    89
    : generate_c_base_and_typeid_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
    90
      search_fb_instance_decl    = new search_fb_instance_decl_c   (scope);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    91
      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
    92
      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
    93
      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
    94
      
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    95
      this->set_variable_prefix(variable_prefix);
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
    96
      current_array_type = NULL;
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
    97
      current_param_type = NULL;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    98
      fcall_number = 0;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
    99
      fbname = name;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   100
      wanted_variablegeneration = expression_vg;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   101
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   102
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   103
    virtual ~generate_c_st_c(void) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   104
      delete search_fb_instance_decl;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   105
      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
   106
      delete search_var_instance_decl;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   107
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   108
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   109
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   110
  public:
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   111
    void generate(statement_list_c *stl) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   112
      stl->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   113
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   114
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   115
  private:
531
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   116
    
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   117
    
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   118
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   119
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   120
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   121
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   122
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
   123
  unsigned int vartype = analyse_variable_c::first_nonfb_vardecltype(symbol, scope_);
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   124
  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
   125
    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
   126
      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
   127
      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
   128
        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
   129
      else
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   130
        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
   131
    }
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   132
    else if (vartype == search_var_instance_decl_c::located_vt)
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   133
      s4o.print(GET_LOCATED_BY_REF);
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   134
    else
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   135
      s4o.print(GET_VAR_BY_REF);
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   136
  }
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   137
  else {
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   138
    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
   139
      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
   140
      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
   141
        s4o.print(GET_EXTERNAL_FB);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   142
      else
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   143
        s4o.print(GET_EXTERNAL);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   144
    }
503
e1e7c7678c44 Edit formating and delete unused code.
Mario de Sousa <msousa@fe.up.pt>
parents: 498
diff changeset
   145
    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
   146
      s4o.print(GET_LOCATED);
e1e7c7678c44 Edit formating and delete unused code.
Mario de Sousa <msousa@fe.up.pt>
parents: 498
diff changeset
   147
    else
e1e7c7678c44 Edit formating and delete unused code.
Mario de Sousa <msousa@fe.up.pt>
parents: 498
diff changeset
   148
      s4o.print(GET_VAR);
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   149
  }
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   150
  
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   151
  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
   152
  s4o.print("(");
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   153
  print_variable_prefix();  
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   154
  wanted_variablegeneration = complextype_base_vg;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   155
  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
   156
  s4o.print(",");
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   157
  wanted_variablegeneration = complextype_suffix_vg;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   158
  symbol->accept(*this);
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   159
  s4o.print(")");
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   160
  wanted_variablegeneration = old_wanted_variablegeneration;
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   161
  return NULL;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   162
}
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   163
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
   164
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
   165
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   166
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
   167
        symbol_c* type,
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   168
        symbol_c* value,
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   169
        symbol_c* fb_symbol = NULL,
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   170
        symbol_c* fb_value = NULL) {
888
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   171
 
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
   172
  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
   173
    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
   174
    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
   175
    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
   176
    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
   177
      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
   178
      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
   179
        s4o.print(SET_EXTERNAL_FB);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   180
      else
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   181
        s4o.print(SET_EXTERNAL);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   182
    }
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
   183
    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
   184
      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
   185
    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
   186
      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
   187
  }
706
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
    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
   190
    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
   191
      s4o.print(SET_EXTERNAL_FB);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   192
    else
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   193
      s4o.print(SET_VAR);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   194
  }
392
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 387
diff changeset
   195
  s4o.print("(");
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   196
  
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   197
  if (fb_symbol != NULL) {
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   198
    print_variable_prefix();
888
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   199
    // 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
   200
    //   wanted_variablegeneration == expression_vg;
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   201
    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
   202
    s4o.print(".,");
888
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   203
    symbol->accept(*this);
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   204
    s4o.print(",");
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   205
    s4o.print(",");    
897
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   206
  } else {
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   207
    print_variable_prefix();
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   208
    s4o.print(",");    
888
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   209
    wanted_variablegeneration = complextype_base_vg;
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   210
    symbol->accept(*this);
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   211
    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
   212
    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
   213
    symbol->accept(*this);
888
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   214
    s4o.print(",");
4893e6b11b25 Remove call to type_is_complex() in ST code generation.
mjsousa
parents: 887
diff changeset
   215
  }
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
   216
  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
   217
  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
   218
  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
   219
  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
   220
  return NULL;
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   221
}
146
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 145
diff changeset
   222
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   223
/********************************/
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   224
/* B 1.3.3 - Derived data types */
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   225
/********************************/
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   226
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   227
/*  signed_integer DOTDOT signed_integer */
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   228
void *visit(subrange_c *symbol) {
999
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
   229
  symbol->lower_limit->accept(*this);
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
   230
  return NULL;
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
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   233
/* 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
   234
void *visit(array_specification_c *symbol) {
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   235
  symbol->non_generic_type_name->accept(*this);
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   236
  return NULL;
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   237
}
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   238
800
2481fffe6e58 Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents: 793
diff changeset
   239
/*  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
   240
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
   241
  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
   242
  return NULL;
2481fffe6e58 Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents: 793
diff changeset
   243
}
2481fffe6e58 Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents: 793
diff changeset
   244
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   245
/*********************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   246
/* B 1.4 - Variables */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   247
/*********************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   248
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
   249
  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
   250
    case complextype_base_vg:
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   251
      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
   252
      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
   253
    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
   254
      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
   255
    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
   256
      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
   257
        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
   258
          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
   259
          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
   260
          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
   261
        }
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
   262
        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
   263
          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
   264
        }
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
   265
      }
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
   266
      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
   267
        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
   268
      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
   269
  }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   270
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   271
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   272
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   273
/********************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   274
/* B.1.4.1   Directly Represented Variables */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   275
/********************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   276
// direct_variable: direct_variable_token   {$$ = new direct_variable_c($1);};
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   277
void *visit(direct_variable_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   278
  TRACE("direct_variable_c");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   279
  /* Do not use print_token() as it will change everything into uppercase */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   280
  if (strlen(symbol->value) == 0) ERROR;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   281
  if (this->is_variable_prefix_null()) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   282
    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
   283
      s4o.print("*(");
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   284
  }
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   285
  else {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   286
    switch (wanted_variablegeneration) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   287
      case expression_vg:
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   288
        s4o.print(GET_LOCATED);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   289
        s4o.print("(");
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   290
        break;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   291
      case fparam_output_vg:
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   292
        s4o.print(GET_LOCATED_BY_REF);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   293
        s4o.print("(");
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   294
        break;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   295
      default:
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   296
        break;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   297
    }
145
72ae82e65dbc Adding support for ouput variables in functions
lbessard
parents: 130
diff changeset
   298
  }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   299
  this->print_variable_prefix();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   300
  s4o.printlocation(symbol->value + 1);
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   301
  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
   302
      (!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
   303
      (!this->is_variable_prefix_null() && (wanted_variablegeneration == fparam_output_vg)))
145
72ae82e65dbc Adding support for ouput variables in functions
lbessard
parents: 130
diff changeset
   304
    s4o.print(")");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   305
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   306
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   307
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   308
/*************************************/
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   309
/* B.1.4.2   Multi-element Variables */
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   310
/*************************************/
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   311
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
   312
// 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
   313
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
   314
  TRACE("structured_variable_c");
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   315
  switch (wanted_variablegeneration) {
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   316
    case complextype_base_vg:
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   317
      symbol->record_variable->accept(*this);
897
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   318
      /* 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
   319
       *        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
   320
       *        (i.e. it does not include the 'values' and 'flag' structure 
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   321
       *        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
   322
       *        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
   323
       *        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
   324
       *        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
   325
       *        using the __SET_VAR and __GET_VAR macros.
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   326
       * 
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   327
       *        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
   328
       */
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   329
      if (   get_datatype_info_c::is_function_block(symbol->record_variable->datatype)
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   330
          || 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
   331
        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
   332
        search_var_instance_decl_c search_var_instance_decl(symbol->record_variable->scope);
936
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   333
        if      (search_var_instance_decl_c::external_vt == search_var_instance_decl.get_vartype(get_var_name_c::get_last_field(symbol->record_variable)))
943
566414d7ba1f fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents: 941
diff changeset
   334
          s4o.print("->");
936
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   335
        else if (dynamic_cast<deref_operator_c *>(symbol->record_variable) != NULL)
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   336
          s4o.print("->"); /* please read the comment in visit(deref_operator_c *) tio understand what this line is doing! */
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
   337
        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
   338
          s4o.print(".");
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   339
        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
   340
      }
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   341
      break;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   342
    case complextype_suffix_vg:
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   343
      symbol->record_variable->accept(*this);
897
8c3e91c385f5 Add support for Stepname.X syntax.
mjsousa
parents: 889
diff changeset
   344
      // 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
   345
      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
   346
            || get_datatype_info_c::is_sfc_step      (symbol->record_variable->datatype))) { // ...nor an SFC step name, then it will certainly be a structure!
936
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   347
        if (dynamic_cast<deref_operator_c *>(symbol->record_variable) != NULL)
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   348
          s4o.print("->"); /* please read the comment in visit(deref_operator_c *) tio understand what this line is doing! */
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   349
        else
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   350
          s4o.print(".");
410
c6486bd97392 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 406
diff changeset
   351
        symbol->field_selector->accept(*this);
c6486bd97392 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 406
diff changeset
   352
      }
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   353
      break;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   354
    default:
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   355
      if (this->is_variable_prefix_null()) {
936
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   356
        /* We are writing code for a FUNCTION. In this case, deref_operator_c are not transformed into the C pointer derefence syntax '->' (e.g. ptr->elem).
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   357
         * We use instead the '*' syntax (e.g. (*ptr).elem)
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   358
         * While in FB the '->' is generated by this structured_variable_c visitor, in Functions the '*' syntax is generated by the deref_operator_c visitor
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   359
         * This is why here we do NOT have --> {if (dynamic_cast<deref_operator_c *>(symbol->record_variable) != NULL)  ..}
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   360
	 *  
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   361
	 * please read the comment in visit(deref_operator_c *) for more information!
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   362
         */
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   363
        symbol->record_variable->accept(*this);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   364
        s4o.print(".");
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   365
        symbol->field_selector->accept(*this);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   366
      }
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   367
      else
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   368
        print_getter(symbol);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   369
      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
   370
  }
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
   371
  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
   372
}
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
   373
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   374
/*  subscripted_variable '[' subscript_list ']' */
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   375
//SYM_REF2(array_variable_c, subscripted_variable, subscript_list)
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   376
void *visit(array_variable_c *symbol) {
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   377
  switch (wanted_variablegeneration) {
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   378
    case complextype_base_vg:
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   379
      symbol->subscripted_variable->accept(*this);
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   380
      break;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   381
    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
   382
      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
   383
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
   384
      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
   385
      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
   386
943
566414d7ba1f fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents: 941
diff changeset
   387
      if (dynamic_cast<deref_operator_c *>(symbol->subscripted_variable) != NULL)
566414d7ba1f fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents: 941
diff changeset
   388
        s4o.print("->"); /* please read the comment in visit(deref_operator_c *) tio understand what this line is doing! */
566414d7ba1f fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents: 941
diff changeset
   389
      else
566414d7ba1f fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents: 941
diff changeset
   390
        s4o.print(".");
566414d7ba1f fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents: 941
diff changeset
   391
      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
   392
      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
   393
      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
   394
      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
   395
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   396
      current_array_type = NULL;
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   397
      break;
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   398
    default:
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   399
      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
   400
        symbol->subscripted_variable->accept(*this);
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   401
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   402
        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
   403
        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
   404
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   405
        s4o.print(".table");
238
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   406
        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
   407
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   408
        current_array_type = NULL;
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   409
      }
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   410
      else
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   411
        print_getter(symbol);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   412
      break;
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   413
  }
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   414
  return NULL;
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
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   417
/* subscript_list ',' subscript */
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   418
void *visit(subscript_list_c *symbol) {
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   419
  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
   420
  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
   421
    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
   422
    if (dimension == NULL) ERROR;
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   423
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   424
    s4o.print("[(");
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   425
    symbol->elements[i]->accept(*this);
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   426
    s4o.print(") - (");
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   427
    dimension->accept(*this);
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   428
    s4o.print(")]");
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   429
  }
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 376
diff changeset
   430
  delete array_dimension_iterator;
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   431
  return NULL;
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   432
}
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   433
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   434
/******************************************/
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   435
/* B 1.4.3 - Declaration & Initialisation */
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   436
/******************************************/
237
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   437
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   438
/* helper symbol for structure_initialization */
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   439
/* structure_element_initialization_list ',' structure_element_initialization */
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   440
void *visit(structure_element_initialization_list_c *symbol) {
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   441
  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
   442
  structure_initialization->init_structure_default(this->current_param_type);
237
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   443
  structure_initialization->init_structure_values(symbol);
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   444
  delete structure_initialization;
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   445
  return NULL;
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   446
}
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   447
237
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   448
/* helper symbol for array_initialization */
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   449
/* array_initial_elements_list ',' array_initial_elements */
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   450
void *visit(array_initial_elements_list_c *symbol) {
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   451
  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
   452
  array_initialization->init_array_size(this->current_param_type);
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   453
  array_initialization->init_array_values(symbol);
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   454
  delete array_initialization;
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   455
  return NULL;
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   456
}
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   457
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   458
/***************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   459
/* B.3 - Language ST (Structured Text) */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   460
/***************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   461
/***********************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   462
/* B 3.1 - Expressions */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   463
/***********************/
936
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   464
void *visit(deref_operator_c *symbol) {
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   465
  /* When producing C code for FUNCTION_BLOCKS, we use the '*' syntax (e.g. (*ptr).elem)
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   466
   * When producing C code for a FUNCTION_BLOCK, the deref_operator_c are transformed in two ways, depending on where they occur.
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   467
   *    - deref_operator between a struct and its elem (e.g. struct_ref^.elem1) 
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   468
   *        are transformed into C using the C pointer derefence syntax '->' (e.g. struct_ref->elem1).
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   469
   *        (In this case, '->' is generated by this structured_variable_c visitor)
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   470
   *    - deref_operator at the end of a struct variable (e.g. struct.elem_ptr^)
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   471
   *        are transformed using the '*' syntax for C pointer dereferencing (e.g. *(struct.elem_ptr) )
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   472
   * 
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   473
   *   NOTE: Ideally, we should always use the '*' C pointer dereferencing syntax. However, due to the
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   474
   *         was the GET_VAR and SET_VAR are transformed into C, this does not work for '^' between a struct and its 
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   475
   *         element (e.g. struct_ref^.elem), which is whey in this case only we use the '->' syntax.
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   476
   *   NOTE: The use of the -> syntax means that pointers to pointers are not supported betweem a struct and its elem
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   477
   *         (e.g. . struct_ref_ref^^.elem) as this would be transformed into the invalid C code struct_ref_ref->->elem.
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   478
   *         This is why we add a test for this case, and bug out with an error if we encounter it!!
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   479
   */
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   480
  if (this->is_variable_prefix_null()) {  
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   481
    /* For code in FUNCTIONs */
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   482
    s4o.print("(*");  
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   483
    symbol->exp->accept(*this);    
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   484
    s4o.print(")");  
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   485
  } else {
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   486
    /* For code in FBs, and PROGRAMS... */
943
566414d7ba1f fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents: 941
diff changeset
   487
    if (   (NULL == dynamic_cast<structured_variable_c *>(symbol->parent)) 
566414d7ba1f fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents: 941
diff changeset
   488
        && (NULL == dynamic_cast<     array_variable_c *>(symbol->parent))) {
936
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   489
      s4o.print("(*");  
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   490
      symbol->exp->accept(*this);    
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   491
      s4o.print(")");  
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   492
    } else {
943
566414d7ba1f fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents: 941
diff changeset
   493
      /* We are in a structured variable - the structured_variable_c or the array_variable_c will already have printed out the '->' !! */ 
936
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   494
      if (NULL != dynamic_cast<deref_operator_c *>(symbol->exp))
941
c2ef93412407 Editing of error message to make it more clear.
mjsousa
parents: 936
diff changeset
   495
        STAGE4_ERROR(symbol, symbol->exp, "The use of two or more consecutive derefencing operators between a struct variable and its record elem (ex: struct_ref_ref^^.elem) is currently not supported for code inside a Function_Block.");
936
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   496
      symbol->exp->accept(*this);
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   497
    }
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   498
  }
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   499
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   500
  return NULL;
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   501
}
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   502
0f7bcc160568 Fix bug: Add support for de-referencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents: 933
diff changeset
   503
933
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   504
void *visit(deref_expression_c *symbol) {
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   505
  s4o.print("(");  
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   506
  if (this->is_variable_prefix_null()) {  
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   507
    /* For code in FUNCTIONs */
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   508
    s4o.print("*");  
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   509
    symbol->exp->accept(*this);    
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   510
    s4o.print("");  
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   511
  } else {
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   512
    /* For code in FBs, and PROGRAMS... */
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   513
    unsigned int vartype = analyse_variable_c::first_nonfb_vardecltype(symbol->exp, scope_);
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   514
    if (vartype == search_var_instance_decl_c::external_vt) {
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   515
      if (!get_datatype_info_c::is_type_valid    (symbol->exp->datatype)) ERROR;
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   516
      if ( get_datatype_info_c::is_function_block(symbol->exp->datatype))
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   517
        s4o.print(GET_EXTERNAL_FB_DREF);
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   518
      else
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   519
        s4o.print(GET_EXTERNAL_DREF);
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   520
    }
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   521
    else if (vartype == search_var_instance_decl_c::located_vt)
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   522
      s4o.print(GET_LOCATED_DREF);
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   523
    else
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   524
      s4o.print(GET_VAR_DREF);
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   525
    
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   526
    variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration; 
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   527
    s4o.print("(");
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   528
    wanted_variablegeneration = complextype_base_vg;
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   529
    print_variable_prefix();
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   530
    symbol->exp->accept(*this);
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   531
    s4o.print(",");
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   532
    wanted_variablegeneration = complextype_suffix_vg;
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   533
    symbol->exp->accept(*this);
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   534
    s4o.print(")");
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   535
    wanted_variablegeneration = old_wanted_variablegeneration;
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   536
  }
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   537
  s4o.print(")");  
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   538
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   539
  return NULL;
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   540
}
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   541
76324f461aed Add support for de-referencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents: 911
diff changeset
   542
873
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   543
void *visit(ref_expression_c *symbol) {
909
8b2a31dea131 Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents: 897
diff changeset
   544
  s4o.print("(");  
873
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   545
  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
   546
    /* For code in FUNCTIONs */
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   547
    s4o.print("&(");  
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   548
    symbol->exp->accept(*this);    
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   549
    s4o.print(")");  
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   550
  } else {
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   551
    /* 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
   552
    s4o.print("(");  
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   553
    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
   554
    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
   555
      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
   556
      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
   557
        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
   558
      else
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   559
        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
   560
    }
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   561
    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
   562
      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
   563
    else
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   564
      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
   565
    
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   566
    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
   567
    s4o.print("(");
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   568
    wanted_variablegeneration = complextype_base_vg;
887
a5e2eedeef53 A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents: 885
diff changeset
   569
    print_variable_prefix();
873
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   570
    symbol->exp->accept(*this);
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   571
    s4o.print(",");
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   572
    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
   573
    symbol->exp->accept(*this);
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   574
    s4o.print(")");
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   575
    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
   576
    
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   577
    s4o.print(")");  
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   578
  }
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   579
  s4o.print(")");  
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   580
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   581
  return NULL;
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   582
}
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   583
dea39ef02847 Add limited support for the REF() operator (defined in v3 of IEC 61131-3)
mjsousa
parents: 864
diff changeset
   584
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   585
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
   586
  if (get_datatype_info_c::is_BOOL_compatible(symbol->datatype))
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   587
    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
   588
  if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol->datatype))
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   589
    return print_binary_expression(symbol->l_exp, symbol->r_exp, " | ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   590
  ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   591
  return NULL;
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(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
   595
  if (get_datatype_info_c::is_BOOL_compatible(symbol->datatype)) {
1026
fe580c0c1911 Fix code generation for XOR expressions in ST (add parenthesis)
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents: 1012
diff changeset
   596
    s4o.print("((");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   597
    symbol->l_exp->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   598
    s4o.print(" && !");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   599
    symbol->r_exp->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   600
    s4o.print(") || (!");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   601
    symbol->l_exp->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   602
    s4o.print(" && ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   603
    symbol->r_exp->accept(*this);
1026
fe580c0c1911 Fix code generation for XOR expressions in ST (add parenthesis)
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents: 1012
diff changeset
   604
    s4o.print("))");
130
a8263f33123f Fixed missing return in XOR operator code gen.
etisserant
parents: 123
diff changeset
   605
    return NULL;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   606
  }
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
   607
  if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol->datatype))
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   608
    return print_binary_expression(symbol->l_exp, symbol->r_exp, " ^ ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   609
  ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   610
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   611
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   612
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   613
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
   614
  if (get_datatype_info_c::is_BOOL_compatible(symbol->datatype))
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   615
    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
   616
  if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol->datatype))
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   617
    return print_binary_expression(symbol->l_exp, symbol->r_exp, " & ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   618
  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
   619
return NULL;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   620
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   621
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   622
void *visit(equ_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   623
  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
   624
      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
   625
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
1011
76175defb87b Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents: 999
diff changeset
   626
    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
   627
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " == ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   628
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   629
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   630
void *visit(notequ_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   631
  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
   632
      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
   633
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
1011
76175defb87b Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents: 999
diff changeset
   634
    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
   635
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " != ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   636
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   637
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   638
void *visit(lt_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   639
  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
   640
      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
   641
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
1011
76175defb87b Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents: 999
diff changeset
   642
    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
   643
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " < ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   644
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   645
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   646
void *visit(gt_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   647
  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
   648
      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
   649
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
1011
76175defb87b Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents: 999
diff changeset
   650
    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
   651
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " > ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   652
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   653
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   654
void *visit(le_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   655
  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
   656
      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
   657
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
1011
76175defb87b Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents: 999
diff changeset
   658
    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
   659
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " <= ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   660
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   661
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   662
void *visit(ge_expression_c *symbol) {
694
a010763dd4cb Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents: 693
diff changeset
   663
  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
   664
      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
   665
      get_datatype_info_c::is_ANY_STRING_compatible(symbol->l_exp->datatype))
1011
76175defb87b Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents: 999
diff changeset
   666
    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
   667
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " >= ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   668
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   669
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   670
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
   671
  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
   672
      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
   673
    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
   674
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " + ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   675
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   676
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   677
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
   678
  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
   679
      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
   680
    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
   681
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " - ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   682
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   683
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   684
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
   685
  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
   686
    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
   687
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " * ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   688
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   689
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   690
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
   691
  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
   692
    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
   693
  return print_binary_expression(symbol->l_exp, symbol->r_exp, " / ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   694
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   695
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   696
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
   697
  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
   698
  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
   699
  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
   700
  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
   701
  s4o.print(")");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   702
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   703
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   704
257
90782e241346 Huge change.
Mario de Sousa <msousa@fe.up.pt>
parents: 202
diff changeset
   705
void *visit(power_expression_c *symbol) {
1011
76175defb87b Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents: 999
diff changeset
   706
  s4o.print("__expt((LREAL)(");
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
   707
  symbol->l_exp->accept(*this);
1011
76175defb87b Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents: 999
diff changeset
   708
  s4o.print("), (LREAL)(");
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
   709
  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
   710
  s4o.print("))");
358
a2c4af8f0c18 Add support for '**' (power) operator in ST expressions
Mario de Sousa <msousa@fe.up.pt>
parents: 355
diff changeset
   711
  return NULL;
257
90782e241346 Huge change.
Mario de Sousa <msousa@fe.up.pt>
parents: 202
diff changeset
   712
}
90782e241346 Huge change.
Mario de Sousa <msousa@fe.up.pt>
parents: 202
diff changeset
   713
123
a9b4af71cfa4 Fixed some issues on:
lbessard
parents: 101
diff changeset
   714
void *visit(neg_expression_c *symbol) {
257
90782e241346 Huge change.
Mario de Sousa <msousa@fe.up.pt>
parents: 202
diff changeset
   715
  return print_unary_expression(symbol->exp, " -");
123
a9b4af71cfa4 Fixed some issues on:
lbessard
parents: 101
diff changeset
   716
}
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   717
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   718
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
   719
  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
   720
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   721
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   722
void *visit(function_invocation_c *symbol) {
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   723
  symbol_c* function_name = NULL;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   724
  DECLARE_PARAM_LIST()
202
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   725
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   726
  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
   727
  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
   728
  if (NULL != symbol->nonformal_param_list) parameter_assignment_list = symbol->nonformal_param_list;
1012
1f2af384fb1f Add support for non standard feature: allow POUs with no in, out and inout parameters
mjsousa
parents: 1011
diff changeset
   729
  // NOTE-> We support the non-standard feature of POUS with no in, out and inout parameters, so this is no longer an internal error!
1f2af384fb1f Add support for non standard feature: allow POUs with no in, out and inout parameters
mjsousa
parents: 1011
diff changeset
   730
  //if (NULL == parameter_assignment_list) ERROR;
202
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 169
diff changeset
   731
233
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   732
  function_call_param_iterator_c function_call_param_iterator(symbol);
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   733
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   734
  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
   735
  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
   736
  
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   737
  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
   738
  
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   739
  /* 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
   740
   * 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
   741
   */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   742
  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
   743
  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
   744
    /* 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
   745
  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
   746
  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
   747
    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
   748
      /* 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
   749
       * 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
   750
       * 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
   751
       *
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   752
       * 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
   753
       * 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
   754
       * 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
   755
       */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   756
      /* 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
   757
       *       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
   758
       *       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
   759
       *       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
   760
       */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   761
      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
   762
      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
   763
      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
   764
      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
   765
      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
   766
      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
   767
      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
   768
      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
   769
      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
   770
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   771
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   772
    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
   773
      /* 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
   774
       * 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
   775
       * 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
   776
       */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   777
      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
   778
      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
   779
      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
   780
      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
   781
      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
   782
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   783
    
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   784
    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
   785
    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
   786
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   787
    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
   788
    
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   789
    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
   790
    
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   791
    /* 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
   792
    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
   793
      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
   794
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   795
    /* 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
   796
    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
   797
      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
   798
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   799
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   800
    /* 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
   801
     * 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
   802
     * 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
   803
     */
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   804
    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
   805
      break;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   806
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   807
    
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   808
    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
   809
      /* 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
   810
      /* 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
   811
      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
   812
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   813
    
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   814
    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
   815
  } /* for(...) */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   816
  // symbol->parameter_assignment->accept(*this);
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   817
  
233
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   818
  if (function_call_param_iterator.next_nf() != NULL) ERROR;
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   819
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   820
  bool has_output_params = false;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   821
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   822
  if (!this->is_variable_prefix_null()) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   823
    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
   824
      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
   825
           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
   826
           PARAM_VALUE != NULL) {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   827
        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
   828
      }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   829
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   830
  }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   831
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   832
  /* 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
   833
  /* (fdecl_mutiplicity > 1)  => calling overloaded function */
5dc33058e041 Fix counting bug in dsymbtable_c
Mario de Sousa <msousa@fe.up.pt>
parents: 718
diff changeset
   834
  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
   835
  if (fdecl_mutiplicity == 0) ERROR;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   836
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   837
  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
   838
    fcall_number++;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   839
    s4o.print("__");
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   840
    fbname->accept(*this);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   841
    s4o.print("_");
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   842
    function_name->accept(*this);
721
5dc33058e041 Fix counting bug in dsymbtable_c
Mario de Sousa <msousa@fe.up.pt>
parents: 718
diff changeset
   843
    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
   844
      /* 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
   845
      s4o.print("__");
406
6381589697ff Fix bug with overloaded function due to literal input values
laurent
parents: 405
diff changeset
   846
      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
   847
      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
   848
    }
594
c8092e909886 Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents: 531
diff changeset
   849
    s4o.print(fcall_number);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   850
  }
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   851
  else {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   852
    function_name->accept(*this);
721
5dc33058e041 Fix counting bug in dsymbtable_c
Mario de Sousa <msousa@fe.up.pt>
parents: 718
diff changeset
   853
    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
   854
      /* 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
   855
      s4o.print("__");
406
6381589697ff Fix bug with overloaded function due to literal input values
laurent
parents: 405
diff changeset
   856
      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
   857
      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
   858
    }
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   859
  }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   860
  s4o.print("(");
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   861
  s4o.indent_right();
1011
76175defb87b Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents: 999
diff changeset
   862
  s4o.print("\n"+s4o.indent_spaces);
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   863
  
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   864
  int nb_param = 0;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   865
  PARAM_LIST_ITERATOR() {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   866
    symbol_c *param_value = PARAM_VALUE;
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   867
    current_param_type = PARAM_TYPE;
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   868
          
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   869
    switch (PARAM_DIRECTION) {
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   870
      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
   871
        if (nb_param > 0)
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   872
          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
   873
        if (param_value == NULL) {
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   874
          /* 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
   875
          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
   876
        }
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   877
        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
   878
        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
   879
        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
   880
          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
   881
        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
   882
          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
   883
        else
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   884
          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
   885
        s4o.print(")");
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   886
        print_check_function(current_param_type, param_value);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   887
        nb_param++;
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   888
        break;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   889
      case function_param_iterator_c::direction_out:
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   890
      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
   891
        if (!has_output_params) {
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   892
          if (nb_param > 0)
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   893
            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
   894
          if (param_value == NULL)
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   895
            s4o.print("NULL");
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   896
          else {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   897
            wanted_variablegeneration = fparam_output_vg;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   898
            param_value->accept(*this);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   899
            wanted_variablegeneration = expression_vg;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   900
          }
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   901
          nb_param++;
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   902
        }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   903
        break;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   904
      case function_param_iterator_c::direction_extref:
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   905
        /* TODO! */
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   906
        ERROR;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   907
        break;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   908
    } /* switch */
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   909
  }
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   910
  if (has_output_params) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   911
    if (nb_param > 0)
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   912
      s4o.print(",\n"+s4o.indent_spaces);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   913
    s4o.print(FB_FUNCTION_PARAM);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   914
  }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   915
  s4o.print(")");
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   916
  s4o.indent_left();
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   917
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   918
  CLEAR_PARAM_LIST()
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   919
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   920
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   921
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   922
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   923
/********************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   924
/* B 3.2 Statements */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   925
/********************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   926
void *visit(statement_list_c *symbol) {
877
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   927
  for(int i = 0; i < symbol->n; i++) {
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   928
    print_line_directive(symbol->elements[i]);
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   929
    s4o.print(s4o.indent_spaces);
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   930
    symbol->elements[i]->accept(*this);
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   931
    s4o.print(";\n");
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   932
  }
c25346eac788 Insert #line directives in generated C code.
mjsousa
parents: 873
diff changeset
   933
  return NULL;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   934
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   935
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   936
/*********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   937
/* B 3.2.1 Assignment Statements */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   938
/*********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   939
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
   940
  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
   941
  
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   942
  if (this->is_variable_prefix_null()) {
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   943
    symbol->l_exp->accept(*this);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   944
    s4o.print(" = ");
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
   945
    print_check_function(left_type, symbol->r_exp);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   946
  }
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   947
  else {
706
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
   948
    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
   949
  }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   950
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   951
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   952
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   953
/*****************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   954
/* B 3.2.2 Subprogram Control Statements */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   955
/*****************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   956
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
   957
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
   958
  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
   959
  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
   960
}
214d3fdee596 fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents: 282
diff changeset
   961
214d3fdee596 fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents: 282
diff changeset
   962
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   963
/* 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
   964
/*    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
   965
/* 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
   966
/* 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
   967
// 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
   968
void *visit(fb_invocation_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   969
  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
   970
  
a3109442e166 Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents: 854
diff changeset
   971
  /* 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
   972
  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
   973
  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
   974
  /* 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
   975
  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
   976
  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
   977
  
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   978
  /* loop through each function block parameter, find the value we should pass
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   979
   * to it, and then output the c equivalent...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   980
   */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   981
  function_param_iterator_c fp_iterator(fb_decl);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   982
  identifier_c *param_name;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   983
  function_call_param_iterator_c function_call_param_iterator(symbol);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   984
  for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   985
    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
   986
    
162
60a124678842 Fixed typo in EN/ENO parameters handling for std library functions
etisserant
parents: 160
diff changeset
   987
    /*fprintf(stderr, "param : %s\n", param_name->value);*/
160
59d58f5e6caa Adding support for compiling struct data types
lbessard
parents: 149
diff changeset
   988
    
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   989
    /* 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
   990
    symbol_c *param_value = function_call_param_iterator.search_f(param_name);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   991
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   992
    /* 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
   993
    /* 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
   994
     * were implicitly defined!
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   995
     */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   996
    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
   997
      param_value = function_call_param_iterator.next_nf();
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   998
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   999
    symbol_c *param_type = fp_iterator.param_type();
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
  1000
    if (param_type == NULL) ERROR;
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
  1001
    
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1002
    /* now output the value assignment */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1003
    if (param_value != NULL)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1004
      if ((param_direction == function_param_iterator_c::direction_in) ||
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1005
          (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
  1006
        if (this->is_variable_prefix_null()) {
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1007
          symbol->fb_name->accept(*this);
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1008
          s4o.print(".");
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1009
          param_name->accept(*this);
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1010
          s4o.print(" = ");
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1011
          print_check_function(param_type, param_value);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1012
        }
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1013
        else {
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1014
          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
  1015
        }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1016
        s4o.print(";\n" + s4o.indent_spaces);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1017
      }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1018
  } /* for(...) */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1019
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1020
  /* now call the function... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1021
  function_block_type_name->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1022
  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
  1023
  s4o.print("(");
31553c22f318 Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents: 625
diff changeset
  1024
  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
  1025
    s4o.print("&");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1026
  print_variable_prefix();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1027
  symbol->fb_name->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1028
  s4o.print(")");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1029
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1030
  /* loop through each function parameter, find the variable to which
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1031
   * we should atribute the value of all output or inoutput parameters.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1032
   */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1033
  fp_iterator.reset();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1034
  function_call_param_iterator.reset();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1035
  for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1036
    function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1037
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1038
    /* 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
  1039
    symbol_c *param_value = function_call_param_iterator.search_f(param_name);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1040
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1041
    /* 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
  1042
    /* 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
  1043
     * were implicitly defined!
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1044
     */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1045
    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
  1046
      param_value = function_call_param_iterator.next_nf();
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1047
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1048
    /* now output the value assignment */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1049
    if (param_value != NULL)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1050
      if ((param_direction == function_param_iterator_c::direction_out) ||
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1051
          (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
  1052
        symbol_c *param_type = search_varfb_instance_type->get_type_id(param_value);
240
f78fa87bb4cb Bugs fixed:
laurent
parents: 238
diff changeset
  1053
        s4o.print(";\n" + s4o.indent_spaces);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1054
        if (this->is_variable_prefix_null()) {
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1055
          param_value->accept(*this);
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1056
          s4o.print(" = ");
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1057
          print_check_function(param_type, param_name, symbol->fb_name);
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
  1058
        }
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1059
        else {
226
29f8ffc203c1 Adding support for setter and getter on complex datatype in ST
laurent
parents: 221
diff changeset
  1060
          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
  1061
        }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1062
      }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1063
  } /* for(...) */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1064
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1065
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1066
}
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
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1071
/* helper symbol for fb_invocation */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1072
/* param_assignment_list ',' param_assignment */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1073
void *visit(param_assignment_list_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1074
  TRACE("param_assignment_list_c");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1075
  /* this should never be called... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1076
  ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1077
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1078
//  return print_list(symbol, "", ", ");
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
void *visit(input_variable_param_assignment_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1083
  TRACE("input_variable_param_assignment_c");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1084
  /* this should never be called... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1085
  ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1086
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1087
/*
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1088
  symbol->variable_name->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1089
  s4o.print(" = ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1090
  symbol->expression->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1091
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1092
*/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1093
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1094
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1095
void *visit(output_variable_param_assignment_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1096
  TRACE("output_variable_param_assignment_c");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1097
  /* this should never be called... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1098
  ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1099
  return NULL;
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);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1102
  if (symbol->not_param != NULL)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1103
    symbol->not_param->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1104
  symbol->variable_name->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1105
  s4o.print(" => ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1106
  symbol->variable->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1107
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1108
*/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1109
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1110
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1111
// TODO: the NOT symbol in function (block) calls...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1112
void *visit(not_paramassign_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1113
  TRACE("not_paramassign_c");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1114
  /* this should never be called... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1115
  ERROR;
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
  s4o.print("NOT ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1119
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1120
*/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1121
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1122
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1123
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1124
/********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1125
/* B 3.2.3 Selection Statements */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1126
/********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1127
void *visit(if_statement_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1128
  s4o.print("if (");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1129
  symbol->expression->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1130
  s4o.print(") {\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1131
  s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1132
  symbol->statement_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1133
  s4o.indent_left();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1134
  symbol->elseif_statement_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1135
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1136
  if (symbol->else_statement_list != NULL) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1137
    s4o.print(s4o.indent_spaces); s4o.print("} else {\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1138
    s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1139
    symbol->else_statement_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1140
    s4o.indent_left();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1141
  }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1142
  s4o.print(s4o.indent_spaces); s4o.print("}");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1143
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1144
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1145
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1146
/* helper symbol for if_statement */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1147
void *visit(elseif_statement_list_c *symbol) {return print_list(symbol);}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1148
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1149
/* helper symbol for elseif_statement_list */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1150
void *visit(elseif_statement_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1151
  s4o.print(s4o.indent_spaces); s4o.print("} else if (");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1152
  symbol->expression->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1153
  s4o.print(") {\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1154
  s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1155
  symbol->statement_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1156
  s4o.indent_left();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1157
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1158
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1159
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1160
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
  1161
  symbol_c *expression_type = symbol->expression->datatype;
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1162
  s4o.print("{\n");
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1163
  s4o.indent_right();
376
7dcbd8418771 Making case statement code generated safer
laurent
parents: 375
diff changeset
  1164
  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
  1165
  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
  1166
           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
  1167
  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
  1168
           get_datatype_info_c::lreal_type_name.accept(*this);
376
7dcbd8418771 Making case statement code generated safer
laurent
parents: 375
diff changeset
  1169
  else
7dcbd8418771 Making case statement code generated safer
laurent
parents: 375
diff changeset
  1170
    expression_type->accept(*this);
7dcbd8418771 Making case statement code generated safer
laurent
parents: 375
diff changeset
  1171
  s4o.print(" __case_expression = ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1172
  symbol->expression->accept(*this);
999
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1173
  s4o.print(";\n");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1174
  symbol->case_element_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1175
  if (symbol->statement_list != NULL) {
999
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1176
    s4o.print(s4o.indent_spaces + "else {\n");
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1177
    s4o.indent_right();
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1178
    symbol->statement_list->accept(*this);
999
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1179
    s4o.indent_left();
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1180
    s4o.print(s4o.indent_spaces + "}\n");
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1181
  }
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1182
  s4o.indent_left();
999
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1183
  s4o.print(s4o.indent_spaces + "}");
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1184
  return NULL;
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1185
}
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1186
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1187
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1188
/* helper symbol for case_statement */
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1189
void *visit(case_element_list_c *symbol) {return print_list(symbol, s4o.indent_spaces+"if ", s4o.indent_spaces+"else if ");}
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1190
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1191
void *visit(case_element_c *symbol) {
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1192
  symbol->case_list->accept(*this);
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1193
  s4o.print(" {\n");
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1194
  s4o.indent_right();
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1195
  symbol->statement_list->accept(*this);
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1196
  s4o.indent_left();
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1197
  s4o.print(s4o.indent_spaces + "}\n");
999
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1198
  return NULL;
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1199
}
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1200
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1201
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1202
void *visit(case_list_c *symbol) {
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1203
  s4o.print("(");
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1204
  for (int i =  0; i < symbol->n; i++) {
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1205
    /* if not the first element, then add an '||', a '\n', and add some spaces to get nice alignment */
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1206
    /* example of generated C code (codition) for 
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1207
     *   case XX of
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1208
     *     10..20,42,15..99:  <---- C code is for this line!
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1209
     * 
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1210
     *    else if ((__case_expression >= 10 && __case_expression <= 20) ||
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1211
     *             (__case_expression == 42) ||
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1212
     *             (__case_expression >= 15 && __case_expression <= 99)) {
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1213
     */
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1214
    if (0 != i)  s4o.print(" ||\n" + s4o.indent_spaces + "         ");
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1215
    s4o.print("(");
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1216
    subrange_c *subrange = dynamic_cast<subrange_c *>(symbol->elements[i]);
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1217
    if (NULL == subrange) {
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1218
      s4o.print("__case_expression == ");
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1219
      symbol->elements[i]->accept(*this);
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1220
    } else {
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1221
      s4o.print("__case_expression >= ");
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1222
      subrange->lower_limit->accept(*this);
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1223
      s4o.print(" && __case_expression <= ");
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1224
      subrange->upper_limit->accept(*this);
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1225
    }
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1226
    s4o.print(")");
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1227
  }
dd50a82ae8da transform CASE into if()..else if().. -> fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents: 945
diff changeset
  1228
  s4o.print(")");
347
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1229
  return NULL;
44ff2a6fcadc Fix case statement in ST, adding support for enumerated types
laurent
parents: 344
diff changeset
  1230
}
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1231
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1232
/********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1233
/* B 3.2.4 Iteration Statements */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1234
/********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1235
void *visit(for_statement_c *symbol) {
1038
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1236
  /* Due to the way the GET/SET_GLOBAL accessor macros access VAR_GLOBAL variables,
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1237
   * these varibles cannot be used within a C for(;;) loop.
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1238
   * We must therefore implemnt the FOR END_FOR loop as a C while() loop
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1239
   */
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1240
  s4o.print("/* FOR ... */\n" + s4o.indent_spaces);
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1241
  /* For the initialization part, we create an assignment_statement_c   */
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1242
  /* and have this visitor visit it!                                    */ 
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1243
  assignment_statement_c ini_assignment(symbol->control_variable, symbol->beg_expression);
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1244
  ini_assignment.accept(*this);
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1245
  //symbol->control_variable->accept(*this);  // this does not work for VAR_GLOBAL variables
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1246
  //s4o.print(" = ");
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1247
  //symbol->beg_expression->accept(*this);
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1248
  
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1249
  /* comparison // check for end of loop */
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1250
  s4o.print(";\n" + s4o.indent_spaces + "while( ");
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
  1251
  if (symbol->by_expression == NULL) {
1038
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1252
    /* increment by 1 */    
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
  1253
    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
  1254
    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
  1255
    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
  1256
  } 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
  1257
    /* 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
  1258
    /* 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
  1259
     * 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
  1260
     * 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
  1261
     * 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
  1262
     * 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
  1263
     * 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
  1264
     */
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("((");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1266
    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
  1267
    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
  1268
    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
  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
    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
  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
    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
  1273
    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
  1274
    symbol->end_expression->accept(*this);
1038
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1275
    s4o.print(")) ");
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1276
  }
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1277
  s4o.print(" ) {\n");
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
  1278
  
1038
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1279
  /* the body part */
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1280
  s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1281
  symbol->statement_list->accept(*this);
1038
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1282
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1283
  /* increment part */
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1284
  s4o.print(s4o.indent_spaces + "/* BY ... (of FOR loop) */\n");
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1285
  s4o.print(s4o.indent_spaces); 
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1286
  if (symbol->by_expression == NULL) {
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1287
    /* increment by 1 */    
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1288
    /* For the increment part, we create an add_expression_c and assignment_statement_c   */
036f15e4041d Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents: 1026
diff changeset
  1289
    /* and have this visitor vist the latter!                                             */