est, C (gcc) - rextester

est

//gcc 4.9.3

#include  <stdio.h>

int main(void)
{
    printf("Hello, world!\n");
    return 0;
}

// My states
typedef enum states {STATE_INIT, STATE_A, STATE_B, STATE_C, STATE_D, STATE_E, STATE_F, STATE_G, STATE_H, STATE_I, STATE_EXIT} State;

// My transitiion functions
State computeTransitionFromStateINIT(int value) {
    State returnState = STATE_INIT;
    if (value==1) {
        returnState = STATE_A;
    }
    return(returnState);
}

State computeTransitionFromStateA(int value) {
    State returnState = STATE_A;
    if (value==1) {
        returnState = STATE_B;
    } 
     else 
    { 
      returnState = STATE_INIT;
    }
    return(returnState);
}

State computeTransitionFromStateB(int value) {
    State returnState = STATE_B;
    if (value==1) {
        returnState = STATE_C;
    }
    else 
    { 
      returnState = STATE_INIT;
    }
    return(returnState);
}

State computeTransitionFromStateC(int value) {
    State returnState = STATE_C;
    if (value==1) {
        returnState = STATE_D;
    }
    else 
    { 
      returnState = STATE_INIT;
    }
    return(returnState);
}

State computeTransitionFromStateD(int value) {
    State returnState = STATE_D;
    if (value==1) {
        returnState = STATE_E;
    }
    else 
    { 
      returnState = STATE_INIT;
    }
    return(returnState);
}

State computeTransitionFromStateE(int value) {
    State returnState = STATE_E;
    if (value==1) {
        returnState = STATE_F;
    }
    else 
    { 
      returnState = STATE_INIT;
    }
    return(returnState);
}

State computeTransitionFromStateF(int value) {
    State returnState = STATE_F;
    if (value==1) {
        returnState = STATE_G;
    }
    else 
    { 
      returnState = STATE_INIT;
    }
    return(returnState);
}

State computeTransitionFromStateG(int value) {
    State returnState = STATE_G;
    if (value==1) {
        returnState = STATE_H;
    }
    else 
    { 
      returnState = STATE_INIT;
    }
    return(returnState);
}

State computeTransitionFromStateH(int value) {
    State returnState = STATE_H;
    if (value==1) {
        returnState = STATE_I;
    }
    else 
    { 
      returnState = STATE_INIT;
    }
    return(returnState);
}

State computeTransitionFromStateI(int value) {
    State returnState = STATE_I;
    if (value==1) {
        returnState = STATE_EXIT;
    }
    else 
    { 
      returnState = STATE_INIT;
    }
    return(returnState);
}

// My finite state machine
State finiteStateMachine(int num)
{
    static State systemState = STATE_INIT;
    switch (systemState) {
        case STATE_INIT:
            systemState = computeTransitionFromStateINIT(num);
            break;
        case STATE_A:
            systemState = computeTransitionFromStateA(num);
            break;
        case STATE_B:
            systemState = computeTransitionFromStateB(num);
            break;
        case STATE_C:
            systemState = computeTransitionFromStateC(num);
            break; 
        case STATE_D:
            systemState = computeTransitionFromStateD(num);
            break; 
        case STATE_E:
            systemState = computeTransitionFromStateE(num);
            break; 
        case STATE_F:
            systemState = computeTransitionFromStateF(num);
            break; 
        case STATE_G:
            systemState = computeTransitionFromStateG(num);
            break; 
        case STATE_H:
            systemState = computeTransitionFromStateH(num);
            break; 
        case STATE_I:
            systemState = computeTransitionFromStateI(num);
            break;

default:
            printf("Should never get here!\n");
            exit(0);
    }
    return(systemState);    
}


run \| edit \| history \| help	0