author  mjsousa 
Sun, 13 Jul 2014 12:26:58 +0100  
changeset 909  8b2a31dea131 
parent 897  8c3e91c385f5 
child 911  ef3347dbfa0c 
permissions  rwxrxrx 
70  1 
/* 
279
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

2 
* matiec  a compiler for the programming languages defined in IEC 611313 
70  3 
* 
279
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

4 
* Copyright (C) 20032011 Mario de Sousa (msousa@fe.up.pt) 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

5 
* Copyright (C) 20072011 Laurent Bessard and Edouard Tisserant 
70  6 
* 
279
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

7 
* This program is free software: you can redistribute it and/or modify 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

8 
* it under the terms of the GNU General Public License as published by 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

9 
* the Free Software Foundation, either version 3 of the License, or 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

10 
* (at your option) any later version. 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

11 
* 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

12 
* This program is distributed in the hope that it will be useful, 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

13 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

14 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

15 
* GNU General Public License for more details. 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

16 
* 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

17 
* You should have received a copy of the GNU General Public License 
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

18 
* along with this program. If not, see <http://www.gnu.org/licenses/>. 
70  19 
* 
20 
* This code is made available on the understanding that it will not be 

21 
* used in safetycritical situations without a full and competent review. 

22 
* 

23 
* Based on the 

24 
* FINAL DRAFT  IEC 611313, 2nd Ed. (20011210) 

25 
* 

26 
*/ 

27 

28 

29 
/* 

30 
* Conversion of st statements (i.e. ST code). 

31 
* 

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

279
c0453b7f99df
Regenerated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
258
diff
changeset

33 
* a C source program equivalent to the IL and ST, or SFC 
70  34 
* code. 
35 
*/ 

36 

37 

350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

38 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

39 
#include "../../util/strdup.hh" 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

40 

70  41 
/***********************************************************************/ 
42 
/***********************************************************************/ 

43 
/***********************************************************************/ 

44 
/***********************************************************************/ 

45 

46 

861
443e8243f289
Code cleanup (part 3): generate_c_typedecl_c is no longer needed for code generation in POUS.c It is now only needed for datatype declaration in POUS.h
mjsousa
parents:
855
diff
changeset

47 
class generate_c_st_c: public generate_c_base_c { 
70  48 

217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

49 
public: 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

50 
typedef enum { 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

51 
expression_vg, 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

52 
complextype_base_vg, 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

53 
complextype_suffix_vg, 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

54 
fparam_output_vg 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

55 
} variablegeneration_t; 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

56 

347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

57 
typedef enum { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

58 
single_cg, 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

59 
subrange_cg, 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

60 
none_cg 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

61 
} casegeneration_t; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

62 

70  63 
private: 
64 
/* When calling a function block, we must first find it's type, 

65 
* by searching through the declarations of the variables currently 

66 
* in scope. 

67 
* This class does just that... 

68 
* A new class is instantiated whenever we begin generating the code 

69 
* for a function block type declaration, or a program declaration. 

70 
* This object instance will then later be called while the 

71 
* function block's or the program's body is being handled. 

72 
* 

73 
* Note that functions cannot contain calls to function blocks, 

74 
* so we do not create an object instance when handling 

75 
* a function declaration. 

76 
*/ 

863
06820d03a433
Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents:
854
diff
changeset

77 
search_fb_instance_decl_c *search_fb_instance_decl; 
70  78 
search_varfb_instance_type_c *search_varfb_instance_type; 
505
21be0f2f242d
Removing code from search_varfb_instance_type_c (use search_var_instance_decl_c instead).
Mario de Sousa <msousa@fe.up.pt>
parents:
503
diff
changeset

79 
search_var_instance_decl_c *search_var_instance_decl; 
863
06820d03a433
Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents:
854
diff
changeset

80 

06820d03a433
Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents:
854
diff
changeset

81 
symbol_c *scope_; 
70  82 

98  83 
symbol_c* current_array_type; 
235  84 
symbol_c* current_param_type; 
98  85 

217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

86 
int fcall_number; 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

87 
symbol_c *fbname; 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

88 

347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

89 
bool first_subrange_case_list; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

90 

217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

91 
variablegeneration_t wanted_variablegeneration; 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

92 
casegeneration_t wanted_casegeneration; 
145  93 

70  94 
public: 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

95 
generate_c_st_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL) 
861
443e8243f289
Code cleanup (part 3): generate_c_typedecl_c is no longer needed for code generation in POUS.c It is now only needed for datatype declaration in POUS.h
mjsousa
parents:
855
diff
changeset

96 
: generate_c_base_c(s4o_ptr) { 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

97 
search_fb_instance_decl = new search_fb_instance_decl_c (scope); 
70  98 
search_varfb_instance_type = new search_varfb_instance_type_c(scope); 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

99 
search_var_instance_decl = new search_var_instance_decl_c (scope); 
863
06820d03a433
Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents:
854
diff
changeset

100 
scope_ = scope; 
505
21be0f2f242d
Removing code from search_varfb_instance_type_c (use search_var_instance_decl_c instead).
Mario de Sousa <msousa@fe.up.pt>
parents:
503
diff
changeset

101 

70  102 
this>set_variable_prefix(variable_prefix); 
98  103 
current_array_type = NULL; 
235  104 
current_param_type = NULL; 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

105 
fcall_number = 0; 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

106 
fbname = name; 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

107 
wanted_variablegeneration = expression_vg; 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

108 
wanted_casegeneration = none_cg; 
70  109 
} 
110 

111 
virtual ~generate_c_st_c(void) { 

112 
delete search_fb_instance_decl; 

113 
delete search_varfb_instance_type; 

505
21be0f2f242d
Removing code from search_varfb_instance_type_c (use search_var_instance_decl_c instead).
Mario de Sousa <msousa@fe.up.pt>
parents:
503
diff
changeset

114 
delete search_var_instance_decl; 
70  115 
} 
116 

117 

118 
public: 

119 
void generate(statement_list_c *stl) { 

120 
stl>accept(*this); 

121 
} 

122 

123 
private: 

531
e7d6f28fc882
Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents:
505
diff
changeset

124 

e7d6f28fc882
Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents:
505
diff
changeset

125 

e7d6f28fc882
Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents:
505
diff
changeset

126 

e7d6f28fc882
Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents:
505
diff
changeset

127 

e7d6f28fc882
Make temporary fix to is_complex() method.
Mario de Sousa <msousa@fe.up.pt>
parents:
505
diff
changeset

128 

70  129 

226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

130 
void *print_getter(symbol_c *symbol) { 
863
06820d03a433
Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents:
854
diff
changeset

131 
unsigned int vartype = analyse_variable_c::first_nonfb_vardecltype(symbol, scope_); 
235  132 
if (wanted_variablegeneration == fparam_output_vg) { 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

133 
if (vartype == search_var_instance_decl_c::external_vt) { 
854
13d0b67de111
Code cleanup: move datatype analysis to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
852
diff
changeset

134 
if (!get_datatype_info_c::is_type_valid (symbol>datatype)) ERROR; 
13d0b67de111
Code cleanup: move datatype analysis to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
852
diff
changeset

135 
if ( get_datatype_info_c::is_function_block(symbol>datatype)) 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

136 
s4o.print(GET_EXTERNAL_FB_BY_REF); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

137 
else 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

138 
s4o.print(GET_EXTERNAL_BY_REF); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

139 
} 
235  140 
else if (vartype == search_var_instance_decl_c::located_vt) 
141 
s4o.print(GET_LOCATED_BY_REF); 

142 
else 

143 
s4o.print(GET_VAR_BY_REF); 

144 
} 

145 
else { 

706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

146 
if (vartype == search_var_instance_decl_c::external_vt) { 
854
13d0b67de111
Code cleanup: move datatype analysis to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
852
diff
changeset

147 
if (!get_datatype_info_c::is_type_valid (symbol>datatype)) ERROR; 
13d0b67de111
Code cleanup: move datatype analysis to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
852
diff
changeset

148 
if ( get_datatype_info_c::is_function_block(symbol>datatype)) 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

149 
s4o.print(GET_EXTERNAL_FB); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

150 
else 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

151 
s4o.print(GET_EXTERNAL); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

152 
} 
503
e1e7c7678c44
Edit formating and delete unused code.
Mario de Sousa <msousa@fe.up.pt>
parents:
498
diff
changeset

153 
else if (vartype == search_var_instance_decl_c::located_vt) 
e1e7c7678c44
Edit formating and delete unused code.
Mario de Sousa <msousa@fe.up.pt>
parents:
498
diff
changeset

154 
s4o.print(GET_LOCATED); 
e1e7c7678c44
Edit formating and delete unused code.
Mario de Sousa <msousa@fe.up.pt>
parents:
498
diff
changeset

155 
else 
e1e7c7678c44
Edit formating and delete unused code.
Mario de Sousa <msousa@fe.up.pt>
parents:
498
diff
changeset

156 
s4o.print(GET_VAR); 
235  157 
} 
887
a5e2eedeef53
A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents:
885
diff
changeset

158 

a5e2eedeef53
A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents:
885
diff
changeset

159 
variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration; 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

160 
s4o.print("("); 
887
a5e2eedeef53
A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents:
885
diff
changeset

161 
print_variable_prefix(); 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

162 
wanted_variablegeneration = complextype_base_vg; 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

163 
symbol>accept(*this); 
851
2c59c2b8fca4
Fix bug/issue #33 (correctly access struct/array variables declared inside a FB > r:=FB1.FB2.struct1.array1[3] )
Mario de Sousa <msousa@fe.up.pt>
parents:
800
diff
changeset

164 
s4o.print(","); 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

165 
wanted_variablegeneration = complextype_suffix_vg; 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

166 
symbol>accept(*this); 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

167 
s4o.print(")"); 
235  168 
wanted_variablegeneration = old_wanted_variablegeneration; 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

169 
return NULL; 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

170 
} 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

