From 78bac11a3c463e8252445cdffa3b51dc6bb60cc6 Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Sat, 23 Jun 2018 20:11:19 -0600 Subject: [PATCH 1/7] Update makefile to format all c|h files. --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 33b265c..be5d5a4 100644 --- a/Makefile +++ b/Makefile @@ -8,4 +8,4 @@ clean: @make -C src clean format: - find src/ -maxdepth 1 -iname *.h -o -iname *.c | xargs clang-format -i + find src/ -iname *.h -o -iname *.c | xargs clang-format -i From c10310ce0e76d6c25d62b7f74e377db3f707e52b Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Sat, 23 Jun 2018 20:15:40 -0600 Subject: [PATCH 2/7] formatting option --- src/examples/dhcpclient/src/dhcpc.c | 13 +- src/examples/dhcpclient/src/dhcpc.h | 4 +- src/examples/dhcpclient/src/dhcpclient.c | 102 ++-- src/examples/simple/simple.c | 11 +- src/tests/common.c | 84 ++- src/tests/common.h | 18 +- src/tests/test_argouml.c | 8 +- src/tests/test_choice.c | 51 +- src/tests/test_choice2.c | 45 +- src/tests/test_compound_transition.c | 43 +- src/tests/test_conref.c | 106 +--- src/tests/test_deephistory.c | 207 ++----- src/tests/test_defer.c | 18 +- src/tests/test_do.c | 40 +- src/tests/test_fork.c | 95 ++- src/tests/test_guards_actions.c | 139 ++--- src/tests/test_join.c | 27 +- src/tests/test_junction.c | 60 +- src/tests/test_queue.c | 47 +- src/tests/test_simple.c | 93 ++- src/tests/test_simple_substate.c | 138 ++--- src/tests/test_stack.c | 41 +- src/tests/test_terminate.c | 30 +- src/tests/test_transition_prio.c | 26 +- src/tests/test_xmi_machine.c | 98 ++- src/tools/output.c | 543 +++++++++-------- src/tools/output.h | 10 +- src/tools/ufsmimport.c | 738 +++++++++++++---------- src/ufsm.c | 622 +++++++++---------- src/ufsm.h | 217 +++---- src/ufsm_queue.c | 35 +- src/ufsm_stack.c | 14 +- 32 files changed, 1746 insertions(+), 1977 deletions(-) diff --git a/src/examples/dhcpclient/src/dhcpc.c b/src/examples/dhcpclient/src/dhcpc.c index 58cda91..09a52e6 100644 --- a/src/examples/dhcpclient/src/dhcpc.c +++ b/src/examples/dhcpclient/src/dhcpc.c @@ -1,29 +1,28 @@ +#include #include #include -#include #include -#include "dhcpc.h" #include "dhcp_client_fsm.h" +#include "dhcpc.h" -static struct ufsm_queue *q; +static struct ufsm_queue* q; static int s_fd; -void dhcpc_enable_broadcast(const char *ifacename) +void dhcpc_enable_broadcast(const char* ifacename) { s_fd = socket(AF_PACKET, SOCK_RAW, IPPROTO_RAW); if (s_fd == -1) - printf ("Could not open raw socket\n"); + printf("Could not open raw socket\n"); } void dhcpc_bcast_request(void) { - } -void dhcpc_reset(struct ufsm_queue *queue) +void dhcpc_reset(struct ufsm_queue* queue) { q = queue; ufsm_queue_put(q, READY); diff --git a/src/examples/dhcpclient/src/dhcpc.h b/src/examples/dhcpclient/src/dhcpc.h index 997455f..efd4523 100644 --- a/src/examples/dhcpclient/src/dhcpc.h +++ b/src/examples/dhcpclient/src/dhcpc.h @@ -3,8 +3,8 @@ #include -void dhcpc_enable_broadcast(const char *ifacename); +void dhcpc_enable_broadcast(const char* ifacename); void dhcpc_bcast_request(void); -void dhcpc_reset(struct ufsm_queue *queue); +void dhcpc_reset(struct ufsm_queue* queue); #endif diff --git a/src/examples/dhcpclient/src/dhcpclient.c b/src/examples/dhcpclient/src/dhcpclient.c index 35e3baa..69be9ce 100644 --- a/src/examples/dhcpclient/src/dhcpclient.c +++ b/src/examples/dhcpclient/src/dhcpclient.c @@ -7,68 +7,68 @@ * */ -#include -#include -#include #include #include +#include +#include #include #include +#include #include "dhcp_client_fsm.h" #include "dhcpc.h" -static struct ufsm_machine *m = NULL; -static struct ufsm_queue *q = NULL; +static struct ufsm_machine* m = NULL; +static struct ufsm_queue* q = NULL; static pthread_mutex_t queue_lock; static pthread_mutex_t event_loop_lock; -static char *ifacename = NULL; +static char* ifacename = NULL; #define MSG(x...) printf(" | Message | " x) /* Debug functions */ -static void debug_transition (struct ufsm_transition *t) +static void debug_transition(struct ufsm_transition* t) { - - printf (" | Transition | %s {%s} --> %s {%s}\n", t->source->name, - ufsm_state_kinds[t->source->kind], - t->dest->name, - ufsm_state_kinds[t->dest->kind]); + printf(" | Transition | %s {%s} --> %s {%s}\n", + t->source->name, + ufsm_state_kinds[t->source->kind], + t->dest->name, + ufsm_state_kinds[t->dest->kind]); } -static void debug_enter_region(struct ufsm_region *r) +static void debug_enter_region(struct ufsm_region* r) { - printf (" | R enter | %s, H=%i\n", r->name, r->has_history); + printf(" | R enter | %s, H=%i\n", r->name, r->has_history); } -static void debug_leave_region(struct ufsm_region *r) +static void debug_leave_region(struct ufsm_region* r) { - printf (" | R exit | %s, H=%i\n", r->name, r->has_history); + printf(" | R exit | %s, H=%i\n", r->name, r->has_history); } static void debug_event(uint32_t ev) { - printf (" %-3i| |\n",ev); + printf(" %-3i| |\n", ev); } -static void debug_action(struct ufsm_action *a) +static void debug_action(struct ufsm_action* a) { - printf (" | Action | %s()\n",a->name); + printf(" | Action | %s()\n", a->name); } -static void debug_guard(struct ufsm_guard *g, bool result) +static void debug_guard(struct ufsm_guard* g, bool result) { - printf (" | Guard | %s() = %i\n", g->name, result); + printf(" | Guard | %s() = %i\n", g->name, result); } -static void debug_enter_state(struct ufsm_state *s) +static void debug_enter_state(struct ufsm_state* s) { - printf (" | S enter | %s {%s}\n", s->name,ufsm_state_kinds[s->kind]); + printf(" | S enter | %s {%s}\n", s->name, ufsm_state_kinds[s->kind]); } -static void debug_exit_state(struct ufsm_state *s) +static void debug_exit_state(struct ufsm_state* s) { - printf (" | S exit | %s {%s}\n", s->name,ufsm_state_kinds[s->kind]); + printf(" | S exit | %s {%s}\n", s->name, ufsm_state_kinds[s->kind]); } /* uFSM actions/guards */ @@ -79,17 +79,17 @@ void dhcp_stop_timers(void) void dhcp_disable_broadcast(void) { - MSG ("Broadcast disable\n"); + MSG("Broadcast disable\n"); } void dhcp_enable_socket(void) { - MSG ("Socket enable\n"); + MSG("Socket enable\n"); } void dhcp_send_request(void) { - MSG ("Send request\n"); + MSG("Send request\n"); } void dhcp_display_result(void) @@ -98,7 +98,7 @@ void dhcp_display_result(void) void dhcp_disable_socket(void) { - MSG ("Disable socket\n"); + MSG("Disable socket\n"); } void dhcp_enable_broadcast(void) @@ -120,9 +120,8 @@ void dhcp_set_timers(void) void dhcp_reset(void) { - MSG ("DHCP Reset\n"); + MSG("DHCP Reset\n"); dhcpc_reset(q); - } void dhcp_select_offer(void) @@ -150,7 +149,6 @@ void dhcp_collect_reply(void) { } - /* Help functions */ void dhcp_run_eventloop(void) @@ -168,39 +166,40 @@ void dhcp_unlock_queue(void) pthread_mutex_unlock(&queue_lock); } -void * q_test (void *arg) +void* q_test(void* arg) { while (true) { - ufsm_queue_put(q,DHCPACK); + ufsm_queue_put(q, DHCPACK); sleep(1); } } -int main(int argc, char **argv) +int main(int argc, char** argv) { bool running = true; uint32_t err = UFSM_OK; uint32_t ev = 0; - printf ("uFSM dhcp client demo\n"); + printf("uFSM dhcp client demo\n"); - if (argc < 2) { - printf ("Usage: dhcpclient \n"); + if (argc < 2) + { + printf("Usage: dhcpclient \n"); return 0; } ifacename = argv[1]; - if (pthread_mutex_init (&queue_lock, NULL) != 0) + if (pthread_mutex_init(&queue_lock, NULL) != 0) { - printf ("Error: Could not initialise queue lock\n"); + printf("Error: Could not initialise queue lock\n"); return -1; } - if (pthread_mutex_init (&event_loop_lock, NULL) != 0) + if (pthread_mutex_init(&event_loop_lock, NULL) != 0) { - printf ("Error: Could not initialise event loop lock\n"); + printf("Error: Could not initialise event loop lock\n"); return -1; } @@ -220,25 +219,28 @@ int main(int argc, char **argv) q->lock = &dhcp_lock_queue; q->unlock = &dhcp_unlock_queue; - printf (" EV | OP | Details\n"); + printf(" EV | OP | Details\n"); ufsm_init_machine(m); pthread_t t; - //pthread_create(&t, NULL, &q_test, NULL); - + // pthread_create(&t, NULL, &q_test, NULL); + while (running) { pthread_mutex_lock(&event_loop_lock); err = ufsm_queue_get(q, &ev); - if (err == UFSM_OK) { + if (err == UFSM_OK) + { pthread_mutex_unlock(&event_loop_lock); err = ufsm_process(m, ev); if (err != UFSM_OK) - MSG ("Error: %s\n", ufsm_errors[err]); - } else { - MSG ("Eventloop: No more events to process, sleeping...\n"); + MSG("Error: %s\n", ufsm_errors[err]); + } + else + { + MSG("Eventloop: No more events to process, sleeping...\n"); } } @@ -247,5 +249,3 @@ int main(int argc, char **argv) return 0; } - - diff --git a/src/examples/simple/simple.c b/src/examples/simple/simple.c index fed3aae..8f3e166 100644 --- a/src/examples/simple/simple.c +++ b/src/examples/simple/simple.c @@ -1,20 +1,20 @@ -#include #include +#include #include "ufsm_demo_fsm.h" void led_on(void) { - printf ("LED ON\n"); + printf("LED ON\n"); } void led_off(void) { - printf ("LED OFF\n"); + printf("LED OFF\n"); } -int main(int argc, char **argv) +int main(int argc, char** argv) { - struct ufsm_machine *m = get_StateMachine1(); + struct ufsm_machine* m = get_StateMachine1(); ufsm_init_machine(m); @@ -30,4 +30,3 @@ int main(int argc, char **argv) return 0; } - diff --git a/src/tests/common.c b/src/tests/common.c index cab28d3..30b69a0 100644 --- a/src/tests/common.c +++ b/src/tests/common.c @@ -1,92 +1,91 @@ -#include #include "common.h" +#include -void debug_transition (struct ufsm_transition *t) +void debug_transition(struct ufsm_transition* t) { #if UFSM_TESTS_VERBOSE == true - - printf (" | Transition | %s {%s} --> %s {%s}\n", t->source->name, - ufsm_state_kinds[t->source->kind], - t->dest->name, - ufsm_state_kinds[t->dest->kind]); + + printf(" | Transition | %s {%s} --> %s {%s}\n", + t->source->name, + ufsm_state_kinds[t->source->kind], + t->dest->name, + ufsm_state_kinds[t->dest->kind]); #endif } -void debug_enter_region(struct ufsm_region *r) +void debug_enter_region(struct ufsm_region* r) { #if UFSM_TESTS_VERBOSE == true - printf (" | R enter | %s, H=%i\n", r->name, r->has_history); + printf(" | R enter | %s, H=%i\n", r->name, r->has_history); #endif } -void debug_leave_region(struct ufsm_region *r) +void debug_leave_region(struct ufsm_region* r) { #if UFSM_TESTS_VERBOSE == true - printf (" | R exit | %s, H=%i\n", r->name, r->has_history); + printf(" | R exit | %s, H=%i\n", r->name, r->has_history); #endif } void debug_event(uint32_t ev) { #if UFSM_TESTS_VERBOSE == true - printf (" %-3i| |\n",ev); + printf(" %-3i| |\n", ev); #endif } -void debug_action(struct ufsm_action *a) +void debug_action(struct ufsm_action* a) { #if UFSM_TESTS_VERBOSE == true - printf (" | Action | %s()\n",a->name); + printf(" | Action | %s()\n", a->name); #endif } -void debug_guard(struct ufsm_guard *g, bool result) +void debug_guard(struct ufsm_guard* g, bool result) { #if UFSM_TESTS_VERBOSE == true - printf (" | Guard | %s() = %i\n", g->name, result); + printf(" | Guard | %s() = %i\n", g->name, result); #endif } -void debug_enter_state(struct ufsm_state *s) +void debug_enter_state(struct ufsm_state* s) { #if UFSM_TESTS_VERBOSE == true - printf (" | S enter | %s {%s}\n", s->name,ufsm_state_kinds[s->kind]); + printf(" | S enter | %s {%s}\n", s->name, ufsm_state_kinds[s->kind]); #endif } -void debug_exit_state(struct ufsm_state *s) +void debug_exit_state(struct ufsm_state* s) { #if UFSM_TESTS_VERBOSE == true - printf (" | S exit | %s {%s}\n", s->name,ufsm_state_kinds[s->kind]); + printf(" | S exit | %s {%s}\n", s->name, ufsm_state_kinds[s->kind]); #endif } - -void debug_reset(struct ufsm_machine *m) +void debug_reset(struct ufsm_machine* m) { #if UFSM_TESTS_VERBOSE == true - printf (" -- | RESET | %s\n", m->name); + printf(" -- | RESET | %s\n", m->name); #endif } -void test_process(struct ufsm_machine *m, uint32_t ev) +void test_process(struct ufsm_machine* m, uint32_t ev) { uint32_t err = UFSM_OK; - err = ufsm_process(m,ev); + err = ufsm_process(m, ev); if (err != UFSM_OK) - printf ("ERROR: %s\n", ufsm_errors[err]); - assert (err == UFSM_OK); - + printf("ERROR: %s\n", ufsm_errors[err]); + assert(err == UFSM_OK); if (m->stack.pos == UFSM_STACK_SIZE) - printf ("ERROR: Stack overflow!\n"); + printf("ERROR: Stack overflow!\n"); else if (m->stack.pos > 0) - printf ("ERROR: Stack did not return to zero\n"); - assert (m->stack.pos == 0); + printf("ERROR: Stack did not return to zero\n"); + assert(m->stack.pos == 0); - struct ufsm_queue *q = ufsm_get_queue(m); + struct ufsm_queue* q = ufsm_get_queue(m); uint32_t q_ev; /* Process queued events */ @@ -95,23 +94,19 @@ void test_process(struct ufsm_machine *m, uint32_t ev) err = ufsm_process(m, q_ev); if (err != UFSM_OK) - printf ("ERROR: %s\n", ufsm_errors[err]); - assert (err == UFSM_OK); - + printf("ERROR: %s\n", ufsm_errors[err]); + assert(err == UFSM_OK); if (m->stack.pos == UFSM_STACK_SIZE) - printf ("ERROR: Stack overflow!\n"); + printf("ERROR: Stack overflow!\n"); else if (m->stack.pos > 0) - printf ("ERROR: Stack did not return to zero\n"); - assert (m->stack.pos == 0); + printf("ERROR: Stack did not return to zero\n"); + assert(m->stack.pos == 0); } } - - -void test_init(struct ufsm_machine *m) +void test_init(struct ufsm_machine* m) { - m->debug_transition = &debug_transition; m->debug_enter_region = &debug_enter_region; m->debug_leave_region = &debug_leave_region; @@ -123,9 +118,6 @@ void test_init(struct ufsm_machine *m) m->debug_reset = &debug_reset; #if UFSM_TESTS_VERBOSE == true - printf (" EV | OP | Details\n"); + printf(" EV | OP | Details\n"); #endif - } - - diff --git a/src/tests/common.h b/src/tests/common.h index 6a8512b..5da9d83 100644 --- a/src/tests/common.h +++ b/src/tests/common.h @@ -4,16 +4,16 @@ #include #include -void debug_transition(struct ufsm_transition *t); -void debug_enter_region(struct ufsm_region *r); -void debug_leave_region(struct ufsm_region *r); +void debug_transition(struct ufsm_transition* t); +void debug_enter_region(struct ufsm_region* r); +void debug_leave_region(struct ufsm_region* r); void debug_event(uint32_t ev); -void debug_action(struct ufsm_action *a); -void debug_guard(struct ufsm_guard *g, bool result); -void debug_enter_state(struct ufsm_state *s); -void debug_exit_state(struct ufsm_state *s); +void debug_action(struct ufsm_action* a); +void debug_guard(struct ufsm_guard* g, bool result); +void debug_enter_state(struct ufsm_state* s); +void debug_exit_state(struct ufsm_state* s); -void test_process(struct ufsm_machine *m, uint32_t ev); -void test_init(struct ufsm_machine *m); +void test_process(struct ufsm_machine* m, uint32_t ev); +void test_init(struct ufsm_machine* m); #endif diff --git a/src/tests/test_argouml.c b/src/tests/test_argouml.c index a6f179b..7b99889 100644 --- a/src/tests/test_argouml.c +++ b/src/tests/test_argouml.c @@ -1,9 +1,5 @@ +#include #include #include "common.h" -#include - - -int main (int argc, char **argv) -{ -} +int main(int argc, char** argv) {} diff --git a/src/tests/test_choice.c b/src/tests/test_choice.c index 327bded..fecca24 100644 --- a/src/tests/test_choice.c +++ b/src/tests/test_choice.c @@ -1,7 +1,7 @@ -#include #include -#include +#include #include +#include #include "common.h" static bool flag_e1 = false; @@ -19,59 +19,40 @@ static void reset_flags(void) flag_e3 = false; } -bool g1(void) -{ - return g1_val; -} +bool g1(void) { return g1_val; } -bool g2(void) -{ - return g2_val; -} +bool g2(void) { return g2_val; } -bool g3(void) -{ - return g3_val; -} +bool g3(void) { return g3_val; } -void e1(void) -{ - flag_e1 = true; -} +void e1(void) { flag_e1 = true; } -void e2(void) -{ - flag_e2 = true; -} +void e2(void) { flag_e2 = true; } -void e3(void) -{ - flag_e3 = true; -} +void e3(void) { flag_e3 = true; } -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); - + struct ufsm_machine* m = get_StateMachine1(); + test_init(m); ufsm_init_machine(m); g3_val = true; test_process(m, EV); - assert (!flag_e1 && !flag_e2 && flag_e3); + assert(!flag_e1 && !flag_e2 && flag_e3); reset_flags(); ufsm_reset_machine(m); ufsm_init_machine(m); - + g3_val = false; g2_val = true; - + test_process(m, EV); - - assert (!flag_e1 && flag_e2 && !flag_e3); - + assert(!flag_e1 && flag_e2 && !flag_e3); + return 0; } diff --git a/src/tests/test_choice2.c b/src/tests/test_choice2.c index b983405..3f425a0 100644 --- a/src/tests/test_choice2.c +++ b/src/tests/test_choice2.c @@ -1,7 +1,7 @@ -#include #include -#include +#include #include +#include #include "common.h" static bool flag_e2 = false; @@ -9,38 +9,25 @@ static bool flag_t1 = false; static bool flag_t2 = false; static bool g_val = true; -void e2(void) -{ - flag_e2 = true; -} +void e2(void) { flag_e2 = true; } -bool g(void) -{ - return g_val; -} +bool g(void) { return g_val; } -void t1(void) -{ - flag_t1 = true; -} - -void t2(void) -{ - flag_t2 = true; -} +void t1(void) { flag_t1 = true; } +void t2(void) { flag_t2 = true; } -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); - + struct ufsm_machine* m = get_StateMachine1(); + test_init(m); ufsm_init_machine(m); - - test_process(m,EV); - assert ( !flag_e2 && flag_t1 && flag_t2); - + test_process(m, EV); + + assert(!flag_e2 && flag_t1 && flag_t2); + ufsm_reset_machine(m); flag_e2 = false; flag_t1 = false; @@ -48,9 +35,9 @@ int main(void) g_val = false; ufsm_init_machine(m); - test_process(m,EV); + test_process(m, EV); + + assert(flag_e2 && !flag_t1 && !flag_t2); - assert ( flag_e2 && !flag_t1 && !flag_t2); - return 0; } diff --git a/src/tests/test_compound_transition.c b/src/tests/test_compound_transition.c index c1837aa..cab9d70 100644 --- a/src/tests/test_compound_transition.c +++ b/src/tests/test_compound_transition.c @@ -1,7 +1,7 @@ -#include -#include #include +#include #include +#include #include "common.h" static bool flag_eT1 = false; @@ -25,76 +25,73 @@ static void reset_flags(void) flag_t3 = false; } -void t1(void) +void t1(void) { flag_t1 = true; - assert (flag_xS11 && !flag_eT1 && !flag_eT11 && !flag_eT111 && - !flag_xS1 && flag_t1 && !flag_t2 && !flag_t3); + assert(flag_xS11 && !flag_eT1 && !flag_eT11 && !flag_eT111 && !flag_xS1 && + flag_t1 && !flag_t2 && !flag_t3); } -void t2(void) +void t2(void) { flag_t2 = true; - assert (flag_xS11 && !flag_eT1 && !flag_eT11 && !flag_eT111 && - flag_xS1 && flag_t1 && flag_t2 && !flag_t3); + assert(flag_xS11 && !flag_eT1 && !flag_eT11 && !flag_eT111 && flag_xS1 && + flag_t1 && flag_t2 && !flag_t3); } -void t3(void) +void t3(void) { flag_t3 = true; - assert (flag_xS11 && flag_eT1 && flag_eT11 && !flag_eT111 && - flag_xS1 && flag_t1 && flag_t2 && flag_t3); + assert(flag_xS11 && flag_eT1 && flag_eT11 && !flag_eT111 && flag_xS1 && + flag_t1 && flag_t2 && flag_t3); } void eT1(void) { - assert (flag_xS1 && flag_xS11); + assert(flag_xS1 && flag_xS11); flag_eT1 = true; } void eT11(void) { - assert (flag_eT1); + assert(flag_eT1); flag_eT11 = true; } void eT111(void) { - assert (flag_eT1 && flag_eT11); + assert(flag_eT1 && flag_eT11); flag_eT111 = true; } void xS1(void) { - assert (flag_xS11); + assert(flag_xS11); flag_xS1 = true; } void xS11(void) { - assert(!flag_eT1 && !flag_eT11 && !flag_eT111); assert(!flag_xS1 && !flag_xS11); - flag_xS11 = true; } -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); - + struct ufsm_machine* m = get_StateMachine1(); + test_init(m); reset_flags(); ufsm_init_machine(m); - + assert(!flag_eT1 && !flag_eT11 && !flag_eT111); assert(!flag_xS1 && !flag_xS11); reset_flags(); - ufsm_process(m, sig); + ufsm_process(m, sig); assert(flag_xS1 && flag_xS11); assert(flag_eT1 && flag_eT11 && flag_eT111); - return 0; } diff --git a/src/tests/test_conref.c b/src/tests/test_conref.c index 46b51f9..4ea60f7 100644 --- a/src/tests/test_conref.c +++ b/src/tests/test_conref.c @@ -1,7 +1,7 @@ -#include #include -#include +#include #include +#include #include "common.h" static uint32_t eAc = 0; @@ -15,103 +15,45 @@ static uint32_t eSAc = 0; static uint32_t xBc = 0; static uint32_t eBc = 0; -void eA(void) -{ - eAc++; -} +void eA(void) { eAc++; } -void eC(void) -{ - eCc++; -} +void eC(void) { eCc++; } -void t0(void) -{ - t0c++; -} +void t0(void) { t0c++; } -void t4(void) -{ - t4c++; -} +void t4(void) { t4c++; } -void t3(void) -{ - t3c++; -} +void t3(void) { t3c++; } -void t1(void) -{ - t1c++; -} +void t1(void) { t1c++; } -void xSA(void) -{ - xSAc++; -} +void xSA(void) { xSAc++; } -void eSA(void) -{ - eSAc++; -} +void eSA(void) { eSAc++; } -void xB(void) -{ - xBc++; -} +void xB(void) { xBc++; } -void eB(void) -{ - eBc++; -} +void eB(void) { eBc++; } -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); - + struct ufsm_machine* m = get_StateMachine1(); + test_init(m); ufsm_init_machine(m); - assert (eAc == 1 && - eCc == 0 && - t0c == 0 && - t1c == 0 && - t3c == 0 && - t4c == 0 && - xSAc == 0 && - eSAc == 0 && - xBc == 0 && - eBc == 0); - - - test_process(m, EV1); - - - assert (eAc == 1 && - eCc == 0 && - t0c == 1 && - t1c == 0 && - t3c == 1 && - t4c == 0 && - xSAc == 0 && - eSAc == 1 && - xBc == 0 && - eBc == 1); - + assert(eAc == 1 && eCc == 0 && t0c == 0 && t1c == 0 && t3c == 0 && + t4c == 0 && xSAc == 0 && eSAc == 0 && xBc == 0 && eBc == 0); + + test_process(m, EV1); + + assert(eAc == 1 && eCc == 0 && t0c == 1 && t1c == 0 && t3c == 1 && + t4c == 0 && xSAc == 0 && eSAc == 1 && xBc == 0 && eBc == 1); test_process(m, EV1); + assert(eAc == 1 && eCc == 1 && t0c == 1 && t1c == 1 && t3c == 1 && + t4c == 1 && xSAc == 1 && eSAc == 1 && xBc == 1 && eBc == 1); - assert (eAc == 1 && - eCc == 1 && - t0c == 1 && - t1c == 1 && - t3c == 1 && - t4c == 1 && - xSAc == 1 && - eSAc == 1 && - xBc == 1 && - eBc == 1); - return 0; } diff --git a/src/tests/test_deephistory.c b/src/tests/test_deephistory.c index a3b2b29..8902655 100644 --- a/src/tests/test_deephistory.c +++ b/src/tests/test_deephistory.c @@ -1,7 +1,7 @@ -#include #include -#include +#include #include +#include #include "common.h" static bool flag_final = false; @@ -37,209 +37,86 @@ static void reset_flags(void) flag_xA = false; } -void final(void) -{ - flag_final = true; -} +void final(void) { flag_final = true; } -void eB(void) -{ - flag_eB = true; -} +void eB(void) { flag_eB = true; } -void eA2(void) -{ - flag_eA2 = true; -} +void eA2(void) { flag_eA2 = true; } -void xA2(void) -{ - flag_xA2 = true; -} +void xA2(void) { flag_xA2 = true; } -void eA1(void) -{ - flag_eA1 = true; -} +void eA1(void) { flag_eA1 = true; } -void xA1(void) -{ - flag_xA1 = true; -} +void xA1(void) { flag_xA1 = true; } -void eE(void) -{ - flag_eE = true; -} +void eE(void) { flag_eE = true; } -void xE(void) -{ - flag_xE = true; -} +void xE(void) { flag_xE = true; } -void eD(void) -{ - flag_eD = true; -} +void eD(void) { flag_eD = true; } -void xD(void) -{ - flag_xD = true; -} +void xD(void) { flag_xD = true; } -void eC(void) -{ - flag_eC = true; -} +void eC(void) { flag_eC = true; } -void xC(void) -{ - flag_xC = true; -} +void xC(void) { flag_xC = true; } -void eA(void) -{ - flag_eA = true; -} +void eA(void) { flag_eA = true; } -void xA(void) -{ - flag_xA = true; -} +void xA(void) { flag_xA = true; } -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); - + struct ufsm_machine* m = get_StateMachine1(); + test_init(m); ufsm_init_machine(m); - assert(!flag_final && - flag_eB && - !flag_eA2 && - !flag_xA2 && - !flag_eA1 && - !flag_xA1 && - !flag_eE && - !flag_xE && - !flag_eD && - !flag_xD && - !flag_eC && - !flag_xC && - !flag_eA && - !flag_xA); + assert(!flag_final && flag_eB && !flag_eA2 && !flag_xA2 && !flag_eA1 && + !flag_xA1 && !flag_eE && !flag_xE && !flag_eD && !flag_xD && + !flag_eC && !flag_xC && !flag_eA && !flag_xA); reset_flags(); test_process(m, EV_A); - assert(!flag_final && - !flag_eB && - !flag_eA2 && - !flag_xA2 && - flag_eA1 && - !flag_xA1 && - !flag_eE && - !flag_xE && - !flag_eD && - !flag_xD && - !flag_eC && - !flag_xC && - flag_eA && - !flag_xA); - + assert(!flag_final && !flag_eB && !flag_eA2 && !flag_xA2 && flag_eA1 && + !flag_xA1 && !flag_eE && !flag_xE && !flag_eD && !flag_xD && + !flag_eC && !flag_xC && flag_eA && !flag_xA); test_process(m, EV_1); test_process(m, EV_1); test_process(m, EV_1); - assert(!flag_final && - !flag_eB && - flag_eA2 && - flag_xA2 && - flag_eA1 && - flag_xA1 && - flag_eE && - flag_xE && - flag_eD && - !flag_xD && - flag_eC && - !flag_xC && - flag_eA && - !flag_xA); + assert(!flag_final && !flag_eB && flag_eA2 && flag_xA2 && flag_eA1 && + flag_xA1 && flag_eE && flag_xE && flag_eD && !flag_xD && flag_eC && + !flag_xC && flag_eA && !flag_xA); reset_flags(); test_process(m, EV_B); - - assert(!flag_final && - flag_eB && - !flag_eA2 && - !flag_xA2 && - !flag_eA1 && - !flag_xA1 && - !flag_eE && - !flag_xE && - !flag_eD && - flag_xD && - !flag_eC && - flag_xC && - !flag_eA && - flag_xA); + assert(!flag_final && flag_eB && !flag_eA2 && !flag_xA2 && !flag_eA1 && + !flag_xA1 && !flag_eE && !flag_xE && !flag_eD && flag_xD && + !flag_eC && flag_xC && !flag_eA && flag_xA); reset_flags(); test_process(m, EV_A); - - assert(!flag_final && - !flag_eB && - !flag_eA2 && - !flag_xA2 && - !flag_eA1 && - !flag_xA1 && - !flag_eE && - !flag_xE && - flag_eD && - !flag_xD && - flag_eC && - !flag_xC && - flag_eA && - !flag_xA); + assert(!flag_final && !flag_eB && !flag_eA2 && !flag_xA2 && !flag_eA1 && + !flag_xA1 && !flag_eE && !flag_xE && flag_eD && !flag_xD && + flag_eC && !flag_xC && flag_eA && !flag_xA); reset_flags(); test_process(m, EV_1); - assert(!flag_final && - !flag_eB && - !flag_eA2 && - !flag_xA2 && - flag_eA1 && - !flag_xA1 && - !flag_eE && - !flag_xE && - !flag_eD && - flag_xD && - !flag_eC && - flag_xC && - !flag_eA && - !flag_xA); - - test_process(m ,EV_1); + assert(!flag_final && !flag_eB && !flag_eA2 && !flag_xA2 && flag_eA1 && + !flag_xA1 && !flag_eE && !flag_xE && !flag_eD && flag_xD && + !flag_eC && flag_xC && !flag_eA && !flag_xA); + + test_process(m, EV_1); reset_flags(); test_process(m, EV_EXIT); - assert(flag_final && - !flag_eB && - !flag_eA2 && - flag_xA2 && - !flag_eA1 && - !flag_xA1 && - !flag_eE && - !flag_xE && - !flag_eD && - !flag_xD && - !flag_eC && - !flag_xC && - !flag_eA && - flag_xA); - + assert(flag_final && !flag_eB && !flag_eA2 && flag_xA2 && !flag_eA1 && + !flag_xA1 && !flag_eE && !flag_xE && !flag_eD && !flag_xD && + !flag_eC && !flag_xC && !flag_eA && flag_xA); return 0; } diff --git a/src/tests/test_defer.c b/src/tests/test_defer.c index 62aeb8a..cfba177 100644 --- a/src/tests/test_defer.c +++ b/src/tests/test_defer.c @@ -1,19 +1,16 @@ -#include #include -#include +#include #include +#include #include "common.h" static bool flag_final = false; -void final(void) -{ - flag_final = true; -} +void final(void) { flag_final = true; } -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); + struct ufsm_machine* m = get_StateMachine1(); uint32_t err = UFSM_OK; uint32_t ev; @@ -26,7 +23,8 @@ int main(void) ufsm_process(m, EV); - while(true) { + while (true) + { err = ufsm_queue_get(&m->queue, &ev); if (err == UFSM_OK) test_process(m, ev); @@ -36,7 +34,5 @@ int main(void) assert(flag_final); - - return 0; } diff --git a/src/tests/test_do.c b/src/tests/test_do.c index 9d26cbc..f379a01 100644 --- a/src/tests/test_do.c +++ b/src/tests/test_do.c @@ -1,50 +1,36 @@ -#include #include -#include +#include #include +#include #include "common.h" static bool flag_final = false; static bool call_cb = true; static bool flag_dA_stop = false; -void xA(void) -{ - assert (flag_dA_stop); -} +void xA(void) { assert(flag_dA_stop); } -void eA(void) -{ - assert (!flag_dA_stop); -} +void eA(void) { assert(!flag_dA_stop); } -void dA_start(struct ufsm_machine *m, - struct ufsm_state *s, - ufsm_doact_cb_t cb) +void dA_start(struct ufsm_machine* m, struct ufsm_state* s, ufsm_doact_cb_t cb) { if (call_cb) - cb(m,s); + cb(m, s); } -void dA_stop(void) -{ - flag_dA_stop = true; -} +void dA_stop(void) { flag_dA_stop = true; } -void final(void) -{ - flag_final = true; -} +void final(void) { flag_final = true; } -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); - + struct ufsm_machine* m = get_StateMachine1(); + test_init(m); ufsm_init_machine(m); assert(flag_final && flag_dA_stop); - + flag_final = false; call_cb = false; flag_dA_stop = false; @@ -53,6 +39,6 @@ int main(void) test_process(m, EV); - assert (!flag_final && flag_dA_stop); + assert(!flag_final && flag_dA_stop); return 0; } diff --git a/src/tests/test_fork.c b/src/tests/test_fork.c index 5dca0b4..6d7e920 100644 --- a/src/tests/test_fork.c +++ b/src/tests/test_fork.c @@ -1,7 +1,7 @@ -#include #include -#include +#include #include +#include #include "common.h" static bool gA_val = false; @@ -36,8 +36,16 @@ void reset_flags(void) flag_xAB = false; } -bool gA(void) { flag_gA = true; return gA_val; } -bool g2(void) { flag_g2 = true; return g2_val; } +bool gA(void) +{ + flag_gA = true; + return gA_val; +} +bool g2(void) +{ + flag_g2 = true; + return g2_val; +} void finalD(void) { flag_finalD = true; } void eD(void) { flag_eD = true; } void eC(void) { flag_eC = true; } @@ -47,86 +55,51 @@ void xB2(void) { flag_xB2 = true; } void eA2(void) { flag_eA2 = true; } void xA2(void) { flag_xA2 = true; } void eAB(void) { flag_eAB = true; } -void xAB(void) { ab_exit_cnt++; flag_xAB = true; } +void xAB(void) +{ + ab_exit_cnt++; + flag_xAB = true; +} -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); - + struct ufsm_machine* m = get_StateMachine1(); + test_init(m); ufsm_init_machine(m); - assert (!flag_finalD && - !flag_gA && - !flag_g2 && - !flag_eD && - !flag_eC && - !flag_finalC && - !flag_eB2 && - !flag_xB2 && - !flag_eA2 && - !flag_xA2 && - !flag_eAB && - !flag_xAB); + assert(!flag_finalD && !flag_gA && !flag_g2 && !flag_eD && !flag_eC && + !flag_finalC && !flag_eB2 && !flag_xB2 && !flag_eA2 && !flag_xA2 && + !flag_eAB && !flag_xAB); g2_val = true; gA_val = false; test_process(m, EV); - assert (!flag_finalD && - flag_gA && - flag_g2 && - !flag_eD && - !flag_eC && - !flag_finalC && - flag_eB2 && - !flag_xB2 && - flag_eA2 && - !flag_xA2 && - flag_eAB && - !flag_xAB); + assert(!flag_finalD && flag_gA && flag_g2 && !flag_eD && !flag_eC && + !flag_finalC && flag_eB2 && !flag_xB2 && flag_eA2 && !flag_xA2 && + flag_eAB && !flag_xAB); reset_flags(); test_process(m, EV); - assert (!flag_finalD && - !flag_gA && - !flag_g2 && - !flag_eD && - !flag_eC && - flag_finalC && - !flag_eB2 && - flag_xB2 && - !flag_eA2 && - flag_xA2 && - !flag_eAB && - flag_xAB); + assert(!flag_finalD && !flag_gA && !flag_g2 && !flag_eD && !flag_eC && + flag_finalC && !flag_eB2 && flag_xB2 && !flag_eA2 && flag_xA2 && + !flag_eAB && flag_xAB); - assert (ab_exit_cnt == 1); + assert(ab_exit_cnt == 1); ufsm_reset_machine(m); ufsm_init_machine(m); reset_flags(), - g2_val = false; + g2_val = false; gA_val = true; test_process(m, EV); - - assert (!flag_finalD && - flag_gA && - !flag_g2 && - !flag_eD && - !flag_eC && - !flag_finalC && - !flag_eB2 && - !flag_xB2 && - !flag_eA2 && - !flag_xA2 && - flag_eAB && - !flag_xAB); - - + assert(!flag_finalD && flag_gA && !flag_g2 && !flag_eD && !flag_eC && + !flag_finalC && !flag_eB2 && !flag_xB2 && !flag_eA2 && !flag_xA2 && + flag_eAB && !flag_xAB); return 0; } diff --git a/src/tests/test_guards_actions.c b/src/tests/test_guards_actions.c index b1fd88e..c5c6fed 100644 --- a/src/tests/test_guards_actions.c +++ b/src/tests/test_guards_actions.c @@ -1,62 +1,57 @@ -#include #include +#include #include #include "common.h" -enum events { +enum events +{ EV_A, EV_B }; - static bool flag_guard1_called = false; static bool flag_guard2_called = false; static bool flag_action1_called = false; static bool guard2_ret_val = true; - -static void reset_test_flags(void) { +static void reset_test_flags(void) +{ flag_guard1_called = false; flag_guard2_called = false; flag_action1_called = false; guard2_ret_val = true; } -static bool guard1_f(void) { +static bool guard1_f(void) +{ flag_guard1_called = true; return true; } -static bool guard2_f(void) { +static bool guard2_f(void) +{ flag_guard2_called = true; return guard2_ret_val; } -static void action1_f(void) { - flag_action1_called = true; -} +static void action1_f(void) { flag_action1_called = true; } static struct ufsm_state A; static struct ufsm_region region1; -static struct ufsm_state simple_INIT = -{ - .name = "Init", - .kind = UFSM_STATE_INIT, - .parent_region = ®ion1, - .next = &A -}; +static struct ufsm_state simple_INIT = {.name = "Init", + .kind = UFSM_STATE_INIT, + .parent_region = ®ion1, + .next = &A}; -static struct ufsm_state B = -{ +static struct ufsm_state B = { .name = "State B", .kind = UFSM_STATE_SIMPLE, .parent_region = ®ion1, .next = NULL, }; -static struct ufsm_state A = -{ +static struct ufsm_state A = { .name = "State A", .kind = UFSM_STATE_SIMPLE, .parent_region = ®ion1, @@ -65,50 +60,40 @@ static struct ufsm_state A = static struct ufsm_guard guard2; -static struct ufsm_guard guard1 = -{ +static struct ufsm_guard guard1 = { .f = &guard1_f, .next = &guard2, }; -static struct ufsm_guard guard2 = -{ +static struct ufsm_guard guard2 = { .f = &guard2_f, .next = NULL, }; -static struct ufsm_action action1 = -{ +static struct ufsm_action action1 = { .f = &action1_f, .next = NULL, }; - -static struct ufsm_transition simple_transition_B = -{ - .name = "EV_B", - .trigger = EV_B, - .kind = UFSM_TRANSITION_EXTERNAL, - .source = &A, - .dest = &B, - .next = NULL -}; - - -static struct ufsm_transition simple_transition_A = -{ - .name = "EV_A", - .trigger = EV_A, - .kind = UFSM_TRANSITION_EXTERNAL, - .source = &B, - .dest = &A, - .guard = &guard1, - .action = &action1, - .next = &simple_transition_B -}; - -static struct ufsm_transition simple_transition_INIT = -{ +static struct ufsm_transition simple_transition_B = + {.name = "EV_B", + .trigger = EV_B, + .kind = UFSM_TRANSITION_EXTERNAL, + .source = &A, + .dest = &B, + .next = NULL}; + +static struct ufsm_transition simple_transition_A = + {.name = "EV_A", + .trigger = EV_A, + .kind = UFSM_TRANSITION_EXTERNAL, + .source = &B, + .dest = &A, + .guard = &guard1, + .action = &action1, + .next = &simple_transition_B}; + +static struct ufsm_transition simple_transition_INIT = { .name = "Init", .kind = UFSM_TRANSITION_EXTERNAL, .source = &simple_INIT, @@ -117,15 +102,11 @@ static struct ufsm_transition simple_transition_INIT = .next = &simple_transition_A, }; -static struct ufsm_region region1 = -{ - .state = &simple_INIT, - .transition = &simple_transition_INIT, - .next = NULL -}; +static struct ufsm_region region1 = {.state = &simple_INIT, + .transition = &simple_transition_INIT, + .next = NULL}; -static struct ufsm_machine m = -{ +static struct ufsm_machine m = { .name = "Simple Test Machine", .region = ®ion1, }; @@ -134,42 +115,38 @@ int main(void) { uint32_t err; - reset_test_flags(); test_init(&m); err = ufsm_init_machine(&m); - assert (err == UFSM_OK && "Initializing"); - assert (m.region->current == &A); - assert (flag_guard1_called == false); - assert (flag_guard2_called == false); - assert (flag_action1_called == false); + assert(err == UFSM_OK && "Initializing"); + assert(m.region->current == &A); + assert(flag_guard1_called == false); + assert(flag_guard2_called == false); + assert(flag_action1_called == false); reset_test_flags(); err = ufsm_process(&m, EV_B); - assert (m.region->current == &B && err == UFSM_OK); + assert(m.region->current == &B && err == UFSM_OK); reset_test_flags(); err = ufsm_process(&m, EV_A); - assert (m.region->current == &A && err == UFSM_OK); - assert (flag_guard1_called); - assert (flag_guard2_called); - assert (flag_action1_called); - + assert(m.region->current == &A && err == UFSM_OK); + assert(flag_guard1_called); + assert(flag_guard2_called); + assert(flag_action1_called); reset_test_flags(); err = ufsm_process(&m, EV_B); - assert (m.region->current == &B && err == UFSM_OK); + assert(m.region->current == &B && err == UFSM_OK); reset_test_flags(); guard2_ret_val = false; err = ufsm_process(&m, EV_A); - assert (m.region->current == &B); - assert (err == UFSM_OK); - assert (flag_guard1_called); - assert (flag_guard2_called); - assert (flag_action1_called == false); - - + assert(m.region->current == &B); + assert(err == UFSM_OK); + assert(flag_guard1_called); + assert(flag_guard2_called); + assert(flag_action1_called == false); return 0; } diff --git a/src/tests/test_join.c b/src/tests/test_join.c index ce5ea84..4558dcb 100644 --- a/src/tests/test_join.c +++ b/src/tests/test_join.c @@ -1,28 +1,21 @@ -#include #include -#include +#include #include +#include #include "common.h" static bool flag_final = false; -void final(void) -{ - flag_final = true; -} +void final(void) { flag_final = true; } -void eAB(void) -{ -} +void eAB(void) {} -void xAB(void) -{ -} +void xAB(void) {} -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); - + struct ufsm_machine* m = get_StateMachine1(); + test_init(m); ufsm_init_machine(m); @@ -30,8 +23,6 @@ int main(void) test_process(m, EV); - - - assert (flag_final); + assert(flag_final); return 0; } diff --git a/src/tests/test_junction.c b/src/tests/test_junction.c index 5fc2957..678b6a6 100644 --- a/src/tests/test_junction.c +++ b/src/tests/test_junction.c @@ -1,7 +1,7 @@ -#include #include -#include +#include #include +#include #include "common.h" static bool flag_eA = false; @@ -19,53 +19,29 @@ static void reset_flags(void) flag_t1 = false; } -void eA(void) -{ - flag_eA = true; -} - -void eB(void) -{ - flag_eB = true; -} +void eA(void) { flag_eA = true; } -void eC(void) -{ - flag_eC = true; -} +void eB(void) { flag_eB = true; } -void eD(void) -{ - flag_eD = true; -} +void eC(void) { flag_eC = true; } -void t1(void) -{ - flag_t1 = true; -} +void eD(void) { flag_eD = true; } +void t1(void) { flag_t1 = true; } -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); - + struct ufsm_machine* m = get_StateMachine1(); + test_init(m); ufsm_init_machine(m); - - assert (flag_eA && - !flag_eB && - !flag_eC && - !flag_eD && - !flag_t1); + + assert(flag_eA && !flag_eB && !flag_eC && !flag_eD && !flag_t1); reset_flags(); test_process(m, EV_J); - - assert (!flag_eA && - !flag_eB && - !flag_eC && - flag_eD && - flag_t1); + + assert(!flag_eA && !flag_eB && !flag_eC && flag_eD && flag_t1); ufsm_reset_machine(m); ufsm_init_machine(m); @@ -75,13 +51,7 @@ int main(void) test_process(m, EV); test_process(m, EV_J); - assert (!flag_eA && - flag_eB && - flag_eC && - flag_eD && - flag_t1); - - + assert(!flag_eA && flag_eB && flag_eC && flag_eD && flag_t1); return 0; } diff --git a/src/tests/test_queue.c b/src/tests/test_queue.c index 2d91d51..2c3aa7f 100644 --- a/src/tests/test_queue.c +++ b/src/tests/test_queue.c @@ -7,8 +7,8 @@ * */ -#include #include +#include #include "common.h" #include "gen/test_terminate_input.h" @@ -20,63 +20,52 @@ static bool flag_q_unlock = false; void xA(void) {} void eA(void) {} -void on_data(void) -{ - flag_on_data = true; -} +void on_data(void) { flag_on_data = true; } -void q_lock(void) -{ - flag_q_lock = true; -} +void q_lock(void) { flag_q_lock = true; } -void q_unlock(void) -{ - flag_q_unlock = true; -} +void q_unlock(void) { flag_q_unlock = true; } int main(void) { uint32_t err = UFSM_OK; uint32_t data[4]; uint32_t i = 0; - struct ufsm_machine *m = get_StateMachine1(); - - struct ufsm_queue *q = ufsm_get_queue(m); - assert (ufsm_queue_init(q, 4, data) == UFSM_OK); + struct ufsm_machine* m = get_StateMachine1(); + struct ufsm_queue* q = ufsm_get_queue(m); + assert(ufsm_queue_init(q, 4, data) == UFSM_OK); q->on_data = on_data; q->lock = q_lock; q->unlock = q_unlock; - err = ufsm_queue_put(q, 1); - assert (err == UFSM_OK); + assert(err == UFSM_OK); err = ufsm_queue_get(q, &i); - assert ( err == UFSM_OK && i == 1); + assert(err == UFSM_OK && i == 1); err = ufsm_queue_get(q, &i); - assert ( err == UFSM_ERROR_QUEUE_EMPTY); + assert(err == UFSM_ERROR_QUEUE_EMPTY); err = ufsm_queue_put(q, 1); err = ufsm_queue_put(q, 2); err = ufsm_queue_put(q, 3); err = ufsm_queue_put(q, 4); - - assert (err == UFSM_OK); + + assert(err == UFSM_OK); err = ufsm_queue_put(q, 5); - assert (err == UFSM_ERROR_QUEUE_FULL); + assert(err == UFSM_ERROR_QUEUE_FULL); err = ufsm_queue_get(q, &i); - assert ( err == UFSM_OK && i == 1); + assert(err == UFSM_OK && i == 1); err = ufsm_queue_get(q, &i); - assert ( err == UFSM_OK && i == 2); + assert(err == UFSM_OK && i == 2); err = ufsm_queue_get(q, &i); - assert ( err == UFSM_OK && i == 3); + assert(err == UFSM_OK && i == 3); err = ufsm_queue_get(q, &i); - assert ( err == UFSM_OK && i == 4); + assert(err == UFSM_OK && i == 4); - assert (flag_on_data && flag_q_unlock && flag_q_lock); + assert(flag_on_data && flag_q_unlock && flag_q_lock); return 0; } diff --git a/src/tests/test_simple.c b/src/tests/test_simple.c index d634f22..1dde953 100644 --- a/src/tests/test_simple.c +++ b/src/tests/test_simple.c @@ -1,10 +1,10 @@ -#include #include +#include #include #include "common.h" - -enum events { +enum events +{ EV_A, EV_B }; @@ -12,56 +12,42 @@ enum events { static struct ufsm_state A; static struct ufsm_region region1; -static struct ufsm_state simple_INIT = -{ - .name = "Init", - .kind = UFSM_STATE_INIT, - .parent_region = ®ion1, - .next = &A -}; +static struct ufsm_state simple_INIT = {.name = "Init", + .kind = UFSM_STATE_INIT, + .parent_region = ®ion1, + .next = &A}; -static struct ufsm_state B = -{ +static struct ufsm_state B = { .name = "State B", .kind = UFSM_STATE_SIMPLE, .parent_region = ®ion1, .next = NULL, }; -static struct ufsm_state A = -{ +static struct ufsm_state A = { .name = "State A", .kind = UFSM_STATE_SIMPLE, .parent_region = ®ion1, .next = &B, }; - - - -static struct ufsm_transition simple_transition_B = -{ - .name = "EV_B", - .trigger = EV_B, - .kind = UFSM_TRANSITION_EXTERNAL, - .source = &A, - .dest = &B, - .next = NULL -}; - - -static struct ufsm_transition simple_transition_A = -{ - .name = "EV_A", - .trigger = EV_A, - .kind = UFSM_TRANSITION_EXTERNAL, - .source = &B, - .dest = &A, - .next = &simple_transition_B -}; - -static struct ufsm_transition simple_transition_INIT = -{ +static struct ufsm_transition simple_transition_B = + {.name = "EV_B", + .trigger = EV_B, + .kind = UFSM_TRANSITION_EXTERNAL, + .source = &A, + .dest = &B, + .next = NULL}; + +static struct ufsm_transition simple_transition_A = + {.name = "EV_A", + .trigger = EV_A, + .kind = UFSM_TRANSITION_EXTERNAL, + .source = &B, + .dest = &A, + .next = &simple_transition_B}; + +static struct ufsm_transition simple_transition_INIT = { .name = "Init", .kind = UFSM_TRANSITION_EXTERNAL, .source = &simple_INIT, @@ -70,35 +56,32 @@ static struct ufsm_transition simple_transition_INIT = .next = &simple_transition_A, }; -static struct ufsm_region region1 = -{ - .state = &simple_INIT, - .transition = &simple_transition_INIT, - .next = NULL -}; +static struct ufsm_region region1 = {.state = &simple_INIT, + .transition = &simple_transition_INIT, + .next = NULL}; -static struct ufsm_machine m = -{ +static struct ufsm_machine m = { .name = "Simple Test Machine", .region = ®ion1, }; -int main(void) { +int main(void) +{ uint32_t err; test_init(&m); err = ufsm_init_machine(&m); - assert (err == UFSM_OK && "Initializing"); - assert (m.region->current == &A); + assert(err == UFSM_OK && "Initializing"); + assert(m.region->current == &A); err = ufsm_process(&m, EV_B); - assert (m.region->current == &B && err == UFSM_OK); + assert(m.region->current == &B && err == UFSM_OK); err = ufsm_process(&m, EV_A); - assert (m.region->current == &A && err == UFSM_OK); + assert(m.region->current == &A && err == UFSM_OK); err = ufsm_process(&m, EV_B); - assert (m.region->current == &B && err == UFSM_OK); + assert(m.region->current == &B && err == UFSM_OK); err = ufsm_process(&m, EV_B); - assert (m.region->current == &B && err == UFSM_ERROR_EVENT_NOT_PROCESSED); + assert(m.region->current == &B && err == UFSM_ERROR_EVENT_NOT_PROCESSED); return 0; } diff --git a/src/tests/test_simple_substate.c b/src/tests/test_simple_substate.c index bc80c39..29f2687 100644 --- a/src/tests/test_simple_substate.c +++ b/src/tests/test_simple_substate.c @@ -1,9 +1,10 @@ -#include #include +#include #include #include "common.h" -enum events { +enum events +{ EV_A, EV_B, EV_C, @@ -14,24 +15,19 @@ static struct ufsm_state A; static struct ufsm_region sub_region; static struct ufsm_region region1; -static struct ufsm_state simple_INIT = -{ - .name = "Init", - .kind = UFSM_STATE_INIT, - .parent_region = ®ion1, - .next = &A -}; +static struct ufsm_state simple_INIT = {.name = "Init", + .kind = UFSM_STATE_INIT, + .parent_region = ®ion1, + .next = &A}; -static struct ufsm_state B = -{ +static struct ufsm_state B = { .name = "State B", .kind = UFSM_STATE_SIMPLE, .parent_region = ®ion1, .next = NULL, }; -static struct ufsm_state A = -{ +static struct ufsm_state A = { .name = "State A", .kind = UFSM_STATE_SIMPLE, .region = &sub_region, @@ -39,29 +35,23 @@ static struct ufsm_state A = .next = &B, }; -static struct ufsm_transition simple_transition_B = -{ - .name = "EV_B", - .trigger = EV_B, - .kind = UFSM_TRANSITION_EXTERNAL, - .source = &A, - .dest = &B, - .next = NULL -}; +static struct ufsm_transition simple_transition_B = + {.name = "EV_B", + .trigger = EV_B, + .kind = UFSM_TRANSITION_EXTERNAL, + .source = &A, + .dest = &B, + .next = NULL}; +static struct ufsm_transition simple_transition_A = + {.name = "EV_A", + .trigger = EV_A, + .kind = UFSM_TRANSITION_EXTERNAL, + .source = &B, + .dest = &A, + .next = &simple_transition_B}; -static struct ufsm_transition simple_transition_A = -{ - .name = "EV_A", - .trigger = EV_A, - .kind = UFSM_TRANSITION_EXTERNAL, - .source = &B, - .dest = &A, - .next = &simple_transition_B -}; - -static struct ufsm_transition simple_transition_INIT = -{ +static struct ufsm_transition simple_transition_INIT = { .name = "Init", .kind = UFSM_TRANSITION_EXTERNAL, .source = &simple_INIT, @@ -70,38 +60,28 @@ static struct ufsm_transition simple_transition_INIT = .next = &simple_transition_A, }; -static struct ufsm_region region1 = -{ - .state = &simple_INIT, - .transition = &simple_transition_INIT, - .next = NULL -}; - +static struct ufsm_region region1 = {.state = &simple_INIT, + .transition = &simple_transition_INIT, + .next = NULL}; /* Substates in A */ - static struct ufsm_state C; static struct ufsm_state D; -static struct ufsm_state simple_sub_INIT = -{ - .name = "Substate Init", - .kind = UFSM_STATE_INIT, - .parent_region = &sub_region, - .next = &C -}; +static struct ufsm_state simple_sub_INIT = {.name = "Substate Init", + .kind = UFSM_STATE_INIT, + .parent_region = &sub_region, + .next = &C}; -static struct ufsm_state C = -{ +static struct ufsm_state C = { .name = "State C", .kind = UFSM_STATE_SIMPLE, .parent_region = &sub_region, .next = &D, }; -static struct ufsm_state D = -{ +static struct ufsm_state D = { .name = "State D", .kind = UFSM_STATE_SIMPLE, .parent_region = &sub_region, @@ -111,8 +91,7 @@ static struct ufsm_state D = static struct ufsm_transition simple_transition_D; static struct ufsm_transition simple_transition_sub_INIT; -static struct ufsm_transition simple_transition_C = -{ +static struct ufsm_transition simple_transition_C = { .name = "EV_C", .trigger = EV_C, .kind = UFSM_TRANSITION_EXTERNAL, @@ -121,9 +100,7 @@ static struct ufsm_transition simple_transition_C = .next = &simple_transition_D, }; - -static struct ufsm_transition simple_transition_D = -{ +static struct ufsm_transition simple_transition_D = { .name = "EV_D", .trigger = EV_D, .kind = UFSM_TRANSITION_EXTERNAL, @@ -132,8 +109,7 @@ static struct ufsm_transition simple_transition_D = .next = &simple_transition_sub_INIT, }; -static struct ufsm_transition simple_transition_sub_INIT = -{ +static struct ufsm_transition simple_transition_sub_INIT = { .name = "Init sub", .kind = UFSM_TRANSITION_EXTERNAL, .source = &simple_sub_INIT, @@ -142,18 +118,12 @@ static struct ufsm_transition simple_transition_sub_INIT = .next = NULL, }; +static struct ufsm_region sub_region = {.name = "Sub region", + .state = &simple_sub_INIT, + .transition = &simple_transition_C, + .next = NULL}; - -static struct ufsm_region sub_region = -{ - .name ="Sub region", - .state = &simple_sub_INIT, - .transition = &simple_transition_C, - .next = NULL -}; - -static struct ufsm_machine m = -{ +static struct ufsm_machine m = { .name = "Simple Substate Test Machine", .region = ®ion1, }; @@ -164,29 +134,27 @@ int main(void) test_init(&m); err = ufsm_init_machine(&m); - assert (err == UFSM_OK && "Initializing"); - assert (m.region->current == &A && m.region->current->region->current == &C); + assert(err == UFSM_OK && "Initializing"); + assert(m.region->current == &A && m.region->current->region->current == &C); err = ufsm_process(&m, EV_B); - assert (m.region->current == &B && err == UFSM_OK); - assert (m.region->current->region == NULL); + assert(m.region->current == &B && err == UFSM_OK); + assert(m.region->current->region == NULL); err = ufsm_process(&m, EV_A); - assert (m.region->current == &A && err == UFSM_OK); - assert (m.region->current->region->current == &C); - + assert(m.region->current == &A && err == UFSM_OK); + assert(m.region->current->region->current == &C); err = ufsm_process(&m, EV_D); - assert (m.region->current == &A && err == UFSM_OK); - assert (m.region->current->region->current == &D); + assert(m.region->current == &A && err == UFSM_OK); + assert(m.region->current->region->current == &D); err = ufsm_process(&m, EV_B); - assert (m.region->current == &B && err == UFSM_OK); - assert (m.region->current->region == NULL); + assert(m.region->current == &B && err == UFSM_OK); + assert(m.region->current->region == NULL); err = ufsm_process(&m, EV_A); - assert (m.region->current == &A && err == UFSM_OK); - assert (m.region->current->region->current == &C); - + assert(m.region->current == &A && err == UFSM_OK); + assert(m.region->current->region->current == &C); return 0; } diff --git a/src/tests/test_stack.c b/src/tests/test_stack.c index 088460f..ea65f85 100644 --- a/src/tests/test_stack.c +++ b/src/tests/test_stack.c @@ -1,39 +1,40 @@ -#include #include +#include #include "common.h" #define STACK_SIZE 4 - int main(void) { - void *stack_data[STACK_SIZE]; + void* stack_data[STACK_SIZE]; struct ufsm_stack s; - const char *test_data = "The Quick Brown Fox Jumps Over The Lazy Dog"; + const char* test_data = "The Quick Brown Fox Jumps Over The Lazy Dog"; - char *popped_string = NULL; + char* popped_string = NULL; - assert (ufsm_stack_init(&s, STACK_SIZE, stack_data) == UFSM_OK); + assert(ufsm_stack_init(&s, STACK_SIZE, stack_data) == UFSM_OK); - assert (ufsm_stack_pop(&s, (void **) &popped_string) == UFSM_ERROR_STACK_UNDERFLOW); + assert(ufsm_stack_pop(&s, (void**)&popped_string) == + UFSM_ERROR_STACK_UNDERFLOW); - assert (ufsm_stack_push(&s, (void *) test_data) == UFSM_OK); + assert(ufsm_stack_push(&s, (void*)test_data) == UFSM_OK); - assert (ufsm_stack_pop(&s, (void **) &popped_string) == UFSM_OK); + assert(ufsm_stack_pop(&s, (void**)&popped_string) == UFSM_OK); - assert (strcmp(popped_string, test_data) == 0); + assert(strcmp(popped_string, test_data) == 0); - assert (ufsm_stack_push(&s, (void *) test_data) == UFSM_OK); - assert (ufsm_stack_push(&s, (void *) test_data) == UFSM_OK); - assert (ufsm_stack_push(&s, (void *) test_data) == UFSM_OK); - assert (ufsm_stack_push(&s, (void *) test_data) == UFSM_OK); - assert (ufsm_stack_push(&s, (void *) test_data) == UFSM_ERROR_STACK_OVERFLOW); + assert(ufsm_stack_push(&s, (void*)test_data) == UFSM_OK); + assert(ufsm_stack_push(&s, (void*)test_data) == UFSM_OK); + assert(ufsm_stack_push(&s, (void*)test_data) == UFSM_OK); + assert(ufsm_stack_push(&s, (void*)test_data) == UFSM_OK); + assert(ufsm_stack_push(&s, (void*)test_data) == UFSM_ERROR_STACK_OVERFLOW); - assert (ufsm_stack_pop(&s, (void **) &popped_string) == UFSM_OK); - assert (ufsm_stack_pop(&s, (void **) &popped_string) == UFSM_OK); - assert (ufsm_stack_pop(&s, (void **) &popped_string) == UFSM_OK); - assert (ufsm_stack_pop(&s, (void **) &popped_string) == UFSM_OK); - assert (ufsm_stack_pop(&s, (void **) &popped_string) == UFSM_ERROR_STACK_UNDERFLOW); + assert(ufsm_stack_pop(&s, (void**)&popped_string) == UFSM_OK); + assert(ufsm_stack_pop(&s, (void**)&popped_string) == UFSM_OK); + assert(ufsm_stack_pop(&s, (void**)&popped_string) == UFSM_OK); + assert(ufsm_stack_pop(&s, (void**)&popped_string) == UFSM_OK); + assert(ufsm_stack_pop(&s, (void**)&popped_string) == + UFSM_ERROR_STACK_UNDERFLOW); return 0; } diff --git a/src/tests/test_terminate.c b/src/tests/test_terminate.c index 8d0f7cb..0d5d284 100644 --- a/src/tests/test_terminate.c +++ b/src/tests/test_terminate.c @@ -1,38 +1,32 @@ -#include #include -#include +#include #include +#include #include "common.h" static bool flag_xA = false; static bool flag_eA = false; -void xA(void) -{ - flag_xA = true; -} +void xA(void) { flag_xA = true; } -void eA(void) -{ - flag_eA = true; -} +void eA(void) { flag_eA = true; } -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); - + struct ufsm_machine* m = get_StateMachine1(); + test_init(m); ufsm_init_machine(m); - assert (flag_eA); + assert(flag_eA); test_process(m, EV); - assert (flag_eA && !flag_xA); - - assert (ufsm_process(m, EV) == UFSM_ERROR_MACHINE_TERMINATED); + assert(flag_eA && !flag_xA); + + assert(ufsm_process(m, EV) == UFSM_ERROR_MACHINE_TERMINATED); - assert (m->terminated); + assert(m->terminated); return 0; } diff --git a/src/tests/test_transition_prio.c b/src/tests/test_transition_prio.c index 99f6c88..798ea21 100644 --- a/src/tests/test_transition_prio.c +++ b/src/tests/test_transition_prio.c @@ -1,7 +1,7 @@ -#include #include -#include +#include #include +#include #include "common.h" static bool flag_eD = false; @@ -13,35 +13,27 @@ static void reset_flags(void) flag_eE = false; } -void eD(void) -{ - flag_eD = true; -} +void eD(void) { flag_eD = true; } -void eE(void) -{ - flag_eE = true; -} +void eE(void) { flag_eE = true; } -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); - + struct ufsm_machine* m = get_StateMachine1(); + test_init(m); ufsm_init_machine(m); test_process(m, EV1); test_process(m, EV1); - assert (flag_eE && - !flag_eD); + assert(flag_eE && !flag_eD); ufsm_reset_machine(m); reset_flags(); ufsm_init_machine(m); test_process(m, EV2); - assert (!flag_eE && - flag_eD); + assert(!flag_eE && flag_eD); return 0; } diff --git a/src/tests/test_xmi_machine.c b/src/tests/test_xmi_machine.c index 48955bb..e353364 100644 --- a/src/tests/test_xmi_machine.c +++ b/src/tests/test_xmi_machine.c @@ -1,8 +1,7 @@ -#include -#include -#include #include +#include #include +#include #include "common.h" static bool flag_eC = false; @@ -22,82 +21,59 @@ static void reset_flags(void) flag_final = false; } +bool Guard(void) { return true; } -bool Guard(void) -{ - return true; -} - -void DoAction(void) -{ -} +void DoAction(void) {} -void eD(void) -{ - flag_eD = true; -} +void eD(void) { flag_eD = true; } -void eC(void) -{ - flag_eC = true; -} +void eC(void) { flag_eC = true; } -void t1(void) -{ - flag_t1 = true; -} +void t1(void) { flag_t1 = true; } -void t2(void) -{ - flag_t2 = true; -} +void t2(void) { flag_t2 = true; } -void t3(void) -{ - flag_t3 = true; -} +void t3(void) { flag_t3 = true; } -void final(void) -{ - flag_final = true; -} +void final(void) { flag_final = true; } -int main(void) +int main(void) { - struct ufsm_machine *m = get_StateMachine1(); + struct ufsm_machine* m = get_StateMachine1(); uint32_t err = UFSM_OK; test_init(m); - assert (ufsm_init_machine(m) == UFSM_OK); - assert (flag_eC); + assert(ufsm_init_machine(m) == UFSM_OK); + assert(flag_eC); reset_flags(); - test_process (m, EV_D); - test_process (m, EV_B); + test_process(m, EV_D); + test_process(m, EV_B); - test_process (m, EV_E); - test_process (m, EV_B); - test_process (m, EV_A); + test_process(m, EV_E); + test_process(m, EV_B); + test_process(m, EV_A); assert(flag_eD); - + reset_flags(); - test_process (m, EV_B); - test_process (m, EV_E); - assert (!flag_t1 && !flag_t2 && !flag_t3); - err = ufsm_process (m, EV_E1); - if (err != UFSM_OK) { - printf ("Error: %i\n", err); + test_process(m, EV_B); + test_process(m, EV_E); + assert(!flag_t1 && !flag_t2 && !flag_t3); + err = ufsm_process(m, EV_E1); + if (err != UFSM_OK) + { + printf("Error: %i\n", err); assert(0); } - - assert (flag_t1); - assert (!flag_t2); - assert (!flag_t3); - assert (flag_t1 && !flag_t2 && !flag_t3); - assert (ufsm_process (m, EV_E2) == UFSM_OK); - assert (flag_t1 && flag_t2 && !flag_t3); - assert (ufsm_process (m, EV_E3) == UFSM_OK); - assert (flag_t1 && flag_t2 && flag_t3); - assert (flag_final); + + assert(flag_t1); + assert(!flag_t2); + assert(!flag_t3); + assert(flag_t1 && !flag_t2 && !flag_t3); + assert(ufsm_process(m, EV_E2) == UFSM_OK); + assert(flag_t1 && flag_t2 && !flag_t3); + assert(ufsm_process(m, EV_E3) == UFSM_OK); + assert(flag_t1 && flag_t2 && flag_t3); + assert(flag_final); return 0; } diff --git a/src/tools/output.c b/src/tools/output.c index b903b68..487b7b9 100644 --- a/src/tools/output.c +++ b/src/tools/output.c @@ -8,35 +8,37 @@ */ #include -#include #include #include #include #include +#include #include "output.h" -static FILE *fp_c = NULL; -static FILE *fp_h = NULL; +static FILE* fp_c = NULL; +static FILE* fp_h = NULL; static uint32_t v = 0; static bool flag_strip = false; -struct event_list { - char *name; +struct event_list +{ + char* name; uint32_t index; - struct event_list *next; + struct event_list* next; }; -static struct event_list *evlist; +static struct event_list* evlist; -static char * id_to_decl(const char *id) +static char* id_to_decl(const char* id) { - char * decl = malloc (strlen(id)+1); - char * decl_ptr = decl; + char* decl = malloc(strlen(id) + 1); + char* decl_ptr = decl; bzero(decl, strlen(id) + 1); - do { + do + { *decl_ptr = *id++; if (*decl_ptr == '+') *decl_ptr = '_'; @@ -46,27 +48,29 @@ static char * id_to_decl(const char *id) *decl_ptr = 0; } while (*decl_ptr++); - - + return decl; } -static uint32_t ev_name_to_index(const char *name) +static uint32_t ev_name_to_index(const char* name) { - struct event_list *last_entry = evlist; + struct event_list* last_entry = evlist; - if (evlist == NULL) { + if (evlist == NULL) + { evlist = malloc(sizeof(struct event_list)); bzero(evlist, sizeof(struct event_list)); - evlist->name = malloc(strlen(name)+1); + evlist->name = malloc(strlen(name) + 1); strcpy(evlist->name, name); evlist->index = 0; evlist->next = NULL; return 0; } - for (struct event_list *e = evlist; e; e = e->next) { - if (strcmp(name, e->name) == 0) { + for (struct event_list* e = evlist; e; e = e->next) + { + if (strcmp(name, e->name) == 0) + { return e->index; } last_entry = e; @@ -74,230 +78,281 @@ static uint32_t ev_name_to_index(const char *name) last_entry->next = malloc(sizeof(struct event_list)); bzero(last_entry->next, sizeof(struct event_list)); - struct event_list *e = last_entry->next; - e->name = malloc(strlen(name)+1); + struct event_list* e = last_entry->next; + e->name = malloc(strlen(name) + 1); strcpy(e->name, name); - e->index = last_entry->index+1; + e->index = last_entry->index + 1; return e->index; } -static void ufsm_gen_regions(struct ufsm_region *region); +static void ufsm_gen_regions(struct ufsm_region* region); -static void ufsm_gen_states(struct ufsm_state *state) +static void ufsm_gen_states(struct ufsm_state* state) { - fprintf(fp_c,"static struct ufsm_state %s = {\n",id_to_decl(state->id)); - if (flag_strip) { - fprintf (fp_c," .id = \"\", \n"); - fprintf (fp_c," .name = \"\", \n"); - } else { - fprintf(fp_c," .id = \"%s\",\n",state->id); - fprintf(fp_c," .name = \"%s\",\n",state->name); + fprintf(fp_c, "static struct ufsm_state %s = {\n", id_to_decl(state->id)); + if (flag_strip) + { + fprintf(fp_c, " .id = \"\", \n"); + fprintf(fp_c, " .name = \"\", \n"); } - fprintf(fp_c," .kind = %i,\n",state->kind); - fprintf(fp_c," .parent_region = &%s,\n", - id_to_decl(state->parent_region->id)); + else + { + fprintf(fp_c, " .id = \"%s\",\n", state->id); + fprintf(fp_c, " .name = \"%s\",\n", state->name); + } + fprintf(fp_c, " .kind = %i,\n", state->kind); + fprintf(fp_c, + " .parent_region = &%s,\n", + id_to_decl(state->parent_region->id)); if (state->entry) - fprintf(fp_c," .entry = &%s,\n",id_to_decl(state->entry->id)); + fprintf(fp_c, " .entry = &%s,\n", id_to_decl(state->entry->id)); else - fprintf(fp_c," .entry = NULL,\n"); - + fprintf(fp_c, " .entry = NULL,\n"); if (state->doact) - fprintf(fp_c," .doact = &%s,\n",id_to_decl(state->doact->id)); + fprintf(fp_c, " .doact = &%s,\n", id_to_decl(state->doact->id)); else - fprintf(fp_c," .doact = NULL,\n"); - + fprintf(fp_c, " .doact = NULL,\n"); if (state->exit) - fprintf(fp_c," .exit = &%s,\n",id_to_decl(state->exit->id)); + fprintf(fp_c, " .exit = &%s,\n", id_to_decl(state->exit->id)); else - fprintf(fp_c," .exit = NULL,\n"); + fprintf(fp_c, " .exit = NULL,\n"); - if (state->region) { - fprintf(fp_c," .region = &%s,\n",id_to_decl(state->region->id)); - } else if (state->submachine) { + if (state->region) + { + fprintf(fp_c, " .region = &%s,\n", id_to_decl(state->region->id)); + } + else if (state->submachine) + { state->submachine->region->parent_state = state; - fprintf(fp_c," .region = &%s,\n",id_to_decl(state->submachine->region->id)); - } else { - fprintf(fp_c," .region = NULL,\n"); + fprintf(fp_c, + " .region = &%s,\n", + id_to_decl(state->submachine->region->id)); + } + else + { + fprintf(fp_c, " .region = NULL,\n"); } - fprintf(fp_c," .submachine = NULL,\n"); + fprintf(fp_c, " .submachine = NULL,\n"); if (state->next) - fprintf(fp_c," .next = &%s,\n",id_to_decl(state->next->id)); + fprintf(fp_c, " .next = &%s,\n", id_to_decl(state->next->id)); else - fprintf(fp_c," .next = NULL,\n"); + fprintf(fp_c, " .next = NULL,\n"); - fprintf(fp_c,"};\n"); + fprintf(fp_c, "};\n"); if (state->region) ufsm_gen_regions(state->region); - for (struct ufsm_entry_exit *e = state->entry; e; e = e->next) { - fprintf(fp_c, "static struct ufsm_entry_exit %s = {\n", - id_to_decl(e->id)); - if (flag_strip) { - fprintf (fp_c," .id = \"\", \n"); - fprintf (fp_c," .name = \"\", \n"); - } else { + for (struct ufsm_entry_exit* e = state->entry; e; e = e->next) + { + fprintf(fp_c, + "static struct ufsm_entry_exit %s = {\n", + id_to_decl(e->id)); + if (flag_strip) + { + fprintf(fp_c, " .id = \"\", \n"); + fprintf(fp_c, " .name = \"\", \n"); + } + else + { fprintf(fp_c, " .id = \"%s\",\n", e->id); - fprintf(fp_c, " .name = \"%s\",\n",e->name); + fprintf(fp_c, " .name = \"%s\",\n", e->name); } fprintf(fp_c, " .f = &%s,\n", e->name); if (e->next) - fprintf (fp_c, " .next = &%s,\n", id_to_decl(e->next->id)); + fprintf(fp_c, " .next = &%s,\n", id_to_decl(e->next->id)); else - fprintf (fp_c, " .next = NULL,\n"); + fprintf(fp_c, " .next = NULL,\n"); fprintf(fp_c, "};\n"); fprintf(fp_h, "void %s(void);\n", e->name); } - - for (struct ufsm_doact *d = state->doact; d; d = d->next) { - fprintf(fp_c, "static struct ufsm_doact %s = {\n", - id_to_decl(d->id)); - if (flag_strip) { - fprintf (fp_c," .id = \"\", \n"); - fprintf (fp_c," .name = \"\", \n"); - } else { + for (struct ufsm_doact* d = state->doact; d; d = d->next) + { + fprintf(fp_c, "static struct ufsm_doact %s = {\n", id_to_decl(d->id)); + if (flag_strip) + { + fprintf(fp_c, " .id = \"\", \n"); + fprintf(fp_c, " .name = \"\", \n"); + } + else + { fprintf(fp_c, " .id = \"%s\",\n", d->id); - fprintf(fp_c, " .name = \"%s\",\n",d->name); + fprintf(fp_c, " .name = \"%s\",\n", d->name); } fprintf(fp_c, " .f_start = &%s_start,\n", d->name); fprintf(fp_c, " .f_stop = &%s_stop,\n", d->name); - if (d->next) - fprintf (fp_c, " .next = &%s,\n", id_to_decl(d->next->id)); + fprintf(fp_c, " .next = &%s,\n", id_to_decl(d->next->id)); else - fprintf (fp_c, " .next = NULL,\n"); - + fprintf(fp_c, " .next = NULL,\n"); fprintf(fp_c, "};\n"); - fprintf(fp_h, "void %s_start(struct ufsm_machine *m, struct ufsm_state *s, ufsm_doact_cb_t cb);\n", d->name); + fprintf(fp_h, + "void %s_start(struct ufsm_machine *m, struct ufsm_state *s, " + "ufsm_doact_cb_t cb);\n", + d->name); fprintf(fp_h, "void %s_stop(void);\n", d->name); - } - for (struct ufsm_entry_exit *e = state->exit; e; e = e->next) { - fprintf(fp_c, "static struct ufsm_entry_exit %s = {\n", - id_to_decl(e->id)); - if (flag_strip) { - fprintf (fp_c," .id = \"\", \n"); - fprintf (fp_c," .name = \"\", \n"); - } else { + for (struct ufsm_entry_exit* e = state->exit; e; e = e->next) + { + fprintf(fp_c, + "static struct ufsm_entry_exit %s = {\n", + id_to_decl(e->id)); + if (flag_strip) + { + fprintf(fp_c, " .id = \"\", \n"); + fprintf(fp_c, " .name = \"\", \n"); + } + else + { fprintf(fp_c, " .id = \"%s\",\n", e->id); - fprintf(fp_c, " .name = \"%s\",\n",e->name); + fprintf(fp_c, " .name = \"%s\",\n", e->name); } fprintf(fp_c, " .f = &%s,\n", e->name); if (e->next) - fprintf (fp_c, " .next = &%s,\n", id_to_decl(e->next->id)); + fprintf(fp_c, " .next = &%s,\n", id_to_decl(e->next->id)); else - fprintf (fp_c, " .next = NULL,\n"); - + fprintf(fp_c, " .next = NULL,\n"); fprintf(fp_c, "};\n"); fprintf(fp_h, "void %s(void);\n", e->name); - } } -static void ufsm_gen_regions(struct ufsm_region *region) +static void ufsm_gen_regions(struct ufsm_region* region) { - for (struct ufsm_region *r = region; r; r = r->next) { - fprintf (fp_c,"static struct ufsm_region %s = {\n",id_to_decl(r->id)); - if (flag_strip) { - fprintf (fp_c," .id = \"\", \n"); - fprintf (fp_c," .name = \"\", \n"); - } else { - fprintf (fp_c," .id = \"%s\",\n", r->id); - fprintf (fp_c," .name = \"%s\",\n", r->name); + for (struct ufsm_region* r = region; r; r = r->next) + { + fprintf(fp_c, "static struct ufsm_region %s = {\n", id_to_decl(r->id)); + if (flag_strip) + { + fprintf(fp_c, " .id = \"\", \n"); + fprintf(fp_c, " .name = \"\", \n"); + } + else + { + fprintf(fp_c, " .id = \"%s\",\n", r->id); + fprintf(fp_c, " .name = \"%s\",\n", r->name); } if (r->state) - fprintf (fp_c," .state = &%s,\n", id_to_decl(r->state->id)); + fprintf(fp_c, " .state = &%s,\n", id_to_decl(r->state->id)); else - fprintf (fp_c," .state = NULL,\n"); + fprintf(fp_c, " .state = NULL,\n"); - fprintf (fp_c," .has_history = %s,\n", r->has_history ? "true" : "false"); - fprintf (fp_c," .history = NULL,\n"); + fprintf(fp_c, + " .has_history = %s,\n", + r->has_history ? "true" : "false"); + fprintf(fp_c, " .history = NULL,\n"); if (r->transition) - fprintf (fp_c," .transition = &%s,\n", - id_to_decl(r->transition->id)); - else - fprintf (fp_c," .transition = NULL,\n"); - + fprintf(fp_c, + " .transition = &%s,\n", + id_to_decl(r->transition->id)); + else + fprintf(fp_c, " .transition = NULL,\n"); + if (r->parent_state) - fprintf (fp_c," .parent_state = &%s,\n", - id_to_decl(r->parent_state->id)); + fprintf(fp_c, + " .parent_state = &%s,\n", + id_to_decl(r->parent_state->id)); else - fprintf (fp_c," .parent_state = NULL,\n"); + fprintf(fp_c, " .parent_state = NULL,\n"); if (r->next) - fprintf (fp_c," .next = &%s,\n",id_to_decl(r->next->id)); + fprintf(fp_c, " .next = &%s,\n", id_to_decl(r->next->id)); else - fprintf (fp_c," .next = NULL,\n"); - fprintf (fp_c,"};\n"); - - for (struct ufsm_transition *t = r->transition; t; t = t->next) { - fprintf(fp_c, "static struct ufsm_transition %s = {\n", - id_to_decl(t->id)); - if (flag_strip) { - fprintf (fp_c," .id = \"\", \n"); - fprintf (fp_c," .name = \"\", \n"); - } else { + fprintf(fp_c, " .next = NULL,\n"); + fprintf(fp_c, "};\n"); + + for (struct ufsm_transition* t = r->transition; t; t = t->next) + { + fprintf(fp_c, + "static struct ufsm_transition %s = {\n", + id_to_decl(t->id)); + if (flag_strip) + { + fprintf(fp_c, " .id = \"\", \n"); + fprintf(fp_c, " .name = \"\", \n"); + } + else + { fprintf(fp_c, " .id = \"%s\",\n", t->id); fprintf(fp_c, " .name = \"\",\n"); } - if (t->trigger_name != NULL) { - fprintf(fp_c, " .trigger = %i,\n", - ev_name_to_index(t->trigger_name)); - fprintf(fp_c, " .trigger_name = \"%s\",\n",t->trigger_name); - } else { + if (t->trigger_name != NULL) + { + fprintf(fp_c, + " .trigger = %i,\n", + ev_name_to_index(t->trigger_name)); + fprintf(fp_c, " .trigger_name = \"%s\",\n", t->trigger_name); + } + else + { fprintf(fp_c, " .trigger = -1,\n"); fprintf(fp_c, " .trigger_name = \"\",\n"); } - fprintf(fp_c, " .kind = %i,\n",t->kind); - if (t->action) { - if (strcmp(t->action->name, "ufsm_defer") == 0) { + fprintf(fp_c, " .kind = %i,\n", t->kind); + if (t->action) + { + if (strcmp(t->action->name, "ufsm_defer") == 0) + { fprintf(fp_c, " .action = NULL,\n"); fprintf(fp_c, " .defer = true,\n"); - } else { - fprintf(fp_c, " .action = &%s,\n", id_to_decl(t->action->id)); + } + else + { + fprintf(fp_c, + " .action = &%s,\n", + id_to_decl(t->action->id)); fprintf(fp_c, " .defer = false,\n"); - fprintf(fp_h, "void %s(void);\n",t->action->name); + fprintf(fp_h, "void %s(void);\n", t->action->name); } - - } else { + } + else + { fprintf(fp_c, " .action = NULL,\n"); fprintf(fp_c, " .defer = false,\n"); } - if (t->guard) { + if (t->guard) + { fprintf(fp_c, " .guard = &%s,\n", id_to_decl(t->guard->id)); - fprintf(fp_h, "bool %s(void);\n",t->guard->name); - } else { + fprintf(fp_h, "bool %s(void);\n", t->guard->name); + } + else + { fprintf(fp_c, " .guard = NULL,\n"); } - fprintf(fp_c, " .source = &%s,\n",id_to_decl(t->source->id)); - fprintf(fp_c, " .dest = &%s,\n",id_to_decl(t->dest->id)); + fprintf(fp_c, " .source = &%s,\n", id_to_decl(t->source->id)); + fprintf(fp_c, " .dest = &%s,\n", id_to_decl(t->dest->id)); if (t->next) - fprintf(fp_c, " .next = &%s,\n",id_to_decl(t->next->id)); + fprintf(fp_c, " .next = &%s,\n", id_to_decl(t->next->id)); else - fprintf(fp_c, " .next = NULL,\n"); + fprintf(fp_c, " .next = NULL,\n"); fprintf(fp_c, "};\n"); - for (struct ufsm_action *a = t->action; a; a = a->next) { + for (struct ufsm_action* a = t->action; a; a = a->next) + { if (strcmp(a->name, "ufsm_defer") == 0) continue; - fprintf(fp_c, "static struct ufsm_action %s = {\n", - id_to_decl(a->id)); - if (flag_strip) { - fprintf (fp_c," .id = \"\", \n"); - fprintf (fp_c," .name = \"\", \n"); - } else { + fprintf(fp_c, + "static struct ufsm_action %s = {\n", + id_to_decl(a->id)); + if (flag_strip) + { + fprintf(fp_c, " .id = \"\", \n"); + fprintf(fp_c, " .name = \"\", \n"); + } + else + { fprintf(fp_c, " .id = \"%s\",\n", a->id); fprintf(fp_c, " .name = \"%s\",\n", a->name); } @@ -308,9 +363,11 @@ static void ufsm_gen_regions(struct ufsm_region *region) fprintf(fp_c, " .next = NULL,\n"); fprintf(fp_c, "};\n"); } - for (struct ufsm_guard *g = t->guard; g; g = g->next) { - fprintf(fp_c, "static struct ufsm_guard %s = {\n", - id_to_decl(g->id)); + for (struct ufsm_guard* g = t->guard; g; g = g->next) + { + fprintf(fp_c, + "static struct ufsm_guard %s = {\n", + id_to_decl(g->id)); fprintf(fp_c, " .id = \"%s\",\n", g->id); fprintf(fp_c, " .name = \"%s\",\n", g->name); fprintf(fp_c, " .f = &%s,\n", g->name); @@ -318,169 +375,177 @@ static void ufsm_gen_regions(struct ufsm_region *region) fprintf(fp_c, " .next = &%s,\n", id_to_decl(g->next->id)); else fprintf(fp_c, " .next = NULL,\n"); - + fprintf(fp_c, "};\n"); } } - for (struct ufsm_state *s = r->state; s; s = s->next) + for (struct ufsm_state* s = r->state; s; s = s->next) ufsm_gen_states(s); } } -bool ufsm_gen_machine (struct ufsm_machine *m) +bool ufsm_gen_machine(struct ufsm_machine* m) { - fprintf (fp_c,"static struct ufsm_machine %s = {\n",id_to_decl(m->id)); - if (flag_strip) { - fprintf (fp_c," .id = \"\", \n"); - fprintf (fp_c," .name = \"\", \n"); - } else { - fprintf (fp_c," .id = \"%s\", \n", m->id); - fprintf (fp_c," .name = \"%s\", \n", m->name); + fprintf(fp_c, "static struct ufsm_machine %s = {\n", id_to_decl(m->id)); + if (flag_strip) + { + fprintf(fp_c, " .id = \"\", \n"); + fprintf(fp_c, " .name = \"\", \n"); + } + else + { + fprintf(fp_c, " .id = \"%s\", \n", m->id); + fprintf(fp_c, " .name = \"%s\", \n", m->name); } - fprintf (fp_c," .region = &%s, \n",id_to_decl(m->region->id)); + fprintf(fp_c, " .region = &%s, \n", id_to_decl(m->region->id)); if (m->next) - fprintf (fp_c," .next = &%s, \n", id_to_decl(m->next->id)); + fprintf(fp_c, " .next = &%s, \n", id_to_decl(m->next->id)); else - fprintf (fp_c," .next = NULL,\n"); - + fprintf(fp_c, " .next = NULL,\n"); if (m->parent_state) - fprintf (fp_c," .parent_state = &%s, \n", id_to_decl(m->parent_state->id)); + fprintf(fp_c, + " .parent_state = &%s, \n", + id_to_decl(m->parent_state->id)); else - fprintf (fp_c," .parent_state = NULL, \n"); + fprintf(fp_c, " .parent_state = NULL, \n"); + + fprintf(fp_c, "};\n"); - fprintf (fp_c,"};\n"); - if (m->region) ufsm_gen_regions(m->region); return true; } +static void ufsm_gen_regions_decl(struct ufsm_region* region); - -static void ufsm_gen_regions_decl(struct ufsm_region *region); - -static void ufsm_gen_states_decl(struct ufsm_state *state) +static void ufsm_gen_states_decl(struct ufsm_state* state) { - fprintf(fp_c,"static struct ufsm_state %s;\n",id_to_decl(state->id)); + fprintf(fp_c, "static struct ufsm_state %s;\n", id_to_decl(state->id)); if (state->region) ufsm_gen_regions_decl(state->region); + for (struct ufsm_entry_exit* e = state->entry; e; e = e->next) + fprintf(fp_c, "static struct ufsm_entry_exit %s;\n", id_to_decl(e->id)); + for (struct ufsm_doact* e = state->doact; e; e = e->next) + fprintf(fp_c, "static struct ufsm_doact %s;\n", id_to_decl(e->id)); - for (struct ufsm_entry_exit *e = state->entry; e; e = e->next) - fprintf(fp_c, "static struct ufsm_entry_exit %s;\n", - id_to_decl(e->id)); - - for (struct ufsm_doact *e = state->doact; e; e = e->next) - fprintf(fp_c, "static struct ufsm_doact %s;\n", - id_to_decl(e->id)); - - for (struct ufsm_entry_exit *e = state->exit; e; e = e->next) - fprintf(fp_c, "static struct ufsm_entry_exit %s;\n", - id_to_decl(e->id)); - - + for (struct ufsm_entry_exit* e = state->exit; e; e = e->next) + fprintf(fp_c, "static struct ufsm_entry_exit %s;\n", id_to_decl(e->id)); } -static void ufsm_gen_regions_decl(struct ufsm_region *region) +static void ufsm_gen_regions_decl(struct ufsm_region* region) { - for (struct ufsm_region *r = region; r; r = r->next) { - fprintf (fp_c,"static struct ufsm_region %s;\n",id_to_decl(r->id)); - - for (struct ufsm_transition *t = r->transition; t; t = t->next) { - fprintf(fp_c, "static struct ufsm_transition %s;\n", - id_to_decl(t->id)); - - for (struct ufsm_action *a = t->action; a; a = a->next) + for (struct ufsm_region* r = region; r; r = r->next) + { + fprintf(fp_c, "static struct ufsm_region %s;\n", id_to_decl(r->id)); + + for (struct ufsm_transition* t = r->transition; t; t = t->next) + { + fprintf(fp_c, + "static struct ufsm_transition %s;\n", + id_to_decl(t->id)); + + for (struct ufsm_action* a = t->action; a; a = a->next) { - if (! (strcmp(a->name, "ufsm_defer") == 0)) - fprintf(fp_c, "static struct ufsm_action %s;\n", + if (!(strcmp(a->name, "ufsm_defer") == 0)) + fprintf(fp_c, + "static struct ufsm_action %s;\n", id_to_decl(a->id)); } - for (struct ufsm_guard *g = t->guard; g; g = g->next) - fprintf(fp_c, "static struct ufsm_guard %s;\n", - id_to_decl(g->id)); - + for (struct ufsm_guard* g = t->guard; g; g = g->next) + fprintf(fp_c, + "static struct ufsm_guard %s;\n", + id_to_decl(g->id)); } - for (struct ufsm_state *s = r->state; s; s = s->next) + for (struct ufsm_state* s = r->state; s; s = s->next) ufsm_gen_states_decl(s); - } } -bool ufsm_gen_machine_decl (struct ufsm_machine *m) +bool ufsm_gen_machine_decl(struct ufsm_machine* m) { - fprintf (fp_c,"static struct ufsm_machine %s;\n",id_to_decl(m->id)); + fprintf(fp_c, "static struct ufsm_machine %s;\n", id_to_decl(m->id)); ufsm_gen_regions_decl(m->region); return true; } -bool ufsm_gen_output(struct ufsm_machine *root, char *output_name, - char *output_prefix, uint32_t verbose, bool strip) +bool ufsm_gen_output(struct ufsm_machine* root, + char* output_name, + char* output_prefix, + uint32_t verbose, + bool strip) { v = verbose; - if (v) printf ("o Generating output %s\n", output_name); - - char *fn_c = malloc(strlen(output_name)+strlen(output_prefix)+3); - char *fn_h = malloc(strlen(output_name)+strlen(output_prefix)+3); + if (v) + printf("o Generating output %s\n", output_name); + + char* fn_c = malloc(strlen(output_name) + strlen(output_prefix) + 3); + char* fn_h = malloc(strlen(output_name) + strlen(output_prefix) + 3); flag_strip = strip; - sprintf(fn_c, "%s%s.c",output_prefix,output_name); - sprintf(fn_h, "%s%s.h",output_prefix,output_name); + sprintf(fn_c, "%s%s.c", output_prefix, output_name); + sprintf(fn_h, "%s%s.h", output_prefix, output_name); fp_c = fopen(fn_c, "w"); fp_h = fopen(fn_h, "w"); - if (fp_c == NULL) { - printf ("Error: Could not open file '%s' for writing\n", fn_c); + if (fp_c == NULL) + { + printf("Error: Could not open file '%s' for writing\n", fn_c); return false; } - if (fp_h == NULL) { - printf ("Error: Could not open file '%s' for writing\n", fn_h); + if (fp_h == NULL) + { + printf("Error: Could not open file '%s' for writing\n", fn_h); return false; } - fprintf(fp_h,"#ifndef UFSM_GEN_%s_H__\n", output_name); - fprintf(fp_h,"#define UFSM_GEN_%s_H__\n", output_name); - fprintf(fp_h,"#include \n"); - fprintf(fp_h,"#ifndef NULL\n"); - fprintf(fp_h," #define NULL (void *) 0\n"); - fprintf(fp_h,"#endif\n"); + fprintf(fp_h, "#ifndef UFSM_GEN_%s_H__\n", output_name); + fprintf(fp_h, "#define UFSM_GEN_%s_H__\n", output_name); + fprintf(fp_h, "#include \n"); + fprintf(fp_h, "#ifndef NULL\n"); + fprintf(fp_h, " #define NULL (void *) 0\n"); + fprintf(fp_h, "#endif\n"); - fprintf(fp_c,"#include \"%s\"\n", fn_h); + fprintf(fp_c, "#include \"%s\"\n", fn_h); - for (struct ufsm_machine *m = root; m; m = m->next) + for (struct ufsm_machine* m = root; m; m = m->next) ufsm_gen_machine_decl(m); - fprintf(fp_c,"\n\n\n"); - for (struct ufsm_machine *m = root; m; m = m->next) + fprintf(fp_c, "\n\n\n"); + for (struct ufsm_machine* m = root; m; m = m->next) ufsm_gen_machine(m); - fprintf(fp_c,"\n"); - for (struct ufsm_machine *m = root; m; m = m->next) { - fprintf(fp_c,"struct ufsm_machine * get_%s(void) { return &%s; }\n", - m->name, id_to_decl(m->id)); + fprintf(fp_c, "\n"); + for (struct ufsm_machine* m = root; m; m = m->next) + { + fprintf(fp_c, + "struct ufsm_machine * get_%s(void) { return &%s; }\n", + m->name, + id_to_decl(m->id)); } fprintf(fp_h, "enum {\n"); - for (struct event_list *e = evlist; e; e = e->next) { - fprintf (fp_h," %s,\n",e->name); + for (struct event_list* e = evlist; e; e = e->next) + { + fprintf(fp_h, " %s,\n", e->name); } - fprintf(fp_h,"};\n"); + fprintf(fp_h, "};\n"); - for (struct ufsm_machine *m = root; m; m = m->next) { - fprintf(fp_h,"struct ufsm_machine * get_%s(void);\n",m->name); + for (struct ufsm_machine* m = root; m; m = m->next) + { + fprintf(fp_h, "struct ufsm_machine * get_%s(void);\n", m->name); } - fprintf(fp_h,"#endif\n"); + fprintf(fp_h, "#endif\n"); fclose(fp_c); fclose(fp_h); - return true; } diff --git a/src/tools/output.h b/src/tools/output.h index 6b387d3..99721f6 100644 --- a/src/tools/output.h +++ b/src/tools/output.h @@ -13,10 +13,10 @@ #include - -bool ufsm_gen_output(struct ufsm_machine *root, char *output_name, - char *output_prefix, uint32_t verbose, bool strip); - - +bool ufsm_gen_output(struct ufsm_machine* root, + char* output_name, + char* output_prefix, + uint32_t verbose, + bool strip); #endif diff --git a/src/tools/ufsmimport.c b/src/tools/ufsmimport.c index 723c9d7..e7454b5 100644 --- a/src/tools/ufsmimport.c +++ b/src/tools/ufsmimport.c @@ -7,103 +7,105 @@ * */ -#include -#include -#include -#include -#include #include -#include +#include #include #include +#include +#include +#include +#include +#include #include #include "output.h" -static struct ufsm_machine *root_machine; +static struct ufsm_machine* root_machine; static uint32_t v = 0; static bool flag_strip = false; -struct ufsmimport_connection_map { - char *id; - char *target_id; - struct ufsmimport_connection_map *next; +struct ufsmimport_connection_map +{ + char* id; + char* target_id; + struct ufsmimport_connection_map* next; }; -static struct ufsmimport_connection_map *conmap; +static struct ufsmimport_connection_map* conmap; -static xmlChar *get_attr(xmlNode *n, const char* id) +static xmlChar* get_attr(xmlNode* n, const char* id) { xmlAttr* attribute = n->properties; - while(attribute) + while (attribute) { xmlChar* value = xmlNodeListGetString(n->doc, attribute->children, 1); - if (value) { - if (strcmp((const char *)attribute->name, id) == 0) + if (value) + { + if (strcmp((const char*)attribute->name, id) == 0) return value; xmlFree(value); - } + } attribute = attribute->next; } return NULL; } -static bool is_type(xmlNode *n, const char *id) +static bool is_type(xmlNode* n, const char* id) { - xmlChar *type_name = get_attr(n, "type"); + xmlChar* type_name = get_attr(n, "type"); if (type_name == NULL) return false; - bool result = (strcmp((const char *)type_name, id) == 0); + bool result = (strcmp((const char*)type_name, id) == 0); xmlFree(type_name); return result; } - -static struct ufsm_machine * ufsmimport_get_machine(struct ufsm_machine *root, - const char *id) +static struct ufsm_machine* ufsmimport_get_machine(struct ufsm_machine* root, + const char* id) { if (id == NULL) return NULL; - for (struct ufsm_machine *m = root; m; m = m->next) { - if (strcmp((char *) id, (char *) m->id) == 0) + for (struct ufsm_machine* m = root; m; m = m->next) + { + if (strcmp((char*)id, (char*)m->id) == 0) return m; } return NULL; } -static struct ufsm_region * _get_region(struct ufsm_region *r, - const char *id) +static struct ufsm_region* _get_region(struct ufsm_region* r, const char* id) { - struct ufsm_region *result = NULL; - - if (strcmp((char *) r->id, id) == 0) + struct ufsm_region* result = NULL; + + if (strcmp((char*)r->id, id) == 0) return r; if (!r->state) return NULL; - for (struct ufsm_state *s = r->state; s; s = s->next) { + for (struct ufsm_state* s = r->state; s; s = s->next) + { if (s->region) result = _get_region(s->region, id); if (result) return result; } - + return NULL; } - -static struct ufsm_region * ufsmimport_get_region(struct ufsm_machine *root, - const char *id) +static struct ufsm_region* ufsmimport_get_region(struct ufsm_machine* root, + const char* id) { - struct ufsm_region *result = NULL; + struct ufsm_region* result = NULL; if (id == NULL) return NULL; - for (struct ufsm_machine *m = root; m; m = m->next) { + for (struct ufsm_machine* m = root; m; m = m->next) + { if (m->region) result = _get_region(m->region, id); @@ -113,36 +115,37 @@ static struct ufsm_region * ufsmimport_get_region(struct ufsm_machine *root, return NULL; } - -static struct ufsm_state * _get_state(struct ufsm_region *regions, - const char *id) +static struct ufsm_state* _get_state(struct ufsm_region* regions, + const char* id) { - struct ufsm_state *result = NULL; - + struct ufsm_state* result = NULL; - for (struct ufsm_region *r = regions; r; r = r->next) { - if (r->state) { - for (struct ufsm_state *s = r->state; s; s = s->next) { - if (strcmp((char*) s->id, id) == 0) + for (struct ufsm_region* r = regions; r; r = r->next) + { + if (r->state) + { + for (struct ufsm_state* s = r->state; s; s = s->next) + { + if (strcmp((char*)s->id, id) == 0) return s; - result = _get_state(s->region,id); + result = _get_state(s->region, id); if (result) return result; - } } } return NULL; } -static struct ufsm_state * ufsmimport_get_state(struct ufsm_machine *root, - const char *id) +static struct ufsm_state* ufsmimport_get_state(struct ufsm_machine* root, + const char* id) { - struct ufsm_state *result = NULL; + struct ufsm_state* result = NULL; - for (struct ufsm_machine *m = root; m; m = m->next) { + for (struct ufsm_machine* m = root; m; m = m->next) + { if (m->region) result = _get_state(m->region, id); @@ -150,8 +153,10 @@ static struct ufsm_state * ufsmimport_get_state(struct ufsm_machine *root, return result; } - if (result == NULL) { - for (struct ufsmimport_connection_map *cm = conmap; cm; cm = cm->next) { + if (result == NULL) + { + for (struct ufsmimport_connection_map* cm = conmap; cm; cm = cm->next) + { if (strcmp(id, cm->id) == 0) result = ufsmimport_get_state(root, cm->target_id); } @@ -160,113 +165,138 @@ static struct ufsm_state * ufsmimport_get_state(struct ufsm_machine *root, return result; } +static uint32_t parse_region(xmlNode* n, + struct ufsm_machine* m, + struct ufsm_region* r, + bool deep_history); - -static uint32_t parse_region(xmlNode *n, struct ufsm_machine *m, - struct ufsm_region *r, - bool deep_history); - - -static uint32_t parse_state(xmlNode *n, struct ufsm_machine *m, - struct ufsm_region *r, - struct ufsm_state *s, - bool deep_history) +static uint32_t parse_state(xmlNode* n, + struct ufsm_machine* m, + struct ufsm_region* r, + struct ufsm_state* s, + bool deep_history) { - struct ufsm_region *state_region = NULL; - struct ufsm_region *state_region_last = NULL; + struct ufsm_region* state_region = NULL; + struct ufsm_region* state_region_last = NULL; uint32_t region_count = 0; if (get_attr(n, "name")) - s->name = (const char *) get_attr(n, "name"); - - s->id = (const char*) get_attr(n, "id"); + s->name = (const char*)get_attr(n, "name"); + + s->id = (const char*)get_attr(n, "id"); s->entry = NULL; s->exit = NULL; s->parent_region = r; - if (v) printf (" S %-25s %s %i\n",s->name,s->id, deep_history); + if (v) + printf(" S %-25s %s %i\n", s->name, s->id, deep_history); - if (get_attr(n,"submachine")) { - s->submachine = ufsmimport_get_machine(root_machine, - (const char*) get_attr(n,"submachine")); - //if (s->submachine->region) + if (get_attr(n, "submachine")) + { + s->submachine = + ufsmimport_get_machine(root_machine, + (const char*)get_attr(n, "submachine")); + // if (s->submachine->region) // s->submachine->region->parent_state = s; } /* TODO: Should deep history propagate to sub statemachines? */ if (s->submachine) - if (v) printf (" o-o M %-19s %s\n",s->submachine->name, s->submachine->id); - - struct ufsm_entry_exit *entry = NULL; - struct ufsm_entry_exit *entry_last = NULL; - struct ufsm_entry_exit *exits = NULL; - struct ufsm_entry_exit *exits_last = NULL; - struct ufsm_doact *doact = NULL; - struct ufsm_doact *doact_last = NULL; + if (v) + printf(" o-o M %-19s %s\n", + s->submachine->name, + s->submachine->id); + + struct ufsm_entry_exit* entry = NULL; + struct ufsm_entry_exit* entry_last = NULL; + struct ufsm_entry_exit* exits = NULL; + struct ufsm_entry_exit* exits_last = NULL; + struct ufsm_doact* doact = NULL; + struct ufsm_doact* doact_last = NULL; /* Parse regions */ - for (xmlNode *r_sub = n->children; r_sub; r_sub = r_sub->next) { - if (is_type(r_sub, "uml:Region")) { - state_region = malloc (sizeof(struct ufsm_region)); + for (xmlNode* r_sub = n->children; r_sub; r_sub = r_sub->next) + { + if (is_type(r_sub, "uml:Region")) + { + state_region = malloc(sizeof(struct ufsm_region)); bzero(state_region, sizeof(struct ufsm_region)); state_region->parent_state = s; state_region->next = state_region_last; state_region->has_history = deep_history; parse_region(r_sub, m, state_region, deep_history); - - if (state_region->name == NULL) { - state_region->name = malloc(strlen(s->name)+32); - sprintf((char *)state_region->name,"%sregion%i", - s->name,region_count++); + + if (state_region->name == NULL) + { + state_region->name = malloc(strlen(s->name) + 32); + sprintf((char*)state_region->name, + "%sregion%i", + s->name, + region_count++); } state_region_last = state_region; - } else if(strcmp((char *)r_sub->name, "entry") == 0) { + } + else if (strcmp((char*)r_sub->name, "entry") == 0) + { entry = malloc(sizeof(struct ufsm_entry_exit)); bzero(entry, sizeof(struct ufsm_entry_exit)); - entry->name = (const char*) get_attr(r_sub,"name"); - entry->id = (const char *) get_attr(r_sub, "id"); + entry->name = (const char*)get_attr(r_sub, "name"); + entry->id = (const char*)get_attr(r_sub, "id"); entry->next = entry_last; entry_last = entry; - } else if(strcmp((char *)r_sub->name, "exit") == 0) { + } + else if (strcmp((char*)r_sub->name, "exit") == 0) + { exits = malloc(sizeof(struct ufsm_entry_exit)); bzero(exits, sizeof(struct ufsm_entry_exit)); - exits->name = (const char*) get_attr(r_sub,"name"); - exits->id = (const char *) get_attr(r_sub, "id"); + exits->name = (const char*)get_attr(r_sub, "name"); + exits->id = (const char*)get_attr(r_sub, "id"); exits->next = exits_last; exits_last = exits; - } else if (strcmp((char *) r_sub->name, "doActivity") == 0) { + } + else if (strcmp((char*)r_sub->name, "doActivity") == 0) + { doact = malloc(sizeof(struct ufsm_doact)); bzero(doact, sizeof(struct ufsm_doact)); - doact->name = (const char*) get_attr(r_sub,"name"); - doact->id = (const char *) get_attr(r_sub, "id"); + doact->name = (const char*)get_attr(r_sub, "name"); + doact->id = (const char*)get_attr(r_sub, "id"); doact->next = doact_last; doact_last = doact; - - } else if(strcmp((char *) r_sub->name, "text") == 0) { + } + else if (strcmp((char*)r_sub->name, "text") == 0) + { /* Do nothing */ - } else if(strcmp((char *) r_sub->name, "connection") == 0) { - struct ufsmimport_connection_map * cm = NULL; + } + else if (strcmp((char*)r_sub->name, "connection") == 0) + { + struct ufsmimport_connection_map* cm = NULL; - if (conmap == NULL) { + if (conmap == NULL) + { conmap = malloc(sizeof(struct ufsmimport_connection_map)); bzero(conmap, sizeof(struct ufsmimport_connection_map)); cm = conmap; - } else { + } + else + { conmap->next = malloc(sizeof(struct ufsmimport_connection_map)); bzero(conmap->next, sizeof(struct ufsmimport_connection_map)); cm = conmap->next; } - cm->id = (char *) get_attr(r_sub, "id"); - cm->target_id = (char *) get_attr (r_sub->children->next, "idref"); + cm->id = (char*)get_attr(r_sub, "id"); + cm->target_id = (char*)get_attr(r_sub->children->next, "idref"); if (v) - printf (" Created connection reference %s -> %s\n", cm->id, cm->target_id); - - } else { - printf ("Error: Unknown element in state definition: '%s'\n", r_sub->name); + printf(" Created connection reference %s -> %s\n", + cm->id, + cm->target_id); + } + else + { + printf("Error: Unknown element in state definition: '%s'\n", + r_sub->name); return UFSM_ERROR; } - } s->entry = entry_last; s->doact = doact_last; @@ -276,78 +306,86 @@ static uint32_t parse_state(xmlNode *n, struct ufsm_machine *m, return UFSM_OK; } - - -static struct ufsm_region * _state_belongs_to(struct ufsm_region *region, - struct ufsm_state *state) +static struct ufsm_region* _state_belongs_to(struct ufsm_region* region, + struct ufsm_state* state) { - struct ufsm_region *result = NULL; + struct ufsm_region* result = NULL; - for (struct ufsm_region *r = region; r; r = r->next) { - for (struct ufsm_state *s = r->state; s; s = s->next) { + for (struct ufsm_region* r = region; r; r = r->next) + { + for (struct ufsm_state* s = r->state; s; s = s->next) + { if (s == state) return r; - if (s->region) { + if (s->region) + { result = _state_belongs_to(s->region, state); if (result) return result; } - } } - + return NULL; } -static struct ufsm_region * state_belongs_to(struct ufsm_machine *machine, - struct ufsm_state *state) +static struct ufsm_region* state_belongs_to(struct ufsm_machine* machine, + struct ufsm_state* state) { - struct ufsm_region *result = NULL; + struct ufsm_region* result = NULL; - for (struct ufsm_machine *m = machine; m; m = m->next) { + for (struct ufsm_machine* m = machine; m; m = m->next) + { result = _state_belongs_to(m->region, state); if (result) return result; - } return NULL; } -static uint32_t parse_transition(xmlNode *n, struct ufsm_machine *m, - struct ufsm_region *r) +static uint32_t parse_transition(xmlNode* n, + struct ufsm_machine* m, + struct ufsm_region* r) { - struct ufsm_transition *t = NULL; - + struct ufsm_transition* t = NULL; + if (n->children == NULL) return UFSM_ERROR; - for (xmlNode *s_node = n->children; s_node; s_node = s_node->next) { - - if (is_type(s_node, "uml:State")) { - for (xmlNode *r_node = s_node->children; r_node; r_node = r_node->next) { - struct ufsm_region *region = ufsmimport_get_region(m, - (const char*) get_attr(r_node,"id")); + for (xmlNode* s_node = n->children; s_node; s_node = s_node->next) + { + if (is_type(s_node, "uml:State")) + { + for (xmlNode* r_node = s_node->children; r_node; + r_node = r_node->next) + { + struct ufsm_region* region = + ufsmimport_get_region(m, + (const char*)get_attr(r_node, "id")); if (region) parse_transition(r_node, m, region); } } - if (is_type(s_node, "uml:Transition")) { + if (is_type(s_node, "uml:Transition")) + { t = malloc(sizeof(struct ufsm_transition)); bzero(t, sizeof(struct ufsm_transition)); - t->id = (const char*) get_attr(s_node, "id"); + t->id = (const char*)get_attr(s_node, "id"); t->next = NULL; - struct ufsm_state *src = ufsmimport_get_state( - m, (const char *) get_attr(s_node, "source")); + struct ufsm_state* src = + ufsmimport_get_state(m, + (const char*)get_attr(s_node, "source")); - struct ufsm_state *dest = ufsmimport_get_state( - m, (const char *) get_attr(s_node, "target")); + struct ufsm_state* dest = + ufsmimport_get_state(m, + (const char*)get_attr(s_node, "target")); t->source = src; t->dest = dest; - char *t_kind = (char *) get_attr(s_node, "kind"); + char* t_kind = (char*)get_attr(s_node, "kind"); if (strcmp(t_kind, "internal") == 0) t->kind = UFSM_TRANSITION_INTERNAL; @@ -356,123 +394,171 @@ static uint32_t parse_transition(xmlNode *n, struct ufsm_machine *m, else if (strcmp(t_kind, "local") == 0) t->kind = UFSM_TRANSITION_LOCAL; - struct ufsm_action *action = NULL; - struct ufsm_action *action_last = NULL; - struct ufsm_guard *guard = NULL; - struct ufsm_guard *guard_last = NULL; - - for (xmlNode *trigger = s_node->children; trigger; trigger = trigger->next) { - if (is_type(trigger, "uml:Trigger")) { - t->trigger_name = (const char*) get_attr(trigger, "name"); - } else if (is_type(trigger, "uml:Activity") || - is_type(trigger, "uml:OpaqueBehavior")) { - action = malloc (sizeof (struct ufsm_action)); + struct ufsm_action* action = NULL; + struct ufsm_action* action_last = NULL; + struct ufsm_guard* guard = NULL; + struct ufsm_guard* guard_last = NULL; + + for (xmlNode* trigger = s_node->children; trigger; + trigger = trigger->next) + { + if (is_type(trigger, "uml:Trigger")) + { + t->trigger_name = (const char*)get_attr(trigger, "name"); + } + else if (is_type(trigger, "uml:Activity") || + is_type(trigger, "uml:OpaqueBehavior")) + { + action = malloc(sizeof(struct ufsm_action)); bzero(action, sizeof(struct ufsm_action)); - action->name = (const char*) get_attr(trigger, "name"); - action->id = (const char *) get_attr(trigger, "id"); + action->name = (const char*)get_attr(trigger, "name"); + action->id = (const char*)get_attr(trigger, "id"); action->next = NULL; if (action_last) action_last->next = action; action_last = action; - if (v) printf (" /%s ", action->name); - } else if (is_type(trigger, "uml:Constraint")) { + if (v) + printf(" /%s ", action->name); + } + else if (is_type(trigger, "uml:Constraint")) + { guard = malloc(sizeof(struct ufsm_guard)); bzero(guard, sizeof(struct ufsm_guard)); - guard->name = (const char*) get_attr(trigger, "specification"); - guard->id = (const char*) get_attr(trigger, "id"); + guard->name = (const char*)get_attr(trigger, + "specification"); + guard->id = (const char*)get_attr(trigger, "id"); guard->next = guard_last; guard_last = guard; - if (v) printf (" [%s] ", guard->name); - } else if (strcmp((char *)trigger->name, "text") == 0) { + if (v) + printf(" [%s] ", guard->name); + } + else if (strcmp((char*)trigger->name, "text") == 0) + { /* Ignore */ - } else if (strcmp((char *)trigger->name, "ownedMember") == 0) { + } + else if (strcmp((char*)trigger->name, "ownedMember") == 0) + { /* Ignore */ - } else if (strcmp((char *)trigger->name, "trigger") == 0) { + } + else if (strcmp((char*)trigger->name, "trigger") == 0) + { /* Ignore */ - } else { - printf ("Unhandeled type '%s' in transition\n",trigger->name); + } + else + { + printf("Unhandeled type '%s' in transition\n", + trigger->name); return UFSM_ERROR; } - } t->action = action_last; t->guard = guard_last; - - struct ufsm_region *trans_region = state_belongs_to(m, src); - if (trans_region->transition == NULL) { + struct ufsm_region* trans_region = state_belongs_to(m, src); + + if (trans_region->transition == NULL) + { trans_region->transition = t; - } else { - struct ufsm_transition *tail = trans_region->transition; - do { - if (tail->next == NULL) { + } + else + { + struct ufsm_transition* tail = trans_region->transition; + do + { + if (tail->next == NULL) + { tail->next = t; break; } - tail = tail->next; - } while(tail); + tail = tail->next; + } while (tail); } - if (v) printf (" src belongs to %s\n", state_belongs_to(m, src)->name); - if (v) printf (" T %-10s -> %-10s %s\n", src->name, - dest->name, - t->id); + if (v) + printf(" src belongs to %s\n", + state_belongs_to(m, src)->name); + if (v) + printf(" T %-10s -> %-10s %s\n", src->name, dest->name, t->id); } } return UFSM_OK; } - -static uint32_t parse_region(xmlNode *n, struct ufsm_machine *m, - struct ufsm_region *r, - bool deep_history) +static uint32_t parse_region(xmlNode* n, + struct ufsm_machine* m, + struct ufsm_region* r, + bool deep_history) { bool has_deep_history = deep_history; uint32_t err = UFSM_OK; - struct ufsm_state *s = NULL; - struct ufsm_state *s_last = NULL; + struct ufsm_state* s = NULL; + struct ufsm_state* s_last = NULL; - r->name = (const char *) get_attr(n, "name"); - r->id = (const char*) get_attr(n, "id"); + r->name = (const char*)get_attr(n, "name"); + r->id = (const char*)get_attr(n, "id"); r->has_history = has_deep_history; - if (v) printf (" R %-25s %s %i\n", r->name, r->id, deep_history); - for (xmlNode *s_node = n->children; s_node; s_node = s_node->next) { - if (is_type(s_node, "uml:Pseudostate")) { - s = malloc (sizeof(struct ufsm_state)); + if (v) + printf(" R %-25s %s %i\n", r->name, r->id, deep_history); + for (xmlNode* s_node = n->children; s_node; s_node = s_node->next) + { + if (is_type(s_node, "uml:Pseudostate")) + { + s = malloc(sizeof(struct ufsm_state)); bzero(s, sizeof(struct ufsm_state)); s->name = NULL; - char *node_kind = (char*) get_attr(s_node, "kind"); + char* node_kind = (char*)get_attr(s_node, "kind"); - if (strcmp(node_kind, "initial") == 0) { + if (strcmp(node_kind, "initial") == 0) + { s->name = malloc(64); - sprintf((char * restrict) s->name,"Init"); + sprintf((char* restrict)s->name, "Init"); s->kind = UFSM_STATE_INIT; - } else if (strcmp(node_kind, "shallowHistory") == 0) { + } + else if (strcmp(node_kind, "shallowHistory") == 0) + { r->has_history = true; s->kind = UFSM_STATE_SHALLOW_HISTORY; - } else if (strcmp(node_kind, "deepHistory") == 0) { + } + else if (strcmp(node_kind, "deepHistory") == 0) + { r->has_history = true; has_deep_history = true; s->kind = UFSM_STATE_DEEP_HISTORY; - } else if (strcmp(node_kind, "exitPoint") == 0) { + } + else if (strcmp(node_kind, "exitPoint") == 0) + { s->kind = UFSM_STATE_EXIT_POINT; - } else if (strcmp(node_kind, "entryPoint") == 0) { + } + else if (strcmp(node_kind, "entryPoint") == 0) + { s->kind = UFSM_STATE_ENTRY_POINT; - } else if (strcmp(node_kind, "join") == 0) { + } + else if (strcmp(node_kind, "join") == 0) + { s->kind = UFSM_STATE_JOIN; - } else if (strcmp(node_kind, "fork") == 0) { + } + else if (strcmp(node_kind, "fork") == 0) + { s->kind = UFSM_STATE_FORK; - } else if (strcmp(node_kind, "choice") == 0) { + } + else if (strcmp(node_kind, "choice") == 0) + { s->kind = UFSM_STATE_CHOICE; - } else if (strcmp(node_kind, "junction") == 0) { + } + else if (strcmp(node_kind, "junction") == 0) + { s->kind = UFSM_STATE_JUNCTION; - } else if (strcmp(node_kind, "terminate") == 0) { + } + else if (strcmp(node_kind, "terminate") == 0) + { s->kind = UFSM_STATE_TERMINATE; - } else { - printf ("Warning: unknown pseudostate '%s'\n", - get_attr(s_node,"kind")); + } + else + { + printf("Warning: unknown pseudostate '%s'\n", + get_attr(s_node, "kind")); } s->next = s_last; @@ -481,23 +567,27 @@ static uint32_t parse_region(xmlNode *n, struct ufsm_machine *m, if (err != UFSM_OK) return err; - } else if (is_type(s_node, "uml:FinalState")) { - s = malloc (sizeof(struct ufsm_state)); + } + else if (is_type(s_node, "uml:FinalState")) + { + s = malloc(sizeof(struct ufsm_state)); bzero(s, sizeof(struct ufsm_state)); s->kind = UFSM_STATE_FINAL; s->name = malloc(64); - sprintf((char * restrict) s->name, "Final"); + sprintf((char* restrict)s->name, "Final"); s->next = s_last; s_last = s; err = parse_state(s_node, m, r, s, false); if (err != UFSM_OK) return err; - } + } } - for (xmlNode *s_node = n->children; s_node; s_node = s_node->next) { - if (is_type(s_node, "uml:State")) { - s = malloc (sizeof(struct ufsm_state)); + for (xmlNode* s_node = n->children; s_node; s_node = s_node->next) + { + if (is_type(s_node, "uml:State")) + { + s = malloc(sizeof(struct ufsm_state)); bzero(s, sizeof(struct ufsm_state)); s->kind = UFSM_STATE_SIMPLE; s->next = s_last; @@ -506,88 +596,101 @@ static uint32_t parse_region(xmlNode *n, struct ufsm_machine *m, if (err != UFSM_OK) return err; } - - } - + r->state = s_last; - + return UFSM_OK; } -static struct ufsm_machine * ufsmimport_pass1 (xmlNode *node) +static struct ufsm_machine* ufsmimport_pass1(xmlNode* node) { - xmlNode *n = NULL; - struct ufsm_machine *m = NULL; - struct ufsm_machine *m_last = NULL; - struct ufsm_machine *m_first = NULL; - if (v) printf ("o Pass 1, analysing state machines...\n"); - for (n = node; n; n = n->next) { - if (is_type(n, "uml:StateMachine")) { + xmlNode* n = NULL; + struct ufsm_machine* m = NULL; + struct ufsm_machine* m_last = NULL; + struct ufsm_machine* m_first = NULL; + if (v) + printf("o Pass 1, analysing state machines...\n"); + for (n = node; n; n = n->next) + { + if (is_type(n, "uml:StateMachine")) + { m = malloc(sizeof(struct ufsm_machine)); - bzero (m, sizeof(struct ufsm_machine)); + bzero(m, sizeof(struct ufsm_machine)); if (!m_first) m_first = m; if (m_last) m_last->next = m; - //m->next = m_last; - m->id = (const char*) get_attr(n, "id"); - m->name = (const char*) get_attr(n, "name"); + // m->next = m_last; + m->id = (const char*)get_attr(n, "id"); + m->name = (const char*)get_attr(n, "name"); m_last = m; - if (v) printf (" M %-25s %s\n",m->name,m->id); + if (v) + printf(" M %-25s %s\n", m->name, m->id); } } return m_first; } -static uint32_t ufsmimport_pass2 (xmlNode *node, struct ufsm_machine *machines) +static uint32_t ufsmimport_pass2(xmlNode* node, struct ufsm_machine* machines) { - struct ufsm_region *r = NULL; + struct ufsm_region* r = NULL; uint32_t region_count = 0; uint32_t err = UFSM_OK; - if (v) printf ("o Pass 2, analysing regions, states and sub machines...\n"); - - for (xmlNode *m = node; m; m = m->next) { + if (v) + printf("o Pass 2, analysing regions, states and sub machines...\n"); + + for (xmlNode* m = node; m; m = m->next) + { region_count = 0; - for (xmlNode *n = m->children; n; n = n->next) { - if (is_type(n, "uml:Region")) { - r = malloc (sizeof(struct ufsm_region)); - bzero (r, sizeof(struct ufsm_region)); + for (xmlNode* n = m->children; n; n = n->next) + { + if (is_type(n, "uml:Region")) + { + r = malloc(sizeof(struct ufsm_region)); + bzero(r, sizeof(struct ufsm_region)); r->next = NULL; - struct ufsm_machine *mach = ufsmimport_get_machine(machines, - (const char*) get_attr(m, "id")); + struct ufsm_machine* mach = + ufsmimport_get_machine(machines, + (const char*)get_attr(m, "id")); mach->region = r; r->parent_state = NULL; err = parse_region(n, mach, r, false); if (err != UFSM_OK) return err; - if (r->name == NULL) { - r->name = malloc(strlen(mach->name)+16); - sprintf ((char *) r->name,"%sregion%i", - mach->name,region_count++); + if (r->name == NULL) + { + r->name = malloc(strlen(mach->name) + 16); + sprintf((char*)r->name, + "%sregion%i", + mach->name, + region_count++); } } } + } - } - return UFSM_OK; } - -static uint32_t ufsmimport_pass3 (xmlNode *node, struct ufsm_machine *machines) +static uint32_t ufsmimport_pass3(xmlNode* node, struct ufsm_machine* machines) { - if (v) printf ("o Pass 3, analysing transitions...\n"); - - for (xmlNode *m = node; m; m = m->next) { - for (xmlNode *n = m->children; n; n = n->next) { - if (is_type(n, "uml:Region")) { - struct ufsm_region *region = ufsmimport_get_region(machines, - (const char*) get_attr(n,"id")); - + if (v) + printf("o Pass 3, analysing transitions...\n"); + + for (xmlNode* m = node; m; m = m->next) + { + for (xmlNode* n = m->children; n; n = n->next) + { + if (is_type(n, "uml:Region")) + { + struct ufsm_region* region = + ufsmimport_get_region(machines, + (const char*)get_attr(n, "id")); + parse_transition(n, machines, region); } } @@ -596,119 +699,130 @@ static uint32_t ufsmimport_pass3 (xmlNode *node, struct ufsm_machine *machines) return UFSM_OK; } - -static xmlNode * get_first_statemachine(xmlNode *node) +static xmlNode* get_first_statemachine(xmlNode* node) { - xmlNode *n = NULL; - xmlNode *result = NULL; + xmlNode* n = NULL; + xmlNode* result = NULL; - for (n = node; n; n = n->next) { - if (is_type(n, "uml:StateMachine")) { + for (n = node; n; n = n->next) + { + if (is_type(n, "uml:StateMachine")) + { return n; } if (n->children) result = get_first_statemachine(n->children); } - return result; + return result; } -int main(int argc, char **argv) +int main(int argc, char** argv) { - extern char *optarg; + extern char* optarg; extern int optind, opterr, optopt; char c; uint32_t err = UFSM_OK; - char *output_prefix = NULL; - char *output_name = NULL; + char* output_prefix = NULL; + char* output_name = NULL; xmlDocPtr doc; - xmlNode *root_element; - xmlNode *root_machine_element; - - if (argc < 3) { - printf ("Usage: ufsmimport [options]\n"); - printf (" -v - Verbose\n"); - printf (" -c prefix/ - Output prefix\n"); - printf (" -s - Strip output\n"); - + xmlNode* root_element; + xmlNode* root_machine_element; + + if (argc < 3) + { + printf("Usage: ufsmimport [options]\n"); + printf(" -v - Verbose\n"); + printf(" -c prefix/ - Output prefix\n"); + printf(" -s - Strip output\n"); + exit(0); } doc = xmlReadFile(argv[1], NULL, 0); output_name = argv[2]; - while ((c = getopt(argc-2, argv+2, "svc:")) != -1) { - switch (c) { + while ((c = getopt(argc - 2, argv + 2, "svc:")) != -1) + { + switch (c) + { case 'c': output_prefix = optarg; - break; + break; case 'v': v++; - break; + break; case 's': flag_strip = true; - break; + break; default: abort(); } } - - if (doc == NULL) { - printf ("Could not read file\n"); + + if (doc == NULL) + { + printf("Could not read file\n"); return -1; } + if (v) + printf("o Reading...\n"); - if (v) printf ("o Reading...\n"); - root_element = xmlDocGetRootElement(doc); - + /* XMI identifier */ - if (strcmp((char *) root_element->name, "XMI") != 0) { - printf ("Error: Not an XMI file\n"); + if (strcmp((char*)root_element->name, "XMI") != 0) + { + printf("Error: Not an XMI file\n"); return -1; } - if (v) printf (" XMI v%s\n",get_attr(root_element,"version")); - + if (v) + printf(" XMI v%s\n", get_attr(root_element, "version")); + /* Exporter info */ root_element = root_element->children; root_element = root_element->next; - if (v) printf (" Exporter: %s, exporter version: %s\n", - get_attr(root_element, "exporter"), - get_attr(root_element, "exporterVersion")); - + if (v) + printf(" Exporter: %s, exporter version: %s\n", + get_attr(root_element, "exporter"), + get_attr(root_element, "exporterVersion")); + root_machine_element = get_first_statemachine(root_element); - root_machine = ufsmimport_pass1 (root_machine_element); - - if (!root_machine) { - printf ("Error: Pass 1 failed, found no root machine\n"); + root_machine = ufsmimport_pass1(root_machine_element); + + if (!root_machine) + { + printf("Error: Pass 1 failed, found no root machine\n"); return UFSM_ERROR; } err = ufsmimport_pass2(root_machine_element, root_machine); - if (err != UFSM_OK) { - printf ("Error: pass2 failed with error code '%i'\n",err); + if (err != UFSM_OK) + { + printf("Error: pass2 failed with error code '%i'\n", err); return err; } err = ufsmimport_pass3(root_machine_element, root_machine); - - if (err != UFSM_OK) { - printf ("Error: pass3 failed with error code '%i'\n",err); + if (err != UFSM_OK) + { + printf("Error: pass3 failed with error code '%i'\n", err); return err; } - - if (output_prefix == NULL) { + if (output_prefix == NULL) + { output_prefix = malloc(2); *output_prefix = 0; } - - if (v) printf ("Output prefix: %s\n", output_prefix); - ufsm_gen_output(root_machine, output_name, output_prefix,v,flag_strip); + + if (v) + printf("Output prefix: %s\n", output_prefix); + ufsm_gen_output(root_machine, output_name, output_prefix, v, flag_strip); return err; } diff --git a/src/ufsm.c b/src/ufsm.c index 88ea7a4..787ff79 100644 --- a/src/ufsm.c +++ b/src/ufsm.c @@ -9,15 +9,13 @@ #include "ufsm.h" -const char *ufsm_transition_kinds[] = -{ +const char* ufsm_transition_kinds[] = { "External", "Internal", "Local", }; -const char *ufsm_state_kinds[] = -{ +const char* ufsm_state_kinds[] = { "Simple", "Init", "Final", @@ -32,8 +30,7 @@ const char *ufsm_state_kinds[] = "Terminate", }; -const char *ufsm_errors[] = -{ +const char* ufsm_errors[] = { "OK", "Error", "No init region found", @@ -47,24 +44,25 @@ const char *ufsm_errors[] = "Machine has terminated", }; -inline static bool ufsm_state_is(struct ufsm_state *s, uint32_t kind) +inline static bool ufsm_state_is(struct ufsm_state* s, uint32_t kind) { return s ? (s->kind == kind) : false; } -static ufsm_status_t ufsm_make_transition(struct ufsm_machine *m, - struct ufsm_transition *t, - struct ufsm_region *r); +static ufsm_status_t ufsm_make_transition(struct ufsm_machine* m, + struct ufsm_transition* t, + struct ufsm_region* r); -static ufsm_status_t ufsm_process_completion(struct ufsm_machine *m, - struct ufsm_state *s) +static ufsm_status_t ufsm_process_completion(struct ufsm_machine* m, + struct ufsm_state* s) { ufsm_status_t err = UFSM_OK; - for (struct ufsm_transition *t = s->parent_region->transition; - t; t = t->next) + for (struct ufsm_transition* t = s->parent_region->transition; t; + t = t->next) { - if (t->source == s && t->trigger == -1) { + if (t->source == s && t->trigger == -1) + { err = ufsm_make_transition(m, t, s->parent_region); break; } @@ -73,27 +71,27 @@ static ufsm_status_t ufsm_process_completion(struct ufsm_machine *m, return err; } -static ufsm_status_t ufsm_completion_handler(struct ufsm_machine *m, - struct ufsm_state *s) +static ufsm_status_t ufsm_completion_handler(struct ufsm_machine* m, + struct ufsm_state* s) { ufsm_status_t err = UFSM_OK; - for (struct ufsm_transition *t = s->parent_region->transition; - t; t = t->next) + for (struct ufsm_transition* t = s->parent_region->transition; t; + t = t->next) { - if (t->source == s && t->trigger == -1) { + if (t->source == s && t->trigger == -1) + { err = ufsm_stack_push(&m->completion_stack, s); if (err == UFSM_OK) err = ufsm_queue_put(&m->queue, UFSM_COMPLETION_EVENT); - } } return err; } -static ufsm_status_t ufsm_enter_state(struct ufsm_machine *m, - struct ufsm_state *s) +static ufsm_status_t ufsm_enter_state(struct ufsm_machine* m, + struct ufsm_state* s) { ufsm_status_t err = UFSM_OK; @@ -102,82 +100,84 @@ static ufsm_status_t ufsm_enter_state(struct ufsm_machine *m, if (m->debug_enter_state) m->debug_enter_state(s); - for (struct ufsm_entry_exit *e = s->entry; e; e = e->next) + for (struct ufsm_entry_exit* e = s->entry; e; e = e->next) e->f(); if (s->kind == UFSM_STATE_SIMPLE) state_completed = true; - for (struct ufsm_doact *d = s->doact; d; d = d->next) + for (struct ufsm_doact* d = s->doact; d; d = d->next) { state_completed = false; - d->f_start(m,s,&ufsm_completion_handler); + d->f_start(m, s, &ufsm_completion_handler); } - if (state_completed) - { - for (struct ufsm_region *r = s->region; r; r = r->next) + if (state_completed) + { + for (struct ufsm_region* r = s->region; r; r = r->next) { - if (r->current) { + if (r->current) + { if (r->current->kind != UFSM_STATE_FINAL) state_completed = false; - } else { + } + else + { state_completed = false; } } - + if (state_completed) ufsm_completion_handler(m, s); - } return err; } -inline static void ufsm_leave_state(struct ufsm_machine *m, - struct ufsm_state *s) +inline static void ufsm_leave_state(struct ufsm_machine* m, + struct ufsm_state* s) { if (m->debug_exit_state) m->debug_exit_state(s); - for (struct ufsm_doact *d = s->doact; d; d = d->next) + for (struct ufsm_doact* d = s->doact; d; d = d->next) d->f_stop(); - for (struct ufsm_entry_exit *e = s->exit; e; e = e->next) + for (struct ufsm_entry_exit* e = s->exit; e; e = e->next) e->f(); } - -inline static void ufsm_set_current_state(struct ufsm_region *r, - struct ufsm_state *s) +inline static void ufsm_set_current_state(struct ufsm_region* r, + struct ufsm_state* s) { if (r) r->current = s; } -inline static struct ufsm_transition *ufsm_find_transition(struct ufsm_region *region, - struct ufsm_state *source, - struct ufsm_state *dest) +inline static struct ufsm_transition* ufsm_find_transition( + struct ufsm_region* region, + struct ufsm_state* source, + struct ufsm_state* dest) { - for (struct ufsm_transition *t = region->transition; t; t = t->next) + for (struct ufsm_transition* t = region->transition; t; t = t->next) { - if ( (t->source == source && dest == NULL) || - (t->source == source && t->dest == dest) || - (t->dest == dest && source == NULL)) + if ((t->source == source && dest == NULL) || + (t->source == source && t->dest == dest) || + (t->dest == dest && source == NULL)) { - return t; + return t; } } return NULL; } -inline static bool ufsm_test_guards(struct ufsm_machine *m, - struct ufsm_transition *t) +inline static bool ufsm_test_guards(struct ufsm_machine* m, + struct ufsm_transition* t) { bool result = true; - for (struct ufsm_guard *g = t->guard; g; g = g->next) + for (struct ufsm_guard* g = t->guard; g; g = g->next) { bool guard_result = g->f(); @@ -191,10 +191,10 @@ inline static bool ufsm_test_guards(struct ufsm_machine *m, return result; } -inline static void ufsm_execute_actions(struct ufsm_machine *m, - struct ufsm_transition *t) +inline static void ufsm_execute_actions(struct ufsm_machine* m, + struct ufsm_transition* t) { - for (struct ufsm_action *a = t->action; a; a = a->next) + for (struct ufsm_action* a = t->action; a; a = a->next) { if (m->debug_action) m->debug_action(a); @@ -203,39 +203,38 @@ inline static void ufsm_execute_actions(struct ufsm_machine *m, } } -inline static void ufsm_update_history(struct ufsm_state *s) +inline static void ufsm_update_history(struct ufsm_state* s) { - if (s->parent_region) + if (s->parent_region) if (s->parent_region->has_history) s->parent_region->history = s; } -static struct ufsm_transition *ufsm_get_first_state (struct ufsm_region *region) +static struct ufsm_transition* ufsm_get_first_state(struct ufsm_region* region) { - - for (struct ufsm_state *s = region->state; s; s = s->next) + for (struct ufsm_state* s = region->state; s; s = s->next) { - if (ufsm_state_is(s, UFSM_STATE_INIT) || + if (ufsm_state_is(s, UFSM_STATE_INIT) || ufsm_state_is(s, UFSM_STATE_SHALLOW_HISTORY) || - ufsm_state_is(s, UFSM_STATE_DEEP_HISTORY)) + ufsm_state_is(s, UFSM_STATE_DEEP_HISTORY)) { - return ufsm_find_transition (region, s, NULL); + return ufsm_find_transition(region, s, NULL); } } return NULL; } -static ufsm_status_t ufsm_enter_parent_states(struct ufsm_machine *m, - struct ufsm_region *ancestor, - struct ufsm_region *r) +static ufsm_status_t ufsm_enter_parent_states(struct ufsm_machine* m, + struct ufsm_region* ancestor, + struct ufsm_region* r) { ufsm_status_t err = UFSM_OK; uint32_t c = 0; - struct ufsm_state *ps = r->parent_state; - struct ufsm_region *pr = NULL; - + struct ufsm_state* ps = r->parent_state; + struct ufsm_region* pr = NULL; + if (!ancestor) return UFSM_OK; @@ -258,7 +257,7 @@ static ufsm_status_t ufsm_enter_parent_states(struct ufsm_machine *m, for (uint32_t i = 0; i < c; i++) { - err = ufsm_stack_pop(&m->stack, (void **) &pr); + err = ufsm_stack_pop(&m->stack, (void**)&pr); if (err != UFSM_OK) break; @@ -267,37 +266,38 @@ static ufsm_status_t ufsm_enter_parent_states(struct ufsm_machine *m, m->debug_enter_region(pr); ps = pr->parent_state; - - if (ps) + + if (ps) { - ufsm_set_current_state (ps->parent_region, ps); + ufsm_set_current_state(ps->parent_region, ps); if (pr != ancestor) - ufsm_enter_state(m, ps); + ufsm_enter_state(m, ps); } } - + return err; } -static struct ufsm_region * ufsm_least_common_ancestor(struct ufsm_region *r1, - struct ufsm_region *r2) +static struct ufsm_region* ufsm_least_common_ancestor(struct ufsm_region* r1, + struct ufsm_region* r2) { - struct ufsm_region *lca = r1; - struct ufsm_region *lca2 = r2; + struct ufsm_region* lca = r1; + struct ufsm_region* lca2 = r2; - while (lca) + while (lca) { lca2 = r2; - do { - if (lca == lca2) + do + { + if (lca == lca2) return lca; - + if (lca2->parent_state == NULL) break; - + lca2 = lca2->parent_state->parent_region; - } while(lca2); + } while (lca2); if (lca->parent_state == NULL) break; @@ -308,62 +308,62 @@ static struct ufsm_region * ufsm_least_common_ancestor(struct ufsm_region *r1, return NULL; } -static ufsm_status_t ufsm_leave_parent_states(struct ufsm_machine *m, - struct ufsm_state *src, - struct ufsm_state *dest, - struct ufsm_region **lca, - struct ufsm_region **act) +static ufsm_status_t ufsm_leave_parent_states(struct ufsm_machine* m, + struct ufsm_state* src, + struct ufsm_state* dest, + struct ufsm_region** lca, + struct ufsm_region** act) { - struct ufsm_region *rl = NULL; - struct ufsm_region *ancestor = NULL; + struct ufsm_region* rl = NULL; + struct ufsm_region* ancestor = NULL; bool states_to_leave = true; - if ( !((src->parent_region != dest->parent_region) && - dest->kind != UFSM_STATE_JOIN)) + if (!((src->parent_region != dest->parent_region) && + dest->kind != UFSM_STATE_JOIN)) return UFSM_OK; *act = dest->parent_region; rl = src->parent_region; ancestor = ufsm_least_common_ancestor(src->parent_region, - dest->parent_region); + dest->parent_region); *lca = ancestor; if (!ancestor) return UFSM_ERROR_LCA_NOT_FOUND; - while (states_to_leave) + while (states_to_leave) { if (ancestor == rl) break; if (m->debug_leave_region) m->debug_leave_region(rl); - - if (rl->parent_state) + + if (rl->parent_state) { - ufsm_leave_state(m, rl->parent_state); + ufsm_leave_state(m, rl->parent_state); rl->current = NULL; - if (rl->parent_state->parent_region) + if (rl->parent_state->parent_region) { rl = rl->parent_state->parent_region; states_to_leave = true; } - - } else { + } + else + { states_to_leave = false; } - } return UFSM_OK; } - -static ufsm_status_t ufsm_leave_nested_states(struct ufsm_machine *m, - struct ufsm_state *s) + +static ufsm_status_t ufsm_leave_nested_states(struct ufsm_machine* m, + struct ufsm_state* s) { - struct ufsm_region *r = NULL; + struct ufsm_region* r = NULL; uint32_t c = 0; ufsm_status_t err = UFSM_OK; @@ -372,7 +372,7 @@ static ufsm_status_t ufsm_leave_nested_states(struct ufsm_machine *m, r = s->region; - do + do { c++; err = ufsm_stack_push(&m->stack, r); @@ -383,14 +383,14 @@ static ufsm_status_t ufsm_leave_nested_states(struct ufsm_machine *m, r = r->current->region; } while (r); - for (uint32_t i = 0; i < c; i++) - { - err = ufsm_stack_pop(&m->stack, (void **) &r); + for (uint32_t i = 0; i < c; i++) + { + err = ufsm_stack_pop(&m->stack, (void**)&r); if (err != UFSM_OK) break; - if (r->current) + if (r->current) { ufsm_leave_state(m, r->current); @@ -402,12 +402,12 @@ static ufsm_status_t ufsm_leave_nested_states(struct ufsm_machine *m, return err; } -static ufsm_status_t ufsm_init_region_history(struct ufsm_machine *m, - struct ufsm_region *regions) +static ufsm_status_t ufsm_init_region_history(struct ufsm_machine* m, + struct ufsm_region* regions) { ufsm_status_t err = UFSM_ERROR_NO_INIT_REGION; - if (regions->has_history && regions->history) + if (regions->has_history && regions->history) { regions->current = regions->history; @@ -421,53 +421,55 @@ static ufsm_status_t ufsm_init_region_history(struct ufsm_machine *m, return err; } - -inline static ufsm_status_t ufsm_push_rt_pair(struct ufsm_machine *m, - struct ufsm_region *r, - struct ufsm_transition *t) +inline static ufsm_status_t ufsm_push_rt_pair(struct ufsm_machine* m, + struct ufsm_region* r, + struct ufsm_transition* t) { ufsm_status_t err = UFSM_OK; - err = ufsm_stack_push (&m->stack, r); - + err = ufsm_stack_push(&m->stack, r); + if (err == UFSM_OK) - err = ufsm_stack_push (&m->stack, t); + err = ufsm_stack_push(&m->stack, t); return err; } -inline static ufsm_status_t ufsm_pop_rt_pair(struct ufsm_machine *m, - struct ufsm_region **r, - struct ufsm_transition **t) +inline static ufsm_status_t ufsm_pop_rt_pair(struct ufsm_machine* m, + struct ufsm_region** r, + struct ufsm_transition** t) { ufsm_status_t err = UFSM_OK; - err = ufsm_stack_pop (&m->stack, (void **) t); - + err = ufsm_stack_pop(&m->stack, (void**)t); + if (err == UFSM_OK) - err = ufsm_stack_pop (&m->stack, (void **) r); + err = ufsm_stack_pop(&m->stack, (void**)r); return err; } -static ufsm_status_t ufsm_process_regions(struct ufsm_machine *m, - struct ufsm_state *dest, - uint32_t *c) +static ufsm_status_t ufsm_process_regions(struct ufsm_machine* m, + struct ufsm_state* dest, + uint32_t* c) { ufsm_status_t err = UFSM_OK; - struct ufsm_region *r = dest->region; + struct ufsm_region* r = dest->region; - for (struct ufsm_region *s_r = r; s_r; s_r = s_r->next) + for (struct ufsm_region* s_r = r; s_r; s_r = s_r->next) { - struct ufsm_transition *init_t = ufsm_get_first_state(s_r); + struct ufsm_transition* init_t = ufsm_get_first_state(s_r); - if (init_t == NULL) { + if (init_t == NULL) + { err = ufsm_init_region_history(m, s_r); - } else { + } + else + { err = ufsm_push_rt_pair(m, s_r, init_t); *c = *c + 1; } - + if (err != UFSM_OK) break; } @@ -475,16 +477,16 @@ static ufsm_status_t ufsm_process_regions(struct ufsm_machine *m, return err; } -static ufsm_status_t ufsm_process_entry_exit_points(struct ufsm_machine *m, - struct ufsm_state *dest, - uint32_t *c) +static ufsm_status_t ufsm_process_entry_exit_points(struct ufsm_machine* m, + struct ufsm_state* dest, + uint32_t* c) { ufsm_status_t err = UFSM_OK; - struct ufsm_transition *transitions = dest->parent_region->transition; + struct ufsm_transition* transitions = dest->parent_region->transition; - for (struct ufsm_transition *te = transitions; te; te = te->next) + for (struct ufsm_transition* te = transitions; te; te = te->next) { - if (te->source == dest) + if (te->source == dest) { err = ufsm_push_rt_pair(m, te->dest->parent_region, te); @@ -494,25 +496,25 @@ static ufsm_status_t ufsm_process_entry_exit_points(struct ufsm_machine *m, *c = *c + 1; } } - + return err; } -static ufsm_status_t ufsm_process_final_state(struct ufsm_machine *m, - struct ufsm_region *act_region, - struct ufsm_state *dest, - uint32_t *c) +static ufsm_status_t ufsm_process_final_state(struct ufsm_machine* m, + struct ufsm_region* act_region, + struct ufsm_state* dest, + uint32_t* c) { ufsm_status_t err = UFSM_OK; bool super_exit = false; - struct ufsm_state *parent_state = act_region->parent_state; + struct ufsm_state* parent_state = act_region->parent_state; act_region->current = dest; - if (dest->kind == UFSM_STATE_FINAL && parent_state) + if (dest->kind == UFSM_STATE_FINAL && parent_state) { super_exit = true; - for (struct ufsm_region *ar = parent_state->region; ar; ar = ar->next) + for (struct ufsm_region* ar = parent_state->region; ar; ar = ar->next) { if (ar->current) if (ar->current->kind != UFSM_STATE_FINAL) @@ -520,21 +522,19 @@ static ufsm_status_t ufsm_process_final_state(struct ufsm_machine *m, } } - if (super_exit && parent_state) + if (super_exit && parent_state) { - struct ufsm_region *parent_region = parent_state->region; - struct ufsm_transition *transition = - parent_state->parent_region->transition; + struct ufsm_region* parent_region = parent_state->region; + struct ufsm_transition* transition = + parent_state->parent_region->transition; - for (struct ufsm_region *ar = parent_region; ar; ar = ar->next) + for (struct ufsm_region* ar = parent_region; ar; ar = ar->next) ufsm_leave_state(m, ar->current); - - for (struct ufsm_transition *tf = transition; tf; tf = tf->next) + + for (struct ufsm_transition* tf = transition; tf; tf = tf->next) { - if (tf->trigger == -1 && - tf->source == parent_state) + if (tf->trigger == -1 && tf->source == parent_state) { - err = ufsm_push_rt_pair(m, parent_state->parent_region, tf); if (err != UFSM_OK) @@ -544,21 +544,21 @@ static ufsm_status_t ufsm_process_final_state(struct ufsm_machine *m, } } } - + return err; } -static ufsm_status_t ufsm_process_fork(struct ufsm_machine *m, - struct ufsm_region *act_region, - struct ufsm_state *dest, - uint32_t *c) +static ufsm_status_t ufsm_process_fork(struct ufsm_machine* m, + struct ufsm_region* act_region, + struct ufsm_state* dest, + uint32_t* c) { ufsm_status_t err = UFSM_OK; - struct ufsm_transition *transitions = act_region->transition; + struct ufsm_transition* transitions = act_region->transition; - for (struct ufsm_transition *tf = transitions; tf; tf = tf->next) + for (struct ufsm_transition* tf = transitions; tf; tf = tf->next) { - if (tf->source == dest) + if (tf->source == dest) { err = ufsm_push_rt_pair(m, act_region, tf); @@ -572,15 +572,15 @@ static ufsm_status_t ufsm_process_fork(struct ufsm_machine *m, return err; } -static ufsm_status_t ufsm_process_join(struct ufsm_machine *m, - struct ufsm_region *act_region, - struct ufsm_state *src, - struct ufsm_state *dest, - uint32_t *c) +static ufsm_status_t ufsm_process_join(struct ufsm_machine* m, + struct ufsm_region* act_region, + struct ufsm_state* src, + struct ufsm_state* dest, + uint32_t* c) { bool exec_join = true; ufsm_status_t err = UFSM_OK; - struct ufsm_region *orth_region = NULL; + struct ufsm_region* orth_region = NULL; if (!src->parent_region->parent_state) return UFSM_ERROR_EVENT_NOT_PROCESSED; @@ -588,19 +588,19 @@ static ufsm_status_t ufsm_process_join(struct ufsm_machine *m, orth_region = src->parent_region->parent_state->region; src->parent_region->current = dest; - for (struct ufsm_region *dr = orth_region; dr; dr = dr->next) + for (struct ufsm_region* dr = orth_region; dr; dr = dr->next) { if (dr->current != dest) exec_join = false; } - if (exec_join) + if (exec_join) { - struct ufsm_transition *transitions = dest->parent_region->transition; + struct ufsm_transition* transitions = dest->parent_region->transition; - for (struct ufsm_transition *dt = transitions; dt; dt = dt->next) + for (struct ufsm_transition* dt = transitions; dt; dt = dt->next) { - if (dt->source == dest) + if (dt->source == dest) { err = ufsm_push_rt_pair(m, act_region, dt); @@ -610,28 +610,28 @@ static ufsm_status_t ufsm_process_join(struct ufsm_machine *m, } } } - + return err; } -static ufsm_status_t ufsm_process_choice(struct ufsm_machine *m, - struct ufsm_region *act_region, - struct ufsm_state *dest, - uint32_t *c) +static ufsm_status_t ufsm_process_choice(struct ufsm_machine* m, + struct ufsm_region* act_region, + struct ufsm_state* dest, + uint32_t* c) { ufsm_status_t err = UFSM_OK; - struct ufsm_transition *t_default = NULL; + struct ufsm_transition* t_default = NULL; bool made_transition = false; - struct ufsm_transition *transitions = dest->parent_region->transition; + struct ufsm_transition* transitions = dest->parent_region->transition; - for (struct ufsm_transition *dt = transitions; dt; dt = dt->next) + for (struct ufsm_transition* dt = transitions; dt; dt = dt->next) { if (dt->source == dest) { if (dt->guard) { - if (ufsm_test_guards(m, dt)) + if (ufsm_test_guards(m, dt)) { err = ufsm_push_rt_pair(m, act_region, dt); @@ -641,13 +641,16 @@ static ufsm_status_t ufsm_process_choice(struct ufsm_machine *m, *c = *c + 1; break; } - } else { + } + else + { t_default = dt; } } } - if (!made_transition && t_default && err == UFSM_OK) { + if (!made_transition && t_default && err == UFSM_OK) + { err = ufsm_push_rt_pair(m, act_region, t_default); *c = *c + 1; } @@ -655,14 +658,14 @@ static ufsm_status_t ufsm_process_choice(struct ufsm_machine *m, return err; } -static ufsm_status_t ufsm_process_junction(struct ufsm_machine *m, - struct ufsm_state *dest, - uint32_t *c) +static ufsm_status_t ufsm_process_junction(struct ufsm_machine* m, + struct ufsm_state* dest, + uint32_t* c) { ufsm_status_t err = UFSM_OK; - struct ufsm_transition *transitions = dest->parent_region->transition; + struct ufsm_transition* transitions = dest->parent_region->transition; - for (struct ufsm_transition *t = transitions; t; t = t->next) + for (struct ufsm_transition* t = transitions; t; t = t->next) { if (t->source == dest) { @@ -674,48 +677,44 @@ static ufsm_status_t ufsm_process_junction(struct ufsm_machine *m, return err; } -void ufsm_update_defer_queue(struct ufsm_machine *m) +void ufsm_update_defer_queue(struct ufsm_machine* m) { ufsm_status_t err = UFSM_OK; uint32_t ev; - do { + do + { err = ufsm_queue_get(&m->defer_queue, &ev); if (err == UFSM_OK) err = ufsm_queue_put(&m->queue, ev); - } while(err == UFSM_OK); - - + } while (err == UFSM_OK); } -static void ufsm_load_history(struct ufsm_state *src, - struct ufsm_state **dest) +static void ufsm_load_history(struct ufsm_state* src, struct ufsm_state** dest) { - if (ufsm_state_is(src, UFSM_STATE_SHALLOW_HISTORY) || ufsm_state_is(src, UFSM_STATE_DEEP_HISTORY)) { if (src->parent_region->history) *dest = src->parent_region->history; } - } -static ufsm_status_t ufsm_make_transition(struct ufsm_machine *m, - struct ufsm_transition *t, - struct ufsm_region *r) +static ufsm_status_t ufsm_make_transition(struct ufsm_machine* m, + struct ufsm_transition* t, + struct ufsm_region* r) { ufsm_status_t err = UFSM_OK; - struct ufsm_state *dest = t->dest; - struct ufsm_state *src = t->source; - struct ufsm_region *act_region = r; - struct ufsm_transition *act_t = NULL; - struct ufsm_region *lca_region = NULL; + struct ufsm_state* dest = t->dest; + struct ufsm_state* src = t->source; + struct ufsm_region* act_region = r; + struct ufsm_transition* act_t = NULL; + struct ufsm_region* lca_region = NULL; uint32_t transition_count = 1; ufsm_update_defer_queue(m); - err = ufsm_push_rt_pair (m, r, t); + err = ufsm_push_rt_pair(m, r, t); while (transition_count && err == UFSM_OK) { @@ -723,7 +722,7 @@ static ufsm_status_t ufsm_make_transition(struct ufsm_machine *m, if (err != UFSM_OK) break; - + transition_count--; src = act_t->source; @@ -731,7 +730,7 @@ static ufsm_status_t ufsm_make_transition(struct ufsm_machine *m, ufsm_load_history(src, &dest); - if (!ufsm_test_guards(m, act_t)) + if (!ufsm_test_guards(m, act_t)) { err = UFSM_ERROR_EVENT_NOT_PROCESSED; break; @@ -742,8 +741,8 @@ static ufsm_status_t ufsm_make_transition(struct ufsm_machine *m, if (t->kind == UFSM_TRANSITION_EXTERNAL) { - /* If we are in a composite state make sure to - * exit all nested states + /* If we are in a composite state make sure to + * exit all nested states **/ ufsm_leave_nested_states(m, src); @@ -752,8 +751,11 @@ static ufsm_status_t ufsm_make_transition(struct ufsm_machine *m, /* For compound transitions parents must be exited and entered * in the correct order. * */ - err = ufsm_leave_parent_states(m, src, dest, &lca_region, - &act_region); + err = ufsm_leave_parent_states(m, + src, + dest, + &lca_region, + &act_region); if (err != UFSM_OK) break; } @@ -761,80 +763,82 @@ static ufsm_status_t ufsm_make_transition(struct ufsm_machine *m, ufsm_execute_actions(m, act_t); if (t->kind == UFSM_TRANSITION_EXTERNAL && - src->parent_region != dest->parent_region) + src->parent_region != dest->parent_region) { err = ufsm_enter_parent_states(m, lca_region, dest->parent_region); if (err != UFSM_OK) break; - } /* Decode destination state kind */ - switch(dest->kind) + switch (dest->kind) { case UFSM_STATE_SHALLOW_HISTORY: case UFSM_STATE_DEEP_HISTORY: case UFSM_STATE_SIMPLE: ufsm_update_history(dest); act_region->current = dest; - if (t->kind == UFSM_TRANSITION_EXTERNAL) + if (t->kind == UFSM_TRANSITION_EXTERNAL) { ufsm_enter_state(m, dest); err = ufsm_process_regions(m, dest, &transition_count); - } - break; + break; case UFSM_STATE_ENTRY_POINT: case UFSM_STATE_EXIT_POINT: - err = ufsm_process_entry_exit_points(m,dest,&transition_count); - break; + err = ufsm_process_entry_exit_points(m, + dest, + &transition_count); + break; case UFSM_STATE_FINAL: - /* If all regions in this state have reached 'Final' + /* If all regions in this state have reached 'Final' * the superstate should exit if there is an anonymous * transition to a final state. * */ - err = ufsm_process_final_state(m, act_region, dest, - &transition_count); - break; + err = ufsm_process_final_state(m, + act_region, + dest, + &transition_count); + break; case UFSM_STATE_FORK: - err = ufsm_process_fork (m, act_region, dest, - &transition_count); - break; + err = ufsm_process_fork(m, act_region, dest, &transition_count); + break; case UFSM_STATE_JOIN: - err = ufsm_process_join(m, act_region, src, dest, - &transition_count); + err = ufsm_process_join(m, + act_region, + src, + dest, + &transition_count); - break; + break; case UFSM_STATE_CHOICE: - err = ufsm_process_choice(m, act_region, dest, - &transition_count); - break; + err = + ufsm_process_choice(m, act_region, dest, &transition_count); + break; case UFSM_STATE_JUNCTION: err = ufsm_process_junction(m, dest, &transition_count); - break; + break; case UFSM_STATE_TERMINATE: m->terminated = true; return UFSM_OK; - break; + break; default: err = UFSM_ERROR_UNKNOWN_STATE_KIND; - break; + break; } } return err; } - -ufsm_status_t ufsm_process_completion_events(struct ufsm_machine *m) +ufsm_status_t ufsm_process_completion_events(struct ufsm_machine* m) { ufsm_status_t err = UFSM_OK; - struct ufsm_state *completed_state; - + struct ufsm_state* completed_state; - while (ufsm_stack_pop(&m->completion_stack, - (void **) &completed_state) == UFSM_OK) + while (ufsm_stack_pop(&m->completion_stack, (void**)&completed_state) == + UFSM_OK) { err = ufsm_process_completion(m, completed_state); if (err != UFSM_OK) @@ -843,21 +847,23 @@ ufsm_status_t ufsm_process_completion_events(struct ufsm_machine *m) return err; } -ufsm_status_t ufsm_init_machine(struct ufsm_machine *m) +ufsm_status_t ufsm_init_machine(struct ufsm_machine* m) { ufsm_status_t err = UFSM_OK; - + ufsm_stack_init(&(m->stack), UFSM_STACK_SIZE, m->stack_data); - ufsm_stack_init(&(m->completion_stack), - UFSM_COMPLETION_STACK_SIZE, m->completion_stack_data); + ufsm_stack_init(&(m->completion_stack), + UFSM_COMPLETION_STACK_SIZE, + m->completion_stack_data); ufsm_queue_init(&(m->queue), UFSM_QUEUE_SIZE, m->queue_data); - ufsm_queue_init(&(m->defer_queue), UFSM_DEFER_QUEUE_SIZE, - m->defer_queue_data); + ufsm_queue_init(&(m->defer_queue), + UFSM_DEFER_QUEUE_SIZE, + m->defer_queue_data); m->terminated = false; - for (struct ufsm_region *r = m->region; r; r = r->next) + for (struct ufsm_region* r = m->region; r; r = r->next) { - struct ufsm_transition *rt = ufsm_get_first_state(r); + struct ufsm_transition* rt = ufsm_get_first_state(r); err = ufsm_make_transition(m, rt, r); if (err != UFSM_OK) @@ -870,25 +876,27 @@ ufsm_status_t ufsm_init_machine(struct ufsm_machine *m) return err; } -ufsm_status_t ufsm_find_active_regions(struct ufsm_machine *m, uint32_t *c) +ufsm_status_t ufsm_find_active_regions(struct ufsm_machine* m, uint32_t* c) { ufsm_status_t err = UFSM_OK; - struct ufsm_region *r = m->region; - struct ufsm_state *s = NULL; - - while (r) + struct ufsm_region* r = m->region; + struct ufsm_state* s = NULL; + + while (r) { s = r->current; - if (s) + if (s) { err = ufsm_stack_push(&m->stack, r); if (err != UFSM_OK) break; - + *c = *c + 1; r = s->region; - } else { + } + else + { break; } } @@ -896,53 +904,51 @@ ufsm_status_t ufsm_find_active_regions(struct ufsm_machine *m, uint32_t *c) return err; } - -bool ufsm_transition(struct ufsm_machine *m, struct ufsm_region *r, - int32_t ev, - bool *state_transitioned) +bool ufsm_transition(struct ufsm_machine* m, + struct ufsm_region* r, + int32_t ev, + bool* state_transitioned) { bool event_consumed = false; ufsm_status_t err = UFSM_OK; - for (struct ufsm_transition *t = r->transition; t; t = t->next) + for (struct ufsm_transition* t = r->transition; t; t = t->next) { - if (t->defer && t->trigger == ev && t->source == r->current) + if (t->defer && t->trigger == ev && t->source == r->current) { err = ufsm_queue_put(&m->defer_queue, ev); - + if (err != UFSM_OK) break; - - } else if (t->trigger == ev && t->source == r->current) { + } + else if (t->trigger == ev && t->source == r->current) + { event_consumed = true; - uint32_t e = ufsm_make_transition(m, t, r); + uint32_t e = ufsm_make_transition(m, t, r); - if (e == UFSM_OK) + if (e == UFSM_OK) { *state_transitioned = true; - - if (!r->next) + + if (!r->next) break; - } - + } } } - + return event_consumed; } - -ufsm_status_t ufsm_process (struct ufsm_machine *m, int32_t ev) +ufsm_status_t ufsm_process(struct ufsm_machine* m, int32_t ev) { ufsm_status_t err = UFSM_OK; uint32_t region_count = 0; - struct ufsm_region *region = NULL; + struct ufsm_region* region = NULL; bool event_consumed = false; if (m->terminated) return UFSM_ERROR_MACHINE_TERMINATED; - ufsm_process_completion_events(m); if (ev == -1) @@ -950,27 +956,27 @@ ufsm_status_t ufsm_process (struct ufsm_machine *m, int32_t ev) if (m->debug_event) m->debug_event(ev); - + ufsm_find_active_regions(m, ®ion_count); - for (uint32_t i = 0; i < region_count; i++) + for (uint32_t i = 0; i < region_count; i++) { - err = ufsm_stack_pop(&m->stack, (void **) ®ion); + err = ufsm_stack_pop(&m->stack, (void**)®ion); if (err != UFSM_OK) break; - - if (!event_consumed) + + if (!event_consumed) { - for (struct ufsm_region *r = region; r; r = r->next) + for (struct ufsm_region* r = region; r; r = r->next) { bool state_transitioned = false; - if (ufsm_transition (m, r, ev, &state_transitioned)) + if (ufsm_transition(m, r, ev, &state_transitioned)) event_consumed = true; if (!state_transitioned) - if (ufsm_transition (m, r, -1, &state_transitioned)) + if (ufsm_transition(m, r, -1, &state_transitioned)) event_consumed = true; if (!r->next && event_consumed) @@ -985,32 +991,31 @@ ufsm_status_t ufsm_process (struct ufsm_machine *m, int32_t ev) return err; } - -static ufsm_status_t ufsm_reset_region(struct ufsm_machine *m, - struct ufsm_region *regions) +static ufsm_status_t ufsm_reset_region(struct ufsm_machine* m, + struct ufsm_region* regions) { ufsm_status_t err = UFSM_OK; - struct ufsm_region *r = NULL; + struct ufsm_region* r = NULL; uint32_t regions_count = 1; - + err = ufsm_stack_push(&m->stack, regions); if (err != UFSM_OK) return err; - while (regions_count) + while (regions_count) { - err = ufsm_stack_pop(&m->stack, (void **) &r); - + err = ufsm_stack_pop(&m->stack, (void**)&r); + if (err != UFSM_OK) break; r->history = NULL; r->current = NULL; - - for (struct ufsm_state *s = r->state; s; s = s->next) + + for (struct ufsm_state* s = r->state; s; s = s->next) { - for (struct ufsm_region *sr = s->region; sr; sr = sr->next) + for (struct ufsm_region* sr = s->region; sr; sr = sr->next) { err = ufsm_stack_push(&m->stack, sr); @@ -1019,27 +1024,26 @@ static ufsm_status_t ufsm_reset_region(struct ufsm_machine *m, regions_count++; } - + if (err != UFSM_OK) break; } - } return err; } -ufsm_status_t ufsm_reset_machine(struct ufsm_machine *m) +ufsm_status_t ufsm_reset_machine(struct ufsm_machine* m) { if (m->debug_reset) m->debug_reset(m); - for (struct ufsm_region *r = m->region; r; r = r->next) + for (struct ufsm_region* r = m->region; r; r = r->next) ufsm_reset_region(m, r); return UFSM_OK; } -struct ufsm_queue * ufsm_get_queue(struct ufsm_machine *m) +struct ufsm_queue* ufsm_get_queue(struct ufsm_machine* m) { return &m->queue; } diff --git a/src/ufsm.h b/src/ufsm.h index 41c2a92..3260123 100644 --- a/src/ufsm.h +++ b/src/ufsm.h @@ -10,12 +10,13 @@ #ifndef UFSM_H #define UFSM_H -#include #include +#include /* Error codes */ -enum ufsm_status_codes { +enum ufsm_status_codes +{ UFSM_OK, UFSM_ERROR, UFSM_ERROR_NO_INIT_REGION, @@ -31,30 +32,30 @@ enum ufsm_status_codes { typedef enum ufsm_status_codes ufsm_status_t; -extern const char *ufsm_errors[]; +extern const char* ufsm_errors[]; /* Misc defines */ #define UFSM_NO_TRIGGER -1 #define UFSM_COMPLETION_EVENT -1 #ifndef UFSM_STACK_SIZE - #define UFSM_STACK_SIZE 128 +#define UFSM_STACK_SIZE 128 #endif #ifndef UFSM_COMPLETION_STACK_SIZE - #define UFSM_COMPLETION_STACK_SIZE 16 +#define UFSM_COMPLETION_STACK_SIZE 16 #endif #ifndef UFSM_QUEUE_SIZE - #define UFSM_QUEUE_SIZE 16 +#define UFSM_QUEUE_SIZE 16 #endif #ifndef UFSM_DEFER_QUEUE_SIZE - #define UFSM_DEFER_QUEUE_SIZE 16 +#define UFSM_DEFER_QUEUE_SIZE 16 #endif #ifndef NULL - #define NULL ((void *) 0) +#define NULL ((void*)0) #endif struct ufsm_state; @@ -64,35 +65,38 @@ struct ufsm_guard; struct ufsm_transition; struct ufsm_region; -typedef bool (*ufsm_guard_func_t) (void); -typedef void (*ufsm_action_func_t) (void); -typedef void (*ufsm_entry_exit_func_t) (void); -typedef void (*ufsm_queue_cb_t) (void); -typedef uint32_t (*ufsm_doact_cb_t) (struct ufsm_machine *m, struct ufsm_state *s); -typedef void (*ufsm_doact_func_t) (struct ufsm_machine *m, - struct ufsm_state *s, - ufsm_doact_cb_t cb); +typedef bool (*ufsm_guard_func_t)(void); +typedef void (*ufsm_action_func_t)(void); +typedef void (*ufsm_entry_exit_func_t)(void); +typedef void (*ufsm_queue_cb_t)(void); +typedef uint32_t (*ufsm_doact_cb_t)(struct ufsm_machine* m, + struct ufsm_state* s); +typedef void (*ufsm_doact_func_t)(struct ufsm_machine* m, + struct ufsm_state* s, + ufsm_doact_cb_t cb); /* Debug callbacks */ -typedef void (*ufsm_debug_event_t) (uint32_t ev); -typedef void (*ufsm_debug_transition_t) (struct ufsm_transition *t); -typedef void (*ufsm_debug_enter_region_t) (struct ufsm_region *region); -typedef void (*ufsm_debug_leave_region_t) (struct ufsm_region *region); -typedef void (*ufsm_debug_guard_t) (struct ufsm_guard *guard, bool result); -typedef void (*ufsm_debug_action_t) (struct ufsm_action *action); -typedef void (*ufsm_debug_enter_state_t) (struct ufsm_state *s); -typedef void (*ufsm_debug_exit_state_t) (struct ufsm_state *s); -typedef void (*ufsm_debug_reset_t) (struct ufsm_machine *m); - -enum ufsm_transition_kind { +typedef void (*ufsm_debug_event_t)(uint32_t ev); +typedef void (*ufsm_debug_transition_t)(struct ufsm_transition* t); +typedef void (*ufsm_debug_enter_region_t)(struct ufsm_region* region); +typedef void (*ufsm_debug_leave_region_t)(struct ufsm_region* region); +typedef void (*ufsm_debug_guard_t)(struct ufsm_guard* guard, bool result); +typedef void (*ufsm_debug_action_t)(struct ufsm_action* action); +typedef void (*ufsm_debug_enter_state_t)(struct ufsm_state* s); +typedef void (*ufsm_debug_exit_state_t)(struct ufsm_state* s); +typedef void (*ufsm_debug_reset_t)(struct ufsm_machine* m); + +enum ufsm_transition_kind +{ UFSM_TRANSITION_EXTERNAL, UFSM_TRANSITION_INTERNAL, UFSM_TRANSITION_LOCAL, }; -extern const char *ufsm_errors[]; +extern const char* ufsm_errors[]; -enum ufsm_state_kind { +enum ufsm_state_kind +{ UFSM_STATE_SIMPLE, UFSM_STATE_INIT, UFSM_STATE_FINAL, @@ -107,28 +111,31 @@ enum ufsm_state_kind { UFSM_STATE_TERMINATE, }; -extern const char *ufsm_state_kinds[]; +extern const char* ufsm_state_kinds[]; -struct ufsm_stack { +struct ufsm_stack +{ uint32_t no_of_elements; - void **data; + void** data; uint32_t pos; }; -struct ufsm_queue { +struct ufsm_queue +{ uint32_t no_of_elements; uint32_t s; uint32_t head; uint32_t tail; - uint32_t *data; + uint32_t* data; ufsm_queue_cb_t on_data; ufsm_queue_cb_t lock; ufsm_queue_cb_t unlock; }; -struct ufsm_machine { - const char *id; - const char *name; +struct ufsm_machine +{ + const char* id; + const char* name; ufsm_debug_event_t debug_event; ufsm_debug_transition_t debug_transition; ufsm_debug_enter_region_t debug_enter_region; @@ -140,104 +147,112 @@ struct ufsm_machine { ufsm_debug_reset_t debug_reset; bool terminated; - void *stack_data[UFSM_STACK_SIZE]; - void *completion_stack_data[UFSM_COMPLETION_STACK_SIZE]; + void* stack_data[UFSM_STACK_SIZE]; + void* completion_stack_data[UFSM_COMPLETION_STACK_SIZE]; uint32_t queue_data[UFSM_QUEUE_SIZE]; uint32_t defer_queue_data[UFSM_DEFER_QUEUE_SIZE]; struct ufsm_queue queue; struct ufsm_queue defer_queue; - struct ufsm_state *parent_state; + struct ufsm_state* parent_state; struct ufsm_stack stack; struct ufsm_stack completion_stack; - struct ufsm_region *region; - struct ufsm_machine *next; + struct ufsm_region* region; + struct ufsm_machine* next; }; -struct ufsm_action { - const char *id; - const char *name; +struct ufsm_action +{ + const char* id; + const char* name; ufsm_action_func_t f; - struct ufsm_action *next; + struct ufsm_action* next; }; -struct ufsm_guard { - const char *id; - const char *name; +struct ufsm_guard +{ + const char* id; + const char* name; ufsm_guard_func_t f; - struct ufsm_guard *next; + struct ufsm_guard* next; }; -struct ufsm_entry_exit { - const char *id; - const char *name; +struct ufsm_entry_exit +{ + const char* id; + const char* name; ufsm_entry_exit_func_t f; - struct ufsm_entry_exit *next; + struct ufsm_entry_exit* next; }; -struct ufsm_doact { - const char *id; - const char *name; +struct ufsm_doact +{ + const char* id; + const char* name; ufsm_doact_func_t f_start; ufsm_entry_exit_func_t f_stop; - struct ufsm_doact *next; + struct ufsm_doact* next; }; -struct ufsm_transition { - const char *id; - const char *name; - const char *trigger_name; +struct ufsm_transition +{ + const char* id; + const char* name; + const char* trigger_name; int32_t trigger; bool defer; enum ufsm_transition_kind kind; - struct ufsm_action *action; - struct ufsm_guard *guard; - struct ufsm_state *source; - struct ufsm_state *dest; - struct ufsm_transition *next; + struct ufsm_action* action; + struct ufsm_guard* guard; + struct ufsm_state* source; + struct ufsm_state* dest; + struct ufsm_transition* next; }; -struct ufsm_region { - const char *id; - const char *name; +struct ufsm_region +{ + const char* id; + const char* name; bool has_history; - struct ufsm_state *current; - struct ufsm_state *history; - struct ufsm_state *state; - struct ufsm_transition *transition; - struct ufsm_state *parent_state; - struct ufsm_region *next; + struct ufsm_state* current; + struct ufsm_state* history; + struct ufsm_state* state; + struct ufsm_transition* transition; + struct ufsm_state* parent_state; + struct ufsm_region* next; }; -struct ufsm_state { - const char *id; - const char *name; +struct ufsm_state +{ + const char* id; + const char* name; enum ufsm_state_kind kind; - struct ufsm_entry_exit *entry; - struct ufsm_doact *doact; - struct ufsm_entry_exit *exit; - struct ufsm_region *region; - struct ufsm_region *parent_region; - struct ufsm_machine *submachine; - struct ufsm_state *next; + struct ufsm_entry_exit* entry; + struct ufsm_doact* doact; + struct ufsm_entry_exit* exit; + struct ufsm_region* region; + struct ufsm_region* parent_region; + struct ufsm_machine* submachine; + struct ufsm_state* next; }; -ufsm_status_t ufsm_init_machine(struct ufsm_machine *m); -ufsm_status_t ufsm_reset_machine(struct ufsm_machine *m); -ufsm_status_t ufsm_process (struct ufsm_machine *m, int32_t ev); -ufsm_status_t ufsm_stack_init(struct ufsm_stack *stack, - uint32_t no_of_elements, - void **stack_data); -ufsm_status_t ufsm_stack_push(struct ufsm_stack *stack, void *item); -ufsm_status_t ufsm_stack_pop(struct ufsm_stack *stack, void **item); - -ufsm_status_t ufsm_queue_init(struct ufsm_queue *q, uint32_t no_of_elements, - uint32_t *data); - -ufsm_status_t ufsm_queue_put(struct ufsm_queue *q, uint32_t ev); -ufsm_status_t ufsm_queue_get(struct ufsm_queue *q, uint32_t *ev); -struct ufsm_queue * ufsm_get_queue(struct ufsm_machine *m); +ufsm_status_t ufsm_init_machine(struct ufsm_machine* m); +ufsm_status_t ufsm_reset_machine(struct ufsm_machine* m); +ufsm_status_t ufsm_process(struct ufsm_machine* m, int32_t ev); +ufsm_status_t ufsm_stack_init(struct ufsm_stack* stack, + uint32_t no_of_elements, + void** stack_data); +ufsm_status_t ufsm_stack_push(struct ufsm_stack* stack, void* item); +ufsm_status_t ufsm_stack_pop(struct ufsm_stack* stack, void** item); + +ufsm_status_t ufsm_queue_init(struct ufsm_queue* q, + uint32_t no_of_elements, + uint32_t* data); + +ufsm_status_t ufsm_queue_put(struct ufsm_queue* q, uint32_t ev); +ufsm_status_t ufsm_queue_get(struct ufsm_queue* q, uint32_t* ev); +struct ufsm_queue* ufsm_get_queue(struct ufsm_machine* m); #endif diff --git a/src/ufsm_queue.c b/src/ufsm_queue.c index 49e28e8..93979ba 100644 --- a/src/ufsm_queue.c +++ b/src/ufsm_queue.c @@ -9,25 +9,27 @@ #include -uint32_t ufsm_queue_put(struct ufsm_queue *q, uint32_t ev) +uint32_t ufsm_queue_put(struct ufsm_queue* q, uint32_t ev) { uint32_t err = UFSM_OK; if (q->lock) q->lock(); - if (q->s < q->no_of_elements) { + if (q->s < q->no_of_elements) + { q->data[q->head] = ev; q->s++; q->head++; - + if (q->on_data) q->on_data(); - + if (q->head >= q->no_of_elements) q->head = 0; - - } else { + } + else + { err = UFSM_ERROR_QUEUE_FULL; } @@ -37,22 +39,24 @@ uint32_t ufsm_queue_put(struct ufsm_queue *q, uint32_t ev) return err; } -uint32_t ufsm_queue_get(struct ufsm_queue *q, uint32_t *ev) +uint32_t ufsm_queue_get(struct ufsm_queue* q, uint32_t* ev) { uint32_t err = UFSM_OK; if (q->lock) q->lock(); - if (q->s) { + if (q->s) + { *ev = q->data[q->tail]; q->s--; q->tail++; if (q->tail >= q->no_of_elements) q->tail = 0; - - } else { + } + else + { err = UFSM_ERROR_QUEUE_EMPTY; } @@ -62,16 +66,17 @@ uint32_t ufsm_queue_get(struct ufsm_queue *q, uint32_t *ev) return err; } -uint32_t ufsm_queue_init(struct ufsm_queue *q, uint32_t no_of_elements, - uint32_t *data) +uint32_t ufsm_queue_init(struct ufsm_queue* q, + uint32_t no_of_elements, + uint32_t* data) { q->head = 0; q->tail = 0; q->data = data; q->s = 0; - //q->on_data = NULL; - //q->lock = NULL; - //q->unlock = NULL; + // q->on_data = NULL; + // q->lock = NULL; + // q->unlock = NULL; q->no_of_elements = no_of_elements; return UFSM_OK; diff --git a/src/ufsm_stack.c b/src/ufsm_stack.c index c2c63cd..e6f7c7f 100644 --- a/src/ufsm_stack.c +++ b/src/ufsm_stack.c @@ -9,9 +9,9 @@ #include -uint32_t ufsm_stack_init(struct ufsm_stack *stack, - uint32_t no_of_elements, - void **stack_data) +uint32_t ufsm_stack_init(struct ufsm_stack* stack, + uint32_t no_of_elements, + void** stack_data) { stack->no_of_elements = no_of_elements; stack->data = stack_data; @@ -20,7 +20,7 @@ uint32_t ufsm_stack_init(struct ufsm_stack *stack, return UFSM_OK; } -uint32_t ufsm_stack_push(struct ufsm_stack *stack, void *item) +uint32_t ufsm_stack_push(struct ufsm_stack* stack, void* item) { if (stack->pos >= stack->no_of_elements) return UFSM_ERROR_STACK_OVERFLOW; @@ -30,11 +30,11 @@ uint32_t ufsm_stack_push(struct ufsm_stack *stack, void *item) return UFSM_OK; } -uint32_t ufsm_stack_pop(struct ufsm_stack *stack, void **item) +uint32_t ufsm_stack_pop(struct ufsm_stack* stack, void** item) { - if(!stack->pos) + if (!stack->pos) return UFSM_ERROR_STACK_UNDERFLOW; - + stack->pos--; *item = stack->data[stack->pos]; From f8f0d4912b84a48b66d90ba2f52b6a49421a5532 Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Sat, 23 Jun 2018 20:15:54 -0600 Subject: [PATCH 3/7] formatting options --- src/tests/.clang-format | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 src/tests/.clang-format diff --git a/src/tests/.clang-format b/src/tests/.clang-format new file mode 100644 index 0000000..379585e --- /dev/null +++ b/src/tests/.clang-format @@ -0,0 +1,15 @@ +BasedOnStyle: Chromium +IndentWidth: 4 +AllowShortFunctionsOnASingleLine: All +BreakBeforeBraces: Allman +# BreakBeforeBinaryOperators: NonAssignment +BreakBeforeBinaryOperators: None +AlignOperands: true +AlignTrailingComments: true +AllowAllParametersOfDeclarationOnNextLine: false +BinPackArguments: false +BinPackParameters: false +AlignAfterOpenBracket: Align +PenaltyBreakAssignment: 100 +PenaltyBreakBeforeFirstCallParameter: 1000 + From 777e0097f8913e90cb35386c0f2d9264170fb032 Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Sat, 23 Jun 2018 20:19:36 -0600 Subject: [PATCH 4/7] tweak --- src/ufsm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ufsm.c b/src/ufsm.c index 787ff79..d8d8e70 100644 --- a/src/ufsm.c +++ b/src/ufsm.c @@ -586,8 +586,8 @@ static ufsm_status_t ufsm_process_join(struct ufsm_machine* m, return UFSM_ERROR_EVENT_NOT_PROCESSED; orth_region = src->parent_region->parent_state->region; - src->parent_region->current = dest; + for (struct ufsm_region* dr = orth_region; dr; dr = dr->next) { if (dr->current != dest) From d2d8a72f5aa5afdbdf2e27bcf19748c81d41e8ce Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Sat, 23 Jun 2018 20:33:18 -0600 Subject: [PATCH 5/7] adding comments --- src/ufsm.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/ufsm.c b/src/ufsm.c index d8d8e70..fbc7400 100644 --- a/src/ufsm.c +++ b/src/ufsm.c @@ -851,16 +851,19 @@ ufsm_status_t ufsm_init_machine(struct ufsm_machine* m) { ufsm_status_t err = UFSM_OK; + // Initialize Stacks ufsm_stack_init(&(m->stack), UFSM_STACK_SIZE, m->stack_data); ufsm_stack_init(&(m->completion_stack), UFSM_COMPLETION_STACK_SIZE, m->completion_stack_data); + // Initialize Queues ufsm_queue_init(&(m->queue), UFSM_QUEUE_SIZE, m->queue_data); ufsm_queue_init(&(m->defer_queue), UFSM_DEFER_QUEUE_SIZE, m->defer_queue_data); m->terminated = false; + // Process Regions for (struct ufsm_region* r = m->region; r; r = r->next) { struct ufsm_transition* rt = ufsm_get_first_state(r); From 66774b7338b0d21f9f660a42e63b842593b72202 Mon Sep 17 00:00:00 2001 From: Jaremy Creechley Date: Sat, 23 Jun 2018 20:34:19 -0600 Subject: [PATCH 6/7] Tweaking format, set binary operators first --- .clang-format | 4 ++-- src/tools/ufsmimport.c | 4 ++-- src/ufsm.c | 28 ++++++++++++++-------------- 3 files changed, 18 insertions(+), 18 deletions(-) diff --git a/.clang-format b/.clang-format index 56b91e8..f1b5480 100644 --- a/.clang-format +++ b/.clang-format @@ -2,8 +2,8 @@ BasedOnStyle: Chromium IndentWidth: 4 AllowShortFunctionsOnASingleLine: None BreakBeforeBraces: Allman -# BreakBeforeBinaryOperators: NonAssignment -BreakBeforeBinaryOperators: None +BreakBeforeBinaryOperators: NonAssignment +# BreakBeforeBinaryOperators: None AlignOperands: true AlignTrailingComments: true AllowAllParametersOfDeclarationOnNextLine: false diff --git a/src/tools/ufsmimport.c b/src/tools/ufsmimport.c index e7454b5..c5a54a7 100644 --- a/src/tools/ufsmimport.c +++ b/src/tools/ufsmimport.c @@ -406,8 +406,8 @@ static uint32_t parse_transition(xmlNode* n, { t->trigger_name = (const char*)get_attr(trigger, "name"); } - else if (is_type(trigger, "uml:Activity") || - is_type(trigger, "uml:OpaqueBehavior")) + else if (is_type(trigger, "uml:Activity") + || is_type(trigger, "uml:OpaqueBehavior")) { action = malloc(sizeof(struct ufsm_action)); bzero(action, sizeof(struct ufsm_action)); diff --git a/src/ufsm.c b/src/ufsm.c index fbc7400..6f132ef 100644 --- a/src/ufsm.c +++ b/src/ufsm.c @@ -161,9 +161,9 @@ inline static struct ufsm_transition* ufsm_find_transition( { for (struct ufsm_transition* t = region->transition; t; t = t->next) { - if ((t->source == source && dest == NULL) || - (t->source == source && t->dest == dest) || - (t->dest == dest && source == NULL)) + if ((t->source == source && dest == NULL) + || (t->source == source && t->dest == dest) + || (t->dest == dest && source == NULL)) { return t; } @@ -214,9 +214,9 @@ static struct ufsm_transition* ufsm_get_first_state(struct ufsm_region* region) { for (struct ufsm_state* s = region->state; s; s = s->next) { - if (ufsm_state_is(s, UFSM_STATE_INIT) || - ufsm_state_is(s, UFSM_STATE_SHALLOW_HISTORY) || - ufsm_state_is(s, UFSM_STATE_DEEP_HISTORY)) + if (ufsm_state_is(s, UFSM_STATE_INIT) + || ufsm_state_is(s, UFSM_STATE_SHALLOW_HISTORY) + || ufsm_state_is(s, UFSM_STATE_DEEP_HISTORY)) { return ufsm_find_transition(region, s, NULL); } @@ -318,8 +318,8 @@ static ufsm_status_t ufsm_leave_parent_states(struct ufsm_machine* m, struct ufsm_region* ancestor = NULL; bool states_to_leave = true; - if (!((src->parent_region != dest->parent_region) && - dest->kind != UFSM_STATE_JOIN)) + if (!((src->parent_region != dest->parent_region) + && dest->kind != UFSM_STATE_JOIN)) return UFSM_OK; *act = dest->parent_region; @@ -692,8 +692,8 @@ void ufsm_update_defer_queue(struct ufsm_machine* m) static void ufsm_load_history(struct ufsm_state* src, struct ufsm_state** dest) { - if (ufsm_state_is(src, UFSM_STATE_SHALLOW_HISTORY) || - ufsm_state_is(src, UFSM_STATE_DEEP_HISTORY)) + if (ufsm_state_is(src, UFSM_STATE_SHALLOW_HISTORY) + || ufsm_state_is(src, UFSM_STATE_DEEP_HISTORY)) { if (src->parent_region->history) *dest = src->parent_region->history; @@ -762,8 +762,8 @@ static ufsm_status_t ufsm_make_transition(struct ufsm_machine* m, ufsm_execute_actions(m, act_t); - if (t->kind == UFSM_TRANSITION_EXTERNAL && - src->parent_region != dest->parent_region) + if (t->kind == UFSM_TRANSITION_EXTERNAL + && src->parent_region != dest->parent_region) { err = ufsm_enter_parent_states(m, lca_region, dest->parent_region); @@ -837,8 +837,8 @@ ufsm_status_t ufsm_process_completion_events(struct ufsm_machine* m) ufsm_status_t err = UFSM_OK; struct ufsm_state* completed_state; - while (ufsm_stack_pop(&m->completion_stack, (void**)&completed_state) == - UFSM_OK) + while (ufsm_stack_pop(&m->completion_stack, (void**)&completed_state) + == UFSM_OK) { err = ufsm_process_completion(m, completed_state); if (err != UFSM_OK) From ef06615406817bf3a36afd09839000c029d564bb Mon Sep 17 00:00:00 2001 From: Jonas Persson Date: Sun, 17 Jun 2018 13:51:40 +0200 Subject: [PATCH 7/7] Added support to store pair's onto the queue --- src/tests/common.c | 6 +- src/tests/common.h | 4 +- src/tests/test_defer.c | 4 +- src/tests/test_gaurd_repeat.c | 152 ++++++++++++++++++++++++++++++++++ src/tests/test_queue.c | 6 +- src/ufsm.c | 6 +- src/ufsm.h | 54 ++++++------ src/ufsm_queue.c | 47 ++++++++--- 8 files changed, 229 insertions(+), 50 deletions(-) create mode 100644 src/tests/test_gaurd_repeat.c diff --git a/src/tests/common.c b/src/tests/common.c index 30b69a0..71c42dc 100644 --- a/src/tests/common.c +++ b/src/tests/common.c @@ -27,7 +27,7 @@ void debug_leave_region(struct ufsm_region* r) #endif } -void debug_event(uint32_t ev) +void debug_event(event_t ev) { #if UFSM_TESTS_VERBOSE == true printf(" %-3i| |\n", ev); @@ -69,7 +69,7 @@ void debug_reset(struct ufsm_machine* m) #endif } -void test_process(struct ufsm_machine* m, uint32_t ev) +void test_process(struct ufsm_machine* m, event_t ev) { uint32_t err = UFSM_OK; @@ -86,7 +86,7 @@ void test_process(struct ufsm_machine* m, uint32_t ev) assert(m->stack.pos == 0); struct ufsm_queue* q = ufsm_get_queue(m); - uint32_t q_ev; + event_t q_ev; /* Process queued events */ while (ufsm_queue_get(q, &q_ev) == UFSM_OK) diff --git a/src/tests/common.h b/src/tests/common.h index 5da9d83..daf4e93 100644 --- a/src/tests/common.h +++ b/src/tests/common.h @@ -7,13 +7,13 @@ void debug_transition(struct ufsm_transition* t); void debug_enter_region(struct ufsm_region* r); void debug_leave_region(struct ufsm_region* r); -void debug_event(uint32_t ev); +void debug_event(event_t ev); void debug_action(struct ufsm_action* a); void debug_guard(struct ufsm_guard* g, bool result); void debug_enter_state(struct ufsm_state* s); void debug_exit_state(struct ufsm_state* s); -void test_process(struct ufsm_machine* m, uint32_t ev); +void test_process(struct ufsm_machine* m, event_t ev); void test_init(struct ufsm_machine* m); #endif diff --git a/src/tests/test_defer.c b/src/tests/test_defer.c index cfba177..cf6bc24 100644 --- a/src/tests/test_defer.c +++ b/src/tests/test_defer.c @@ -11,8 +11,8 @@ void final(void) { flag_final = true; } int main(void) { struct ufsm_machine* m = get_StateMachine1(); - uint32_t err = UFSM_OK; - uint32_t ev; + ufsm_status_t err = UFSM_OK; + event_t ev; test_init(m); ufsm_init_machine(m); diff --git a/src/tests/test_gaurd_repeat.c b/src/tests/test_gaurd_repeat.c new file mode 100644 index 0000000..c5c6fed --- /dev/null +++ b/src/tests/test_gaurd_repeat.c @@ -0,0 +1,152 @@ +#include +#include +#include +#include "common.h" + +enum events +{ + EV_A, + EV_B +}; + +static bool flag_guard1_called = false; +static bool flag_guard2_called = false; +static bool flag_action1_called = false; +static bool guard2_ret_val = true; + +static void reset_test_flags(void) +{ + flag_guard1_called = false; + flag_guard2_called = false; + flag_action1_called = false; + guard2_ret_val = true; +} + +static bool guard1_f(void) +{ + flag_guard1_called = true; + return true; +} + +static bool guard2_f(void) +{ + flag_guard2_called = true; + return guard2_ret_val; +} + +static void action1_f(void) { flag_action1_called = true; } + +static struct ufsm_state A; +static struct ufsm_region region1; + +static struct ufsm_state simple_INIT = {.name = "Init", + .kind = UFSM_STATE_INIT, + .parent_region = ®ion1, + .next = &A}; + +static struct ufsm_state B = { + .name = "State B", + .kind = UFSM_STATE_SIMPLE, + .parent_region = ®ion1, + .next = NULL, +}; + +static struct ufsm_state A = { + .name = "State A", + .kind = UFSM_STATE_SIMPLE, + .parent_region = ®ion1, + .next = &B, +}; + +static struct ufsm_guard guard2; + +static struct ufsm_guard guard1 = { + .f = &guard1_f, + .next = &guard2, +}; + +static struct ufsm_guard guard2 = { + .f = &guard2_f, + .next = NULL, +}; + +static struct ufsm_action action1 = { + .f = &action1_f, + .next = NULL, +}; + +static struct ufsm_transition simple_transition_B = + {.name = "EV_B", + .trigger = EV_B, + .kind = UFSM_TRANSITION_EXTERNAL, + .source = &A, + .dest = &B, + .next = NULL}; + +static struct ufsm_transition simple_transition_A = + {.name = "EV_A", + .trigger = EV_A, + .kind = UFSM_TRANSITION_EXTERNAL, + .source = &B, + .dest = &A, + .guard = &guard1, + .action = &action1, + .next = &simple_transition_B}; + +static struct ufsm_transition simple_transition_INIT = { + .name = "Init", + .kind = UFSM_TRANSITION_EXTERNAL, + .source = &simple_INIT, + .trigger = UFSM_NO_TRIGGER, + .dest = &A, + .next = &simple_transition_A, +}; + +static struct ufsm_region region1 = {.state = &simple_INIT, + .transition = &simple_transition_INIT, + .next = NULL}; + +static struct ufsm_machine m = { + .name = "Simple Test Machine", + .region = ®ion1, +}; + +int main(void) +{ + uint32_t err; + + reset_test_flags(); + test_init(&m); + err = ufsm_init_machine(&m); + assert(err == UFSM_OK && "Initializing"); + assert(m.region->current == &A); + assert(flag_guard1_called == false); + assert(flag_guard2_called == false); + assert(flag_action1_called == false); + + reset_test_flags(); + err = ufsm_process(&m, EV_B); + assert(m.region->current == &B && err == UFSM_OK); + + reset_test_flags(); + err = ufsm_process(&m, EV_A); + assert(m.region->current == &A && err == UFSM_OK); + assert(flag_guard1_called); + assert(flag_guard2_called); + assert(flag_action1_called); + + reset_test_flags(); + err = ufsm_process(&m, EV_B); + assert(m.region->current == &B && err == UFSM_OK); + + reset_test_flags(); + guard2_ret_val = false; + err = ufsm_process(&m, EV_A); + assert(m.region->current == &B); + assert(err == UFSM_OK); + assert(flag_guard1_called); + assert(flag_guard2_called); + assert(flag_action1_called == false); + + return 0; +} diff --git a/src/tests/test_queue.c b/src/tests/test_queue.c index 2c3aa7f..2912f5a 100644 --- a/src/tests/test_queue.c +++ b/src/tests/test_queue.c @@ -28,9 +28,9 @@ void q_unlock(void) { flag_q_unlock = true; } int main(void) { - uint32_t err = UFSM_OK; - uint32_t data[4]; - uint32_t i = 0; + ufsm_status_t err = UFSM_OK; + struct ufsm_queue_data_t data[4]; + event_t i = 0; struct ufsm_machine* m = get_StateMachine1(); struct ufsm_queue* q = ufsm_get_queue(m); diff --git a/src/ufsm.c b/src/ufsm.c index 6f132ef..7ff4345 100644 --- a/src/ufsm.c +++ b/src/ufsm.c @@ -680,7 +680,7 @@ static ufsm_status_t ufsm_process_junction(struct ufsm_machine* m, void ufsm_update_defer_queue(struct ufsm_machine* m) { ufsm_status_t err = UFSM_OK; - uint32_t ev; + event_t ev; do { @@ -909,7 +909,7 @@ ufsm_status_t ufsm_find_active_regions(struct ufsm_machine* m, uint32_t* c) bool ufsm_transition(struct ufsm_machine* m, struct ufsm_region* r, - int32_t ev, + event_t ev, bool* state_transitioned) { bool event_consumed = false; @@ -943,7 +943,7 @@ bool ufsm_transition(struct ufsm_machine* m, return event_consumed; } -ufsm_status_t ufsm_process(struct ufsm_machine* m, int32_t ev) +ufsm_status_t ufsm_process(struct ufsm_machine* m, event_t ev) { ufsm_status_t err = UFSM_OK; uint32_t region_count = 0; diff --git a/src/ufsm.h b/src/ufsm.h index 3260123..6fcc64a 100644 --- a/src/ufsm.h +++ b/src/ufsm.h @@ -31,6 +31,7 @@ enum ufsm_status_codes }; typedef enum ufsm_status_codes ufsm_status_t; +typedef int32_t event_t; extern const char* ufsm_errors[]; @@ -76,7 +77,7 @@ typedef void (*ufsm_doact_func_t)(struct ufsm_machine* m, ufsm_doact_cb_t cb); /* Debug callbacks */ -typedef void (*ufsm_debug_event_t)(uint32_t ev); +typedef void (*ufsm_debug_event_t)(event_t ev); typedef void (*ufsm_debug_transition_t)(struct ufsm_transition* t); typedef void (*ufsm_debug_enter_region_t)(struct ufsm_region* region); typedef void (*ufsm_debug_leave_region_t)(struct ufsm_region* region); @@ -120,13 +121,17 @@ struct ufsm_stack uint32_t pos; }; -struct ufsm_queue -{ +struct ufsm_queue_data_t { + event_t ev; + void *data; +}; + +struct ufsm_queue { uint32_t no_of_elements; uint32_t s; uint32_t head; uint32_t tail; - uint32_t* data; + struct ufsm_queue_data_t *data; ufsm_queue_cb_t on_data; ufsm_queue_cb_t lock; ufsm_queue_cb_t unlock; @@ -147,10 +152,10 @@ struct ufsm_machine ufsm_debug_reset_t debug_reset; bool terminated; - void* stack_data[UFSM_STACK_SIZE]; - void* completion_stack_data[UFSM_COMPLETION_STACK_SIZE]; - uint32_t queue_data[UFSM_QUEUE_SIZE]; - uint32_t defer_queue_data[UFSM_DEFER_QUEUE_SIZE]; + void *stack_data[UFSM_STACK_SIZE]; + void *completion_stack_data[UFSM_COMPLETION_STACK_SIZE]; + struct ufsm_queue_data_t queue_data[UFSM_QUEUE_SIZE]; + struct ufsm_queue_data_t defer_queue_data[UFSM_DEFER_QUEUE_SIZE]; struct ufsm_queue queue; struct ufsm_queue defer_queue; @@ -238,21 +243,22 @@ struct ufsm_state struct ufsm_state* next; }; -ufsm_status_t ufsm_init_machine(struct ufsm_machine* m); -ufsm_status_t ufsm_reset_machine(struct ufsm_machine* m); -ufsm_status_t ufsm_process(struct ufsm_machine* m, int32_t ev); -ufsm_status_t ufsm_stack_init(struct ufsm_stack* stack, - uint32_t no_of_elements, - void** stack_data); -ufsm_status_t ufsm_stack_push(struct ufsm_stack* stack, void* item); -ufsm_status_t ufsm_stack_pop(struct ufsm_stack* stack, void** item); - -ufsm_status_t ufsm_queue_init(struct ufsm_queue* q, - uint32_t no_of_elements, - uint32_t* data); - -ufsm_status_t ufsm_queue_put(struct ufsm_queue* q, uint32_t ev); -ufsm_status_t ufsm_queue_get(struct ufsm_queue* q, uint32_t* ev); -struct ufsm_queue* ufsm_get_queue(struct ufsm_machine* m); +ufsm_status_t ufsm_init_machine(struct ufsm_machine *m); +ufsm_status_t ufsm_reset_machine(struct ufsm_machine *m); +ufsm_status_t ufsm_process (struct ufsm_machine *m, event_t ev); +ufsm_status_t ufsm_stack_init(struct ufsm_stack *stack, + uint32_t no_of_elements, + void **stack_data); +ufsm_status_t ufsm_stack_push(struct ufsm_stack *stack, void *item); +ufsm_status_t ufsm_stack_pop(struct ufsm_stack *stack, void **item); + +ufsm_status_t ufsm_queue_init(struct ufsm_queue *q, uint32_t no_of_elements, + struct ufsm_queue_data_t *data); + +ufsm_status_t ufsm_queue_put(struct ufsm_queue *q, event_t ev); +ufsm_status_t ufsm_queue_get(struct ufsm_queue *q, event_t *ev); +ufsm_status_t ufsm_queue_put2(struct ufsm_queue *q, event_t ev, void *data); +ufsm_status_t ufsm_queue_get2(struct ufsm_queue *q, event_t *ev, void **data); +struct ufsm_queue * ufsm_get_queue(struct ufsm_machine *m); #endif diff --git a/src/ufsm_queue.c b/src/ufsm_queue.c index 93979ba..0cb218e 100644 --- a/src/ufsm_queue.c +++ b/src/ufsm_queue.c @@ -4,21 +4,22 @@ * Copyright (C) 2018 Jonas Persson * * SPDX-License-Identifier: BSD-3-Clause + * */ #include -uint32_t ufsm_queue_put(struct ufsm_queue* q, uint32_t ev) +static ufsm_status_t _ufsm_queue_put(struct ufsm_queue *q, event_t ev, void *data) { - uint32_t err = UFSM_OK; + ufsm_status_t err = UFSM_OK; if (q->lock) q->lock(); - if (q->s < q->no_of_elements) - { - q->data[q->head] = ev; + if (q->s < q->no_of_elements) { + q->data[q->head].ev = ev; + q->data[q->head].data = data; q->s++; q->head++; @@ -39,16 +40,17 @@ uint32_t ufsm_queue_put(struct ufsm_queue* q, uint32_t ev) return err; } -uint32_t ufsm_queue_get(struct ufsm_queue* q, uint32_t* ev) +static ufsm_status_t _ufsm_queue_get(struct ufsm_queue *q, event_t *ev, void **data) { - uint32_t err = UFSM_OK; + ufsm_status_t err = UFSM_OK; if (q->lock) q->lock(); - if (q->s) - { - *ev = q->data[q->tail]; + if (q->s) { + *ev = q->data[q->tail].ev; + if (data != NULL) + *data = q->data[q->tail].data; q->s--; q->tail++; @@ -66,9 +68,28 @@ uint32_t ufsm_queue_get(struct ufsm_queue* q, uint32_t* ev) return err; } -uint32_t ufsm_queue_init(struct ufsm_queue* q, - uint32_t no_of_elements, - uint32_t* data) +ufsm_status_t ufsm_queue_put(struct ufsm_queue *q, event_t ev) +{ + return _ufsm_queue_put(q, ev, NULL); +} + +ufsm_status_t ufsm_queue_get(struct ufsm_queue *q, event_t *ev) +{ + return _ufsm_queue_get(q, ev, NULL); +} + +ufsm_status_t ufsm_queue_put2(struct ufsm_queue *q, event_t ev, void *data) +{ + return _ufsm_queue_put(q, ev, data); +} + +ufsm_status_t ufsm_queue_get2(struct ufsm_queue *q, event_t *ev, void **data) +{ + return _ufsm_queue_get(q, ev, data); +} + +ufsm_status_t ufsm_queue_init(struct ufsm_queue *q, uint32_t no_of_elements, + struct ufsm_queue_data_t *data) { q->head = 0; q->tail = 0;