author  Mario de Sousa <msousa@fe.up.pt> 
Sun, 09 Apr 2017 23:43:04 +0100  
changeset 1038  036f15e4041d 
parent 1026  fe580c0c1911 
child 1049  4d7183013481 
permissions  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 

945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
943
diff
changeset

47 
class generate_c_st_c: public generate_c_base_and_typeid_c { 
70  48 

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

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

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

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

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

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

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

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

56 

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

59 
* by searching through the declarations of the variables currently 

60 
* in scope. 

61 
* This class does just that... 

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

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

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

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

66 
* 

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

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

69 
* a function declaration. 

70 
*/ 

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

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

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

74 

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

75 
symbol_c *scope_; 
70  76 

98  77 
symbol_c* current_array_type; 
235  78 
symbol_c* current_param_type; 
98  79 

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

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

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

82 

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

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

84 

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

85 
variablegeneration_t wanted_variablegeneration; 
145  86 

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

88 
generate_c_st_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL) 
945
477393b00f95
Add support for relaxed datatype model for array datatypes.
mjsousa
parents:
943
diff
changeset

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

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

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

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

94 

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

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

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

100 
wanted_variablegeneration = expression_vg; 
70  101 
} 
102 

103 
virtual ~generate_c_st_c(void) { 

104 
delete search_fb_instance_decl; 

105 
delete search_varfb_instance_type; 

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

106 
delete search_var_instance_decl; 
70  107 
} 
108 

109 

110 
public: 

111 
void generate(statement_list_c *stl) { 

112 
stl>accept(*this); 

113 
} 

114 

115 
private: 

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

116 

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

117 

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

118 

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

119 

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

120 

70  121 

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

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

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

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

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

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

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

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

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

131 
} 
235  132 
else if (vartype == search_var_instance_decl_c::located_vt) 
133 
s4o.print(GET_LOCATED_BY_REF); 

134 
else 

135 
s4o.print(GET_VAR_BY_REF); 

136 
} 

137 
else { 

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

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

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

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

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

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

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

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

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

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

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

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

150 

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

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

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

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

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

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

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

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

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

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

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

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

163 

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

164 

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

165 

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

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

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

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

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

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

171 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

196 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

222 

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

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

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

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

226 

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

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

228 
void *visit(subrange_c *symbol) { 
999
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

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

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

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

232 

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

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

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

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

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

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

238 

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

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

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

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

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

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

244 

70  245 
/*********************/ 
246 
/* B 1.4  Variables */ 

247 
/*********************/ 

248 
void *visit(symbolic_variable_c *symbol) { 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

269 
} 
70  270 
return NULL; 
271 
} 

272 

273 
/********************************************/ 

274 
/* B.1.4.1 Directly Represented Variables */ 

275 
/********************************************/ 

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

277 
void *visit(direct_variable_c *symbol) { 

278 
TRACE("direct_variable_c"); 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

297 
} 
145  298 
} 
70  299 
this>print_variable_prefix(); 
300 
s4o.printlocation(symbol>value + 1); 

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

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

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

303 
(!this>is_variable_prefix_null() && (wanted_variablegeneration == fparam_output_vg))) 
145  304 
s4o.print(")"); 
70  305 
return NULL; 
306 
} 

307 

98  308 
/*************************************/ 
309 
/* B.1.4.2 Multielement Variables */ 

310 
/*************************************/ 

311 

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

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

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

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

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

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

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

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

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

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

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

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

325 
* using the __SET_VAR and __GET_VAR macros. 

326 
* 

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

328 
*/ 

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

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

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

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

332 
search_var_instance_decl_c search_var_instance_decl(symbol>record_variable>scope); 
936
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

333 
if (search_var_instance_decl_c::external_vt == search_var_instance_decl.get_vartype(get_var_name_c::get_last_field(symbol>record_variable))) 
943
566414d7ba1f
fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents:
941
diff
changeset

334 
s4o.print(">"); 
936
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

335 
else if (dynamic_cast<deref_operator_c *>(symbol>record_variable) != NULL) 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

