author | Edouard Tisserant |
Wed, 28 Nov 2012 12:00:38 +0900 | |
changeset 710 | e9bb0ed80471 |
parent 630 | 5250fbf20999 |
child 861 | 443e8243f289 |
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 |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
3 |
* |
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 |
c0453b7f99df
Re-generated std lib related code, with updated headers, updated all forgotten headers
Edouard Tisserant
parents:
244
diff
changeset
|
6 |
* |
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 |
||
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
25 |
typedef struct |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
26 |
{ |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
27 |
identifier_c *symbol; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
28 |
} VARIABLE; |
70 | 29 |
|
30 |
/***********************************************************************/ |
|
31 |
/***********************************************************************/ |
|
32 |
/***********************************************************************/ |
|
33 |
/***********************************************************************/ |
|
34 |
||
35 |
class generate_c_sfcdecl_c: protected generate_c_typedecl_c { |
|
36 |
||
37 |
public: |
|
38 |
typedef enum { |
|
39 |
sfcdecl_sd, |
|
40 |
sfcinit_sd, |
|
41 |
stepcount_sd, |
|
42 |
stepdef_sd, |
|
43 |
stepundef_sd, |
|
44 |
actiondef_sd, |
|
45 |
actionundef_sd, |
|
229 | 46 |
actioncount_sd, |
47 |
transitioncount_sd |
|
70 | 48 |
} sfcdeclaration_t; |
49 |
||
50 |
private: |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
51 |
int step_number; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
52 |
int action_number; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
53 |
int transition_number; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
54 |
std::list<VARIABLE> variable_list; |
70 | 55 |
|
56 |
sfcdeclaration_t wanted_sfcdeclaration; |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
57 |
|
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
58 |
search_var_instance_decl_c *search_var_instance_decl; |
70 | 59 |
|
60 |
public: |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
61 |
generate_c_sfcdecl_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) |
70 | 62 |
: generate_c_typedecl_c(s4o_ptr) { |
63 |
this->set_variable_prefix(variable_prefix); |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
64 |
search_var_instance_decl = new search_var_instance_decl_c(scope); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
65 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
66 |
~generate_c_sfcdecl_c(void) { |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
67 |
variable_list.clear(); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
68 |
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
|
69 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
70 |
|
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
71 |
void generate(symbol_c *symbol, sfcdeclaration_t declaration_type) { |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
72 |
wanted_sfcdeclaration = declaration_type; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
73 |
|
70 | 74 |
symbol->accept(*this); |
75 |
} |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
76 |
|
70 | 77 |
/*********************************************/ |
78 |
/* B.1.6 Sequential function chart elements */ |
|
79 |
/*********************************************/ |
|
80 |
||
81 |
void *visit(sequential_function_chart_c *symbol) { |
|
82 |
step_number = 0; |
|
83 |
action_number = 0; |
|
84 |
transition_number = 0; |
|
85 |
switch (wanted_sfcdeclaration) { |
|
86 |
case sfcdecl_sd: |
|
87 |
for(int i = 0; i < symbol->n; i++) |
|
88 |
symbol->elements[i]->accept(*this); |
|
89 |
||
90 |
/* steps table declaration */ |
|
141 | 91 |
s4o.print(s4o.indent_spaces + "STEP __step_list["); |
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
92 |
s4o.print(step_number); |
70 | 93 |
s4o.print("];\n"); |
141 | 94 |
s4o.print(s4o.indent_spaces + "UINT __nb_steps;\n"); |
70 | 95 |
|
96 |
/* actions table declaration */ |
|
141 | 97 |
s4o.print(s4o.indent_spaces + "ACTION __action_list["); |
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
98 |
s4o.print(action_number); |
70 | 99 |
s4o.print("];\n"); |
141 | 100 |
s4o.print(s4o.indent_spaces + "UINT __nb_actions;\n"); |
70 | 101 |
|
102 |
/* transitions table declaration */ |
|
221
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
160
diff
changeset
|
103 |
s4o.print(s4o.indent_spaces + "__IEC_BOOL_t __transition_list["); |
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
104 |
s4o.print(transition_number); |
70 | 105 |
s4o.print("];\n"); |
106 |
||
141 | 107 |
/* transitions debug table declaration */ |
221
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
160
diff
changeset
|
108 |
s4o.print(s4o.indent_spaces + "__IEC_BOOL_t __debug_transition_list["); |
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
109 |
s4o.print(transition_number); |
141 | 110 |
s4o.print("];\n"); |
229 | 111 |
s4o.print(s4o.indent_spaces + "UINT __nb_transitions;\n"); |
141 | 112 |
|
125
7ec16536bc87
Modifying time qualifier in SFC to take real time enlapsed instead of theoric period time
lbessard
parents:
120
diff
changeset
|
113 |
/* last_ticktime declaration */ |
141 | 114 |
s4o.print(s4o.indent_spaces + "TIME __lasttick_time;\n"); |
70 | 115 |
break; |
116 |
case sfcinit_sd: |
|
117 |
s4o.print(s4o.indent_spaces); |
|
118 |
s4o.print("UINT i;\n"); |
|
119 |
||
120 |
/* steps table count */ |
|
121 |
wanted_sfcdeclaration = stepcount_sd; |
|
122 |
for(int i = 0; i < symbol->n; i++) |
|
123 |
symbol->elements[i]->accept(*this); |
|
124 |
s4o.print(s4o.indent_spaces); |
|
125 |
print_variable_prefix(); |
|
141 | 126 |
s4o.print("__nb_steps = "); |
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
127 |
s4o.print(step_number); |
70 | 128 |
s4o.print(";\n"); |
129 |
step_number = 0; |
|
130 |
wanted_sfcdeclaration = sfcinit_sd; |
|
131 |
||
132 |
/* steps table initialisation */ |
|
401
7f052bd3508a
Fix STEP and ACTION structure initialization value in SFC
laurent
parents:
392
diff
changeset
|
133 |
s4o.print(s4o.indent_spaces + "static const STEP temp_step = {{0, 0}, 0, {0, 0}};\n"); |
70 | 134 |
s4o.print(s4o.indent_spaces + "for(i = 0; i < "); |
135 |
print_variable_prefix(); |
|
141 | 136 |
s4o.print("__nb_steps; i++) {\n"); |
70 | 137 |
s4o.indent_right(); |
138 |
s4o.print(s4o.indent_spaces); |
|
139 |
print_variable_prefix(); |
|
141 | 140 |
s4o.print("__step_list[i] = temp_step;\n"); |
70 | 141 |
s4o.indent_left(); |
142 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
143 |
for(int i = 0; i < symbol->n; i++) |
|
144 |
symbol->elements[i]->accept(*this); |
|
145 |
||
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
146 |
/* actions table count */ |
70 | 147 |
wanted_sfcdeclaration = actioncount_sd; |
148 |
for(int i = 0; i < symbol->n; i++) |
|
149 |
symbol->elements[i]->accept(*this); |
|
150 |
s4o.print(s4o.indent_spaces); |
|
151 |
print_variable_prefix(); |
|
141 | 152 |
s4o.print("__nb_actions = "); |
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
153 |
s4o.print(action_number); |
70 | 154 |
s4o.print(";\n"); |
155 |
action_number = 0; |
|
156 |
wanted_sfcdeclaration = sfcinit_sd; |
|
157 |
||
158 |
/* actions table initialisation */ |
|
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:
594
diff
changeset
|
159 |
s4o.print(s4o.indent_spaces + "static const ACTION temp_action = {0, {0, 0}, 0, 0, {0, 0}, {0, 0}};\n"); |
70 | 160 |
s4o.print(s4o.indent_spaces + "for(i = 0; i < "); |
161 |
print_variable_prefix(); |
|
141 | 162 |
s4o.print("__nb_actions; i++) {\n"); |
70 | 163 |
s4o.indent_right(); |
164 |
s4o.print(s4o.indent_spaces); |
|
165 |
print_variable_prefix(); |
|
141 | 166 |
s4o.print("__action_list[i] = temp_action;\n"); |
70 | 167 |
s4o.indent_left(); |
168 |
s4o.print(s4o.indent_spaces + "}\n"); |
|
125
7ec16536bc87
Modifying time qualifier in SFC to take real time enlapsed instead of theoric period time
lbessard
parents:
120
diff
changeset
|
169 |
|
229 | 170 |
/* transitions table count */ |
171 |
wanted_sfcdeclaration = transitioncount_sd; |
|
172 |
for(int i = 0; i < symbol->n; i++) |
|
173 |
symbol->elements[i]->accept(*this); |
|
174 |
s4o.print(s4o.indent_spaces); |
|
175 |
print_variable_prefix(); |
|
176 |
s4o.print("__nb_transitions = "); |
|
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
177 |
s4o.print(transition_number); |
229 | 178 |
s4o.print(";\n"); |
179 |
transition_number = 0; |
|
180 |
wanted_sfcdeclaration = sfcinit_sd; |
|
181 |
||
125
7ec16536bc87
Modifying time qualifier in SFC to take real time enlapsed instead of theoric period time
lbessard
parents:
120
diff
changeset
|
182 |
/* last_ticktime initialisation */ |
160 | 183 |
s4o.print(s4o.indent_spaces); |
125
7ec16536bc87
Modifying time qualifier in SFC to take real time enlapsed instead of theoric period time
lbessard
parents:
120
diff
changeset
|
184 |
print_variable_prefix(); |
141 | 185 |
s4o.print("__lasttick_time = __CURRENT_TIME;\n"); |
70 | 186 |
break; |
187 |
case stepdef_sd: |
|
188 |
s4o.print("// Steps definitions\n"); |
|
189 |
for(int i = 0; i < symbol->n; i++) |
|
190 |
symbol->elements[i]->accept(*this); |
|
191 |
s4o.print("\n"); |
|
192 |
break; |
|
193 |
case actiondef_sd: |
|
194 |
s4o.print("// Actions definitions\n"); |
|
630
5250fbf20999
Fix bug SFC action index declarations were different in POUS.c and VARIABLES.csv when boolean variables are used as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
195 |
for(int i = 0; i < symbol->n; i++) |
5250fbf20999
Fix bug SFC action index declarations were different in POUS.c and VARIABLES.csv when boolean variables are used as action name in step action association
Laurent Bessard
parents:
628
diff
changeset
|
196 |
symbol->elements[i]->accept(*this); |
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
197 |
{ |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
198 |
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
|
199 |
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
|
200 |
s4o.print("#define "); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
201 |
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
|
202 |
pt->symbol->accept(*this); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
203 |
s4o.print(" "); |
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
204 |
s4o.print(action_number); |
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
205 |
s4o.print("\n"); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
206 |
action_number++; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
207 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
208 |
} |
70 | 209 |
s4o.print("\n"); |
210 |
break; |
|
211 |
case stepundef_sd: |
|
212 |
s4o.print("// Steps undefinitions\n"); |
|
213 |
for(int i = 0; i < symbol->n; i++) |
|
214 |
symbol->elements[i]->accept(*this); |
|
215 |
s4o.print("\n"); |
|
216 |
break; |
|
217 |
case actionundef_sd: |
|
218 |
s4o.print("// Actions undefinitions\n"); |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
219 |
{ |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
220 |
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
|
221 |
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
|
222 |
s4o.print("#undef "); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
223 |
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
|
224 |
pt->symbol->accept(*this); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
225 |
s4o.print("\n"); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
226 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
227 |
} |
70 | 228 |
for(int i = 0; i < symbol->n; i++) |
229 |
symbol->elements[i]->accept(*this); |
|
230 |
s4o.print("\n"); |
|
231 |
break; |
|
232 |
default: |
|
233 |
break; |
|
234 |
} |
|
235 |
return NULL; |
|
236 |
} |
|
237 |
||
238 |
void *visit(initial_step_c *symbol) { |
|
239 |
switch (wanted_sfcdeclaration) { |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
240 |
case actioncount_sd: |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
241 |
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
|
242 |
break; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
243 |
case sfcdecl_sd: |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
244 |
symbol->action_association_list->accept(*this); |
70 | 245 |
case stepcount_sd: |
246 |
step_number++; |
|
247 |
break; |
|
248 |
case sfcinit_sd: |
|
249 |
s4o.print(s4o.indent_spaces); |
|
221
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
160
diff
changeset
|
250 |
s4o.print(SET_VAR); |
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
160
diff
changeset
|
251 |
s4o.print("("); |
70 | 252 |
print_variable_prefix(); |
392
9b88b8b6bccd
Fixing generated code for global variables. Adding support for defining global variables with complex type
laurent
parents:
279
diff
changeset
|
253 |
s4o.print(",__step_list["); |
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
254 |
s4o.print(step_number); |
221
c6aed7e5f070
Adding support for flags on Function Block variables for marking which variable must be debugged, retained or is forced
laurent
parents:
160
diff
changeset
|
255 |
s4o.print("].state,1);\n"); |
70 | 256 |
step_number++; |
257 |
break; |
|
258 |
case stepdef_sd: |
|
259 |
s4o.print("#define "); |
|
260 |
s4o.print(SFC_STEP_ACTION_PREFIX); |
|
261 |
symbol->step_name->accept(*this); |
|
262 |
s4o.print(" "); |
|
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
263 |
s4o.print(step_number); |
70 | 264 |
s4o.print("\n"); |
265 |
step_number++; |
|
266 |
break; |
|
267 |
case stepundef_sd: |
|
268 |
s4o.print("#undef "); |
|
269 |
s4o.print(SFC_STEP_ACTION_PREFIX); |
|
270 |
symbol->step_name->accept(*this); |
|
271 |
s4o.print("\n"); |
|
272 |
break; |
|
273 |
default: |
|
274 |
break; |
|
275 |
} |
|
276 |
return NULL; |
|
277 |
} |
|
278 |
||
279 |
void *visit(step_c *symbol) { |
|
280 |
switch (wanted_sfcdeclaration) { |
|
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
281 |
case actioncount_sd: |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
282 |
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
|
283 |
break; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
284 |
case sfcdecl_sd: |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
285 |
symbol->action_association_list->accept(*this); |
70 | 286 |
case stepcount_sd: |
119
4cbf71106b66
Bug with C code generation for SFC when more than one sfc_network in one sequential_function_chart fixed
lbessard
parents:
116
diff
changeset
|
287 |
case sfcinit_sd: |
70 | 288 |
step_number++; |
289 |
break; |
|
290 |
case stepdef_sd: |
|
291 |
s4o.print("#define "); |
|
292 |
s4o.print(SFC_STEP_ACTION_PREFIX); |
|
293 |
symbol->step_name->accept(*this); |
|
294 |
s4o.print(" "); |
|
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
295 |
s4o.print(step_number); |
70 | 296 |
s4o.print("\n"); |
297 |
step_number++; |
|
298 |
break; |
|
299 |
case stepundef_sd: |
|
300 |
s4o.print("#undef "); |
|
301 |
s4o.print(SFC_STEP_ACTION_PREFIX); |
|
302 |
symbol->step_name->accept(*this); |
|
303 |
s4o.print("\n"); |
|
304 |
break; |
|
305 |
default: |
|
306 |
break; |
|
307 |
} |
|
308 |
return NULL; |
|
309 |
} |
|
310 |
||
244
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
311 |
void *visit(action_association_c *symbol) { |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
312 |
/* 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
|
313 |
symbol_c *var_decl = search_var_instance_decl->get_decl(symbol->action_name); |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
314 |
|
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
315 |
if (var_decl != NULL) { |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
316 |
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
|
317 |
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
|
318 |
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
|
319 |
return NULL; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
320 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
321 |
VARIABLE *variable; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
322 |
variable = new VARIABLE; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
323 |
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
|
324 |
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
|
325 |
action_number++; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
326 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
327 |
return NULL; |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
328 |
} |
3a478229db8b
Adding support for generating code for variable in step action association instead of action
laurent
parents:
229
diff
changeset
|
329 |
|
70 | 330 |
void *visit(transition_c *symbol) { |
331 |
switch (wanted_sfcdeclaration) { |
|
332 |
case sfcdecl_sd: |
|
229 | 333 |
case transitioncount_sd: |
70 | 334 |
transition_number++; |
335 |
break; |
|
336 |
default: |
|
337 |
break; |
|
338 |
} |
|
339 |
return NULL; |
|
340 |
} |
|
341 |
||
342 |
void *visit(action_c *symbol) { |
|
343 |
switch (wanted_sfcdeclaration) { |
|
344 |
case actiondef_sd: |
|
345 |
s4o.print("#define "); |
|
346 |
s4o.print(SFC_STEP_ACTION_PREFIX); |
|
347 |
symbol->action_name->accept(*this); |
|
348 |
s4o.print(" "); |
|
594
c8092e909886
Clean up code (remove parsing of integers in stage 4).
Mario de Sousa <msousa@fe.up.pt>
parents:
401
diff
changeset
|
349 |
s4o.print(action_number); |
70 | 350 |
s4o.print("\n"); |
351 |
action_number++; |
|
352 |
break; |
|
353 |
case actionundef_sd: |
|
354 |
s4o.print("#undef "); |
|
355 |
s4o.print(SFC_STEP_ACTION_PREFIX); |
|
356 |
symbol->action_name->accept(*this); |
|
357 |
s4o.print("\n"); |
|
358 |
break; |
|
359 |
case actioncount_sd: |
|
360 |
case sfcdecl_sd: |
|
361 |
action_number++; |
|
362 |
break; |
|
363 |
default: |
|
364 |
break; |
|
365 |
} |
|
366 |
return NULL; |
|
367 |
} |
|
368 |
||
369 |
void *visit(instruction_list_c *symbol) { |
|
370 |
return NULL; |
|
371 |
} |
|
372 |
||
373 |
void *visit(statement_list_c *symbol) { |
|
374 |
return NULL; |
|
375 |
} |
|
376 |
||
377 |
}; /* generate_c_sfcdecl_c */ |
|
378 |