runtime/Cpp/include/antlr3exception.inl - platform/external/antlr - Git at Google

 ANTLR_BEGIN_NAMESPACE()

 template<class ImplTraits, class StreamType>
 ANTLR_ExceptionBase<ImplTraits, StreamType>::ANTLR_ExceptionBase(const StringType& message)
 	:m_message(message)
 	,m_input(NULL)
 {
 	m_index = 0;
 	m_token	= NULL;
 	m_expecting = 0;
 	m_expectingSet = NULL;
 	m_node = NULL;
 	m_c = 0;
 	m_line = 0;
 	m_charPositionInLine = 0;
 	m_decisionNum = 0;
 	m_state = 0;
 	m_nextException = NULL;
 }

 template<class ImplTraits, class StreamType>
 ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_message()
 {
 	return m_message;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_streamName()
 {
 	return m_streamName;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE ANTLR_MARKER ANTLR_ExceptionBase<ImplTraits, StreamType>::get_index() const
 {
 	return m_index;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE const typename ANTLR_ExceptionBase<ImplTraits, StreamType>::TokenType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_token() const
 {
 	return m_token;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::ExceptionBaseType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_nextException() const
 {
 	return m_nextException;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_expecting() const
 {
 	return m_expecting;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::BitsetListType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_expectingSet() const
 {
 	return m_expectingSet;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::TokenType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_node() const
 {
 	return m_node;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE ANTLR_UCHAR ANTLR_ExceptionBase<ImplTraits, StreamType>::get_c() const
 {
 	return m_c;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_line() const
 {
 	return m_line;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE ANTLR_INT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_charPositionInLine() const
 {
 	return m_charPositionInLine;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_decisionNum() const
 {
 	return m_decisionNum;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_state() const
 {
 	return m_state;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_ruleName()
 {
 	return m_ruleName;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::IntStreamType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_input() const
 {
 	return m_input;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_message( const StringType& message )
 {
 	m_message = message;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_streamName( const StringType& streamName )
 {
 	m_streamName = streamName;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_index( ANTLR_MARKER index )
 {
 	m_index = index;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_token( const TokenType* token )
 {
 	m_token = token;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_nextException( ExceptionBaseType* nextException )
 {
 	m_nextException = nextException;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_expecting( ANTLR_UINT32 expecting )
 {
 	m_expecting = expecting;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_expectingSet( BitsetListType* expectingSet )
 {
 	m_expectingSet = expectingSet;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_node( TokenType* node )
 {
 	m_node = node;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_c( ANTLR_UCHAR c )
 {
 	m_c = c;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_line( ANTLR_UINT32 line )
 {
 	m_line = line;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_charPositionInLine( ANTLR_INT32 charPositionInLine )
 {
 	m_charPositionInLine = charPositionInLine;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_decisionNum( ANTLR_UINT32 decisionNum )
 {
 	m_decisionNum = decisionNum;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_state( ANTLR_UINT32 state )
 {
 	m_state = state;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_ruleName( const StringType& ruleName )
 {
 	m_ruleName = ruleName;
 }
 template<class ImplTraits, class StreamType>
 ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_input( IntStreamType* input )
 {
 	m_input = input;
 }


 template<class ImplTraits, ExceptionType Ex, class StreamType>
 	template<typename BaseRecognizerType>
 ANTLR_Exception<ImplTraits, Ex, StreamType>::ANTLR_Exception(BaseRecognizerType* recognizer, const StringType& message)
 	:BaseType( message )
 {
 	recognizer->get_super()->fillExceptionData( this );
 	BaseType::m_input	= recognizer->get_super()->get_istream();
 	BaseType::m_nextException	= recognizer->get_state()->get_exception();	/* So we don't leak the memory */
 	recognizer->get_state()->set_exception(this);
 	recognizer->get_state()->set_error( true );	    /* Exception is outstanding	*/
 }

 template<class ImplTraits, ExceptionType Ex, class StreamType>
 ANTLR_UINT32 ANTLR_Exception<ImplTraits, Ex, StreamType>::getType() const
 {
 	return static_cast<ANTLR_UINT32>(Ex);
 }

 template<class ImplTraits, ExceptionType Ex, class StreamType>
 void ANTLR_Exception<ImplTraits, Ex, StreamType>::print() const
 {
    /* Ensure valid pointer
      */
 	/* Number if no message, else the message
 	*/
 	if  ( BaseType::m_message.empty() )
 	{
 		fprintf(stderr, "ANTLR3_EXCEPTION number %d (%08X).\n", Ex, Ex);
 	}
 	else
 	{
 		fprintf(stderr, "ANTLR3_EXCEPTION: %s\n", BaseType::m_message.c_str() );
 	}
 }

 template<class ImplTraits, ExceptionType Ex, class StreamType>
 typename ANTLR_Exception<ImplTraits, Ex, StreamType>::StringType
 	ANTLR_Exception<ImplTraits, Ex, StreamType>::getName() const
 {
 	const char* exArray[] = {
 						"org.antlr.runtime.RecognitionException"
 						, "org.antlr.runtime.MismatchedTokenException"
 						, "org.antlr.runtime.NoViableAltException"
 						, "org.antlr.runtime.MismatchedSetException"
 						, "org.antlr.runtime.EarlyExitException"
 						, "org.antlr.runtime.FailedPredicateException"
 						, "org.antlr.runtime.MismatchedTreeNodeException"
 						, "org.antlr.runtime.tree.RewriteEarlyExitException"
 						, "org.antlr.runtime.UnwantedTokenException"
 						, "org.antlr.runtime.MissingTokenException"
 					  };
 	return StringType(exArray[Ex]);
 }

 template<class ImplTraits, ExceptionType Ex, class StreamType>
 void ANTLR_Exception<ImplTraits, Ex, StreamType>::displayRecognitionError( ANTLR_UINT8** tokenNames,
 																			StringStreamType& str_stream ) const
 {
 	switch( Ex )
 	{
 	case RECOGNITION_EXCEPTION:
 		// Indicates that the recognizer received a token
 		// in the input that was not predicted. This is the basic exception type
 		// from which all others are derived. So we assume it was a syntax error.
 		// You may get this if there are not more tokens and more are needed
 		// to complete a parse for instance.
 		//
 		str_stream << " : syntax error...\n";
 		break;
 	case UNWANTED_TOKEN_EXCEPTION:
 		// Indicates that the recognizer was fed a token which seesm to be
 		// spurious input. We can detect this when the token that follows
 		// this unwanted token would normally be part of the syntactically
 		// correct stream. Then we can see that the token we are looking at
 		// is just something that should not be there and throw this exception.
 		//
 		if	(tokenNames == NULL)
 		{
 			str_stream << " : Extraneous input...";
 		}
 		else
 		{
 			if	( BaseType::m_expecting == ImplTraits::CommonTokenType::TOKEN_EOF)
 			{
 				str_stream << " : Extraneous input - expected <EOF>\n";
 			}
 			else
 			{
 				str_stream << " : Extraneous input - expected "
 						   << tokenNames[ BaseType::m_expecting] << " ...\n";
 			}
 		}
 		break;
 	case MISSING_TOKEN_EXCEPTION:
 		// Indicates that the recognizer detected that the token we just
 		// hit would be valid syntactically if preceeded by a particular
 		// token. Perhaps a missing ';' at line end or a missing ',' in an
 		// expression list, and such like.
 		//
 		if	(tokenNames == NULL)
 		{
 			str_stream << " : Missing token ("
 					   << BaseType::m_expecting << ")...\n";
 		}
 		else
 		{
 			if	( BaseType::m_expecting == ImplTraits::CommonTokenType::TOKEN_EOF )
 			{
 				str_stream <<" : Missing <EOF>\n";
 			}
 			else
 			{
 				str_stream << " : Missing " << tokenNames[BaseType::m_expecting] <<" \n";
 			}
 		}
 		break;
 	case NO_VIABLE_ALT_EXCEPTION:
 		// We could not pick any alt decision from the input given
 		// so god knows what happened - however when you examine your grammar,
 		// you should. It means that at the point where the current token occurred
 		// that the DFA indicates nowhere to go from here.
 		//
 		str_stream << " : cannot match to any predicted input...\n";
 		break;
 	case MISMATCHED_SET_EXCEPTION:
 		{
 			ANTLR_UINT32	  count;
 			ANTLR_UINT32	  bit;
 			ANTLR_UINT32	  size;
 			ANTLR_UINT32	  numbits;
 			BitsetType*	  errBits;

 			// This means we were able to deal with one of a set of
 			// possible tokens at this point, but we did not see any
 			// member of that set.
 			//
 			str_stream << " : unexpected input...\n  expected one of : ";

 			// What tokens could we have accepted at this point in the
 			// parse?
 			//
 			count   = 0;
 			errBits = BaseType::m_expectingSet->bitsetLoad();
 			numbits = errBits->numBits();
 			size    = errBits->size();

 			if  (size > 0)
 			{
 				// However many tokens we could have dealt with here, it is usually
 				// not useful to print ALL of the set here. I arbitrarily chose 8
 				// here, but you should do whatever makes sense for you of course.
 				// No token number 0, so look for bit 1 and on.
 				//
 				for	(bit = 1; bit < numbits && count < 8 && count < size; bit++)
 				{
 					// TODO: This doesn;t look right - should be asking if the bit is set!!
 					//
 					if  (tokenNames[bit])
 					{
 						str_stream <<  ( count > 0 ? ", " : "" )
 								   <<  tokenNames[bit];
 						count++;
 					}
 				}
 				str_stream << "\n";
 			}
 			else
 			{
 				str_stream << "Actually dude, we didn't seem to be expecting anything here, or at least\n";
 				str_stream << "I could not work out what I was expecting, like so many of us these days!\n";
 			}
 		}
 		break;
 	case EARLY_EXIT_EXCEPTION:
 		str_stream << " : missing elements...\n";
 		break;
 	default:
 		str_stream << " : syntax not recognized...\n";
 		break;
 	}
 }

 template<class ImplTraits, class StreamType>
 ANTLR_ExceptionBase<ImplTraits,StreamType>::~ANTLR_ExceptionBase()
 {
 	ANTLR_ExceptionBase<ImplTraits,StreamType>* next;
 	ANTLR_ExceptionBase<ImplTraits,StreamType>* ex = m_nextException;

     /* Ensure valid pointer
      */
     while   (ex != NULL)
     {
 		/* Pick up anythign following now, before we free the
 		 * current memory block.
 		 */
 		next	= ex->m_nextException;
 		ex->m_nextException = NULL;

 		/* Free the actual structure itself
 		 */
 		delete ex;

 		ex = next;
     }
 }

 ANTLR_END_NAMESPACE()
	ANTLR_BEGIN_NAMESPACE()

	template<class ImplTraits, class StreamType>
	ANTLR_ExceptionBase<ImplTraits, StreamType>::ANTLR_ExceptionBase(const StringType& message)
	:m_message(message)
	,m_input(NULL)
	{
	m_index = 0;
	m_token = NULL;
	m_expecting = 0;
	m_expectingSet = NULL;
	m_node = NULL;
	m_c = 0;
	m_line = 0;
	m_charPositionInLine = 0;
	m_decisionNum = 0;
	m_state = 0;
	m_nextException = NULL;
	}

	template<class ImplTraits, class StreamType>
	ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_message()
	{
	return m_message;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_streamName()
	{
	return m_streamName;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE ANTLR_MARKER ANTLR_ExceptionBase<ImplTraits, StreamType>::get_index() const
	{
	return m_index;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE const typename ANTLR_ExceptionBase<ImplTraits, StreamType>::TokenType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_token() const
	{
	return m_token;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::ExceptionBaseType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_nextException() const
	{
	return m_nextException;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_expecting() const
	{
	return m_expecting;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::BitsetListType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_expectingSet() const
	{
	return m_expectingSet;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::TokenType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_node() const
	{
	return m_node;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE ANTLR_UCHAR ANTLR_ExceptionBase<ImplTraits, StreamType>::get_c() const
	{
	return m_c;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_line() const
	{
	return m_line;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE ANTLR_INT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_charPositionInLine() const
	{
	return m_charPositionInLine;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_decisionNum() const
	{
	return m_decisionNum;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE ANTLR_UINT32 ANTLR_ExceptionBase<ImplTraits, StreamType>::get_state() const
	{
	return m_state;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::StringType& ANTLR_ExceptionBase<ImplTraits, StreamType>::get_ruleName()
	{
	return m_ruleName;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE typename ANTLR_ExceptionBase<ImplTraits, StreamType>::IntStreamType* ANTLR_ExceptionBase<ImplTraits, StreamType>::get_input() const
	{
	return m_input;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_message( const StringType& message )
	{
	m_message = message;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_streamName( const StringType& streamName )
	{
	m_streamName = streamName;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_index( ANTLR_MARKER index )
	{
	m_index = index;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_token( const TokenType* token )
	{
	m_token = token;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_nextException( ExceptionBaseType* nextException )
	{
	m_nextException = nextException;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_expecting( ANTLR_UINT32 expecting )
	{
	m_expecting = expecting;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_expectingSet( BitsetListType* expectingSet )
	{
	m_expectingSet = expectingSet;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_node( TokenType* node )
	{
	m_node = node;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_c( ANTLR_UCHAR c )
	{
	m_c = c;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_line( ANTLR_UINT32 line )
	{
	m_line = line;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_charPositionInLine( ANTLR_INT32 charPositionInLine )
	{
	m_charPositionInLine = charPositionInLine;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_decisionNum( ANTLR_UINT32 decisionNum )
	{
	m_decisionNum = decisionNum;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_state( ANTLR_UINT32 state )
	{
	m_state = state;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_ruleName( const StringType& ruleName )
	{
	m_ruleName = ruleName;
	}
	template<class ImplTraits, class StreamType>
	ANTLR_INLINE void ANTLR_ExceptionBase<ImplTraits, StreamType>::set_input( IntStreamType* input )
	{
	m_input = input;
	}


	template<class ImplTraits, ExceptionType Ex, class StreamType>
	template<typename BaseRecognizerType>
	ANTLR_Exception<ImplTraits, Ex, StreamType>::ANTLR_Exception(BaseRecognizerType* recognizer, const StringType& message)
	:BaseType( message )
	{
	recognizer->get_super()->fillExceptionData( this );
	BaseType::m_input = recognizer->get_super()->get_istream();
	BaseType::m_nextException = recognizer->get_state()->get_exception(); /* So we don't leak the memory */
	recognizer->get_state()->set_exception(this);
	recognizer->get_state()->set_error( true ); /* Exception is outstanding */
	}

	template<class ImplTraits, ExceptionType Ex, class StreamType>
	ANTLR_UINT32 ANTLR_Exception<ImplTraits, Ex, StreamType>::getType() const
	{
	return static_cast<ANTLR_UINT32>(Ex);
	}

	template<class ImplTraits, ExceptionType Ex, class StreamType>
	void ANTLR_Exception<ImplTraits, Ex, StreamType>::print() const
	{
	/* Ensure valid pointer
	*/
	/* Number if no message, else the message
	*/
	if ( BaseType::m_message.empty() )
	{
	fprintf(stderr, "ANTLR3_EXCEPTION number %d (%08X).\n", Ex, Ex);
	}
	else
	{
	fprintf(stderr, "ANTLR3_EXCEPTION: %s\n", BaseType::m_message.c_str() );
	}
	}

	template<class ImplTraits, ExceptionType Ex, class StreamType>
	typename ANTLR_Exception<ImplTraits, Ex, StreamType>::StringType
	ANTLR_Exception<ImplTraits, Ex, StreamType>::getName() const
	{
	const char* exArray[] = {
	"org.antlr.runtime.RecognitionException"
	, "org.antlr.runtime.MismatchedTokenException"
	, "org.antlr.runtime.NoViableAltException"
	, "org.antlr.runtime.MismatchedSetException"
	, "org.antlr.runtime.EarlyExitException"
	, "org.antlr.runtime.FailedPredicateException"
	, "org.antlr.runtime.MismatchedTreeNodeException"
	, "org.antlr.runtime.tree.RewriteEarlyExitException"
	, "org.antlr.runtime.UnwantedTokenException"
	, "org.antlr.runtime.MissingTokenException"
	};
	return StringType(exArray[Ex]);
	}

	template<class ImplTraits, ExceptionType Ex, class StreamType>
	void ANTLR_Exception<ImplTraits, Ex, StreamType>::displayRecognitionError( ANTLR_UINT8** tokenNames,
	StringStreamType& str_stream ) const
	{
	switch( Ex )
	{
	case RECOGNITION_EXCEPTION:
	// Indicates that the recognizer received a token
	// in the input that was not predicted. This is the basic exception type
	// from which all others are derived. So we assume it was a syntax error.
	// You may get this if there are not more tokens and more are needed
	// to complete a parse for instance.
	//
	str_stream << " : syntax error...\n";
	break;
	case UNWANTED_TOKEN_EXCEPTION:
	// Indicates that the recognizer was fed a token which seesm to be
	// spurious input. We can detect this when the token that follows
	// this unwanted token would normally be part of the syntactically
	// correct stream. Then we can see that the token we are looking at
	// is just something that should not be there and throw this exception.
	//
	if (tokenNames == NULL)
	{
	str_stream << " : Extraneous input...";
	}
	else
	{
	if ( BaseType::m_expecting == ImplTraits::CommonTokenType::TOKEN_EOF)
	{
	str_stream << " : Extraneous input - expected <EOF>\n";
	}
	else
	{
	str_stream << " : Extraneous input - expected "
	<< tokenNames[ BaseType::m_expecting] << " ...\n";
	}
	}
	break;
	case MISSING_TOKEN_EXCEPTION:
	// Indicates that the recognizer detected that the token we just
	// hit would be valid syntactically if preceeded by a particular
	// token. Perhaps a missing ';' at line end or a missing ',' in an
	// expression list, and such like.
	//
	if (tokenNames == NULL)
	{
	str_stream << " : Missing token ("
	<< BaseType::m_expecting << ")...\n";
	}
	else
	{
	if ( BaseType::m_expecting == ImplTraits::CommonTokenType::TOKEN_EOF )
	{
	str_stream <<" : Missing <EOF>\n";
	}
	else
	{
	str_stream << " : Missing " << tokenNames[BaseType::m_expecting] <<" \n";
	}
	}
	break;
	case NO_VIABLE_ALT_EXCEPTION:
	// We could not pick any alt decision from the input given
	// so god knows what happened - however when you examine your grammar,
	// you should. It means that at the point where the current token occurred
	// that the DFA indicates nowhere to go from here.
	//
	str_stream << " : cannot match to any predicted input...\n";
	break;
	case MISMATCHED_SET_EXCEPTION:
	{
	ANTLR_UINT32 count;
	ANTLR_UINT32 bit;
	ANTLR_UINT32 size;
	ANTLR_UINT32 numbits;
	BitsetType* errBits;

	// This means we were able to deal with one of a set of
	// possible tokens at this point, but we did not see any
	// member of that set.
	//
	str_stream << " : unexpected input...\n expected one of : ";

	// What tokens could we have accepted at this point in the
	// parse?
	//
	count = 0;
	errBits = BaseType::m_expectingSet->bitsetLoad();
	numbits = errBits->numBits();
	size = errBits->size();

	if (size > 0)
	{
	// However many tokens we could have dealt with here, it is usually
	// not useful to print ALL of the set here. I arbitrarily chose 8
	// here, but you should do whatever makes sense for you of course.
	// No token number 0, so look for bit 1 and on.
	//
	for (bit = 1; bit < numbits && count < 8 && count < size; bit++)
	{
	// TODO: This doesn;t look right - should be asking if the bit is set!!
	//
	if (tokenNames[bit])
	{
	str_stream << ( count > 0 ? ", " : "" )
	<< tokenNames[bit];
	count++;
	}
	}
	str_stream << "\n";
	}
	else
	{
	str_stream << "Actually dude, we didn't seem to be expecting anything here, or at least\n";
	str_stream << "I could not work out what I was expecting, like so many of us these days!\n";
	}
	}
	break;
	case EARLY_EXIT_EXCEPTION:
	str_stream << " : missing elements...\n";
	break;
	default:
	str_stream << " : syntax not recognized...\n";
	break;
	}
	}

	template<class ImplTraits, class StreamType>
	ANTLR_ExceptionBase<ImplTraits,StreamType>::~ANTLR_ExceptionBase()
	{
	ANTLR_ExceptionBase<ImplTraits,StreamType>* next;
	ANTLR_ExceptionBase<ImplTraits,StreamType>* ex = m_nextException;

	/* Ensure valid pointer
	*/
	while (ex != NULL)
	{
	/* Pick up anythign following now, before we free the
	* current memory block.
	*/
	next = ex->m_nextException;
	ex->m_nextException = NULL;

	/* Free the actual structure itself
	*/
	delete ex;

	ex = next;
	}
	}

	ANTLR_END_NAMESPACE()