336 
s4o.print(">"); /* please read the comment in visit(deref_operator_c *) tio understand what this line is doing! */ 
889
5f380b99e95e
Correctly handle structured variables that include FB and external FBs (example: FB1.FB2.extFB3.FB4.extFB5.extFB6.structvar.field1 := 42;) (this commit fixes only ST code. TODO: IL and SFC)
mjsousa
parents:
888
diff
changeset

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

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

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

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

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

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

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

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

936
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

347 
if (dynamic_cast<deref_operator_c *>(symbol>record_variable) != NULL) 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

348 
s4o.print(">"); /* please read the comment in visit(deref_operator_c *) tio understand what this line is doing! */ 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

349 
else 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

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

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

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

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

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

355 
if (this>is_variable_prefix_null()) { 
936
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

356 
/* We are writing code for a FUNCTION. In this case, deref_operator_c are not transformed into the C pointer derefence syntax '>' (e.g. ptr>elem). 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

357 
* We use instead the '*' syntax (e.g. (*ptr).elem) 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

358 
* While in FB the '>' is generated by this structured_variable_c visitor, in Functions the '*' syntax is generated by the deref_operator_c visitor 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

359 
* This is why here we do NOT have > {if (dynamic_cast<deref_operator_c *>(symbol>record_variable) != NULL) ..} 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

360 
* 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

361 
* please read the comment in visit(deref_operator_c *) for more information! 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

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

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

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

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

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

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

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

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

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

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

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

373 

98  374 
/* subscripted_variable '[' subscript_list ']' */ 
375 
//SYM_REF2(array_variable_c, subscripted_variable, subscript_list) 

376 
void *visit(array_variable_c *symbol) { 

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

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

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

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

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

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

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

383 

417
d48f53715f77
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

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

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

386 

943
566414d7ba1f
fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents:
941
diff
changeset

387 
if (dynamic_cast<deref_operator_c *>(symbol>subscripted_variable) != NULL) 
566414d7ba1f
fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents:
941
diff
changeset

388 
s4o.print(">"); /* please read the comment in visit(deref_operator_c *) tio understand what this line is doing! */ 
566414d7ba1f
fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents:
941
diff
changeset

389 
else 
566414d7ba1f
fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents:
941
diff
changeset

390 
s4o.print("."); 
566414d7ba1f
fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents:
941
diff
changeset

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

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

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

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

395 

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

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

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

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

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

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

401 

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

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

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

404 

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

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

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

407 

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

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

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

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

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

412 
break; 
98  413 
} 
414 
return NULL; 

415 
} 

416 

417 
/* subscript_list ',' subscript */ 

418 
void *visit(subscript_list_c *symbol) { 

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

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

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

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

423 

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

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

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

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

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

430 
delete array_dimension_iterator; 
98  431 
return NULL; 
432 
} 

433 

235  434 
/******************************************/ 
435 
/* B 1.4.3  Declaration & Initialisation */ 

436 
/******************************************/ 

237  437 

438 
/* helper symbol for structure_initialization */ 

439 
/* structure_element_initialization_list ',' structure_element_initialization */ 

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

442 
structure_initialization>init_structure_default(this>current_param_type); 

237  443 
structure_initialization>init_structure_values(symbol); 
235  444 
delete structure_initialization; 
445 
return NULL; 

446 
} 

98  447 

237  448 
/* helper symbol for array_initialization */ 
449 
/* array_initial_elements_list ',' array_initial_elements */ 

450 
void *visit(array_initial_elements_list_c *symbol) { 

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

452 
array_initialization>init_array_size(this>current_param_type); 

453 
array_initialization>init_array_values(symbol); 

454 
delete array_initialization; 

455 
return NULL; 

456 
} 

457 

70  458 
/***************************************/ 
459 
/* B.3  Language ST (Structured Text) */ 

460 
/***************************************/ 

461 
/***********************/ 

462 
/* B 3.1  Expressions */ 

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

936
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

