include/rv/automata.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Copyright (C) 2019-2022 Red Hat, Inc. Daniel Bristot de Oliveira  <bristot@kernel.org>
   4  *
   5  * Deterministic automata helper functions, to be used with the automata
   6  * models in C generated by the dot2k tool.
   7  */
   8
   9 /*
  10  * DECLARE_AUTOMATA_HELPERS - define a set of helper functions for automata
  11  *
  12  * Define a set of helper functions for automata. The 'name' argument is used
  13  * as suffix for the functions and data. These functions will handle automaton
  14  * with data type 'type'.
  15  */
  16 #define DECLARE_AUTOMATA_HELPERS(name, type)                                    \
  17                                                                                 \
  18 /*                                                                              \
  19  * model_get_state_name_##name - return the (string) name of the given state    \
  20  */                                                                             \
  21 static char *model_get_state_name_##name(enum states_##name state)              \
  22 {                                                                               \
  23         if ((state < 0) || (state >= state_max_##name))                         \
  24                 return "INVALID";                                               \
  25                                                                                 \
  26         return automaton_##name.state_names[state];                             \
  27 }                                                                               \
  28                                                                                 \
  29 /*                                                                              \
  30  * model_get_event_name_##name - return the (string) name of the given event    \
  31  */                                                                             \
  32 static char *model_get_event_name_##name(enum events_##name event)              \
  33 {                                                                               \
  34         if ((event < 0) || (event >= event_max_##name))                         \
  35                 return "INVALID";                                               \
  36                                                                                 \
  37         return automaton_##name.event_names[event];                             \
  38 }                                                                               \
  39                                                                                 \
  40 /*                                                                              \
  41  * model_get_initial_state_##name - return the automaton's initial state                \
  42  */                                                                             \
  43 static inline type model_get_initial_state_##name(void)                         \
  44 {                                                                               \
  45         return automaton_##name.initial_state;                                  \
  46 }                                                                               \
  47                                                                                 \
  48 /*                                                                              \
  49  * model_get_next_state_##name - process an automaton event occurrence          \
  50  *                                                                              \
  51  * Given the current state (curr_state) and the event (event), returns          \
  52  * the next state, or INVALID_STATE in case of error.                           \
  53  */                                                                             \
  54 static inline type model_get_next_state_##name(enum states_##name curr_state,   \
  55                                                enum events_##name event)        \
  56 {                                                                               \
  57         if ((curr_state < 0) || (curr_state >= state_max_##name))               \
  58                 return INVALID_STATE;                                           \
  59                                                                                 \
  60         if ((event < 0) || (event >= event_max_##name))                         \
  61                 return INVALID_STATE;                                           \
  62                                                                                 \
  63         return automaton_##name.function[curr_state][event];                    \
  64 }                                                                               \
  65                                                                                 \
  66 /*                                                                              \
  67  * model_is_final_state_##name - check if the given state is a final state      \
  68  */                                                                             \
  69 static inline bool model_is_final_state_##name(enum states_##name state)        \
  70 {                                                                               \
  71         if ((state < 0) || (state >= state_max_##name))                         \
  72                 return 0;                                                       \
  73                                                                                 \
  74         return automaton_##name.final_states[state];                            \
  75 }