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.
210 lines
7.8 KiB
210 lines
7.8 KiB
/** \file
|
|
* Contains the definition of a basic ANTLR3 exception structure created
|
|
* by a recognizer when errors are found/predicted.
|
|
|
|
* Two things to be noted for C++ Target:
|
|
a) This is not the C++ Exception. Consider this just as yet another class. This
|
|
has to be like this because there is a inbuilt recovery and hence there is a try..catch
|
|
block for every new token. This is not how C++ Exceptions work.Still there is exception support, as we are handling things like OutofMemory by
|
|
throwing exceptions
|
|
|
|
b) There is no use in implementing templates here, as all the exceptions are grouped in
|
|
one container and hence needs virtual functions. But this would occur only when there is
|
|
a exception/ while deleting base recognizer. So shouldn't incur the overhead in normal operation
|
|
*/
|
|
#ifndef _ANTLR3_EXCEPTION_HPP
|
|
#define _ANTLR3_EXCEPTION_HPP
|
|
|
|
// [The "BSD licence"]
|
|
// Copyright (c) 2005-2009 Gokulakannan Somasundaram, ElectronDB
|
|
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions
|
|
// are met:
|
|
// 1. Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// 2. Redistributions in binary form must reproduce the above copyright
|
|
// notice, this list of conditions and the following disclaimer in the
|
|
// documentation and/or other materials provided with the distribution.
|
|
// 3. The name of the author may not be used to endorse or promote products
|
|
// derived from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#include "antlr3defs.hpp"
|
|
|
|
ANTLR_BEGIN_NAMESPACE()
|
|
|
|
/** Base structure for an ANTLR3 exception tracker
|
|
*/
|
|
|
|
template<class ImplTraits, class StreamType>
|
|
class ANTLR_ExceptionBase
|
|
{
|
|
public:
|
|
typedef typename StreamType::UnitType TokenType;
|
|
typedef typename StreamType::IntStreamType IntStreamType;
|
|
typedef typename ImplTraits::AllocPolicyType AllocPolicyType;
|
|
typedef typename ImplTraits::StringType StringType;
|
|
typedef typename ImplTraits::StringStreamType StringStreamType;
|
|
typedef typename ImplTraits::BitsetType BitsetType;
|
|
typedef typename ImplTraits::BitsetListType BitsetListType;
|
|
typedef typename ImplTraits::template ExceptionBaseType<StreamType> ExceptionBaseType;
|
|
|
|
protected:
|
|
/** The printable message that goes with this exception, in your preferred
|
|
* encoding format. ANTLR just uses ASCII by default but you can ignore these
|
|
* messages or convert them to another format or whatever of course. They are
|
|
* really internal messages that you then decide how to print out in a form that
|
|
* the users of your product will understand, as they are unlikely to know what
|
|
* to do with "Recognition exception at: [[TOK_GERUND..... " ;-)
|
|
*/
|
|
StringType m_message;
|
|
|
|
/** Name of the file/input source for reporting. Note that this may be empty!!
|
|
*/
|
|
StringType m_streamName;
|
|
|
|
/** Indicates the index of the 'token' we were looking at when the
|
|
* exception occurred.
|
|
*/
|
|
ANTLR_MARKER m_index;
|
|
|
|
/** Indicates what the current token/tree was when the error occurred. Since not
|
|
* all input streams will be able to retrieve the nth token, we track it here
|
|
* instead. This is for parsers, and even tree parsers may set this.
|
|
*/
|
|
const TokenType* m_token;
|
|
|
|
/** Pointer to the next exception in the chain (if any)
|
|
*/
|
|
ExceptionBaseType* m_nextException;
|
|
|
|
/** Indicates the token we were expecting to see next when the error occurred
|
|
*/
|
|
ANTLR_UINT32 m_expecting;
|
|
|
|
/** Indicates a set of tokens that we were expecting to see one of when the
|
|
* error occurred. It is a following bitset list, so you can use load it and use ->toIntList() on it
|
|
* to generate an array of integer tokens that it represents.
|
|
*/
|
|
BitsetListType* m_expectingSet;
|
|
|
|
/** If this is a tree parser exception then the node is set to point to the node
|
|
* that caused the issue.
|
|
*/
|
|
TokenType* m_node;
|
|
|
|
/** The current character when an error occurred - for lexers.
|
|
*/
|
|
ANTLR_UCHAR m_c;
|
|
|
|
/** Track the line at which the error occurred in case this is
|
|
* generated from a lexer. We need to track this since the
|
|
* unexpected char doesn't carry the line info.
|
|
*/
|
|
ANTLR_UINT32 m_line;
|
|
|
|
/** Character position in the line where the error occurred.
|
|
*/
|
|
ANTLR_INT32 m_charPositionInLine;
|
|
|
|
/** decision number for NVE
|
|
*/
|
|
ANTLR_UINT32 m_decisionNum;
|
|
|
|
/** State for NVE
|
|
*/
|
|
ANTLR_UINT32 m_state;
|
|
|
|
/** Rule name for failed predicate exception
|
|
*/
|
|
StringType m_ruleName;
|
|
|
|
/** Pointer to the input stream that this exception occurred in.
|
|
*/
|
|
IntStreamType* m_input;
|
|
|
|
public:
|
|
StringType& get_message();
|
|
StringType& get_streamName();
|
|
ANTLR_MARKER get_index() const;
|
|
const TokenType* get_token() const;
|
|
ExceptionBaseType* get_nextException() const;
|
|
ANTLR_UINT32 get_expecting() const;
|
|
BitsetListType* get_expectingSet() const;
|
|
TokenType* get_node() const;
|
|
ANTLR_UCHAR get_c() const;
|
|
ANTLR_UINT32 get_line() const;
|
|
ANTLR_INT32 get_charPositionInLine() const;
|
|
ANTLR_UINT32 get_decisionNum() const;
|
|
ANTLR_UINT32 get_state() const;
|
|
StringType& get_ruleName();
|
|
IntStreamType* get_input() const;
|
|
void set_message( const StringType& message );
|
|
void set_streamName( const StringType& streamName );
|
|
void set_index( ANTLR_MARKER index );
|
|
void set_token( const TokenType* token );
|
|
void set_nextException( ExceptionBaseType* nextException );
|
|
void set_expecting( ANTLR_UINT32 expecting );
|
|
void set_expectingSet( BitsetListType* expectingSet );
|
|
void set_node( TokenType* node );
|
|
void set_c( ANTLR_UCHAR c );
|
|
void set_line( ANTLR_UINT32 line );
|
|
void set_charPositionInLine( ANTLR_INT32 charPositionInLine );
|
|
void set_decisionNum( ANTLR_UINT32 decisionNum );
|
|
void set_state( ANTLR_UINT32 state );
|
|
void set_ruleName( const StringType& ruleName );
|
|
void set_input( IntStreamType* input );
|
|
StringType getDescription() const;
|
|
|
|
virtual StringType getName() const = 0;
|
|
virtual ANTLR_UINT32 getType() const = 0;
|
|
virtual void print() const = 0;
|
|
virtual void displayRecognitionError( ANTLR_UINT8** tokenNames, StringStreamType& str ) const = 0;
|
|
|
|
virtual ~ANTLR_ExceptionBase();
|
|
|
|
protected:
|
|
ANTLR_ExceptionBase(const StringType& message);
|
|
};
|
|
|
|
|
|
template<class ImplTraits, ExceptionType Ex, class StreamType>
|
|
class ANTLR_Exception : public ImplTraits::template ExceptionBaseType<StreamType>
|
|
{
|
|
public:
|
|
typedef typename ImplTraits::StringType StringType;
|
|
typedef typename ImplTraits::StringStreamType StringStreamType;
|
|
typedef typename ImplTraits::BitsetType BitsetType;
|
|
typedef typename ImplTraits::template ExceptionBaseType<StreamType> BaseType;
|
|
|
|
public:
|
|
template<typename BaseRecognizerType>
|
|
ANTLR_Exception(BaseRecognizerType* recognizer, const StringType& message);
|
|
|
|
const StringType& get_name() const;
|
|
virtual StringType getName() const;
|
|
virtual ANTLR_UINT32 getType() const;
|
|
virtual void print() const;
|
|
virtual void displayRecognitionError( ANTLR_UINT8** tokenNames, StringStreamType& str_stream) const;
|
|
};
|
|
|
|
ANTLR_END_NAMESPACE()
|
|
|
|
#include "antlr3exception.inl"
|
|
|
|
#endif
|