src/antlr/Parser.hpp

#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$
 */

#include <antlr/config.hpp>

#include <iostream>
#include <exception>

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

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
namespace antlr {
#endif

extern bool DEBUG_PARSER;

/** A generic ANTLR parser (LL(k) for k>=1) containing a bunch of
 * utility routines useful at any lookahead depth.  We distinguish between
 * the LL(1) and LL(k) parsers because of efficiency.  This may not be
 * necessary in the near future.
 *
 * Each parser object contains the state of the parse including a lookahead
 * cache (the form of which is determined by the subclass), whether or
 * not the parser is in guess mode, where tokens come from, etc...
 *
 * <p>
 * During <b>guess</b> mode, the current lookahead token(s) and token type(s)
 * cache must be saved because the token stream may not have been informed
 * to save the token (via <tt>mark</tt>) before the <tt>try</tt> block.
 * Guessing is started by:
 * <ol>
 * <li>saving the lookahead cache.
 * <li>marking the current position in the TokenBuffer.
 * <li>increasing the guessing level.
 * </ol>
 *
 * After guessing, the parser state is restored by:
 * <ol>
 * <li>restoring the lookahead cache.
 * <li>rewinding the TokenBuffer.
 * <li>decreasing the guessing level.
 * </ol>
 *
 * @see antlr.Token
 * @see antlr.TokenBuffer
 * @see antlr.TokenStream
 * @see antlr.LL1Parser
 * @see antlr.LLkParser
 *
 * @todo add constructors with ASTFactory.
 */
class ANTLR_API Parser {
protected:
        Parser(TokenBuffer& input)
        : inputState(new ParserInputState(input)), astFactory(0), traceDepth(0)
        {
        }
        Parser(TokenBuffer* input)
        : inputState(new ParserInputState(input)), astFactory(0), traceDepth(0)
        {
        }
        Parser(const ParserSharedInputState& state)
        : inputState(state), astFactory(0), traceDepth(0)
        {
        }
public:
        virtual ~Parser()
        {
        }

        /** Return the token type of the ith token of lookahead where i=1
         * is the current token being examined by the parser (i.e., it
         * has not been matched yet).
         */
        virtual int LA(unsigned int i)=0;

        /// Return the i-th token of lookahead
        virtual RefToken LT(unsigned int i)=0;

        /** DEPRECATED! Specify the factory to be used during tree building. (Compulsory)
         * Setting the factory is nowadays compulsory.
         * @see setASTFactory
         */
        virtual void setASTNodeFactory( ASTFactory *factory )
        {
                astFactory = factory;
        }
        /** Specify the factory to be used during tree building. (Compulsory)
         * Setting the factory is nowadays compulsory.
         */
        virtual void setASTFactory( ASTFactory *factory )
        {
                astFactory = factory;
        }
        /** Return a pointer to the ASTFactory used.
         * So you might use it in subsequent treewalkers or to reload AST's
         * from disk.
         */
        virtual ASTFactory* getASTFactory()
        {
                return astFactory;
        }
        /** Get the root AST node of the generated AST. When using a custom AST type
         * or heterogenous AST's, you'll have to convert it to the right type
         * yourself.
         */
        virtual RefAST getAST() = 0;

        /// Return the filename of the input file.
        virtual inline ANTLR_USE_NAMESPACE(std)string getFilename() const
        {
                return inputState->filename;
        }
        /// Set the filename of the input file (used for error reporting).
        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;
        }

        /// Get another token object from the token stream
        virtual void consume()=0;
        /// Consume tokens until one matches the given token
        virtual void consumeUntil(int tokenType)
        {
                while (LA(1) != Token::EOF_TYPE && LA(1) != tokenType)
                        consume();
        }

        /// Consume tokens until one matches the given token set
        virtual void consumeUntil(const BitSet& set)
        {
                while (LA(1) != Token::EOF_TYPE && !set.member(LA(1)))
                        consume();
        }

        /** Make sure current lookahead symbol matches token type <tt>t</tt>.
         * Throw an exception upon mismatch, which is catch by either the
         * error handler or by the syntactic predicate.
         */
        virtual void match(int t)
        {
                if ( DEBUG_PARSER )
                {
                        traceIndent();
                        ANTLR_USE_NAMESPACE(std)cout << "enter match(" << t << ") with LA(1)=" << LA(1) << ANTLR_USE_NAMESPACE(std)endl;
                }
                if ( LA(1) != t )
                {
                        if ( DEBUG_PARSER )
                        {
                                traceIndent();
                                ANTLR_USE_NAMESPACE(std)cout << "token mismatch: " << LA(1) << "!=" << t << ANTLR_USE_NAMESPACE(std)endl;
                        }
                        throw MismatchedTokenException(getTokenNames(), getNumTokens(), LT(1), t, false, getFilename());
                }
                else
                {
                        // mark token as consumed -- fetch next token deferred until LA/LT
                        consume();
                }
        }