171 

852
efb44e892582
Fix bug: allow use, as lvalues, structures/arrays inside FBs (e.g. fb1.struct1.r := 33.3).
Mario de Sousa <msousa@fe.up.pt>
parents:
851
diff
changeset

172 

efb44e892582
Fix bug: allow use, as lvalues, structures/arrays inside FBs (e.g. fb1.struct1.r := 33.3).
Mario de Sousa <msousa@fe.up.pt>
parents:
851
diff
changeset

173 

226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

174 
void *print_setter(symbol_c* symbol, 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

175 
symbol_c* type, 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

176 
symbol_c* value, 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

177 
symbol_c* fb_symbol = NULL, 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

178 
symbol_c* fb_value = NULL) { 
888
4893e6b11b25
Remove call to type_is_complex() in ST code generation.
mjsousa
parents:
887
diff
changeset

179 

405
7b5d67d1aeef
Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents:
399
diff
changeset

180 
if (fb_symbol == NULL) { 
863
06820d03a433
Fix bug: correctly generate code when accessing external variables declared inside FBs as a structured variable (realvar := fb1.fb2.extvar1.realvar)
Mario de Sousa <msousa@fe.up.pt>
parents:
854
diff
changeset

181 
unsigned int vartype = analyse_variable_c::first_nonfb_vardecltype(symbol, scope_); 
889
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
888
diff
changeset

182 
symbol_c *first_nonfb = analyse_variable_c::find_first_nonfb(symbol); 
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
888
diff
changeset

183 
if (first_nonfb == NULL) ERROR; 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

184 
if (vartype == search_var_instance_decl_c::external_vt) { 
889
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
888
diff
changeset

185 
if (!get_datatype_info_c::is_type_valid (first_nonfb>datatype)) ERROR; 
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
888
diff
changeset

186 
if ( get_datatype_info_c::is_function_block(first_nonfb>datatype)) // handle situation where we are copying a complete fb > fb1.fb2.fb3 := fb4 (and fb3 is external!) 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

187 
s4o.print(SET_EXTERNAL_FB); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

188 
else 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

189 
s4o.print(SET_EXTERNAL); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

190 
} 
405
7b5d67d1aeef
Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents:
399
diff
changeset

191 
else if (vartype == search_var_instance_decl_c::located_vt) 
7b5d67d1aeef
Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents:
399
diff
changeset

192 
s4o.print(SET_LOCATED); 
7b5d67d1aeef
Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents:
399
diff
changeset

193 
else 
7b5d67d1aeef
Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents:
399
diff
changeset

194 
s4o.print(SET_VAR); 
7b5d67d1aeef
Fix bug wrong code generated when, in a pou, a located variable has the same name than a function block instance input variable
laurent
parents:
399
diff
changeset

195 
} 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

196 
else { 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

197 
unsigned int vartype = search_var_instance_decl>get_vartype(fb_symbol); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

198 
if (vartype == search_var_instance_decl_c::external_vt) 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

199 
s4o.print(SET_EXTERNAL_FB); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

200 
else 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

201 
s4o.print(SET_VAR); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

202 
} 
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
387
diff
changeset

203 
s4o.print("("); 
887
a5e2eedeef53
A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents:
885
diff
changeset

204 

226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

205 
if (fb_symbol != NULL) { 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

206 
print_variable_prefix(); 
888
4893e6b11b25
Remove call to type_is_complex() in ST code generation.
mjsousa
parents:
887
diff
changeset

207 
// It is my (MJS) conviction that by this time the following will always be true... 
4893e6b11b25
Remove call to type_is_complex() in ST code generation.
mjsousa
parents:
887
diff
changeset

208 
// wanted_variablegeneration == expression_vg; 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

209 
fb_symbol>accept(*this); 
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
387
diff
changeset

210 
s4o.print(".,"); 
888
4893e6b11b25
Remove call to type_is_complex() in ST code generation.
mjsousa
parents:
887
diff
changeset

211 
symbol>accept(*this); 
4893e6b11b25
Remove call to type_is_complex() in ST code generation.
mjsousa
parents:
887
diff
changeset

212 
s4o.print(","); 
4893e6b11b25
Remove call to type_is_complex() in ST code generation.
mjsousa
parents:
887
diff
changeset

213 
s4o.print(","); 
897  214 
} else { 
887
a5e2eedeef53
A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents:
885
diff
changeset

215 
print_variable_prefix(); 
a5e2eedeef53
A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents:
885
diff
changeset

216 
s4o.print(","); 
888
4893e6b11b25
Remove call to type_is_complex() in ST code generation.
mjsousa
parents:
887
diff
changeset

217 
wanted_variablegeneration = complextype_base_vg; 
4893e6b11b25
Remove call to type_is_complex() in ST code generation.
mjsousa
parents:
887
diff
changeset

218 
symbol>accept(*this); 
4893e6b11b25
Remove call to type_is_complex() in ST code generation.
mjsousa
parents:
887
diff
changeset

219 
s4o.print(","); 
885
b2604fc6d25c
Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents:
877
diff
changeset

220 
wanted_variablegeneration = complextype_suffix_vg; 
b2604fc6d25c
Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents:
877
diff
changeset

221 
symbol>accept(*this); 
888
4893e6b11b25
Remove call to type_is_complex() in ST code generation.
mjsousa
parents:
887
diff
changeset

222 
s4o.print(","); 
4893e6b11b25
Remove call to type_is_complex() in ST code generation.
mjsousa
parents:
887
diff
changeset

223 
} 
885
b2604fc6d25c
Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents:
877
diff
changeset

224 
wanted_variablegeneration = expression_vg; 
b2604fc6d25c
Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents:
877
diff
changeset

225 
print_check_function(type, value, fb_value); 
b2604fc6d25c
Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents:
877
diff
changeset

226 
s4o.print(")"); 
b2604fc6d25c
Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents:
877
diff
changeset

227 
wanted_variablegeneration = expression_vg; 
b2604fc6d25c
Change order of SET_xxx() macros. (this will allow me to simplify the print_setter() methods later on)
mjsousa
parents:
877
diff
changeset

228 
return NULL; 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

229 
} 
146
eef5e62048c7
Adding support for EN/ENO params in function and function blocks (standard function not supported yet)
lbessard
parents:
145
diff
changeset

230 

347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

231 
/********************************/ 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

232 
/* B 1.3.3  Derived data types */ 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

233 
/********************************/ 
377
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

234 

347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

235 
/* signed_integer DOTDOT signed_integer */ 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