464 
void *visit(deref_operator_c *symbol) { 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

465 
/* When producing C code for FUNCTION_BLOCKS, we use the '*' syntax (e.g. (*ptr).elem) 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

466 
* When producing C code for a FUNCTION_BLOCK, the deref_operator_c are transformed in two ways, depending on where they occur. 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

467 
*  deref_operator between a struct and its elem (e.g. struct_ref^.elem1) 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

468 
* are transformed into C using the C pointer derefence syntax '>' (e.g. struct_ref>elem1). 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

469 
* (In this case, '>' is generated by this structured_variable_c visitor) 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

470 
*  deref_operator at the end of a struct variable (e.g. struct.elem_ptr^) 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

471 
* are transformed using the '*' syntax for C pointer dereferencing (e.g. *(struct.elem_ptr) ) 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

472 
* 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

473 
* NOTE: Ideally, we should always use the '*' C pointer dereferencing syntax. However, due to the 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

474 
* was the GET_VAR and SET_VAR are transformed into C, this does not work for '^' between a struct and its 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

475 
* element (e.g. struct_ref^.elem), which is whey in this case only we use the '>' syntax. 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

476 
* NOTE: The use of the > syntax means that pointers to pointers are not supported betweem a struct and its elem 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

477 
* (e.g. . struct_ref_ref^^.elem) as this would be transformed into the invalid C code struct_ref_ref>>elem. 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

478 
* This is why we add a test for this case, and bug out with an error if we encounter it!! 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

479 
*/ 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

480 
if (this>is_variable_prefix_null()) { 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

481 
/* For code in FUNCTIONs */ 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

482 
s4o.print("(*"); 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

483 
symbol>exp>accept(*this); 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

484 
s4o.print(")"); 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

485 
} else { 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

486 
/* For code in FBs, and PROGRAMS... */ 
943
566414d7ba1f
fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents:
941
diff
changeset

487 
if ( (NULL == dynamic_cast<structured_variable_c *>(symbol>parent)) 
566414d7ba1f
fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents:
941
diff
changeset

488 
&& (NULL == dynamic_cast< array_variable_c *>(symbol>parent))) { 
936
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

489 
s4o.print("(*"); 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

490 
symbol>exp>accept(*this); 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

491 
s4o.print(")"); 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

492 
} else { 
943
566414d7ba1f
fix code generation when dereferencing pointers (ref_to) to arrays (ref_to_array^[5])
mjsousa
parents:
941
diff
changeset

493 
/* We are in a structured variable  the structured_variable_c or the array_variable_c will already have printed out the '>' !! */ 
936
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

494 
if (NULL != dynamic_cast<deref_operator_c *>(symbol>exp)) 
941  495 
STAGE4_ERROR(symbol, symbol>exp, "The use of two or more consecutive derefencing operators between a struct variable and its record elem (ex: struct_ref_ref^^.elem) is currently not supported for code inside a Function_Block."); 
936
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

496 
symbol>exp>accept(*this); 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

497 
} 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

498 
} 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

499 

0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

500 
return NULL; 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

501 
} 
0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

502 

0f7bcc160568
Fix bug: Add support for dereferencing pointers to struct (struct_ptr^.elem1) when used inside FB.
mjsousa
parents:
933
diff
changeset

503 

933
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

504 
void *visit(deref_expression_c *symbol) { 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

505 
s4o.print("("); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

506 
if (this>is_variable_prefix_null()) { 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

507 
/* For code in FUNCTIONs */ 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

508 
s4o.print("*"); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

509 
symbol>exp>accept(*this); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

510 
s4o.print(""); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

511 
} else { 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

512 
/* For code in FBs, and PROGRAMS... */ 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

513 
unsigned int vartype = analyse_variable_c::first_nonfb_vardecltype(symbol>exp, scope_); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

514 
if (vartype == search_var_instance_decl_c::external_vt) { 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

515 
if (!get_datatype_info_c::is_type_valid (symbol>exp>datatype)) ERROR; 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

516 
if ( get_datatype_info_c::is_function_block(symbol>exp>datatype)) 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

517 
s4o.print(GET_EXTERNAL_FB_DREF); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

518 
else 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

519 
s4o.print(GET_EXTERNAL_DREF); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

520 
} 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

521 
else if (vartype == search_var_instance_decl_c::located_vt) 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

522 
s4o.print(GET_LOCATED_DREF); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

523 
else 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

524 
s4o.print(GET_VAR_DREF); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

525 

76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

526 
variablegeneration_t old_wanted_variablegeneration = wanted_variablegeneration; 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

527 
s4o.print("("); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

528 
wanted_variablegeneration = complextype_base_vg; 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

529 
print_variable_prefix(); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

530 
symbol>exp>accept(*this); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

531 
s4o.print(","); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

532 
wanted_variablegeneration = complextype_suffix_vg; 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

533 
symbol>exp>accept(*this); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

534 
s4o.print(")"); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

535 
wanted_variablegeneration = old_wanted_variablegeneration; 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

536 
} 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

537 
s4o.print(")"); 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

538 

76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

539 
return NULL; 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

540 
} 
76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

