codegentreewalker.java

antlr最新版本V3源代码

				_t = __t65;
				_t = _t.getNextSibling();
				break;
			}
			case CHAR_RANGE:
			{
				AST __t66 = _t;
				GrammarAST tmp43_AST_in = (GrammarAST)_t;
				match(_t,CHAR_RANGE);
				_t = _t.getFirstChild();
				a = (GrammarAST)_t;
				match(_t,CHAR_LITERAL);
				_t = _t.getNextSibling();
				b = (GrammarAST)_t;
				match(_t,CHAR_LITERAL);
				_t = _t.getNextSibling();
				_t = __t66;
				_t = _t.getNextSibling();
				code = templates.getInstanceOf("charRangeRef");
						 String low =
						 	generator.target.getTargetCharLiteralFromANTLRCharLiteral(generator,a.getText());
						 String high =
						 	generator.target.getTargetCharLiteralFromANTLRCharLiteral(generator,b.getText());
				code.setAttribute("a", low);
				code.setAttribute("b", high);
				if ( label!=null ) {
				code.setAttribute("label", label.getText());
				}
				
				break;
			}
			case TREE_BEGIN:
			{
				code=tree(_t);
				_t = _retTree;
				break;
			}
			case ACTION:
			{
				code=element_action(_t);
				_t = _retTree;
				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");
				code.setAttribute("pred", generator.translateAction(currentRuleName,sp));
						String description =
							generator.target.getTargetStringLiteralFromString(sp.getText());
						code.setAttribute("description", description);
				
				break;
			}
			case SYN_SEMPRED:
			{
				GrammarAST tmp44_AST_in = (GrammarAST)_t;
				match(_t,SYN_SEMPRED);
				_t = _t.getNextSibling();
				break;
			}
			case BACKTRACK_SEMPRED:
			{
				GrammarAST tmp45_AST_in = (GrammarAST)_t;
				match(_t,BACKTRACK_SEMPRED);
				_t = _t.getNextSibling();
				break;
			}
			case EPSILON:
			{
				GrammarAST tmp46_AST_in = (GrammarAST)_t;
				match(_t,EPSILON);
				_t = _t.getNextSibling();
				break;
			}
			default:
				if (_t==null) _t=ASTNULL;
				if ((((_t.getType() >= BLOCK && _t.getType() <= POSITIVE_CLOSURE)))&&(element_AST_in.getSetValue()==null)) {
					code=ebnf(_t);
					_t = _retTree;
				}
				else if ((_t.getType()==BLOCK||_t.getType()==STRING_LITERAL||_t.getType()==CHAR_LITERAL||_t.getType()==TOKEN_REF||_t.getType()==RULE_REF||_t.getType()==WILDCARD)) {
					code=atom(_t,label, astSuffix);
					_t = _retTree;
				}
			else {
				throw new NoViableAltException(_t);
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			if (_t!=null) {_t = _t.getNextSibling();}
		}
		_retTree = _t;
		return code;
	}
	
	public final StringTemplate  notElement(AST _t,
		GrammarAST n, GrammarAST label, GrammarAST astSuffix
	) throws RecognitionException {
		StringTemplate code=null;
		
		GrammarAST notElement_AST_in = (_t == ASTNULL) ? null : (GrammarAST)_t;
		GrammarAST assign_c = null;
		GrammarAST assign_s = null;
		GrammarAST assign_t = null;
		GrammarAST assign_st = null;
		
		IntSet elements=null;
		String labelText = null;
		if ( label!=null ) {
		labelText = label.getText();
		}
		
		
		try {      // for error handling
			{
			if (_t==null) _t=ASTNULL;
			switch ( _t.getType()) {
			case CHAR_LITERAL:
			{
				assign_c = (GrammarAST)_t;
				match(_t,CHAR_LITERAL);
				_t = _t.getNextSibling();
				
				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);
				
				break;
			}
			case STRING_LITERAL:
			{
				assign_s = (GrammarAST)_t;
				match(_t,STRING_LITERAL);
				_t = _t.getNextSibling();
				
				int ttype=0;
				if ( grammar.type==Grammar.LEXER ) {
				// TODO: error!
				}
				else {
				ttype = grammar.getTokenType(assign_s.getText());
				}
				elements = grammar.complement(ttype);
				
				break;
			}
			case TOKEN_REF:
			{
				assign_t = (GrammarAST)_t;
				match(_t,TOKEN_REF);
				_t = _t.getNextSibling();
				
				int ttype = grammar.getTokenType(assign_t.getText());
				elements = grammar.complement(ttype);
				
				break;
			}
			case BLOCK:
			{
				assign_st = (GrammarAST)_t;
				match(_t,BLOCK);
				_t = _t.getNextSibling();
				
				elements = assign_st.getSetValue();
				elements = grammar.complement(elements);
				
				break;
			}
			default:
			{
				throw new NoViableAltException(_t);
			}
			}
			}
			
			code = getTokenElementST("matchSet",
			"set",
			(GrammarAST)n.getFirstChild(),
			astSuffix,
			labelText);
			code.setAttribute("s",generator.genSetExpr(templates,elements,1,false));
			int i = ((TokenWithIndex)n.getToken()).getIndex();
			code.setAttribute("elementIndex", i);
			if ( grammar.type!=Grammar.LEXER ) {
			generator.generateLocalFOLLOW(n,"set",currentRuleName,i);
			}
			
		}
		catch (RecognitionException ex) {
			reportError(ex);
			if (_t!=null) {_t = _t.getNextSibling();}
		}
		_retTree = _t;
		return code;
	}
	
	public final StringTemplate  ebnf(AST _t) throws RecognitionException {
		StringTemplate code=null;
		
		GrammarAST ebnf_AST_in = (_t == ASTNULL) ? null : (GrammarAST)_t;
		
		DFA dfa=null;
		GrammarAST b = (GrammarAST)ebnf_AST_in.getFirstChild();
		GrammarAST eob = (GrammarAST)b.getLastChild(); // loops will use EOB DFA
		
		
		try {      // for error handling
			{
			if (_t==null) _t=ASTNULL;
			switch ( _t.getType()) {
			case BLOCK:
			{
				dfa = ebnf_AST_in.getLookaheadDFA();
				code=block(_t,"block", dfa);
				_t = _retTree;
				break;
			}
			case OPTIONAL:
			{
				dfa = ebnf_AST_in.getLookaheadDFA();
				AST __t73 = _t;
				GrammarAST tmp47_AST_in = (GrammarAST)_t;
				match(_t,OPTIONAL);
				_t = _t.getFirstChild();
				code=block(_t,"optionalBlock", dfa);
				_t = _retTree;
				_t = __t73;
				_t = _t.getNextSibling();
				break;
			}
			case CLOSURE:
			{
				dfa = eob.getLookaheadDFA();
				AST __t74 = _t;
				GrammarAST tmp48_AST_in = (GrammarAST)_t;
				match(_t,CLOSURE);
				_t = _t.getFirstChild();
				code=block(_t,"closureBlock", dfa);
				_t = _retTree;
				_t = __t74;
				_t = _t.getNextSibling();
				break;
			}
			case POSITIVE_CLOSURE:
			{
				dfa = eob.getLookaheadDFA();
				AST __t75 = _t;
				GrammarAST tmp49_AST_in = (GrammarAST)_t;
				match(_t,POSITIVE_CLOSURE);
				_t = _t.getFirstChild();
				code=block(_t,"positiveClosureBlock", dfa);
				_t = _retTree;
				_t = __t75;
				_t = _t.getNextSibling();
				break;
			}
			default:
			{
				throw new NoViableAltException(_t);
			}
			}
			}
			
					String description = grammar.grammarTreeToString(ebnf_AST_in, false);
					description = generator.target.getTargetStringLiteralFromString(description);
				code.setAttribute("description", description);
				
		}
		catch (RecognitionException ex) {
			reportError(ex);
			if (_t!=null) {_t = _t.getNextSibling();}
		}
		_retTree = _t;
		return code;
	}
	
	public final StringTemplate  atom(AST _t,
		GrammarAST label, GrammarAST astSuffix
	) throws RecognitionException {
		StringTemplate code=null;
		
		GrammarAST atom_AST_in = (_t == ASTNULL) ? null : (GrammarAST)_t;
		GrammarAST r = null;
		GrammarAST rarg = null;
		GrammarAST t = null;
		GrammarAST targ = null;
		GrammarAST c = null;
		GrammarAST s = null;
		GrammarAST w = null;
		
		String labelText=null;
		if ( label!=null ) {
		labelText = label.getText();
		}
		
		
		try {      // for error handling
			if (_t==null) _t=ASTNULL;
			switch ( _t.getType()) {
			case RULE_REF:
			{
				AST __t83 = _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:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(_t);
				}
				}
				}
				_t = __t83;
				_t = _t.getNextSibling();
				
				grammar.checkRuleReference(r, rarg, currentRuleName);
				Rule rdef = grammar.getRule(r.getText());
				// don't insert label=r() if $label.attr not used, no ret value, ...
				if ( !rdef.getHasReturnValue() ) {
				labelText = null;
				}
				code = getRuleElementST("ruleRef", r.getText(), r, astSuffix, labelText);
						code.setAttribute("rule", r.getText());
				
						if ( rarg!=null ) {
							List args = generator.translateAction(currentRuleName,rarg);
							code.setAttribute("args", args);
						}
				int i = ((TokenWithIndex)r.getToken()).getIndex();
						code.setAttribute("elementIndex", i);
						generator.generateLocalFOLLOW(r,r.getText(),currentRuleName,i);
						r.code = code;
				
				break;
			}
			case TOKEN_REF:
			{
				AST __t85 = _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:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(_t);
				}
				}
				}
				_t = __t85;
				_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");
				if ( isListLabel(labelText) ) {
				code = templates.getInstanceOf("lexerRuleRefAndListLabel");
				}
									code.setAttribute("rule", t.getText());
									if ( targ!=null ) {
										List args = generator.translateAction(currentRuleName,targ);
										code.setAttribute("args", args);
									}
								}
				int i = ((TokenWithIndex)t.getToken()).getIndex();
							    code.setAttribute("elementIndex", i);
							    if ( label!=null ) code.setAttribute("label", labelText);
						   }
						   else {
								code = getTokenElementST("tokenRef", t.getText(), t, astSuffix, labelText);
								String tokenLabel =
								   generator.getTokenTypeAsTargetLabel(grammar.getTokenType(t.getText()));
								code.setAttribute("token",tokenLabel);
				int i = ((TokenWithIndex)t.getToken()).getIndex();
							    code.setAttribute("elementIndex", i);
							    generator.generateLocalFOLLOW(t,tokenLabel,currentRuleName,i);
						   }
						   t.code = code;
						
				break;
			}
			case CHAR_LITERAL:
			{
				c = (GrammarAST)_t;
				match(_t,CHAR_LITERAL);
				_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", labelText);
							}
						}
						else { // else it's a token type reference
							code = getTokenElementST("tokenRef", "char_literal", c, astSuffix, labelText);
							String tokenLabel = generator.getTokenTypeAsTargetLabel(grammar.getTokenType(c.getText()));
							code.setAttribute("token",tokenLabel);
				int i = ((TokenWithIndex)c.getToken()).getIndex();
							code.setAttribute("elementIndex", i);
							generator.generateLocalFOLLOW(c,tokenLabel,currentRuleName,i);
						}
				
				break;
			}
			case STRING_LITERAL:
			{
				s = (GrammarAST)_t;
				match(_t,STRING_LITERAL);
				_t = _t.getNextSibling();
				
						if ( grammar.type==Grammar.LEXER ) {
							code = templates.getInstanceOf("lexerStringRef");
							code.setAttribute("string",
							   generator.target.getTargetStringLiteralFromANTLRStringLiteral(generator,s.getText()));
							if ( label!=null ) {
								code.setAttribute("label", labelText);
							}
						}
						else { // else it's a token type reference
							code = getTokenElementST("tokenRef", "string_literal", s, astSuffix, labelText);
							String tokenLabel =
							   generator.getTokenTypeAsTargetLabel(grammar.getTokenType(s.getText()));
							code.setAttribute("token",tokenLabel);
				int i = ((TokenWithIndex)s.getToken()).getIndex();
							code.setAttribute("elementIndex", i);
							generator.generateLocalFOLLOW(s,tokenLabel,currentRuleName,i);
						}
						
				break;
			}
			case WILDCARD:
			{
				w = (GrammarAST)_t;
				match(_t,WILDCARD);
				_t = _t.getNextSibling();
				
						code = getWildcardST(w,astSuffix,labelText);
						code.setAttribute("elementIndex", ((TokenWithIndex)w.getToken()).getIndex());
						
				break;
			}
			case BLOCK:
			{
				code=set(_t,label,astSuffix);
				_t = _retTree;
				break;
			}