C++ RefToken类代码示例

void TokenStreamHiddenTokenFilter::consumeFirst()
{
	consume();

	// Handle situation where hidden or discarded tokens
	// appear first in input stream
	RefToken p;
	// while hidden or discarded scarf tokens
	while ( hideMask.member(LA(1)->getType()) || discardMask.member(LA(1)->getType()) ) {
		if ( hideMask.member(LA(1)->getType()) ) {
			if ( !p ) {
				p = LA(1);
			}
			else {
				static_cast<CommonHiddenStreamToken*>(p.get())->setHiddenAfter(LA(1));
				static_cast<CommonHiddenStreamToken*>(LA(1).get())->setHiddenBefore(p); // double-link
				p = LA(1);
			}
			lastHiddenToken = p;
			if (!firstHidden)
				firstHidden = p; // record hidden token if first
		}
		consume();
	}
}

/** Return the next monitored token.
*  Test the token following the monitored token.
*  If following is another monitored token, save it
*  for the next invocation of nextToken (like a single
*  lookahead token) and return it then.
*  If following is unmonitored, nondiscarded (hidden)
*  channel token, add it to the monitored token.
*
*  Note: EOF must be a monitored Token.
*/
RefToken TokenStreamHiddenTokenFilter::nextToken()
{
	// handle an initial condition; don't want to get lookahead
	// token of this splitter until first call to nextToken
	if ( !LA(1) ) {
		consumeFirst();
	}

	// we always consume hidden tokens after monitored, thus,
	// upon entry LA(1) is a monitored token.
	RefToken monitored = LA(1);
	// point to hidden tokens found during last invocation
	static_cast<CommonHiddenStreamToken*>(monitored.get())->setHiddenBefore(lastHiddenToken);
	lastHiddenToken = nullToken;

	// Look for hidden tokens, hook them into list emanating
	// from the monitored tokens.
	consume();
	RefToken p = monitored;
	// while hidden or discarded scarf tokens
	while ( hideMask.member(LA(1)->getType()) || discardMask.member(LA(1)->getType()) ) {
		if ( hideMask.member(LA(1)->getType()) ) {
			// attach the hidden token to the monitored in a chain
			// link forwards
			static_cast<CommonHiddenStreamToken*>(p.get())->setHiddenAfter(LA(1));
			// link backwards
			if (p != monitored) { //hidden cannot point to monitored tokens
				static_cast<CommonHiddenStreamToken*>(LA(1).get())->setHiddenBefore(p);
			}
			p = lastHiddenToken = LA(1);
		}
		consume();
	}
	return monitored;
}

RefToken TokenStreamBasicFilter::nextToken()
{
	RefToken tok = input->nextToken();
	while ( tok && discardMask.member(tok->getType()) ) {
		tok = input->nextToken();
	}
	return tok;
}

void BinaryCompArithOpAST::initialize( RefToken t ) {
	BasicAST::initialize(t);
	switch (t->getType()) {
			 case PTokenTypes::EQ: 
				 _opType = ByteCodeNS::EQ;
				 break;
			 case PTokenTypes::NE: 
				 _opType = ByteCodeNS::NE;
				 break;
			 case PTokenTypes::OP_LT: 
				 _opType = ByteCodeNS::LT;
				 break;
			 case PTokenTypes::LE: 
				 _opType = ByteCodeNS::LE;
				 break;
			 case PTokenTypes::GT: 
				 _opType = ByteCodeNS::GT;
				 break;
			 case PTokenTypes::GE: 
				 _opType = ByteCodeNS::GE;
				 break;

			 case PTokenTypes::PLUS: 
				 _opType = ByteCodeNS::PLUS;
				 break;
			 case PTokenTypes::MINUS: 
				 _opType = ByteCodeNS::MINUS;
				 break;
			 case PTokenTypes::MUL: 
				 _opType = ByteCodeNS::MUL;
				 break;
			 case PTokenTypes::DIV: 
				 _opType = ByteCodeNS::DIV;
				 break;
			 case PTokenTypes::MOD: 
				 _opType = ByteCodeNS::MOD;
				 break;
			 case PTokenTypes::EXP: 
				 _opType = ByteCodeNS::EXP;
				 break;
			 default:
				 assert(false);
	}
}

string BasePortugolParser::getTokenDescription(const RefToken& token) {
    string str;

    if(token->getType() == PortugolParserTokenTypes::T_IDENTIFICADOR) {
        str = "\"";
        str += token->getText();
        str += "\"";
    } else if(isKeyword(token->getType())) {
        str = "a palavra-chave ";
        str += getTokenNames()[token->getType()];
    } else if(token->getType() == PortugolParserTokenTypes::EOF_) {
        str = "fim de arquivo (EOF)";
    } else {
//     str = getTokenNames()[token->getType()];
        str = token->getText();
    }
    return str;
}

#include "antlr/String.hpp"

#ifdef ANTLR_CXX_SUPPORTS_NAMESPACE
namespace antlr {
#endif

ANTLR_USING_NAMESPACE(std)

NoViableAltException::NoViableAltException(RefAST t)
  : RecognitionException("NoViableAlt","<AST>",-1,-1),
    token(0), node(t)
{
}

NoViableAltException::NoViableAltException(
	RefToken t,
	const ANTLR_USE_NAMESPACE(std)string& fileName_
) : RecognitionException("NoViableAlt",fileName_,t->getLine(),t->getColumn()),
    token(t), node(nullASTptr)
{
}

ANTLR_USE_NAMESPACE(std)string NoViableAltException::getMessage() const
{
	if (token)
	{
		if( token->getType() == Token::EOF_TYPE )
			return string("unexpected end of file");
		else if( token->getType() == Token::NULL_TREE_LOOKAHEAD )
			return string("unexpected end of tree");
		else
			return string("unexpected token: ")+token->getText();

void CommonAST::initialize(RefToken t)
{
    setType(t->getType());
    setText(t->getText());
}

CommonAST::CommonAST(RefToken t)
    :  BaseAST(),
       ttype( t->getType() ),
       text( t->getText() )
{
}

/** Return a ptr to the hidden token appearing immediately before
 *  token t in the input stream.
 */
RefToken TokenStreamHiddenTokenFilter::getHiddenBefore(RefToken t)
{
	return static_cast<CommonHiddenStreamToken*>(t.get())->getHiddenBefore();
}

void CommonASTWithHiddenTokens::initialize(RefToken t)
{
	CommonAST::initialize(t);
	hiddenBefore = static_cast<CommonHiddenStreamToken*>(t.get())->getHiddenBefore();
	hiddenAfter = static_cast<CommonHiddenStreamToken*>(t.get())->getHiddenAfter();
}