View difference between Paste ID: uTvTmXze and hudeeH2W

 #include<stdio.h>
 #include<stdlib.h>
 #include<string.h>
 
 #define MAX_NAME_LENGTH 20
 #define STIMULI_AMOUNT 4
 #define STATE_AMOUNT 5
 
-enum Stimuli {
+enum Stimuli
 {
 	TurnOn,
 	TurnOff,
 	SpeedUp,
 	SpeedDown
 };
-enum State {
+
 enum State
 {
 	Off,
 	Stopped,
 	Walking,
 	Running,
 	Error
-struct Transition {
+
-	enum State prev_state;
+
-	enum Stimuli stimulus;
+
-	enum State next_state;
+
 
 struct FSM
 {
 	enum State curr_state;
-struct FSM {
+	enum State ** transition_logic;
 	const char* printable_stimuli[4];
-	transition ** transition_logic;
+
 };
 
 void stimulate (struct FSM* fsm, enum Stimuli stimulus);
 void print_transition (enum State previous, enum Stimuli stimulus, enum State newState, const char** printable_stimuli, const char** printable_states);
 void initialize (struct FSM* fsm);
-void print_transition (const transition trans, const char** printable_stimuli, const char** printable_states);
+
 int main (void)
 {
-int main (void) {
+
 	int input;
 	struct FSM the_machine;
 
 	initialize (&the_machine);
 	input = 0;
 
 	while (input != 4)
-	while (input != 4) {
+	{
 		printf("Input stimulus: 0_On, 1_Off, 2_SpUp, 3_SpDn, 4_Exit \n");
 		scanf("%i", &input);
 
-		if ((0 <= input) && (input < 4)){
+		if ((0 <= input) && (input < 4))
 		{
 			stimulate (&the_machine, input);
 		}
 	}
 
 	return EXIT_SUCCESS;
 
 }
-void stimulate(struct FSM* fsm, enum Stimuli stimulus) {
+
 void stimulate(struct FSM* fsm, enum Stimuli stimulus)
 {
 
 	enum State previous;
 
-	(*fsm).curr_state = (((*fsm).transition_logic)[previous][stimulus]).next_state;
+
 
-	print_transition (((*fsm).transition_logic)[previous][stimulus], (*fsm).printable_stimuli, (*fsm).printable_states);
+	(*fsm).curr_state = (((*fsm).transition_logic)[previous][stimulus]);
 
 	print_transition (previous, stimulus, (*fsm).curr_state, (*fsm).printable_stimuli, (*fsm).printable_states);
 
-void print_transition (const transition trans, const char** printable_stimuli, const char** printable_states) {
+
 
 void print_transition (const enum State previous, const enum Stimuli stimulus, const enum State newState, const char** printable_stimuli, const char** printable_states)
-	char stimulus[MAX_NAME_LENGTH];
+{
 
 	char prev_state[MAX_NAME_LENGTH];
-	strncpy (prev_state, printable_states[trans.prev_state], MAX_NAME_LENGTH);
+	char received_stimulus[MAX_NAME_LENGTH];
-	strncpy (stimulus, printable_stimuli[trans.stimulus], MAX_NAME_LENGTH);
+
-	strncpy (next_state, printable_states[trans.next_state], MAX_NAME_LENGTH);
+
 	strncpy (prev_state, printable_states[previous], MAX_NAME_LENGTH);
-	printf("[%s]---[%s]--->[%s]\n", prev_state, stimulus, next_state);
+	strncpy (received_stimulus, printable_stimuli[stimulus], MAX_NAME_LENGTH);
 	strncpy (next_state, printable_states[newState], MAX_NAME_LENGTH);
 
-void initialize (struct FSM* fsm) {
+	printf("[%s]---[%s]--->[%s]\n", prev_state, received_stimulus, next_state);
 }
 
 void initialize (struct FSM* fsm)
 {
 
-	(*fsm).printable_stimuli[0] = "TurnOn";
+
-	(*fsm).printable_stimuli[1] = "TurnOff";
+
-	(*fsm).printable_stimuli[2] = "SpeedUp";
+
-	(*fsm).printable_stimuli[3] = "SpeedDown";
+
 	(*fsm).printable_stimuli[TurnOn] = "TurnOn";
-	(*fsm).printable_states[0] = "Off";
+	(*fsm).printable_stimuli[TurnOff] = "TurnOff";
-	(*fsm).printable_states[1] = "Stopped";
+	(*fsm).printable_stimuli[SpeedUp] = "SpeedUp";
-	(*fsm).printable_states[2] = "Walking";
+	(*fsm).printable_stimuli[SpeedDown] = "SpeedDown";
-	(*fsm).printable_states[3] = "Running";
+
-	(*fsm).printable_states[4] = "Error";
+	(*fsm).printable_states[Off] = "Off";
 	(*fsm).printable_states[Stopped] = "Stopped";
-	(*fsm).transition_logic = (transition **) calloc (STATE_AMOUNT ,sizeof(transition*));
+	(*fsm).printable_states[Walking] = "Walking";
 	(*fsm).printable_states[Running] = "Running";
-	for (i=0; i<STATE_AMOUNT; i++) {
+	(*fsm).printable_states[Error] = "Error";
-		(*fsm).transition_logic[i] = (transition *) calloc (STIMULI_AMOUNT ,sizeof(transition));
+
 	(*fsm).transition_logic = (enum State **) calloc (STATE_AMOUNT ,sizeof(enum State *));
 
 	for (i=0; i<STATE_AMOUNT; i++)
 	{
-	(((*fsm).transition_logic)[0][0]).prev_state = Off;
+		(*fsm).transition_logic[i] = (enum State *) calloc (STIMULI_AMOUNT ,sizeof(enum State));
-	(((*fsm).transition_logic)[0][0]).stimulus = TurnOn;
+
-	(((*fsm).transition_logic)[0][0]).next_state = Stopped;
+
 	/** OFF STATE */
 	/* TURNON STIMULUS */
-	(((*fsm).transition_logic)[0][1]).prev_state = Off;
+	((*fsm).transition_logic)[Off][TurnOn] = Stopped;
-	(((*fsm).transition_logic)[0][1]).stimulus = TurnOff;
+
-	(((*fsm).transition_logic)[0][1]).next_state = Off;
+
 	((*fsm).transition_logic)[Off][TurnOff] = Off;
 
-	(((*fsm).transition_logic)[0][2]).prev_state = Off;
+
-	(((*fsm).transition_logic)[0][2]).stimulus = SpeedUp;
+	((*fsm).transition_logic)[Off][SpeedUp] = Error;
-	(((*fsm).transition_logic)[0][2]).next_state = Error;
+
 	/* SPEEDDOWN STIMULUS */
 	((*fsm).transition_logic)[Off][SpeedDown] = Error;
-	(((*fsm).transition_logic)[0][3]).prev_state = Off;
+
-	(((*fsm).transition_logic)[0][3]).stimulus = SpeedDown;
+
-	(((*fsm).transition_logic)[0][3]).next_state = Error;
+
 	((*fsm).transition_logic)[Stopped][TurnOn] = Error;
 
 	/* TURNOFF STIMULUS */
-	(((*fsm).transition_logic)[1][0]).prev_state = Stopped;
+	((*fsm).transition_logic)[Stopped][TurnOff] = Off;
-	(((*fsm).transition_logic)[1][0]).stimulus = TurnOn;
+
-	(((*fsm).transition_logic)[1][0]).next_state = Error;
+
 	((*fsm).transition_logic)[Stopped][SpeedUp] = Walking;
 
-	(((*fsm).transition_logic)[1][1]).prev_state = Stopped;
+
-	(((*fsm).transition_logic)[1][1]).stimulus = TurnOff;
+	((*fsm).transition_logic)[Stopped][SpeedDown] = Error;
-	(((*fsm).transition_logic)[1][1]).next_state = Off;
+
 	/** WALKING STATE */
 	/* TURNON STIMULUS */
-	(((*fsm).transition_logic)[1][2]).prev_state = Stopped;
+	((*fsm).transition_logic)[Walking][TurnOn] = Walking;
-	(((*fsm).transition_logic)[1][2]).stimulus = SpeedUp;
+
-	(((*fsm).transition_logic)[1][2]).next_state = Walking;
+
 	((*fsm).transition_logic)[Walking][TurnOff] = Off;
 
-	(((*fsm).transition_logic)[1][3]).prev_state = Stopped;
+
-	(((*fsm).transition_logic)[1][3]).stimulus = SpeedDown;
+	((*fsm).transition_logic)[Walking][SpeedUp] = Running;
-	(((*fsm).transition_logic)[1][3]).next_state = Error;
+
 	/* SPEEDDOWN STIMULUS */
 	((*fsm).transition_logic)[Walking][SpeedDown] = Stopped;
 
-	(((*fsm).transition_logic)[2][0]).prev_state = Walking;
+
-	(((*fsm).transition_logic)[2][0]).stimulus = TurnOn;
+
-	(((*fsm).transition_logic)[2][0]).next_state = Walking;
+	((*fsm).transition_logic)[Running][TurnOn] = Running;
 
 	/* TURNOFF STIMULUS */
-	(((*fsm).transition_logic)[2][1]).prev_state = Walking;
+	((*fsm).transition_logic)[Running][TurnOff] = Off;
-	(((*fsm).transition_logic)[2][1]).stimulus = TurnOff;
+
-	(((*fsm).transition_logic)[2][1]).next_state = Off;
+
 	((*fsm).transition_logic)[Running][SpeedUp] = Error;
 
-	(((*fsm).transition_logic)[2][2]).prev_state = Walking;
+
-	(((*fsm).transition_logic)[2][2]).stimulus = SpeedUp;
+	((*fsm).transition_logic)[Running][SpeedDown] = Walking;
-	(((*fsm).transition_logic)[2][2]).next_state = Running;
+
 	/** ERROR STATE */
 	/* TURNON STIMULUS */
-	(((*fsm).transition_logic)[2][3]).prev_state = Walking;
+	((*fsm).transition_logic)[Error][TurnOn] = Error;
-	(((*fsm).transition_logic)[2][3]).stimulus = SpeedDown;
+
-	(((*fsm).transition_logic)[2][3]).next_state = Stopped;
+
 	((*fsm).transition_logic)[Error][TurnOff] = Off;
 
 	/* SPEEDUP STIMULUS */
-	(((*fsm).transition_logic)[3][0]).prev_state = Running;
+	((*fsm).transition_logic)[Error][SpeedUp] = Error;
-	(((*fsm).transition_logic)[3][0]).stimulus = TurnOn;
+
-	(((*fsm).transition_logic)[3][0]).next_state = Running;
+
 	((*fsm).transition_logic)[Error][SpeedDown] = Error;
 
-	(((*fsm).transition_logic)[3][1]).prev_state = Running;
+