stage4/generate_c/generate_c_il.cc
author Mario de Sousa <msousa@fe.up.pt>
Thu, 25 Oct 2012 11:15:55 +0100
changeset 683 2d96a47a75b1
parent 682 966f32af570d
child 687 81dcb3987cbb
permissions -rwxr-xr-x
Code cleanup: get the datatype of each entity off symbol->datatype (set in stage3 datatype checking), instead of determining it again in stage4. (NOTE: handling of IL parenthesized expressions is not working! Will be fixed later.)
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: 240
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: 240
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: 240
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: 240
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: 240
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: 240
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: 240
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: 240
diff changeset
    11
 *
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 240
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: 240
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: 240
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: 240
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: 240
diff changeset
    16
 *
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 240
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: 240
diff changeset
    18
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
c0453b7f99df Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents: 240
diff changeset
    19
 *
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    20
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    21
 * This code is made available on the understanding that it will not be
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    22
 * used in safety-critical situations without a full and competent review.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    23
 */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    24
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
/* Returns the data type of an il_operand.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    31
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    32
 * Note that the il_operand may be a variable, in which case
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    33
 * we return the type of the variable instance.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    34
 * The il_operand may also be a constant, in which case
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    35
 * we return the data type of that constant.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    36
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    37
 * The variable instance may be a member of a structured variable,
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    38
 * or an element in an array, or any combination of the two.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    39
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    40
 * The class constructor must be given the search scope
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    41
 * (function, function block or program within which
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    42
 * the possible il_operand variable instance was declared).
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
/***********************************************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    47
/***********************************************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    48
/***********************************************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    49
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    50
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
    51
/* A new class to ouput the IL implicit variable to c++ code
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    52
 * We use this class, inheriting from symbol_c, so it may be used
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    53
 * as any other symbol_c object in the intermediate parse tree,
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    54
 * more specifically, so it can be used as any other il operand.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    55
 * This makes the rest of the code much easier...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    56
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    57
 * Nevertheless, the basic visitor class visitor_c does not know
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    58
 * how to visit this new il_default_variable_c class, so we have
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    59
 * to extend that too.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    60
 * In reality extending the basic symbols doesn't quite work out
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    61
 * as cleanly as desired (we need to use dynamic_cast in the
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    62
 * accept method of the il_default_variable_c), but it is cleaner
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    63
 * than the alternative...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    64
 */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    65
class il_default_variable_c;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    66
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    67
/* This visitor class is not really required, we could place the
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    68
 * visit() method directly in genertae_cc_il_c, but doing it in
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    69
 * a seperate class makes the architecture more evident...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    70
 */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    71
class il_default_variable_visitor_c {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    72
  public:
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    73
    virtual void *visit(il_default_variable_c *symbol) = 0;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    74
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    75
    virtual ~il_default_variable_visitor_c(void) {return;}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    76
};
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    77
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    78
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    79
/* A class to print out to the resulting C++ code
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
    80
 * the IL implicit variable name.
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    81
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    82
 * It includes a reference to its name,
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    83
 * and the data type of the data currently stored
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    84
 * in this C++ variable... This is required because the
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    85
 * C++ variable is a union, and we must know which member
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    86
 * of the union top reference!!
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    87
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    88
 * Note that we also need to keep track of the data type of
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
    89
 * the value currently being stored in the IL implicit variable.
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    90
 * This is required so we can process parenthesis,
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    91
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    92
 * e.g. :
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    93
 *         LD var1
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    94
 *         AND (
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    95
 *         LD var2
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    96
 *         OR var3
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    97
 *         )
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    98
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
    99
 * Note that we only execute the 'AND (' operation when we come across
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   100
 * the ')', i.e. once we have evaluated the result of the
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   101
 * instructions inside the parenthesis.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   102
 * When we do execute the 'AND (' operation, we need to know the data type
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   103
 * of the operand, which in this case is the result of the evaluation of the
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   104
 * instruction list inside the parenthesis. We can only know this if we
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   105
 * keep track of the data type currently stored in the IL implicit variable!
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   106
 *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   107
 * We use the current_type inside the generate_c_il::default_variable_name variable
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   108
 * to track this!
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   109
 */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   110
class il_default_variable_c: public symbol_c {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   111
  public:
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   112
    symbol_c *var_name;  /* in principle, this should point to an indentifier_c */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   113
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   114
  public:
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   115
    il_default_variable_c(const char *var_name_str, symbol_c *current_type);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   116
    virtual void *accept(visitor_c &visitor);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   117
};
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   118
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   119
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   120
/***********************************************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   121
/***********************************************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   122
/***********************************************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   123
/***********************************************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   124
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   125
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   126
669
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   127
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   128
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   129
class generate_c_il_c: public generate_c_typedecl_c, il_default_variable_visitor_c {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   130
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   131
  public:
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   132
    typedef enum {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   133
      expression_vg,
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   134
      assignment_vg,
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   135
      complextype_base_vg,
392
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   136
      complextype_base_assignment_vg,
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   137
      complextype_suffix_vg,
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   138
      fparam_output_vg
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   139
    } variablegeneration_t;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   140
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   141
  private:
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   142
    /* Label to which the current IL jump operation should jump to... */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   143
    /* This variable is used to pass data from the
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   144
     * il_jump_operation_c visitor
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   145
     * to the il jump operator visitors (i.e. JMP_operator_c,
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   146
     * JMPC_operator_c, JMPCN_operator_c, ...)
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   147
     */
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   148
    symbol_c *jump_label;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   149
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   150
    /* the data type of the IL implicit variable... */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   151
    #define IL_DEFVAR_T VAR_LEADER "IL_DEFVAR_T"
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   152
    /* The name of the IL implicit variable... */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   153
    #define IL_DEFVAR   VAR_LEADER "IL_DEFVAR"
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   154
    /* The name of the variable used to pass the result of a
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   155
     * parenthesised instruction list to the immediately preceding
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   156
     * scope ...
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   157
     */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   158
    #define IL_DEFVAR_BACK   VAR_LEADER "IL_DEFVAR_BACK"
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   159
    
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   160
    il_default_variable_c implicit_variable_current;      /* the current   implicit variable, with the datatype resulting from the previous IL operation */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   161
    il_default_variable_c implicit_variable_result;       /* the resulting implicit variable, with the datatype resulting from the current  IL operation */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   162
    il_default_variable_c implicit_variable_result_back;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   163
    
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   164
    /* Operand to the IL operation currently being processed... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   165
    /* These variables are used to pass data from the
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   166
     * il_simple_operation_c and il_expression_c visitors
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   167
     * to the il operator visitors (i.e. LD_operator_c,
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   168
     * LDN_operator_c, ST_operator_c, STN_operator_c, ...)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   169
     */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   170
    symbol_c *current_operand;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   171
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   172
    /* When calling a function block, we must first find it's type,
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   173
     * by searching through the declarations of the variables currently
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   174
     * in scope.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   175
     * This class does just that...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   176
     * A new class is instantiated whenever we begin generating the code
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   177
     * for a function block type declaration, or a program declaration.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   178
     * This object instance will then later be called while the
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   179
     * function block's or the program's body is being handled.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   180
     *
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   181
     * Note that functions cannot contain calls to function blocks,
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   182
     * so we do not create an object instance when handling
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   183
     * a function declaration.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   184
     */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   185
    search_fb_instance_decl_c *search_fb_instance_decl;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   186
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   187
    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: 498