236 
void *visit(subrange_c *symbol) { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

237 
switch (wanted_casegeneration) { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

238 
case subrange_cg: 
376  239 
s4o.print("__case_expression >= "); 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

240 
symbol>lower_limit>accept(*this); 
376  241 
s4o.print(" && __case_expression <= "); 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

242 
symbol>upper_limit>accept(*this); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

243 
break; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

244 
default: 
377
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

245 
symbol>lower_limit>accept(*this); 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

246 
break; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

247 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

248 
return NULL; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

249 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

250 

377
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

251 
/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */ 
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

252 
void *visit(array_specification_c *symbol) { 
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

253 
symbol>non_generic_type_name>accept(*this); 
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

254 
return NULL; 
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

255 
} 
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

256 

800
2481fffe6e58
Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents:
793
diff
changeset

257 
/* enumerated_type_name ':' enumerated_spec_init */ 
2481fffe6e58
Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents:
793
diff
changeset

258 
void *visit(enumerated_type_declaration_c *symbol) { 
2481fffe6e58
Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents:
793
diff
changeset

259 
symbol>enumerated_type_name>accept(*this); 
2481fffe6e58
Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents:
793
diff
changeset

260 
return NULL; 
2481fffe6e58
Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents:
793
diff
changeset

261 
} 
2481fffe6e58
Fixed bug in case statement with enumerated type variable as case expression
Laurent Bessard
parents:
793
diff
changeset

262 

70  263 
/*********************/ 
264 
/* B 1.4  Variables */ 

265 
/*********************/ 

266 
void *visit(symbolic_variable_c *symbol) { 

382
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

267 
switch (wanted_variablegeneration) { 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

268 
case complextype_base_vg: 
887
a5e2eedeef53
A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents:
885
diff
changeset

269 
symbol>var_name>accept(*this); //generate_c_base_c::visit(symbol); 
382
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

270 
break; 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

271 
case complextype_suffix_vg: 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

272 
break; 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

273 
default: 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

274 
if (this>is_variable_prefix_null()) { 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

275 
if (wanted_variablegeneration == fparam_output_vg) { 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

276 
s4o.print("&("); 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

277 
generate_c_base_c::visit(symbol); 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

278 
s4o.print(")"); 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

279 
} 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

280 
else { 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

281 
generate_c_base_c::visit(symbol); 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

282 
} 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

283 
} 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

284 
else 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

285 
print_getter(symbol); 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

286 
break; 
ac6dfec701c9
Fix bug in parser while trying to use IL operator like S1, R1, etc... as standard function block interface variable in structured_variable syntax and bug in code generator while generating code for assignment of function block interface variable using structured_variable syntax
laurent
parents:
377
diff
changeset

287 
} 
70  288 
return NULL; 
289 
} 

290 

291 
/********************************************/ 

292 
/* B.1.4.1 Directly Represented Variables */ 

293 
/********************************************/ 

294 
// direct_variable: direct_variable_token {$$ = new direct_variable_c($1);}; 

295 
void *visit(direct_variable_c *symbol) { 

296 
TRACE("direct_variable_c"); 

297 
/* Do not use print_token() as it will change everything into uppercase */ 

298 
if (strlen(symbol>value) == 0) ERROR; 

217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

299 
if (this>is_variable_prefix_null()) { 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

300 
if (wanted_variablegeneration != fparam_output_vg) 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

301 
s4o.print("*("); 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

302 
} 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

303 
else { 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

304 
switch (wanted_variablegeneration) { 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

305 
case expression_vg: 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

306 
s4o.print(GET_LOCATED); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

307 
s4o.print("("); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

308 
break; 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

309 
case fparam_output_vg: 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

310 
s4o.print(GET_LOCATED_BY_REF); 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

311 
s4o.print("("); 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

312 
break; 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

313 
default: 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

314 
break; 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

315 
} 
145  316 
} 
70  317 
this>print_variable_prefix(); 
318 
s4o.printlocation(symbol>value + 1); 

887
a5e2eedeef53
A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents:
885
diff
changeset

319 
if (( this>is_variable_prefix_null() && (wanted_variablegeneration != fparam_output_vg))  
a5e2eedeef53
A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents:
885
diff
changeset

320 
(!this>is_variable_prefix_null() && (wanted_variablegeneration == expression_vg ))  
a5e2eedeef53
A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents:
885
diff
changeset

321 
(!this>is_variable_prefix_null() && (wanted_variablegeneration == fparam_output_vg))) 
145  322 
s4o.print(")"); 
70  323 
return NULL; 
324 
} 

325 

98  326 
/*************************************/ 
327 
/* B.1.4.2 Multielement Variables */ 

328 
/*************************************/ 

329 

221
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
220
diff
changeset

330 
// SYM_REF2(structured_variable_c, record_variable, field_selector) 
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
220
diff
changeset

331 
void *visit(structured_variable_c *symbol) { 
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
220
diff
changeset

332 
TRACE("structured_variable_c"); 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

333 
switch (wanted_variablegeneration) { 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

334 
case complextype_base_vg: 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

335 
symbol>record_variable>accept(*this); 
897  336 
/* NOTE: The following test includes a special case for SFC Steps. They are currently mapped onto a C data structure 
337 
* that does not follow the standard IEC_<typename> pattern used for user defined structure datatypes 

338 
* (i.e. it does not include the 'values' and 'flag' structure 

339 
* elements that are tested by __GET_VAR and __SET_VAR acessor macros defined in acessor.h). However, the 

340 
* STEP.T and STEP.X elements of this step structure are of the IEC_BOOL and IEC_TIME datatypes, and are 

341 
* actually structures that do have the 'value' and 'flags' elements. So, it is safe to say that any variable 

342 
* that is a STEPname is not of a complex type, as its .T and .X elements are and can later be safely accessed 

343 
* using the __SET_VAR and __GET_VAR macros. 

344 
* 

345 
* For the above reason, a STEP must be handled as a FB, i.e. it does NOT contain the 'flags' and 'value' elements! 

346 
*/ 

347 
if ( get_datatype_info_c::is_function_block(symbol>record_variable>datatype) 

348 
 get_datatype_info_c::is_sfc_step (symbol>record_variable>datatype)) { 

889
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
888
diff
changeset

349 
if (NULL == symbol>record_variable>scope) ERROR; 
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
888
diff
changeset

350 
search_var_instance_decl_c search_var_instance_decl(symbol>record_variable>scope); 
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
888
diff
changeset

351 
if (search_var_instance_decl_c::external_vt == search_var_instance_decl.get_vartype(get_var_name_c::get_last_field(symbol>record_variable))) 
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
888
diff
changeset

352 
s4o.print(">"); 
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
888
diff
changeset

353 
else 
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
888
diff
changeset

354 
s4o.print("."); 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

355 
symbol>field_selector>accept(*this); 
410
c6486bd97392
Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents:
406
diff
changeset

356 
} 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

357 
break; 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

358 
case complextype_suffix_vg: 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

359 
symbol>record_variable>accept(*this); 
897  360 
// the following condition MUST be a negation of the above condition used in the 'case complextype_base_vg:' 
361 
if (!( get_datatype_info_c::is_function_block(symbol>record_variable>datatype) // if the record variable is not a FB... 

362 
 get_datatype_info_c::is_sfc_step (symbol>record_variable>datatype))) { // ...nor an SFC step name, then it will certainly be a structure! 

410
c6486bd97392
Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents:
406
diff
changeset

363 
s4o.print("."); 
c6486bd97392
Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents:
406
diff
changeset

364 
symbol>field_selector>accept(*this); 
c6486bd97392
Fix bug while using complex type variables in Function and FunctionBlock interface
Laurent Bessard
parents:
406
diff
changeset

365 
} 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

366 
break; 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

367 
default: 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

368 
if (this>is_variable_prefix_null()) { 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

369 
symbol>record_variable>accept(*this); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

370 
s4o.print("."); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

371 
symbol>field_selector>accept(*this); 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

372 
} 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

373 
else 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

374 
print_getter(symbol); 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

375 
break; 
221
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
220
diff
changeset

376 
} 
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
220
diff
changeset

377 
return NULL; 
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
220
diff
changeset

378 
} 
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
220
diff
changeset

379 

98  380 
/* subscripted_variable '[' subscript_list ']' */ 
381 
//SYM_REF2(array_variable_c, subscripted_variable, subscript_list) 

382 
void *visit(array_variable_c *symbol) { 

226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

383 
switch (wanted_variablegeneration) { 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

384 
case complextype_base_vg: 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

385 
symbol>subscripted_variable>accept(*this); 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

386 
break; 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

387 
case complextype_suffix_vg: 
238
0919986a5c98
Bug when trying to get type of elements in a big complex structure fixed
laurent
parents:
237
diff
changeset

388 
symbol>subscripted_variable>accept(*this); 
0919986a5c98
Bug when trying to get type of elements in a big complex structure fixed
laurent
parents:
237
diff
changeset

389 

417
d48f53715f77
Rewrite of stage3 code (done by Manuele and I), rewrite of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
392
diff
changeset

390 
current_array_type = search_varfb_instance_type>get_basetype_decl(symbol>subscripted_variable); 
238
0919986a5c98
Bug when trying to get type of elements in a big complex structure fixed
laurent
parents:
237
diff
changeset

391 
if (current_array_type == NULL) ERROR; 
0919986a5c98
Bug when trying to get type of elements in a big complex structure fixed
laurent
parents:
237
diff
changeset

392 

0919986a5c98
Bug when trying to get type of elements in a big complex structure fixed
laurent
parents:
237
diff
changeset

393 
s4o.print(".table"); 
298
022a874149ce
Fixing code generation of array indexes in Function Blocks.
Mario de Sousa <msousa@fe.up.pt>
parents:
283
diff
changeset

394 
wanted_variablegeneration = expression_vg; 
238
0919986a5c98
Bug when trying to get type of elements in a big complex structure fixed
laurent
parents:
237
diff
changeset

395 
symbol>subscript_list>accept(*this); 
298
022a874149ce
Fixing code generation of array indexes in Function Blocks.
Mario de Sousa <msousa@fe.up.pt>
parents:
283
diff
changeset

396 
wanted_variablegeneration = complextype_suffix_vg; 
238
0919986a5c98
Bug when trying to get type of elements in a big complex structure fixed
laurent
parents:
237
diff
changeset

397 

0919986a5c98
Bug when trying to get type of elements in a big complex structure fixed
laurent
parents:
237
diff
changeset

398 
current_array_type = NULL; 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

399 
break; 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

400 
default: 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

401 
if (this>is_variable_prefix_null()) { 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

402 
symbol>subscripted_variable>accept(*this); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

403 

31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

404 
current_array_type = search_varfb_instance_type>get_basetype_decl(symbol>subscripted_variable); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

405 
if (current_array_type == NULL) ERROR; 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

406 

31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

407 
s4o.print(".table"); 
238
0919986a5c98
Bug when trying to get type of elements in a big complex structure fixed
laurent
parents:
237
diff
changeset

408 
symbol>subscript_list>accept(*this); 
0919986a5c98
Bug when trying to get type of elements in a big complex structure fixed
laurent
parents:
237
diff
changeset

409 

0919986a5c98
Bug when trying to get type of elements in a big complex structure fixed
laurent
parents:
237
diff
changeset

410 
current_array_type = NULL; 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

411 
} 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

412 
else 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

413 
print_getter(symbol); 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

414 
break; 
98  415 
} 
416 
return NULL; 

417 
} 

418 

419 
/* subscript_list ',' subscript */ 

420 
void *visit(subscript_list_c *symbol) { 

377
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

421 
array_dimension_iterator_c* array_dimension_iterator = new array_dimension_iterator_c(current_array_type); 
98  422 
for (int i = 0; i < symbol>n; i++) { 
377
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

423 
symbol_c* dimension = array_dimension_iterator>next(); 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

424 
if (dimension == NULL) ERROR; 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

425 

31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

426 
s4o.print("[("); 
98  427 
symbol>elements[i]>accept(*this); 
377
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

428 
s4o.print(")  ("); 
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

429 
dimension>accept(*this); 
98  430 
s4o.print(")]"); 
431 
} 

377
60b012b7793f
Adding support for compiling direct array specification inside variable declaration
laurent
parents:
376
diff
changeset

432 
delete array_dimension_iterator; 
98  433 
return NULL; 
434 
} 

435 

235  436 
/******************************************/ 
437 
/* B 1.4.3  Declaration & Initialisation */ 

438 
/******************************************/ 

237  439 

440 
/* helper symbol for structure_initialization */ 

441 
/* structure_element_initialization_list ',' structure_element_initialization */ 

235  442 
void *visit(structure_element_initialization_list_c *symbol) { 
443 
generate_c_structure_initialization_c *structure_initialization = new generate_c_structure_initialization_c(&s4o); 

444 
structure_initialization>init_structure_default(this>current_param_type); 

237  445 
structure_initialization>init_structure_values(symbol); 
235  446 
delete structure_initialization; 
447 
return NULL; 

448 
} 

98  449 

237  450 
/* helper symbol for array_initialization */ 
451 
/* array_initial_elements_list ',' array_initial_elements */ 

452 
void *visit(array_initial_elements_list_c *symbol) { 

453 
generate_c_array_initialization_c *array_initialization = new generate_c_array_initialization_c(&s4o); 

454 
array_initialization>init_array_size(this>current_param_type); 

455 
array_initialization>init_array_values(symbol); 

456 
delete array_initialization; 

457 
return NULL; 

458 
} 

459 

70  460 
/***************************************/ 
461 
/* B.3  Language ST (Structured Text) */ 

462 
/***************************************/ 

463 
/***********************/ 

464 
/* B 3.1  Expressions */ 

465 
/***********************/ 

873
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

466 
void *visit(ref_expression_c *symbol) { 
909
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
897
diff
changeset

467 
s4o.print("("); 
8b2a31dea131
Add support for REF_TO derived datatypes (along with datatype verification)
mjsousa
parents:
897
diff
changeset

468 
s4o.print("(IEC_UDINT)"); 
873
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

469 
if (this>is_variable_prefix_null()) { 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

470 
/* For code in FUNCTIONs */ 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

471 
s4o.print("&("); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

472 
symbol>exp>accept(*this); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

473 
s4o.print(")"); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

474 
} else { 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

475 
/* For code in FBs, and PROGRAMS... */ 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

476 
s4o.print("("); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

477 
unsigned int vartype = analyse_variable_c::first_nonfb_vardecltype(symbol>exp, scope_); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

478 
if (vartype == search_var_instance_decl_c::external_vt) { 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

479 
if (!get_datatype_info_c::is_type_valid (symbol>exp>datatype)) ERROR; 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

480 
if ( get_datatype_info_c::is_function_block(symbol>exp>datatype)) 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

481 
s4o.print(GET_EXTERNAL_FB_REF); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

482 
else 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

483 
s4o.print(GET_EXTERNAL_REF); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

484 
} 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

485 
else if (vartype == search_var_instance_decl_c::located_vt) 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

486 
s4o.print(GET_LOCATED_REF); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

487 
else 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

488 
s4o.print(GET_VAR_REF); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

489 

dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

490 
variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration; 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

491 
s4o.print("("); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

492 
wanted_variablegeneration = complextype_base_vg; 
887
a5e2eedeef53
A little code cleanup (reduce number of possible variable generation states)
mjsousa
parents:
885
diff
changeset

493 
print_variable_prefix(); 
873
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

494 
symbol>exp>accept(*this); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

495 
s4o.print(","); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

496 
wanted_variablegeneration = complextype_suffix_vg; 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

497 
symbol>exp>accept(*this); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

498 
s4o.print(")"); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

499 
wanted_variablegeneration = old_wanted_variablegeneration; 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

500 

dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

501 
s4o.print(")"); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

502 
} 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

503 
s4o.print(")"); 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

504 

dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

505 
return NULL; 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

506 
} 
dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

507 

dea39ef02847
Add limited support for the REF() operator (defined in v3 of IEC 611313)
mjsousa
parents:
864
diff
changeset

508 

70  509 
void *visit(or_expression_c *symbol) { 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

510 
if (get_datatype_info_c::is_BOOL_compatible(symbol>datatype)) 
70  511 
return print_binary_expression(symbol>l_exp, symbol>r_exp, "  "); 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

512 
if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol>datatype)) 
70  513 
return print_binary_expression(symbol>l_exp, symbol>r_exp, "  "); 
514 
ERROR; 

515 
return NULL; 

516 
} 

