matiec: stage4/generate_cc/generate_cc_sfc.cc@7f0cea717342 (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;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	68
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	69	int transition_number;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	70	std::list<TRANSITION> transition_list;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	71
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	72	symbol_c *current_step;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	73	symbol_c *current_action;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	74
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	75	sfcgeneration_t wanted_sfcgeneration;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	76
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	77	public:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	78	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	79	: generate_cc_base_c(s4o_ptr) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	80	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	81	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	82	generate_cc_code = new generate_cc_SFC_IL_ST_c(s4o_ptr, scope, variable_prefix);
19 cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	83	this->set_variable_prefix(variable_prefix);
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	84	}
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	85
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	86	~generate_cc_sfc_elements_c(void) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	87	delete generate_cc_il;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	88	delete generate_cc_st;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	89	delete generate_cc_code;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	90	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	91
19 cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	92	void reset_transition_number(void) {transition_number = 0;}
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	void generate(symbol_c *symbol, sfcgeneration_t generation_type) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	95	wanted_sfcgeneration = generation_type;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	96	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	97	case transitiontest_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	98	{
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	99	std::list<TRANSITION>::iterator pt;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	100	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	101	transition_number = pt->index;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	102	pt->symbol->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	103	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	104	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	105	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	106	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	107	symbol->accept(*this);
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	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	110	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	111
19 cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	112	void print_step_argument(symbol_c step_name, const char argument) {
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	113	print_variable_prefix();
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	114	s4o.print("step_list[");
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	115	s4o.print(SFC_STEP_ACTION_PREFIX);
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	116	step_name->accept(*this);
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	117	s4o.print("].");
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	118	s4o.print(argument);
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	119	}
cee3c4e5afe2 Adding priority support for transitions in SFC lbessard parents: 18 diff changeset	120
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	121	void print_action_argument(symbol_c action_name, const char argument) {
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	122	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	123	s4o.print("action_list[");
18 e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	124	s4o.print(SFC_STEP_ACTION_PREFIX);
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	125	action_name->accept(*this);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	126	s4o.print("].");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	127	s4o.print(argument);
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	128	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	129
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	130	void print_transition_number(void) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	131	char str[10];
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	132	sprintf(str, "%d", transition_number);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	133	s4o.print(str);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	134	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	135
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	136	void print_reset_step(symbol_c *step_name) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	137	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	138	print_step_argument(step_name, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	139	s4o.print(" = 0;\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	140	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	141
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	142	void print_set_step(symbol_c *step_name) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	143	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	144	print_step_argument(step_name, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	145	s4o.print(" = 1;\n" + s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	146	print_step_argument(step_name, "elapsed_time");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	147	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	148	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	149
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	150
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	151	/*********************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	152	/* B.1.6 Sequential function chart elements */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	153	/*********************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	154
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	155	void visit(initial_step_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	156	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	157	case actionassociation_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	158	if (((list_c*)symbol->action_association_list)->n > 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	159	s4o.print(s4o.indent_spaces + "// ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	160	symbol->step_name->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	161	s4o.print(" action associations\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	162	current_step = symbol->step_name;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	163	s4o.print(s4o.indent_spaces + "{\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	164	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	165	s4o.print(s4o.indent_spaces + "char activated = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	166	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	167	s4o.print(" && !");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	168	print_step_argument(current_step, "prev_state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	169	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	170	s4o.print(s4o.indent_spaces + "char desactivated = !");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	171	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	172	s4o.print(" && ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	173	print_step_argument(current_step, "prev_state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	174	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	175	s4o.print(s4o.indent_spaces + "char active = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	176	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	177	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	178	symbol->action_association_list->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	179	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	180	s4o.print(s4o.indent_spaces + "}\n\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	181	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	182	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	183	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	184	break;
18 e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	185	}
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	186	return NULL;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	187	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	188
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	189	void visit(step_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	190	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	191	case actionassociation_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	192	if (((list_c*)symbol->action_association_list)->n > 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	193	s4o.print(s4o.indent_spaces + "// ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	194	symbol->step_name->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	195	s4o.print(" action associations\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	196	current_step = symbol->step_name;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	197	s4o.print(s4o.indent_spaces + "{\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	198	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	199	s4o.print(s4o.indent_spaces + "char activated = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	200	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	201	s4o.print(" && !");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	202	print_step_argument(current_step, "prev_state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	203	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	204	s4o.print(s4o.indent_spaces + "char desactivated = !");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	205	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	206	s4o.print(" && ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	207	print_step_argument(current_step, "prev_state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	208	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	209	s4o.print(s4o.indent_spaces + "char active = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	210	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	211	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	212	symbol->action_association_list->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	213	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	214	s4o.print(s4o.indent_spaces + "}\n\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	215	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	216	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	217	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	218	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	219	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	220	return NULL;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	221	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	222
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	223	void visit(transition_c symbol) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	224	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	225	case transitionlist_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	226	{
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	227	TRANSITION *transition;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	228	transition = new TRANSITION;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	229	transition->symbol = symbol;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	230	transition->index = transition_number;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	231	if (symbol->integer != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	232	transition->priority = atoi(((token_c *)symbol->integer)->value);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	233	std::list<TRANSITION>::iterator pt = transition_list.begin();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	234	while (pt != transition_list.end() && pt->priority > transition->priority) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	235	pt++;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	236	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	237	transition_list.insert(pt, *transition);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	238	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	239	else {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	240	transition->priority = 0;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	241	transition_list.push_back(*transition);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	242	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	243	transition_number++;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	244	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	245	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	246	case transitiontest_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	247	s4o.print(s4o.indent_spaces + "if (");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	248	symbol->from_steps->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	249	s4o.print(") {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	250	s4o.indent_right();
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	// Calculate transition value
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	253	if (symbol->transition_condition_il != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	254	generate_cc_il->declare_backup_variable();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	255	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	256	symbol->transition_condition_il->accept(*generate_cc_il);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	257	print_variable_prefix();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	258	s4o.print("transition_list[");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	259	print_transition_number();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	260	s4o.print("] = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	261	generate_cc_il->print_backup_variable();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	262	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	263	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	264	if (symbol->transition_condition_st != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	265	s4o.print(s4o.indent_spaces);
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	symbol->transition_condition_st->accept(*generate_cc_st);
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->integer != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	274	s4o.print(s4o.indent_spaces + "if (");
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("]) {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	279	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	280	wanted_sfcgeneration = stepreset_sg;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	281	symbol->from_steps->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	282	wanted_sfcgeneration = transitiontest_sg;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	283	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	284	s4o.print(s4o.indent_spaces + "}\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	285	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	286	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	287	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	288	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	289	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	290	print_variable_prefix();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	291	s4o.print("transition_list[");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	292	print_transition_number();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	293	s4o.print("] = 0;\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	294	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	295	s4o.print(s4o.indent_spaces + "}\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	296	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	297	case stepset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	298	s4o.print(s4o.indent_spaces + "if (");
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("]) {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	303	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	304	symbol->to_steps->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	305	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	306	s4o.print(s4o.indent_spaces + "}\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	307	transition_number++;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	308	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	309	case stepreset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	310	if (symbol->integer == NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	311	s4o.print(s4o.indent_spaces + "if (");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	312	print_variable_prefix();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	313	s4o.print("transition_list[");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	314	print_transition_number();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	315	s4o.print("]) {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	316	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	317	symbol->from_steps->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	318	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	319	s4o.print(s4o.indent_spaces + "}\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	320	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	321	transition_number++;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	322	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	323	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	324	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	325	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	326	return NULL;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	327	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	328
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	329	void visit(action_c symbol) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	330	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	331	case actionbody_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	332	s4o.print(s4o.indent_spaces + "if(");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	333	print_variable_prefix();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	334	s4o.print("action_list[");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	335	s4o.print(SFC_STEP_ACTION_PREFIX);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	336	symbol->action_name->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	337	s4o.print("].state) {");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	338	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	339
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	340	// generate action code
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	341	symbol->function_block_body->accept(*generate_cc_code);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	342
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	343	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	344	s4o.print(s4o.indent_spaces + "}\n\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	345	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	346	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	347	break;
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	return NULL;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	350	}
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	void visit(steps_c symbol) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	353	if (symbol->step_name != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	354	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	355	case transitiontest_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	356	print_step_argument(symbol->step_name, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	357	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	358	case stepset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	359	print_set_step(symbol->step_name);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	360	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	361	case stepreset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	362	print_reset_step(symbol->step_name);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	363	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	364	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	365	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	366	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	367	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	368	else if (symbol->step_name_list != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	369	symbol->step_name_list->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	370	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	371	return NULL;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	372	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	373
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	374	void visit(step_name_list_c symbol) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	375	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	376	case transitiontest_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	377	for(int i = 0; i < symbol->n; i++) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	378	print_step_argument(symbol->elements[i], "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	379	if (i < symbol->n - 1) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	380	s4o.print(" && ");
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	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	384	case stepset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	385	for(int i = 0; i < symbol->n; i++) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	386	print_set_step(symbol->elements[i]);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	387	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	388	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	389	case stepreset_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	390	for(int i = 0; i < symbol->n; i++) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	391	print_reset_step(symbol->elements[i]);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	392	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	393	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	394	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	395	break;
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	return NULL;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	398	}
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	399
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	400	void visit(action_association_list_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	401	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	402	case actionassociation_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	403	print_list(symbol, "", "\n", "\n");
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	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	406	break;
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	return NULL;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	409	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	410
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	411	void visit(action_association_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	412	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	413	case actionassociation_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	414	if (symbol->action_qualifier != NULL) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	415	current_action = symbol->action_name;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	416	symbol->action_qualifier->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	417	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	418	else {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	419	s4o.print(s4o.indent_spaces + "if (");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	420	print_step_argument(current_step, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	421	s4o.print(") {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	422	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	423	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	424	print_action_argument(symbol->action_name, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	425	s4o.print(" = 1;\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	426	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	427	s4o.print(s4o.indent_spaces + "}");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	428	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	429	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	430	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	431	break;
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	432	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	433	return NULL;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	434	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	435
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	436	void visit(action_qualifier_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	437	switch (wanted_sfcgeneration) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	438	case actionassociation_sg:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	439	{
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	440	char qualifier = (char )symbol->action_qualifier->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	441	s4o.print(s4o.indent_spaces + "if (");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	442	if (strcmp(qualifier, "N") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	443	s4o.print("active");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	444	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	445	if (strcmp(qualifier, "P") == 0 \|\| strcmp(qualifier, "SD") == 0 \|\|
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	446	strcmp(qualifier, "DS") == 0 \|\| strcmp(qualifier, "SL") == 0 \|\|
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	447	strcmp(qualifier, "S") == 0 \|\| strcmp(qualifier, "R") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	448	s4o.print("activated");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	449	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	450	if (strcmp(qualifier, "D") == 0 \|\| strcmp(qualifier, "L") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	451	s4o.print("active && ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	452	print_step_argument(current_step, "elapsed_time");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	453	if (strcmp(qualifier, "D") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	454	s4o.print(" >= ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	455	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	456	else {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	457	s4o.print(" < ");
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	symbol->action_time->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	460	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	461	s4o.print(") {\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	462	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	463	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	464	if (strcmp(qualifier, "N") == 0 \|\| strcmp(qualifier, "P") == 0 \|\|
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	465	strcmp(qualifier, "D") == 0 \|\| strcmp(qualifier, "L") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	466	print_action_argument(current_action, "state");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	467	s4o.print(" = 1;\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	468	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	469	if (strcmp(qualifier, "S") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	470	print_action_argument(current_action, "set");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	471	s4o.print(" = 1;\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	472	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	473	if (strcmp(qualifier, "R") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	474	print_action_argument(current_action, "reset");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	475	s4o.print(" = 1;\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	476	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	477	if (strcmp(qualifier, "SD") == 0 \|\| strcmp(qualifier, "DS") == 0 \|\|
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	478	strcmp(qualifier, "SL") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	479	if (strcmp(qualifier, "SL") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	480	print_action_argument(current_action, "reset_remaining_time");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	481	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	482	else {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	483	print_action_argument(current_action, "set_remaining_time");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	484	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	485	s4o.print(" = ");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	486	symbol->action_time->accept(*this);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	487	s4o.print(";\n");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	488	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	489	s4o.indent_left();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	490	s4o.print(s4o.indent_spaces + "}");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	491	if (strcmp(qualifier, "DS") == 0) {
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	492	s4o.print("desactivated");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	493	s4o.indent_right();
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	494	s4o.print(s4o.indent_spaces);
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	495	print_action_argument(current_action, "set_remaining_time");
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	496	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	497	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	498	}
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	499	break;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	500	default:
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	501	break;
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	502	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	503	return NULL;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	504	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	505
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	506	void visit(qualifier_c symbol) {
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	507	return (void *)symbol->value;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	508	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	509
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	510	void visit(timed_qualifier_c symbol) {
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	511	return (void *)symbol->value;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	512	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	513
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	514	}; /* generate_cc_sfc_actiondecl_c */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	515
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	516
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	517
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	518	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	519	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	520	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	521	/***********************************************************************/
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	522
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	523	class generate_cc_sfc_c: public generate_cc_typedecl_c {
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	524
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	525	private:
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	526	generate_cc_sfc_elements_c *generate_cc_sfc_elements;
f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	527
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	528	public:
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	529	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	530	: generate_cc_typedecl_c(s4o_ptr) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	531	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	532	this->set_variable_prefix(variable_prefix);
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	virtual ~generate_cc_sfc_c(void) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	536	delete generate_cc_sfc_elements;
17 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	/* B.1.6 Sequential function chart elements */
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	void visit(sfc_network_c symbol) {
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	544	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	545	s4o.print(s4o.indent_spaces +"INT i;\n\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	546	s4o.print(s4o.indent_spaces +"BOOL transition;\n\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	547
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	548	/* generate step initilizations */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	549	s4o.print(s4o.indent_spaces + "// Steps initialisation\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	550	s4o.print(s4o.indent_spaces + "for (i = 0; i < ");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	551	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	552	s4o.print("nb_steps; i++) {\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	553	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	554	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	555	print_variable_prefix();
18 e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	556	s4o.print("step_list[i].prev_state = ");
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	557	print_variable_prefix();
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	558	s4o.print("step_list[i].state;\n");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	559	s4o.print(s4o.indent_spaces + "if (");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	560	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	561	s4o.print("step_list[i].state) {\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	562	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	563	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	564	print_variable_prefix();
41 8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	565	s4o.print("step_list[i].elapsed_time = __time_add(");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	566	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	567	s4o.print("step_list[i].elapsed_time, PERIOD);\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	568	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	569	s4o.print(s4o.indent_spaces + "}\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	570	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	571	s4o.print(s4o.indent_spaces + "}\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	572
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	573	/* generate action initilizations */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	574	s4o.print(s4o.indent_spaces + "// Actions initialisation\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	575	s4o.print(s4o.indent_spaces + "for (i = 0; i < ");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	576	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	577	s4o.print("nb_actions; i++) {\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	578	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	579	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	580	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	581	s4o.print("action_list[i].state = 0;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	582	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	583	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	584	s4o.print("action_list[i].set = 0;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	585	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	586	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	587	s4o.print("action_list[i].reset = 0;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	588	s4o.print(s4o.indent_spaces + "if (");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	589	print_variable_prefix();
41 8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	590	s4o.print("__gt_TIME(action_list[i].set_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0)) {\n");
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	591	s4o.indent_right();
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	592	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	593	print_variable_prefix();
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	594	s4o.print("action_list[i].set_remaining_time = __time_sub(");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	595	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	596	s4o.print("action_list[i].set_remaining_time, PERIOD);\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	597	s4o.print(s4o.indent_spaces + "if (");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	598	print_variable_prefix();
41 8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	599	s4o.print("__le_TIME(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	600	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	601	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	602	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	603	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	604	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	605	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	606	s4o.print("action_list[i].set = 1;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	607	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	608	s4o.print(s4o.indent_spaces + "}\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	609	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	610	s4o.print(s4o.indent_spaces + "}\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	611	s4o.print(s4o.indent_spaces + "if (");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	612	print_variable_prefix();
41 8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	613	s4o.print("__gt_TIME(action_list[i].reset_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0)) {\n");
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	614	s4o.indent_right();
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	615	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	616	print_variable_prefix();
8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	617	s4o.print("action_list[i].reset_remaining_time = __time_sub(");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	618	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	619	s4o.print("action_list[i].reset_remaining_time, PERIOD);\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	620	s4o.print(s4o.indent_spaces + "if (");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	621	print_variable_prefix();
41 8998c8b24b60 First working IEC std lib test, actually test from string and to_string functions. etisserant parents: 22 diff changeset	622	s4o.print("__le_TIME(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	623	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	624	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	625	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	626	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	627	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	628	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	629	s4o.print("action_list[i].reset = 1;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	630	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	631	s4o.print(s4o.indent_spaces + "}\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	632	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	633	s4o.print(s4o.indent_spaces + "}\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\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	636
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	637	/* generate transition tests */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	638	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	639	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	640	s4o.print("\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	641
18 e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	642	/* generate transition reset steps */
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	643	s4o.print(s4o.indent_spaces + "// Transitions reset steps\n");
53 7f0cea717342 Bug into generate_cc_sfc fixed lbessard parents: 52 diff changeset	644	generate_cc_sfc_elements->reset_transition_number();
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	645	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	646	s4o.print("\n");
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	647
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	648	/* generate transition set steps */
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	649	s4o.print(s4o.indent_spaces + "// Transitions set steps\n");
53 7f0cea717342 Bug into generate_cc_sfc fixed lbessard parents: 52 diff changeset	650	generate_cc_sfc_elements->reset_transition_number();
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	651	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	652	s4o.print("\n");
e6af5eb5f546 SFC generator improved lbessard parents: 17 diff changeset	653
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	654	/* generate step association */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	655	s4o.print(s4o.indent_spaces + "// Steps association\n");
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	656	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	657	s4o.print("\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	658
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	659	/* generate action state evaluation */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	660	s4o.print(s4o.indent_spaces + "// Actions state evaluation\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	661	s4o.print(s4o.indent_spaces + "for (i = 0; i < ");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	662	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	663	s4o.print("nb_actions; i++) {\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	664	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	665	s4o.print(s4o.indent_spaces + "if (");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	666	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	667	s4o.print("action_list[i].set) {\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	668	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	669	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	670	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	671	s4o.print("action_list[i].stored = 1;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	672	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	673	s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces + "if (");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	674	print_variable_prefix();
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	675	s4o.print("action_list[i].reset) {\n");
17 38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	676	s4o.indent_right();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	677	s4o.print(s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	678	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	679	s4o.print("action_list[i].set_remaining_time = 0;\n" + s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	680	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	681	s4o.print("action_list[i].reset_remaining_time = 0;\n" + s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	682	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	683	s4o.print("action_list[i].stored = 0;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	684	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	685	s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	686	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	687	s4o.print("action_list[i].state \|= ");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	688	print_variable_prefix();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	689	s4o.print("action_list[i].stored;\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	690	s4o.indent_left();
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	691	s4o.print(s4o.indent_spaces + "}\n\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	692
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	693	/* generate action execution */
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	694	s4o.print(s4o.indent_spaces + "// Actions execution\n");
52 f44458d1fa29 Adding SET (S) and RESET(R) to action qualifier lbessard parents: 45 diff changeset	695	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	696	s4o.print("\n");
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	697
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	698	return NULL;
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	699	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	700
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	701	void generate(sequential_function_chart_c *sfc) {
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	702	sfc->accept(*this);
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	703	}
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	704
38754701ac41 SFC state machine first approach generator implemented lbessard parents: diff changeset	705	}; /* generate_cc_sfc_c */

author	lbessard
	Mon, 27 Aug 2007 17:38:26 +0200
changeset 53	7f0cea717342
parent 52	f44458d1fa29
child 66	501e9d494744
permissions	-rw-r--r--