diff changeset
   188
    search_var_instance_decl_c   *search_var_instance_decl;
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   189
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   190
    symbol_c* current_array_type;
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   191
    symbol_c* current_param_type;
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   192
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   193
    int fcall_number;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   194
    symbol_c *fbname;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   195
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   196
    variablegeneration_t wanted_variablegeneration;
146
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 123
diff changeset
   197
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   198
  public:
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   199
    generate_c_il_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL)
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   200
    : generate_c_typedecl_c(s4o_ptr),
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   201
      implicit_variable_current    (IL_DEFVAR,      NULL),
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   202
      implicit_variable_result     (IL_DEFVAR,      NULL),
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   203
      implicit_variable_result_back(IL_DEFVAR_BACK, NULL)
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   204
    {
669
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   205
      search_fb_instance_decl    = new search_fb_instance_decl_c   (scope);
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   206
      search_varfb_instance_type = new search_varfb_instance_type_c(scope);
669
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   207
      search_var_instance_decl   = new search_var_instance_decl_c  (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: 498
diff changeset
   208
      
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   209
      current_operand = NULL;
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   210
      current_array_type = NULL;
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   211
      current_param_type = NULL;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   212
      fcall_number = 0;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   213
      fbname = name;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   214
      wanted_variablegeneration = expression_vg;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   215
      this->set_variable_prefix(variable_prefix);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   216
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   217
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   218
    virtual ~generate_c_il_c(void) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   219
      delete search_fb_instance_decl;
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
   220
      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: 498
diff changeset
   221
      delete search_var_instance_decl;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   222
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   223
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   224
    void generate(instruction_list_c *il) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   225
      il->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   226
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   227
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   228
  private:
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   229
    /* Declare an implicit IL variable... */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   230
    void declare_implicit_variable(il_default_variable_c *implicit_var) {
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   231
      s4o.print(s4o.indent_spaces);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   232
      s4o.print(IL_DEFVAR_T);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   233
      s4o.print(" ");
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   234
      implicit_var->datatype = NULL;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   235
      implicit_var->accept(*this);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   236
      s4o.print(";\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   237
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   238
    
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   239
  public:  
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   240
    /* Declare the default variable, that will store the result of the IL operations */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   241
    void declare_implicit_variable(void) {
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   242
      declare_implicit_variable(&this->implicit_variable_result);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   243
    }
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   244
    
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   245
    /* Declare the backup to the default variable, that will store the result of the IL operations executed inside a parenthesis... */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   246
    void declare_implicit_variable_back(void) {
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   247
      declare_implicit_variable(&this->implicit_variable_result_back);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   248
    }
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   249
    
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   250
    void print_implicit_variable_back(void) {
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   251
      this->implicit_variable_result_back.accept(*this);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   252
    }    
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   253
392
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   254
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   255
  private:
669
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   256
    /* a small helper function */
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   257
    symbol_c *default_literal_type(symbol_c *symbol) {
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   258
      if (get_datatype_info_c::is_ANY_INT_literal(symbol)) {
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   259
        return &search_constant_type_c::lint_type_name;
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   260
      }
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   261
      else if (get_datatype_info_c::is_ANY_REAL_literal(symbol)) {
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   262
        return &search_constant_type_c::lreal_type_name;
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   263
      }
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   264
      return symbol;
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   265
    }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   266
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   267
    /* A helper function... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   268
    void *XXX_operator(symbol_c *lo, const char *op, symbol_c *ro) {
669
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   269
      if ((NULL == lo) || (NULL == ro) || (NULL == op)) ERROR;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   270
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   271
      lo->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   272
      s4o.print(op);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   273
      ro->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   274
      return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   275
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   276
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   277
    /* A helper function... */
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   278
    void *XXX_function(symbol_c *res, const char *func, symbol_c *lo, symbol_c *ro) {
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   279
      if ((NULL == res) || (NULL == lo) || (NULL == ro)) ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   280
      if  (NULL == func) ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   281
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   282
      res->accept(*this);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   283
      s4o.print(" = ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   284
      s4o.print(func);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   285
      s4o.print("(");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   286
      lo->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   287
      s4o.print(", ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   288
      ro->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   289
      s4o.print(")");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   290
      return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   291
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   292
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   293
    /* A helper function... used for implicit FB calls: S1, R1, CLK, CU, CD, PV, IN, and PT */
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   294
    void *XXX_CAL_operator(const char *param_name, symbol_c *fb_name) {
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
   295
      if (wanted_variablegeneration != expression_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
   296
        s4o.print(param_name);
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
   297
        return 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
   298
      }
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
   299
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   300
      if (NULL == fb_name) ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   301
      symbolic_variable_c *sv = dynamic_cast<symbolic_variable_c *>(fb_name);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   302
      if (NULL == sv) ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   303
      identifier_c *id = dynamic_cast<identifier_c *>(sv->var_name);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   304
      if (NULL == id) ERROR;
202
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 201
diff changeset
   305
      
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   306
      identifier_c param(param_name);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   307
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   308
      //SYM_REF3(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list)
202
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 201
diff changeset
   309
      il_assign_operator_c il_assign_operator(&param);
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   310
      il_param_assignment_c il_param_assignment(&il_assign_operator, &this->implicit_variable_current, NULL);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   311
      // SYM_LIST(il_param_list_c)
202
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 201
diff changeset
   312
      il_param_list_c il_param_list;   
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   313
      il_param_list.add_element(&il_param_assignment);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   314
      CAL_operator_c CAL_operator;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   315
      // SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   316
      il_fb_call_c il_fb_call(&CAL_operator, id, NULL, &il_param_list);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   317
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   318
      il_fb_call.accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   319
      return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   320
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   321
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   322
    /* A helper function... */
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   323
    void *CMP_operator(symbol_c *operand, const char *operation) {
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   324
      if (NULL == operand) ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   325
      if (NULL == operand->datatype) ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   326
      if (NULL == this->implicit_variable_current.datatype) ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   327
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   328
      this->implicit_variable_result.accept(*this);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   329
      s4o.print(" = ");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   330
      s4o.print(operation);
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   331
      operand->datatype->accept(*this);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   332
      /* NOTE: we are calling a standard Function: 
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   333
       *         1st parameter: EN  (enable)
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   334
       *         2nd parameter: ENO (enable output)
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   335
       *         3rd parameter: number of operands we will be passing (required because we are calling an extensible standard function!)
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   336
       *         4th parameter: the left  hand side of the comparison expression (in out case, the IL implicit variable)
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   337
       *         4th parameter: the right hand side of the comparison expression (in out case, current operand)
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   338
       */
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   339
      s4o.print("(__BOOL_LITERAL(TRUE), NULL, 2, ");
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   340
      this->implicit_variable_current.accept(*this);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   341
      s4o.print(", ");
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   342
      operand->accept(*this);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   343
      s4o.print(")");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   344
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   345
      return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   346
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   347
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   348
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   349
    /* A helper function... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   350
    void C_modifier(void) {
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   351
      if (!get_datatype_info_c::is_BOOL_compatible(implicit_variable_current.datatype)) ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   352
      s4o.print("if (");
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   353
      this->implicit_variable_current.accept(*this);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   354
      s4o.print(") ");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   355
    }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   356
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   357
    /* A helper function... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   358
    void CN_modifier(void) {
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   359
      if (!get_datatype_info_c::is_BOOL_compatible(implicit_variable_current.datatype)) ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   360
      s4o.print("if (!");
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   361
      this->implicit_variable_current.accept(*this);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   362
      s4o.print(") ");
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   363
    }
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   364
210
8387cac2aba6 Adding support for forcing tick count to return to zero as the same time than all tasks firing are synchronized
laurent
parents: 208
diff changeset
   365
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   366
    void *print_getter(symbol_c *symbol) {
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: 498
diff changeset
   367
      unsigned int vartype = search_var_instance_decl->get_vartype(symbol);
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   368
      if (wanted_variablegeneration == fparam_output_vg) {
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   369
      	if (vartype == search_var_instance_decl_c::external_vt)
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   370
          s4o.print(GET_EXTERNAL_BY_REF);
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   371
        else if (vartype == search_var_instance_decl_c::located_vt)
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   372
          s4o.print(GET_LOCATED_BY_REF);
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   373
        else
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   374
          s4o.print(GET_VAR_BY_REF);
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   375
      }
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   376
      else {
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   377
    	if (vartype == search_var_instance_decl_c::external_vt)
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   378
    	  s4o.print(GET_EXTERNAL);
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   379
    	else if (vartype == search_var_instance_decl_c::located_vt)
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   380
    	  s4o.print(GET_LOCATED);
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   381
    	else
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   382
    	  s4o.print(GET_VAR);
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   383
      }
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   384
      s4o.print("(");
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   385
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   386
      variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration;
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   387
      wanted_variablegeneration = complextype_base_vg;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   388
      symbol->accept(*this);
531
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   389
      if (search_var_instance_decl->type_is_complex(symbol))
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   390
        s4o.print(",");
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   391
      wanted_variablegeneration = complextype_suffix_vg;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   392
      symbol->accept(*this);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   393
      s4o.print(")");
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   394
      wanted_variablegeneration = old_wanted_variablegeneration;
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   395
      return NULL;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   396
    }
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   397
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   398
    void *print_setter(symbol_c* symbol,
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   399
    		symbol_c* type,
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   400
    		symbol_c* value,
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   401
    		symbol_c* fb_symbol = NULL,
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   402
    		symbol_c* fb_value = NULL,
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   403
    		bool negative = false) {
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
   404
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
   405
      bool type_is_complex = false;
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
   406
      if (fb_symbol == NULL) {
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: 498
diff changeset
   407
        unsigned int vartype = search_var_instance_decl->get_vartype(symbol);
531
e7d6f28fc882 Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents: 505
diff changeset
   408
        type_is_complex = search_var_instance_decl->type_is_complex(symbol);
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
   409
        if (vartype == search_var_instance_decl_c::external_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
   410
          s4o.print(SET_EXTERNAL);
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
   411
        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
   412
          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
   413
        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
   414
          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
   415
      }
392
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   416
      else
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   417
        s4o.print(SET_VAR);
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   418
      s4o.print("(");
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   419
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   420
      if (fb_symbol != NULL) {
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   421
        print_variable_prefix();
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   422
        fb_symbol->accept(*this);
392
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   423
        s4o.print(".,");
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   424
      }
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
   425
      else if (type_is_complex)
392
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   426
        wanted_variablegeneration = complextype_base_assignment_vg;
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   427
      else
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
   428
        wanted_variablegeneration = assignment_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
   429
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   430
      symbol->accept(*this);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   431
      s4o.print(",");
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   432
      if (negative) {
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   433
	    if (get_datatype_info_c::is_BOOL_compatible(this->current_operand->datatype))
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   434
		  s4o.print("!");
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   435
	    else
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   436
		  s4o.print("~");
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   437
      }
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   438
      wanted_variablegeneration = expression_vg;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   439
      print_check_function(type, value, fb_value);
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
   440
      if (type_is_complex) {
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   441
        s4o.print(",");
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   442
        wanted_variablegeneration = complextype_suffix_vg;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   443
        symbol->accept(*this);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   444
      }
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   445
      s4o.print(")");
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   446
      wanted_variablegeneration = expression_vg;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   447
      return NULL;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   448
    }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   449
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   450
public:
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   451
void *visit(il_default_variable_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   452
  symbol->var_name->accept(*this);
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   453
  if (NULL != symbol->datatype) {
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   454
    s4o.print(".");
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   455
    symbol->datatype->accept(*this);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   456
    s4o.print("var");
563
61410284a9b4 little typo in last commited code
Andreas Graeper <agraeper@googemail.com>
parents: 531
diff changeset
   457
  } return NULL;
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
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   460
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   461
private:
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   462
202
da1a8186f86f Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents: 201
diff changeset
   463
146
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 123
diff changeset
   464
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   465
/********************************/
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   466
/* B 1.3.3 - Derived data types */
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   467
/********************************/
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   468
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
   469
/*  signed_integer DOTDOT signed_integer */
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
   470
void *visit(subrange_c *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
   471
  symbol->lower_limit->accept(*this);
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
   472
  return 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
   473
}
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
   474
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   475
/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   476
void *visit(array_specification_c *symbol) {
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   477
  symbol->non_generic_type_name->accept(*this);
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   478
  return NULL;
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   479
}
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   480
146
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 123
diff changeset
   481
/*********************/
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 123
diff changeset
   482
/* B 1.4 - Variables */
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 123
diff changeset
   483
/*********************/
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
   484
146
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 123
diff changeset
   485
void *visit(symbolic_variable_c *symbol) {
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   486
  unsigned int vartype;
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
   487
  switch (wanted_variablegeneration) {
392
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   488
    case complextype_base_assignment_vg:
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   489
    case assignment_vg:
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   490
      this->print_variable_prefix();
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   491
      s4o.print(",");
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   492
      symbol->var_name->accept(*this);
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   493
      break;
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
   494
    case complextype_base_vg:
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
   495
      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
   496
      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
   497
    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
   498
	  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
   499
    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
   500
      if (this->is_variable_prefix_null()) {
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: 498
diff changeset
   501
	    vartype = search_var_instance_decl->get_vartype(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
   502
        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
   503
          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
   504
          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
   505
          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
   506
        }
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
   507
        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
   508
          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
   509
        }
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
   510
      }
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
   511
      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
   512
        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
   513
      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
   514
  }
146
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 123
diff changeset
   515
  return NULL;
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 123
diff changeset
   516
}
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 123
diff changeset
   517
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   518
/********************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   519
/* B.1.4.1   Directly Represented Variables */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   520
/********************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   521
// direct_variable: direct_variable_token   {$$ = new direct_variable_c($1);};
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   522
void *visit(direct_variable_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   523
  TRACE("direct_variable_c");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   524
  /* Do not use print_token() as it will change everything into uppercase */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   525
  if (strlen(symbol->value) == 0) ERROR;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   526
  if (this->is_variable_prefix_null()) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   527
    if (wanted_variablegeneration != fparam_output_vg)
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   528
	  s4o.print("*(");
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   529
  }
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   530
  else {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   531
    switch (wanted_variablegeneration) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   532
      case expression_vg:
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   533
  	    s4o.print(GET_LOCATED);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   534
  	    s4o.print("(");
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   535
  	    break;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   536
      case fparam_output_vg:
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   537
        s4o.print(GET_LOCATED_BY_REF);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   538
        s4o.print("(");
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   539
        break;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   540
      default:
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   541
        break;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   542
    }
146
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 123
diff changeset
   543
  }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   544
  this->print_variable_prefix();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   545
  s4o.printlocation(symbol->value + 1);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   546
  if ((this->is_variable_prefix_null() && wanted_variablegeneration != fparam_output_vg) ||
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   547
	  wanted_variablegeneration != assignment_vg)
146
eef5e62048c7 Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents: 123
diff changeset
   548
    s4o.print(")");
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   549
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   550
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   551
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   552
/*************************************/
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   553
/* B.1.4.2   Multi-element Variables */
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   554
/*************************************/
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   555
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   556
// SYM_REF2(structured_variable_c, record_variable, field_selector)
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   557
void *visit(structured_variable_c *symbol) {
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   558
  TRACE("structured_variable_c");
625
c0bda77b37a0 Merge with c2546c6e0cfa5ad55b288895f17f1b9f2a228f3b
Laurent Bessard
parents: 411 594
diff changeset
   559
  bool type_is_complex = search_var_instance_decl->type_is_complex(symbol->record_variable);
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   560
  switch (wanted_variablegeneration) {
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   561
    case complextype_base_vg:
392
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   562
    case complextype_base_assignment_vg:
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   563
      symbol->record_variable->accept(*this);
410
c6486bd97392 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 406
diff changeset
   564
      if (!type_is_complex) {
c6486bd97392 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 406
diff changeset
   565
        s4o.print(".");
c6486bd97392 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 406
diff changeset
   566
        symbol->field_selector->accept(*this);
c6486bd97392 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 406
diff changeset
   567
      }
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   568
      break;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   569
    case complextype_suffix_vg:
411
3e21d98d0a71 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 410
diff changeset
   570
	  symbol->record_variable->accept(*this);
3e21d98d0a71 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 410
diff changeset
   571
	  if (type_is_complex) {
3e21d98d0a71 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 410
diff changeset
   572
		s4o.print(".");
3e21d98d0a71 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 410
diff changeset
   573
		symbol->field_selector->accept(*this);
3e21d98d0a71 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 410
diff changeset
   574
	  }
3e21d98d0a71 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 410
diff changeset
   575
	  break;
3e21d98d0a71 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 410
diff changeset
   576
	case assignment_vg:
3e21d98d0a71 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 410
diff changeset
   577
	  symbol->record_variable->accept(*this);
3e21d98d0a71 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 410
diff changeset
   578
	  s4o.print(".");
3e21d98d0a71 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 410
diff changeset
   579
	  symbol->field_selector->accept(*this);
3e21d98d0a71 Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents: 410
diff changeset
   580
	  break;
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   581
    default:
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   582
      if (this->is_variable_prefix_null()) {
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   583
    	symbol->record_variable->accept(*this);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   584
    	s4o.print(".");
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   585
    	symbol->field_selector->accept(*this);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   586
      }
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   587
      else
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   588
    	print_getter(symbol);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   589
      break;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   590
  }
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   591
  return NULL;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   592
}
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   593
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   594
/*  subscripted_variable '[' subscript_list ']' */
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   595
//SYM_REF2(array_variable_c, subscripted_variable, subscript_list)
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   596
void *visit(array_variable_c *symbol) {
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   597
  switch (wanted_variablegeneration) {
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   598
    case complextype_base_vg:
392
9b88b8b6bccd Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents: 382
diff changeset
   599
    case complextype_base_assignment_vg:
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   600
      symbol->subscripted_variable->accept(*this);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   601
      break;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   602
    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
   603
      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
   604
321
a96399ab57c2 Add better comments, and change name of functions to clarify what they do.
Mario de Sousa <msousa@fe.up.pt>
parents: 311
diff changeset
   605
      current_array_type = search_varfb_instance_type->get_type_id(symbol->subscripted_variable);
238
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   606
      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
   607
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   608
      s4o.print(".table");
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   609
      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
   610
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   611
      current_array_type = NULL;
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   612
      break;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   613
    default:
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   614
      if (this->is_variable_prefix_null()) {
238
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   615
        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
   616
321
a96399ab57c2 Add better comments, and change name of functions to clarify what they do.
Mario de Sousa <msousa@fe.up.pt>
parents: 311
diff changeset
   617
        current_array_type = search_varfb_instance_type->get_type_id(symbol->subscripted_variable);
238
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   618
        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
   619
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   620
        s4o.print(".table");
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   621
        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
   622
0919986a5c98 Bug when trying to get type of elements in a big complex structure fixed
laurent
parents: 237
diff changeset
   623
        current_array_type = NULL;
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   624
      }
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   625
      else
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   626
    	print_getter(symbol);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   627
      break;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   628
  }
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   629
  return NULL;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   630
}
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   631
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   632
/* subscript_list ',' subscript */
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   633
void *visit(subscript_list_c *symbol) {
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   634
  array_dimension_iterator_c* array_dimension_iterator = new array_dimension_iterator_c(current_array_type);
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   635
  for (int i =  0; i < symbol->n; i++) {
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   636
    symbol_c* dimension = array_dimension_iterator->next();
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   637
	if (dimension == NULL) ERROR;
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   638
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   639
	s4o.print("[(");
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   640
    symbol->elements[i]->accept(*this);
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   641
    s4o.print(") - (");
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   642
    dimension->accept(*this);
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   643
    s4o.print(")]");
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   644
  }
377
60b012b7793f Adding support for compiling direct array specification inside variable declaration
laurent
parents: 355
diff changeset
   645
  delete array_dimension_iterator;
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   646
  return NULL;
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   647
}
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
   648
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   649
/******************************************/
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   650
/* B 1.4.3 - Declaration & Initialisation */
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   651
/******************************************/
237
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   652
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   653
/* helper symbol for structure_initialization */
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   654
/* structure_element_initialization_list ',' structure_element_initialization */
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   655
void *visit(structure_element_initialization_list_c *symbol) {
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   656
  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
   657
  structure_initialization->init_structure_default(this->current_param_type);
237
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   658
  structure_initialization->init_structure_values(symbol);
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   659
  delete structure_initialization;
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   660
  return NULL;
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   661
}
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   662
237
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   663
/* helper symbol for array_initialization */
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   664
/* array_initial_elements_list ',' array_initial_elements */
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   665
void *visit(array_initial_elements_list_c *symbol) {
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   666
  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
   667
  array_initialization->init_array_size(this->current_param_type);
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   668
  array_initialization->init_array_values(symbol);
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   669
  delete array_initialization;
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   670
  return NULL;
cece842c7417 Adding support for using arrays in POU interface
laurent
parents: 236
diff changeset
   671
}
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   672
/****************************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   673
/* B.2 - Language IL (Instruction List) */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   674
/****************************************/
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
/* B 2.1 Instructions and Operands */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   678
/***********************************/
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   679
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   680
/*| instruction_list il_instruction */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   681
void *visit(instruction_list_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   682
  
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   683
  /* Declare the IL implicit variable, that will store the result of the IL operations... */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   684
  declare_implicit_variable();
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   685
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   686
  /* Declare the backup to the IL implicit variable, that will store the result of the IL operations executed inside a parenthesis... */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   687
  declare_implicit_variable_back();
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   688
  /*
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   689
  s4o.print(s4o.indent_spaces);
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   690
  this->implicit_variable_result_back.accept(*this);
211
5249d313ff7c Remove warnings when compiling IL generated C code
laurent
parents: 210
diff changeset
   691
  s4o.print(".INTvar = 0;\n\n");
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   692
  */
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   693
  print_list(symbol, s4o.indent_spaces, ";\n" + s4o.indent_spaces, ";\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   694
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   695
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   696
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   697
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   698
/* | label ':' [il_incomplete_instruction] eol_list */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   699
// SYM_REF2(il_instruction_c, label, il_instruction)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   700
void *visit(il_instruction_c *symbol) {
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   701
  /* all previous IL instructions should have the same datatype (checked in stage3), so we get the datatype from the first previous IL instruction we find */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   702
  implicit_variable_current.datatype = (symbol->prev_il_instruction.empty())? NULL : symbol->prev_il_instruction[0]->datatype;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   703
  implicit_variable_result .datatype = symbol->datatype;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   704
  
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   705
  if (NULL != symbol->label) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   706
    symbol->label->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   707
    s4o.print(":\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   708
    s4o.print(s4o.indent_spaces);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   709
  }
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   710
311
8fcea60029de Allow [EOL] after a label in IL.
Mario de Sousa <msousa@fe.up.pt>
parents: 309
diff changeset
   711
  if (NULL != symbol->il_instruction) {
8fcea60029de Allow [EOL] after a label in IL.
Mario de Sousa <msousa@fe.up.pt>
parents: 309
diff changeset
   712
    symbol->il_instruction->accept(*this);
8fcea60029de Allow [EOL] after a label in IL.
Mario de Sousa <msousa@fe.up.pt>
parents: 309
diff changeset
   713
  }  
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   714
  
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   715
  implicit_variable_result .datatype = NULL;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   716
  implicit_variable_current.datatype = NULL;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   717
  return NULL;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   718
}
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   719
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
/* | il_simple_operator [il_operand] */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   722
//SYM_REF2(il_simple_operation_c, il_simple_operator, il_operand)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   723
void *visit(il_simple_operation_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   724
  this->current_operand = symbol->il_operand;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   725
  symbol->il_simple_operator->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   726
  this->current_operand = NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   727
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   728
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   729
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   730
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   731
/* | function_name [il_operand_list] */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   732
// SYM_REF2(il_function_call_c, function_name, il_operand_list)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   733
void *visit(il_function_call_c *symbol) {
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   734
  symbol_c* function_type_prefix = NULL;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   735
  symbol_c* function_name = NULL;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   736
  symbol_c* function_type_suffix = NULL;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   737
  DECLARE_PARAM_LIST()
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   738
  
233
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   739
  function_call_param_iterator_c function_call_param_iterator(symbol);
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   740
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   741
  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
   742
  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
   743
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   744
  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
   745
  
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   746
  /* 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
   747
   * 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
   748
   */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   749
  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
   750
  identifier_c *param_name;
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   751
    /* flag to remember whether we have already used the value stored in the implicit variable to pass to the first parameter */
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   752
  bool used_defvar = false; 
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   753
    /* 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
   754
  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
   755
  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
   756
    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
   757
      /* 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
   758
       * 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
   759
       * 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
   760
       *
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   761
       * 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
   762
       * 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
   763
       * 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
   764
       */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   765
      /* 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
   766
       *       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
   767
       *       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
   768
       *       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
   769
       */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   770
      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
   771
      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
   772
      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
   773
      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
   774
      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
   775
      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
   776
      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
   777
      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
   778
      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
   779
    }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   780
    
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   781
    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
   782
    if (param_type == NULL) ERROR;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   783
    
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   784
    function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   785
    
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   786
    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
   787
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   788
    /* 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
   789
    /* NOTE: Since the class il_function_call_c only references a non.formal function call,
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   790
     * the following line of code is not required in this case. However, it doesn't
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   791
     * harm to leave it in, as in the case of a non-formal syntax function call,
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   792
     * it will always return NULL.
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   793
     * We leave it in in case we later decide to merge this part of the code together
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   794
     * with the function calling code in generate_c_st_c, which does require
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   795
     * the following line...
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   796
     */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   797
    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
   798
      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
   799
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   800
    /* if it is the first parameter in a non-formal function call (which is the
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   801
     * case being handled!), semantics specifies that we should
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   802
     * get the value off the IL implicit variable!
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   803
     *
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   804
     * However, if the parameter is an implicitly defined EN or ENO parameter, we should not
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   805
     * use the IL implicit variable as a source of data to pass to those parameters!
350
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
    if ((param_value == NULL) &&  (!used_defvar) && !fp_iterator.is_en_eno_param_implicit()) {
683
2d96a47a75b1 Code cleanup: get the datatype of each entity off symbol->datatype (set in stage3 datatype checking), instead of determining it again in stage4. (NOTE: handling of IL parenthesized expressions is not working! Will be fixed later.)
Mario de Sousa <msousa@fe.up.pt>
parents: 682
diff changeset
   808
      if (NULL == implicit_variable_current.datatype) ERROR;
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   809
      param_value = &this->implicit_variable_current;
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   810
      used_defvar = true;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   811
    }
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
    /* 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
   814
    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
   815
      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
   816
    }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   817
    
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   818
    /* 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
   819
     * 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
   820
     * have reached the end, and should simply jump out of the for loop.
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   821
     */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   822
    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
   823
      break;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   824
    }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   825
    
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   826
    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
   827
      /* 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
   828
      /* 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
   829
      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
   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
    ADD_PARAM_LIST(param_name, param_value, param_type, 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
   833
  } /* for(...) */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   834
233
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   835
  if (function_call_param_iterator.next_nf() != NULL) ERROR;
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
   836
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   837
  bool has_output_params = false;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   838
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   839
  if (!this->is_variable_prefix_null()) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   840
    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
   841
      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
   842
           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
   843
           PARAM_VALUE != NULL) {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   844
        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
   845
      }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   846
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   847
  }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   848
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   849
  /* Check whether we are calling an overloaded function! */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   850
  /* (fdecl_mutiplicity==2)  => calling overloaded function */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   851
  int fdecl_mutiplicity =  function_symtable.multiplicity(symbol->function_name);
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   852
  if (fdecl_mutiplicity == 0) ERROR;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   853
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   854
  this->implicit_variable_result.accept(*this);
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   855
  s4o.print(" = ");
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   856
    
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   857
  if (function_type_prefix != NULL) {
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   858
    s4o.print("(");
669
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   859
    default_literal_type(function_type_prefix)->accept(*this);
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
  }
336
229eb3e29216 Fix bug in function calls with literal parameters
laurent
parents: 321
diff changeset
   862
  if (function_type_suffix != NULL) {
669
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   863
  	function_type_suffix = default_literal_type(function_type_suffix);
336
229eb3e29216 Fix bug in function calls with literal parameters
laurent
parents: 321
diff changeset
   864
  }
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   865
  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
   866
    fcall_number++;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   867
    s4o.print("__");
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   868
    fbname->accept(*this);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   869
    s4o.print("_");
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   870
    function_name->accept(*this);
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   871
    if (fdecl_mutiplicity == 2) {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   872
      /* 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
   873
      s4o.print("__");
406
6381589697ff Fix bug with overloaded function due to literal input values
laurent
parents: 405
diff changeset
   874
      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
   875
      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
   876
    }
594
c8092e909886 Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents: 563
diff changeset
   877
    s4o.print(fcall_number);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   878
  }
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   879
  else {
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   880
    if (function_name != NULL) {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   881
          function_name->accept(*this);
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   882
          if (fdecl_mutiplicity == 2) {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   883
            /* 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
   884
            s4o.print("__");
406
6381589697ff Fix bug with overloaded function due to literal input values
laurent
parents: 405
diff changeset
   885
            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
   886
            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
   887
          }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   888
    }	  
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   889
    if (function_type_suffix != NULL)
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   890
      function_type_suffix->accept(*this);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   891
  }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   892
  s4o.print("(");
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   893
  s4o.indent_right();
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   894
  
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   895
  int nb_param = 0;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   896
  PARAM_LIST_ITERATOR() {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   897
    symbol_c *param_value = PARAM_VALUE;
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   898
    current_param_type = PARAM_TYPE;
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   899
    
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   900
    switch (PARAM_DIRECTION) {
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   901
      case function_param_iterator_c::direction_in:
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   902
        if (nb_param > 0)
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   903
          s4o.print(",\n"+s4o.indent_spaces);
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   904
        if (param_value == NULL) {
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   905
          /* If not, get the default value of this variable's type */
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   906
          param_value = (symbol_c *)current_param_type->accept(*type_initial_value_c::instance());
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   907
        }
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   908
        if (param_value == NULL) ERROR;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   909
        s4o.print("(");
669
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   910
        if (get_datatype_info_c::is_ANY_INT_literal(current_param_type))
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   911
          search_constant_type_c::lint_type_name.accept(*this);
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   912
        else if (get_datatype_info_c::is_ANY_REAL_literal(current_param_type))
7049fd6fe515 Deprecate use of search_expression_type_c (prepare for complete removal!)
Mario de Sousa <msousa@fe.up.pt>
parents: 667
diff changeset
   913
          search_constant_type_c::lreal_type_name.accept(*this);
220
f332b62cd2c1 Bug with ULINT correction fixed
laurent
parents: 217
diff changeset
   914
        else
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   915
          current_param_type->accept(*this);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   916
        s4o.print(")");
235
ed66dc50f31a Bug on generate_c_inlinefcall fixed
laurent
parents: 233
diff changeset
   917
        print_check_function(current_param_type, param_value);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   918
        nb_param++;
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   919
        break;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   920
      case function_param_iterator_c::direction_out:
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   921
      case function_param_iterator_c::direction_inout:
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   922
        if (!has_output_params) {
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   923
          if (nb_param > 0)
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   924
            s4o.print(",\n"+s4o.indent_spaces);
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   925
            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
   926
              s4o.print("NULL");
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   927
            } else {
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   928
              wanted_variablegeneration = fparam_output_vg;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   929
              param_value->accept(*this);
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   930
              wanted_variablegeneration = expression_vg;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   931
            }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   932
          nb_param++;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   933
        }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   934
        break;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   935
      case function_param_iterator_c::direction_extref:
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   936
        /* TODO! */
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   937
        ERROR;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   938
        break;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   939
    } /* switch */
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   940
  }
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   941
  if (has_output_params) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   942
    if (nb_param > 0)
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
   943
      s4o.print(",\n"+s4o.indent_spaces);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   944
    s4o.print(FB_FUNCTION_PARAM);
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   945
  }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   946
  
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
   947
  s4o.print(")");
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   948
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   949
  CLEAR_PARAM_LIST()
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
   950
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   951
  return NULL;
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
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   955
/* | il_expr_operator '(' [il_operand] eol_list [simple_instr_list] ')' */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   956
//SYM_REF4(il_expression_c, il_expr_operator, il_operand, simple_instr_list, unused)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   957
void *visit(il_expression_c *symbol) {
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   958
  LD_operator_c           *tmp_LD_operator           = NULL;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   959
  il_simple_operation_c   *tmp_il_simple_operation   = NULL;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   960
  il_simple_instruction_c *tmp_il_simple_instruction = NULL;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   961
  
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   962
  /* We will be recursevely interpreting an instruction list, so we store a backup of the implicit_variable_result/current.
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   963
   * Notice that they will be overwriten while processing the parenthsized instruction list.
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   964
   */
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   965
  il_default_variable_c old_implicit_variable_current = this->implicit_variable_current;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   966
  il_default_variable_c old_implicit_variable_result  = this->implicit_variable_result;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   967
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   968
  /* If the symbol->il_operand is not NULL, then we instantiate a 'LD' operation and insert it into the simple_instr_list
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   969
   * (i.e. add an equivalent LD operation to the Abstract Syntax Tree), and let it be handled like any other LD operation!
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   970
   */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   971
  if (NULL != symbol->il_operand) {
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   972
    tmp_LD_operator = new LD_operator_c();
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   973
    if (NULL == tmp_LD_operator)  ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   974
    /* copy all the location, datatpe, etc.. data from symbol->il_operand to the new object! */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   975
    *((symbol_c *)tmp_LD_operator) = *(symbol->il_operand);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   976
    
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   977
    tmp_il_simple_operation = new il_simple_operation_c(tmp_LD_operator, symbol->il_operand);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   978
    if (NULL == tmp_il_simple_operation)  ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   979
    /* copy all the location, datatpe, etc.. data from symbol->il_operand to the new object! */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   980
    *((symbol_c *)tmp_il_simple_operation) = *(symbol->il_operand);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   981
    
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   982
    tmp_il_simple_instruction = new il_simple_instruction_c(tmp_il_simple_operation);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   983
    if (NULL == tmp_il_simple_instruction)  ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   984
    /* copy all the location, datatpe, etc.. data from symbol->il_operand to the new object! */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   985
    *((symbol_c *)tmp_il_simple_instruction) = *(symbol->il_operand);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   986
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   987
    if (NULL == symbol->simple_instr_list)  {
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   988
      symbol->simple_instr_list = new simple_instr_list_c();
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   989
      if (NULL == symbol->simple_instr_list)  ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   990
      /* copy all the location, datatpe, etc.. data from symbol->il_operand to the new object! */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   991
      *((symbol_c *)symbol->simple_instr_list) = *(symbol->il_operand);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   992
    }
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   993
    list_c *tmp_list = dynamic_cast <list_c *>(symbol->simple_instr_list);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   994
    if (NULL == tmp_list)  ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   995
    tmp_list->insert_element(tmp_il_simple_instruction, 0);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   996
  }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   997
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
   998
  /* Now do the parenthesised instructions... */
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
   999
  /* NOTE: the following code line will overwrite the variables implicit_variable_current and implicit_variable_result */
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1000
  symbol->simple_instr_list->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1001
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1002
  /* delete/undo any changes made to the AST above */
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1003
  if (NULL != symbol->il_operand) {
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1004
    delete tmp_LD_operator;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1005
    delete tmp_il_simple_operation;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1006
    delete tmp_il_simple_instruction;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1007
    list_c *tmp_list = dynamic_cast <list_c *>(symbol->simple_instr_list);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1008
    if (NULL == tmp_list)  ERROR;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1009
    delete tmp_list->elements[0];
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1010
    tmp_list->remove_element(0);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1011
    if (0 == tmp_list->n) {
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1012
      delete symbol->simple_instr_list;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1013
      symbol->simple_instr_list = NULL;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1014
    }
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1015
  }
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1016
  
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1017
  /* Now do the operation, using the previous result! */
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1018
  /* NOTE: The result of the previous instruction list in the parenthesis will be stored
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1019
   * in a variable named IL_DEFVAR_BACK. This is done in the visitor
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1020
   * to instruction_list_c objects...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1021
   */
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1022
  this->implicit_variable_result_back.datatype = symbol->simple_instr_list->datatype;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1023
  this->current_operand = &(this->implicit_variable_result_back);
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1024
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1025
  this->implicit_variable_current = old_implicit_variable_current;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1026
  this->implicit_variable_result  = old_implicit_variable_result;
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1027
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1028
  symbol->il_expr_operator->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1029
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1030
  this->current_operand = NULL;
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1031
  this->implicit_variable_result_back.datatype = NULL;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1032
  return NULL;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1033
}
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1034
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1035
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1036
/*  il_jump_operator label */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1037
// SYM_REF2(il_jump_operation_c, il_jump_operator, label)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1038
void *visit(il_jump_operation_c *symbol) {
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1039
 /* Pass the symbol->label to the il_jump_operation visitor using the jump_label parameter... */
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1040
  this->jump_label = symbol->label;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1041
  symbol->il_jump_operator->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1042
  this->jump_label = NULL;
682
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1043
  return NULL;
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1044
}
966f32af570d Major code cleanup: IL code generation now uses symbol.datatype (filled in during stage3 data type checking) instead of determining the symbol's datatype by itself.
Mario de Sousa <msousa@fe.up.pt>
parents: 669
diff changeset
  1045
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1046
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1047
/*   il_call_operator prev_declared_fb_name
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1048
 * | il_call_operator prev_declared_fb_name '(' ')'
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1049
 * | il_call_operator prev_declared_fb_name '(' eol_list ')'
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1050
 * | il_call_operator prev_declared_fb_name '(' il_operand_list ')'
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1051
 * | il_call_operator prev_declared_fb_name '(' eol_list il_param_list ')'
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1052
 */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1053
// SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1054
void *visit(il_fb_call_c *symbol) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1055
  symbol->il_call_operator->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1056
  s4o.print("{\n");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1057
  s4o.indent_right();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1058
  s4o.print(s4o.indent_spaces);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1059
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1060
  /* first figure out what is the name of the function block type of the function block being called... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1061
  symbol_c *function_block_type_name = this->search_fb_instance_decl->get_type_name(symbol->fb_name);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1062
    /* should never occur. The function block instance MUST have been declared... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1063
  if (function_block_type_name == NULL) ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1064
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1065
  /* Now find the declaration of the function block type being called... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1066
  function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(function_block_type_name);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1067
    /* should never occur. The function block type being called MUST be in the symtable... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1068
  if (fb_decl == function_block_type_symtable.end_value()) ERROR;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1069
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1070
  /* loop through each function block parameter, find the value we should pass
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1071
   * to it, and then output the c equivalent...
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1072
   */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1073
  function_param_iterator_c fp_iterator(fb_decl);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1074
  identifier_c *param_name;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1075
  function_call_param_iterator_c function_call_param_iterator(symbol);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1076
  for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1077
    function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1078
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1079
    /* 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: 201
diff changeset
  1080
    symbol_c *param_value = function_call_param_iterator.search_f(param_name);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1081
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1082
    /* 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
  1083
    /* 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
  1084
     * were implicitly defined!
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1085
     */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1086
    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: 201
diff changeset
  1087
      param_value = function_call_param_iterator.next_nf();
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1088
98
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
  1089
    symbol_c *param_type = fp_iterator.param_type();
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
  1090
    if (param_type == NULL) ERROR;
d0cdf1d00b74 Adding support for derived data types.
lbessard
parents: 70
diff changeset
  1091
    
123
a9b4af71cfa4 Fixed some issues on:
lbessard
parents: 98
diff changeset
  1092
        /* now output the value assignment */
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1093
    if (param_value != NULL)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1094
      if ((param_direction == function_param_iterator_c::direction_in) ||
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1095
          (param_direction == function_param_iterator_c::direction_inout)) {
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1096
    	if (this->is_variable_prefix_null()) {
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1097
    	  symbol->fb_name->accept(*this);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1098
          s4o.print(".");
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1099
          param_name->accept(*this);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1100
          s4o.print(" = ");
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1101
          print_check_function(param_type, param_value);
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1102
    	}
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1103
        else {
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1104
          print_setter(param_name, param_type, param_value, symbol->fb_name);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1105
        }
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1106
        s4o.print(";\n" + s4o.indent_spaces);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1107
      }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1108
  } /* for(...) */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1109
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1110
  /* now call the function... */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1111
  function_block_type_name->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1112
  s4o.print(FB_FUNCTION_SUFFIX);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1113
  s4o.print("(&");
240
f78fa87bb4cb Bugs fixed:
laurent
parents: 238
diff changeset
  1114
  print_variable_prefix();
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1115
  symbol->fb_name->accept(*this);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1116
  s4o.print(")");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1117
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1118
  /* loop through each function parameter, find the variable to which
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1119
   * we should atribute the value of all output or inoutput parameters.
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1120
   */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1121
  fp_iterator.reset();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1122
  function_call_param_iterator.reset();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1123
  for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) {
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1124
    function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1125
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1126
    /* 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: 201
diff changeset
  1127
    symbol_c *param_value = function_call_param_iterator.search_f(param_name);
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1128
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1129
    /* 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
  1130
    /* 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
  1131
     * were implicitly defined!
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1132
     */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1133
    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: 201
diff changeset
  1134
      param_value = function_call_param_iterator.next_nf();
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1135
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1136
    /* now output the value assignment */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1137
    if (param_value != NULL)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1138
      if ((param_direction == function_param_iterator_c::direction_out) ||
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1139
          (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: 311
diff changeset
  1140
        symbol_c *param_type = search_varfb_instance_type->get_type_id(param_value);
240
f78fa87bb4cb Bugs fixed:
laurent
parents: 238
diff changeset
  1141
        s4o.print(";\n" + s4o.indent_spaces);
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1142
        if (this->is_variable_prefix_null()) {
240
f78fa87bb4cb Bugs fixed:
laurent
parents: 238
diff changeset
  1143
          param_value->accept(*this);
228
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1144
		  s4o.print(" = ");
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1145
		  print_check_function(param_type, param_name, symbol->fb_name);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1146
		}
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1147
		else {
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1148
		  print_setter(param_value, param_type, param_name, NULL, symbol->fb_name);
43831b683764 Adding support for setter and getter on complex datatype in IL
berem
parents: 226
diff changeset
  1149
		}
70
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1150
      }
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1151
  } /* for(...) */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1152
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_left();
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1155
  s4o.print(s4o.indent_spaces);
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1156
  s4o.print("}");
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1157
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1158
  return NULL;
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1159
}
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1160
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1161
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1162
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1163
/* | function_name '(' eol_list [il_param_list] ')' */
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1164
// SYM_REF2(il_formal_funct_call_c, function_name, il_param_list)
e1f0ebd2d9ec Change generate_cc to generate_c
lbessard
parents:
diff changeset
  1165
