You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
380 lines
12 KiB
380 lines
12 KiB
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()
|