517 

518 
void *visit(xor_expression_c *symbol) { 

668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

519 
if (get_datatype_info_c::is_BOOL_compatible(symbol>datatype)) { 
70  520 
s4o.print("("); 
521 
symbol>l_exp>accept(*this); 

522 
s4o.print(" && !"); 

523 
symbol>r_exp>accept(*this); 

524 
s4o.print(")  (!"); 

525 
symbol>l_exp>accept(*this); 

526 
s4o.print(" && "); 

527 
symbol>r_exp>accept(*this); 

528 
s4o.print(")"); 

130  529 
return NULL; 
70  530 
} 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

531 
if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol>datatype)) 
70  532 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " ^ "); 
533 
ERROR; 

534 
return NULL; 

535 
} 

536 

537 
void *visit(and_expression_c *symbol) { 

668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

538 
if (get_datatype_info_c::is_BOOL_compatible(symbol>datatype)) 
70  539 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " && "); 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

540 
if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol>datatype)) 
70  541 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " & "); 
542 
ERROR; 

668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

543 
return NULL; 
70  544 
} 
545 

546 
void *visit(equ_expression_c *symbol) { 

694
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

547 
if (get_datatype_info_c::is_TIME_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

548 
get_datatype_info_c::is_ANY_DATE_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

549 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

550 
return print_compare_function("EQ_", symbol>l_exp>datatype, symbol>l_exp, symbol>r_exp); 
70  551 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " == "); 
552 
} 

553 

554 
void *visit(notequ_expression_c *symbol) { 

694
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

555 
if (get_datatype_info_c::is_TIME_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

556 
get_datatype_info_c::is_ANY_DATE_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

557 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

558 
return print_compare_function("NE_", symbol>l_exp>datatype, symbol>l_exp, symbol>r_exp); 
70  559 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " != "); 
560 
} 

561 

562 
void *visit(lt_expression_c *symbol) { 

694
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

563 
if (get_datatype_info_c::is_TIME_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

564 
get_datatype_info_c::is_ANY_DATE_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

565 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

566 
return print_compare_function("LT_", symbol>l_exp>datatype, symbol>l_exp, symbol>r_exp); 
653
ea78924a1f60
Deleting datatype checks no longer needed (with a view of making search_expression_type_c redundant).
Mario de Sousa <msousa@fe.up.pt>
parents:
594
diff
changeset

567 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " < "); 
70  568 
} 
569 

570 
void *visit(gt_expression_c *symbol) { 

694
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

571 
if (get_datatype_info_c::is_TIME_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

572 
get_datatype_info_c::is_ANY_DATE_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

573 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

574 
return print_compare_function("GT_", symbol>l_exp>datatype, symbol>l_exp, symbol>r_exp); 
653
ea78924a1f60
Deleting datatype checks no longer needed (with a view of making search_expression_type_c redundant).
Mario de Sousa <msousa@fe.up.pt>
parents:
594
diff
changeset

575 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " > "); 
70  576 
} 
577 

578 
void *visit(le_expression_c *symbol) { 

694
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

579 
if (get_datatype_info_c::is_TIME_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

580 
get_datatype_info_c::is_ANY_DATE_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

581 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

582 
return print_compare_function("LE_", symbol>l_exp>datatype, symbol>l_exp, symbol>r_exp); 
653
ea78924a1f60
Deleting datatype checks no longer needed (with a view of making search_expression_type_c redundant).
Mario de Sousa <msousa@fe.up.pt>
parents:
594
diff
changeset

583 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " <= "); 
70  584 
} 
585 

586 
void *visit(ge_expression_c *symbol) { 

694
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

587 
if (get_datatype_info_c::is_TIME_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

588 
get_datatype_info_c::is_ANY_DATE_compatible (symbol>l_exp>datatype)  
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

589 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
a010763dd4cb
Fix stage4 for compare expressions.
Manuele Conti <conti.ma@alice.it>
parents:
693
diff
changeset

590 
return print_compare_function("GE_", symbol>l_exp>datatype, symbol>l_exp, symbol>r_exp); 
653
ea78924a1f60
Deleting datatype checks no longer needed (with a view of making search_expression_type_c redundant).
Mario de Sousa <msousa@fe.up.pt>
parents:
594
diff
changeset

591 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " >= "); 
70  592 
} 
593 

