OgreCompiler2Pass.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.stevestreeting.com/ogre/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/gpl.html.
-----------------------------------------------------------------------------
*/


#ifndef __Compiler2Pass_H__
#define __Compiler2Pass_H__

#include <vector>
#include "OgrePrerequisites.h"

namespace Ogre {

    class _OgreExport Compiler2Pass
    {

    protected:

        // BNF operation types
        enum OperationType {otUNKNOWN, otRULE, otAND, otOR, otOPTIONAL, otREPEAT, otDATA, otNOT_TEST, otEND};

        struct TokenRule
        {
            OperationType operation;
            size_t tokenID;

            TokenRule(void) : operation(otUNKNOWN), tokenID(0) {}
            TokenRule(const OperationType ot, const size_t token)
                : operation(ot), tokenID(token) {}
        };

        typedef std::vector<TokenRule> TokenRuleContainer;
        typedef TokenRuleContainer::iterator TokenRuleIterator;

        static const size_t SystemTokenBase = 1000;
        enum SystemRuleToken {
            _no_token_ = SystemTokenBase,
            _character_,
            _value_,
            _no_space_skip_
        };

        enum BNF_ID {BNF_UNKOWN = 0,
            BNF_SYNTAX, BNF_RULE, BNF_IDENTIFIER, BNF_IDENTIFIER_RIGHT, BNF_IDENTIFIER_CHARACTERS, BNF_ID_BEGIN, BNF_ID_END,
            BNF_CONSTANT_BEGIN, BNF_SET_RULE, BNF_EXPRESSION,
            BNF_AND_TERM, BNF_OR_TERM, BNF_TERM, BNF_TERM_ID, BNF_CONSTANT, BNF_OR, BNF_TERMINAL_SYMBOL, BNF_TERMINAL_START,
            BNF_REPEAT_EXPRESSION, BNF_REPEAT_BEGIN, BNF_REPEAT_END, BNF_SET, BNF_SET_BEGIN, BNF_SET_END,
            BNF_NOT_TEST, BNF_NOT_TEST_BEGIN, BNF_OPTIONAL_EXPRESSION, BNF_NOT_EXPRESSION, BNF_NOT_CHK,
            BNF_OPTIONAL_BEGIN, BNF_OPTIONAL_END, BNF_NO_TOKEN_START, BNF_SINGLEQUOTE, BNF_SINGLE_QUOTE_EXC, BNF_SET_END_EXC,
            BNF_ANY_CHARACTER, BNF_SPECIAL_CHARACTERS1,
            BNF_SPECIAL_CHARACTERS2, BNF_WHITE_SPACE_CHK,

            BNF_LETTER, BNF_LETTER_DIGIT, BNF_DIGIT, BNF_WHITE_SPACE,
            BNF_ALPHA_SET, BNF_NUMBER_SET, BNF_SPECIAL_CHARACTER_SET1,
            BNF_SPECIAL_CHARACTER_SET2, BNF_SPECIAL_CHARACTER_SET3, BNF_NOT_CHARS
        };


        struct LexemeTokenDef
        {
            size_t ID;                  
            bool hasAction;            
            bool isNonTerminal;        
            size_t ruleID;              
            bool isCaseSensitive;        
            String lexeme;             

            LexemeTokenDef(void) : ID(0), hasAction(false), isNonTerminal(false), ruleID(0), isCaseSensitive(false) {}
            LexemeTokenDef( const size_t ID, const String& lexeme, const bool hasAction = false, const bool caseSensitive = false )
                : ID(ID)
                , hasAction(hasAction)
                , isNonTerminal(false)
                , ruleID(0)
                , isCaseSensitive(caseSensitive)
                , lexeme(lexeme)
            {
            }

        };

        typedef std::vector<LexemeTokenDef> LexemeTokenDefContainer;
        typedef LexemeTokenDefContainer::iterator LexemeTokenDefIterator;

