自学教程：C++ ANTLR_USE_NAMESPACE函数代码示例

ANTLR_USE_NAMESPACE(antlr)RefToken LexTokenStream::nextToken(){	ANTLR_USE_NAMESPACE(antlr)RefToken ret;	if (!reachedEOF)	{		int type;		currentLexer = this;		while ((type = yylex()) == -1) // Token::SKIP			;		if (type != 0)		{			if( type != JavaTokenTypes::STRING_LITERAL )				ret = ANTLR_USE_NAMESPACE(antlr)RefToken(new ANTLR_USE_NAMESPACE(antlr)CommonToken(type,yytext));			else				ret = ANTLR_USE_NAMESPACE(antlr)RefToken(new ANTLR_USE_NAMESPACE(antlr)CommonToken(type,string_buf));//			ANTLR_USE_NAMESPACE(std)cout << "Read token " << type << " [" << ret->getText() << "]" << ANTLR_USE_NAMESPACE(std)endl;		}		else			reachedEOF = true;	}	if (reachedEOF)	{		ret = ANTLR_USE_NAMESPACE(antlr)RefToken(new ANTLR_USE_NAMESPACE(antlr)CommonToken(1,"EOF"));		//		cout << "EOF reached" << endl;	}	ret->setLine(line);	return ret;}

void IOSCfgParser::access_group_by_number() {	ANTLR_USE_NAMESPACE(antlr)RefToken  acln = ANTLR_USE_NAMESPACE(antlr)nullToken;	ANTLR_USE_NAMESPACE(antlr)RefToken  dir = ANTLR_USE_NAMESPACE(antlr)nullToken;		try {      // for error handling		match(ACCESS_GROUP);		acln = LT(1);		match(INT_CONST);		dir = LT(1);		match(WORD);		if ( inputState->guessing==0 ) {#line 625 "iosacl.g"						importer->setCurrentLineNumber(LT(0)->getLine());			importer->setInterfaceAndDirectionForRuleSet(			std::string("acl_") + acln->getText(),			"",			dir->getText() );			*dbg << LT(1)->getLine() << ":"			<< " INTRFACE: ACL '" << acln->getText() << "'"			<< " " << dir->getText() << std::endl;			#line 2116 "IOSCfgParser.cpp"		}	}	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {		if( inputState->guessing == 0 ) {			reportError(ex);			recover(ex,_tokenSet_14);		} else {			throw;		}	}}

void MDParser::inttuple() {	returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;		try {      // for error handling		intConst();		astFactory->addASTChild( currentAST, returnAST );		{ // ( ... )*		for (;;) {			if ((LA(1) == COMMA)) {				match(COMMA);				intConst();				astFactory->addASTChild( currentAST, returnAST );			}			else {				goto _loop71;			}					}		_loop71:;		} // ( ... )*		inttuple_AST = currentAST.root;	}	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {		reportError(ex);		recover(ex,_tokenSet_12);	}	returnAST = inttuple_AST;}

/** Parser error-reporting function can be overridden in subclass */void Parser::reportError(const RecognitionException& ex){	// DW 060204 Amended to indicate error in DOS window	ANTLR_USE_NAMESPACE(std)cerr << "cerr " << ex.toString().c_str() << ANTLR_USE_NAMESPACE(std)endl;	// DW 060204 Inserted to show position of condition in trace output	ANTLR_USE_NAMESPACE(std)cout << "cout " << ex.toString().c_str() << ANTLR_USE_NAMESPACE(std)endl;}

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;}

void ConversionParser::conversion() {	ANTLR_USE_NAMESPACE(antlr)RefToken  v_from = ANTLR_USE_NAMESPACE(antlr)nullToken;	ANTLR_USE_NAMESPACE(antlr)RefToken  v_to = ANTLR_USE_NAMESPACE(antlr)nullToken;		unsigned int from;	unsigned int to;	bool add = false;			try {      // for error handling		v_from = LT(1);		match(NUMBER);		{		switch ( LA(1)) {		case C_TYPE:		{			match(C_TYPE);			add = true;			break;		}		case S_TYPE:		{			match(S_TYPE);			add = true;			break;		}		case T_TYPE:		{			match(T_TYPE);			break;		}		case F_TYPE:		{			match(F_TYPE);			break;		}		default:		{			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());		}		}		}		v_to = LT(1);		match(NUMBER);				if(add)		{		from = toHexInt(v_from->getText());		to = toHexInt(v_to->getText());		changer->SetConversion(from,to);		}			}	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {		reportError(ex);		recover(ex,_tokenSet_1);	}}

void P::factor() {	returnAST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;	RefBasicAST factor_AST = RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST);		try {      // for error handling		factor2();		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));		{ // ( ... )*		for (;;) {			if ((LA(1) == MOD || LA(1) == EXP)) {				{				switch ( LA(1)) {				case EXP:				{					RefBinaryCompArithOpAST tmp11_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));					tmp11_AST = astFactory->create(LT(1));					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp11_AST));					match(EXP);					break;				}				case MOD:				{					RefBinaryCompArithOpAST tmp12_AST = RefBinaryCompArithOpAST(RefBasicAST(ANTLR_USE_NAMESPACE(antlr)nullAST));					tmp12_AST = astFactory->create(LT(1));					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp12_AST));					match(MOD);					break;				}				default:				{					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());				}				}				}				factor2();				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));			}			else {				goto _loop14;			}					}		_loop14:;		} // ( ... )*		factor_AST = RefBasicAST(currentAST.root);	}	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {		reportError(ex);		recover(ex,_tokenSet_3);	}	returnAST = factor_AST;}

void IOSCfgParser::xoperator() {		try {      // for error handling		switch ( LA(1)) {		case P_EQ:		case P_GT:		case P_LT:		case P_NEQ:		{			single_port_op();			break;		}		case P_RANGE:		{			port_range();			break;		}		default:		{			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());		}		}	}	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {		if( inputState->guessing == 0 ) {			reportError(ex);			recover(ex,_tokenSet_11);		} else {			throw;		}	}}

void IOSCfgParser::description() {		try {      // for error handling		match(DESCRIPTION);		if ( inputState->guessing==0 ) {#line 547 "iosacl.g"						importer->setCurrentLineNumber(LT(0)->getLine());			*dbg << LT(1)->getLine() << ":";			std::string descr;			while (LA(1) != ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE && LA(1) != NEWLINE)			{			descr += LT(1)->getText() + " ";			consume();			}			importer->setInterfaceComment( descr );			*dbg << " DESCRIPTION " << descr << std::endl;			//consumeUntil(NEWLINE);			#line 489 "IOSCfgParser.cpp"		}	}	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {		if( inputState->guessing == 0 ) {			reportError(ex);			recover(ex,_tokenSet_2);		} else {			throw;		}	}}

void IOSCfgParser::interface_known_ip_commands() {		try {      // for error handling		{		if ((LA(1) == ACCESS_GROUP) && (LA(2) == WORD)) {			access_group_by_name();		}		else if ((LA(1) == ACCESS_GROUP) && (LA(2) == INT_CONST)) {			access_group_by_number();		}		else if ((LA(1) == ADDRESS)) {			intf_address();		}		else {			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());		}				}		match(NEWLINE);	}	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {		if( inputState->guessing == 0 ) {			reportError(ex);			recover(ex,_tokenSet_2);		} else {			throw;		}	}}

/** get the current marked characters as a string * @warning it may treat 0 and EOF values wrong */ANTLR_USE_NAMESPACE(std)string InputBuffer::getMarkedChars( void ) const{	ANTLR_USE_NAMESPACE(std)string ret;	for(unsigned int i = 0; i < markerOffset; i++)		ret += queue.elementAt(i);	return ret;}

/** get the current lookahead characters as a string * @warning it may treat 0 and EOF values wrong */ANTLR_USE_NAMESPACE(std)string InputBuffer::getLAChars( void ) const{	ANTLR_USE_NAMESPACE(std)string ret;	for(int i = markerOffset; i < queue.entries(); i++)		ret += queue.elementAt(i);	return ret;}

ANTLR_USE_NAMESPACE(std)vector<unsigned int> BitSet::toArray() const {  ANTLR_USE_NAMESPACE(std)vector<unsigned int> elems;  for (unsigned int i = 0; i < storage.size(); i++) {    if (storage[i])      elems.push_back(i);  }  return elems;}

/**Make sure current lookahead symbol matches token type <tt>t</tt>. * Throw an exception upon mismatch, which is catch by either the * error handler or by the syntactic predicate. */void Parser::match(int t){		if ( DEBUG_PARSER )	{		traceIndent();		ANTLR_USE_NAMESPACE(std)cout << "enter match(" << t << ") with LA(1)=" << LA(1) << ANTLR_USE_NAMESPACE(std)endl;	}	if ( LA(1)!=t ) {		if ( DEBUG_PARSER )		{			traceIndent();			ANTLR_USE_NAMESPACE(std)cout << "token mismatch: " << LA(1) << "!=" << t << ANTLR_USE_NAMESPACE(std)endl;		}		throw MismatchedTokenException(getTokenNames(), getNumTokens(), LT(1), t, false, getFilename());	} else {		// mark token as consumed -- fetch next token deferred until LA/LT		consume();	}}