DtGLSLPreprocessor.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2012 MAK Technologies, Inc.
 * All rights reserved.
 *****************************************************************************/


#ifndef DTGLSLPREPROCESSOR_H
#define DTGLSLPREPROCESSOR_H

#include <string.h>
#include <stdlib.h>

namespace makVrv {

class CPreprocessor
{
    class Token
    {
    public:
        enum Kind
        {
            TK_EOS,          // End of input stream
            TK_ERROR,        // An error has been encountered
            TK_WHITESPACE,   // A whitespace span (but not newline)
            TK_NEWLINE,      // A single newline (CR & LF)
            TK_LINECONT,     // Line continuation ('\' followed by LF)
            TK_NUMBER,       // A number
            TK_KEYWORD,      // A keyword
            TK_PUNCTUATION,  // A punctuation character
            TK_DIRECTIVE,    // A preprocessor directive
            TK_STRING,       // A string
            TK_COMMENT,      // A block comment
            TK_LINECOMMENT,  // A line comment
            TK_TEXT,         // An unparsed text (cannot be returned from GetToken())
        };

        Kind Type;
        mutable size_t Allocated;
        union
        {
            const char *String;
            char *Buffer;
        };
        size_t Length;

        Token () : Type(TK_WHITESPACE), Allocated (0), String (NULL), Length (0)
        { }

        Token (Kind iType) : Type (iType), Allocated (0), String (NULL), Length (0)
        { }

        Token (Kind iType, const char *iString, size_t iLength) :
            Type (iType), Allocated (0), String (iString), Length (iLength)
        { }

        Token (const Token &iOther)
        {
            Type = iOther.Type;
            Allocated = iOther.Allocated;
            iOther.Allocated = 0; // !!! not quite correct but effective
            String = iOther.String;
            Length = iOther.Length;
        }

        ~Token ()
        { if (Allocated) free (Buffer); }

        Token &operator = (const Token &iOther)
        {
            if (Allocated) free (Buffer);
            Type = iOther.Type;
            Allocated = iOther.Allocated;
            iOther.Allocated = 0; // !!! not quite correct but effective
            String = iOther.String;
            Length = iOther.Length;
            return *this;
        }

        void Append (const char *iString, size_t iLength);

        void Append (const Token &iOther);

        void AppendNL (int iCount);

        int CountNL ();

        bool GetValue (long &oValue) const;

        void SetValue (long iValue);

        bool operator == (const Token &iOther)
        {
            if (iOther.Length != Length)
                return false;
            return (memcmp (String, iOther.String, Length) == 0);
        }
    };

    class Macro
    {
    public:
        Token Name;
        int NumArgs;
        Token *Args;
        Token Value;
        Token Body;
        Macro *Next;
        Token (*ExpandFunc) (CPreprocessor *iParent, int iNumArgs, Token *iArgs);
        bool Expanding;

        Macro (const Token &iName) :
            Name (iName), NumArgs (0), Args (NULL), Next (NULL),
            ExpandFunc (NULL), Expanding (false)
        { }

        ~Macro ()
        { delete [] Args; delete Next; }

        Token Expand (int iNumArgs, Token *iArgs, Macro *iMacros);
    };

    friend class CPreprocessor::Macro;

    const char *Source;
    const char *SourceEnd;
    int Line;
    bool BOL;
    unsigned EnableOutput;
    Macro *MacroList;

    CPreprocessor (const Token &iToken, int iLine);

    Token GetToken (bool iExpand);

    Token HandleDirective (Token &iToken, int iLine);

    bool HandleDefine (Token &iBody, int iLine);

    bool HandleUnDef (Token &iBody, int iLine);

    bool HandleIfDef (Token &iBody, int iLine);

    bool HandleIf (Token &iBody, int iLine);

    bool HandleElse (Token &iBody, int iLine);

    bool HandleEndIf (Token &iBody, int iLine);

    Token GetArgument (Token &oArg, bool iExpand);

    Token GetArguments (int &oNumArgs, Token *&oArgs, bool iExpand);

    Token GetExpression (Token &oResult, int iLine, int iOpPriority = 0);

    bool GetValue (const Token &iToken, long &oValue, int iLine);

    Token ExpandMacro (const Token &iToken);

    Macro *IsDefined (const Token &iToken);

    static Token ExpandDefined (CPreprocessor *iParent, int iNumArgs, Token *iArgs);

    Token Parse (const Token &iSource);

    void Error (int iLine, const char *iError, const Token *iToken = NULL);

public:
   CPreprocessor() 
      : MacroList(NULL)
      , Source(NULL)
      , SourceEnd(NULL)
      , Line(0)
      , BOL(false)
      , EnableOutput(false)
      , ErrorData(NULL)
    { }

    virtual ~CPreprocessor ();

    void Define (const char *iMacroName, size_t iMacroNameLen,
                 const char *iMacroValue, size_t iMacroValueLen);

    void Define (const char *iMacroName, size_t iMacroNameLen, long iMacroValue);

    bool Undef (const char *iMacroName, size_t iMacroNameLen);

    char *Parse (const char *iSource, size_t iLength, size_t &oLength);

    typedef void (*ErrorHandlerFunc) (
        void *iData, int iLine, const char *iError,
        const char *iToken, size_t iTokenLen);

    static ErrorHandlerFunc ErrorHandler;

    void *ErrorData;
};

} 

#endif // DTGLSLPREPROCESSOR_H