1 /* |
|
2 * (c) 2007 Mario de Sousa, Laurent Bessard |
|
3 * |
|
4 * Offered to the public under the terms of the GNU General Public License |
|
5 * as published by the Free Software Foundation; either version 2 of the |
|
6 * License, or (at your option) any later version. |
|
7 * |
|
8 * This program is distributed in the hope that it will be useful, but |
|
9 * WITHOUT ANY WARRANTY; without even the implied warranty of |
|
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General |
|
11 * Public License for more details. |
|
12 * |
|
13 * This code is made available on the understanding that it will not be |
|
14 * used in safety-critical situations without a full and competent review. |
|
15 */ |
|
16 |
|
17 /* |
|
18 * An IEC 61131-3 IL and ST compiler. |
|
19 * |
|
20 * Based on the |
|
21 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10) |
|
22 * |
|
23 */ |
|
24 |
|
25 |
|
26 /* |
|
27 * Conversion of sfc networks (i.e. SFC code). |
|
28 * |
|
29 * This is part of the 4th stage that generates |
|
30 * a c++ source program equivalent to the SFC, IL and ST |
|
31 * code. |
|
32 */ |
|
33 |
|
34 |
|
35 |
|
36 |
|
37 /***********************************************************************/ |
|
38 /***********************************************************************/ |
|
39 /***********************************************************************/ |
|
40 /***********************************************************************/ |
|
41 |
|
42 class generate_cc_sfcdecl_c: protected generate_cc_typedecl_c { |
|
43 |
|
44 public: |
|
45 typedef enum { |
|
46 sfcdecl_sd, |
|
47 sfcinit_sd, |
|
48 stepcount_sd, |
|
49 stepdef_sd, |
|
50 stepundef_sd, |
|
51 actiondef_sd, |
|
52 actionundef_sd, |
|
53 actioncount_sd |
|
54 } sfcdeclaration_t; |
|
55 |
|
56 private: |
|
57 char step_number; |
|
58 char action_number; |
|
59 char transition_number; |
|
60 |
|
61 sfcdeclaration_t wanted_sfcdeclaration; |
|
62 |
|
63 public: |
|
64 generate_cc_sfcdecl_c(stage4out_c *s4o_ptr, sfcdeclaration_t sfcdeclaration) |
|
65 : generate_cc_typedecl_c(s4o_ptr) { |
|
66 wanted_sfcdeclaration = sfcdeclaration; |
|
67 } |
|
68 ~generate_cc_sfcdecl_c(void) {} |
|
69 |
|
70 void print(symbol_c *symbol, const char *variable_prefix = NULL) { |
|
71 this->set_variable_prefix(variable_prefix); |
|
72 |
|
73 symbol->accept(*this); |
|
74 } |
|
75 |
|
76 /*********************************************/ |
|
77 /* B.1.6 Sequential function chart elements */ |
|
78 /*********************************************/ |
|
79 |
|
80 void *visit(sequential_function_chart_c *symbol) { |
|
81 step_number = 0; |
|
82 action_number = 0; |
|
83 transition_number = 0; |
|
84 switch (wanted_sfcdeclaration) { |
|
85 case sfcdecl_sd: |
|
86 for(int i = 0; i < symbol->n; i++) |
|
87 symbol->elements[i]->accept(*this); |
|
88 |
|
89 /* steps table declaration */ |
|
90 s4o.print(s4o.indent_spaces + "STEP step_list["); |
|
91 s4o.print_integer(step_number); |
|
92 s4o.print("];\n"); |
|
93 s4o.print(s4o.indent_spaces + "UINT nb_steps;\n"); |
|
94 |
|
95 /* actions table declaration */ |
|
96 s4o.print(s4o.indent_spaces + "ACTION action_list["); |
|
97 s4o.print_integer(action_number); |
|
98 s4o.print("];\n"); |
|
99 s4o.print(s4o.indent_spaces + "UINT nb_actions;\n"); |
|
100 |
|
101 /* transitions table declaration */ |
|
102 s4o.print(s4o.indent_spaces + "USINT transition_list["); |
|
103 s4o.print_integer(transition_number); |
|
104 s4o.print("];\n"); |
|
105 |
|
106 /* period declaration */ |
|
107 s4o.print(s4o.indent_spaces + "TIME period;\n"); |
|
108 break; |
|
109 case sfcinit_sd: |
|
110 s4o.print(s4o.indent_spaces); |
|
111 s4o.print("UINT i;\n"); |
|
112 |
|
113 /* steps table count */ |
|
114 wanted_sfcdeclaration = stepcount_sd; |
|
115 for(int i = 0; i < symbol->n; i++) |
|
116 symbol->elements[i]->accept(*this); |
|
117 s4o.print(s4o.indent_spaces); |
|
118 print_variable_prefix(); |
|
119 s4o.print("nb_steps = "); |
|
120 s4o.print_integer(step_number); |
|
121 s4o.print(";\n"); |
|
122 step_number = 0; |
|
123 wanted_sfcdeclaration = sfcinit_sd; |
|
124 |
|
125 /* steps table initialisation */ |
|
126 s4o.print(s4o.indent_spaces + "STEP temp_step = {0, 0, 0};\n"); |
|
127 s4o.print(s4o.indent_spaces + "for(i = 0; i < "); |
|
128 print_variable_prefix(); |
|
129 s4o.print("nb_steps; i++) {\n"); |
|
130 s4o.indent_right(); |
|
131 s4o.print(s4o.indent_spaces); |
|
132 print_variable_prefix(); |
|
133 s4o.print("step_list[i] = temp_step;\n"); |
|
134 s4o.indent_left(); |
|
135 s4o.print(s4o.indent_spaces + "}\n"); |
|
136 for(int i = 0; i < symbol->n; i++) |
|
137 symbol->elements[i]->accept(*this); |
|
138 |
|
139 /* steps table count */ |
|
140 wanted_sfcdeclaration = actioncount_sd; |
|
141 for(int i = 0; i < symbol->n; i++) |
|
142 symbol->elements[i]->accept(*this); |
|
143 s4o.print(s4o.indent_spaces); |
|
144 print_variable_prefix(); |
|
145 s4o.print("nb_actions = "); |
|
146 s4o.print_integer(action_number); |
|
147 s4o.print(";\n"); |
|
148 action_number = 0; |
|
149 wanted_sfcdeclaration = sfcinit_sd; |
|
150 |
|
151 /* actions table initialisation */ |
|
152 s4o.print(s4o.indent_spaces + "ACTION temp_action = {0, 0, 0, 0, 0, 0};\n"); |
|
153 s4o.print(s4o.indent_spaces + "for(i = 0; i < "); |
|
154 print_variable_prefix(); |
|
155 s4o.print("nb_actions; i++) {\n"); |
|
156 s4o.indent_right(); |
|
157 s4o.print(s4o.indent_spaces); |
|
158 print_variable_prefix(); |
|
159 s4o.print("action_list[i] = temp_action;\n"); |
|
160 |
|
161 /* period initialisation */ |
|
162 s4o.print(s4o.indent_spaces); |
|
163 print_variable_prefix(); |
|
164 s4o.print("period = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); |
|
165 |
|
166 s4o.indent_left(); |
|
167 s4o.print(s4o.indent_spaces + "}\n"); |
|
168 break; |
|
169 case stepdef_sd: |
|
170 s4o.print("// Steps definitions\n"); |
|
171 for(int i = 0; i < symbol->n; i++) |
|
172 symbol->elements[i]->accept(*this); |
|
173 s4o.print("\n"); |
|
174 break; |
|
175 case actiondef_sd: |
|
176 s4o.print("// Actions definitions\n"); |
|
177 for(int i = 0; i < symbol->n; i++) |
|
178 symbol->elements[i]->accept(*this); |
|
179 s4o.print("\n"); |
|
180 break; |
|
181 case stepundef_sd: |
|
182 s4o.print("// Steps undefinitions\n"); |
|
183 for(int i = 0; i < symbol->n; i++) |
|
184 symbol->elements[i]->accept(*this); |
|
185 s4o.print("\n"); |
|
186 break; |
|
187 case actionundef_sd: |
|
188 s4o.print("// Actions undefinitions\n"); |
|
189 for(int i = 0; i < symbol->n; i++) |
|
190 symbol->elements[i]->accept(*this); |
|
191 s4o.print("\n"); |
|
192 break; |
|
193 default: |
|
194 break; |
|
195 } |
|
196 return NULL; |
|
197 } |
|
198 |
|
199 void *visit(initial_step_c *symbol) { |
|
200 switch (wanted_sfcdeclaration) { |
|
201 case stepcount_sd: |
|
202 case sfcdecl_sd: |
|
203 step_number++; |
|
204 break; |
|
205 case sfcinit_sd: |
|
206 s4o.print(s4o.indent_spaces); |
|
207 print_variable_prefix(); |
|
208 s4o.print("step_list["); |
|
209 s4o.print_integer(step_number); |
|
210 s4o.print("].state = 1;\n"); |
|
211 step_number++; |
|
212 break; |
|
213 case stepdef_sd: |
|
214 s4o.print("#define "); |
|
215 s4o.print(SFC_STEP_ACTION_PREFIX); |
|
216 symbol->step_name->accept(*this); |
|
217 s4o.print(" "); |
|
218 s4o.print_integer(step_number); |
|
219 s4o.print("\n"); |
|
220 step_number++; |
|
221 break; |
|
222 case stepundef_sd: |
|
223 s4o.print("#undef "); |
|
224 s4o.print(SFC_STEP_ACTION_PREFIX); |
|
225 symbol->step_name->accept(*this); |
|
226 s4o.print("\n"); |
|
227 break; |
|
228 default: |
|
229 break; |
|
230 } |
|
231 return NULL; |
|
232 } |
|
233 |
|
234 void *visit(step_c *symbol) { |
|
235 switch (wanted_sfcdeclaration) { |
|
236 case stepcount_sd: |
|
237 case sfcdecl_sd: |
|
238 step_number++; |
|
239 break; |
|
240 case stepdef_sd: |
|
241 s4o.print("#define "); |
|
242 s4o.print(SFC_STEP_ACTION_PREFIX); |
|
243 symbol->step_name->accept(*this); |
|
244 s4o.print(" "); |
|
245 s4o.print_integer(step_number); |
|
246 s4o.print("\n"); |
|
247 step_number++; |
|
248 break; |
|
249 case stepundef_sd: |
|
250 s4o.print("#undef "); |
|
251 s4o.print(SFC_STEP_ACTION_PREFIX); |
|
252 symbol->step_name->accept(*this); |
|
253 s4o.print("\n"); |
|
254 break; |
|
255 default: |
|
256 break; |
|
257 } |
|
258 return NULL; |
|
259 } |
|
260 |
|
261 void *visit(transition_c *symbol) { |
|
262 switch (wanted_sfcdeclaration) { |
|
263 case sfcdecl_sd: |
|
264 transition_number++; |
|
265 break; |
|
266 default: |
|
267 break; |
|
268 } |
|
269 return NULL; |
|
270 } |
|
271 |
|
272 void *visit(action_c *symbol) { |
|
273 switch (wanted_sfcdeclaration) { |
|
274 case actiondef_sd: |
|
275 s4o.print("#define "); |
|
276 s4o.print(SFC_STEP_ACTION_PREFIX); |
|
277 symbol->action_name->accept(*this); |
|
278 s4o.print(" "); |
|
279 s4o.print_integer(action_number); |
|
280 s4o.print("\n"); |
|
281 action_number++; |
|
282 break; |
|
283 case actionundef_sd: |
|
284 s4o.print("#undef "); |
|
285 s4o.print(SFC_STEP_ACTION_PREFIX); |
|
286 symbol->action_name->accept(*this); |
|
287 s4o.print("\n"); |
|
288 break; |
|
289 case actioncount_sd: |
|
290 case sfcdecl_sd: |
|
291 action_number++; |
|
292 break; |
|
293 default: |
|
294 break; |
|
295 } |
|
296 return NULL; |
|
297 } |
|
298 |
|
299 void *visit(instruction_list_c *symbol) { |
|
300 return NULL; |
|
301 } |
|
302 |
|
303 void *visit(statement_list_c *symbol) { |
|
304 return NULL; |
|
305 } |
|
306 |
|
307 }; /* generate_cc_sfcdecl_c */ |
|
308 |
|