541 

76324f461aed
Add support for dereferencing of REF_TO datatypes (Note: dereferencing of arrays and structs not yet supported!)
mjsousa
parents:
911
diff
changeset

542 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

565 

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

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

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

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

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

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

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

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

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

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

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

576 

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

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

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

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

580 

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

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

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

583 

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

584 

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

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

588 
if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol>datatype)) 
70  589 
return print_binary_expression(symbol>l_exp, symbol>r_exp, "  "); 
590 
ERROR; 

591 
return NULL; 

592 
} 

593 

594 
void *visit(xor_expression_c *symbol) { 

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

595 
if (get_datatype_info_c::is_BOOL_compatible(symbol>datatype)) { 
1026
fe580c0c1911
Fix code generation for XOR expressions in ST (add parenthesis)
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1012
diff
changeset

596 
s4o.print("(("); 
70  597 
symbol>l_exp>accept(*this); 
598 
s4o.print(" && !"); 

599 
symbol>r_exp>accept(*this); 

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

601 
symbol>l_exp>accept(*this); 

602 
s4o.print(" && "); 

603 
symbol>r_exp>accept(*this); 

1026
fe580c0c1911
Fix code generation for XOR expressions in ST (add parenthesis)
Andrey Skvortsov <andrej.skvortzov@gmail.com>
parents:
1012
diff
changeset

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

607 
if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol>datatype)) 
70  608 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " ^ "); 
609 
ERROR; 

610 
return NULL; 

611 
} 

612 

613 
void *visit(and_expression_c *symbol) { 

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

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

616 
if (get_datatype_info_c::is_ANY_nBIT_compatible(symbol>datatype)) 
70  617 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " & "); 
618 
ERROR; 

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

619 
return NULL; 
70  620 
} 
621 

622 
void *visit(equ_expression_c *symbol) { 

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

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

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

625 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
1011
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
999
diff
changeset

626 
return print_compare_function("EQ", symbol>l_exp>datatype, symbol>l_exp, symbol>r_exp); 
70  627 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " == "); 
628 
} 

629 

630 
void *visit(notequ_expression_c *symbol) { 

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

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

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

633 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
1011
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
999
diff
changeset

634 
return print_compare_function("NE", symbol>l_exp>datatype, symbol>l_exp, symbol>r_exp); 
70  635 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " != "); 
636 
} 

637 

638 
void *visit(lt_expression_c *symbol) { 

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

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

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

641 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
1011
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
999
diff
changeset

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

643 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " < "); 
70  644 
} 
645 

646 
void *visit(gt_expression_c *symbol) { 

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

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

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

649 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
1011
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
999
diff
changeset

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

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

654 
void *visit(le_expression_c *symbol) { 

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

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

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

657 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
1011
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
999
diff
changeset

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

659 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " <= "); 
70  660 
} 
661 

662 
void *visit(ge_expression_c *symbol) { 

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

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

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

665 
get_datatype_info_c::is_ANY_STRING_compatible(symbol>l_exp>datatype)) 
1011
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
999
diff
changeset

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

667 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " >= "); 
70  668 
} 
669 

670 
void *visit(add_expression_c *symbol) { 

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

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

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

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

674 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " + "); 
70  675 
} 
676 

677 
void *visit(sub_expression_c *symbol) { 

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

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

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

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

681 
return print_binary_expression(symbol>l_exp, symbol>r_exp, "  "); 
70  682 
} 
683 