594 
void *visit(add_expression_c *symbol) { 

668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

595 
/* 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

596 
symbol_c *left_type = symbol>l_exp>datatype; 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

597 
symbol_c *right_type = symbol>r_exp>datatype; 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

598 
if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c))  
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

599 
(typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c))  
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

600 
(typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c))) 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

601 
return print_binary_function("__time_add", symbol>l_exp, symbol>r_exp); 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

602 
*/ 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

603 
if (get_datatype_info_c::is_TIME_compatible (symbol>datatype)  
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

604 
get_datatype_info_c::is_ANY_DATE_compatible (symbol>datatype)) 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

605 
return print_binary_function("__time_add", symbol>l_exp, symbol>r_exp); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

606 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " + "); 
70  607 
} 
608 

609 
void *visit(sub_expression_c *symbol) { 

668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

610 
/* 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

611 
symbol_c *left_type = symbol>l_exp>datatype; 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

612 
symbol_c *right_type = symbol>r_exp>datatype; 
70  613 
if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c))  
614 
(typeid(*left_type) == typeid(date_type_name_c) && typeid(*right_type) == typeid(date_type_name_c))  

668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

615 
(typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c))  
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

616 
(typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(tod_type_name_c))  
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

617 
(typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c))  
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

618 
(typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(dt_type_name_c))) 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

619 
return print_binary_function("__time_sub", symbol>l_exp, symbol>r_exp); 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

620 
*/ 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

621 
if (get_datatype_info_c::is_TIME_compatible (symbol>datatype)  
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

622 
get_datatype_info_c::is_ANY_DATE_compatible (symbol>datatype)) 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

623 
return print_binary_function("__time_sub", symbol>l_exp, symbol>r_exp); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

624 
return print_binary_expression(symbol>l_exp, symbol>r_exp, "  "); 
70  625 
} 
626 

627 
void *visit(mul_expression_c *symbol) { 

668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

628 
/* 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

629 
symbol_c *left_type = symbol>l_exp>datatype; 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

630 
symbol_c *right_type = symbol>r_exp>datatype; 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

631 
if ((typeid(*left_type) == typeid(time_type_name_c) && get_datatype_info_c::is_ANY_INT_compatible (right_type))  
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

632 
(typeid(*left_type) == typeid(time_type_name_c) && get_datatype_info_c::is_ANY_REAL_compatible(right_type))) 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

633 
return print_binary_function("__time_mul", symbol>l_exp, symbol>r_exp); 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

634 
*/ 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

635 
if (get_datatype_info_c::is_TIME_compatible (symbol>datatype)) 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

636 
return print_binary_function("__time_mul", symbol>l_exp, symbol>r_exp); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

637 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " * "); 
70  638 
} 
639 

640 
void *visit(div_expression_c *symbol) { 

668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

641 
/* 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

642 
symbol_c *left_type = symbol>l_exp>datatype; 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

643 
symbol_c *right_type = symbol>r_exp>datatype; 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

644 
if ((typeid(*left_type) == typeid(time_type_name_c) && get_datatype_info_c::is_ANY_INT_compatible (right_type))  
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

645 
(typeid(*left_type) == typeid(time_type_name_c) && get_datatype_info_c::is_ANY_REAL_compatible(right_type))) 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

646 
return print_binary_function("__time_div", symbol>l_exp, symbol>r_exp); 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

647 
*/ 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

648 
if (get_datatype_info_c::is_TIME_compatible (symbol>datatype)) 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

649 
return print_binary_function("__time_div", symbol>l_exp, symbol>r_exp); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

650 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " / "); 
70  651 
} 
652 

653 
void *visit(mod_expression_c *symbol) { 

668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

654 
s4o.print("(("); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

655 
symbol>r_exp>accept(*this); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

656 
s4o.print(" == 0)?0:"); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

657 
print_binary_expression(symbol>l_exp, symbol>r_exp, " % "); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

658 
s4o.print(")"); 
70  659 
return NULL; 
660 
} 

661 

257  662 
void *visit(power_expression_c *symbol) { 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

663 
s4o.print("EXPT__LREAL__LREAL__LREAL((BOOL)__BOOL_LITERAL(TRUE),\n"); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

664 
s4o.indent_right(); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

665 
s4o.print(s4o.indent_spaces + "NULL,\n"); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

666 
s4o.print(s4o.indent_spaces + "(LREAL)("); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

667 
symbol>l_exp>accept(*this); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

668 
s4o.print("),\n"); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

669 
s4o.print(s4o.indent_spaces + "(LREAL)("); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

670 
symbol>r_exp>accept(*this); 
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

671 
s4o.print("))"); 
358
a2c4af8f0c18
Add support for '**' (power) operator in ST expressions
Mario de Sousa <msousa@fe.up.pt>
parents:
355
diff
changeset

672 
return NULL; 
257  673 
} 
674 

123  675 
void *visit(neg_expression_c *symbol) { 
257  676 
return print_unary_expression(symbol>exp, " "); 
123  677 
} 
70  678 

679 
void *visit(not_expression_c *symbol) { 

668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

680 
return print_unary_expression(symbol>exp, get_datatype_info_c::is_BOOL_compatible(symbol>datatype)?"!":"~"); 
70  681 
} 
682 

683 
void *visit(function_invocation_c *symbol) { 

149  684 
symbol_c* function_name = NULL; 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

685 
DECLARE_PARAM_LIST() 
202
da1a8186f86f
Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents:
169
diff
changeset

686 

da1a8186f86f
Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents:
169
diff
changeset

687 
symbol_c *parameter_assignment_list = NULL; 
da1a8186f86f
Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents:
169
diff
changeset

688 
if (NULL != symbol> formal_param_list) parameter_assignment_list = symbol> formal_param_list; 
da1a8186f86f
Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents:
169
diff
changeset

689 
if (NULL != symbol>nonformal_param_list) parameter_assignment_list = symbol>nonformal_param_list; 
da1a8186f86f
Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents:
169
diff
changeset

690 
if (NULL == parameter_assignment_list) ERROR; 
da1a8186f86f
Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents:
169
diff
changeset

691 

233
3d23a68183d3
Bug on standard functions called with literals fixed
laurent
parents:
231
diff
changeset

692 
function_call_param_iterator_c function_call_param_iterator(symbol); 
3d23a68183d3
Bug on standard functions called with literals fixed
laurent
parents:
231
diff
changeset

693 

350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

694 
function_declaration_c *f_decl = (function_declaration_c *)symbol>called_function_declaration; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

695 
if (f_decl == NULL) ERROR; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

696 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

697 
function_name = symbol>function_name; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

698 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

699 
/* loop through each function parameter, find the value we should pass 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

700 
* to it, and then output the c equivalent... 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

701 
*/ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

702 
function_param_iterator_c fp_iterator(f_decl); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

703 
identifier_c *param_name; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

704 
/* flag to cirreclty handle calls to extensible standard functions (i.e. functions with variable number of input parameters) */ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

705 
bool found_first_extensible_parameter = false; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

706 
for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

707 
if (fp_iterator.is_extensible_param() && (!found_first_extensible_parameter)) { 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

708 
/* We are calling an extensible function. Before passing the extensible 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

709 
* parameters, we must add a dummy paramater value to tell the called 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

710 
* function how many extensible parameters we will be passing. 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

711 
* 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

712 
* Note that stage 3 has already determined the number of extensible 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

713 
* paramters, and stored that info in the abstract syntax tree. We simply 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

714 
* reuse that value. 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

715 
*/ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

716 
/* NOTE: we are not freeing the malloc'd memory. This is not really a bug. 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

717 
* Since we are writing a compiler, which runs to termination quickly, 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

718 
* we can consider this as just memory required for the compilation process 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

719 
* that will be free'd when the program terminates. 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

720 
*/ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

721 
char *tmp = (char *)malloc(32); /* enough space for a call with 10^31 (larger than 2^64) input parameters! */ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

722 
if (tmp == NULL) ERROR; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

723 
int res = snprintf(tmp, 32, "%d", symbol>extensible_param_count); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

724 
if ((res >= 32)  (res < 0)) ERROR; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

725 
identifier_c *param_value = new identifier_c(tmp); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

726 
uint_type_name_c *param_type = new uint_type_name_c(); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

727 
identifier_c *param_name = new identifier_c(""); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

728 
ADD_PARAM_LIST(param_name, param_value, param_type, function_param_iterator_c::direction_in) 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

729 
found_first_extensible_parameter = true; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

730 
} 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

731 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

732 
if (fp_iterator.is_extensible_param()) { 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

733 
/* since we are handling an extensible parameter, we must add the index to the 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

734 
* parameter name so we can go looking for the value passed to the correct 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

735 
* extended parameter (e.g. IN1, IN2, IN3, IN4, ...) 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

736 
*/ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

737 
char *tmp = (char *)malloc(32); /* enough space for a call with 10^31 (larger than 2^64) input parameters! */ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

738 
int res = snprintf(tmp, 32, "%d", fp_iterator.extensible_param_index()); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

739 
if ((res >= 32)  (res < 0)) ERROR; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

740 
param_name = new identifier_c(strdup2(param_name>value, tmp)); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

741 
if (param_name>value == NULL) ERROR; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

742 
} 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

743 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

744 
symbol_c *param_type = fp_iterator.param_type(); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

745 
if (param_type == NULL) ERROR; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

746 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

747 
function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

748 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

749 
symbol_c *param_value = NULL; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

750 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

751 
/* Get the value from a foo(<param_name> = <param_value>) style call */ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

752 
if (param_value == NULL) 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

753 
param_value = function_call_param_iterator.search_f(param_name); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

754 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

755 
/* Get the value from a foo(<param_value>) style call */ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

756 
if ((param_value == NULL) && !fp_iterator.is_en_eno_param_implicit()) { 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

757 
param_value = function_call_param_iterator.next_nf(); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

758 
} 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

759 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

760 
/* if no more parameter values in function call, and the current parameter 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

761 
* of the function declaration is an extensible parameter, we 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

762 
* have reached the end, and should simply jump out of the for loop. 
70  763 
*/ 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

764 
if ((param_value == NULL) && (fp_iterator.is_extensible_param())) { 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

765 
break; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

766 
} 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

767 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

768 
if ((param_value == NULL) && (param_direction == function_param_iterator_c::direction_in)) { 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

769 
/* No value given for parameter, so we must use the default... */ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

770 
/* First check whether default value specified in function declaration...*/ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

771 
param_value = fp_iterator.default_value(); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

772 
} 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

773 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

774 
ADD_PARAM_LIST(param_name, param_value, param_type, param_direction) 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

775 
} /* for(...) */ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

