---

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: TreeParser.hpp,v 1.1 2004/10/08 16:27:34 dfisher Exp $
 */

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

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
namespace antlr {
#endif

class ANTLR_API TreeParser {
public:
        TreeParser();
        TreeParser(const TreeParserSharedInputState& state);
        virtual ~TreeParser();

        virtual RefAST getAST() = 0;

        virtual void match(RefAST t, const BitSet& b);

        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 panic();

        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);
        virtual void matchNot(RefAST t, int ttype);

        /* Where did this rule leave off parsing; avoids a return parameter */
        //RefAST _retTree;
        /* AST return value for a rule is squirreled away here */
        //RefAST returnAST;
        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__

---