        virtual void matchNot(int t)
        {
                if ( LA(1)==t )
                {
                        // Throws inverted-sense exception
                        throw MismatchedTokenException(getTokenNames(), getNumTokens(), LT(1), t, true, getFilename());
                }
                else
                {
                        // mark token as consumed -- fetch next token deferred until LA/LT
                        consume();
                }
        }

        /** Make sure current lookahead symbol matches the given set
         * Throw an exception upon mismatch, which is catch by either the
         * error handler or by the syntactic predicate.
         */
        virtual void match(const BitSet& b)
        {
                if ( DEBUG_PARSER )
                {
                        traceIndent();
                        ANTLR_USE_NAMESPACE(std)cout << "enter match(" << "bitset" /*b.toString()*/
                                << ") with LA(1)=" << LA(1) << ANTLR_USE_NAMESPACE(std)endl;
                }
                if ( !b.member(LA(1)) )
                {
                        if ( DEBUG_PARSER )
                        {
                                traceIndent();
                                ANTLR_USE_NAMESPACE(std)cout << "token mismatch: " << LA(1) << " not member of "
                                        << "bitset" /*b.toString()*/ << ANTLR_USE_NAMESPACE(std)endl;
                        }
                        throw MismatchedTokenException(getTokenNames(), getNumTokens(), LT(1), b, false, getFilename());
                }
                else
                {
                        // mark token as consumed -- fetch next token deferred until LA/LT
                        consume();
                }
        }

        /** Mark a spot in the input and return the position.
         * Forwarded to TokenBuffer.
         */
        virtual inline unsigned int mark()
        {
                return inputState->getInput().mark();
        }
        /// rewind to a previously marked position
        virtual inline void rewind(unsigned int pos)
        {
                inputState->getInput().rewind(pos);
        }
        /** called by the generated parser to do error recovery, override to
         * customize the behaviour.
         */
        virtual void recover(const RecognitionException& ex, const BitSet& tokenSet)
        {
                consume();
                consumeUntil(tokenSet);
        }

        /// Parser error-reporting function can be overridden in subclass
        virtual void reportError(const RecognitionException& ex);
        /// Parser error-reporting function can be overridden in subclass
        virtual void reportError(const ANTLR_USE_NAMESPACE(std)string& s);
        /// Parser warning-reporting function can be overridden in subclass
        virtual void reportWarning(const ANTLR_USE_NAMESPACE(std)string& s);

        /// get the token name for the token number 'num'
        virtual const char* getTokenName(int num) const = 0;
        /// get a vector with all token names
        virtual const char* const* getTokenNames() const = 0;
        /** Get the number of tokens defined.
         * This one should be overridden in subclasses.
         */
        virtual int getNumTokens(void) const = 0;

        /** Set or change the input token buffer */
//      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;

        /// AST support code; parser and treeparser delegate to this object
        ASTFactory *astFactory;

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