void *visit(il_formal_funct_call_c *symbol) {
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
  1166
  symbol_c* function_type_prefix = NULL;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
  1167
  symbol_c* function_name = NULL;
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
  1168
  symbol_c* function_type_suffix = NULL;
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1169
  DECLARE_PARAM_LIST()
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
  1170
233
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
  1171
  function_call_param_iterator_c function_call_param_iterator(symbol);
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
  1172
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1173
  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
  1174
  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
  1175
        
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1176
  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
  1177
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1178
  /* 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
  1179
   * 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
  1180
   */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1181
  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
  1182
  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
  1183
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1184
    /* 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
  1185
  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
  1186
  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
  1187
    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
  1188
      /* 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
  1189
       * 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
  1190
       * 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
  1191
       *
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1192
       * 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
  1193
       * 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
  1194
       * 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
  1195
       */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1196
      /* 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
  1197
       *       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
  1198
       *       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
  1199
       *       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
  1200
       */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1201
      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
  1202
      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
  1203
      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
  1204
      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
  1205
      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
  1206
      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
  1207
      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
  1208
      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
  1209
      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
  1210
    }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
  1211
    
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1212
    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
  1213
      /* 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
  1214
       * 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
  1215
       * 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
  1216
       */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1217
      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
  1218
      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
  1219
      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
  1220
      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
  1221
      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
  1222
    }
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1223
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1224
    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
  1225
    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
  1226
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1227
    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
  1228
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1229
    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
  1230
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1231
    /* 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
  1232
    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
  1233
      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
  1234
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1235
    /* 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
  1236
    /* NOTE: the following line of code is not required in this case, but it doesn't
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1237
     * harm to leave it in, as in the case of a formal syntax function call,
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1238
     * it will always return NULL.
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1239
     * We leave it in in case we later decide to merge this part of the code together
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1240
     * with the function calling code in generate_c_st_c, which does require
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1241
     * the following line...
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1242
     */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1243
    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
  1244
      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
  1245
    }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
  1246
    
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1247
    /* 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
  1248
     * 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
  1249
     * have reached the end, and should simply jump out of the for loop.
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1250
     */
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1251
    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
  1252
      break;
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1253
    }
169
bea932bc60b0 Bug when function with unconnected input fixed
lbessard
parents: 149
diff changeset
  1254
    
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1255
    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
  1256
      /* 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
  1257
      /* 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
  1258
      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
  1259
    }
149
05ca171a3d57 Adding support for EN/ENO in standard functions
lbessard
parents: 146
diff changeset
  1260
    
350
2c3c4dc34979 Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents: 336
diff changeset
  1261
    ADD_PARAM_LIST(param_name, param_value, param_type, fp_iterator.param_direction())
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1262
  }
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1263
  
233
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
  1264
  if (function_call_param_iterator.next_nf() != NULL) ERROR;
3d23a68183d3 Bug on standard functions called with literals fixed
laurent
parents: 231
diff changeset
  1265
217
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1266
  bool has_output_params = false;
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1267
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent
parents: 216
diff changeset
  1268
  if (!this->is_variable_prefix_null()) {
f5dfadf5de54 Adding support for declare, init, get and set macros
laurent