684 
void *visit(mul_expression_c *symbol) { 

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

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

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

687 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " * "); 
70  688 
} 
689 

690 
void *visit(div_expression_c *symbol) { 

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

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

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

693 
return print_binary_expression(symbol>l_exp, symbol>r_exp, " / "); 
70  694 
} 
695 

696 
void *visit(mod_expression_c *symbol) { 

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

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

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

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

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

701 
s4o.print(")"); 
70  702 
return NULL; 
703 
} 

704 

257  705 
void *visit(power_expression_c *symbol) { 
1011
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
999
diff
changeset

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

707 
symbol>l_exp>accept(*this); 
1011
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
999
diff
changeset

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

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

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

711 
return NULL; 
257  712 
} 
713 

123  714 
void *visit(neg_expression_c *symbol) { 
257  715 
return print_unary_expression(symbol>exp, " "); 
123  716 
} 
70  717 

718 
void *visit(not_expression_c *symbol) { 

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

719 
return print_unary_expression(symbol>exp, get_datatype_info_c::is_BOOL_compatible(symbol>datatype)?"!":"~"); 
70  720 
} 
721 

722 
void *visit(function_invocation_c *symbol) { 

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

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

725 

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

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

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

728 
if (NULL != symbol>nonformal_param_list) parameter_assignment_list = symbol>nonformal_param_list; 
1012
1f2af384fb1f
Add support for non standard feature: allow POUs with no in, out and inout parameters
mjsousa
parents:
1011
diff
changeset

729 
// NOTE> We support the nonstandard feature of POUS with no in, out and inout parameters, so this is no longer an internal error! 
1f2af384fb1f
Add support for non standard feature: allow POUs with no in, out and inout parameters
mjsousa
parents:
1011
diff
changeset

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

731 

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

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

733 

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

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

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

736 

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

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

738 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

771 

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

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

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

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

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

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

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

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

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

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

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

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

783 

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

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

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

786 

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

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

788 

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

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

790 

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

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

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

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

794 

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

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

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

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

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

799 

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

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

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

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

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

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

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

807 

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

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

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

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

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

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

813 

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

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

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

816 
// symbol>parameter_assignment>accept(*this); 
149  817 

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

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

819 

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

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

821 

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

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

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

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

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

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

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

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

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

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

831 

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

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

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

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

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

836 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

859 
} 
149  860 
s4o.print("("); 
861 
s4o.indent_right(); 

1011
76175defb87b
Add option to not add the EN and ENO parameters to every function and FB (generated C code becomes smaller, and uses less memory for function invocations)
mjsousa
parents:
999
diff
changeset

862 
s4o.print("\n"+s4o.indent_spaces); 
149  863 

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

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

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

866 
symbol_c *param_value = PARAM_VALUE; 
235  867 
current_param_type = PARAM_TYPE; 
149  868 

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

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

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

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

873 
if (param_value == NULL) { 
149  874 
/* If not, get the default value of this variable's type */ 
762  875 
param_value = type_initial_value_c::get(current_param_type); 
149  876 
} 
877 
if (param_value == NULL) ERROR; 

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

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

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

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

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

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

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

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

887 
nb_param++; 
149  888 
break; 
889 
case function_param_iterator_c::direction_out: 

890 
case function_param_iterator_c::direction_inout: 

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

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

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

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

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

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

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

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

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

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

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

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

902 
} 
149  903 
break; 
904 
case function_param_iterator_c::direction_extref: 

905 
/* TODO! */ 

906 
ERROR; 

907 
break; 

908 
} /* switch */ 

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

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

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

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

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

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

914 
} 
149  915 
s4o.print(")"); 
916 
s4o.indent_left(); 

70  917 

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

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

919 

70  920 
return NULL; 
921 
} 

922 

923 
/********************/ 

924 
/* B 3.2 Statements */ 

925 
/********************/ 

926 
void *visit(statement_list_c *symbol) { 

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

929 
s4o.print(s4o.indent_spaces); 

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

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

932 
} 

933 
return NULL; 

70  934 
} 
935 

936 
/*********************************/ 

937 
/* B 3.2.1 Assignment Statements */ 

