reaction_macros.h

Go to the documentation of this file.

 
// Prevent inclusion twice in a row without an intervening inclusion of reaction_macros_undef.h.
#ifndef REACTION_MACROS_H
#define REACTION_MACROS_H
 
// NOTE: According to the "Swallowing the Semicolon" section on this page:
//    https://gcc.gnu.org/onlinedocs/gcc-3.0.1/cpp_3.html
// some of the following macros should use an odd do-while construct to avoid
// problems with if ... else statements that do not use braces around the
// two branches. Specifically, if the macro expands to more than one statement,
// then the odd construct is needed.

#define lf_set_present(out) lf_set_present((lf_port_base_t*)out)

#define lf_set(out, val)                                                                                               \
  do {                                                                                                                 \
    out->value = val;                                                                                                  \
    lf_set_present(out);                                                                                               \
    if (((token_template_t*)out)->token != NULL) {                                                                     \
      /* The cast "*((void**) &out->value)" is a hack to make the code */                                              \
      /* compile with non-token types where value is not a pointer. */                                                 \
      lf_token_t* token = _lf_initialize_token_with_value((token_template_t*)out, *((void**)&out->value), 1);          \
      out->token = token;                                                                                              \
    }                                                                                                                  \
  } while (0)

#ifndef __cplusplus
#define lf_set_array(out, val, len)                                                                                    \
  do {                                                                                                                 \
    lf_set_present(out);                                                                                               \
    lf_token_t* token = _lf_initialize_token_with_value((token_template_t*)out, val, len);                             \
    out->token = token;                                                                                                \
    out->value = token->value;                                                                                         \
    out->length = len;                                                                                                 \
  } while (0)
#else
#define lf_set_array(out, val, len)                                                                                    \
  do {                                                                                                                 \
    lf_set_present(out);                                                                                               \
    lf_token_t* token = _lf_initialize_token_with_value((token_template_t*)out, val, len);                             \
    out->token = token;                                                                                                \
    out->value = static_cast<decltype(out->value)>(token->value);                                                      \
    out->length = len;                                                                                                 \
  } while (0)
#endif

#ifndef __cplusplus
#define lf_set_token(out, newtoken)                                                                                    \
  do {                                                                                                                 \
    lf_set_present(out);                                                                                               \
    _lf_replace_template_token((token_template_t*)out, newtoken);                                                      \
    out->value = newtoken->value;                                                                                      \
    out->length = newtoken->length;                                                                                    \
  } while (0)
#else
#define lf_set_token(out, newtoken)                                                                                    \
  do {                                                                                                                 \
    lf_set_present(out);                                                                                               \
    _lf_replace_template_token((token_template_t*)out, newtoken);                                                      \
    out->value = static_cast<decltype(out->value)>(newtoken->value);                                                   \
    out->length = newtoken->length;                                                                                    \
  } while (0)
#endif

#define lf_set_destructor(out, dtor) ((token_type_t*)out)->destructor = dtor

#define lf_set_copy_constructor(out, cpy_ctor) ((token_type_t*)out)->copy_constructor = cpy_ctor
 
#ifdef MODAL_REACTORS

#define lf_set_mode(mode) _LF_SET_MODE_WITH_TYPE(mode, _lf_##mode##_change_type)
 
#endif // MODAL_REACTORS

// For simplicity and backward compatability, don't require the environment-pointer when calling the timing API.
// As long as this is done from the context of a reaction, `self` is in scope and is a pointer to the self-struct
// of the current reactor.

#define lf_tag() lf_tag(self->base.environment)

#define lf_time_logical() lf_time_logical(self->base.environment)

#define lf_time_logical_elapsed() lf_time_logical_elapsed(self->base.environment)

#define lf_add_worker_thread() lf_add_worker_thread(self->base.environment)

#define lf_added_worker_thread_count() lf_added_worker_thread_count(self->base.environment)

#define lf_async(action, func, ...)                                                                                    \
  ({                                                                                                                   \
    lf_async_state_t _lf_async_state;                                                                                  \
    _lf_async_begin(&_lf_async_state, self, (action), NULL);                                                           \
    __typeof__(func(__VA_ARGS__)) _lf_async_result = func(__VA_ARGS__);                                                \
    _lf_async_end(&_lf_async_state);                                                                                   \
    _lf_async_result;                                                                                                  \
  })

#define lf_await(port) _lf_await(self, (port))

#define lf_await_resume(port) _lf_await_resume(self, (port))

#define lf_reactor_name(reactor) lf_reactor_name(&reactor->base)

#define lf_reactor_full_name(reactor) lf_reactor_full_name(&reactor->base)
 
#endif // REACTION_MACROS_H