src/antlr/MismatchedTokenException.cpp

/* ANTLR Translator Generator
 * Project led by Terence Parr at http://www.jGuru.com
 * Software rights: http://www.antlr.org/license.html
 *
 * $Id: MismatchedTokenException.cpp,v 1.1 2005-12-02 15:38:02 tim Exp $
 */

#include "antlr/MismatchedTokenException.hpp"
#include "antlr/String.hpp"

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
namespace antlr {
#endif

MismatchedTokenException::MismatchedTokenException()
  : RecognitionException("Mismatched Token: expecting any AST node","<AST>",-1,-1)
  , token(0)
  , node(nullASTptr)
  , tokenNames(0)
  , numTokens(0)
{
}

// Expected range / not range
MismatchedTokenException::MismatchedTokenException(
        const char* const* tokenNames_,
        const int numTokens_,
        RefAST node_,
        int lower,
        int upper_,
        bool matchNot
) : RecognitionException("Mismatched Token","<AST>",-1,-1)
  , token(0)
  , node(node_)
  , tokenText( (node_ ? node_->toString(): ANTLR_USE_NAMESPACE(std)string("<empty tree>")) )
  , mismatchType(matchNot ? NOT_RANGE : RANGE)
  , expecting(lower)
  , upper(upper_)
  , tokenNames(tokenNames_)
  , numTokens(numTokens_)
{
}

// Expected token / not token
MismatchedTokenException::MismatchedTokenException(
        const char* const* tokenNames_,
        const int numTokens_,
        RefAST node_,
        int expecting_,
        bool matchNot
) : RecognitionException("Mismatched Token","<AST>",-1,-1)
  , token(0)
  , node(node_)
  , tokenText( (node_ ? node_->toString(): ANTLR_USE_NAMESPACE(std)string("<empty tree>")) )
  , mismatchType(matchNot ? NOT_TOKEN : TOKEN)
  , expecting(expecting_)
  , tokenNames(tokenNames_)
  , numTokens(numTokens_)
{
}

// Expected BitSet / not BitSet
MismatchedTokenException::MismatchedTokenException(
        const char* const* tokenNames_,
        const int numTokens_,
        RefAST node_,
        BitSet set_,
        bool matchNot
) : RecognitionException("Mismatched Token","<AST>",-1,-1)
  , token(0)
  , node(node_)
  , tokenText( (node_ ? node_->toString(): ANTLR_USE_NAMESPACE(std)string("<empty tree>")) )
  , mismatchType(matchNot ? NOT_SET : SET)
  , set(set_)
  , tokenNames(tokenNames_)
  , numTokens(numTokens_)
{
}

// Expected range / not range
MismatchedTokenException::MismatchedTokenException(
        const char* const* tokenNames_,
        const int numTokens_,
        RefToken token_,
        int lower,
        int upper_,
        bool matchNot,
        const ANTLR_USE_NAMESPACE(std)string& fileName_
) : RecognitionException("Mismatched Token",fileName_,token_->getLine(),token_->getColumn())
  , token(token_)
  , node(nullASTptr)
  , tokenText(token_->getText())
  , mismatchType(matchNot ? NOT_RANGE : RANGE)
  , expecting(lower)
  , upper(upper_)
  , tokenNames(tokenNames_)
  , numTokens(numTokens_)
{
}

// Expected token / not token
MismatchedTokenException::MismatchedTokenException(
        const char* const* tokenNames_,
        const int numTokens_,
        RefToken token_,
        int expecting_,
        bool matchNot,
        const ANTLR_USE_NAMESPACE(std)string& fileName_
) : RecognitionException("Mismatched Token",fileName_,token_->getLine(),token_->getColumn())
  , token(token_)
  , node(nullASTptr)
  , tokenText(token_->getText())
  , mismatchType(matchNot ? NOT_TOKEN : TOKEN)
  , expecting(expecting_)
  , tokenNames(tokenNames_)
  , numTokens(numTokens_)
{
}

// Expected BitSet / not BitSet
MismatchedTokenException::MismatchedTokenException(
        const char* const* tokenNames_,
        const int numTokens_,
        RefToken token_,
        BitSet set_,
        bool matchNot,
        const ANTLR_USE_NAMESPACE(std)string& fileName_
) : RecognitionException("Mismatched Token",fileName_,token_->getLine(),token_->getColumn())
  , token(token_)
  , node(nullASTptr)
  , tokenText(token_->getText())
  , mismatchType(matchNot ? NOT_SET : SET)
  , set(set_)
  , tokenNames(tokenNames_)
  , numTokens(numTokens_)
{
}

ANTLR_USE_NAMESPACE(std)string MismatchedTokenException::getMessage() const
{
        ANTLR_USE_NAMESPACE(std)string s;
        switch (mismatchType) {
        case TOKEN:
                s += "expecting " + tokenName(expecting) + ", found '" + tokenText + "'";
                break;
        case NOT_TOKEN:
                s += "expecting anything but " + tokenName(expecting) + "; got it anyway";
                break;
        case RANGE:
                s += "expecting token in range: " + tokenName(expecting) + ".." + tokenName(upper) + ", found '" + tokenText + "'";
                break;
        case NOT_RANGE:
                s += "expecting token NOT in range: " + tokenName(expecting) + ".." + tokenName(upper) + ", found '" + tokenText + "'";
                break;
        case SET:
        case NOT_SET:
                {
                        s += ANTLR_USE_NAMESPACE(std)string("expecting ") + (mismatchType == NOT_SET ? "NOT " : "") + "one of (";
                        ANTLR_USE_NAMESPACE(std)vector<unsigned int> elems = set.toArray();
                        for ( unsigned int i = 0; i < elems.size(); i++ )
                        {
                                s += " ";
                                s += tokenName(elems[i]);
                        }
                        s += "), found '" + tokenText + "'";
                }
                break;
        default:
                s = RecognitionException::getMessage();
                break;
        }
        return s;
}

ANTLR_USE_NAMESPACE(std)string MismatchedTokenException::tokenName(int tokenType) const
{
        if (tokenType == Token::INVALID_TYPE)
                return "<Set of tokens>";
        else if (tokenType < 0 || tokenType >= numTokens)
                return ANTLR_USE_NAMESPACE(std)string("<") + tokenType + ">";
        else
                return tokenNames[tokenType];
}

#ifndef NO_STATIC_CONSTS
const int MismatchedTokenException::TOKEN;
const int MismatchedTokenException::NOT_TOKEN;
const int MismatchedTokenException::RANGE;
const int MismatchedTokenException::NOT_RANGE;
const int MismatchedTokenException::SET;
const int MismatchedTokenException::NOT_SET;
#endif

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
}
#endif
Revision:	2469
Committed:	Fri Dec 2 15:38:03 2005 UTC (18 years, 7 months ago) by tim
File size:	5406 byte(s)
Log Message:	End of the Link --> List Return of the Oject-Oriented replace yacc/lex parser with antlr parser
#	User	Rev	Content
1	tim	2469	/* ANTLR Translator Generator
2			* Project led by Terence Parr at http://www.jGuru.com
3			* Software rights: http://www.antlr.org/license.html
4			*
5			* $Id: MismatchedTokenException.cpp,v 1.1 2005-12-02 15:38:02 tim Exp $
6			*/
7
8			#include "antlr/MismatchedTokenException.hpp"
9			#include "antlr/String.hpp"
10
11			#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
12			namespace antlr {
13			#endif
14
15			MismatchedTokenException::MismatchedTokenException()
16			: RecognitionException("Mismatched Token: expecting any AST node","<AST>",-1,-1)
17			, token(0)
18			, node(nullASTptr)
19			, tokenNames(0)
20			, numTokens(0)
21			{
22			}
23
24			// Expected range / not range
25			MismatchedTokenException::MismatchedTokenException(
26			const char* const* tokenNames_,
27			const int numTokens_,
28			RefAST node_,
29			int lower,
30			int upper_,
31			bool matchNot
32			) : RecognitionException("Mismatched Token","<AST>",-1,-1)
33			, token(0)
34			, node(node_)
35			, tokenText( (node_ ? node_->toString(): ANTLR_USE_NAMESPACE(std)string("<empty tree>")) )
36			, mismatchType(matchNot ? NOT_RANGE : RANGE)
37			, expecting(lower)
38			, upper(upper_)
39			, tokenNames(tokenNames_)
40			, numTokens(numTokens_)
41			{
42			}
43
44			// Expected token / not token
45			MismatchedTokenException::MismatchedTokenException(
46			const char* const* tokenNames_,
47			const int numTokens_,
48			RefAST node_,
49			int expecting_,
50			bool matchNot
51			) : RecognitionException("Mismatched Token","<AST>",-1,-1)
52			, token(0)
53			, node(node_)
54			, tokenText( (node_ ? node_->toString(): ANTLR_USE_NAMESPACE(std)string("<empty tree>")) )
55			, mismatchType(matchNot ? NOT_TOKEN : TOKEN)
56			, expecting(expecting_)
57			, tokenNames(tokenNames_)
58			, numTokens(numTokens_)
59			{
60			}
61
62			// Expected BitSet / not BitSet
63			MismatchedTokenException::MismatchedTokenException(
64			const char* const* tokenNames_,
65			const int numTokens_,
66			RefAST node_,
67			BitSet set_,
68			bool matchNot
69			) : RecognitionException("Mismatched Token","<AST>",-1,-1)
70			, token(0)
71			, node(node_)
72			, tokenText( (node_ ? node_->toString(): ANTLR_USE_NAMESPACE(std)string("<empty tree>")) )
73			, mismatchType(matchNot ? NOT_SET : SET)
74			, set(set_)
75			, tokenNames(tokenNames_)
76			, numTokens(numTokens_)
77			{
78			}
79
80			// Expected range / not range
81			MismatchedTokenException::MismatchedTokenException(
82			const char* const* tokenNames_,
83			const int numTokens_,
84			RefToken token_,
85			int lower,
86			int upper_,
87			bool matchNot,
88			const ANTLR_USE_NAMESPACE(std)string& fileName_
89			) : RecognitionException("Mismatched Token",fileName_,token_->getLine(),token_->getColumn())
90			, token(token_)
91			, node(nullASTptr)
92			, tokenText(token_->getText())
93			, mismatchType(matchNot ? NOT_RANGE : RANGE)
94			, expecting(lower)
95			, upper(upper_)
96			, tokenNames(tokenNames_)
97			, numTokens(numTokens_)
98			{
99			}
100
101			// Expected token / not token
102			MismatchedTokenException::MismatchedTokenException(
103			const char* const* tokenNames_,
104			const int numTokens_,
105			RefToken token_,
106			int expecting_,
107			bool matchNot,
108			const ANTLR_USE_NAMESPACE(std)string& fileName_
109			) : RecognitionException("Mismatched Token",fileName_,token_->getLine(),token_->getColumn())
110			, token(token_)
111			, node(nullASTptr)
112			, tokenText(token_->getText())
113			, mismatchType(matchNot ? NOT_TOKEN : TOKEN)
114			, expecting(expecting_)
115			, tokenNames(tokenNames_)
116			, numTokens(numTokens_)
117			{
118			}
119
120			// Expected BitSet / not BitSet
121			MismatchedTokenException::MismatchedTokenException(
122			const char* const* tokenNames_,
123			const int numTokens_,
124			RefToken token_,
125			BitSet set_,
126			bool matchNot,
127			const ANTLR_USE_NAMESPACE(std)string& fileName_
128			) : RecognitionException("Mismatched Token",fileName_,token_->getLine(),token_->getColumn())
129			, token(token_)
130			, node(nullASTptr)
131			, tokenText(token_->getText())
132			, mismatchType(matchNot ? NOT_SET : SET)
133			, set(set_)
134			, tokenNames(tokenNames_)
135			, numTokens(numTokens_)
136			{
137			}
138
139			ANTLR_USE_NAMESPACE(std)string MismatchedTokenException::getMessage() const
140			{
141			ANTLR_USE_NAMESPACE(std)string s;
142			switch (mismatchType) {
143			case TOKEN:
144			s += "expecting " + tokenName(expecting) + ", found '" + tokenText + "'";
145			break;
146			case NOT_TOKEN:
147			s += "expecting anything but " + tokenName(expecting) + "; got it anyway";
148			break;
149			case RANGE:
150			s += "expecting token in range: " + tokenName(expecting) + ".." + tokenName(upper) + ", found '" + tokenText + "'";
151			break;
152			case NOT_RANGE:
153			s += "expecting token NOT in range: " + tokenName(expecting) + ".." + tokenName(upper) + ", found '" + tokenText + "'";
154			break;
155			case SET:
156			case NOT_SET:
157			{
158			s += ANTLR_USE_NAMESPACE(std)string("expecting ") + (mismatchType == NOT_SET ? "NOT " : "") + "one of (";
159			ANTLR_USE_NAMESPACE(std)vector<unsigned int> elems = set.toArray();
160			for ( unsigned int i = 0; i < elems.size(); i++ )
161			{
162			s += " ";
163			s += tokenName(elems[i]);
164			}
165			s += "), found '" + tokenText + "'";
166			}
167			break;
168			default:
169			s = RecognitionException::getMessage();
170			break;
171			}
172			return s;
173			}
174
175			ANTLR_USE_NAMESPACE(std)string MismatchedTokenException::tokenName(int tokenType) const
176			{
177			if (tokenType == Token::INVALID_TYPE)
178			return "<Set of tokens>";
179			else if (tokenType < 0 \|\| tokenType >= numTokens)
180			return ANTLR_USE_NAMESPACE(std)string("<") + tokenType + ">";
181			else
182			return tokenNames[tokenType];
183			}
184
185			#ifndef NO_STATIC_CONSTS
186			const int MismatchedTokenException::TOKEN;
187			const int MismatchedTokenException::NOT_TOKEN;
188			const int MismatchedTokenException::RANGE;
189			const int MismatchedTokenException::NOT_RANGE;
190			const int MismatchedTokenException::SET;
191			const int MismatchedTokenException::NOT_SET;
192			#endif
193
194			#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
195			}
196			#endif