776 
// symbol>parameter_assignment>accept(*this); 
149  777 

233
3d23a68183d3
Bug on standard functions called with literals fixed
laurent
parents:
231
diff
changeset

778 
if (function_call_param_iterator.next_nf() != NULL) ERROR; 
3d23a68183d3
Bug on standard functions called with literals fixed
laurent
parents:
231
diff
changeset

779 

217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

780 
bool has_output_params = false; 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

781 

f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

782 
if (!this>is_variable_prefix_null()) { 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

783 
PARAM_LIST_ITERATOR() { 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

784 
if ((PARAM_DIRECTION == function_param_iterator_c::direction_out  
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

785 
PARAM_DIRECTION == function_param_iterator_c::direction_inout) && 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

786 
PARAM_VALUE != NULL) { 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

787 
has_output_params = true; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

788 
} 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

789 
} 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

790 
} 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

791 

2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

792 
/* Check whether we are calling an overloaded function! */ 
721
5dc33058e041
Fix counting bug in dsymbtable_c
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset

793 
/* (fdecl_mutiplicity > 1) => calling overloaded function */ 
5dc33058e041
Fix counting bug in dsymbtable_c
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset

794 
int fdecl_mutiplicity = function_symtable.count(symbol>function_name); 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

795 
if (fdecl_mutiplicity == 0) ERROR; 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

796 

f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

797 
if (has_output_params) { 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

798 
fcall_number++; 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

799 
s4o.print("__"); 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

800 
fbname>accept(*this); 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

801 
s4o.print("_"); 
149  802 
function_name>accept(*this); 
721
5dc33058e041
Fix counting bug in dsymbtable_c
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset

803 
if (fdecl_mutiplicity > 1) { 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

804 
/* function being called is overloaded! */ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

805 
s4o.print("__"); 
406
6381589697ff
Fix bug with overloaded function due to literal input values
laurent
parents:
405
diff
changeset

806 
print_function_parameter_data_types_c overloaded_func_suf(&s4o); 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

807 
f_decl>accept(overloaded_func_suf); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

808 
} 
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
531
diff
changeset

809 
s4o.print(fcall_number); 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

810 
} 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

811 
else { 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

812 
function_name>accept(*this); 
721
5dc33058e041
Fix counting bug in dsymbtable_c
Mario de Sousa <msousa@fe.up.pt>
parents:
718
diff
changeset

813 
if (fdecl_mutiplicity > 1) { 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

814 
/* function being called is overloaded! */ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

815 
s4o.print("__"); 
406
6381589697ff
Fix bug with overloaded function due to literal input values
laurent
parents:
405
diff
changeset

816 
print_function_parameter_data_types_c overloaded_func_suf(&s4o); 
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

817 
f_decl>accept(overloaded_func_suf); 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

818 
} 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

819 
} 
149  820 
s4o.print("("); 
821 
s4o.indent_right(); 

822 

217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

823 
int nb_param = 0; 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

824 
PARAM_LIST_ITERATOR() { 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

825 
symbol_c *param_value = PARAM_VALUE; 
235  826 
current_param_type = PARAM_TYPE; 
149  827 

217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

828 
switch (PARAM_DIRECTION) { 
149  829 
case function_param_iterator_c::direction_in: 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

830 
if (nb_param > 0) 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

831 
s4o.print(",\n"+s4o.indent_spaces); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

832 
if (param_value == NULL) { 
149  833 
/* If not, get the default value of this variable's type */ 
762  834 
param_value = type_initial_value_c::get(current_param_type); 
149  835 
} 
836 
if (param_value == NULL) ERROR; 

216
136d6ae70745
Bug with using non explicit literals as standard library functions input parameters fixed
laurent
parents:
208
diff
changeset

837 
s4o.print("("); 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

838 
if (get_datatype_info_c::is_ANY_INT_literal(current_param_type)) 
693
51a2fa6441b9
Prepare to delete search_constant_type_c > Move the static variables from search_constant_type_c to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
668
diff
changeset

839 
get_datatype_info_c::lint_type_name.accept(*this); 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

840 
else if (get_datatype_info_c::is_ANY_REAL_literal(current_param_type)) 
693
51a2fa6441b9
Prepare to delete search_constant_type_c > Move the static variables from search_constant_type_c to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
668
diff
changeset

841 
get_datatype_info_c::lreal_type_name.accept(*this); 
216
136d6ae70745
Bug with using non explicit literals as standard library functions input parameters fixed
laurent
parents:
208
diff
changeset

842 
else 
235  843 
current_param_type>accept(*this); 
216
136d6ae70745
Bug with using non explicit literals as standard library functions input parameters fixed
laurent
parents:
208
diff
changeset

844 
s4o.print(")"); 
235  845 
print_check_function(current_param_type, param_value); 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

846 
nb_param++; 
149  847 
break; 
848 
case function_param_iterator_c::direction_out: 

849 
case function_param_iterator_c::direction_inout: 

706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

850 
if (!has_output_params) { 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

851 
if (nb_param > 0) 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

852 
s4o.print(",\n"+s4o.indent_spaces); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

853 
if (param_value == NULL) 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

854 
s4o.print("NULL"); 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

855 
else { 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

856 
wanted_variablegeneration = fparam_output_vg; 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

857 
param_value>accept(*this); 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

858 
wanted_variablegeneration = expression_vg; 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

859 
} 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

860 
nb_param++; 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

861 
} 
149  862 
break; 
863 
case function_param_iterator_c::direction_extref: 

864 
/* TODO! */ 

865 
ERROR; 

866 
break; 

867 
} /* switch */ 

217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

868 
} 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

869 
if (has_output_params) { 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

870 
if (nb_param > 0) 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

871 
s4o.print(",\n"+s4o.indent_spaces); 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

872 
s4o.print(FB_FUNCTION_PARAM); 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

873 
} 
149  874 
s4o.print(")"); 
875 
s4o.indent_left(); 

70  876 

217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

877 
CLEAR_PARAM_LIST() 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

878 

70  879 
return NULL; 
880 
} 

881 

882 
/********************/ 

883 
/* B 3.2 Statements */ 

884 
/********************/ 

885 
void *visit(statement_list_c *symbol) { 

877  886 
for(int i = 0; i < symbol>n; i++) { 
887 
print_line_directive(symbol>elements[i]); 

888 
s4o.print(s4o.indent_spaces); 

889 
symbol>elements[i]>accept(*this); 

890 
s4o.print(";\n"); 

891 
} 

892 
return NULL; 

70  893 
} 
894 

895 
/*********************************/ 

896 
/* B 3.2.1 Assignment Statements */ 

897 
/*********************************/ 

898 
void *visit(assignment_statement_c *symbol) { 

321
a96399ab57c2
Add better comments, and change name of functions to clarify what they do.
Mario de Sousa <msousa@fe.up.pt>
parents:
309
diff
changeset

899 
symbol_c *left_type = search_varfb_instance_type>get_type_id(symbol>l_exp); 
98  900 

226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

901 
if (this>is_variable_prefix_null()) { 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

902 
symbol>l_exp>accept(*this); 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

903 
s4o.print(" = "); 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

904 
print_check_function(left_type, symbol>r_exp); 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

905 
} 
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

906 
else { 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

907 
print_setter(symbol>l_exp, left_type, symbol>r_exp); 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

908 
} 
70  909 
return NULL; 
910 
} 

911 

912 
/*****************************************/ 

913 
/* B 3.2.2 Subprogram Control Statements */ 

914 
/*****************************************/ 

915 

283
214d3fdee596
fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents:
282
diff
changeset

