29 * This is part of the 4th stage that generates |
29 * This is part of the 4th stage that generates |
30 * a c++ source program equivalent to the SFC, IL and ST |
30 * a c++ source program equivalent to the SFC, IL and ST |
31 * code. |
31 * code. |
32 */ |
32 */ |
33 |
33 |
|
34 #include <list> |
|
35 |
|
36 typedef struct |
|
37 { |
|
38 transition_c *symbol; |
|
39 int priority; |
|
40 int index; |
|
41 } TRANSITION; |
|
42 |
|
43 |
|
44 |
34 |
45 |
35 |
46 |
36 /***********************************************************************/ |
47 /***********************************************************************/ |
37 /***********************************************************************/ |
48 /***********************************************************************/ |
38 /***********************************************************************/ |
49 /***********************************************************************/ |
39 /***********************************************************************/ |
50 /***********************************************************************/ |
40 |
51 |
41 class transition_element { |
52 class generate_cc_sfc_elements_c: public generate_cc_base_c { |
42 |
|
43 private: |
|
44 transition_c *transition; |
|
45 char priority; |
|
46 char index; |
|
47 transition_element *prev; |
|
48 transition_element *next; |
|
49 |
|
50 public: |
|
51 transition_element(transition_c *tr, char pr, char idx) { |
|
52 prev = NULL; |
|
53 next = NULL; |
|
54 transition = tr; |
|
55 priority = pr; |
|
56 index = idx; |
|
57 } |
|
58 |
|
59 void set_prev(transition_element *tr) {prev = tr;} |
|
60 void set_next(transition_element *tr) {next = tr;} |
|
61 transition_element *get_prev(void) {return prev;} |
|
62 transition_element *get_next(void) {return next;} |
|
63 transition_c *get_transition(void) {return transition;} |
|
64 char get_priority(void) {return priority;} |
|
65 char get_index(void) {return index;} |
|
66 }; |
|
67 |
|
68 |
|
69 |
|
70 |
|
71 /***********************************************************************/ |
|
72 /***********************************************************************/ |
|
73 /***********************************************************************/ |
|
74 /***********************************************************************/ |
|
75 |
|
76 class generate_cc_sfc_transitionresetsteps_c: public generate_cc_base_c { |
|
77 |
|
78 private: |
|
79 char transition_number; |
|
80 |
53 |
81 public: |
54 public: |
82 generate_cc_sfc_transitionresetsteps_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) |
55 typedef enum { |
|
56 transitionlist_sg, |
|
57 transitiontest_sg, |
|
58 stepset_sg, |
|
59 stepreset_sg, |
|
60 actionassociation_sg, |
|
61 actionbody_sg |
|
62 } sfcgeneration_t; |
|
63 |
|
64 private: |
|
65 generate_cc_il_c *generate_cc_il; |
|
66 generate_cc_st_c *generate_cc_st; |
|
67 generate_cc_SFC_IL_ST_c *generate_cc_code; |
|
68 |
|
69 int transition_number; |
|
70 std::list<TRANSITION> transition_list; |
|
71 |
|
72 symbol_c *current_step; |
|
73 symbol_c *current_action; |
|
74 |
|
75 sfcgeneration_t wanted_sfcgeneration; |
|
76 |
|
77 public: |
|
78 generate_cc_sfc_elements_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) |
83 : generate_cc_base_c(s4o_ptr) { |
79 : generate_cc_base_c(s4o_ptr) { |
|
80 generate_cc_il = new generate_cc_il_c(s4o_ptr, scope, variable_prefix); |
|
81 generate_cc_st = new generate_cc_st_c(s4o_ptr, scope, variable_prefix); |
|
82 generate_cc_code = new generate_cc_SFC_IL_ST_c(s4o_ptr, scope, variable_prefix); |
84 this->set_variable_prefix(variable_prefix); |
83 this->set_variable_prefix(variable_prefix); |
85 } |
84 } |
86 |
85 |
87 void set_transition_number(char number) {transition_number = number;} |
86 ~generate_cc_sfc_elements_c(void) { |
|
87 delete generate_cc_il; |
|
88 delete generate_cc_st; |
|
89 delete generate_cc_code; |
|
90 } |
|
91 |
88 void reset_transition_number(void) {transition_number = 0;} |
92 void reset_transition_number(void) {transition_number = 0;} |
89 void print_transition_number(void) { |
93 |
90 char str[10]; |
94 void generate(symbol_c *symbol, sfcgeneration_t generation_type) { |
91 sprintf(str, "%d", transition_number); |
95 wanted_sfcgeneration = generation_type; |
92 s4o.print(str); |
96 switch (wanted_sfcgeneration) { |
93 } |
97 case transitiontest_sg: |
94 |
98 { |
|
99 std::list<TRANSITION>::iterator pt; |
|
100 for(pt = transition_list.begin(); pt != transition_list.end(); pt++) { |
|
101 transition_number = pt->index; |
|
102 pt->symbol->accept(*this); |
|
103 } |
|
104 } |
|
105 break; |
|
106 default: |
|
107 symbol->accept(*this); |
|
108 break; |
|
109 } |
|
110 } |
|
111 |
95 void print_step_argument(symbol_c *step_name, const char* argument) { |
112 void print_step_argument(symbol_c *step_name, const char* argument) { |
96 print_variable_prefix(); |
113 print_variable_prefix(); |
97 s4o.print("step_list["); |
114 s4o.print("step_list["); |
98 s4o.print(SFC_STEP_ACTION_PREFIX); |
115 s4o.print(SFC_STEP_ACTION_PREFIX); |
99 step_name->accept(*this); |
116 step_name->accept(*this); |
100 s4o.print("]."); |
117 s4o.print("]."); |
101 s4o.print(argument); |
118 s4o.print(argument); |
102 } |
119 } |
103 |
120 |
104 void print_reset_step(symbol_c *step_name) { |
|
105 s4o.print(s4o.indent_spaces); |
|
106 print_step_argument(step_name, "state"); |
|
107 s4o.print(" = 0;\n"); |
|
108 } |
|
109 |
|
110 /*********************************************/ |
|
111 /* B.1.6 Sequential function chart elements */ |
|
112 /*********************************************/ |
|
113 |
|
114 void *visit(initial_step_c *symbol) {return NULL;} |
|
115 |
|
116 void *visit(step_c *symbol) {return NULL;} |
|
117 |
|
118 void *visit(transition_c *symbol) { |
|
119 if (symbol->integer == NULL) { |
|
120 s4o.print(s4o.indent_spaces + "if ("); |
|
121 print_variable_prefix(); |
|
122 s4o.print("transition_list["); |
|
123 print_transition_number(); |
|
124 s4o.print("]) {\n"); |
|
125 s4o.indent_right(); |
|
126 symbol->from_steps->accept(*this); |
|
127 s4o.indent_left(); |
|
128 s4o.print(s4o.indent_spaces + "}\n"); |
|
129 } |
|
130 transition_number++; |
|
131 return NULL; |
|
132 } |
|
133 |
|
134 void *visit(steps_c *symbol) { |
|
135 if (symbol->step_name != NULL) { |
|
136 print_reset_step(symbol->step_name); |
|
137 } |
|
138 if (symbol->step_name_list != NULL) { |
|
139 symbol->step_name_list->accept(*this); |
|
140 } |
|
141 return NULL; |
|
142 } |
|
143 |
|
144 void *visit(step_name_list_c *symbol) { |
|
145 for(int i = 0; i < symbol->n; i++) { |
|
146 print_reset_step(symbol->elements[i]); |
|
147 } |
|
148 return NULL; |
|
149 } |
|
150 |
|
151 void *visit(action_c *symbol) {return NULL;} |
|
152 |
|
153 }; /* generate_cc_sfc_transitionresetsteps_c */ |
|
154 |
|
155 |
|
156 |
|
157 |
|
158 /***********************************************************************/ |
|
159 /***********************************************************************/ |
|
160 /***********************************************************************/ |
|
161 /***********************************************************************/ |
|
162 |
|
163 class generate_cc_sfc_transitionsetsteps_c: public generate_cc_base_c { |
|
164 |
|
165 private: |
|
166 char transition_number; |
|
167 |
|
168 public: |
|
169 generate_cc_sfc_transitionsetsteps_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) |
|
170 : generate_cc_base_c(s4o_ptr) { |
|
171 this->set_variable_prefix(variable_prefix); |
|
172 } |
|
173 |
|
174 void reset_transition_number(void) {transition_number = 0;} |
|
175 void print_transition_number(void) { |
|
176 char str[10]; |
|
177 sprintf(str, "%d", transition_number); |
|
178 s4o.print(str); |
|
179 } |
|
180 |
|
181 void print_step_argument(symbol_c *step_name, const char* argument) { |
|
182 print_variable_prefix(); |
|
183 s4o.print("step_list["); |
|
184 s4o.print(SFC_STEP_ACTION_PREFIX); |
|
185 step_name->accept(*this); |
|
186 s4o.print("]."); |
|
187 s4o.print(argument); |
|
188 } |
|
189 |
|
190 void print_set_step(symbol_c *step_name) { |
|
191 s4o.print(s4o.indent_spaces); |
|
192 print_step_argument(step_name, "state"); |
|
193 s4o.print(" = 1;\n" + s4o.indent_spaces); |
|
194 print_step_argument(step_name, "elapsed_time"); |
|
195 s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); |
|
196 } |
|
197 |
|
198 /*********************************************/ |
|
199 /* B.1.6 Sequential function chart elements */ |
|
200 /*********************************************/ |
|
201 |
|
202 void *visit(initial_step_c *symbol) {return NULL;} |
|
203 |
|
204 void *visit(step_c *symbol) {return NULL;} |
|
205 |
|
206 void *visit(transition_c *symbol) { |
|
207 s4o.print(s4o.indent_spaces + "if ("); |
|
208 print_variable_prefix(); |
|
209 s4o.print("transition_list["); |
|
210 print_transition_number(); |
|
211 s4o.print("]) {\n"); |
|
212 s4o.indent_right(); |
|
213 symbol->to_steps->accept(*this); |
|
214 s4o.indent_left(); |
|
215 s4o.print(s4o.indent_spaces + "}\n"); |
|
216 transition_number++; |
|
217 return NULL; |
|
218 } |
|
219 |
|
220 void *visit(steps_c *symbol) { |
|
221 if (symbol->step_name != NULL) { |
|
222 print_set_step(symbol->step_name); |
|
223 } |
|
224 if (symbol->step_name_list != NULL) { |
|
225 symbol->step_name_list->accept(*this); |
|
226 } |
|
227 return NULL; |
|
228 } |
|
229 |
|
230 void *visit(step_name_list_c *symbol) { |
|
231 for(int i = 0; i < symbol->n; i++) { |
|
232 print_set_step(symbol->elements[i]); |
|
233 } |
|
234 return NULL; |
|
235 } |
|
236 |
|
237 void *visit(action_c *symbol) {return NULL;} |
|
238 |
|
239 }; /* generate_cc_sfc_transitionsetsteps_c */ |
|
240 |
|
241 |
|
242 |
|
243 |
|
244 /***********************************************************************/ |
|
245 /***********************************************************************/ |
|
246 /***********************************************************************/ |
|
247 /***********************************************************************/ |
|
248 |
|
249 class generate_cc_sfc_transitiontest_c: public generate_cc_base_c { |
|
250 |
|
251 private: |
|
252 char transition_number; |
|
253 |
|
254 private: |
|
255 generate_cc_il_c *generate_cc_il; |
|
256 generate_cc_st_c *generate_cc_st; |
|
257 generate_cc_sfc_transitionresetsteps_c *generate_cc_sfc_transitionresetsteps; |
|
258 |
|
259 public: |
|
260 generate_cc_sfc_transitiontest_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) |
|
261 : generate_cc_base_c(s4o_ptr) { |
|
262 generate_cc_il = new generate_cc_il_c(s4o_ptr, scope, variable_prefix); |
|
263 generate_cc_st = new generate_cc_st_c(s4o_ptr, scope, variable_prefix); |
|
264 generate_cc_sfc_transitionresetsteps = new generate_cc_sfc_transitionresetsteps_c(s4o_ptr, scope, variable_prefix); |
|
265 this->set_variable_prefix(variable_prefix); |
|
266 } |
|
267 |
|
268 ~generate_cc_sfc_transitiontest_c(void) { |
|
269 delete generate_cc_il; |
|
270 delete generate_cc_st; |
|
271 delete generate_cc_sfc_transitionresetsteps; |
|
272 } |
|
273 |
|
274 void set_transition_number(char number) {transition_number = number;} |
|
275 void print_transition_number(void) { |
|
276 char str[10]; |
|
277 sprintf(str, "%d", transition_number); |
|
278 s4o.print(str); |
|
279 } |
|
280 |
|
281 void print_step_argument(symbol_c *step_name, const char* argument) { |
|
282 print_variable_prefix(); |
|
283 s4o.print("step_list["); |
|
284 s4o.print(SFC_STEP_ACTION_PREFIX); |
|
285 step_name->accept(*this); |
|
286 s4o.print("]."); |
|
287 s4o.print(argument); |
|
288 } |
|
289 |
|
290 void print_reset_step(symbol_c *step_name) { |
|
291 s4o.print(s4o.indent_spaces); |
|
292 print_step_argument(step_name, "state"); |
|
293 s4o.print(" = 0;\n"); |
|
294 } |
|
295 |
|
296 /*********************************************/ |
|
297 /* B.1.6 Sequential function chart elements */ |
|
298 /*********************************************/ |
|
299 |
|
300 void *visit(transition_c *symbol) { |
|
301 s4o.print(s4o.indent_spaces + "if ("); |
|
302 symbol->from_steps->accept(*this); |
|
303 s4o.print(") {\n"); |
|
304 s4o.indent_right(); |
|
305 |
|
306 // Calculate transition value |
|
307 if (symbol->transition_condition_il != NULL) { |
|
308 generate_cc_il->declare_backup_variable(); |
|
309 s4o.print(s4o.indent_spaces); |
|
310 symbol->transition_condition_il->accept(*generate_cc_il); |
|
311 print_variable_prefix(); |
|
312 s4o.print("transition_list["); |
|
313 print_transition_number(); |
|
314 s4o.print("] = "); |
|
315 generate_cc_il->print_backup_variable(); |
|
316 s4o.print(";\n"); |
|
317 } |
|
318 if (symbol->transition_condition_st != NULL) { |
|
319 s4o.print(s4o.indent_spaces); |
|
320 print_variable_prefix(); |
|
321 s4o.print("transition_list["); |
|
322 print_transition_number(); |
|
323 s4o.print("] = "); |
|
324 symbol->transition_condition_st->accept(*generate_cc_st); |
|
325 s4o.print(";\n"); |
|
326 } |
|
327 if (symbol->integer != NULL) { |
|
328 s4o.print(s4o.indent_spaces + "if ("); |
|
329 print_variable_prefix(); |
|
330 s4o.print("transition_list["); |
|
331 print_transition_number(); |
|
332 s4o.print("]) {\n"); |
|
333 s4o.indent_right(); |
|
334 symbol->from_steps->accept(*generate_cc_sfc_transitionresetsteps); |
|
335 s4o.indent_left(); |
|
336 s4o.print(s4o.indent_spaces + "}\n"); |
|
337 } |
|
338 s4o.indent_left(); |
|
339 s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces + "else {\n"); |
|
340 s4o.indent_right(); |
|
341 s4o.print(s4o.indent_spaces); |
|
342 print_variable_prefix(); |
|
343 s4o.print("transition_list["); |
|
344 print_transition_number(); |
|
345 s4o.print("] = 0;\n"); |
|
346 s4o.indent_left(); |
|
347 s4o.print(s4o.indent_spaces + "}\n"); |
|
348 |
|
349 transition_number++; |
|
350 return NULL; |
|
351 } |
|
352 |
|
353 void *visit(steps_c *symbol) { |
|
354 if (symbol->step_name != NULL) { |
|
355 print_step_argument(symbol->step_name, "state"); |
|
356 } |
|
357 if (symbol->step_name_list != NULL) { |
|
358 symbol->step_name_list->accept(*this); |
|
359 } |
|
360 return NULL; |
|
361 } |
|
362 |
|
363 void *visit(step_name_list_c *symbol) { |
|
364 for(int i = 0; i < symbol->n; i++) { |
|
365 print_step_argument(symbol->elements[i], "state"); |
|
366 if (i < symbol->n - 1) { |
|
367 s4o.print(" && "); |
|
368 } |
|
369 } |
|
370 return NULL; |
|
371 } |
|
372 |
|
373 }; /* generate_cc_sfc_transitiontest_c */ |
|
374 |
|
375 |
|
376 |
|
377 |
|
378 /***********************************************************************/ |
|
379 /***********************************************************************/ |
|
380 /***********************************************************************/ |
|
381 /***********************************************************************/ |
|
382 |
|
383 class generate_cc_sfc_transitionsort_c: public iterator_visitor_c { |
|
384 |
|
385 private: |
|
386 char transition_number; |
|
387 transition_element *first_transition; |
|
388 transition_element *last_transition; |
|
389 |
|
390 private: |
|
391 generate_cc_sfc_transitiontest_c *generate_cc_sfc_transitiontest; |
|
392 |
|
393 public: |
|
394 generate_cc_sfc_transitionsort_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) { |
|
395 generate_cc_sfc_transitiontest = new generate_cc_sfc_transitiontest_c(s4o_ptr, scope, variable_prefix); |
|
396 first_transition = NULL; |
|
397 last_transition = NULL; |
|
398 } |
|
399 |
|
400 ~generate_cc_sfc_transitionsort_c(void) { |
|
401 delete generate_cc_sfc_transitiontest; |
|
402 } |
|
403 |
|
404 void append_transition(transition_c *transition, char priority, char index) { |
|
405 transition_element *new_transition = new transition_element(transition, priority, index); |
|
406 new_transition->set_prev(last_transition); |
|
407 if (last_transition != NULL) { |
|
408 last_transition->set_next(new_transition); |
|
409 } |
|
410 else { |
|
411 first_transition = new_transition; |
|
412 } |
|
413 last_transition = new_transition; |
|
414 transition_number++; |
|
415 } |
|
416 |
|
417 void sort_transitions(void) { |
|
418 int i, j; |
|
419 transition_element *current_transition; |
|
420 transition_element *next_transition; |
|
421 for (i = transition_number; i > 1; i--) { |
|
422 current_transition = first_transition; |
|
423 for (j = 0; j < i - 1; j++) { |
|
424 next_transition = current_transition->get_next(); |
|
425 if (current_transition->get_priority() > next_transition->get_priority()) { |
|
426 if (current_transition->get_prev() != NULL) { |
|
427 current_transition->get_prev()->set_next(next_transition); |
|
428 } |
|
429 else { |
|
430 first_transition = next_transition; |
|
431 } |
|
432 if (next_transition->get_next() != NULL) { |
|
433 next_transition->get_next()->set_prev(current_transition); |
|
434 } |
|
435 else { |
|
436 last_transition = current_transition; |
|
437 } |
|
438 current_transition->set_next(next_transition->get_next()); |
|
439 next_transition->set_prev(current_transition->get_prev()); |
|
440 current_transition->set_prev(next_transition); |
|
441 next_transition->set_next(current_transition); |
|
442 } |
|
443 else { |
|
444 current_transition = next_transition; |
|
445 } |
|
446 } |
|
447 } |
|
448 } |
|
449 |
|
450 void reset_transition_number(void) {transition_number = 0;} |
|
451 |
|
452 void generate(symbol_c *symbol) { |
|
453 symbol->accept(*this); |
|
454 sort_transitions(); |
|
455 transition_element *next_transition = first_transition; |
|
456 while (next_transition != NULL) { |
|
457 generate_cc_sfc_transitiontest->set_transition_number(next_transition->get_index()); |
|
458 next_transition->get_transition()->accept(*generate_cc_sfc_transitiontest); |
|
459 next_transition = next_transition->get_next(); |
|
460 } |
|
461 } |
|
462 |
|
463 /*********************************************/ |
|
464 /* B.1.6 Sequential function chart elements */ |
|
465 /*********************************************/ |
|
466 |
|
467 void *visit(initial_step_c *symbol) {return NULL;} |
|
468 |
|
469 void *visit(step_c *symbol) {return NULL;} |
|
470 |
|
471 void *visit(transition_c *symbol) { |
|
472 if (symbol->integer != NULL) { |
|
473 append_transition(symbol, atoi(((token_c *)symbol->integer)->value), transition_number); |
|
474 } |
|
475 else { |
|
476 append_transition(symbol, 0, transition_number); |
|
477 } |
|
478 return NULL; |
|
479 } |
|
480 |
|
481 void *visit(action_c *symbol) {return NULL;} |
|
482 |
|
483 };/* generate_cc_sfc_transitionsort_c */ |
|
484 |
|
485 |
|
486 |
|
487 |
|
488 /***********************************************************************/ |
|
489 /***********************************************************************/ |
|
490 /***********************************************************************/ |
|
491 /***********************************************************************/ |
|
492 |
|
493 class generate_cc_sfc_stepassociation_c: public generate_cc_base_c { |
|
494 |
|
495 private: |
|
496 symbol_c *current_step; |
|
497 symbol_c *current_action; |
|
498 |
|
499 public: |
|
500 generate_cc_sfc_stepassociation_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) |
|
501 : generate_cc_base_c(s4o_ptr) { |
|
502 this->set_variable_prefix(variable_prefix); |
|
503 } |
|
504 |
|
505 void print_step_argument(symbol_c *step_name, const char* argument) { |
|
506 print_variable_prefix(); |
|
507 s4o.print("step_list["); |
|
508 s4o.print(SFC_STEP_ACTION_PREFIX); |
|
509 step_name->accept(*this); |
|
510 s4o.print("]."); |
|
511 s4o.print(argument); |
|
512 } |
|
513 |
|
514 void print_action_argument(symbol_c *action_name, const char* argument) { |
121 void print_action_argument(symbol_c *action_name, const char* argument) { |
515 print_variable_prefix(); |
122 print_variable_prefix(); |
516 s4o.print("action_list["); |
123 s4o.print("action_list["); |
517 s4o.print(SFC_STEP_ACTION_PREFIX); |
124 s4o.print(SFC_STEP_ACTION_PREFIX); |
518 action_name->accept(*this); |
125 action_name->accept(*this); |
519 s4o.print("]."); |
126 s4o.print("]."); |
520 s4o.print(argument); |
127 s4o.print(argument); |
521 } |
128 } |
|
129 |
|
130 void print_transition_number(void) { |
|
131 char str[10]; |
|
132 sprintf(str, "%d", transition_number); |
|
133 s4o.print(str); |
|
134 } |
|
135 |
|
136 void print_reset_step(symbol_c *step_name) { |
|
137 s4o.print(s4o.indent_spaces); |
|
138 print_step_argument(step_name, "state"); |
|
139 s4o.print(" = 0;\n"); |
|
140 } |
|
141 |
|
142 void print_set_step(symbol_c *step_name) { |
|
143 s4o.print(s4o.indent_spaces); |
|
144 print_step_argument(step_name, "state"); |
|
145 s4o.print(" = 1;\n" + s4o.indent_spaces); |
|
146 print_step_argument(step_name, "elapsed_time"); |
|
147 s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); |
|
148 } |
|
149 |
522 |
150 |
523 /*********************************************/ |
151 /*********************************************/ |
524 /* B.1.6 Sequential function chart elements */ |
152 /* B.1.6 Sequential function chart elements */ |
525 /*********************************************/ |
153 /*********************************************/ |
526 |
154 |
527 void *visit(initial_step_c *symbol) { |
155 void *visit(initial_step_c *symbol) { |
528 if (((list_c*)symbol->action_association_list)->n > 0) { |
156 switch (wanted_sfcgeneration) { |
529 s4o.print(s4o.indent_spaces + "// "); |
157 case actionassociation_sg: |
530 symbol->step_name->accept(*this); |
158 if (((list_c*)symbol->action_association_list)->n > 0) { |
531 s4o.print(" action associations\n"); |
159 s4o.print(s4o.indent_spaces + "// "); |
532 current_step = symbol->step_name; |
160 symbol->step_name->accept(*this); |
533 s4o.print(s4o.indent_spaces + "{\n"); |
161 s4o.print(" action associations\n"); |
534 s4o.indent_right(); |
162 current_step = symbol->step_name; |
535 s4o.print(s4o.indent_spaces + "char activated = "); |
163 s4o.print(s4o.indent_spaces + "{\n"); |
536 print_step_argument(current_step, "state"); |
164 s4o.indent_right(); |
537 s4o.print(" && !"); |
165 s4o.print(s4o.indent_spaces + "char activated = "); |
538 print_step_argument(current_step, "prev_state"); |
166 print_step_argument(current_step, "state"); |
539 s4o.print(";\n"); |
167 s4o.print(" && !"); |
540 s4o.print(s4o.indent_spaces + "char desactivated = !"); |
168 print_step_argument(current_step, "prev_state"); |
541 print_step_argument(current_step, "state"); |
169 s4o.print(";\n"); |
542 s4o.print(" && "); |
170 s4o.print(s4o.indent_spaces + "char desactivated = !"); |
543 print_step_argument(current_step, "prev_state"); |
171 print_step_argument(current_step, "state"); |
544 s4o.print(";\n"); |
172 s4o.print(" && "); |
545 s4o.print(s4o.indent_spaces + "char active = "); |
173 print_step_argument(current_step, "prev_state"); |
546 print_step_argument(current_step, "state"); |
174 s4o.print(";\n"); |
547 s4o.print(";\n"); |
175 s4o.print(s4o.indent_spaces + "char active = "); |
548 symbol->action_association_list->accept(*this); |
176 print_step_argument(current_step, "state"); |
549 s4o.indent_left(); |
177 s4o.print(";\n"); |
550 s4o.print(s4o.indent_spaces + "}\n\n"); |
178 symbol->action_association_list->accept(*this); |
|
179 s4o.indent_left(); |
|
180 s4o.print(s4o.indent_spaces + "}\n\n"); |
|
181 } |
|
182 break; |
|
183 default: |
|
184 break; |
551 } |
185 } |
552 return NULL; |
186 return NULL; |
553 } |
187 } |
554 |
188 |
555 void *visit(step_c *symbol) { |
189 void *visit(step_c *symbol) { |
556 if (((list_c*)symbol->action_association_list)->n > 0) { |
190 switch (wanted_sfcgeneration) { |
557 s4o.print(s4o.indent_spaces + "// "); |
191 case actionassociation_sg: |
558 symbol->step_name->accept(*this); |
192 if (((list_c*)symbol->action_association_list)->n > 0) { |
559 s4o.print(" action associations\n"); |
193 s4o.print(s4o.indent_spaces + "// "); |
560 current_step = symbol->step_name; |
194 symbol->step_name->accept(*this); |
561 s4o.print(s4o.indent_spaces + "{\n"); |
195 s4o.print(" action associations\n"); |
562 s4o.indent_right(); |
196 current_step = symbol->step_name; |
563 s4o.print(s4o.indent_spaces + "char activated = "); |
197 s4o.print(s4o.indent_spaces + "{\n"); |
564 print_step_argument(current_step, "state"); |
198 s4o.indent_right(); |
565 s4o.print(" && !"); |
199 s4o.print(s4o.indent_spaces + "char activated = "); |
566 print_step_argument(current_step, "prev_state"); |
200 print_step_argument(current_step, "state"); |
567 s4o.print(";\n"); |
201 s4o.print(" && !"); |
568 s4o.print(s4o.indent_spaces + "char desactivated = !"); |
202 print_step_argument(current_step, "prev_state"); |
569 print_step_argument(current_step, "state"); |
203 s4o.print(";\n"); |
570 s4o.print(" && "); |
204 s4o.print(s4o.indent_spaces + "char desactivated = !"); |
571 print_step_argument(current_step, "prev_state"); |
205 print_step_argument(current_step, "state"); |
572 s4o.print(";\n"); |
206 s4o.print(" && "); |
573 s4o.print(s4o.indent_spaces + "char active = "); |
207 print_step_argument(current_step, "prev_state"); |
574 print_step_argument(current_step, "state"); |
208 s4o.print(";\n"); |
575 s4o.print(";\n"); |
209 s4o.print(s4o.indent_spaces + "char active = "); |
576 symbol->action_association_list->accept(*this); |
210 print_step_argument(current_step, "state"); |
577 s4o.indent_left(); |
211 s4o.print(";\n"); |
578 s4o.print(s4o.indent_spaces + "}\n\n"); |
212 symbol->action_association_list->accept(*this); |
579 } |
213 s4o.indent_left(); |
580 return NULL; |
214 s4o.print(s4o.indent_spaces + "}\n\n"); |
581 } |
215 } |
582 |
216 break; |
583 void *visit(transition_c *symbol) {return NULL;} |
217 default: |
584 |
218 break; |
585 void *visit(action_c *symbol) {return NULL;} |
219 } |
|
220 return NULL; |
|
221 } |
|
222 |
|
223 void *visit(transition_c *symbol) { |
|
224 switch (wanted_sfcgeneration) { |
|
225 case transitionlist_sg: |
|
226 { |
|
227 TRANSITION *transition; |
|
228 transition = new TRANSITION; |
|
229 transition->symbol = symbol; |
|
230 transition->index = transition_number; |
|
231 if (symbol->integer != NULL) { |
|
232 transition->priority = atoi(((token_c *)symbol->integer)->value); |
|
233 std::list<TRANSITION>::iterator pt = transition_list.begin(); |
|
234 while (pt != transition_list.end() && pt->priority > transition->priority) { |
|
235 pt++; |
|
236 } |
|
237 transition_list.insert(pt, *transition); |
|
238 } |
|
239 else { |
|
240 transition->priority = 0; |
|
241 transition_list.push_back(*transition); |
|
242 } |
|
243 transition_number++; |
|
244 } |
|
245 break; |
|
246 case transitiontest_sg: |
|
247 s4o.print(s4o.indent_spaces + "if ("); |
|
248 symbol->from_steps->accept(*this); |
|
249 s4o.print(") {\n"); |
|
250 s4o.indent_right(); |
|
251 |
|
252 // Calculate transition value |
|
253 if (symbol->transition_condition_il != NULL) { |
|
254 generate_cc_il->declare_backup_variable(); |
|
255 s4o.print(s4o.indent_spaces); |
|
256 symbol->transition_condition_il->accept(*generate_cc_il); |
|
257 print_variable_prefix(); |
|
258 s4o.print("transition_list["); |
|
259 print_transition_number(); |
|
260 s4o.print("] = "); |
|
261 generate_cc_il->print_backup_variable(); |
|
262 s4o.print(";\n"); |
|
263 } |
|
264 if (symbol->transition_condition_st != NULL) { |
|
265 s4o.print(s4o.indent_spaces); |
|
266 print_variable_prefix(); |
|
267 s4o.print("transition_list["); |
|
268 print_transition_number(); |
|
269 s4o.print("] = "); |
|
270 symbol->transition_condition_st->accept(*generate_cc_st); |
|
271 s4o.print(";\n"); |
|
272 } |
|
273 if (symbol->integer != NULL) { |
|
274 s4o.print(s4o.indent_spaces + "if ("); |
|
275 print_variable_prefix(); |
|
276 s4o.print("transition_list["); |
|
277 print_transition_number(); |
|
278 s4o.print("]) {\n"); |
|
279 s4o.indent_right(); |
|
280 wanted_sfcgeneration = stepreset_sg; |
|
281 symbol->from_steps->accept(*this); |
|
282 wanted_sfcgeneration = transitiontest_sg; |
|
283 s4o.indent_left(); |
|
284 s4o.print(s4o.indent_spaces + "}\n"); |
|
285 } |
|
286 s4o.indent_left(); |
|
287 s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces + "else {\n"); |
|
288 s4o.indent_right(); |
|
289 s4o.print(s4o.indent_spaces); |
|
290 print_variable_prefix(); |
|
291 s4o.print("transition_list["); |
|
292 print_transition_number(); |
|
293 s4o.print("] = 0;\n"); |
|
294 s4o.indent_left(); |
|
295 s4o.print(s4o.indent_spaces + "}\n"); |
|
296 break; |
|
297 case stepset_sg: |
|
298 s4o.print(s4o.indent_spaces + "if ("); |
|
299 print_variable_prefix(); |
|
300 s4o.print("transition_list["); |
|
301 print_transition_number(); |
|
302 s4o.print("]) {\n"); |
|
303 s4o.indent_right(); |
|
304 symbol->to_steps->accept(*this); |
|
305 s4o.indent_left(); |
|
306 s4o.print(s4o.indent_spaces + "}\n"); |
|
307 transition_number++; |
|
308 break; |
|
309 case stepreset_sg: |
|
310 if (symbol->integer == NULL) { |
|
311 s4o.print(s4o.indent_spaces + "if ("); |
|
312 print_variable_prefix(); |
|
313 s4o.print("transition_list["); |
|
314 print_transition_number(); |
|
315 s4o.print("]) {\n"); |
|
316 s4o.indent_right(); |
|
317 symbol->from_steps->accept(*this); |
|
318 s4o.indent_left(); |
|
319 s4o.print(s4o.indent_spaces + "}\n"); |
|
320 } |
|
321 transition_number++; |
|
322 break; |
|
323 default: |
|
324 break; |
|
325 } |
|
326 return NULL; |
|
327 } |
|
328 |
|
329 void *visit(action_c *symbol) { |
|
330 switch (wanted_sfcgeneration) { |
|
331 case actionbody_sg: |
|
332 s4o.print(s4o.indent_spaces + "if("); |
|
333 print_variable_prefix(); |
|
334 s4o.print("action_list["); |
|
335 s4o.print(SFC_STEP_ACTION_PREFIX); |
|
336 symbol->action_name->accept(*this); |
|
337 s4o.print("].state) {"); |
|
338 s4o.indent_right(); |
|
339 |
|
340 // generate action code |
|
341 symbol->function_block_body->accept(*generate_cc_code); |
|
342 |
|
343 s4o.indent_left(); |
|
344 s4o.print(s4o.indent_spaces + "}\n\n"); |
|
345 break; |
|
346 default: |
|
347 break; |
|
348 } |
|
349 return NULL; |
|
350 } |
|
351 |
|
352 void *visit(steps_c *symbol) { |
|
353 if (symbol->step_name != NULL) { |
|
354 switch (wanted_sfcgeneration) { |
|
355 case transitiontest_sg: |
|
356 print_step_argument(symbol->step_name, "state"); |
|
357 break; |
|
358 case stepset_sg: |
|
359 print_set_step(symbol->step_name); |
|
360 break; |
|
361 case stepreset_sg: |
|
362 print_reset_step(symbol->step_name); |
|
363 break; |
|
364 default: |
|
365 break; |
|
366 } |
|
367 } |
|
368 else if (symbol->step_name_list != NULL) { |
|
369 symbol->step_name_list->accept(*this); |
|
370 } |
|
371 return NULL; |
|
372 } |
|
373 |
|
374 void *visit(step_name_list_c *symbol) { |
|
375 switch (wanted_sfcgeneration) { |
|
376 case transitiontest_sg: |
|
377 for(int i = 0; i < symbol->n; i++) { |
|
378 print_step_argument(symbol->elements[i], "state"); |
|
379 if (i < symbol->n - 1) { |
|
380 s4o.print(" && "); |
|
381 } |
|
382 } |
|
383 break; |
|
384 case stepset_sg: |
|
385 for(int i = 0; i < symbol->n; i++) { |
|
386 print_set_step(symbol->elements[i]); |
|
387 } |
|
388 break; |
|
389 case stepreset_sg: |
|
390 for(int i = 0; i < symbol->n; i++) { |
|
391 print_reset_step(symbol->elements[i]); |
|
392 } |
|
393 break; |
|
394 default: |
|
395 break; |
|
396 } |
|
397 return NULL; |
|
398 } |
586 |
399 |
587 void *visit(action_association_list_c* symbol) { |
400 void *visit(action_association_list_c* symbol) { |
588 print_list(symbol, "", "\n", "\n"); |
401 switch (wanted_sfcgeneration) { |
|
402 case actionassociation_sg: |
|
403 print_list(symbol, "", "\n", "\n"); |
|
404 break; |
|
405 default: |
|
406 break; |
|
407 } |
589 return NULL; |
408 return NULL; |
590 } |
409 } |
591 |
410 |
592 void *visit(action_association_c *symbol) { |
411 void *visit(action_association_c *symbol) { |
593 if (symbol->action_qualifier != NULL) { |
412 switch (wanted_sfcgeneration) { |
594 current_action = symbol->action_name; |
413 case actionassociation_sg: |
595 symbol->action_qualifier->accept(*this); |
414 if (symbol->action_qualifier != NULL) { |
596 } |
415 current_action = symbol->action_name; |
597 else { |
416 symbol->action_qualifier->accept(*this); |
598 s4o.print(s4o.indent_spaces + "if ("); |
417 } |
599 print_step_argument(current_step, "state"); |
418 else { |
600 s4o.print(") {\n"); |
419 s4o.print(s4o.indent_spaces + "if ("); |
601 s4o.indent_right(); |
420 print_step_argument(current_step, "state"); |
602 s4o.print(s4o.indent_spaces); |
421 s4o.print(") {\n"); |
603 print_action_argument(symbol->action_name, "state"); |
422 s4o.indent_right(); |
604 s4o.print(" = 1;\n"); |
423 s4o.print(s4o.indent_spaces); |
605 s4o.indent_left(); |
424 print_action_argument(symbol->action_name, "state"); |
606 s4o.print(s4o.indent_spaces + "}"); |
425 s4o.print(" = 1;\n"); |
|
426 s4o.indent_left(); |
|
427 s4o.print(s4o.indent_spaces + "}"); |
|
428 } |
|
429 break; |
|
430 default: |
|
431 break; |
607 } |
432 } |
608 return NULL; |
433 return NULL; |
609 } |
434 } |
610 |
435 |
611 void *visit(action_qualifier_c *symbol) { |
436 void *visit(action_qualifier_c *symbol) { |
612 char *qualifier = (char *)symbol->action_qualifier->accept(*this); |
437 switch (wanted_sfcgeneration) { |
613 |
438 case actionassociation_sg: |
614 s4o.print(s4o.indent_spaces + "if ("); |
439 { |
615 if (strcmp(qualifier, "N") == 0) { |
440 char *qualifier = (char *)symbol->action_qualifier->accept(*this); |
616 s4o.print("active"); |
441 s4o.print(s4o.indent_spaces + "if ("); |
617 } |
442 if (strcmp(qualifier, "N") == 0) { |
618 if (strcmp(qualifier, "P") == 0 || strcmp(qualifier, "SD") == 0 || |
443 s4o.print("active"); |
619 strcmp(qualifier, "DS") == 0 || strcmp(qualifier, "SL") == 0) { |
444 } |
620 s4o.print("activated"); |
445 if (strcmp(qualifier, "P") == 0 || strcmp(qualifier, "SD") == 0 || |
621 } |
446 strcmp(qualifier, "DS") == 0 || strcmp(qualifier, "SL") == 0 || |
622 if (strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) { |
447 strcmp(qualifier, "S") == 0 || strcmp(qualifier, "R") == 0) { |
623 s4o.print("active && "); |
448 s4o.print("activated"); |
624 print_step_argument(current_step, "elapsed_time"); |
449 } |
625 if (strcmp(qualifier, "D") == 0) { |
450 if (strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) { |
626 s4o.print(" >= "); |
451 s4o.print("active && "); |
627 } |
452 print_step_argument(current_step, "elapsed_time"); |
628 else { |
453 if (strcmp(qualifier, "D") == 0) { |
629 s4o.print(" < "); |
454 s4o.print(" >= "); |
630 } |
455 } |
631 symbol->action_time->accept(*this); |
456 else { |
632 } |
457 s4o.print(" < "); |
633 s4o.print(") {\n"); |
458 } |
634 s4o.indent_right(); |
459 symbol->action_time->accept(*this); |
635 s4o.print(s4o.indent_spaces); |
460 } |
636 if (strcmp(qualifier, "N") == 0 || strcmp(qualifier, "P") == 0 || |
461 s4o.print(") {\n"); |
637 strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) { |
462 s4o.indent_right(); |
638 print_action_argument(current_action, "state"); |
463 s4o.print(s4o.indent_spaces); |
639 s4o.print(" = 1;\n"); |
464 if (strcmp(qualifier, "N") == 0 || strcmp(qualifier, "P") == 0 || |
640 } |
465 strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) { |
641 if (strcmp(qualifier, "SD") == 0 || strcmp(qualifier, "DS") == 0 || |
466 print_action_argument(current_action, "state"); |
642 strcmp(qualifier, "SL") == 0) { |
467 s4o.print(" = 1;\n"); |
643 if (strcmp(qualifier, "SL") == 0) { |
468 } |
644 print_action_argument(current_action, "reset_remaining_time"); |
469 if (strcmp(qualifier, "S") == 0) { |
645 } |
470 print_action_argument(current_action, "set"); |
646 else { |
471 s4o.print(" = 1;\n"); |
647 print_action_argument(current_action, "set_remaining_time"); |
472 } |
648 } |
473 if (strcmp(qualifier, "R") == 0) { |
649 s4o.print(" = "); |
474 print_action_argument(current_action, "reset"); |
650 symbol->action_time->accept(*this); |
475 s4o.print(" = 1;\n"); |
651 s4o.print(";\n"); |
476 } |
652 } |
477 if (strcmp(qualifier, "SD") == 0 || strcmp(qualifier, "DS") == 0 || |
653 s4o.indent_left(); |
478 strcmp(qualifier, "SL") == 0) { |
654 s4o.print(s4o.indent_spaces + "}"); |
479 if (strcmp(qualifier, "SL") == 0) { |
655 if (strcmp(qualifier, "DS") == 0) { |
480 print_action_argument(current_action, "reset_remaining_time"); |
656 s4o.print("desactivated"); |
481 } |
657 s4o.indent_right(); |
482 else { |
658 s4o.print(s4o.indent_spaces); |
483 print_action_argument(current_action, "set_remaining_time"); |
659 print_action_argument(current_action, "set_remaining_time"); |
484 } |
660 s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); |
485 s4o.print(" = "); |
|
486 symbol->action_time->accept(*this); |
|
487 s4o.print(";\n"); |
|
488 } |
|
489 s4o.indent_left(); |
|
490 s4o.print(s4o.indent_spaces + "}"); |
|
491 if (strcmp(qualifier, "DS") == 0) { |
|
492 s4o.print("desactivated"); |
|
493 s4o.indent_right(); |
|
494 s4o.print(s4o.indent_spaces); |
|
495 print_action_argument(current_action, "set_remaining_time"); |
|
496 s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); |
|
497 } |
|
498 } |
|
499 break; |
|
500 default: |
|
501 break; |
661 } |
502 } |
662 return NULL; |
503 return NULL; |
663 } |
504 } |
664 |
505 |
665 void *visit(qualifier_c *symbol) { |
506 void *visit(qualifier_c *symbol) { |
666 return (void *)symbol->value; |
507 return (void *)symbol->value; |
667 } |
508 } |
668 |
509 |
669 void *visit(timed_qualifier_c *symbol) { |
510 void *visit(timed_qualifier_c *symbol) { |
670 return (void *)symbol->value; |
511 return (void *)symbol->value; |
671 } |
|
672 |
|
673 }; /* generate_cc_sfc_actiondecl_c */ |
|
674 |
|
675 |
|
676 |
|
677 |
|
678 /***********************************************************************/ |
|
679 /***********************************************************************/ |
|
680 /***********************************************************************/ |
|
681 /***********************************************************************/ |
|
682 |
|
683 class generate_cc_sfc_actionexecution_c: public generate_cc_base_c { |
|
684 |
|
685 private: |
|
686 generate_cc_SFC_IL_ST_c *generate_cc_code; |
|
687 |
|
688 public: |
|
689 generate_cc_sfc_actionexecution_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) |
|
690 : generate_cc_base_c(s4o_ptr) { |
|
691 generate_cc_code = new generate_cc_SFC_IL_ST_c(s4o_ptr, scope, variable_prefix); |
|
692 this->set_variable_prefix(variable_prefix); |
|
693 } |
|
694 |
|
695 ~generate_cc_sfc_actionexecution_c(void) { |
|
696 delete generate_cc_code; |
|
697 } |
|
698 |
|
699 /*********************************************/ |
|
700 /* B.1.6 Sequential function chart elements */ |
|
701 /*********************************************/ |
|
702 |
|
703 void *visit(initial_step_c *symbol) {return NULL;} |
|
704 |
|
705 void *visit(step_c *symbol) {return NULL;} |
|
706 |
|
707 void *visit(transition_c *symbol) {return NULL;} |
|
708 |
|
709 void *visit(action_c *symbol) { |
|
710 s4o.print(s4o.indent_spaces + "if("); |
|
711 print_variable_prefix(); |
|
712 s4o.print("action_list["); |
|
713 s4o.print(SFC_STEP_ACTION_PREFIX); |
|
714 symbol->action_name->accept(*this); |
|
715 s4o.print("].state) {"); |
|
716 s4o.indent_right(); |
|
717 |
|
718 // generate action code |
|
719 symbol->function_block_body->accept(*generate_cc_code); |
|
720 |
|
721 s4o.indent_left(); |
|
722 s4o.print(s4o.indent_spaces + "}\n\n"); |
|
723 return NULL; |
|
724 } |
512 } |
725 |
513 |
726 }; /* generate_cc_sfc_actiondecl_c */ |
514 }; /* generate_cc_sfc_actiondecl_c */ |
727 |
515 |
728 |
516 |