matiec: stage4/generate_cc/generate_cc_sfc.cc@501e9d494744 (annotated)

17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	1	/*
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	2	* (c) 2007 Mario de Sousa, Laurent Bessard
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	3	*
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	4	* Offered to the public under the terms of the GNU General Public License
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	5	* as published by the Free Software Foundation; either version 2 of the
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	6	* License, or (at your option) any later version.
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	7	*
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	8	* This program is distributed in the hope that it will be useful, but
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	11	* Public License for more details.
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	12	*
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	13	* This code is made available on the understanding that it will not be
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	14	* used in safety-critical situations without a full and competent review.
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	15	*/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	16
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	17	/*
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	18	* An IEC 61131-3 IL and ST compiler.
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	19	*
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	20	* Based on the
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	21	* FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	22	*
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	23	*/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	24
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	25
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	26	/*
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	27	* Conversion of sfc networks (i.e. SFC code).
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	28	*
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	29	* This is part of the 4th stage that generates
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	30	* a c++ source program equivalent to the SFC, IL and ST
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	31	* code.
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	32	*/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	33
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	34	#include <list>
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	35
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	36	typedef struct
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	37	{
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	38	transition_c *symbol;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	39	int priority;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	40	int index;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	41	} TRANSITION;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	42
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	43
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	44
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	45
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	46
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	47	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	48	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	49	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	50	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	51
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	52	class generate_cc_sfc_elements_c: public generate_cc_base_c {
19 cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	53
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	54	public:
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	55	typedef enum {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	56	transitionlist_sg,
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	57	transitiontest_sg,
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	58	stepset_sg,
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	59	stepreset_sg,
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	60	actionassociation_sg,
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	61	actionbody_sg
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	62	} sfcgeneration_t;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	63
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	64	private:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	65	generate_cc_il_c *generate_cc_il;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	66	generate_cc_st_c *generate_cc_st;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	67	generate_cc_SFC_IL_ST_c *generate_cc_code;
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	68	search_var_instance_decl_c *search_var_instance_decl;
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	69
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	70	int transition_number;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	71	std::list<TRANSITION> transition_list;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	72
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	73	symbol_c *current_step;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	74	symbol_c *current_action;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	75
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	76	sfcgeneration_t wanted_sfcgeneration;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	77
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	78	public:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	79	generate_cc_sfc_elements_c(stage4out_c s4o_ptr, symbol_c scope, const char *variable_prefix = NULL)
19 cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	80	: generate_cc_base_c(s4o_ptr) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	81	generate_cc_il = new generate_cc_il_c(s4o_ptr, scope, variable_prefix);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	82	generate_cc_st = new generate_cc_st_c(s4o_ptr, scope, variable_prefix);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	83	generate_cc_code = new generate_cc_SFC_IL_ST_c(s4o_ptr, scope, variable_prefix);
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	84	search_var_instance_decl = new search_var_instance_decl_c(scope);
19 cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	85	this->set_variable_prefix(variable_prefix);
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	86	}
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	87
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	88	~generate_cc_sfc_elements_c(void) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	89	delete generate_cc_il;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	90	delete generate_cc_st;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	91	delete generate_cc_code;
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	92	delete search_var_instance_decl;
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	93	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	94
19 cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	95	void reset_transition_number(void) {transition_number = 0;}
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	96
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	97	void generate(symbol_c *symbol, sfcgeneration_t generation_type) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	98	wanted_sfcgeneration = generation_type;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	99	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	100	case transitiontest_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	101	{
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	102	std::list<TRANSITION>::iterator pt;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	103	for(pt = transition_list.begin(); pt != transition_list.end(); pt++) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	104	transition_number = pt->index;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	105	pt->symbol->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	106	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	107	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	108	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	109	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	110	symbol->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	111	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	112	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	113	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	114
19 cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	115	void print_step_argument(symbol_c step_name, const char argument) {
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	116	print_variable_prefix();
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	117	s4o.print("step_list[");
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	118	s4o.print(SFC_STEP_ACTION_PREFIX);
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	119	step_name->accept(*this);
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	120	s4o.print("].");
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	121	s4o.print(argument);
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	122	}
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	123
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	124	void print_action_argument(symbol_c action_name, const char argument) {
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	125	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	126	s4o.print("action_list[");
18 e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	127	s4o.print(SFC_STEP_ACTION_PREFIX);
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	128	action_name->accept(*this);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	129	s4o.print("].");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	130	s4o.print(argument);
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	131	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	132
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	133	void print_transition_number(void) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	134	char str[10];
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	135	sprintf(str, "%d", transition_number);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	136	s4o.print(str);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	137	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	138
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	139	void print_reset_step(symbol_c *step_name) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	140	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	141	print_step_argument(step_name, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	142	s4o.print(" = 0;\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	143	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	144
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	145	void print_set_step(symbol_c *step_name) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	146	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	147	print_step_argument(step_name, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	148	s4o.print(" = 1;\n" + s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	149	print_step_argument(step_name, "elapsed_time");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	150	s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	151	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	152
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	153	bool is_variable(symbol_c *symbol) {
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	154	/* we try to find the variable instance declaration, to determine its type... */
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	155	symbol_c *var_decl = search_var_instance_decl->get_decl(symbol);
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	156
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	157	return var_decl != NULL;
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	158	}
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	159
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	160	/*********************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	161	/* B.1.6 Sequential function chart elements */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	162	/*********************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	163
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	164	void visit(initial_step_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	165	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	166	case actionassociation_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	167	if (((list_c*)symbol->action_association_list)->n > 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	168	s4o.print(s4o.indent_spaces + "// ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	169	symbol->step_name->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	170	s4o.print(" action associations\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	171	current_step = symbol->step_name;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	172	s4o.print(s4o.indent_spaces + "{\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	173	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	174	s4o.print(s4o.indent_spaces + "char activated = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	175	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	176	s4o.print(" && !");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	177	print_step_argument(current_step, "prev_state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	178	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	179	s4o.print(s4o.indent_spaces + "char desactivated = !");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	180	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	181	s4o.print(" && ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	182	print_step_argument(current_step, "prev_state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	183	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	184	s4o.print(s4o.indent_spaces + "char active = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	185	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	186	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	187	symbol->action_association_list->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	188	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	189	s4o.print(s4o.indent_spaces + "}\n\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	190	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	191	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	192	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	193	break;
18 e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	194	}
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	195	return NULL;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	196	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	197
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	198	void visit(step_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	199	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	200	case actionassociation_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	201	if (((list_c*)symbol->action_association_list)->n > 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	202	s4o.print(s4o.indent_spaces + "// ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	203	symbol->step_name->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	204	s4o.print(" action associations\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	205	current_step = symbol->step_name;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	206	s4o.print(s4o.indent_spaces + "{\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	207	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	208	s4o.print(s4o.indent_spaces + "char activated = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	209	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	210	s4o.print(" && !");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	211	print_step_argument(current_step, "prev_state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	212	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	213	s4o.print(s4o.indent_spaces + "char desactivated = !");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	214	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	215	s4o.print(" && ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	216	print_step_argument(current_step, "prev_state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	217	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	218	s4o.print(s4o.indent_spaces + "char active = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	219	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	220	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	221	symbol->action_association_list->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	222	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	223	s4o.print(s4o.indent_spaces + "}\n\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	224	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	225	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	226	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	227	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	228	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	229	return NULL;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	230	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	231
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	232	void visit(transition_c symbol) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	233	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	234	case transitionlist_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	235	{
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	236	TRANSITION *transition;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	237	transition = new TRANSITION;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	238	transition->symbol = symbol;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	239	transition->index = transition_number;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	240	if (symbol->integer != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	241	transition->priority = atoi(((token_c *)symbol->integer)->value);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	242	std::list<TRANSITION>::iterator pt = transition_list.begin();
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	243	while (pt != transition_list.end() && pt->priority <= transition->priority) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	244	pt++;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	245	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	246	transition_list.insert(pt, *transition);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	247	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	248	else {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	249	transition->priority = 0;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	250	transition_list.push_back(*transition);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	251	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	252	transition_number++;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	253	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	254	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	255	case transitiontest_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	256	s4o.print(s4o.indent_spaces + "if (");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	257	symbol->from_steps->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	258	s4o.print(") {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	259	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	260
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	261	// Calculate transition value
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	262	if (symbol->transition_condition_il != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	263	generate_cc_il->declare_backup_variable();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	264	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	265	symbol->transition_condition_il->accept(*generate_cc_il);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	266	print_variable_prefix();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	267	s4o.print("transition_list[");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	268	print_transition_number();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	269	s4o.print("] = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	270	generate_cc_il->print_backup_variable();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	271	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	272	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	273	if (symbol->transition_condition_st != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	274	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	275	print_variable_prefix();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	276	s4o.print("transition_list[");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	277	print_transition_number();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	278	s4o.print("] = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	279	symbol->transition_condition_st->accept(*generate_cc_st);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	280	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	281	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	282	if (symbol->integer != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	283	s4o.print(s4o.indent_spaces + "if (");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	284	print_variable_prefix();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	285	s4o.print("transition_list[");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	286	print_transition_number();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	287	s4o.print("]) {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	288	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	289	wanted_sfcgeneration = stepreset_sg;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	290	symbol->from_steps->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	291	wanted_sfcgeneration = transitiontest_sg;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	292	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	293	s4o.print(s4o.indent_spaces + "}\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	294	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	295	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	296	s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces + "else {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	297	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	298	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	299	print_variable_prefix();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	300	s4o.print("transition_list[");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	301	print_transition_number();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	302	s4o.print("] = 0;\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	303	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	304	s4o.print(s4o.indent_spaces + "}\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	305	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	306	case stepset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	307	s4o.print(s4o.indent_spaces + "if (");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	308	print_variable_prefix();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	309	s4o.print("transition_list[");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	310	print_transition_number();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	311	s4o.print("]) {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	312	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	313	symbol->to_steps->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	314	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	315	s4o.print(s4o.indent_spaces + "}\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	316	transition_number++;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	317	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	318	case stepreset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	319	if (symbol->integer == NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	320	s4o.print(s4o.indent_spaces + "if (");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	321	print_variable_prefix();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	322	s4o.print("transition_list[");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	323	print_transition_number();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	324	s4o.print("]) {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	325	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	326	symbol->from_steps->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	327	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	328	s4o.print(s4o.indent_spaces + "}\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	329	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	330	transition_number++;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	331	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	332	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	333	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	334	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	335	return NULL;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	336	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	337
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	338	void visit(action_c symbol) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	339	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	340	case actionbody_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	341	s4o.print(s4o.indent_spaces + "if(");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	342	print_variable_prefix();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	343	s4o.print("action_list[");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	344	s4o.print(SFC_STEP_ACTION_PREFIX);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	345	symbol->action_name->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	346	s4o.print("].state) {");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	347	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	348
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	349	// generate action code
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	350	symbol->function_block_body->accept(*generate_cc_code);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	351
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	352	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	353	s4o.print(s4o.indent_spaces + "}\n\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	354	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	355	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	356	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	357	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	358	return NULL;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	359	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	360
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	361	void visit(steps_c symbol) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	362	if (symbol->step_name != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	363	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	364	case transitiontest_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	365	print_step_argument(symbol->step_name, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	366	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	367	case stepset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	368	print_set_step(symbol->step_name);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	369	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	370	case stepreset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	371	print_reset_step(symbol->step_name);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	372	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	373	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	374	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	375	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	376	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	377	else if (symbol->step_name_list != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	378	symbol->step_name_list->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	379	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	380	return NULL;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	381	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	382
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	383	void visit(step_name_list_c symbol) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	384	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	385	case transitiontest_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	386	for(int i = 0; i < symbol->n; i++) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	387	print_step_argument(symbol->elements[i], "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	388	if (i < symbol->n - 1) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	389	s4o.print(" && ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	390	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	391	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	392	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	393	case stepset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	394	for(int i = 0; i < symbol->n; i++) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	395	print_set_step(symbol->elements[i]);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	396	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	397	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	398	case stepreset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	399	for(int i = 0; i < symbol->n; i++) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	400	print_reset_step(symbol->elements[i]);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	401	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	402	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	403	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	404	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	405	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	406	return NULL;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	407	}
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	408
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	409	void visit(action_association_list_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	410	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	411	case actionassociation_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	412	print_list(symbol, "", "\n", "\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	413	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	414	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	415	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	416	}
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	417	return NULL;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	418	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	419
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	420	void visit(action_association_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	421	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	422	case actionassociation_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	423	if (symbol->action_qualifier != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	424	current_action = symbol->action_name;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	425	symbol->action_qualifier->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	426	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	427	else {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	428	s4o.print(s4o.indent_spaces + "if (");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	429	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	430	s4o.print(") {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	431	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	432	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	433	print_action_argument(symbol->action_name, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	434	s4o.print(" = 1;\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	435	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	436	s4o.print(s4o.indent_spaces + "}");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	437	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	438	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	439	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	440	break;
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	441	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	442	return NULL;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	443	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	444
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	445	void visit(action_qualifier_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	446	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	447	case actionassociation_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	448	{
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	449	char qualifier = (char )symbol->action_qualifier->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	450	s4o.print(s4o.indent_spaces + "if (");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	451	if (strcmp(qualifier, "N") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	452	s4o.print("active");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	453	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	454	if (strcmp(qualifier, "P") == 0 \|\| strcmp(qualifier, "SD") == 0 \|\|
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	455	strcmp(qualifier, "DS") == 0 \|\| strcmp(qualifier, "SL") == 0 \|\|
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	456	strcmp(qualifier, "S") == 0 \|\| strcmp(qualifier, "R") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	457	s4o.print("activated");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	458	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	459	if (strcmp(qualifier, "D") == 0 \|\| strcmp(qualifier, "L") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	460	s4o.print("active && ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	461	print_step_argument(current_step, "elapsed_time");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	462	if (strcmp(qualifier, "D") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	463	s4o.print(" >= ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	464	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	465	else {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	466	s4o.print(" < ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	467	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	468	symbol->action_time->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	469	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	470	s4o.print(") {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	471	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	472	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	473	if (strcmp(qualifier, "N") == 0 \|\| strcmp(qualifier, "P") == 0 \|\|
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	474	strcmp(qualifier, "D") == 0 \|\| strcmp(qualifier, "L") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	475	print_action_argument(current_action, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	476	s4o.print(" = 1;\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	477	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	478	if (strcmp(qualifier, "S") == 0) {
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	479	if (is_variable(current_action)) {
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	480	print_variable_prefix();
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	481	current_action->accept(*this);
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	482	}
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	483	else
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	484	print_action_argument(current_action, "set");
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	485	s4o.print(" = 1;\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	486	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	487	if (strcmp(qualifier, "R") == 0) {
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	488	if (is_variable(current_action)) {
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	489	print_variable_prefix();
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	490	current_action->accept(*this);
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	491	s4o.print(" = 0;\n");
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	492	}
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	493	else {
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	494	print_action_argument(current_action, "reset");
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	495	s4o.print(" = 1;\n");
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	496	}
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	497	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	498	if (strcmp(qualifier, "SD") == 0 \|\| strcmp(qualifier, "DS") == 0 \|\|
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	499	strcmp(qualifier, "SL") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	500	if (strcmp(qualifier, "SL") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	501	print_action_argument(current_action, "reset_remaining_time");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	502	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	503	else {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	504	print_action_argument(current_action, "set_remaining_time");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	505	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	506	s4o.print(" = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	507	symbol->action_time->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	508	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	509	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	510	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	511	s4o.print(s4o.indent_spaces + "}");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	512	if (strcmp(qualifier, "DS") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	513	s4o.print("desactivated");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	514	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	515	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	516	print_action_argument(current_action, "set_remaining_time");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	517	s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	518	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	519	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	520	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	521	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	522	break;
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	523	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	524	return NULL;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	525	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	526
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	527	void visit(qualifier_c symbol) {
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	528	return (void *)symbol->value;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	529	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	530
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	531	void visit(timed_qualifier_c symbol) {
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	532	return (void *)symbol->value;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	533	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	534
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	535	}; /* generate_cc_sfc_actiondecl_c */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	536
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	537
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	538
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	539	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	540	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	541	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	542	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	543
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	544	class generate_cc_sfc_c: public generate_cc_typedecl_c {
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	545
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	546	private:
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	547	generate_cc_sfc_elements_c *generate_cc_sfc_elements;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	548
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	549	public:
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	550	generate_cc_sfc_c(stage4out_c s4o_ptr, symbol_c scope, const char *variable_prefix = NULL)
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	551	: generate_cc_typedecl_c(s4o_ptr) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	552	generate_cc_sfc_elements = new generate_cc_sfc_elements_c(s4o_ptr, scope, variable_prefix);
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	553	this->set_variable_prefix(variable_prefix);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	554	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	555
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	556	virtual ~generate_cc_sfc_c(void) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	557	delete generate_cc_sfc_elements;
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	558	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	559
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	560	/*********************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	561	/* B.1.6 Sequential function chart elements */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	562	/*********************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	563
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	564	void visit(sfc_network_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	565	generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::transitionlist_sg);
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	566	s4o.print(s4o.indent_spaces +"INT i;\n\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	567	s4o.print(s4o.indent_spaces +"BOOL transition;\n\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	568
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	569	/* generate step initilizations */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	570	s4o.print(s4o.indent_spaces + "// Steps initialisation\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	571	s4o.print(s4o.indent_spaces + "for (i = 0; i < ");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	572	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	573	s4o.print("nb_steps; i++) {\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	574	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	575	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	576	print_variable_prefix();
18 e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	577	s4o.print("step_list[i].prev_state = ");
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	578	print_variable_prefix();
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	579	s4o.print("step_list[i].state;\n");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	580	s4o.print(s4o.indent_spaces + "if (");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	581	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	582	s4o.print("step_list[i].state) {\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	583	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	584	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	585	print_variable_prefix();
41 8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	586	s4o.print("step_list[i].elapsed_time = __time_add(");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	587	print_variable_prefix();
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	588	s4o.print("step_list[i].elapsed_time, ");
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	589	print_variable_prefix();
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	590	s4o.print("period);\n");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	591	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	592	s4o.print(s4o.indent_spaces + "}\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	593	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	594	s4o.print(s4o.indent_spaces + "}\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	595
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	596	/* generate action initilizations */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	597	s4o.print(s4o.indent_spaces + "// Actions initialisation\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	598	s4o.print(s4o.indent_spaces + "for (i = 0; i < ");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	599	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	600	s4o.print("nb_actions; i++) {\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	601	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	602	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	603	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	604	s4o.print("action_list[i].state = 0;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	605	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	606	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	607	s4o.print("action_list[i].set = 0;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	608	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	609	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	610	s4o.print("action_list[i].reset = 0;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	611	s4o.print(s4o.indent_spaces + "if (");
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	612	s4o.print("__gt_TIME(2, ");
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	613	print_variable_prefix();
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	614	s4o.print("action_list[i].set_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n");
41 8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	615	s4o.indent_right();
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	616	s4o.print(s4o.indent_spaces);
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	617	print_variable_prefix();
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	618	s4o.print("action_list[i].set_remaining_time = __time_sub(");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	619	print_variable_prefix();
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	620	s4o.print("action_list[i].set_remaining_time, ");
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	621	print_variable_prefix();
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	622	s4o.print("period);\n");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	623	s4o.print(s4o.indent_spaces + "if (");
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	624	s4o.print("__le_TIME(2, ");
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	625	print_variable_prefix();
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	626	s4o.print("action_list[i].set_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	627	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	628	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	629	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	630	s4o.print("action_list[i].set_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	631	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	632	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	633	s4o.print("action_list[i].set = 1;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	634	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	635	s4o.print(s4o.indent_spaces + "}\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	636	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	637	s4o.print(s4o.indent_spaces + "}\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	638	s4o.print(s4o.indent_spaces + "if (");
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	639	s4o.print("__gt_TIME(2, ");
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	640	print_variable_prefix();
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	641	s4o.print("action_list[i].reset_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n");
41 8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	642	s4o.indent_right();
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	643	s4o.print(s4o.indent_spaces);
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	644	print_variable_prefix();
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	645	s4o.print("action_list[i].reset_remaining_time = __time_sub(");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	646	print_variable_prefix();
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	647	s4o.print("action_list[i].reset_remaining_time, ");
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	648	print_variable_prefix();
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	649	s4o.print("period);\n");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	650	s4o.print(s4o.indent_spaces + "if (");
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	651	s4o.print("__le_TIME(2, ");
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	652	print_variable_prefix();
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	653	s4o.print("action_list[i].reset_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	654	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	655	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	656	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	657	s4o.print("action_list[i].reset_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	658	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	659	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	660	s4o.print("action_list[i].reset = 1;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	661	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	662	s4o.print(s4o.indent_spaces + "}\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	663	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	664	s4o.print(s4o.indent_spaces + "}\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	665	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	666	s4o.print(s4o.indent_spaces + "}\n\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	667
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	668	/* generate transition tests */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	669	s4o.print(s4o.indent_spaces + "// Transitions fire test\n");
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	670	generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::transitiontest_sg);
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	671	s4o.print("\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	672
18 e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	673	/* generate transition reset steps */
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	674	s4o.print(s4o.indent_spaces + "// Transitions reset steps\n");
53 7f0cea717342 Bug into generate_cc_sfc fixed lbessard parents: 52 diff changeset	675	generate_cc_sfc_elements->reset_transition_number();
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	676	generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::stepreset_sg);
18 e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	677	s4o.print("\n");
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	678
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	679	/* generate transition set steps */
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	680	s4o.print(s4o.indent_spaces + "// Transitions set steps\n");
53 7f0cea717342 Bug into generate_cc_sfc fixed lbessard parents: 52 diff changeset	681	generate_cc_sfc_elements->reset_transition_number();
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	682	generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::stepset_sg);
18 e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	683	s4o.print("\n");
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	684
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	685	/* generate step association */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	686	s4o.print(s4o.indent_spaces + "// Steps association\n");
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	687	generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::actionassociation_sg);
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	688	s4o.print("\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	689
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	690	/* generate action state evaluation */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	691	s4o.print(s4o.indent_spaces + "// Actions state evaluation\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	692	s4o.print(s4o.indent_spaces + "for (i = 0; i < ");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	693	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	694	s4o.print("nb_actions; i++) {\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	695	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	696	s4o.print(s4o.indent_spaces + "if (");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	697	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	698	s4o.print("action_list[i].set) {\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	699	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	700	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	701	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	702	s4o.print("action_list[i].stored = 1;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	703	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	704	s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces + "if (");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	705	print_variable_prefix();
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	706	s4o.print("action_list[i].reset) {\n");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	707	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	708	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	709	print_variable_prefix();
66 501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	710	s4o.print("action_list[i].set_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n" + s4o.indent_spaces);
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	711	print_variable_prefix();
501e9d494744 Bugs on SFC generation fixed lbessard parents: 53 diff changeset	712	s4o.print("action_list[i].reset_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n" + s4o.indent_spaces);
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	713	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	714	s4o.print("action_list[i].stored = 0;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	715	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	716	s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	717	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	718	s4o.print("action_list[i].state \|= ");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	719	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	720	s4o.print("action_list[i].stored;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	721	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	722	s4o.print(s4o.indent_spaces + "}\n\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	723
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	724	/* generate action execution */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	725	s4o.print(s4o.indent_spaces + "// Actions execution\n");
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	726	generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::actionbody_sg);
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	727	s4o.print("\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	728
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	729	return NULL;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	730	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	731
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	732	void generate(sequential_function_chart_c *sfc) {
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	733	sfc->accept(*this);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	734	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	735
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	736	}; /* generate_cc_sfc_c */

author	lbessard
	Wed, 17 Oct 2007 17:51:24 +0200
changeset 66	501e9d494744
parent 53	7f0cea717342
permissions	-rw-r--r--