State_RemoveComments.c

Go to the documentation of this file.

 
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "State_RemoveComments.h"
 
typedef enum
{
    State_Initial,                
    State_NormalText,             
    State_DoubleQuotedText,       
    State_SingleQuotedText,       
    State_EscapedDoubleQuoteText, 
    State_EscapedSingleQuoteText, 
    State_StartComment,           
    State_LineComment,            
    State_BlockComment,           
    State_EndBlockComment,        
    State_Done,                   
    State_Error                   
} CurrentState;
 
struct StateContext; // forward reference
typedef CurrentState (*StateFunctionPtr)(struct StateContext*);
 
enum _Constants
{
    EOF_CHAR = (char)-1  
};
 
 
typedef struct StateContext
{
    const char* inputText;      
    size_t textIndex;           
    char* outputText;           
    size_t outputTextIndex;     
    CurrentState currentState;  
    StateFunctionPtr currentStateBehavior; 
} StateContext;
 
//=============================================================================
//=============================================================================
 
static const char* _CurrentStateToString(CurrentState state)
{
    // Need something for formatted error string that persists beyond this function.
    static char errorBuffer[64] = { 0 };
    const char* stateAsString = NULL;
 
    switch (state)
    {
        case State_Initial:
            stateAsString = "Initial";
            break;
 
        case State_NormalText:
            stateAsString = "NormalText";
            break;
 
        case State_DoubleQuotedText:
            stateAsString = "DoubleQuotedText";
            break;
 
        case State_SingleQuotedText:
            stateAsString = "SingleQuotedText";
            break;
 
        case State_EscapedDoubleQuoteText:
            stateAsString = "EscapedDoubleQuoteText";
            break;
 
        case State_EscapedSingleQuoteText:
            stateAsString = "EscapedSingleQuoteText";
            break;
 
        case State_StartComment:
            stateAsString = "StartComment";
            break;
 
        case State_LineComment:
            stateAsString = "LineComment";
            break;
 
        case State_BlockComment:
            stateAsString = "BlockComment";
            break;
 
        case State_EndBlockComment:
            stateAsString = "EndBlockComment";
            break;
 
        case State_Done:
            stateAsString = "Done";
            break;
 
        case State_Error:
            stateAsString = "Error";
            break;
 
        default:
            {
                errorBuffer[0] = '\0';
                int num_chars = snprintf(errorBuffer, sizeof(errorBuffer), "Unknown state (%d)", state);
                if (num_chars >= 0)
                {
                    stateAsString = errorBuffer;
                }
                else
                {
                    stateAsString = "Error converting state to string";
                }
            }
            break;
    }
 
 
    return stateAsString;
}
 
 
static char _GetNextCharacter(StateContext* context)
{
    char character = EOF_CHAR;
 
    if (context != NULL)
    {
        if (context->inputText[context->textIndex] != '\0')
        {
            character = context->inputText[context->textIndex];
            context->textIndex++;
        }
    }
    return character;
}
 
static void _OutputCharacter(StateContext* context, char character)
{
    if (context != NULL && character != EOF_CHAR)
    {
        context->outputText[context->outputTextIndex] = character;
        context->outputTextIndex++;
        context->outputText[context->outputTextIndex] = '\0';
    }
}
 
//=============================================================================
//=============================================================================
 
static CurrentState _State_NormalText_GoNextState(StateContext* context)
{
    CurrentState nextState = State_Error;
 
    if (context != NULL)
    {
        char character = _GetNextCharacter(context);
        nextState = State_NormalText;
 
        switch (character)
        {
            case EOF_CHAR:
                nextState = State_Done;
                break;
 
            case '"':
                _OutputCharacter(context, character);
                nextState = State_DoubleQuotedText;
                break;
 
            case '\'':
                _OutputCharacter(context, character);
                nextState = State_SingleQuotedText;
                break;
 
            case '/':
                nextState = State_StartComment;
                break;
 
            default:
                _OutputCharacter(context, character);
                break;
        }
    }
 
    return nextState;
}
 
