C 언어에서 매크로를 활용한 간단한 상태 머신 구현 방법

#define MAX(a, b) ((a) > (b) ? (a) : (b))

  #ifdef DEBUG
  printf("Debug mode enabled\n");
  #endif

#define STATE_IDLE    0
#define STATE_RUNNING 1
#define STATE_PAUSED  2
#define STATE_STOPPED 3

#define STATE_TABLE(STATE) \
    STATE(IDLE)           \
    STATE(RUNNING)        \
    STATE(PAUSED)         \
    STATE(STOPPED)

#define DEFINE_STATE(name) void state_##name(void)
DEFINE_STATE(IDLE) { printf("System is idle\n"); }
DEFINE_STATE(RUNNING) { printf("System is running\n"); }

#define TRANSITION(current, event, next) \
    if (state == current && input == event) { \
        state = next; \
        printf("Transitioning from " #current " to " #next "\n"); \
    }

int state = STATE_IDLE; // 초기 상태
int input = EVENT_START; // 예제 이벤트

void handle_state_transition() {
    TRANSITION(STATE_IDLE, EVENT_START, STATE_RUNNING);
    TRANSITION(STATE_RUNNING, EVENT_PAUSE, STATE_PAUSED);
    TRANSITION(STATE_PAUSED, EVENT_RESUME, STATE_RUNNING);
    TRANSITION(STATE_RUNNING, EVENT_STOP, STATE_STOPPED);
}

#define TRANSITION_TABLE \
    TRANSITION(STATE_IDLE, EVENT_START, STATE_RUNNING) \
    TRANSITION(STATE_RUNNING, EVENT_PAUSE, STATE_PAUSED) \
    TRANSITION(STATE_PAUSED, EVENT_RESUME, STATE_RUNNING) \
    TRANSITION(STATE_RUNNING, EVENT_STOP, STATE_STOPPED)

// 상태 정의
#define STATE_IDLE    0
#define STATE_RUNNING 1
#define STATE_PAUSED  2
#define STATE_STOPPED 3

// 이벤트 정의
#define EVENT_START  0
#define EVENT_PAUSE  1
#define EVENT_RESUME 2
#define EVENT_STOP   3

#define TRANSITION(current, event, next) \
    if (state == current && input == event) { \
        state = next; \
        printf("Transitioned to: " #next "\n"); \
    }

#include <stdio.h>

int main() {
    int state = STATE_IDLE; // 초기 상태
    int input; // 사용자 입력 이벤트

    while (1) {
        printf("Current State: %d\n", state);
        printf("Enter Event (0: Start, 1: Pause, 2: Resume, 3: Stop): ");
        scanf("%d", &input);

        // 상태 전환 규칙
        TRANSITION(STATE_IDLE, EVENT_START, STATE_RUNNING);
        TRANSITION(STATE_RUNNING, EVENT_PAUSE, STATE_PAUSED);
        TRANSITION(STATE_PAUSED, EVENT_RESUME, STATE_RUNNING);
        TRANSITION(STATE_RUNNING, EVENT_STOP, STATE_STOPPED);

        if (state == STATE_STOPPED) {
            printf("State machine stopped.\n");
            break;
        }
    }

    return 0;
}

Current State: 0
Enter Event (0: Start, 1: Pause, 2: Resume, 3: Stop): 0
Transitioned to: STATE_RUNNING
Current State: 1
Enter Event (0: Start, 1: Pause, 2: Resume, 3: Stop): 1
Transitioned to: STATE_PAUSED
Current State: 2
Enter Event (0: Start, 1: Pause, 2: Resume, 3: Stop): 2
Transitioned to: STATE_RUNNING
Current State: 1
Enter Event (0: Start, 1: Pause, 2: Resume, 3: Stop): 3
Transitioned to: STATE_STOPPED
State machine stopped.

#define STATE_TABLE(STATE) \
    STATE(IDLE)            \
    STATE(RUNNING)         \
    STATE(PAUSED)          \
    STATE(STOPPED)         \
    STATE(ERROR)

#define EVENT_TABLE(EVENT) \
    EVENT(START)           \
    EVENT(PAUSE)           \
    EVENT(RESUME)          \
    EVENT(STOP)            \
    EVENT(RESET)

#define DEFINE_ENUM(name) STATE_##name,
typedef enum { STATE_TABLE(DEFINE_ENUM) } State;

#define DEFINE_EVENT_ENUM(name) EVENT_##name,
typedef enum { EVENT_TABLE(DEFINE_EVENT_ENUM) } Event;

typedef struct {
    int currentState;
    int event;
    int nextState;
} Transition;

Transition transitions[] = {
    {STATE_IDLE, EVENT_START, STATE_RUNNING},
    {STATE_RUNNING, EVENT_PAUSE, STATE_PAUSED},
    {STATE_PAUSED, EVENT_RESUME, STATE_RUNNING},
    {STATE_RUNNING, EVENT_STOP, STATE_STOPPED},
    {STATE_STOPPED, EVENT_RESET, STATE_IDLE}
};

#define TRANSITION(current, event, next) \
    if (state == current && input == event) { \
        printf("Transition: %d -> %d (Event: %d)\n", current, next, event); \
        state = next; \
    }

if (state < STATE_IDLE || state > STATE_STOPPED) {
    printf("Error: Invalid state detected\n");
    state = STATE_IDLE; // 복구 로직
}

#ifdef DEBUG
#define DEBUG_LOG(msg) printf("DEBUG: %s\n", msg)
#else
#define DEBUG_LOG(msg)
#endif

void test_state_transition() {
    state = STATE_IDLE;
    input = EVENT_START;
    TRANSITION(STATE_IDLE, EVENT_START, STATE_RUNNING);
    assert(state == STATE_RUNNING);
}

void test_invalid_state() {
    state = -1; // 잘못된 상태
    input = EVENT_START;
    handle_state_transition();
    assert(state == STATE_IDLE); // 복구 상태 확인
}

void run_all_tests() {
    test_state_transition();
    test_invalid_state();
    printf("All tests passed.\n");
}

digraph state_machine {
    IDLE -> RUNNING [label="START"];
    RUNNING -> PAUSED [label="PAUSE"];
    PAUSED -> RUNNING [label="RESUME"];
    RUNNING -> STOPPED [label="STOP"];
}

#define STATE_TABLE(STATE) \
    STATE(OFF)             \
    STATE(ON)              \
    STATE(SLEEP)           \
    STATE(REBOOT)

#define EVENT_TABLE(EVENT) \
    EVENT(POWER_ON)        \
    EVENT(POWER_OFF)       \
    EVENT(TIMEOUT)         \
    EVENT(RESET)

typedef enum { STATE_TABLE(DEFINE_ENUM) } State;
typedef enum { EVENT_TABLE(DEFINE_EVENT_ENUM) } Event;

// 상태 전환 규칙 테이블로 구현
Transition transitions[] = {
    {STATE_OFF, EVENT_POWER_ON, STATE_ON},
    {STATE_ON, EVENT_TIMEOUT, STATE_SLEEP},
    {STATE_SLEEP, EVENT_POWER_ON, STATE_ON},
    {STATE_ON, EVENT_RESET, STATE_REBOOT},
    {STATE_REBOOT, EVENT_POWER_OFF, STATE_OFF}
};

#define DEFINE_STATE_ACTION(name) void action_##name() { printf("Character is " #name "\n"); }
STATE_TABLE(DEFINE_STATE_ACTION)

#define STATE_TABLE(STATE) \
    STATE(LISTEN)          \
    STATE(SYN_SENT)        \
    STATE(ESTABLISHED)     \
    STATE(CLOSED)

#define TRANSITION_LOG(current, event, next) \
    printf("\"%s\" -> \"%s\" [label=\"%s\"];\n", #current, #next, #event);

#define HANDLE_EVENT(event) \
    switch (event) { \
        case EVENT_START: state = STATE_RUNNING; break; \
        case EVENT_STOP: state = STATE_STOPPED; break; \
        default: printf("Unhandled event\n"); break; \
    }