modes.h

Go to the documentation of this file.

 
#ifndef MODES_H
#define MODES_H
 
#ifdef MODAL_REACTORS
 
#include <stddef.h>
#include <stdbool.h>
 
#include "lf_types.h"
#include "tag.h"
 
typedef struct event_t event_t;
typedef struct reaction_t reaction_t;
typedef struct trigger_t trigger_t;
 
 
#define _LF_SET_MODE_WITH_TYPE(mode, change_type)                                                                      \
  do {                                                                                                                 \
    ((self_base_t*)self)->_lf__mode_state.next_mode = mode;                                                            \
    ((self_base_t*)self)->_lf__mode_state.mode_change = change_type;                                                   \
  } while (0)
 
 
typedef struct reactor_mode_t reactor_mode_t;
typedef struct reactor_mode_state_t reactor_mode_state_t;
typedef struct mode_state_variable_reset_data_t mode_state_variable_reset_data_t;
 
typedef enum { no_transition, reset_transition, history_transition } lf_mode_change_type_t;
 
struct reactor_mode_t {
  reactor_mode_state_t* state; // Pointer to a struct with the reactor's mode state. INSTANCE.
  char* name;                  // Name of this mode.
  instant_t deactivation_time; // Time when the mode was left.
  uint8_t flags;               // Bit vector for several internal flags related to the mode.
};
 
struct reactor_mode_state_t {
  reactor_mode_t* parent_mode;       // Pointer to the next enclosing mode (if exists).
  reactor_mode_t* initial_mode;      // Pointer to the initial mode.
  reactor_mode_t* current_mode;      // Pointer to the currently active mode (only locally active).
  reactor_mode_t* next_mode;         // Pointer to the next mode to activate at the end of this step (if set).
  lf_mode_change_type_t mode_change; // A mode change type flag.
};
struct mode_state_variable_reset_data_t {
  reactor_mode_t* mode; // Pointer to the enclosing mode.
  void* target;         // Pointer to the target variable.
  void* source;         // Pointer to the data source.
  size_t size;          // The size of the variable.
};
 
typedef struct environment_t environment_t;
 
void _lf_initialize_modes(environment_t* env);
void _lf_handle_mode_changes(environment_t* env);
void _lf_handle_mode_triggered_reactions(environment_t* env);
bool _lf_mode_is_active(reactor_mode_t* mode);
void _lf_initialize_mode_states(environment_t* env, reactor_mode_state_t* states[], int states_size);
void _lf_process_mode_changes(environment_t* env, reactor_mode_state_t* states[], int states_size,
                              mode_state_variable_reset_data_t reset_data[], int reset_data_size,
                              trigger_t* timer_triggers[], int timer_triggers_size);
void _lf_add_suspended_event(event_t* event);
void _lf_handle_mode_startup_reset_reactions(environment_t* env, reaction_t** startup_reactions,
                                             int startup_reactions_size, reaction_t** reset_reactions,
                                             int reset_reactions_size, reactor_mode_state_t* states[], int states_size);
void _lf_handle_mode_shutdown_reactions(environment_t* env, reaction_t** shutdown_reactions,
                                        int shutdown_reactions_size);
void _lf_terminate_modal_reactors(environment_t* env);
 
#else  /* IF NOT MODAL_REACTORS */
/*
 * Reactions and triggers must have a mode pointer to set up connection to enclosing modes,
 * also when they are precompiled without modal reactors in order to later work in modal reactors.
 * Hence define mode type as void in the absence of modes to treat mode pointer as void pointers for that time being.
 */
typedef void reactor_mode_t;
#endif /* MODAL_REACTORS */
#endif /* MODES_H */