938 
/*********************************/ 

939 
void *visit(assignment_statement_c *symbol) { 

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

940 
symbol_c *left_type = search_varfb_instance_type>get_type_id(symbol>l_exp); 
98  941 

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

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

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

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

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

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

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

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

949 
} 
70  950 
return NULL; 
951 
} 

952 

953 
/*****************************************/ 

954 
/* B 3.2.2 Subprogram Control Statements */ 

955 
/*****************************************/ 

956 

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

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

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

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

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

961 

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

962 

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

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

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

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

967 
// SYM_REF3(fb_invocation_c, fb_name, formal_param_list, nonformal_param_list, symbol_c *called_fb_declaration;) 
70  968 
void *visit(fb_invocation_c *symbol) { 
969 
TRACE("fb_invocation_c"); 

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

970 

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

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

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

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

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

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

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

977 

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

980 
*/ 

981 
function_param_iterator_c fp_iterator(fb_decl); 

982 
identifier_c *param_name; 

983 
function_call_param_iterator_c function_call_param_iterator(symbol); 

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

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

160  986 

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

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

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

990 
symbol_c *param_value = function_call_param_iterator.search_f(param_name); 
70  991 

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

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

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

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

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

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

997 
param_value = function_call_param_iterator.next_nf(); 
70  998 

98  999 
symbol_c *param_type = fp_iterator.param_type(); 
1000 
if (param_type == NULL) ERROR; 

1001 

70  1002 
/* now output the value assignment */ 
1003 
if (param_value != NULL) 

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

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

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

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

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

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

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

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

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

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

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

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

1015 
} 
70  1016 
s4o.print(";\n" + s4o.indent_spaces); 
1017 
} 

1018 
} /* for(...) */ 

1019 

1020 
/* now call the function... */ 

1021 
function_block_type_name>accept(*this); 

1022 
s4o.print(FB_FUNCTION_SUFFIX); 

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

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

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

1025 
s4o.print("&"); 
70  1026 
print_variable_prefix(); 
1027 
symbol>fb_name>accept(*this); 

1028 
s4o.print(")"); 

1029 

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

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

1032 
*/ 

1033 
fp_iterator.reset(); 

1034 
function_call_param_iterator.reset(); 

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

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

1037 

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

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

1039 
symbol_c *param_value = function_call_param_iterator.search_f(param_name); 
70  1040 

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

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

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

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

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

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

1046 
param_value = function_call_param_iterator.next_nf(); 
70  1047 

1048 
/* now output the value assignment */ 

1049 
if (param_value != NULL) 

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

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

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

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

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

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

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

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

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

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

1061 
} 
70  1062 
} 
1063 
} /* for(...) */ 

1064 

1065 
return NULL; 

1066 
} 

1067 

1068 

1069 

1070 

1071 
/* helper symbol for fb_invocation */ 

1072 
/* param_assignment_list ',' param_assignment */ 

1073 
void *visit(param_assignment_list_c *symbol) { 

1074 
TRACE("param_assignment_list_c"); 

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

1076 
ERROR; 

1077 
return NULL; 

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

1079 
} 

1080 

1081 

1082 
void *visit(input_variable_param_assignment_c *symbol) { 

1083 
TRACE("input_variable_param_assignment_c"); 

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

1085 
ERROR; 

1086 
return NULL; 

1087 
/* 

1088 
symbol>variable_name>accept(*this); 

1089 
s4o.print(" = "); 

1090 
symbol>expression>accept(*this); 

1091 
return NULL; 

1092 
*/ 

1093 
} 

1094 

1095 
void *visit(output_variable_param_assignment_c *symbol) { 

1096 
TRACE("output_variable_param_assignment_c"); 

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

1098 
ERROR; 

1099 
return NULL; 

1100 
/* 

1101 
s4o.print(s4o.indent_spaces); 

1102 
if (symbol>not_param != NULL) 

1103 
symbol>not_param>accept(*this); 

1104 
symbol>variable_name>accept(*this); 

1105 
s4o.print(" => "); 

1106 
symbol>variable>accept(*this); 

1107 
return NULL; 

1108 
*/ 

1109 
} 

