author | Edouard Tisserant |
Wed, 28 Nov 2012 12:00:38 +0900 | |
changeset 710 | e9bb0ed80471 |
parent 704 | 1adc8df05d2b |
child 793 | 268bf4ca5fa1 |
permissions | -rwxr-xr-x |
70 | 1 |
/* |
279
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
2 |
* matiec - a compiler for the programming languages defined in IEC 61131-3 |
70 | 3 |
* |
279
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
4 |
* Copyright (C) 2003-2011 Mario de Sousa (msousa@fe.up.pt) |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
5 |
* Copyright (C) 2007-2011 Laurent Bessard and Edouard Tisserant |
70 | 6 |
* |
279
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
7 |
* This program is free software: you can redistribute it and/or modify |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
8 |
* it under the terms of the GNU General Public License as published by |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
9 |
* the Free Software Foundation, either version 3 of the License, or |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
10 |
* (at your option) any later version. |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
11 |
* |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
12 |
* This program is distributed in the hope that it will be useful, |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
13 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
14 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
15 |
* GNU General Public License for more details. |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
16 |
* |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
17 |
* You should have received a copy of the GNU General Public License |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
18 |
* along with this program. If not, see <http://www.gnu.org/licenses/>. |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
19 |
* |
70 | 20 |
* |
21 |
* This code is made available on the understanding that it will not be |
|
22 |
* used in safety-critical situations without a full and competent review. |
|
23 |
*/ |
|
24 |
||
25 |
typedef struct |
|
26 |
{ |
|
27 |
transition_c *symbol; |
|
28 |
int priority; |
|
29 |
int index; |
|
30 |
} TRANSITION; |
|
31 |
||
32 |
/***********************************************************************/ |
|
33 |
/***********************************************************************/ |
|
34 |
/***********************************************************************/ |
|
35 |
/***********************************************************************/ |
|
36 |
||
37 |
class generate_c_sfc_elements_c: public generate_c_base_c { |
|
38 |
||
39 |
public: |
|
40 |
typedef enum { |
|
41 |
transitionlist_sg, |
|
42 |
transitiontest_sg, |
|
141 | 43 |
transitiontestdebug_sg, |
70 | 44 |
stepset_sg, |
45 |
stepreset_sg, |
|
46 |
actionassociation_sg, |
|
47 |
actionbody_sg |
|
48 |
} sfcgeneration_t; |
|
49 |
||
50 |
private: |
|
51 |
generate_c_il_c *generate_c_il; |
|
52 |
generate_c_st_c *generate_c_st; |
|
53 |
generate_c_SFC_IL_ST_c *generate_c_code; |
|
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
54 |
search_var_instance_decl_c *search_var_instance_decl; |
70 | 55 |
|
56 |
int transition_number; |
|
57 |
std::list<TRANSITION> transition_list; |
|
58 |
||
59 |
symbol_c *current_step; |
|
60 |
symbol_c *current_action; |
|
61 |
||
62 |
sfcgeneration_t wanted_sfcgeneration; |
|
63 |
||
64 |
public: |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
65 |
generate_c_sfc_elements_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL) |
70 | 66 |
: generate_c_base_c(s4o_ptr) { |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
67 |
generate_c_il = new generate_c_il_c(s4o_ptr, name, scope, variable_prefix); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
68 |
generate_c_st = new generate_c_st_c(s4o_ptr, name, scope, variable_prefix); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
69 |
generate_c_code = new generate_c_SFC_IL_ST_c(s4o_ptr, name, scope, variable_prefix); |
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
70 |
search_var_instance_decl = new search_var_instance_decl_c(scope); |
70 | 71 |
this->set_variable_prefix(variable_prefix); |
72 |
} |
|
73 |
||
74 |
~generate_c_sfc_elements_c(void) { |
|
149 | 75 |
transition_list.clear(); |
70 | 76 |
delete generate_c_il; |
77 |
delete generate_c_st; |
|
78 |
delete generate_c_code; |
|
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
79 |
delete search_var_instance_decl; |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
80 |
} |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
81 |
|
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
82 |
|
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
83 |
bool is_variable(symbol_c *symbol) { |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
84 |
/* we try to find the variable instance declaration, to determine if symbol is variable... */ |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
85 |
symbol_c *var_decl = search_var_instance_decl->get_decl(symbol); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
86 |
|
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
87 |
return var_decl != NULL; |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
88 |
} |
70 | 89 |
|
90 |
void reset_transition_number(void) {transition_number = 0;} |
|
91 |
||
92 |
void generate(symbol_c *symbol, sfcgeneration_t generation_type) { |
|
93 |
wanted_sfcgeneration = generation_type; |
|
94 |
switch (wanted_sfcgeneration) { |
|
95 |
case transitiontest_sg: |
|
96 |
{ |
|
97 |
std::list<TRANSITION>::iterator pt; |
|
98 |
for(pt = transition_list.begin(); pt != transition_list.end(); pt++) { |
|
99 |
transition_number = pt->index; |
|
100 |
pt->symbol->accept(*this); |
|
101 |
} |
|
102 |
} |
|
103 |
break; |
|
104 |
default: |
|
105 |
symbol->accept(*this); |
|
106 |
break; |
|
107 |
} |
|
108 |
} |
|
109 |
||
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
110 |
void print_step_argument(symbol_c *step_name, const char* argument, bool setter=false) { |
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
111 |
print_variable_prefix(); |
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
112 |
if (setter) s4o.print(","); |
141 | 113 |
s4o.print("__step_list["); |
70 | 114 |
s4o.print(SFC_STEP_ACTION_PREFIX); |
115 |
step_name->accept(*this); |
|
116 |
s4o.print("]."); |
|
117 |
s4o.print(argument); |
|
118 |
} |
|
119 |
||
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
120 |
void print_action_argument(symbol_c *action_name, const char* argument, bool setter=false) { |
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
121 |
print_variable_prefix(); |
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
122 |
if (setter) s4o.print(","); |
141 | 123 |
s4o.print("__action_list["); |
70 | 124 |
s4o.print(SFC_STEP_ACTION_PREFIX); |
125 |
action_name->accept(*this); |
|
126 |
s4o.print("]."); |
|
127 |
s4o.print(argument); |
|
128 |
} |
|
129 |
||
130 |
void print_transition_number(void) { |
|
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
561
diff
changeset
|
131 |
s4o.print(transition_number); |
70 | 132 |
} |
133 |
||
134 |
void print_reset_step(symbol_c *step_name) { |
|
135 |
s4o.print(s4o.indent_spaces); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
136 |
s4o.print(SET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
137 |
s4o.print("("); |
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
138 |
print_step_argument(step_name, "state", true); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
139 |
s4o.print(",0);\n"); |
70 | 140 |
} |
141 |
||
142 |
void print_set_step(symbol_c *step_name) { |
|
143 |
s4o.print(s4o.indent_spaces); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
144 |
s4o.print(SET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
145 |
s4o.print("("); |
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
146 |
print_step_argument(step_name, "state", true); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
147 |
s4o.print(",1);\n" + s4o.indent_spaces); |
70 | 148 |
print_step_argument(step_name, "elapsed_time"); |
149 |
s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); |
|
150 |
} |
|
151 |
||
152 |
/*********************************************/ |
|
153 |
/* B.1.6 Sequential function chart elements */ |
|
154 |
/*********************************************/ |
|
155 |
||
156 |
void *visit(initial_step_c *symbol) { |
|
157 |
switch (wanted_sfcgeneration) { |
|
158 |
case actionassociation_sg: |
|
159 |
if (((list_c*)symbol->action_association_list)->n > 0) { |
|
160 |
s4o.print(s4o.indent_spaces + "// "); |
|
161 |
symbol->step_name->accept(*this); |
|
162 |
s4o.print(" action associations\n"); |
|
163 |
current_step = symbol->step_name; |
|
164 |
s4o.print(s4o.indent_spaces + "{\n"); |
|
165 |
s4o.indent_right(); |
|
166 |
s4o.print(s4o.indent_spaces + "char activated = "); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
167 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
168 |
s4o.print("("); |
70 | 169 |
print_step_argument(current_step, "state"); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
170 |
s4o.print(") && !"); |
70 | 171 |
print_step_argument(current_step, "prev_state"); |
172 |
s4o.print(";\n"); |
|
173 |
s4o.print(s4o.indent_spaces + "char desactivated = !"); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
174 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
175 |
s4o.print("("); |
70 | 176 |
print_step_argument(current_step, "state"); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
177 |
s4o.print(") && "); |
70 | 178 |
print_step_argument(current_step, "prev_state"); |
179 |
s4o.print(";\n"); |
|
180 |
s4o.print(s4o.indent_spaces + "char active = "); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
181 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
182 |
s4o.print("("); |
70 | 183 |
print_step_argument(current_step, "state"); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
184 |
s4o.print(");\n"); |
70 | 185 |
symbol->action_association_list->accept(*this); |
186 |
s4o.indent_left(); |
|
187 |
s4o.print(s4o.indent_spaces + "}\n\n"); |
|
188 |
} |
|
189 |
break; |
|
190 |
default: |
|
191 |
break; |
|
192 |
} |
|
193 |
return NULL; |
|
194 |
} |
|
195 |
||
196 |
void *visit(step_c *symbol) { |
|
197 |
switch (wanted_sfcgeneration) { |
|
198 |
case actionassociation_sg: |
|
199 |
if (((list_c*)symbol->action_association_list)->n > 0) { |
|
200 |
s4o.print(s4o.indent_spaces + "// "); |
|
201 |
symbol->step_name->accept(*this); |
|
202 |
s4o.print(" action associations\n"); |
|
203 |
current_step = symbol->step_name; |
|
204 |
s4o.print(s4o.indent_spaces + "{\n"); |
|
205 |
s4o.indent_right(); |
|
702
56337e796ab0
Fix indentation and unused variable warning in SFC generated code
Laurent Bessard
parents:
629
diff
changeset
|
206 |
s4o.print(s4o.indent_spaces + "char activated, desactivated, active;\n"); |
56337e796ab0
Fix indentation and unused variable warning in SFC generated code
Laurent Bessard
parents:
629
diff
changeset
|
207 |
s4o.print(s4o.indent_spaces + "activated = "); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
208 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
209 |
s4o.print("("); |
70 | 210 |
print_step_argument(current_step, "state"); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
211 |
s4o.print(") && !"); |
70 | 212 |
print_step_argument(current_step, "prev_state"); |
213 |
s4o.print(";\n"); |
|
702
56337e796ab0
Fix indentation and unused variable warning in SFC generated code
Laurent Bessard
parents:
629
diff
changeset
|
214 |
s4o.print(s4o.indent_spaces + "desactivated = !"); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
215 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
216 |
s4o.print("("); |
70 | 217 |
print_step_argument(current_step, "state"); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
218 |
s4o.print(") && "); |
70 | 219 |
print_step_argument(current_step, "prev_state"); |
220 |
s4o.print(";\n"); |
|
702
56337e796ab0
Fix indentation and unused variable warning in SFC generated code
Laurent Bessard
parents:
629
diff
changeset
|
221 |
s4o.print(s4o.indent_spaces + "active = "); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
222 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
223 |
s4o.print("("); |
70 | 224 |
print_step_argument(current_step, "state"); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
225 |
s4o.print(");\n"); |
70 | 226 |
symbol->action_association_list->accept(*this); |
227 |
s4o.indent_left(); |
|
228 |
s4o.print(s4o.indent_spaces + "}\n\n"); |
|
229 |
} |
|
230 |
break; |
|
231 |
default: |
|
232 |
break; |
|
233 |
} |
|
234 |
return NULL; |
|
235 |
} |
|
236 |
||
237 |
void *visit(transition_c *symbol) { |
|
238 |
switch (wanted_sfcgeneration) { |
|
239 |
case transitionlist_sg: |
|
240 |
{ |
|
241 |
TRANSITION *transition; |
|
242 |
transition = new TRANSITION; |
|
243 |
transition->symbol = symbol; |
|
244 |
transition->index = transition_number; |
|
245 |
if (symbol->integer != NULL) { |
|
246 |
transition->priority = atoi(((token_c *)symbol->integer)->value); |
|
247 |
std::list<TRANSITION>::iterator pt = transition_list.begin(); |
|
248 |
while (pt != transition_list.end() && pt->priority <= transition->priority) { |
|
249 |
pt++; |
|
250 |
} |
|
251 |
transition_list.insert(pt, *transition); |
|
252 |
} |
|
253 |
else { |
|
254 |
transition->priority = 0; |
|
255 |
transition_list.push_back(*transition); |
|
256 |
} |
|
257 |
transition_number++; |
|
258 |
} |
|
259 |
break; |
|
260 |
case transitiontest_sg: |
|
261 |
s4o.print(s4o.indent_spaces + "if ("); |
|
262 |
symbol->from_steps->accept(*this); |
|
263 |
s4o.print(") {\n"); |
|
264 |
s4o.indent_right(); |
|
265 |
||
266 |
// Calculate transition value |
|
87 | 267 |
symbol->transition_condition->accept(*this); |
268 |
||
70 | 269 |
if (symbol->integer != NULL) { |
270 |
s4o.print(s4o.indent_spaces + "if ("); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
271 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
272 |
s4o.print("("); |
70 | 273 |
print_variable_prefix(); |
141 | 274 |
s4o.print("__transition_list["); |
70 | 275 |
print_transition_number(); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
276 |
s4o.print("])) {\n"); |
70 | 277 |
s4o.indent_right(); |
278 |
wanted_sfcgeneration = stepreset_sg; |
|
279 |
symbol->from_steps->accept(*this); |
|
280 |
wanted_sfcgeneration = transitiontest_sg; |
|
281 |
s4o.indent_left(); |
|
282 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
283 |
} |
|
284 |
s4o.indent_left(); |
|
141 | 285 |
s4o.print(s4o.indent_spaces + "}\n"); |
286 |
s4o.print(s4o.indent_spaces + "else {\n"); |
|
70 | 287 |
s4o.indent_right(); |
141 | 288 |
// Calculate transition value for debug |
289 |
s4o.print(s4o.indent_spaces + "if (__DEBUG) {\n"); |
|
290 |
s4o.indent_right(); |
|
291 |
wanted_sfcgeneration = transitiontestdebug_sg; |
|
292 |
symbol->transition_condition->accept(*this); |
|
293 |
wanted_sfcgeneration = transitiontest_sg; |
|
294 |
s4o.indent_left(); |
|
295 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
70 | 296 |
s4o.print(s4o.indent_spaces); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
297 |
s4o.print(SET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
298 |
s4o.print("("); |
70 | 299 |
print_variable_prefix(); |
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
300 |
s4o.print(",__transition_list["); |
70 | 301 |
print_transition_number(); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
302 |
s4o.print("],0);\n"); |
70 | 303 |
s4o.indent_left(); |
304 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
305 |
break; |
|
306 |
case stepset_sg: |
|
307 |
s4o.print(s4o.indent_spaces + "if ("); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
308 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
309 |
s4o.print("("); |
70 | 310 |
print_variable_prefix(); |
141 | 311 |
s4o.print("__transition_list["); |
70 | 312 |
print_transition_number(); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
313 |
s4o.print("])) {\n"); |
70 | 314 |
s4o.indent_right(); |
315 |
symbol->to_steps->accept(*this); |
|
316 |
s4o.indent_left(); |
|
317 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
318 |
transition_number++; |
|
319 |
break; |
|
320 |
case stepreset_sg: |
|
321 |
if (symbol->integer == NULL) { |
|
322 |
s4o.print(s4o.indent_spaces + "if ("); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
323 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
324 |
s4o.print("("); |
70 | 325 |
print_variable_prefix(); |
141 | 326 |
s4o.print("__transition_list["); |
70 | 327 |
print_transition_number(); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
328 |
s4o.print("])) {\n"); |
70 | 329 |
s4o.indent_right(); |
330 |
symbol->from_steps->accept(*this); |
|
331 |
s4o.indent_left(); |
|
332 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
333 |
} |
|
334 |
transition_number++; |
|
335 |
break; |
|
336 |
default: |
|
337 |
break; |
|
338 |
} |
|
339 |
return NULL; |
|
340 |
} |
|
341 |
||
87 | 342 |
void *visit(transition_condition_c *symbol) { |
343 |
switch (wanted_sfcgeneration) { |
|
344 |
case transitiontest_sg: |
|
141 | 345 |
case transitiontestdebug_sg: |
87 | 346 |
// Transition condition is in IL |
347 |
if (symbol->transition_condition_il != NULL) { |
|
348 |
generate_c_il->declare_backup_variable(); |
|
349 |
s4o.print(s4o.indent_spaces); |
|
350 |
symbol->transition_condition_il->accept(*generate_c_il); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
351 |
s4o.print(SET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
352 |
s4o.print("("); |
87 | 353 |
print_variable_prefix(); |
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
354 |
s4o.print(","); |
141 | 355 |
if (wanted_sfcgeneration == transitiontestdebug_sg) |
356 |
s4o.print("__debug_"); |
|
357 |
else |
|
358 |
s4o.print("__"); |
|
87 | 359 |
s4o.print("transition_list["); |
360 |
print_transition_number(); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
361 |
s4o.print("],"); |
87 | 362 |
generate_c_il->print_backup_variable(); |
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
363 |
generate_c_il->reset_default_variable_name(); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
364 |
s4o.print(");\n"); |
87 | 365 |
} |
366 |
// Transition condition is in ST |
|
367 |
if (symbol->transition_condition_st != NULL) { |
|
368 |
s4o.print(s4o.indent_spaces); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
369 |
s4o.print(SET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
370 |
s4o.print("("); |
87 | 371 |
print_variable_prefix(); |
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
372 |
s4o.print(","); |
141 | 373 |
if (wanted_sfcgeneration == transitiontestdebug_sg) |
374 |
s4o.print("__debug_"); |
|
375 |
else |
|
376 |
s4o.print("__"); |
|
87 | 377 |
s4o.print("transition_list["); |
378 |
print_transition_number(); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
379 |
s4o.print("],"); |
87 | 380 |
symbol->transition_condition_st->accept(*generate_c_st); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
381 |
s4o.print(");\n"); |
87 | 382 |
} |
141 | 383 |
if (wanted_sfcgeneration == transitiontest_sg) { |
384 |
s4o.print(s4o.indent_spaces + "if (__DEBUG) {\n"); |
|
385 |
s4o.indent_right(); |
|
386 |
s4o.print(s4o.indent_spaces); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
387 |
s4o.print(SET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
388 |
s4o.print("("); |
141 | 389 |
print_variable_prefix(); |
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
350
diff
changeset
|
390 |
s4o.print(",__debug_transition_list["); |
141 | 391 |
print_transition_number(); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
392 |
s4o.print("],"); |
221
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
217
diff
changeset
|
393 |
s4o.print(GET_VAR); |
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
217
diff
changeset
|
394 |
s4o.print("("); |
141 | 395 |
print_variable_prefix(); |
396 |
s4o.print("__transition_list["); |
|
397 |
print_transition_number(); |
|
221
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
217
diff
changeset
|
398 |
s4o.print("]));\n"); |
141 | 399 |
s4o.indent_left(); |
400 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
401 |
} |
|
87 | 402 |
break; |
403 |
default: |
|
404 |
break; |
|
405 |
} |
|
406 |
return NULL; |
|
407 |
} |
|
408 |
||
70 | 409 |
void *visit(action_c *symbol) { |
410 |
switch (wanted_sfcgeneration) { |
|
411 |
case actionbody_sg: |
|
412 |
s4o.print(s4o.indent_spaces + "if("); |
|
628
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
413 |
s4o.print(GET_VAR); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
414 |
s4o.print("("); |
70 | 415 |
print_variable_prefix(); |
141 | 416 |
s4o.print("__action_list["); |
70 | 417 |
s4o.print(SFC_STEP_ACTION_PREFIX); |
418 |
symbol->action_name->accept(*this); |
|
628
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
419 |
s4o.print("].state)) {\n"); |
70 | 420 |
s4o.indent_right(); |
421 |
||
422 |
// generate action code |
|
423 |
symbol->function_block_body->accept(*generate_c_code); |
|
424 |
||
425 |
s4o.indent_left(); |
|
426 |
s4o.print(s4o.indent_spaces + "}\n\n"); |
|
427 |
break; |
|
428 |
default: |
|
429 |
break; |
|
430 |
} |
|
431 |
return NULL; |
|
432 |
} |
|
433 |
||
434 |
void *visit(steps_c *symbol) { |
|
435 |
if (symbol->step_name != NULL) { |
|
436 |
switch (wanted_sfcgeneration) { |
|
437 |
case transitiontest_sg: |
|
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
438 |
s4o.print(GET_VAR); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
439 |
s4o.print("("); |
70 | 440 |
print_step_argument(symbol->step_name, "state"); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
441 |
s4o.print(")"); |
70 | 442 |
break; |
443 |
case stepset_sg: |
|
444 |
print_set_step(symbol->step_name); |
|
445 |
break; |
|
446 |
case stepreset_sg: |
|
447 |
print_reset_step(symbol->step_name); |
|
448 |
break; |
|
449 |
default: |
|
450 |
break; |
|
451 |
} |
|
452 |
} |
|
453 |
else if (symbol->step_name_list != NULL) { |
|
454 |
symbol->step_name_list->accept(*this); |
|
455 |
} |
|
456 |
return NULL; |
|
457 |
} |
|
458 |
||
459 |
void *visit(step_name_list_c *symbol) { |
|
460 |
switch (wanted_sfcgeneration) { |
|
461 |
case transitiontest_sg: |
|
462 |
for(int i = 0; i < symbol->n; i++) { |
|
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
463 |
s4o.print(GET_VAR); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
464 |
s4o.print("("); |
70 | 465 |
print_step_argument(symbol->elements[i], "state"); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
466 |
s4o.print(")"); |
70 | 467 |
if (i < symbol->n - 1) { |
468 |
s4o.print(" && "); |
|
469 |
} |
|
470 |
} |
|
471 |
break; |
|
472 |
case stepset_sg: |
|
473 |
for(int i = 0; i < symbol->n; i++) { |
|
474 |
print_set_step(symbol->elements[i]); |
|
475 |
} |
|
476 |
break; |
|
477 |
case stepreset_sg: |
|
478 |
for(int i = 0; i < symbol->n; i++) { |
|
479 |
print_reset_step(symbol->elements[i]); |
|
480 |
} |
|
481 |
break; |
|
482 |
default: |
|
483 |
break; |
|
484 |
} |
|
485 |
return NULL; |
|
486 |
} |
|
487 |
||
488 |
void *visit(action_association_list_c* symbol) { |
|
489 |
switch (wanted_sfcgeneration) { |
|
490 |
case actionassociation_sg: |
|
491 |
print_list(symbol, "", "\n", "\n"); |
|
492 |
break; |
|
493 |
default: |
|
494 |
break; |
|
495 |
} |
|
496 |
return NULL; |
|
497 |
} |
|
498 |
||
499 |
void *visit(action_association_c *symbol) { |
|
500 |
switch (wanted_sfcgeneration) { |
|
501 |
case actionassociation_sg: |
|
502 |
if (symbol->action_qualifier != NULL) { |
|
503 |
current_action = symbol->action_name; |
|
504 |
symbol->action_qualifier->accept(*this); |
|
505 |
} |
|
506 |
else { |
|
507 |
s4o.print(s4o.indent_spaces + "if ("); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
508 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
509 |
s4o.print("("); |
70 | 510 |
print_step_argument(current_step, "state"); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
511 |
s4o.print(")) {\n"); |
70 | 512 |
s4o.indent_right(); |
513 |
s4o.print(s4o.indent_spaces); |
|
628
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
514 |
s4o.print(SET_VAR); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
515 |
s4o.print("("); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
516 |
print_action_argument(symbol->action_name, "state", true); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
517 |
s4o.print(",1);\n"); |
70 | 518 |
s4o.indent_left(); |
519 |
s4o.print(s4o.indent_spaces + "}"); |
|
520 |
} |
|
521 |
break; |
|
522 |
default: |
|
523 |
break; |
|
524 |
} |
|
525 |
return NULL; |
|
526 |
} |
|
527 |
||
528 |
void *visit(action_qualifier_c *symbol) { |
|
529 |
switch (wanted_sfcgeneration) { |
|
530 |
case actionassociation_sg: |
|
531 |
{ |
|
532 |
char *qualifier = (char *)symbol->action_qualifier->accept(*this); |
|
533 |
s4o.print(s4o.indent_spaces + "if ("); |
|
155 | 534 |
if (strcmp(qualifier, "N") == 0 || strcmp(qualifier, "S") == 0 || |
535 |
strcmp(qualifier, "R") == 0) { |
|
70 | 536 |
s4o.print("active"); |
537 |
} |
|
627
e7caa7d32ef5
Adding support for P0 and P1 qualifiers and fixing code generated for SL qualifier
Laurent Bessard
parents:
594
diff
changeset
|
538 |
else if (strcmp(qualifier, "P") == 0 || strcmp(qualifier, "SD") == 0 || |
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
539 |
strcmp(qualifier, "DS") == 0 || strcmp(qualifier, "SL") == 0 || |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
540 |
strcmp(qualifier, "P0") == 0) { |
70 | 541 |
s4o.print("activated"); |
542 |
} |
|
627
e7caa7d32ef5
Adding support for P0 and P1 qualifiers and fixing code generated for SL qualifier
Laurent Bessard
parents:
594
diff
changeset
|
543 |
else if (strcmp(qualifier, "P1") == 0) { |
e7caa7d32ef5
Adding support for P0 and P1 qualifiers and fixing code generated for SL qualifier
Laurent Bessard
parents:
594
diff
changeset
|
544 |
s4o.print("desactivated"); |
e7caa7d32ef5
Adding support for P0 and P1 qualifiers and fixing code generated for SL qualifier
Laurent Bessard
parents:
594
diff
changeset
|
545 |
} |
e7caa7d32ef5
Adding support for P0 and P1 qualifiers and fixing code generated for SL qualifier
Laurent Bessard
parents:
594
diff
changeset
|
546 |
else if (strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) { |
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
547 |
s4o.print("active && __time_cmp("); |
70 | 548 |
print_step_argument(current_step, "elapsed_time"); |
120
74640e3c7f53
Bug with D and L action qualifier and timing management in SFC generated fixed
lbessard
parents:
119
diff
changeset
|
549 |
s4o.print(", "); |
74640e3c7f53
Bug with D and L action qualifier and timing management in SFC generated fixed
lbessard
parents:
119
diff
changeset
|
550 |
symbol->action_time->accept(*this); |
70 | 551 |
if (strcmp(qualifier, "D") == 0) { |
120
74640e3c7f53
Bug with D and L action qualifier and timing management in SFC generated fixed
lbessard
parents:
119
diff
changeset
|
552 |
s4o.print(") >= 0"); |
70 | 553 |
} |
554 |
else { |
|
120
74640e3c7f53
Bug with D and L action qualifier and timing management in SFC generated fixed
lbessard
parents:
119
diff
changeset
|
555 |
s4o.print(") < 0"); |
70 | 556 |
} |
557 |
} |
|
558 |
s4o.print(") {\n"); |
|
559 |
s4o.indent_right(); |
|
560 |
s4o.print(s4o.indent_spaces); |
|
561 |
if (strcmp(qualifier, "N") == 0 || strcmp(qualifier, "P") == 0 || |
|
627
e7caa7d32ef5
Adding support for P0 and P1 qualifiers and fixing code generated for SL qualifier
Laurent Bessard
parents:
594
diff
changeset
|
562 |
strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0 || |
e7caa7d32ef5
Adding support for P0 and P1 qualifiers and fixing code generated for SL qualifier
Laurent Bessard
parents:
594
diff
changeset
|
563 |
strcmp(qualifier, "P0") == 0 || strcmp(qualifier, "P1") == 0) { |
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
564 |
|
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
565 |
if (is_variable(current_action)) { |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
566 |
unsigned int vartype = search_var_instance_decl->get_vartype(current_action); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
567 |
|
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
568 |
if (vartype == search_var_instance_decl_c::external_vt) |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
569 |
s4o.print(SET_EXTERNAL); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
570 |
else if (vartype == search_var_instance_decl_c::located_vt) |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
571 |
s4o.print(SET_LOCATED); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
572 |
else |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
573 |
s4o.print(SET_VAR); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
574 |
s4o.print("("); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
575 |
print_variable_prefix(); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
576 |
s4o.print(","); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
577 |
current_action->accept(*this); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
578 |
s4o.print(",1);\n"); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
579 |
s4o.indent_left(); |
702
56337e796ab0
Fix indentation and unused variable warning in SFC generated code
Laurent Bessard
parents:
629
diff
changeset
|
580 |
s4o.print(s4o.indent_spaces + "}\n"); |
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
581 |
s4o.print(s4o.indent_spaces + "else if (active) {\n"); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
582 |
s4o.indent_right(); |
702
56337e796ab0
Fix indentation and unused variable warning in SFC generated code
Laurent Bessard
parents:
629
diff
changeset
|
583 |
s4o.print(s4o.indent_spaces); |
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
584 |
if (vartype == search_var_instance_decl_c::external_vt) |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
585 |
s4o.print(SET_EXTERNAL); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
586 |
else if (vartype == search_var_instance_decl_c::located_vt) |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
587 |
s4o.print(SET_LOCATED); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
588 |
else |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
589 |
s4o.print(SET_VAR); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
590 |
s4o.print("("); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
591 |
print_variable_prefix(); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
592 |
s4o.print(","); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
593 |
current_action->accept(*this); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
594 |
s4o.print(",0);\n"); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
595 |
} |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
596 |
|
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
597 |
else { |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
598 |
s4o.print(SET_VAR); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
599 |
s4o.print("("); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
600 |
print_action_argument(current_action, "state", true); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
601 |
s4o.print(",1);\n"); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
602 |
} |
70 | 603 |
} |
627
e7caa7d32ef5
Adding support for P0 and P1 qualifiers and fixing code generated for SL qualifier
Laurent Bessard
parents:
594
diff
changeset
|
604 |
if (strcmp(qualifier, "S") == 0 || strcmp(qualifier, "SL") == 0) { |
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
605 |
print_action_argument(current_action, "set"); |
70 | 606 |
s4o.print(" = 1;\n"); |
607 |
} |
|
608 |
if (strcmp(qualifier, "R") == 0) { |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
609 |
print_action_argument(current_action, "reset"); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
610 |
s4o.print(" = 1;\n"); |
70 | 611 |
} |
612 |
if (strcmp(qualifier, "SD") == 0 || strcmp(qualifier, "DS") == 0 || |
|
613 |
strcmp(qualifier, "SL") == 0) { |
|
614 |
if (strcmp(qualifier, "SL") == 0) { |
|
703
48d106ffc2ca
Fix indentation in SFC SL qualifier code generated
Laurent Bessard
parents:
702
diff
changeset
|
615 |
s4o.print(s4o.indent_spaces); |
48d106ffc2ca
Fix indentation in SFC SL qualifier code generated
Laurent Bessard
parents:
702
diff
changeset
|
616 |
print_action_argument(current_action, "reset_remaining_time"); |
70 | 617 |
} |
618 |
else { |
|
619 |
print_action_argument(current_action, "set_remaining_time"); |
|
620 |
} |
|
621 |
s4o.print(" = "); |
|
622 |
symbol->action_time->accept(*this); |
|
623 |
s4o.print(";\n"); |
|
624 |
} |
|
625 |
s4o.indent_left(); |
|
561 | 626 |
s4o.print(s4o.indent_spaces + "}\n"); |
70 | 627 |
if (strcmp(qualifier, "DS") == 0) { |
704
1adc8df05d2b
Fix definition of BCD to ANY_UINT and ANY_UINT to BCD conversion standard functions
Laurent Bessard
parents:
703
diff
changeset
|
628 |
s4o.print(s4o.indent_spaces + "if (desactivated) {\n"); |
70 | 629 |
s4o.indent_right(); |
630 |
s4o.print(s4o.indent_spaces); |
|
631 |
print_action_argument(current_action, "set_remaining_time"); |
|
632 |
s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); |
|
561 | 633 |
s4o.indent_left(); |
634 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
70 | 635 |
} |
636 |
} |
|
637 |
break; |
|
638 |
default: |
|
639 |
break; |
|
640 |
} |
|
641 |
return NULL; |
|
642 |
} |
|
643 |
||
644 |
void *visit(qualifier_c *symbol) { |
|
645 |
return (void *)symbol->value; |
|
646 |
} |
|
647 |
||
648 |
void *visit(timed_qualifier_c *symbol) { |
|
649 |
return (void *)symbol->value; |
|
650 |
} |
|
651 |
||
652 |
}; /* generate_c_sfc_actiondecl_c */ |
|
653 |
||
654 |
||
655 |
/***********************************************************************/ |
|
656 |
/***********************************************************************/ |
|
657 |
/***********************************************************************/ |
|
658 |
/***********************************************************************/ |
|
659 |
||
660 |
class generate_c_sfc_c: public generate_c_typedecl_c { |
|
661 |
||
662 |
private: |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
663 |
std::list<VARIABLE> variable_list; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
664 |
|
70 | 665 |
generate_c_sfc_elements_c *generate_c_sfc_elements; |
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
666 |
search_var_instance_decl_c *search_var_instance_decl; |
70 | 667 |
|
668 |
public: |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
669 |
generate_c_sfc_c(stage4out_c *s4o_ptr, symbol_c *name, symbol_c *scope, const char *variable_prefix = NULL) |
70 | 670 |
: generate_c_typedecl_c(s4o_ptr) { |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
671 |
generate_c_sfc_elements = new generate_c_sfc_elements_c(s4o_ptr, name, scope, variable_prefix); |
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
672 |
search_var_instance_decl = new search_var_instance_decl_c(scope); |
70 | 673 |
this->set_variable_prefix(variable_prefix); |
674 |
} |
|
675 |
||
676 |
virtual ~generate_c_sfc_c(void) { |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
677 |
variable_list.clear(); |
70 | 678 |
delete generate_c_sfc_elements; |
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
679 |
delete search_var_instance_decl; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
680 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
681 |
|
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
682 |
bool is_variable(symbol_c *symbol) { |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
683 |
/* we try to find the variable instance declaration, to determine if symbol is variable... */ |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
684 |
symbol_c *var_decl = search_var_instance_decl->get_decl(symbol); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
685 |
|
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
686 |
return var_decl != NULL; |
70 | 687 |
} |
688 |
||
689 |
/*********************************************/ |
|
690 |
/* B.1.6 Sequential function chart elements */ |
|
691 |
/*********************************************/ |
|
119
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
692 |
|
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
693 |
void *visit(sequential_function_chart_c *symbol) { |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
694 |
int i; |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
695 |
|
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
696 |
generate_c_sfc_elements->reset_transition_number(); |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
697 |
for(i = 0; i < symbol->n; i++) { |
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
698 |
symbol->elements[i]->accept(*this); |
119
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
699 |
generate_c_sfc_elements->generate(symbol->elements[i], generate_c_sfc_elements_c::transitionlist_sg); |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
700 |
} |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
701 |
|
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
702 |
s4o.print(s4o.indent_spaces +"INT i;\n"); |
125
7ec16536bc87
Modifying time qualifier in SFC to take real time enlapsed instead of theoric period time
lbessard
parents:
121
diff
changeset
|
703 |
s4o.print(s4o.indent_spaces +"TIME elapsed_time, current_time;\n\n"); |
7ec16536bc87
Modifying time qualifier in SFC to take real time enlapsed instead of theoric period time
lbessard
parents:
121
diff
changeset
|
704 |
|
229 | 705 |
/* generate elapsed_time initializations */ |
125
7ec16536bc87
Modifying time qualifier in SFC to take real time enlapsed instead of theoric period time
lbessard
parents:
121
diff
changeset
|
706 |
s4o.print(s4o.indent_spaces + "// Calculate elapsed_time\n"); |
7ec16536bc87
Modifying time qualifier in SFC to take real time enlapsed instead of theoric period time
lbessard
parents:
121
diff
changeset
|
707 |
s4o.print(s4o.indent_spaces +"current_time = __CURRENT_TIME;\n"); |
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
708 |
// s4o.print(s4o.indent_spaces +"elapsed_time = __time_sub(__BOOL_LITERAL(TRUE), NULL, current_time, "); |
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
709 |
// s4o.print(s4o.indent_spaces +"elapsed_time = SUB_TIME(__BOOL_LITERAL(TRUE), NULL, current_time, "); |
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
710 |
s4o.print(s4o.indent_spaces +"elapsed_time = __time_sub(current_time, "); |
125
7ec16536bc87
Modifying time qualifier in SFC to take real time enlapsed instead of theoric period time
lbessard
parents:
121
diff
changeset
|
711 |
print_variable_prefix(); |
141 | 712 |
s4o.print("__lasttick_time);\n"); |
713 |
s4o.print(s4o.indent_spaces); |
|
714 |
print_variable_prefix(); |
|
715 |
s4o.print("__lasttick_time = current_time;\n"); |
|
119
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
716 |
|
229 | 717 |
/* generate transition initializations */ |
718 |
s4o.print(s4o.indent_spaces + "// Transitions initialization\n"); |
|
719 |
s4o.print(s4o.indent_spaces + "if (__DEBUG) {\n"); |
|
720 |
s4o.indent_right(); |
|
721 |
s4o.print(s4o.indent_spaces + "for (i = 0; i < "); |
|
722 |
print_variable_prefix(); |
|
723 |
s4o.print("__nb_transitions; i++) {\n"); |
|
724 |
s4o.indent_right(); |
|
725 |
s4o.print(s4o.indent_spaces); |
|
726 |
print_variable_prefix(); |
|
727 |
s4o.print("__transition_list[i] = "); |
|
728 |
print_variable_prefix(); |
|
729 |
s4o.print("__debug_transition_list[i];\n"); |
|
730 |
s4o.indent_left(); |
|
731 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
732 |
s4o.indent_left(); |
|
733 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
734 |
||
735 |
/* generate step initializations */ |
|
736 |
s4o.print(s4o.indent_spaces + "// Steps initialization\n"); |
|
70 | 737 |
s4o.print(s4o.indent_spaces + "for (i = 0; i < "); |
738 |
print_variable_prefix(); |
|
141 | 739 |
s4o.print("__nb_steps; i++) {\n"); |
740 |
s4o.indent_right(); |
|
741 |
s4o.print(s4o.indent_spaces); |
|
742 |
print_variable_prefix(); |
|
743 |
s4o.print("__step_list[i].prev_state = "); |
|
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
744 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
745 |
s4o.print("("); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
746 |
print_variable_prefix(); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
747 |
s4o.print("__step_list[i].state);\n"); |
70 | 748 |
s4o.print(s4o.indent_spaces + "if ("); |
217
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
749 |
s4o.print(GET_VAR); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
750 |
s4o.print("("); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
751 |
print_variable_prefix(); |
f5dfadf5de54
Adding support for declare, init, get and set macros
laurent
parents:
155
diff
changeset
|
752 |
s4o.print("__step_list[i].state)) {\n"); |
141 | 753 |
s4o.indent_right(); |
754 |
s4o.print(s4o.indent_spaces); |
|
755 |
print_variable_prefix(); |
|
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
756 |
// s4o.print("__step_list[i].elapsed_time = __time_add(__BOOL_LITERAL(TRUE), NULL, "); |
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
757 |
// s4o.print("__step_list[i].elapsed_time = ADD_TIME(__BOOL_LITERAL(TRUE), NULL, "); |
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
758 |
s4o.print("__step_list[i].elapsed_time = __time_add("); |
141 | 759 |
print_variable_prefix(); |
760 |
s4o.print("__step_list[i].elapsed_time, elapsed_time);\n"); |
|
70 | 761 |
s4o.indent_left(); |
762 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
763 |
s4o.indent_left(); |
|
764 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
765 |
||
229 | 766 |
/* generate action initializations */ |
767 |
s4o.print(s4o.indent_spaces + "// Actions initialization\n"); |
|
70 | 768 |
s4o.print(s4o.indent_spaces + "for (i = 0; i < "); |
769 |
print_variable_prefix(); |
|
141 | 770 |
s4o.print("__nb_actions; i++) {\n"); |
771 |
s4o.indent_right(); |
|
772 |
s4o.print(s4o.indent_spaces); |
|
628
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
773 |
s4o.print(SET_VAR); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
774 |
s4o.print("("); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
775 |
print_variable_prefix(); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
776 |
s4o.print(",__action_list[i].state,0);\n"); |
141 | 777 |
s4o.print(s4o.indent_spaces); |
778 |
print_variable_prefix(); |
|
779 |
s4o.print("__action_list[i].set = 0;\n"); |
|
780 |
s4o.print(s4o.indent_spaces); |
|
781 |
print_variable_prefix(); |
|
782 |
s4o.print("__action_list[i].reset = 0;\n"); |
|
70 | 783 |
s4o.print(s4o.indent_spaces + "if ("); |
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
784 |
s4o.print("__time_cmp("); |
149 | 785 |
print_variable_prefix(); |
786 |
s4o.print("__action_list[i].set_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0)) > 0) {\n"); |
|
787 |
s4o.indent_right(); |
|
788 |
s4o.print(s4o.indent_spaces); |
|
789 |
print_variable_prefix(); |
|
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
790 |
// s4o.print("__action_list[i].set_remaining_time = __time_sub(__BOOL_LITERAL(TRUE), NULL, "); |
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
791 |
// s4o.print("__action_list[i].set_remaining_time = SUB_TIME(__BOOL_LITERAL(TRUE), NULL, "); |
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
792 |
s4o.print("__action_list[i].set_remaining_time = __time_sub("); |
141 | 793 |
print_variable_prefix(); |
794 |
s4o.print("__action_list[i].set_remaining_time, elapsed_time);\n"); |
|
70 | 795 |
s4o.print(s4o.indent_spaces + "if ("); |
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
796 |
s4o.print("__time_cmp("); |
149 | 797 |
print_variable_prefix(); |
798 |
s4o.print("__action_list[i].set_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0)) <= 0) {\n"); |
|
141 | 799 |
s4o.indent_right(); |
800 |
s4o.print(s4o.indent_spaces); |
|
801 |
print_variable_prefix(); |
|
802 |
s4o.print("__action_list[i].set_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); |
|
803 |
s4o.print(s4o.indent_spaces); |
|
804 |
print_variable_prefix(); |
|
805 |
s4o.print("__action_list[i].set = 1;\n"); |
|
70 | 806 |
s4o.indent_left(); |
807 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
808 |
s4o.indent_left(); |
|
809 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
810 |
s4o.print(s4o.indent_spaces + "if ("); |
|
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
811 |
s4o.print("__time_cmp("); |
149 | 812 |
print_variable_prefix(); |
813 |
s4o.print("__action_list[i].reset_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0)) > 0) {\n"); |
|
814 |
s4o.indent_right(); |
|
815 |
s4o.print(s4o.indent_spaces); |
|
816 |
print_variable_prefix(); |
|
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
817 |
// s4o.print("__action_list[i].reset_remaining_time = __time_sub(__BOOL_LITERAL(TRUE), NULL, "); |
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
818 |
// s4o.print("__action_list[i].reset_remaining_time = SUB_TIME(__BOOL_LITERAL(TRUE), NULL, "); |
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
819 |
s4o.print("__action_list[i].reset_remaining_time = __time_sub("); |
141 | 820 |
print_variable_prefix(); |
821 |
s4o.print("__action_list[i].reset_remaining_time, elapsed_time);\n"); |
|
70 | 822 |
s4o.print(s4o.indent_spaces + "if ("); |
350
2c3c4dc34979
Support for semantic verification of calls to standard functions.
Mario de Sousa <msousa@fe.up.pt>
parents:
279
diff
changeset
|
823 |
s4o.print("__time_cmp("); |
149 | 824 |
print_variable_prefix(); |
825 |
s4o.print("__action_list[i].reset_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0)) <= 0) {\n"); |
|
141 | 826 |
s4o.indent_right(); |
827 |
s4o.print(s4o.indent_spaces); |
|
828 |
print_variable_prefix(); |
|
829 |
s4o.print("__action_list[i].reset_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); |
|
830 |
s4o.print(s4o.indent_spaces); |
|
831 |
print_variable_prefix(); |
|
832 |
s4o.print("__action_list[i].reset = 1;\n"); |
|
70 | 833 |
s4o.indent_left(); |
834 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
835 |
s4o.indent_left(); |
|
836 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
837 |
s4o.indent_left(); |
|
838 |
s4o.print(s4o.indent_spaces + "}\n\n"); |
|
839 |
||
840 |
/* generate transition tests */ |
|
841 |
s4o.print(s4o.indent_spaces + "// Transitions fire test\n"); |
|
119
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
842 |
generate_c_sfc_elements->generate((symbol_c *)symbol, generate_c_sfc_elements_c::transitiontest_sg); |
70 | 843 |
s4o.print("\n"); |
844 |
||
845 |
/* generate transition reset steps */ |
|
846 |
s4o.print(s4o.indent_spaces + "// Transitions reset steps\n"); |
|
847 |
generate_c_sfc_elements->reset_transition_number(); |
|
119
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
848 |
for(i = 0; i < symbol->n; i++) { |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
849 |
generate_c_sfc_elements->generate(symbol->elements[i], generate_c_sfc_elements_c::stepreset_sg); |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
850 |
} |
70 | 851 |
s4o.print("\n"); |
852 |
||
853 |
/* generate transition set steps */ |
|
854 |
s4o.print(s4o.indent_spaces + "// Transitions set steps\n"); |
|
855 |
generate_c_sfc_elements->reset_transition_number(); |
|
119
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
856 |
for(i = 0; i < symbol->n; i++) { |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
857 |
generate_c_sfc_elements->generate(symbol->elements[i], generate_c_sfc_elements_c::stepset_sg); |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
858 |
} |
70 | 859 |
s4o.print("\n"); |
860 |
||
119
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
861 |
/* generate step association */ |
70 | 862 |
s4o.print(s4o.indent_spaces + "// Steps association\n"); |
119
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
863 |
for(i = 0; i < symbol->n; i++) { |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
864 |
generate_c_sfc_elements->generate(symbol->elements[i], generate_c_sfc_elements_c::actionassociation_sg); |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
865 |
} |
70 | 866 |
s4o.print("\n"); |
867 |
||
868 |
/* generate action state evaluation */ |
|
869 |
s4o.print(s4o.indent_spaces + "// Actions state evaluation\n"); |
|
870 |
s4o.print(s4o.indent_spaces + "for (i = 0; i < "); |
|
871 |
print_variable_prefix(); |
|
141 | 872 |
s4o.print("__nb_actions; i++) {\n"); |
70 | 873 |
s4o.indent_right(); |
874 |
s4o.print(s4o.indent_spaces + "if ("); |
|
875 |
print_variable_prefix(); |
|
141 | 876 |
s4o.print("__action_list[i].set) {\n"); |
877 |
s4o.indent_right(); |
|
878 |
s4o.print(s4o.indent_spaces); |
|
879 |
print_variable_prefix(); |
|
880 |
s4o.print("__action_list[i].stored = 1;\n"); |
|
70 | 881 |
s4o.indent_left(); |
882 |
s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces + "if ("); |
|
883 |
print_variable_prefix(); |
|
141 | 884 |
s4o.print("__action_list[i].reset) {\n"); |
885 |
s4o.indent_right(); |
|
886 |
s4o.print(s4o.indent_spaces); |
|
887 |
print_variable_prefix(); |
|
888 |
s4o.print("__action_list[i].set_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n" + s4o.indent_spaces); |
|
889 |
print_variable_prefix(); |
|
890 |
s4o.print("__action_list[i].reset_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n" + s4o.indent_spaces); |
|
891 |
print_variable_prefix(); |
|
892 |
s4o.print("__action_list[i].stored = 0;\n"); |
|
70 | 893 |
s4o.indent_left(); |
894 |
s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces); |
|
628
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
895 |
s4o.print(SET_VAR); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
896 |
s4o.print("("); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
897 |
print_variable_prefix(); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
898 |
s4o.print(",__action_list[i].state,"); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
899 |
s4o.print(GET_VAR); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
900 |
s4o.print("("); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
901 |
print_variable_prefix(); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
902 |
s4o.print("__action_list[i].state) | "); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
903 |
print_variable_prefix(); |
fe0d516fe291
Fix bug in SFC generated code. Action state was declared in the list of variables to debug, but wasn't stored using structure with flags. This error had side effects that makes Beremiz debug crash.
Laurent Bessard
parents:
627
diff
changeset
|
904 |
s4o.print("__action_list[i].stored);\n"); |
70 | 905 |
s4o.indent_left(); |
906 |
s4o.print(s4o.indent_spaces + "}\n\n"); |
|
907 |
||
908 |
/* generate action execution */ |
|
909 |
s4o.print(s4o.indent_spaces + "// Actions execution\n"); |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
910 |
{ |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
911 |
std::list<VARIABLE>::iterator pt; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
912 |
for(pt = variable_list.begin(); pt != variable_list.end(); pt++) { |
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
913 |
|
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
914 |
if (is_variable(pt->symbol)) { |
417
d48f53715f77
Re-write of stage3 code (done by Manuele and I), re-write of search_varfb_instance_type_c (done by myself), and several other bug fixes.
Mario de Sousa <msousa@fe.up.pt>
parents:
392
diff
changeset
|
915 |
unsigned int vartype = search_var_instance_decl->get_vartype(pt->symbol); |
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
916 |
|
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
917 |
s4o.print(s4o.indent_spaces + "if ("); |
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
918 |
print_variable_prefix(); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
919 |
s4o.print("__action_list["); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
920 |
s4o.print(SFC_STEP_ACTION_PREFIX); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
921 |
pt->symbol->accept(*this); |
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
922 |
s4o.print("].reset) {\n"); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
923 |
s4o.indent_right(); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
924 |
s4o.print(s4o.indent_spaces); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
925 |
if (vartype == search_var_instance_decl_c::external_vt) |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
926 |
s4o.print(SET_EXTERNAL); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
927 |
else if (vartype == search_var_instance_decl_c::located_vt) |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
928 |
s4o.print(SET_LOCATED); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
929 |
else |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
930 |
s4o.print(SET_VAR); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
931 |
s4o.print("("); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
932 |
print_variable_prefix(); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
933 |
s4o.print(","); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
934 |
pt->symbol->accept(*this); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
935 |
s4o.print(",0);\n"); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
936 |
s4o.indent_left(); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
937 |
s4o.print(s4o.indent_spaces + "}\n"); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
938 |
s4o.print(s4o.indent_spaces + "else if ("); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
939 |
print_variable_prefix(); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
940 |
s4o.print("__action_list["); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
941 |
s4o.print(SFC_STEP_ACTION_PREFIX); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
942 |
pt->symbol->accept(*this); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
943 |
s4o.print("].set) {\n"); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
944 |
s4o.indent_right(); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
945 |
s4o.print(s4o.indent_spaces); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
946 |
if (vartype == search_var_instance_decl_c::external_vt) |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
947 |
s4o.print(SET_EXTERNAL); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
948 |
else if (vartype == search_var_instance_decl_c::located_vt) |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
949 |
s4o.print(SET_LOCATED); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
950 |
else |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
951 |
s4o.print(SET_VAR); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
952 |
s4o.print("("); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
953 |
print_variable_prefix(); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
954 |
s4o.print(","); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
955 |
pt->symbol->accept(*this); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
956 |
s4o.print(",1);\n"); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
957 |
s4o.indent_left(); |
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
958 |
s4o.print(s4o.indent_spaces + "}\n"); |
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
959 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
960 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
961 |
} |
119
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
962 |
for(i = 0; i < symbol->n; i++) { |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
963 |
generate_c_sfc_elements->generate(symbol->elements[i], generate_c_sfc_elements_c::actionbody_sg); |
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
964 |
} |
70 | 965 |
s4o.print("\n"); |
966 |
||
967 |
return NULL; |
|
968 |
} |
|
119
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
111
diff
changeset
|
969 |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
970 |
void *visit(initial_step_c *symbol) { |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
971 |
symbol->action_association_list->accept(*this); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
972 |
return NULL; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
973 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
974 |
|
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
975 |
void *visit(step_c *symbol) { |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
976 |
symbol->action_association_list->accept(*this); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
977 |
return NULL; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
978 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
979 |
|
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
980 |
void *visit(action_association_c *symbol) { |
629
06abc9867095
Fix generated code when using boolean variable as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
981 |
if (is_variable(symbol->action_name)) { |
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
982 |
std::list<VARIABLE>::iterator pt; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
983 |
for(pt = variable_list.begin(); pt != variable_list.end(); pt++) { |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
984 |
if (!compare_identifiers(pt->symbol, symbol->action_name)) |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
985 |
return NULL; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
986 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
987 |
VARIABLE *variable; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
988 |
variable = new VARIABLE; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
989 |
variable->symbol = (identifier_c*)(symbol->action_name); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
990 |
variable_list.push_back(*variable); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
991 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
992 |
return NULL; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
993 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
994 |
|
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
995 |
void *visit(transition_c *symbol) { |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
996 |
return NULL; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
997 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
998 |
|
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
999 |
void *visit(action_c *symbol) { |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
1000 |
return NULL; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
1001 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
1002 |
|
70 | 1003 |
void generate(sequential_function_chart_c *sfc) { |
1004 |
sfc->accept(*this); |
|
1005 |
} |
|
1006 |
||
1007 |
}; /* generate_c_sfc_c */ |