        typedef std::map<std::string, size_t> LexemeTokenMap;
        typedef LexemeTokenMap::iterator TokenKeyIterator;


        struct TokenInst
        {
        size_t NTTRuleID;           
        size_t tokenID;                 
        size_t line;                
        size_t pos;             
        bool found;                
        };

        typedef std::vector<TokenInst> TokenInstContainer;
        typedef TokenInstContainer::iterator TokenInstIterator;

        // token que, definitions, rules
        struct TokenState
        {
            TokenInstContainer       tokenQue;
            LexemeTokenDefContainer  lexemeTokenDefinitions;
            TokenRuleContainer       rootRulePath;
            LexemeTokenMap           lexemeTokenMap;
        };

        TokenState* mClientTokenState;

        TokenState* mActiveTokenState;
        size_t mPass2TokenQuePosition;
        size_t mPreviousActionQuePosition;

        const String* mSource;
        String mSourceName;
        size_t mEndOfSource;

        size_t mCurrentLine; 
        size_t mCharPos;     

        std::map<size_t, float> mConstants;
        std::map<size_t, String> mLabels;
        bool mLabelIsActive;
        size_t mActiveLabelKey;
        bool mNoSpaceSkip;
        bool mNoTerminalToken;

        uint mActiveContexts;

        bool doPass1();

        bool doPass2();

        virtual void executeTokenAction(const size_t tokenID) = 0;
        virtual void setupTokenDefinitions(void) = 0;
        const TokenInst& getNextToken(const size_t expectedTokenID = 0);
        const TokenInst& getCurrentToken(void);
        bool testNextTokenID(const size_t expectedTokenID);
        void replaceToken(void);
        float getNextTokenValue(void);
        const String& getNextTokenLabel(void);
        size_t getPass2TokenQueCount(void) const;
        size_t getRemainingTokensForAction(void) const;

        void addLexemeToken(const String& lexeme, const size_t token, const bool hasAction = false, const bool caseSensitive = false);

        void setClientBNFGrammer(void);



        void findEOL();

        bool isFloatValue(float& fvalue, size_t& charsize) const;

        bool isCharacterLabel(const size_t rulepathIDX);
        bool isLexemeMatch(const String& lexeme, const bool caseSensitive) const;
        bool positionToNextLexeme();
        bool processRulePath( size_t rulepathIDX);


        void setActiveContexts(const uint contexts){ mActiveContexts = contexts; }

        void skipComments();

        void skipEOL();

        void skipWhiteSpace();


        bool ValidateToken(const size_t rulepathIDX, const size_t activeRuleID);

        void verifyTokenRuleLinks(const String& grammerName);
        void checkTokenActionTrigger(void);
        String getBNFGrammerTextFromRulePath(size_t ruleID);


    private:
        // used for interpreting BNF script
        // keep it as static so that only one structure is created
        // no matter how many times this class is instantiated.
        static TokenState mBNFTokenState;
        // maintain a map of BNF grammer
        typedef std::map<String, TokenState> TokenStateContainer;
        static TokenStateContainer mClientTokenStates;
        void activatePreviousTokenAction(void);
        void initBNFCompiler(void);
        void buildClientBNFRulePaths(void);
        void modifyLastRule(const OperationType pendingRuleOp, const size_t tokenID);
        size_t getClientLexemeTokenID(const String& lexeme, const bool isCaseSensitive = false);
        void extractNonTerminal(const OperationType pendingRuleOp);
        void extractTerminal(const OperationType pendingRuleOp, const bool notoken = false);
        void extractSet(const OperationType pendingRuleOp);
        void extractNumericConstant(const OperationType pendingRuleOp);
        String getLexemeText(size_t& ruleID);

    public:

        Compiler2Pass();
        virtual ~Compiler2Pass() {}

        bool compile(const String& source, const String& sourceName);
        virtual const String& getClientBNFGrammer(void) = 0;

        virtual const String& getClientGrammerName(void) = 0;

    };

}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:38 2006