1110 

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

1112 
void *visit(not_paramassign_c *symbol) { 

1113 
TRACE("not_paramassign_c"); 

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

1115 
ERROR; 

1116 
return NULL; 

1117 
/* 

1118 
s4o.print("NOT "); 

1119 
return NULL; 

1120 
*/ 

1121 
} 

1122 

1123 

1124 
/********************************/ 

1125 
/* B 3.2.3 Selection Statements */ 

1126 
/********************************/ 

1127 
void *visit(if_statement_c *symbol) { 

1128 
s4o.print("if ("); 

1129 
symbol>expression>accept(*this); 

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

1131 
s4o.indent_right(); 

1132 
symbol>statement_list>accept(*this); 

1133 
s4o.indent_left(); 

1134 
symbol>elseif_statement_list>accept(*this); 

1135 

1136 
if (symbol>else_statement_list != NULL) { 

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

1138 
s4o.indent_right(); 

1139 
symbol>else_statement_list>accept(*this); 

1140 
s4o.indent_left(); 

1141 
} 

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

1143 
return NULL; 

1144 
} 

1145 

1146 
/* helper symbol for if_statement */ 

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

1148 

1149 
/* helper symbol for elseif_statement_list */ 

1150 
void *visit(elseif_statement_c *symbol) { 

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

1152 
symbol>expression>accept(*this); 

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

1154 
s4o.indent_right(); 

1155 
symbol>statement_list>accept(*this); 

1156 
s4o.indent_left(); 

1157 
return NULL; 

1158 
} 

1159 