        /** Utility class which allows tracing to work even when exceptions are
         * thrown.
         */
        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__
Revision:	1633
Committed:	Thu Sep 15 13:39:36 2011 UTC (13 years, 7 months ago) by gezelter
File size:	8802 byte(s)
Log Message:	Updated antlr, fixed a clang compilation bug, removed a warning message
#	User	Rev	Content
1	tim	770	#ifndef INC_Parser_hpp__
2			#define INC_Parser_hpp__
3
4			/* ANTLR Translator Generator
5			* Project led by Terence Parr at http://www.jGuru.com
6			* Software rights: http://www.antlr.org/license.html
7			*
8	gezelter	1442	* $Id$
9	tim	770	*/
10
11	gezelter	1633	#include <antlr/config.hpp>
12
13	tim	770	#include <iostream>
14			#include <exception>
15
16			#include <antlr/BitSet.hpp>
17			#include <antlr/TokenBuffer.hpp>
18			#include <antlr/RecognitionException.hpp>
19			#include <antlr/MismatchedTokenException.hpp>
20			#include <antlr/ASTFactory.hpp>
21			#include <antlr/ParserSharedInputState.hpp>
22
23			#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
24			namespace antlr {
25			#endif
26
27			extern bool DEBUG_PARSER;
28
29			/** A generic ANTLR parser (LL(k) for k>=1) containing a bunch of
30			* utility routines useful at any lookahead depth. We distinguish between
31			* the LL(1) and LL(k) parsers because of efficiency. This may not be
32			* necessary in the near future.
33			*
34			* Each parser object contains the state of the parse including a lookahead
35			* cache (the form of which is determined by the subclass), whether or
36			* not the parser is in guess mode, where tokens come from, etc...
37			*
38			* <p>
39			* During <b>guess</b> mode, the current lookahead token(s) and token type(s)
40			* cache must be saved because the token stream may not have been informed
41			* to save the token (via <tt>mark</tt>) before the <tt>try</tt> block.
42			* Guessing is started by:
43			* <ol>
44			* <li>saving the lookahead cache.
45			* <li>marking the current position in the TokenBuffer.
46			* <li>increasing the guessing level.
47			* </ol>
48			*
49			* After guessing, the parser state is restored by:
50			* <ol>
51			* <li>restoring the lookahead cache.
52			* <li>rewinding the TokenBuffer.
53			* <li>decreasing the guessing level.
54			* </ol>
55			*
56			* @see antlr.Token
57			* @see antlr.TokenBuffer
58			* @see antlr.TokenStream
59			* @see antlr.LL1Parser
60			* @see antlr.LLkParser
61			*
62			* @todo add constructors with ASTFactory.
63			*/
64			class ANTLR_API Parser {
65			protected:
66			Parser(TokenBuffer& input)
67			: inputState(new ParserInputState(input)), astFactory(0), traceDepth(0)
68			{
69			}
70			Parser(TokenBuffer* input)
71			: inputState(new ParserInputState(input)), astFactory(0), traceDepth(0)
72			{
73			}
74			Parser(const ParserSharedInputState& state)
75			: inputState(state), astFactory(0), traceDepth(0)
76			{
77			}
78			public:
79			virtual ~Parser()
80			{
81			}
82
83			/** Return the token type of the ith token of lookahead where i=1
84			* is the current token being examined by the parser (i.e., it
85			* has not been matched yet).
86			*/
87			virtual int LA(unsigned int i)=0;
88
89			/// Return the i-th token of lookahead
90			virtual RefToken LT(unsigned int i)=0;
91
92			/** DEPRECATED! Specify the factory to be used during tree building. (Compulsory)
93			* Setting the factory is nowadays compulsory.
94			* @see setASTFactory
95			*/
96			virtual void setASTNodeFactory( ASTFactory *factory )
97			{
98			astFactory = factory;
99			}
100			/** Specify the factory to be used during tree building. (Compulsory)
101			* Setting the factory is nowadays compulsory.
102			*/
103			virtual void setASTFactory( ASTFactory *factory )
104			{
105			astFactory = factory;
106			}
107			/** Return a pointer to the ASTFactory used.
108			* So you might use it in subsequent treewalkers or to reload AST's
109			* from disk.
110			*/
111			virtual ASTFactory* getASTFactory()
112			{
113			return astFactory;
114			}
115			/** Get the root AST node of the generated AST. When using a custom AST type
116			* or heterogenous AST's, you'll have to convert it to the right type
117			* yourself.
118			*/
119			virtual RefAST getAST() = 0;
120
121			/// Return the filename of the input file.
122			virtual inline ANTLR_USE_NAMESPACE(std)string getFilename() const
123			{
124			return inputState->filename;
125			}
126			/// Set the filename of the input file (used for error reporting).
127			virtual void setFilename(const ANTLR_USE_NAMESPACE(std)string& f)
128			{
129			inputState->filename = f;
130			}
131
132			virtual void setInputState(ParserSharedInputState state)
133			{
134			inputState = state;
135			}
136			virtual inline ParserSharedInputState getInputState() const
137			{
138			return inputState;
139			}
140
141			/// Get another token object from the token stream
142			virtual void consume()=0;
143			/// Consume tokens until one matches the given token
144			virtual void consumeUntil(int tokenType)
145			{
146			while (LA(1) != Token::EOF_TYPE && LA(1) != tokenType)
147			consume();
148			}
149
150			/// Consume tokens until one matches the given token set
151			virtual void consumeUntil(const BitSet& set)
152			{
153			while (LA(1) != Token::EOF_TYPE && !set.member(LA(1)))
154			consume();
155			}
156
157			/** Make sure current lookahead symbol matches token type <tt>t</tt>.
158			* Throw an exception upon mismatch, which is catch by either the
159			* error handler or by the syntactic predicate.
160			*/
161			virtual void match(int t)
162			{
163			if ( DEBUG_PARSER )
164			{
165			traceIndent();
166			ANTLR_USE_NAMESPACE(std)cout << "enter match(" << t << ") with LA(1)=" << LA(1) << ANTLR_USE_NAMESPACE(std)endl;
167			}
168			if ( LA(1) != t )
169			{
170			if ( DEBUG_PARSER )
171			{
172			traceIndent();
173			ANTLR_USE_NAMESPACE(std)cout << "token mismatch: " << LA(1) << "!=" << t << ANTLR_USE_NAMESPACE(std)endl;
174			}
175			throw MismatchedTokenException(getTokenNames(), getNumTokens(), LT(1), t, false, getFilename());
176			}
177			else
178			{
179			// mark token as consumed -- fetch next token deferred until LA/LT
180			consume();
181			}
182			}
183
184			virtual void matchNot(int t)
185			{
186			if ( LA(1)==t )
187			{
188			// Throws inverted-sense exception
189			throw MismatchedTokenException(getTokenNames(), getNumTokens(), LT(1), t, true, getFilename());
190			}
191			else
192			{
193			// mark token as consumed -- fetch next token deferred until LA/LT
194			consume();
195			}
196			}
197
198			/** Make sure current lookahead symbol matches the given set
199			* Throw an exception upon mismatch, which is catch by either the
200			* error handler or by the syntactic predicate.
201			*/
202			virtual void match(const BitSet& b)
203			{
204			if ( DEBUG_PARSER )
205			{
206			traceIndent();
207			ANTLR_USE_NAMESPACE(std)cout << "enter match(" << "bitset" /b.toString()/
208			<< ") with LA(1)=" << LA(1) << ANTLR_USE_NAMESPACE(std)endl;
209			}
210			if ( !b.member(LA(1)) )
211			{
212			if ( DEBUG_PARSER )
213			{
214			traceIndent();
215			ANTLR_USE_NAMESPACE(std)cout << "token mismatch: " << LA(1) << " not member of "
216			<< "bitset" /b.toString()/ << ANTLR_USE_NAMESPACE(std)endl;
217			}
218			throw MismatchedTokenException(getTokenNames(), getNumTokens(), LT(1), b, false, getFilename());
219			}
220			else
221			{
222			// mark token as consumed -- fetch next token deferred until LA/LT
223			consume();
224			}
225			}
226
227			/** Mark a spot in the input and return the position.
228			* Forwarded to TokenBuffer.
229			*/
230			virtual inline unsigned int mark()
231			{
232			return inputState->getInput().mark();
233			}
234			/// rewind to a previously marked position
235			virtual inline void rewind(unsigned int pos)
236			{
237			inputState->getInput().rewind(pos);
238			}
239			/** called by the generated parser to do error recovery, override to
240			* customize the behaviour.
241			*/
242			virtual void recover(const RecognitionException& ex, const BitSet& tokenSet)
243			{
244			consume();
245			consumeUntil(tokenSet);
246			}
247
248			/// Parser error-reporting function can be overridden in subclass
249			virtual void reportError(const RecognitionException& ex);
250			/// Parser error-reporting function can be overridden in subclass
251			virtual void reportError(const ANTLR_USE_NAMESPACE(std)string& s);
252			/// Parser warning-reporting function can be overridden in subclass
253			virtual void reportWarning(const ANTLR_USE_NAMESPACE(std)string& s);
254
255			/// get the token name for the token number 'num'
256			virtual const char* getTokenName(int num) const = 0;
257			/// get a vector with all token names
258			virtual const char* const* getTokenNames() const = 0;
259			/** Get the number of tokens defined.
260			* This one should be overridden in subclasses.
261			*/
262			virtual int getNumTokens(void) const = 0;
263
264			/** Set or change the input token buffer */
265			// void setTokenBuffer(TokenBuffer<Token>* t);
266
267			virtual void traceIndent();
268			virtual void traceIn(const char* rname);
269			virtual void traceOut(const char* rname);
270			protected:
271			// void setTokenNames(const char** tokenNames_);
272
273			ParserSharedInputState inputState;
274
275			// /// AST return value for a rule is squirreled away here
276			// RefAST returnAST;
277
278			/// AST support code; parser and treeparser delegate to this object
279			ASTFactory *astFactory;
280
281			// used to keep track of the indentation for the trace
282			int traceDepth;
283
284			/** Utility class which allows tracing to work even when exceptions are
285			* thrown.
286			*/
287			class Tracer { /{{{/
288			private:
289			Parser* parser;
290			const char* text;
291			public:
292			Tracer(Parser* p,const char * t)
293			: parser(p), text(t)
294			{
295			parser->traceIn(text);
296			}
297			~Tracer()
298			{
299			#ifdef ANTLR_CXX_SUPPORTS_UNCAUGHT_EXCEPTION
300			// Only give trace if there's no uncaught exception..
301			if(!ANTLR_USE_NAMESPACE(std)uncaught_exception())
302			#endif
303			parser->traceOut(text);
304			}
305			private:
306			Tracer(const Tracer&); // undefined
307			const Tracer& operator=(const Tracer&); // undefined
308			/}}}/
309			};
310			private:
311			Parser(const Parser&); // undefined
312			const Parser& operator=(const Parser&); // undefined
313			};
314
315			#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
316			}
317			#endif
318
319			#endif //INC_Parser_hpp__