static CurrentState _State_DoubleQuotedText_GoNextState(StateContext* context)
{
    CurrentState nextState = State_Error;
 
    if (context != NULL)
    {
        char character = _GetNextCharacter(context);
        nextState = State_DoubleQuotedText;
 
        switch (character)
        {
        case EOF_CHAR:
            nextState = State_Done;
            break;
 
        case '"':
            _OutputCharacter(context, character);
            nextState = State_NormalText;
            break;
 
        case '\\':
            _OutputCharacter(context, character);
            nextState = State_EscapedDoubleQuoteText;
            break;
 
        default:
            _OutputCharacter(context, character);
            break;
        }
    }
 
    return nextState;
}
 
static CurrentState _State_SingleQuotedText_GoNextState(StateContext* context)
{
    CurrentState nextState = State_Error;
 
    if (context != NULL)
    {
        char character = _GetNextCharacter(context);
        nextState = State_SingleQuotedText;
        switch (character)
        {
            case EOF_CHAR:
                nextState = State_Done;
                break;
 
            case '\'':
                _OutputCharacter(context, character);
                nextState = State_NormalText;
                break;
 
            case '\\':
                _OutputCharacter(context, character);
                nextState = State_EscapedSingleQuoteText;
                break;
 
            default:
                _OutputCharacter(context, character);
                break;
        }
    }
 
    return nextState;
}
 
static CurrentState _State_EscapedDoubleQuoteText_GoNextState(StateContext* context)
{
    CurrentState nextState = State_Error;
 
    if (context != NULL)
    {
        char character = _GetNextCharacter(context);
        nextState = State_DoubleQuotedText;
        switch (character)
        {
            case EOF_CHAR:
                nextState = State_Done;
                break;
 
            default:
                _OutputCharacter(context, character);
            break;
        }
 
    }
 
    return nextState;
}
 
static CurrentState _State_EscapedSingleQuoteText_GoNextState(StateContext* context)
{
    CurrentState nextState = State_Error;
 
    if (context != NULL)
    {
        char character = _GetNextCharacter(context);
        nextState = State_SingleQuotedText;
        switch (character)
        {
        case EOF_CHAR:
            nextState = State_Done;
            break;
 
        default:
            _OutputCharacter(context, character);
            break;
        }
 
    }
 
    return nextState;
}
 
static CurrentState _State_StartComment_GoNextState(StateContext* context)
{
    CurrentState nextState = State_Error;
 
    if (context != NULL)
    {
        char character = _GetNextCharacter(context);
        nextState = State_StartComment;
        switch (character)
        {
            case EOF_CHAR:
                nextState = State_Done;
                break;
 
            case '/':
                nextState = State_LineComment;
                break;
 
            case '*':
                nextState = State_BlockComment;
                break;
 
            default:
                // Not the start of a comment so output the leading slash
                // that led to the state followed by the character we just
                // processed.
                _OutputCharacter(context, '/');
                _OutputCharacter(context, character);
                nextState = State_NormalText;
            break;
        }
 
    }
 
    return nextState;
}
 
static CurrentState _State_LineComment_GoNextState(StateContext* context)
{
    CurrentState nextState = State_Error;
 
    if (context != NULL)
    {
        char character = _GetNextCharacter(context);
        nextState = State_LineComment;
        switch (character)
        {
            case EOF_CHAR:
                nextState = State_Done;
                break;
 
            case '\n':
                _OutputCharacter(context, character);
                nextState = State_NormalText;
                break;
 
            default:
                // We are in a comment to be removed, so do nothing here.
                break;
        }
 
    }
 
    return nextState;
}
 
static CurrentState _State_BlockComment_GoNextState(StateContext* context)
{
    CurrentState nextState = State_Error;
 
    if (context != NULL)
    {
        char character = _GetNextCharacter(context);
        nextState = State_BlockComment;
        switch (character)
        {
            case EOF_CHAR:
                nextState = State_Done;
                break;
 
            case '*':
                nextState = State_EndBlockComment;
                break;
 
            default:
                // We are in a comment to be removed, so do nothing here.
                break;
        }
    }
 
    return nextState;
}
 
