Several smaller fixes and improvements after porting Polulu robot to uc (#154)

* Fix the preamble generator

* Also test imported preambles

* Fix scoping

* Update macros

* Add support for inheritance

* Also collect prembles in suport type

* Fix preamble include system

* Formatting

* Rmove STDC_FORMAT_MACROS define

* Minor fixes

* Port deadline macros to new system

* Also add support for main reactor with parameters

* Formatting

* Native platform for Deadline.lf

* Add a couple of target properties and add interleaved connections

* support both bank_idx and bank_indxe

* Fix

Author: erlingrj

benchmarks/src/PingPongUc.lf

@@ -19,6 +19,7 @@
  * @author Edward A. Lee
  */
  target uC {
+  platform: Native,
   fast: true,
   build-type: Release
 }
@@ -32,9 +33,6 @@ reactor Ping(count: size_t = 1000000) {
   output finished: bool
   state pingsLeft: size_t = count
   logical action serve
-  reaction(startup) {=
-    self->pingsLeft = self->count;
-  =}
 
   reaction(start, serve) -> send {=
     lf_set(send, self->pingsLeft--);

benchmarks/src/ReactionLatencyUc.lf

@@ -1,5 +1,6 @@
 target uC {
-  build-type: Release
+  build-type: Release,
+  platform: Native,
 }
 
 

examples/common/timer_source.h

@@ -1,24 +1,24 @@
 #include "reactor-uc/reactor-uc.h"
 
-DEFINE_TIMER_STRUCT(TimerSource, t, 1, 0);
-DEFINE_TIMER_CTOR(TimerSource, t, 1, 0);
-DEFINE_REACTION_STRUCT(TimerSource, r, 0);
-DEFINE_REACTION_CTOR(TimerSource, r, 0);
+LF_DEFINE_TIMER_STRUCT(TimerSource, t, 1, 0);
+LF_DEFINE_TIMER_CTOR(TimerSource, t, 1, 0);
+LF_DEFINE_REACTION_STRUCT(TimerSource, r, 0);
+LF_DEFINE_REACTION_CTOR(TimerSource, r, 0);
 
 typedef struct {
   Reactor super;
-  TIMER_INSTANCE(TimerSource, t);
-  REACTION_INSTANCE(TimerSource, r);
-  REACTOR_BOOKKEEPING_INSTANCES(1,1,0);
+  LF_TIMER_INSTANCE(TimerSource, t);
+  LF_REACTION_INSTANCE(TimerSource, r);
+  LF_REACTOR_BOOKKEEPING_INSTANCES(1,1,0);
 } TimerSource;
 
 
-REACTOR_CTOR_SIGNATURE(TimerSource) {
-  REACTOR_CTOR_PREAMBLE();
-  REACTOR_CTOR(TimerSource);
-  INITIALIZE_REACTION(TimerSource, r);
-  INITIALIZE_TIMER(TimerSource, t, MSEC(0), MSEC(500));
-  TIMER_REGISTER_EFFECT(self->t, self->r);
+LF_REACTOR_CTOR_SIGNATURE(TimerSource) {
+  LF_REACTOR_CTOR_PREAMBLE();
+  LF_REACTOR_CTOR(TimerSource);
+  LF_INITIALIZE_REACTION(TimerSource, r);
+  LF_INITIALIZE_TIMER(TimerSource, t, MSEC(0), MSEC(500));
+  LF_TIMER_REGISTER_EFFECT(self->t, self->r);
 }
 
-ENTRY_POINT(TimerSource, SEC(1), false, false);
+LF_ENTRY_POINT(TimerSource, SEC(1), false, false);

examples/flexpret/CMakeLists.txt

@@ -14,8 +14,8 @@ project(fp-lf)
 include(src-gen/Smoke/CMakeLists.txt)
 add_subdirectory(${REACTOR_UC_PATH})
 
-add_executable(fp-smoke main.c ${LF_SOURCES})
+add_executable(fp-smoke main.c ${LFC_GEN_SOURCES})
 target_link_libraries(fp-smoke PUBLIC reactor-uc)
-target_include_directories(fp-smoke PRIVATE ${LF_INCLUDE_DIRS})
+target_include_directories(fp-smoke PRIVATE ${LFC_GEN_INCLUDE_DIRS})
 
 fp_add_outputs(fp-smoke)

examples/pico/blinky.c

@@ -37,9 +37,9 @@ void pico_toggle_led() {
 #endif
 }
 
-DEFINE_REACTION_BODY(TimerSource, r) {
-  SCOPE_SELF(TimerSource);
-  SCOPE_ENV();
+LF_DEFINE_REACTION_BODY(TimerSource, r) {
+  LF_SCOPE_SELF(TimerSource);
+  LF_SCOPE_ENV();
   printf("Hello World @ %lld\n", env->get_elapsed_logical_time(env));
   pico_toggle_led();
 }

examples/posix/federated/receiver.c

@@ -19,71 +19,71 @@ lf_ret_t deserialize_msg_t(void *user_struct, const unsigned char *msg_buf, size
   return LF_OK;
 }
 
-DEFINE_REACTION_STRUCT(Receiver, r, 0);
-DEFINE_REACTION_CTOR(Receiver, r, 0);
-DEFINE_INPUT_STRUCT(Receiver, in, 1, 0, msg_t, 0);
-DEFINE_INPUT_CTOR(Receiver, in, 1, 0, msg_t, 0);
+LF_DEFINE_REACTION_STRUCT(Receiver, r, 0);
+LF_DEFINE_REACTION_CTOR(Receiver, r, 0);
+LF_DEFINE_INPUT_STRUCT(Receiver, in, 1, 0, msg_t, 0);
+LF_DEFINE_INPUT_CTOR(Receiver, in, 1, 0, msg_t, 0);
 
 typedef struct {
   Reactor super;
-  REACTION_INSTANCE(Receiver, r);
-  PORT_INSTANCE(Receiver, in, 1);
+  LF_REACTION_INSTANCE(Receiver, r);
+  LF_PORT_INSTANCE(Receiver, in, 1);
   int cnt;
-  REACTOR_BOOKKEEPING_INSTANCES(1, 1, 0);
+  LF_REACTOR_BOOKKEEPING_INSTANCES(1, 1, 0);
 } Receiver;
 
-DEFINE_REACTION_BODY(Receiver, r) {
-  SCOPE_SELF(Receiver);
-  SCOPE_ENV();
-  SCOPE_PORT(Receiver, in);
+LF_DEFINE_REACTION_BODY(Receiver, r) {
+  LF_SCOPE_SELF(Receiver);
+  LF_SCOPE_ENV();
+  LF_SCOPE_PORT(Receiver, in);
   printf("Input triggered @ %" PRId64 " with %s size %d\n", env->get_elapsed_logical_time(env), in->value.msg,
          in->value.size);
 }
 
-REACTOR_CTOR_SIGNATURE_WITH_PARAMETERS(Receiver, InputExternalCtorArgs *in_external) {
-  REACTOR_CTOR_PREAMBLE();
-  REACTOR_CTOR(Receiver);
-  INITIALIZE_REACTION(Receiver, r);
-  INITIALIZE_INPUT(Receiver, in, 1, in_external);
+LF_REACTOR_CTOR_SIGNATURE_WITH_PARAMETERS(Receiver, InputExternalCtorArgs *in_external) {
+  LF_REACTOR_CTOR_PREAMBLE();
+  LF_REACTOR_CTOR(Receiver);
+  LF_INITIALIZE_REACTION(Receiver, r);
+  LF_INITIALIZE_INPUT(Receiver, in, 1, in_external);
 
   // Register reaction as an effect of in
-  PORT_REGISTER_EFFECT(self->in, self->r, 1);
+  LF_PORT_REGISTER_EFFECT(self->in, self->r, 1);
 }
 
-DEFINE_FEDERATED_INPUT_CONNECTION(Receiver, in, msg_t, 5, MSEC(100), false);
+LF_DEFINE_FEDERATED_INPUT_CONNECTION(Receiver, in, msg_t, 5, MSEC(100), false);
 
 typedef struct {
   FederatedConnectionBundle super;
   TcpIpChannel channel;
-  FEDERATED_INPUT_CONNECTION_INSTANCE(Receiver, in);
-  FEDERATED_CONNECTION_BUNDLE_BOOKKEEPING_INSTANCES(1, 0)
-} FEDERATED_CONNECTION_BUNDLE_NAME(Receiver, Sender);
+  LF_FEDERATED_INPUT_CONNECTION_INSTANCE(Receiver, in);
+  LF_FEDERATED_CONNECTION_BUNDLE_BOOKKEEPING_INSTANCES(1,0)
+} LF_FEDERATED_CONNECTION_BUNDLE_NAME(Receiver, Sender);
 
-FEDERATED_CONNECTION_BUNDLE_CTOR_SIGNATURE(Receiver, Sender) {
-  FEDERATED_CONNECTION_BUNDLE_CTOR_PREAMBLE();
+LF_FEDERATED_CONNECTION_BUNDLE_CTOR_SIGNATURE(Receiver, Sender) {
+  LF_FEDERATED_CONNECTION_BUNDLE_CTOR_PREAMBLE();
   TcpIpChannel_ctor(&self->channel, parent->env, "127.0.0.1", PORT_NUM, AF_INET, false);
-  FEDERATED_CONNECTION_BUNDLE_CALL_CTOR();
-  INITIALIZE_FEDERATED_INPUT_CONNECTION(Receiver, in, deserialize_msg_t);
+  LF_FEDERATED_CONNECTION_BUNDLE_CALL_CTOR();
+  LF_INITIALIZE_FEDERATED_INPUT_CONNECTION(Receiver, in, deserialize_msg_t);
 }
 
 typedef struct {
   Reactor super;
-  CHILD_REACTOR_INSTANCE(Receiver, receiver, 1);
-  FEDERATED_CONNECTION_BUNDLE_INSTANCE(Receiver, Sender);
-  FEDERATE_BOOKKEEPING_INSTANCES(1);
-  CHILD_INPUT_SOURCES(receiver, in, 1, 1, 0);
+  LF_CHILD_REACTOR_INSTANCE(Receiver, receiver, 1);
+  LF_FEDERATED_CONNECTION_BUNDLE_INSTANCE(Receiver, Sender);
+  LF_FEDERATE_BOOKKEEPING_INSTANCES(1);
+  LF_CHILD_INPUT_SOURCES(receiver, in, 1, 1, 0);
 } MainRecv;
 
-REACTOR_CTOR_SIGNATURE(MainRecv) {
-  FEDERATE_CTOR_PREAMBLE();
-  REACTOR_CTOR(MainRecv);
-  DEFINE_CHILD_INPUT_ARGS(receiver, in, 1, 1);
-  INITIALIZE_CHILD_REACTOR_WITH_PARAMETERS(Receiver, receiver, 1, _receiver_in_args[i]);
-  INITIALIZE_FEDERATED_CONNECTION_BUNDLE(Receiver, Sender);
-  BUNDLE_REGISTER_DOWNSTREAM(Receiver, Sender, receiver, in);
+LF_REACTOR_CTOR_SIGNATURE(MainRecv) {
+  LF_FEDERATE_CTOR_PREAMBLE();
+  LF_REACTOR_CTOR(MainRecv);
+  LF_DEFINE_CHILD_INPUT_ARGS(receiver, in, 1, 1);
+  LF_INITIALIZE_CHILD_REACTOR_WITH_PARAMETERS(Receiver, receiver, 1, _receiver_in_args[i]);
+  LF_INITIALIZE_FEDERATED_CONNECTION_BUNDLE(Receiver, Sender);
+  LF_BUNDLE_REGISTER_DOWNSTREAM(Receiver, Sender, receiver, in);
 }
 
-ENTRY_POINT_FEDERATED(MainRecv, SEC(1), true, true, 1, false)
+LF_ENTRY_POINT_FEDERATED(MainRecv, SEC(1), true, true, 1, false)
 
 int main() {
   lf_start();

examples/posix/federated/sender.c

@@ -21,25 +21,25 @@ size_t serialize_msg_t(const void *user_struct, size_t user_struct_size, unsigne
   return sizeof(msg->size) + msg->size;
 }
 
-DEFINE_TIMER_STRUCT(Sender, t, 1, 0)
-DEFINE_TIMER_CTOR(Sender, t, 1, 0)
-DEFINE_REACTION_STRUCT(Sender, r, 1)
-DEFINE_REACTION_CTOR(Sender, r, 0)
-DEFINE_OUTPUT_STRUCT(Sender, out, 1, msg_t)
-DEFINE_OUTPUT_CTOR(Sender, out, 1)
+LF_DEFINE_TIMER_STRUCT(Sender, t, 1, 0)
+LF_DEFINE_TIMER_CTOR(Sender, t, 1, 0)
+LF_DEFINE_REACTION_STRUCT(Sender, r, 1)
+LF_DEFINE_REACTION_CTOR(Sender, r, 0)
+LF_DEFINE_OUTPUT_STRUCT(Sender, out, 1, msg_t)
+LF_DEFINE_OUTPUT_CTOR(Sender, out, 1)  
 
 typedef struct {
   Reactor super;
-  TIMER_INSTANCE(Sender, t);
-  REACTION_INSTANCE(Sender, r);
-  PORT_INSTANCE(Sender, out, 1);
-  REACTOR_BOOKKEEPING_INSTANCES(1, 2, 0);
+  LF_TIMER_INSTANCE(Sender, t);
+  LF_REACTION_INSTANCE(Sender, r);
+  LF_PORT_INSTANCE(Sender, out, 1);
+  LF_REACTOR_BOOKKEEPING_INSTANCES(1, 2, 0);
 } Sender;
 
-DEFINE_REACTION_BODY(Sender, r) {
-  SCOPE_SELF(Sender);
-  SCOPE_ENV();
-  SCOPE_PORT(Sender, out);
+LF_DEFINE_REACTION_BODY(Sender, r) {
+  LF_SCOPE_SELF(Sender);
+  LF_SCOPE_ENV();
+  LF_SCOPE_PORT(Sender, out);
 
   printf("Timer triggered @ %" PRId64 "\n", env->get_elapsed_logical_time(env));
   msg_t val;
@@ -48,55 +48,55 @@ DEFINE_REACTION_BODY(Sender, r) {
   lf_set(out, val);
 }
 
-REACTOR_CTOR_SIGNATURE_WITH_PARAMETERS(Sender, OutputExternalCtorArgs *out_external) {
-  REACTOR_CTOR_PREAMBLE();
-  REACTOR_CTOR(Sender);
-  INITIALIZE_REACTION(Sender, r);
-  INITIALIZE_TIMER(Sender, t, MSEC(0), SEC(1));
-  INITIALIZE_OUTPUT(Sender, out, 1, out_external);
+LF_REACTOR_CTOR_SIGNATURE_WITH_PARAMETERS(Sender, OutputExternalCtorArgs *out_external) {
+  LF_REACTOR_CTOR_PREAMBLE();
+  LF_REACTOR_CTOR(Sender);
+  LF_INITIALIZE_REACTION(Sender, r);
+  LF_INITIALIZE_TIMER(Sender, t, MSEC(0), SEC(1));
+  LF_INITIALIZE_OUTPUT(Sender, out, 1, out_external);
 
-  TIMER_REGISTER_EFFECT(self->t, self->r);
-  PORT_REGISTER_SOURCE(self->out, self->r, 1);
+  LF_TIMER_REGISTER_EFFECT(self->t, self->r);
+  LF_PORT_REGISTER_SOURCE(self->out, self->r, 1);
 }
 
-DEFINE_FEDERATED_OUTPUT_CONNECTION(Sender, out, msg_t, 1)
+LF_DEFINE_FEDERATED_OUTPUT_CONNECTION(Sender, out, msg_t, 1)
 
 typedef struct {
   FederatedConnectionBundle super;
   TcpIpChannel channel;
-  FEDERATED_OUTPUT_CONNECTION_INSTANCE(Sender, out);
-  FEDERATED_CONNECTION_BUNDLE_BOOKKEEPING_INSTANCES(0, 1);
-} FEDERATED_CONNECTION_BUNDLE_NAME(Sender, Receiver);
+  LF_FEDERATED_OUTPUT_CONNECTION_INSTANCE(Sender, out);
+  LF_FEDERATED_CONNECTION_BUNDLE_BOOKKEEPING_INSTANCES(0, 1);
+} LF_FEDERATED_CONNECTION_BUNDLE_NAME(Sender, Receiver);
 
-FEDERATED_CONNECTION_BUNDLE_CTOR_SIGNATURE(Sender, Receiver) {
-  FEDERATED_CONNECTION_BUNDLE_CTOR_PREAMBLE();
+LF_FEDERATED_CONNECTION_BUNDLE_CTOR_SIGNATURE(Sender, Receiver) {
+  LF_FEDERATED_CONNECTION_BUNDLE_CTOR_PREAMBLE();
   TcpIpChannel_ctor(&self->channel, parent->env, "127.0.0.1", PORT_NUM, AF_INET, true);
 
-  FEDERATED_CONNECTION_BUNDLE_CALL_CTOR();
-
-  INITIALIZE_FEDERATED_OUTPUT_CONNECTION(Sender, out, serialize_msg_t);
+  LF_FEDERATED_CONNECTION_BUNDLE_CALL_CTOR();
+  
+  LF_INITIALIZE_FEDERATED_OUTPUT_CONNECTION(Sender, out, serialize_msg_t);
 }
 
 // Reactor main
 typedef struct {
   Reactor super;
-  CHILD_REACTOR_INSTANCE(Sender, sender, 1);
-  FEDERATED_CONNECTION_BUNDLE_INSTANCE(Sender, Receiver);
-  FEDERATE_BOOKKEEPING_INSTANCES(1);
-  CHILD_OUTPUT_CONNECTIONS(sender, out, 1, 1, 1);
-  CHILD_OUTPUT_EFFECTS(sender, out, 1, 1, 0);
-  CHILD_OUTPUT_OBSERVERS(sender, out, 1, 1, 0);
+  LF_CHILD_REACTOR_INSTANCE(Sender, sender, 1);
+  LF_FEDERATED_CONNECTION_BUNDLE_INSTANCE(Sender, Receiver);
+  LF_FEDERATE_BOOKKEEPING_INSTANCES(1);
+  LF_CHILD_OUTPUT_CONNECTIONS(sender, out, 1, 1, 1);
+  LF_CHILD_OUTPUT_EFFECTS(sender, out, 1, 1, 0);
+  LF_CHILD_OUTPUT_OBSERVERS(sender, out, 1, 1, 0);
 } MainSender;
 
-REACTOR_CTOR_SIGNATURE(MainSender) {
-  FEDERATE_CTOR_PREAMBLE();
-  DEFINE_CHILD_OUTPUT_ARGS(sender, out, 1, 1);
-  INITIALIZE_CHILD_REACTOR_WITH_PARAMETERS(Sender, sender, 1, _sender_out_args[i]);
-  INITIALIZE_FEDERATED_CONNECTION_BUNDLE(Sender, Receiver);
-  BUNDLE_REGISTER_UPSTREAM(Sender, Receiver, sender, out);
-  REACTOR_CTOR(MainSender);
+LF_REACTOR_CTOR_SIGNATURE(MainSender) {
+  LF_FEDERATE_CTOR_PREAMBLE();
+  LF_DEFINE_CHILD_OUTPUT_ARGS(sender, out,1,1);
+  LF_INITIALIZE_CHILD_REACTOR_WITH_PARAMETERS(Sender, sender, 1, _sender_out_args[i]);
+  LF_INITIALIZE_FEDERATED_CONNECTION_BUNDLE(Sender, Receiver);
+  LF_BUNDLE_REGISTER_UPSTREAM(Sender, Receiver, sender, out);
+  LF_REACTOR_CTOR(MainSender);
 }
-ENTRY_POINT_FEDERATED(MainSender, SEC(1), true, false, 1, true)
+LF_ENTRY_POINT_FEDERATED(MainSender, SEC(1), true, false, 1, true)
 
 int main() {
   lf_start();

examples/posix/hello/hello.c

@@ -1,9 +1,9 @@
 #include "reactor-uc/reactor-uc.h"
 #include "../../common/timer_source.h" 
 
-DEFINE_REACTION_BODY(TimerSource, r) {
-  SCOPE_SELF(TimerSource);
-  SCOPE_ENV();
+LF_DEFINE_REACTION_BODY(TimerSource, r) {
+  LF_SCOPE_SELF(TimerSource);
+  LF_SCOPE_ENV();
   printf("TimerSource World @ %lld\n", env->get_elapsed_logical_time(env));
 }
 

examples/riot/blinky/main.c

@@ -4,9 +4,9 @@
 #include "../../common/timer_source.h"
 
 
-DEFINE_REACTION_BODY(TimerSource, r) {
-  SCOPE_SELF(TimerSource);
-  SCOPE_ENV();
+LF_DEFINE_REACTION_BODY(TimerSource, r) {
+  LF_SCOPE_SELF(TimerSource);
+  LF_SCOPE_ENV();
   printf("Hello World @ %lld\n", env->get_elapsed_logical_time(env));
   LED0_TOGGLE;
 }

examples/riot/hello/main.c

@@ -2,9 +2,9 @@
 
 #include "../../common/timer_source.h" 
 
-DEFINE_REACTION_BODY(TimerSource, r) {
-  SCOPE_SELF(TimerSource);
-  SCOPE_ENV();
+LF_DEFINE_REACTION_BODY(TimerSource, r) {
+  LF_SCOPE_SELF(TimerSource);
+  LF_SCOPE_ENV();
   printf("TimerSource World @ %lld\n", env->get_elapsed_logical_time(env));
 }