916 
void *visit(return_statement_c *symbol) { 
214d3fdee596
fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents:
282
diff
changeset

917 
s4o.print("goto "); s4o.print(END_LABEL); 
214d3fdee596
fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents:
282
diff
changeset

918 
return NULL; 
214d3fdee596
fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents:
282
diff
changeset

919 
} 
214d3fdee596
fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents:
282
diff
changeset

920 

214d3fdee596
fixing C code generation of return_statement_c and exit_statement_c
Mario de Sousa <msousa@fe.up.pt>
parents:
282
diff
changeset

921 

70  922 
/* fb_name '(' [param_assignment_list] ')' */ 
855
a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

923 
/* formal_param_list > may be NULL ! */ 
a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

924 
/* nonformal_param_list > may be NULL ! */ 
a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

925 
/* NOTE: The parameter 'called_fb_declaration'is used to pass data between stage 3 and stage4 (although currently it is not used in stage 4 */ 
a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

926 
// SYM_REF3(fb_invocation_c, fb_name, formal_param_list, nonformal_param_list, symbol_c *called_fb_declaration;) 
70  927 
void *visit(fb_invocation_c *symbol) { 
928 
TRACE("fb_invocation_c"); 

855
a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

929 

a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

930 
/* find the declaration of the function block type being called... */ 
a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

931 
symbol_c *fb_decl = symbol>called_fb_declaration; 
a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

932 
if (fb_decl == NULL) ERROR; 
a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

933 
/* figure out the name of the function block type of the function block being called... */ 
a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

934 
symbol_c *function_block_type_name = get_datatype_info_c::get_id(fb_decl); 
a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

935 
if (NULL == function_block_type_name) ERROR; 
a3109442e166
Start using the called_fb_declaration annotation when generating C code from FB calls in ST.
mjsousa
parents:
854
diff
changeset

936 

70  937 
/* loop through each function block parameter, find the value we should pass 
938 
* to it, and then output the c equivalent... 

939 
*/ 

940 
function_param_iterator_c fp_iterator(fb_decl); 

941 
identifier_c *param_name; 

942 
function_call_param_iterator_c function_call_param_iterator(symbol); 

943 
for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { 

944 
function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); 

160  945 

162
60a124678842
Fixed typo in EN/ENO parameters handling for std library functions
etisserant
parents:
160
diff
changeset

946 
/*fprintf(stderr, "param : %s\n", param_name>value);*/ 
160  947 

70  948 
/* Get the value from a foo(<param_name> = <param_value>) style call */ 
202
da1a8186f86f
Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents:
169
diff
changeset

949 
symbol_c *param_value = function_call_param_iterator.search_f(param_name); 
70  950 

951 
/* Get the value from a foo(<param_value>) style call */ 

350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

952 
/* When using the informal invocation style, user can not pass values to EN or ENO parameters if these 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

953 
* were implicitly defined! 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

954 
*/ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

955 
if ((param_value == NULL) && !fp_iterator.is_en_eno_param_implicit()) 
202
da1a8186f86f
Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents:
169
diff
changeset

956 
param_value = function_call_param_iterator.next_nf(); 
70  957 

98  958 
symbol_c *param_type = fp_iterator.param_type(); 
959 
if (param_type == NULL) ERROR; 

960 

70  961 
/* now output the value assignment */ 
962 
if (param_value != NULL) 

963 
if ((param_direction == function_param_iterator_c::direction_in)  

964 
(param_direction == function_param_iterator_c::direction_inout)) { 

226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

965 
if (this>is_variable_prefix_null()) { 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

966 
symbol>fb_name>accept(*this); 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

967 
s4o.print("."); 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

968 
param_name>accept(*this); 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

969 
s4o.print(" = "); 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

970 
print_check_function(param_type, param_value); 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

971 
} 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

972 
else { 
228
43831b683764
Adding support for setter and getter on complex datatype in IL
berem
parents:
226
diff
changeset

973 
print_setter(param_name, param_type, param_value, symbol>fb_name); 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

974 
} 
70  975 
s4o.print(";\n" + s4o.indent_spaces); 
976 
} 

977 
} /* for(...) */ 

978 

979 
/* now call the function... */ 

980 
function_block_type_name>accept(*this); 

981 
s4o.print(FB_FUNCTION_SUFFIX); 

706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

982 
s4o.print("("); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

983 
if (search_var_instance_decl>get_vartype(symbol>fb_name) != search_var_instance_decl_c::external_vt) 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

984 
s4o.print("&"); 
70  985 
print_variable_prefix(); 
986 
symbol>fb_name>accept(*this); 

987 
s4o.print(")"); 

988 

989 
/* loop through each function parameter, find the variable to which 

990 
* we should atribute the value of all output or inoutput parameters. 

991 
*/ 

992 
fp_iterator.reset(); 

993 
function_call_param_iterator.reset(); 

994 
for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { 

995 
function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); 

996 

997 
/* Get the value from a foo(<param_name> = <param_value>) style call */ 

202
da1a8186f86f
Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents:
169
diff
changeset

998 
symbol_c *param_value = function_call_param_iterator.search_f(param_name); 
70  999 

1000 
/* Get the value from a foo(<param_value>) style call */ 

350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

1001 
/* When using the informal invocation style, user can not pass values to EN or ENO parameters if these 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

1002 
* were implicitly defined! 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

1003 
*/ 
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
336
diff
changeset

1004 
if ((param_value == NULL) && !fp_iterator.is_en_eno_param_implicit()) 
202
da1a8186f86f
Initial (very rough) version of semantic checker (stage3)
Catarina Boucinha <ccb@fe.up.pt>
parents:
169
diff
changeset

1005 
param_value = function_call_param_iterator.next_nf(); 
70  1006 

1007 
/* now output the value assignment */ 

1008 
if (param_value != NULL) 

1009 
if ((param_direction == function_param_iterator_c::direction_out)  

1010 
(param_direction == function_param_iterator_c::direction_inout)) { 

321
a96399ab57c2
Add better comments, and change name of functions to clarify what they do.
Mario de Sousa <msousa@fe.up.pt>
parents:
309
diff
changeset

1011 
symbol_c *param_type = search_varfb_instance_type>get_type_id(param_value); 
240  1012 
s4o.print(";\n" + s4o.indent_spaces); 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

1013 
if (this>is_variable_prefix_null()) { 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

1014 
param_value>accept(*this); 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

1015 
s4o.print(" = "); 
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

1016 
print_check_function(param_type, param_name, symbol>fb_name); 
98  1017 
} 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

1018 
else { 
226
29f8ffc203c1
Adding support for setter and getter on complex datatype in ST
laurent
parents:
221
diff
changeset

1019 
print_setter(param_value, param_type, param_name, NULL, symbol>fb_name); 
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
216
diff
changeset

1020 
} 
70  1021 
} 
1022 
} /* for(...) */ 

1023 

1024 
return NULL; 

1025 
} 

1026 

1027 

1028 

1029 

1030 
/* helper symbol for fb_invocation */ 

1031 
/* param_assignment_list ',' param_assignment */ 

1032 
void *visit(param_assignment_list_c *symbol) { 

1033 
TRACE("param_assignment_list_c"); 

1034 
/* this should never be called... */ 

1035 
ERROR; 

1036 
return NULL; 

1037 
// return print_list(symbol, "", ", "); 

1038 
} 

1039 

1040 

1041 
void *visit(input_variable_param_assignment_c *symbol) { 

1042 
TRACE("input_variable_param_assignment_c"); 

1043 
/* this should never be called... */ 

1044 
ERROR; 

1045 
return NULL; 

1046 
/* 

1047 
symbol>variable_name>accept(*this); 

1048 
s4o.print(" = "); 

1049 
symbol>expression>accept(*this); 

1050 
return NULL; 

1051 
*/ 

1052 
} 

1053 

1054 
void *visit(output_variable_param_assignment_c *symbol) { 

1055 
TRACE("output_variable_param_assignment_c"); 

1056 
/* this should never be called... */ 

1057 
ERROR; 

1058 
return NULL; 

1059 
/* 

1060 
s4o.print(s4o.indent_spaces); 

1061 
if (symbol>not_param != NULL) 

1062 
symbol>not_param>accept(*this); 

1063 
symbol>variable_name>accept(*this); 

1064 
s4o.print(" => "); 

1065 
symbol>variable>accept(*this); 

1066 
return NULL; 

1067 
*/ 

1068 
} 

1069 

1070 
// TODO: the NOT symbol in function (block) calls... 

1071 
void *visit(not_paramassign_c *symbol) { 

1072 
TRACE("not_paramassign_c"); 

1073 
/* this should never be called... */ 

1074 
ERROR; 

1075 
return NULL; 

1076 
/* 

1077 
s4o.print("NOT "); 

1078 
return NULL; 

1079 
*/ 

1080 
} 

1081 

1082 

1083 
/********************************/ 

1084 
/* B 3.2.3 Selection Statements */ 

1085 
/********************************/ 

1086 
void *visit(if_statement_c *symbol) { 

1087 
s4o.print("if ("); 

1088 
symbol>expression>accept(*this); 

1089 
s4o.print(") {\n"); 

1090 
s4o.indent_right(); 

1091 
symbol>statement_list>accept(*this); 

1092 
s4o.indent_left(); 

1093 
symbol>elseif_statement_list>accept(*this); 

1094 

1095 
if (symbol>else_statement_list != NULL) { 

1096 
s4o.print(s4o.indent_spaces); s4o.print("} else {\n"); 

1097 
s4o.indent_right(); 

1098 
symbol>else_statement_list>accept(*this); 

1099 
s4o.indent_left(); 

1100 
} 

1101 
s4o.print(s4o.indent_spaces); s4o.print("}"); 

1102 
return NULL; 

1103 
} 

