treetonfaconverter.java

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

		
		try {      // for error handling
			if (_t==null) _t=ASTNULL;
			switch ( _t.getType()) {
			case SET:
			case STRING_LITERAL:
			case CHAR_LITERAL:
			case TOKEN_REF:
			case RULE_REF:
			case WILDCARD:
			{
				g=atom(_t);
				_t = _retTree;
				break;
			}
			case NOT:
			{
				AST __t90 = _t;
				n = _t==ASTNULL ? null :(GrammarAST)_t;
				match(_t,NOT);
				_t = _t.getFirstChild();
				{
				if (_t==null) _t=ASTNULL;
				switch ( _t.getType()) {
				case CHAR_LITERAL:
				{
					c = (GrammarAST)_t;
					match(_t,CHAR_LITERAL);
					_t = _t.getNextSibling();
					{
					if (_t==null) _t=ASTNULL;
					switch ( _t.getType()) {
					case BANG:
					case ROOT:
					case RULEROOT:
					{
						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(c.getText());
								}
								else {
								ttype = grammar.getTokenType(c.getText());
							}
					IntSet notAtom = grammar.complement(ttype);
					if ( notAtom.isNil() ) {
					ErrorManager.grammarError(ErrorManager.MSG_EMPTY_COMPLEMENT,
										  			              grammar,
													              c.token,
														          c.getText());
					}
						            g=factory.build_Set(notAtom);
						
					break;
				}
				case TOKEN_REF:
				{
					t = (GrammarAST)_t;
					match(_t,TOKEN_REF);
					_t = _t.getNextSibling();
					{
					if (_t==null) _t=ASTNULL;
					switch ( _t.getType()) {
					case BANG:
					case ROOT:
					case RULEROOT:
					{
						ast3 = _t==ASTNULL ? null : (GrammarAST)_t;
						ast_suffix(_t);
						_t = _retTree;
						break;
					}
					case 3:
					{
						break;
					}
					default:
					{
						throw new NoViableAltException(_t);
					}
					}
					}
					
						           int ttype = grammar.getTokenType(t.getText());
					IntSet notAtom = grammar.complement(ttype);
					if ( notAtom.isNil() ) {
					ErrorManager.grammarError(ErrorManager.MSG_EMPTY_COMPLEMENT,
									  			              grammar,
												              t.token,
													          t.getText());
					}
						           g=factory.build_Set(notAtom);
						
					break;
				}
				case SET:
				{
					g=set(_t);
					_t = _retTree;
					
						           GrammarAST stNode = (GrammarAST)n.getFirstChild();
					IntSet notSet = grammar.complement(stNode.getSetValue());
					stNode.setSetValue(notSet);
					if ( notSet.isNil() ) {
					ErrorManager.grammarError(ErrorManager.MSG_EMPTY_COMPLEMENT,
									  			              grammar,
												              n.token);
					}
						           g=factory.build_Set(notSet);
						
					break;
				}
				default:
				{
					throw new NoViableAltException(_t);
				}
				}
				}
				n.followingNFAState = g.right;
				_t = __t90;
				_t = _t.getNextSibling();
				break;
			}
			default:
			{
				throw new NoViableAltException(_t);
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			if (_t!=null) {_t = _t.getNextSibling();}
		}
		_retTree = _t;
		return g;
	}
	
	public final StateCluster  ebnf(AST _t) throws RecognitionException {
		StateCluster g=null;
		
		GrammarAST ebnf_AST_in = (_t == ASTNULL) ? null : (GrammarAST)_t;
		GrammarAST blk = null;
		GrammarAST eob = null;
		GrammarAST blk2 = null;
		GrammarAST eob3 = null;
		
		StateCluster b = null;
		
		
		try {      // for error handling
			if (_t==null) _t=ASTNULL;
			switch ( _t.getType()) {
			case BLOCK:
			{
				AST __t78 = _t;
				GrammarAST tmp55_AST_in = (GrammarAST)_t;
				match(_t,BLOCK);
				_t = _t.getFirstChild();
				b=block(_t);
				_t = _retTree;
				GrammarAST tmp56_AST_in = (GrammarAST)_t;
				match(_t,EOB);
				_t = _t.getNextSibling();
				_t = __t78;
				_t = _t.getNextSibling();
				
				// track decision if > 1 alts
				if ( grammar.getNumberOfAltsForDecisionNFA(b.left)>1 ) {
				b.left.setDescription(grammar.grammarTreeToString(tmp55_AST_in,false));
				b.left.setDecisionASTNode(tmp55_AST_in);
				int d = grammar.assignDecisionNumber( b.left );
				grammar.setDecisionNFA( d, b.left );
				grammar.setDecisionBlockAST(d, tmp55_AST_in);
				}
				g = b;
				
				break;
			}
			case OPTIONAL:
			{
				AST __t79 = _t;
				GrammarAST tmp57_AST_in = (GrammarAST)_t;
				match(_t,OPTIONAL);
				_t = _t.getFirstChild();
				AST __t80 = _t;
				blk = _t==ASTNULL ? null :(GrammarAST)_t;
				match(_t,BLOCK);
				_t = _t.getFirstChild();
				b=block(_t);
				_t = _retTree;
				GrammarAST tmp58_AST_in = (GrammarAST)_t;
				match(_t,EOB);
				_t = _t.getNextSibling();
				_t = __t80;
				_t = _t.getNextSibling();
				_t = __t79;
				_t = _t.getNextSibling();
				
				g = factory.build_Aoptional(b);
					g.left.setDescription(grammar.grammarTreeToString(ebnf_AST_in,false));
				// there is always at least one alt even if block has just 1 alt
				int d = grammar.assignDecisionNumber( g.left );
						grammar.setDecisionNFA(d, g.left);
				grammar.setDecisionBlockAST(d, blk);
				g.left.setDecisionASTNode(ebnf_AST_in);
					
				break;
			}
			case CLOSURE:
			{
				AST __t81 = _t;
				GrammarAST tmp59_AST_in = (GrammarAST)_t;
				match(_t,CLOSURE);
				_t = _t.getFirstChild();
				AST __t82 = _t;
				GrammarAST tmp60_AST_in = (GrammarAST)_t;
				match(_t,BLOCK);
				_t = _t.getFirstChild();
				b=block(_t);
				_t = _retTree;
				eob = (GrammarAST)_t;
				match(_t,EOB);
				_t = _t.getNextSibling();
				_t = __t82;
				_t = _t.getNextSibling();
				_t = __t81;
				_t = _t.getNextSibling();
				
				g = factory.build_Astar(b);
						// track the loop back / exit decision point
					b.right.setDescription("()* loopback of "+grammar.grammarTreeToString(ebnf_AST_in,false));
				int d = grammar.assignDecisionNumber( b.right );
						grammar.setDecisionNFA(d, b.right);
				grammar.setDecisionBlockAST(d, tmp60_AST_in);
				b.right.setDecisionASTNode(eob);
				// make block entry state also have same decision for interpreting grammar
				NFAState altBlockState = (NFAState)g.left.transition(0).target;
				altBlockState.setDecisionASTNode(ebnf_AST_in);
				altBlockState.setDecisionNumber(d);
				g.left.setDecisionNumber(d); // this is the bypass decision (2 alts)
				g.left.setDecisionASTNode(ebnf_AST_in);
					
				break;
			}
			case POSITIVE_CLOSURE:
			{
				AST __t83 = _t;
				GrammarAST tmp61_AST_in = (GrammarAST)_t;
				match(_t,POSITIVE_CLOSURE);
				_t = _t.getFirstChild();
				AST __t84 = _t;
				blk2 = _t==ASTNULL ? null :(GrammarAST)_t;
				match(_t,BLOCK);
				_t = _t.getFirstChild();
				b=block(_t);
				_t = _retTree;
				eob3 = (GrammarAST)_t;
				match(_t,EOB);
				_t = _t.getNextSibling();
				_t = __t84;
				_t = _t.getNextSibling();
				_t = __t83;
				_t = _t.getNextSibling();
				
				g = factory.build_Aplus(b);
				// don't make a decision on left edge, can reuse loop end decision
						// track the loop back / exit decision point
					b.right.setDescription("()+ loopback of "+grammar.grammarTreeToString(ebnf_AST_in,false));
				int d = grammar.assignDecisionNumber( b.right );
						grammar.setDecisionNFA(d, b.right);
				grammar.setDecisionBlockAST(d, blk2);
				b.right.setDecisionASTNode(eob3);
				// make block entry state also have same decision for interpreting grammar
				NFAState altBlockState = (NFAState)g.left.transition(0).target;
				altBlockState.setDecisionASTNode(ebnf_AST_in);
				altBlockState.setDecisionNumber(d);
				
				break;
			}
			default:
			{
				throw new NoViableAltException(_t);
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			if (_t!=null) {_t = _t.getNextSibling();}
		}
		_retTree = _t;
		return g;
	}
	
	public final StateCluster  tree(AST _t) throws RecognitionException {
		StateCluster g=null;
		
		GrammarAST tree_AST_in = (_t == ASTNULL) ? null : (GrammarAST)_t;
		
		StateCluster e=null;
		
		
		try {      // for error handling
			AST __t86 = _t;
			GrammarAST tmp62_AST_in = (GrammarAST)_t;
			match(_t,TREE_BEGIN);
			_t = _t.getFirstChild();
			GrammarAST el=(GrammarAST)_t;
			g=element(_t);
			_t = _retTree;
			
			StateCluster down = factory.build_Atom(Label.DOWN);
			// TODO set following states for imaginary nodes?
			//el.followingNFAState = down.right;
					   g = factory.build_AB(g,down);
					
			{
			_loop88:
			do {
				if (_t==null) _t=ASTNULL;
				if ((_tokenSet_0.member(_t.getType()))) {
					el=(GrammarAST)_t;
					e=element(_t);
					_t = _retTree;
					g = factory.build_AB(g,e);
				}
				else {
					break _loop88;
				}
				
			} while (true);
			}
			
			StateCluster up = factory.build_Atom(Label.UP);
			//el.followingNFAState = up.right;
					   g = factory.build_AB(g,up);
					   // tree roots point at right edge of DOWN for LOOK computation later
					   tree_AST_in.NFATreeDownState = down.left;
					
			_t = __t86;
			_t = _t.getNextSibling();
		}
		catch (RecognitionException ex) {
			reportError(ex);
			if (_t!=null) {_t = _t.getNextSibling();}
		}
		_retTree = _t;
		return g;
	}
	
	public final void setElement(AST _t,
		IntSet elements
	) throws RecognitionException {
		
		GrammarAST setElement_AST_in = (_t == ASTNULL) ? null : (GrammarAST)_t;
		GrammarAST c = null;
		GrammarAST t = null;
		GrammarAST s = null;
		GrammarAST c1 = null;
		GrammarAST c2 = null;
		
		int ttype;
		
		
		try {      // for error handling
			if (_t==null) _t=ASTNULL;
			switch ( _t.getType()) {
			case CHAR_LITERAL:
			{
				c = (GrammarAST)_t;
				match(_t,CHAR_LITERAL);
				_t = _t.getNextSibling();
				
					if ( grammar.type==Grammar.LEXER ) {
					ttype = Grammar.getCharValueFromGrammarCharLiteral(c.getText());
					}
					else {
					ttype = grammar.getTokenType(c.getText());
				}
				if ( elements.member(ttype) ) {
							ErrorManager.grammarError(ErrorManager.MSG_DUPLICATE_SET_ENTRY,
													  grammar,
													  c.token,
													  c.getText());
				}
				elements.add(ttype);
				
				break;
			}
			case TOKEN_REF:
			{
				t = (GrammarAST)_t;
				match(_t,TOKEN_REF);
				_t = _t.getNextSibling();
				
				ttype = grammar.getTokenType(t.getText());
				if ( elements.member(ttype) ) {
							ErrorManager.grammarError(ErrorManager.MSG_DUPLICATE_SET_ENTRY,
													  grammar,
													  t.token,
													  t.getText());
				}
				elements.add(ttype);
				
				break;
			}
			case STRING_LITERAL:
			{
				s = (GrammarAST)_t;
				match(_t,STRING_LITERAL);
				_t = _t.getNextSibling();
				
				ttype = grammar.getTokenType(s.getText());
				if ( elements.member(ttype) ) {
							ErrorManager.grammarError(ErrorManager.MSG_DUPLICATE_SET_ENTRY,
													  grammar,
													  s.token,
													  s.getText());
				}
				elements.add(ttype);
				
				break;
			}
			case CHAR_RANGE:
			{
				AST __t114 = _t;
				GrammarAST tmp63_AST_in = (GrammarAST)_t;
				match(_t,CHAR_RANGE);
				_t = _t.getFirstChild();
				c1 = (GrammarAST)_t;
				match(_t,CHAR_LITERAL);
				_t = _t.getNextSibling();
				c2 = (GrammarAST)_t;
				match(_t,CHAR_LITERAL);
				_t = _t.getNextSibling();
				_t = __t114;
				_t = _t.getNextSibling();
				
					if ( grammar.type==Grammar.LEXER ) {
					        int a = Grammar.getCharValueFromGrammarCharLiteral(c1.getText());
					    int b = Grammar.getCharValueFromGrammarCharLiteral(c2.getText());
						elements.addAll(IntervalSet.of(a,b));
					}
					
				break;
			}
			default:
			{
				throw new NoViableAltException(_t);
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			if (_t!=null) {_t = _t.getNextSibling();}
		}
		_retTree = _t;
	}
	
	
	public static final String[] _tokenNames = {
		"<0>",
		"EOF",
		"<2>",
		"NULL_TREE_LOOKAHEAD",
		"\"options\"",
		"\"tokens\"",
		"\"parser\"",
		"LEXER",
		"RULE",
		"BLOCK",
		"OPTIONAL",
		"CLOSURE",
		"POSITIVE_CLOSURE",
		"SYNPRED",
		"RANGE",
		"CHAR_RANGE",
		"EPSILON",
		"ALT",
		"EOR",
		"EOB",
		"EOA",
		"CHARSET",
		"SET",
		"ID",
		"ARG",
		"ARGLIST",
		"RET",
		"LEXER_GRAMMAR",
		"PARSER_GRAMMAR",
		"TREE_GRAMMAR",
		"COMBINED_GRAMMAR",
		"INITACTION",
		"LABEL",
		"TEMPLATE",
		"\"scope\"",
		"GATED_SEMPRED",
		"SYN_SEMPRED",
		"\"fragment\"",
		"ACTION",
		"DOC_COMMENT",
		"SEMI",
		"\"lexer\"",
		"\"tree\"",
		"\"grammar\"",
		"AMPERSAND",
		"COLON",
		"RCURLY",
		"ASSIGN",
		"STRING_LITERAL",
		"CHAR_LITERAL",
		"INT",
		"STAR",
		"TOKEN_REF",
		"\"protected\"",
		"\"public\"",
		"\"private\"",
		"BANG",
		"ARG_ACTION",
		"\"returns\"",
		"\"throws\"",
		"COMMA",
		"LPAREN",
		"OR",
		"RPAREN",
		"\"exception\"",
		"\"catch\"",
		"OPEN_ELEMENT_OPTION",
		"CLOSE_ELEMENT_OPTION",
		"PLUS_ASSIGN",
		"SEMPRED",
		"IMPLIES",
		"NOT",
		"TREE_BEGIN",
		"QUESTION",
		"PLUS",
		"RULE_REF",
		"WILDCARD",
		"ROOT",
		"RULEROOT",
		"REWRITE",
		"DOLLAR",
		"DOUBLE_QUOTE_STRING_LITERAL",
		"DOUBLE_ANGLE_STRING_LITERAL",
		"WS",
		"COMMENT",
		"SL_COMMENT",
		"ML_COMMENT",
		"ESC",
		"DIGIT",
		"XDIGIT",
		"NESTED_ARG_ACTION",
		"NESTED_ACTION",
		"ACTION_CHAR_LITERAL",
		"ACTION_STRING_LITERAL",
		"ACTION_ESC",
		"WS_LOOP",
		"INTERNAL_RULE_REF",
		"WS_OPT",
		"SRC"
	};
	
	private static final long[] mk_tokenSet_0() {
		long[] data = { 5489140007304704L, 6576L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
	private static final long[] mk_tokenSet_1() {
		long[] data = { 5348024557535232L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
	}