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: Parser.hpp,v 1.1 2005-12-02 15:38:02 tim Exp $
 */

#include <iostream>
#include <exception>

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