---

Parser.hpp

Go to the documentation of this file.

#ifndef INC_Parser_hpp__
#define INC_Parser_hpp__

/* ANTLR Translator Generator
 * Project led by Terence Parr at http://www.jGuru.com
 * Software rights: http://www.antlr.org/license.html
 *
 * $Id: Parser.hpp,v 1.1 2004/10/08 16:27:34 dfisher Exp $
 */

#include <antlr/config.hpp>
#include <antlr/BitSet.hpp>
#include <antlr/TokenBuffer.hpp>
#include <antlr/RecognitionException.hpp>
#include <antlr/ASTFactory.hpp>
#include <antlr/ParserSharedInputState.hpp>

#include <exception>

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
namespace antlr {
#endif

extern bool DEBUG_PARSER;

class ANTLR_API Parser {
protected:
        Parser(TokenBuffer& input_);
        Parser(TokenBuffer* input_);

        Parser(const ParserSharedInputState& state);
public:
        virtual ~Parser();

        virtual int LA(unsigned int i)=0;

        virtual RefToken LT(unsigned int i)=0;

        virtual void setASTNodeFactory( ASTFactory *factory )
        {
                astFactory = factory;
        }
        virtual void setASTFactory( ASTFactory *factory )
        {
                astFactory = factory;
        }
        virtual ASTFactory* getASTFactory()
        {
                return astFactory;
        }
        virtual RefAST getAST() {
                return RefAST();
        }

        virtual inline ANTLR_USE_NAMESPACE(std)string getFilename() const
        {
                return inputState->filename;
        }
        virtual void setFilename(const ANTLR_USE_NAMESPACE(std)string& f)
        {
                inputState->filename = f;
        }

        virtual void setInputState(ParserSharedInputState state)
        {
                inputState = state;
        }
        virtual inline ParserSharedInputState getInputState() const
        {
                return inputState;
        }

        virtual void consume()=0;
        virtual void consumeUntil(int tokenType);
        virtual void consumeUntil(const BitSet& set);

        virtual void match(int t);
        virtual void matchNot(int t);
        virtual void match(const BitSet& b);

        virtual inline unsigned int mark()
        {
                return inputState->getInput().mark();
        }
        virtual inline void rewind(unsigned int pos)
        {
                inputState->getInput().rewind(pos);
        }

        virtual void reportError(const RecognitionException& ex);
        virtual void reportError(const ANTLR_USE_NAMESPACE(std)string& s);
        virtual void reportWarning(const ANTLR_USE_NAMESPACE(std)string& s);

        virtual void panic();

        virtual const char* getTokenName(int num) const = 0;
        virtual const char* const* getTokenNames() const = 0;
        virtual int getNumTokens(void) const = 0;

//      void setTokenBuffer(TokenBuffer<Token>* t);

        virtual void traceIndent();
        virtual void traceIn(const char* rname);
        virtual void traceOut(const char* rname);
protected:
//      void setTokenNames(const char** tokenNames_);

        ParserSharedInputState inputState;

//      /// AST return value for a rule is squirreled away here
//      RefAST returnAST;

        ASTFactory *astFactory;

        // used to keep track of the indentation for the trace
        int traceDepth;

        class Tracer { /*{{{*/
        private:
                Parser* parser;
                const char* text;
        public:
                Tracer(Parser* p,const char * t)
                : parser(p), text(t)
                {
                        parser->traceIn(text);
                }
                ~Tracer()
                {
#ifdef ANTLR_CXX_SUPPORTS_UNCAUGHT_EXCEPTION
                        // Only give trace if there's no uncaught exception..
                        if(!ANTLR_USE_NAMESPACE(std)uncaught_exception())
#endif
                                parser->traceOut(text);
                }
        private:
                Tracer(const Tracer&);                                                  // undefined
                const Tracer& operator=(const Tracer&); // undefined
                /*}}}*/
        };
private:
        Parser(const Parser&);                                                          // undefined
        const Parser& operator=(const Parser&);         // undefined
};

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
}
#endif

#endif //INC_Parser_hpp__

---