static CurrentState _State_EndBlockComment_GoNextState(StateContext* context)
{
    CurrentState nextState = State_Error;
 
    if (context != NULL)
    {
        char character = _GetNextCharacter(context);
        nextState = State_BlockComment;
        switch (character)
        {
            case EOF_CHAR:
                nextState = State_Done;
                break;
 
            case '/':
                nextState = State_NormalText;
                break;
 
            default:
                // We are still in a block comment to be removed, so do nothing here.
                break;
        }
 
    }
 
    return nextState;
}
 
static CurrentState _State_Done_GoNextState(StateContext* context)
{
    CurrentState nextState = State_Error;
 
    if (context != NULL)
    {
        // Do nothing (Yes!  Another Null Object example!)
        nextState = State_Done;
    }
 
    return nextState;
}
 
 
 
//=============================================================================
//=============================================================================
 
typedef struct
{
    CurrentState state;            
    StateFunctionPtr stateHandler; 
} StateHandler;
 
static StateHandler _stateHandlers[] = {
    { State_NormalText            , _State_NormalText_GoNextState             },
    { State_DoubleQuotedText      , _State_DoubleQuotedText_GoNextState       },
    { State_SingleQuotedText      , _State_SingleQuotedText_GoNextState       },
    { State_EscapedDoubleQuoteText, _State_EscapedDoubleQuoteText_GoNextState },
    { State_EscapedSingleQuoteText, _State_EscapedSingleQuoteText_GoNextState },
    { State_StartComment          , _State_StartComment_GoNextState           },
    { State_LineComment           , _State_LineComment_GoNextState            },
    { State_BlockComment          , _State_BlockComment_GoNextState           },
    { State_EndBlockComment       , _State_EndBlockComment_GoNextState        },
    { State_Done                  , _State_Done_GoNextState                   },
    { State_Initial               , NULL }, // end of list
};
 
static StateFunctionPtr _GetStateFunction(CurrentState state)
{
    StateFunctionPtr functionPtr = NULL;
 
    for (size_t index = 0; _stateHandlers[index].stateHandler != NULL; index++)
    {
        if (_stateHandlers[index].state == state)
        {
            functionPtr = _stateHandlers[index].stateHandler;
            break;
        }
    }
 
    if (functionPtr == NULL)
    {
        printf("Error!  _GetStateFunction() received an unrecognized state.  Cannot retrieve the state function.\n");
    }
 
    return functionPtr;
}
 
 
static bool _SetNextState(StateContext *context, CurrentState newState)
{
    bool success = false;
 
    if (context != NULL)
    {
        success = true;
        if (newState != context->currentState)
        {
            context->currentStateBehavior = _GetStateFunction(newState);
            if (context->currentStateBehavior != NULL)
            {
                printf("    --> State Transition: %s -> %s\n",
                    _CurrentStateToString(context->currentState),
                    _CurrentStateToString(newState));
 
                context->currentState = newState;
            }
            else
            {
                success = false;
            }
        }
    }
 
    return success;
}
 
 
// State_RemoveComments()
bool State_RemoveComments(const char* text, DynamicString* filteredText)
{
    bool success = false;
 
    if (text != NULL && filteredText != NULL)
    {
        StateContext context = { 0 };
        // Filtered text is guaranteed to be no larger than the raw text, so
        // allocate a buffer the same size for the output text.  This avoids
        // a lot of messy out of memory error checking in the code.
        context.outputText = calloc(1, strlen(text) + 1);
        if (context.outputText != NULL)
        {
            context.inputText = text;
            context.textIndex = 0;
            context.outputTextIndex = 0;
            context.currentState = State_Initial;
            success = _SetNextState(&context, State_NormalText);
        }
        else
        {
            printf("  Error!  Unable to allocate memory for the output text in the state machine!\n");
        }
 
        if (success)
        {
            while (context.currentState != State_Done && success)
            {
                CurrentState newState = context.currentStateBehavior(&context);
                if (newState == State_Error)
                {
                    printf("  Error!  The state machine ran into an error condition (likely a NULL argument)!\n");
                    break;
                }
                success = _SetNextState(&context, newState);
            }
 
            if (success)
            {
                success = DynamicString_Set(filteredText, context.outputText);
                free(context.outputText);
            }
        }
    }
 
    return success;
}