antlr/include/antlr/TreeParser.hpp

Go to the documentation of this file.

#ifndef INC_TreeParser_hpp__
#define INC_TreeParser_hpp__

/* ANTLR Translator Generator
 * Project led by Terence Parr at http://www.jGuru.com
 * Software rights: http://www.antlr.org/license.html
 *
 * $Id: //depot/code/org.antlr/release/antlr-2.7.7/lib/cpp/antlr/TreeParser.hpp#2 $
 */

#include <antlr/config.hpp>
#include <antlr/AST.hpp>
#include <antlr/ASTFactory.hpp>
#include <antlr/BitSet.hpp>
#include <antlr/RecognitionException.hpp>
#include <antlr/MismatchedTokenException.hpp>
#include <antlr/TreeParserSharedInputState.hpp>

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
namespace antlr {
#endif

class ANTLR_API TreeParser {
public:
        TreeParser()
        : astFactory(0)
        , inputState(new TreeParserInputState())
        , traceDepth(0)
        {
        }

        TreeParser(const TreeParserSharedInputState& state)
        : astFactory(0)
        , inputState(state)
        , traceDepth(0)
        {
        }

        virtual ~TreeParser()
        {
        }

        virtual RefAST getAST() = 0;

        virtual void match(RefAST t, const BitSet& b)
        {
                if ( !t || t==ASTNULL || !b.member(t->getType()) )
                        throw MismatchedTokenException( getTokenNames(), getNumTokens(),
                                                                                                          t, b, false );
        }

        virtual void setASTFactory(ASTFactory* factory)
        {
                astFactory = factory;
        }
        virtual ASTFactory* getASTFactory() const
        {
                return astFactory;
        }
        virtual const char* getTokenName(int num) const = 0;
        virtual int getNumTokens() const = 0;
        virtual const char* const* getTokenNames() const = 0;

        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 traceIndent();
        virtual void traceIn(const char* rname, RefAST t);
        virtual void traceOut(const char* rname, RefAST t);

        static RefAST ASTNULL;

protected:
        virtual void match(RefAST t, int ttype)
        {
                if (!t || t == ASTNULL || t->getType() != ttype )
                        throw MismatchedTokenException( getTokenNames(), getNumTokens(),
                                                                                                          t, ttype, false );
        }

        virtual void matchNot(RefAST t, int ttype)
        {
                if ( !t || t == ASTNULL || t->getType() == ttype )
                        throw MismatchedTokenException( getTokenNames(), getNumTokens(),
                                                                                                          t, ttype, true );
        }

        ASTFactory* astFactory;

        TreeParserSharedInputState inputState;

        int traceDepth;

        class Tracer {
        private:
                TreeParser* parser;
                const char* text;
                RefAST tree;
        public:
                Tracer(TreeParser* p, const char* t, RefAST a)
                : parser(p), text(t), tree(a)
                {
                        parser->traceIn(text,tree);
                }
                ~Tracer()
                {
                        parser->traceOut(text,tree);
                }
        private:
                Tracer(const Tracer&);                                                  // undefined
                const Tracer& operator=(const Tracer&); // undefined
        };

private:
        // no copying of treeparser instantiations...
        TreeParser(const TreeParser& other);
        TreeParser& operator=(const TreeParser& other);
};

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
}
#endif

#endif //INC_TreeParser_hpp__

---