1104 

1105 
/* helper symbol for if_statement */ 

1106 
void *visit(elseif_statement_list_c *symbol) {return print_list(symbol);} 

1107 

1108 
/* helper symbol for elseif_statement_list */ 

1109 
void *visit(elseif_statement_c *symbol) { 

1110 
s4o.print(s4o.indent_spaces); s4o.print("} else if ("); 

1111 
symbol>expression>accept(*this); 

1112 
s4o.print(") {\n"); 

1113 
s4o.indent_right(); 

1114 
symbol>statement_list>accept(*this); 

1115 
s4o.indent_left(); 

1116 
return NULL; 

1117 
} 

1118 

1119 
void *visit(case_statement_c *symbol) { 

668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

1120 
symbol_c *expression_type = symbol>expression>datatype; 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1121 
s4o.print("{\n"); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1122 
s4o.indent_right(); 
376  1123 
s4o.print(s4o.indent_spaces); 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

1124 
if (get_datatype_info_c::is_ANY_INT_literal(expression_type)) 
693
51a2fa6441b9
Prepare to delete search_constant_type_c > Move the static variables from search_constant_type_c to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
668
diff
changeset

1125 
get_datatype_info_c::lint_type_name.accept(*this); 
668
90b6eb7f1775
Deprecating use of search_expression_type_c, so it may later be deleted!
Mario de Sousa <msousa@fe.up.pt>
parents:
667
diff
changeset

1126 
else if (get_datatype_info_c::is_ANY_REAL_literal(expression_type)) 
693
51a2fa6441b9
Prepare to delete search_constant_type_c > Move the static variables from search_constant_type_c to get_datatype_info_c
Mario de Sousa <msousa@fe.up.pt>
parents:
668
diff
changeset

1127 
get_datatype_info_c::lreal_type_name.accept(*this); 
376  1128 
else 
1129 
expression_type>accept(*this); 

1130 
s4o.print(" __case_expression = "); 

70  1131 
symbol>expression>accept(*this); 
376  1132 
s4o.print(";\n" + s4o.indent_spaces + "switch (__case_expression) {\n"); 
70  1133 
s4o.indent_right(); 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1134 
wanted_casegeneration = single_cg; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1135 
symbol>case_element_list>accept(*this); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1136 
wanted_casegeneration = subrange_cg; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1137 
s4o.print(s4o.indent_spaces + "default:\n"); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1138 
s4o.indent_right(); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1139 
first_subrange_case_list = true; 
70  1140 
symbol>case_element_list>accept(*this); 
1141 
if (symbol>statement_list != NULL) { 

706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

1142 
if (!first_subrange_case_list) { 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1143 
s4o.print(s4o.indent_spaces + "else {\n"); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1144 
s4o.indent_right(); 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

1145 
} 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1146 
symbol>statement_list>accept(*this); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1147 
if (!first_subrange_case_list) { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1148 
s4o.indent_left(); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1149 
s4o.print(s4o.indent_spaces + "}\n"); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1150 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1151 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1152 
s4o.print(s4o.indent_spaces + "break;\n"); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1153 
s4o.indent_left(); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1154 
wanted_casegeneration = none_cg; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1155 
s4o.indent_left(); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1156 
s4o.print(s4o.indent_spaces + "}\n"); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1157 
s4o.indent_left(); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1158 
s4o.print(s4o.indent_spaces + "}"); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1159 
return NULL; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1160 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1161 

44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1162 
/* helper symbol for case_statement */ 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1163 
void *visit(case_element_list_c *symbol) {return print_list(symbol);} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1164 

44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1165 
void *visit(case_element_c *symbol) { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1166 
case_element_iterator_c *case_element_iterator; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1167 
symbol_c* element = NULL; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1168 
bool first_element = true; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1169 

44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1170 
switch (wanted_casegeneration) { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1171 
case single_cg: 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1172 
case_element_iterator = new case_element_iterator_c(symbol>case_list, case_element_iterator_c::element_single); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1173 
for (element = case_element_iterator>next(); element != NULL; element = case_element_iterator>next()) { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1174 
if (first_element) first_element = false; 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

1175 
s4o.print(s4o.indent_spaces + "case "); 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1176 
element>accept(*this); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1177 
s4o.print(":\n"); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1178 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1179 
delete case_element_iterator; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1180 
break; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1181 

44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1182 
case subrange_cg: 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1183 
case_element_iterator = new case_element_iterator_c(symbol>case_list, case_element_iterator_c::element_subrange); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1184 
for (element = case_element_iterator>next(); element != NULL; element = case_element_iterator>next()) { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1185 
if (first_element) { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1186 
if (first_subrange_case_list) { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1187 
s4o.print(s4o.indent_spaces + "if ("); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1188 
first_subrange_case_list = false; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1189 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1190 
else { 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

1191 
s4o.print(s4o.indent_spaces + "else if ("); 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1192 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1193 
first_element = false; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1194 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1195 
else { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1196 
s4o.print(" && "); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1197 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1198 
element>accept(*this); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1199 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1200 
delete case_element_iterator; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1201 
if (!first_element) { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1202 
s4o.print(") {\n"); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1203 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1204 
break; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1205 

44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1206 
default: 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1207 
break; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1208 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1209 

44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1210 
if (!first_element) { 
70  1211 
s4o.indent_right(); 
1212 
symbol>statement_list>accept(*this); 

347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1213 
switch (wanted_casegeneration) { 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1214 
case single_cg: 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1215 
s4o.print(s4o.indent_spaces + "break;\n"); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1216 
s4o.indent_left(); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1217 
break; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1218 
case subrange_cg: 
706
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

1219 
s4o.indent_left(); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

1220 
s4o.print(s4o.indent_spaces + "}\n"); 
31553c22f318
Adding support for declaring function block instances as global and external variables
Laurent Bessard
parents:
625
diff
changeset

1221 
break; 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1222 
default: 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1223 
break; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1224 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1225 
} 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1226 
return NULL; 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1227 
} 
70  1228 

1229 
/********************************/ 

1230 
/* B 3.2.4 Iteration Statements */ 

1231 
/********************************/ 

1232 
void *visit(for_statement_c *symbol) { 

1233 
s4o.print("for("); 

1234 
symbol>control_variable>accept(*this); 

1235 
s4o.print(" = "); 

1236 
symbol>beg_expression>accept(*this); 

1237 
s4o.print("; "); 

387
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1238 
if (symbol>by_expression == NULL) { 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1239 
/* increment by 1 */ 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1240 
symbol>control_variable>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1241 
s4o.print(" <= "); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1242 
symbol>end_expression>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1243 
s4o.print("; "); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1244 
symbol>control_variable>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1245 
s4o.print("++"); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1246 
} else { 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1247 
/* increment by user defined value */ 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1248 
/* The user defined increment value may be negative, in which case 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1249 
* the expression to determine whether we have reached the end of the loop 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1250 
* changes from a '<=' to a '>='. 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1251 
* Since the increment value may change during runtime (remember, it is 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1252 
* an expression, so may contain variables), choosing which test 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1253 
* to use has to be done at runtime. 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1254 
*/ 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1255 
s4o.print("(("); 
70  1256 
symbol>by_expression>accept(*this); 
387
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1257 
s4o.print(") > 0)? ("); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1258 
symbol>control_variable>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1259 
s4o.print(" <= ("); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1260 
symbol>end_expression>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1261 
s4o.print(")) : ("); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1262 
symbol>control_variable>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1263 
s4o.print(" >= ("); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1264 
symbol>end_expression>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1265 
s4o.print(")); "); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1266 
symbol>control_variable>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1267 
s4o.print(" += ("); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1268 
symbol>by_expression>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1269 
s4o.print(")"); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1270 
} 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1271 
s4o.print(")"); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1272 

db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1273 
s4o.print(" {\n"); 
70  1274 
s4o.indent_right(); 
1275 
symbol>statement_list>accept(*this); 

1276 
s4o.indent_left(); 

1277 
s4o.print(s4o.indent_spaces); s4o.print("}"); 

1278 
return NULL; 

1279 
} 

387
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1280 

70  1281 
void *visit(while_statement_c *symbol) { 
1282 
s4o.print("while ("); 

1283 
symbol>expression>accept(*this); 

1284 
s4o.print(") {\n"); 

1285 
s4o.indent_right(); 

1286 
symbol>statement_list>accept(*this); 

1287 
s4o.indent_left(); 

1288 
s4o.print(s4o.indent_spaces); s4o.print("}"); 

1289 
return NULL; 

1290 
} 

387
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1291 

70  1292 
void *visit(repeat_statement_c *symbol) { 
1293 
s4o.print("do {\n"); 

1294 
s4o.indent_right(); 

1295 
symbol>statement_list>accept(*this); 

1296 
s4o.indent_left(); 

1297 
s4o.print(s4o.indent_spaces); s4o.print("} while("); 

1298 
symbol>expression>accept(*this); 

1299 
s4o.print(")"); 

1300 
return NULL; 

1301 
} 

387
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1302 

70 