codegentreewalker.java

ANTLR(ANother Tool for Language Recognition)它是这样的一种工具

				switch ( _t.getType()) {
				case NOT:
				{
					AST __t77 = _t;
					assign_n = _t==ASTNULL ? null :(GrammarAST)_t;
					match(_t,NOT);
					_t = _t.getFirstChild();
					{
					if (_t==null) _t=ASTNULL;
					switch ( _t.getType()) {
					case CHAR_LITERAL:
					{
						assign_c = (GrammarAST)_t;
						match(_t,CHAR_LITERAL);
						_t = _t.getNextSibling();
						{
						if (_t==null) _t=ASTNULL;
						switch ( _t.getType()) {
						case BANG:
						case ROOT:
						case RULEROOT:
						{
							assign_ast1 = _t==ASTNULL ? null : (GrammarAST)_t;
							ast_suffix(_t);
							_t = _retTree;
							break;
						}
						case 3:
						{
							break;
						}
						default:
						{
							throw new NoViableAltException(_t);
						}
						}
						}
						
							            int ttype=0;
									if ( grammar.type==Grammar.LEXER ) {
									ttype = Grammar.getCharValueFromGrammarCharLiteral(assign_c.getText());
									}
									else {
									ttype = grammar.getTokenType(assign_c.getText());
								}
							            elements = grammar.complement(ttype);
							            ast = assign_ast1;
							
						break;
					}
					case STRING_LITERAL:
					{
						assign_s = (GrammarAST)_t;
						match(_t,STRING_LITERAL);
						_t = _t.getNextSibling();
						{
						if (_t==null) _t=ASTNULL;
						switch ( _t.getType()) {
						case BANG:
						case ROOT:
						case RULEROOT:
						{
							assign_ast2 = _t==ASTNULL ? null : (GrammarAST)_t;
							ast_suffix(_t);
							_t = _retTree;
							break;
						}
						case 3:
						{
							break;
						}
						default:
						{
							throw new NoViableAltException(_t);
						}
						}
						}
						
							            int ttype=0;
									if ( grammar.type==Grammar.LEXER ) {
									// TODO: error!
									}
									else {
									ttype = grammar.getTokenType(assign_s.getText());
								}
							            elements = grammar.complement(ttype);
							            ast = assign_ast2;
							
						break;
					}
					case TOKEN_REF:
					{
						assign_t = (GrammarAST)_t;
						match(_t,TOKEN_REF);
						_t = _t.getNextSibling();
						{
						if (_t==null) _t=ASTNULL;
						switch ( _t.getType()) {
						case BANG:
						case ROOT:
						case RULEROOT:
						{
							assign_ast3 = _t==ASTNULL ? null : (GrammarAST)_t;
							ast_suffix(_t);
							_t = _retTree;
							break;
						}
						case 3:
						{
							break;
						}
						default:
						{
							throw new NoViableAltException(_t);
						}
						}
						}
						
							           int ttype = grammar.getTokenType(assign_t.getText());
							           elements = grammar.complement(ttype);
							           ast = assign_ast3;
							
						break;
					}
					case SET:
					{
						assign_st = (GrammarAST)_t;
						match(_t,SET);
						_t = _t.getNextSibling();
						{
						int _cnt83=0;
						_loop83:
						do {
							if (_t==null) _t=ASTNULL;
							if ((_t.getType()==CHAR_RANGE||_t.getType()==STRING_LITERAL||_t.getType()==CHAR_LITERAL||_t.getType()==TOKEN_REF)) {
								setElement(_t);
								_t = _retTree;
							}
							else {
								if ( _cnt83>=1 ) { break _loop83; } else {throw new NoViableAltException(_t);}
							}
							
							_cnt83++;
						} while (true);
						}
						{
						if (_t==null) _t=ASTNULL;
						switch ( _t.getType()) {
						case BANG:
						case ROOT:
						case RULEROOT:
						{
							assign_ast4 = _t==ASTNULL ? null : (GrammarAST)_t;
							ast_suffix(_t);
							_t = _retTree;
							break;
						}
						case 3:
						{
							break;
						}
						default:
						{
							throw new NoViableAltException(_t);
						}
						}
						}
						
						// SETs are not precomplemented by buildnfa.g like
						// simple elements.
						elements = st.getSetValue();
							           ast = assign_ast4;
						
						break;
					}
					default:
					{
						throw new NoViableAltException(_t);
					}
					}
					}
					
					code = getTokenElementST("matchSet",
					"set",
					(GrammarAST)assign_n.getFirstChild(),
					ast,
					label.getText());
					code.setAttribute("s", generator.genSetExpr(templates,elements,1,false));
							 	code.setAttribute("elementIndex", ((TokenWithIndex)assign_n.getToken()).getIndex());
								if ( grammar.type!=Grammar.LEXER ) {
							 		generator.generateLocalFOLLOW(assign_n,"set",currentRuleName);
						}
					
					_t = __t77;
					_t = _t.getNextSibling();
					break;
				}
				case SET:
				case STRING_LITERAL:
				case CHAR_LITERAL:
				case TOKEN_REF:
				case RULE_REF:
				case WILDCARD:
				{
					code=atom(_t,label.getText());
					_t = _retTree;
					break;
				}
				default:
				{
					throw new NoViableAltException(_t);
				}
				}
				}
				_t = __t75;
				_t = _t.getNextSibling();
				break;
			}
			case PLUS_ASSIGN:
			{
				AST __t85 = _t;
				GrammarAST tmp41_AST_in = (GrammarAST)_t;
				match(_t,PLUS_ASSIGN);
				_t = _t.getFirstChild();
				label2 = (GrammarAST)_t;
				match(_t,ID);
				_t = _t.getNextSibling();
				code=atom(_t,label2.getText());
				_t = _retTree;
				_t = __t85;
				_t = _t.getNextSibling();
				break;
			}
			case BLOCK:
			case OPTIONAL:
			case CLOSURE:
			case POSITIVE_CLOSURE:
			{
				code=ebnf(_t);
				_t = _retTree;
				break;
			}
			case TREE_BEGIN:
			{
				code=tree(_t);
				_t = _retTree;
				break;
			}
			case ACTION:
			{
				act = (GrammarAST)_t;
				match(_t,ACTION);
				_t = _t.getNextSibling();
				
				act.outerAltNum = this.outerAltNum;
				code = templates.getInstanceOf("execAction");
				code.setAttribute("action", generator.translateAction(currentRuleName,act));
				
				break;
			}
			case GATED_SEMPRED:
			case SEMPRED:
			{
				{
				if (_t==null) _t=ASTNULL;
				switch ( _t.getType()) {
				case SEMPRED:
				{
					sp = (GrammarAST)_t;
					match(_t,SEMPRED);
					_t = _t.getNextSibling();
					break;
				}
				case GATED_SEMPRED:
				{
					gsp = (GrammarAST)_t;
					match(_t,GATED_SEMPRED);
					_t = _t.getNextSibling();
					sp=gsp;
					break;
				}
				default:
				{
					throw new NoViableAltException(_t);
				}
				}
				}
				
				code = templates.getInstanceOf("validateSemanticPredicate");
				sp.outerAltNum = this.outerAltNum;
				code.setAttribute("pred", generator.translateAction(currentRuleName,sp));
						String description =
							generator.target.getTargetStringLiteralFromString(sp.getText());
						code.setAttribute("description", description);
				
				break;
			}
			case SYN_SEMPRED:
			{
				GrammarAST tmp42_AST_in = (GrammarAST)_t;
				match(_t,SYN_SEMPRED);
				_t = _t.getNextSibling();
				break;
			}
			case EPSILON:
			{
				GrammarAST tmp43_AST_in = (GrammarAST)_t;
				match(_t,EPSILON);
				_t = _t.getNextSibling();
				break;
			}
			default:
			{
				throw new NoViableAltException(_t);
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			if (_t!=null) {_t = _t.getNextSibling();}
		}
		_retTree = _t;
		return code;
	}
	
	public final StringTemplate  atom(AST _t,
		String label
	) throws RecognitionException {
		StringTemplate code=null;
		
		GrammarAST atom_AST_in = (_t == ASTNULL) ? null : (GrammarAST)_t;
		GrammarAST r = null;
		GrammarAST rarg = null;
		GrammarAST as1 = null;
		GrammarAST t = null;
		GrammarAST targ = null;
		GrammarAST as2 = null;
		GrammarAST c = null;
		GrammarAST as3 = null;
		GrammarAST s = null;
		GrammarAST as4 = null;
		GrammarAST w = null;
		GrammarAST as5 = null;
		
		try {      // for error handling
			if (_t==null) _t=ASTNULL;
			switch ( _t.getType()) {
			case RULE_REF:
			{
				AST __t97 = _t;
				r = _t==ASTNULL ? null :(GrammarAST)_t;
				match(_t,RULE_REF);
				_t = _t.getFirstChild();
				{
				if (_t==null) _t=ASTNULL;
				switch ( _t.getType()) {
				case ARG_ACTION:
				{
					rarg = (GrammarAST)_t;
					match(_t,ARG_ACTION);
					_t = _t.getNextSibling();
					break;
				}
				case 3:
				case BANG:
				case ROOT:
				case RULEROOT:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(_t);
				}
				}
				}
				{
				if (_t==null) _t=ASTNULL;
				switch ( _t.getType()) {
				case BANG:
				case ROOT:
				case RULEROOT:
				{
					as1 = _t==ASTNULL ? null : (GrammarAST)_t;
					ast_suffix(_t);
					_t = _retTree;
					break;
				}
				case 3:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(_t);
				}
				}
				}
				_t = __t97;
				_t = _t.getNextSibling();
				
				grammar.checkRuleReference(r, rarg, currentRuleName);
				code = getRuleElementST("ruleRef", r.getText(), r, as1, label);
						code.setAttribute("rule", r.getText());
				
						if ( rarg!=null ) {
							rarg.outerAltNum = this.outerAltNum;
							List args = generator.translateArgAction(currentRuleName,rarg);
							code.setAttribute("args", args);
						}
						code.setAttribute("elementIndex", ((TokenWithIndex)r.getToken()).getIndex());
						generator.generateLocalFOLLOW(r,r.getText(),currentRuleName);
						r.code = code;
				
				break;
			}
			case TOKEN_REF:
			{
				AST __t100 = _t;
				t = _t==ASTNULL ? null :(GrammarAST)_t;
				match(_t,TOKEN_REF);
				_t = _t.getFirstChild();
				{
				if (_t==null) _t=ASTNULL;
				switch ( _t.getType()) {
				case ARG_ACTION:
				{
					targ = (GrammarAST)_t;
					match(_t,ARG_ACTION);
					_t = _t.getNextSibling();
					break;
				}
				case 3:
				case BANG:
				case ROOT:
				case RULEROOT:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(_t);
				}
				}
				}
				{
				if (_t==null) _t=ASTNULL;
				switch ( _t.getType()) {
				case BANG:
				case ROOT:
				case RULEROOT:
				{
					as2 = _t==ASTNULL ? null : (GrammarAST)_t;
					ast_suffix(_t);
					_t = _retTree;
					break;
				}
				case 3:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(_t);
				}
				}
				}
				_t = __t100;
				_t = _t.getNextSibling();
				
				grammar.checkRuleReference(t, targ, currentRuleName);
						   if ( grammar.type==Grammar.LEXER ) {
								if ( grammar.getTokenType(t.getText())==Label.EOF ) {
									code = templates.getInstanceOf("lexerMatchEOF");
								}
							    else {
									code = templates.getInstanceOf("lexerRuleRef");
									code.setAttribute("rule", t.getText());
									if ( targ!=null ) {
										targ.outerAltNum = this.outerAltNum;
										List args = generator.translateArgAction(currentRuleName,targ);
										code.setAttribute("args", args);
									}
								}
							    if ( label!=null ) code.setAttribute("label", label);
						   }
						   else {
								code = getTokenElementST("tokenRef", t.getText(), t, as2, label);
								String tokenLabel =
								   generator.getTokenTypeAsTargetLabel(grammar.getTokenType(t.getText()));
								code.setAttribute("token",tokenLabel);
							    code.setAttribute("elementIndex", ((TokenWithIndex)t.getToken()).getIndex());
							    generator.generateLocalFOLLOW(t,tokenLabel,currentRuleName);
						   }
						   t.code = code;
						
				break;
			}
			case CHAR_LITERAL:
			{
				AST __t103 = _t;
				c = _t==ASTNULL ? null :(GrammarAST)_t;
				match(_t,CHAR_LITERAL);
				_t = _t.getFirstChild();
				{
				if (_t==null) _t=ASTNULL;
				switch ( _t.getType()) {
				case BANG:
				case ROOT:
				case RULEROOT:
				{
					as3 = _t==ASTNULL ? null : (GrammarAST)_t;
					ast_suffix(_t);
					_t = _retTree;
					break;
				}
				case 3:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(_t);
				}
				}
				}
				_t = __t103;
				_t = _t.getNextSibling();
				
						if ( grammar.type==Grammar.LEXER ) {
							code = templates.getInstanceOf("charRef");
							code.setAttribute("char",
							   generator.target.getTargetCharLiteralFromANTLRCharLiteral(generator,c.getText()));
							if ( label!=null ) {
								code.setAttribute("label", label);
							}
						}
						else { // else it's a token type reference
							code = getTokenElementST("tokenRef", "char_literal", c, as3, label);