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)
 
#endif // REACTION_MACROS_H