1160 
void *visit(case_statement_c *symbol) { 

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

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

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

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

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

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

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

1168 
get_datatype_info_c::lreal_type_name.accept(*this); 
376  1169 
else 
1170 
expression_type>accept(*this); 

1171 
s4o.print(" __case_expression = "); 

70  1172 
symbol>expression>accept(*this); 
999
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1173 
s4o.print(";\n"); 
70  1174 
symbol>case_element_list>accept(*this); 
1175 
if (symbol>statement_list != NULL) { 

999
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1176 
s4o.print(s4o.indent_spaces + "else {\n"); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1177 
s4o.indent_right(); 
347
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1178 
symbol>statement_list>accept(*this); 
999
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1179 
s4o.indent_left(); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1180 
s4o.print(s4o.indent_spaces + "}\n"); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

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

1182 
s4o.indent_left(); 
999
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1183 
s4o.print(s4o.indent_spaces + "}"); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1184 
return NULL; 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1185 
} 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1186 

dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1187 

dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1188 
/* helper symbol for case_statement */ 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1189 
void *visit(case_element_list_c *symbol) {return print_list(symbol, s4o.indent_spaces+"if ", s4o.indent_spaces+"else if ");} 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1190 

dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1191 
void *visit(case_element_c *symbol) { 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1192 
symbol>case_list>accept(*this); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1193 
s4o.print(" {\n"); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1194 
s4o.indent_right(); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

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

1196 
s4o.indent_left(); 
44ff2a6fcadc
Fix case statement in ST, adding support for enumerated types
laurent
parents:
344
diff
changeset

1197 
s4o.print(s4o.indent_spaces + "}\n"); 
999
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1198 
return NULL; 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1199 
} 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1200 

dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1201 

dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1202 
void *visit(case_list_c *symbol) { 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1203 
s4o.print("("); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1204 
for (int i = 0; i < symbol>n; i++) { 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1205 
/* if not the first element, then add an '', a '\n', and add some spaces to get nice alignment */ 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1206 
/* example of generated C code (codition) for 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1207 
* case XX of 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1208 
* 10..20,42,15..99: < C code is for this line! 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1209 
* 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1210 
* else if ((__case_expression >= 10 && __case_expression <= 20)  
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1211 
* (__case_expression == 42)  
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1212 
* (__case_expression >= 15 && __case_expression <= 99)) { 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1213 
*/ 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1214 
if (0 != i) s4o.print(" \n" + s4o.indent_spaces + " "); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1215 
s4o.print("("); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1216 
subrange_c *subrange = dynamic_cast<subrange_c *>(symbol>elements[i]); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1217 
if (NULL == subrange) { 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1218 
s4o.print("__case_expression == "); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1219 
symbol>elements[i]>accept(*this); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1220 
} else { 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1221 
s4o.print("__case_expression >= "); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1222 
subrange>lower_limit>accept(*this); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1223 
s4o.print(" && __case_expression <= "); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1224 
subrange>upper_limit>accept(*this); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1225 
} 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1226 
s4o.print(")"); 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

1227 
} 
dd50a82ae8da
transform CASE into if()..else if().. > fixes 2 bugs (1)case within case statements, and (2)repeated elements in case options
mjsousa
parents:
945
diff
changeset

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

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

1230 
} 
70  1231 

1232 
/********************************/ 

1233 
/* B 3.2.4 Iteration Statements */ 

1234 
/********************************/ 

1235 
void *visit(for_statement_c *symbol) { 

1038
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1236 
/* Due to the way the GET/SET_GLOBAL accessor macros access VAR_GLOBAL variables, 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1237 
* these varibles cannot be used within a C for(;;) loop. 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1238 
* We must therefore implemnt the FOR END_FOR loop as a C while() loop 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1239 
*/ 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1240 
s4o.print("/* FOR ... */\n" + s4o.indent_spaces); 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1241 
/* For the initialization part, we create an assignment_statement_c */ 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1242 
/* and have this visitor visit it! */ 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1243 
assignment_statement_c ini_assignment(symbol>control_variable, symbol>beg_expression); 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1244 
ini_assignment.accept(*this); 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1245 
//symbol>control_variable>accept(*this); // this does not work for VAR_GLOBAL variables 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1246 
//s4o.print(" = "); 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1247 
//symbol>beg_expression>accept(*this); 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1248 

036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1249 
/* comparison // check for end of loop */ 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1250 
s4o.print(";\n" + s4o.indent_spaces + "while( "); 
387
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1251 
if (symbol>by_expression == NULL) { 
1038
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1252 
/* increment by 1 */ 
387
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1253 
symbol>control_variable>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1254 
s4o.print(" <= "); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1255 
symbol>end_expression>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1256 
} else { 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1257 
/* increment by user defined value */ 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1258 
/* The user defined increment value may be negative, in which case 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1259 
* the expression to determine whether we have reached the end of the loop 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1260 
* changes from a '<=' to a '>='. 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1261 
* Since the increment value may change during runtime (remember, it is 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1262 
* an expression, so may contain variables), choosing which test 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1263 
* to use has to be done at runtime. 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1264 
*/ 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1265 
s4o.print("(("); 
70  1266 
symbol>by_expression>accept(*this); 
387
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1267 
s4o.print(") > 0)? ("); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1268 
symbol>control_variable>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1269 
s4o.print(" <= ("); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1270 
symbol>end_expression>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1271 
s4o.print(")) : ("); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1272 
symbol>control_variable>accept(*this); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1273 
s4o.print(" >= ("); 
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1274 
symbol>end_expression>accept(*this); 
1038
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1275 
s4o.print(")) "); 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1276 
} 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1277 
s4o.print(" ) {\n"); 
387
db368e53133c
Fix code generation of FOR loops. Now handles negative values of BY correctly.
Mario de Sousa <msousa@fe.up.pt>
parents:
382
diff
changeset

1278 

1038
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1279 
/* the body part */ 
70  1280 
s4o.indent_right(); 
1281 
symbol>statement_list>accept(*this); 

1038
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1282 

036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1283 
/* increment part */ 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1284 
s4o.print(s4o.indent_spaces + "/* BY ... (of FOR loop) */\n"); 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1285 
s4o.print(s4o.indent_spaces); 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1286 
if (symbol>by_expression == NULL) { 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1287 
/* increment by 1 */ 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1288 
/* For the increment part, we create an add_expression_c and assignment_statement_c */ 
036f15e4041d
Allow use of GLOBAL/EXTERNAL variables as control variable of FOR loop.
Mario de Sousa <msousa@fe.up.pt>
parents:
1026
diff
changeset

1289 
/* and have this visitor vist the latter! */ 
036f15e4041d
Allow u 