1ANTLR_BEGIN_NAMESPACE()
2
3template<class ImplTraits, class StreamType>
4ANTLR_ExceptionBase<ImplTraits, StreamType>::ANTLR_ExceptionBase(const StringType& message)
5	:m_message(message)
6	,m_input(NULL)
7{
8	m_index = 0;
9	m_token	= NULL;
10	m_expecting = 0;
11	m_expectingSet = NULL;
12	m_node = NULL;
13	m_c = 0;
14	m_line = 0;
15	m_charPositionInLine = 0;
16	m_decisionNum = 0;
17	m_state = 0;
18	m_nextException = NULL;
19}
20
21template<class ImplTraits, class StreamType>
22ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_message()
23{
24	return m_message;
25}
26template<class ImplTraits, class StreamType>
27ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_streamName()
28{
29	return m_streamName;
30}
31template<class ImplTraits, class StreamType>
32ANTLR_INLINE ANTLR_MARKER ANTLR_ExceptionBase<ImplTraits, StreamType>::get_index() const
33{
34	return m_index;
35}
36template<class ImplTraits, class StreamType>
37ANTLR_INLINE const typename ANTLR_ExceptionBase<ImplTraits, StreamType>::TokenType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_token() const
38{
39	return m_token;
40}
41template<class ImplTraits, class StreamType>
42ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::ExceptionBaseType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_nextException() const
43{
44	return m_nextException;
45}
46template<class ImplTraits, class StreamType>
47ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_expecting() const
48{
49	return m_expecting;
50}
51template<class ImplTraits, class StreamType>
52ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::BitsetListType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_expectingSet() const
53{
54	return m_expectingSet;
55}
56template<class ImplTraits, class StreamType>
57ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::TokenType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_node() const
58{
59	return m_node;
60}
61template<class ImplTraits, class StreamType>
62ANTLR_INLINE ANTLR_UCHAR ANTLR_ExceptionBase<ImplTraits, StreamType>::get_c() const
63{
64	return m_c;
65}
66template<class ImplTraits, class StreamType>
67ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_line() const
68{
69	return m_line;
70}
71template<class ImplTraits, class StreamType>
72ANTLR_INLINE ANTLR_INT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_charPositionInLine() const
73{
74	return m_charPositionInLine;
75}
76template<class ImplTraits, class StreamType>
77ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_decisionNum() const
78{
79	return m_decisionNum;
80}
81template<class ImplTraits, class StreamType>
82ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_state() const
83{
84	return m_state;
85}
86template<class ImplTraits, class StreamType>
87ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_ruleName()
88{
89	return m_ruleName;
90}
91template<class ImplTraits, class StreamType>
92ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::IntStreamType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_input() const
93{
94	return m_input;
95}
96template<class ImplTraits, class StreamType>
97ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_message( const StringType& message )
98{
99	m_message = message;
100}
101template<class ImplTraits, class StreamType>
102ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_streamName( const StringType& streamName )
103{
104	m_streamName = streamName;
105}
106template<class ImplTraits, class StreamType>
107ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_index( ANTLR_MARKER index )
108{
109	m_index = index;
110}
111template<class ImplTraits, class StreamType>
112ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_token( const TokenType* token )
113{
114	m_token = token;
115}
116template<class ImplTraits, class StreamType>
117ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_nextException( ExceptionBaseType* nextException )
118{
119	m_nextException = nextException;
120}
121template<class ImplTraits, class StreamType>
122ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_expecting( ANTLR_UINT32 expecting )
123{
124	m_expecting = expecting;
125}
126template<class ImplTraits, class StreamType>
127ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_expectingSet( BitsetListType* expectingSet )
128{
129	m_expectingSet = expectingSet;
130}
131template<class ImplTraits, class StreamType>
132ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_node( TokenType* node )
133{
134	m_node = node;
135}
136template<class ImplTraits, class StreamType>
137ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_c( ANTLR_UCHAR c )
138{
139	m_c = c;
140}
141template<class ImplTraits, class StreamType>
142ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_line( ANTLR_UINT32 line )
143{
144	m_line = line;
145}
146template<class ImplTraits, class StreamType>
147ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_charPositionInLine( ANTLR_INT32 charPositionInLine )
148{
149	m_charPositionInLine = charPositionInLine;
150}
151template<class ImplTraits, class StreamType>
152ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_decisionNum( ANTLR_UINT32 decisionNum )
153{
154	m_decisionNum = decisionNum;
155}
156template<class ImplTraits, class StreamType>
157ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_state( ANTLR_UINT32 state )
158{
159	m_state = state;
160}
161template<class ImplTraits, class StreamType>
162ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_ruleName( const StringType& ruleName )
163{
164	m_ruleName = ruleName;
165}
166template<class ImplTraits, class StreamType>
167ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_input( IntStreamType* input )
168{
169	m_input = input;
170}
171
172
173template<class ImplTraits, ExceptionType Ex, class StreamType>
174	template<typename BaseRecognizerType>
175ANTLR_Exception<ImplTraits, Ex, StreamType>::ANTLR_Exception(BaseRecognizerType* recognizer, const StringType& message)
176	:BaseType( message )
177{
178	recognizer->get_super()->fillExceptionData( this );
179	BaseType::m_input	= recognizer->get_super()->get_istream();
180	BaseType::m_nextException	= recognizer->get_state()->get_exception();	/* So we don't leak the memory */
181	recognizer->get_state()->set_exception(this);
182	recognizer->get_state()->set_error( true );	    /* Exception is outstanding	*/
183}
184
185template<class ImplTraits, ExceptionType Ex, class StreamType>
186ANTLR_UINT32 ANTLR_Exception<ImplTraits, Ex, StreamType>::getType() const
187{
188	return static_cast<ANTLR_UINT32>(Ex);
189}
190
191template<class ImplTraits, ExceptionType Ex, class StreamType>
192void ANTLR_Exception<ImplTraits, Ex, StreamType>::print() const
193{
194   /* Ensure valid pointer
195     */
196	/* Number if no message, else the message
197	*/
198	if  ( BaseType::m_message.empty() )
199	{
200		fprintf(stderr, "ANTLR3_EXCEPTION number %d (%08X).\n", Ex, Ex);
201	}
202	else
203	{
204		fprintf(stderr, "ANTLR3_EXCEPTION: %s\n", BaseType::m_message.c_str() );
205	}
206}
207
208template<class ImplTraits, ExceptionType Ex, class StreamType>
209typename ANTLR_Exception<ImplTraits, Ex, StreamType>::StringType
210	ANTLR_Exception<ImplTraits, Ex, StreamType>::getName() const
211{
212	const char* exArray[] = {
213						"org.antlr.runtime.RecognitionException"
214						, "org.antlr.runtime.MismatchedTokenException"
215						, "org.antlr.runtime.NoViableAltException"
216						, "org.antlr.runtime.MismatchedSetException"
217						, "org.antlr.runtime.EarlyExitException"
218						, "org.antlr.runtime.FailedPredicateException"
219						, "org.antlr.runtime.MismatchedTreeNodeException"
220						, "org.antlr.runtime.tree.RewriteEarlyExitException"
221						, "org.antlr.runtime.UnwantedTokenException"
222						, "org.antlr.runtime.MissingTokenException"
223					  };
224	return StringType(exArray[Ex]);
225}
226
227template<class ImplTraits, ExceptionType Ex, class StreamType>
228void ANTLR_Exception<ImplTraits, Ex, StreamType>::displayRecognitionError( ANTLR_UINT8** tokenNames,
229																			StringStreamType& str_stream ) const
230{
231	switch( Ex )
232	{
233	case RECOGNITION_EXCEPTION:
234		// Indicates that the recognizer received a token
235		// in the input that was not predicted. This is the basic exception type
236		// from which all others are derived. So we assume it was a syntax error.
237		// You may get this if there are not more tokens and more are needed
238		// to complete a parse for instance.
239		//
240		str_stream << " : syntax error...\n";
241		break;
242	case UNWANTED_TOKEN_EXCEPTION:
243		// Indicates that the recognizer was fed a token which seesm to be
244		// spurious input. We can detect this when the token that follows
245		// this unwanted token would normally be part of the syntactically
246		// correct stream. Then we can see that the token we are looking at
247		// is just something that should not be there and throw this exception.
248		//
249		if	(tokenNames == NULL)
250		{
251			str_stream << " : Extraneous input...";
252		}
253		else
254		{
255			if	( BaseType::m_expecting == ImplTraits::CommonTokenType::TOKEN_EOF)
256			{
257				str_stream << " : Extraneous input - expected <EOF>\n";
258			}
259			else
260			{
261				str_stream << " : Extraneous input - expected "
262						   << tokenNames[ BaseType::m_expecting] << " ...\n";
263			}
264		}
265		break;
266	case MISSING_TOKEN_EXCEPTION:
267		// Indicates that the recognizer detected that the token we just
268		// hit would be valid syntactically if preceeded by a particular
269		// token. Perhaps a missing ';' at line end or a missing ',' in an
270		// expression list, and such like.
271		//
272		if	(tokenNames == NULL)
273		{
274			str_stream << " : Missing token ("
275					   << BaseType::m_expecting << ")...\n";
276		}
277		else
278		{
279			if	( BaseType::m_expecting == ImplTraits::CommonTokenType::TOKEN_EOF )
280			{
281				str_stream <<" : Missing <EOF>\n";
282			}
283			else
284			{
285				str_stream << " : Missing " << tokenNames[BaseType::m_expecting] <<" \n";
286			}
287		}
288		break;
289	case NO_VIABLE_ALT_EXCEPTION:
290		// We could not pick any alt decision from the input given
291		// so god knows what happened - however when you examine your grammar,
292		// you should. It means that at the point where the current token occurred
293		// that the DFA indicates nowhere to go from here.
294		//
295		str_stream << " : cannot match to any predicted input...\n";
296		break;
297	case MISMATCHED_SET_EXCEPTION:
298		{
299			ANTLR_UINT32	  count;
300			ANTLR_UINT32	  bit;
301			ANTLR_UINT32	  size;
302			ANTLR_UINT32	  numbits;
303			BitsetType*	  errBits;
304
305			// This means we were able to deal with one of a set of
306			// possible tokens at this point, but we did not see any
307			// member of that set.
308			//
309			str_stream << " : unexpected input...\n  expected one of : ";
310
311			// What tokens could we have accepted at this point in the
312			// parse?
313			//
314			count   = 0;
315			errBits = BaseType::m_expectingSet->bitsetLoad();
316			numbits = errBits->numBits();
317			size    = errBits->size();
318
319			if  (size > 0)
320			{
321				// However many tokens we could have dealt with here, it is usually
322				// not useful to print ALL of the set here. I arbitrarily chose 8
323				// here, but you should do whatever makes sense for you of course.
324				// No token number 0, so look for bit 1 and on.
325				//
326				for	(bit = 1; bit < numbits && count < 8 && count < size; bit++)
327				{
328					// TODO: This doesn;t look right - should be asking if the bit is set!!
329					//
330					if  (tokenNames[bit])
331					{
332						str_stream <<  ( count > 0 ? ", " : "" )
333								   <<  tokenNames[bit];
334						count++;
335					}
336				}
337				str_stream << "\n";
338			}
339			else
340			{
341				str_stream << "Actually dude, we didn't seem to be expecting anything here, or at least\n";
342				str_stream << "I could not work out what I was expecting, like so many of us these days!\n";
343			}
344		}
345		break;
346	case EARLY_EXIT_EXCEPTION:
347		str_stream << " : missing elements...\n";
348		break;
349	default:
350		str_stream << " : syntax not recognized...\n";
351		break;
352	}
353}
354
355template<class ImplTraits, class StreamType>
356ANTLR_ExceptionBase<ImplTraits,StreamType>::~ANTLR_ExceptionBase()
357{
358	ANTLR_ExceptionBase<ImplTraits,StreamType>* next;
359	ANTLR_ExceptionBase<ImplTraits,StreamType>* ex = m_nextException;
360
361    /* Ensure valid pointer
362     */
363    while   (ex != NULL)
364    {
365		/* Pick up anythign following now, before we free the
366		 * current memory block.
367		 */
368		next	= ex->m_nextException;
369		ex->m_nextException = NULL;
370
371		/* Free the actual structure itself
372		 */
373		delete ex;
374
375		ex = next;
376    }
377}
378
379ANTLR_END_NAMESPACE()
380