antlrparser.java

来自「antlr最新版本V3源代码」· Java 代码 · 共 2,609 行 · 第 1/5 页

						astFactory.makeASTRoot(currentAST, tmp48_AST);
						match(PLUS_ASSIGN);
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					{
					switch ( LA(1)) {
					case STRING_LITERAL:
					case CHAR_LITERAL:
					case TOKEN_REF:
					case RULE_REF:
					case NOT:
					case WILDCARD:
					{
						atom();
						astFactory.addASTChild(currentAST, returnAST);
						break;
					}
					case LPAREN:
					{
						block();
						astFactory.addASTChild(currentAST, returnAST);
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					{
					switch ( LA(1)) {
					case STAR:
					case QUESTION:
					case PLUS:
					{
						sub=ebnfSuffix((GrammarAST)currentAST.root,false);
						elementNoOptionSpec_AST = (GrammarAST)currentAST.root;
						elementNoOptionSpec_AST=sub;
						currentAST.root = elementNoOptionSpec_AST;
						currentAST.child = elementNoOptionSpec_AST!=null &&elementNoOptionSpec_AST.getFirstChild()!=null ?
							elementNoOptionSpec_AST.getFirstChild() : elementNoOptionSpec_AST;
						currentAST.advanceChildToEnd();
						break;
					}
					case ACTION:
					case SEMI:
					case STRING_LITERAL:
					case CHAR_LITERAL:
					case TOKEN_REF:
					case LPAREN:
					case OR:
					case RPAREN:
					case SEMPRED:
					case RULE_REF:
					case NOT:
					case TREE_BEGIN:
					case WILDCARD:
					case REWRITE:
					{
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					elementNoOptionSpec_AST = (GrammarAST)currentAST.root;
				}
				else if ((_tokenSet_23.member(LA(1))) && (_tokenSet_24.member(LA(2)))) {
					atom();
					astFactory.addASTChild(currentAST, returnAST);
					{
					switch ( LA(1)) {
					case STAR:
					case QUESTION:
					case PLUS:
					{
						sub2=ebnfSuffix((GrammarAST)currentAST.root,false);
						elementNoOptionSpec_AST = (GrammarAST)currentAST.root;
						elementNoOptionSpec_AST=sub2;
						currentAST.root = elementNoOptionSpec_AST;
						currentAST.child = elementNoOptionSpec_AST!=null &&elementNoOptionSpec_AST.getFirstChild()!=null ?
							elementNoOptionSpec_AST.getFirstChild() : elementNoOptionSpec_AST;
						currentAST.advanceChildToEnd();
						break;
					}
					case ACTION:
					case SEMI:
					case STRING_LITERAL:
					case CHAR_LITERAL:
					case TOKEN_REF:
					case LPAREN:
					case OR:
					case RPAREN:
					case SEMPRED:
					case RULE_REF:
					case NOT:
					case TREE_BEGIN:
					case WILDCARD:
					case REWRITE:
					{
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					elementNoOptionSpec_AST = (GrammarAST)currentAST.root;
				}
			else {
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			recover(ex,_tokenSet_21);
		}
		returnAST = elementNoOptionSpec_AST;
	}
	
	public final void atom() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		GrammarAST atom_AST = null;
		Token  rr = null;
		GrammarAST rr_AST = null;
		
		try {      // for error handling
			switch ( LA(1)) {
			case NOT:
			{
				notSet();
				astFactory.addASTChild(currentAST, returnAST);
				{
				switch ( LA(1)) {
				case ROOT:
				{
					GrammarAST tmp49_AST = null;
					tmp49_AST = (GrammarAST)astFactory.create(LT(1));
					astFactory.makeASTRoot(currentAST, tmp49_AST);
					match(ROOT);
					break;
				}
				case BANG:
				{
					GrammarAST tmp50_AST = null;
					tmp50_AST = (GrammarAST)astFactory.create(LT(1));
					astFactory.makeASTRoot(currentAST, tmp50_AST);
					match(BANG);
					break;
				}
				case ACTION:
				case SEMI:
				case STRING_LITERAL:
				case CHAR_LITERAL:
				case STAR:
				case TOKEN_REF:
				case LPAREN:
				case OR:
				case RPAREN:
				case SEMPRED:
				case RULE_REF:
				case NOT:
				case TREE_BEGIN:
				case QUESTION:
				case PLUS:
				case WILDCARD:
				case REWRITE:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				atom_AST = (GrammarAST)currentAST.root;
				break;
			}
			case RULE_REF:
			{
				rr = LT(1);
				rr_AST = (GrammarAST)astFactory.create(rr);
				astFactory.makeASTRoot(currentAST, rr_AST);
				match(RULE_REF);
				{
				switch ( LA(1)) {
				case ARG_ACTION:
				{
					GrammarAST tmp51_AST = null;
					tmp51_AST = (GrammarAST)astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp51_AST);
					match(ARG_ACTION);
					break;
				}
				case ACTION:
				case SEMI:
				case STRING_LITERAL:
				case CHAR_LITERAL:
				case STAR:
				case TOKEN_REF:
				case BANG:
				case LPAREN:
				case OR:
				case RPAREN:
				case SEMPRED:
				case ROOT:
				case RULE_REF:
				case NOT:
				case TREE_BEGIN:
				case QUESTION:
				case PLUS:
				case WILDCARD:
				case REWRITE:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				{
				switch ( LA(1)) {
				case ROOT:
				{
					GrammarAST tmp52_AST = null;
					tmp52_AST = (GrammarAST)astFactory.create(LT(1));
					astFactory.makeASTRoot(currentAST, tmp52_AST);
					match(ROOT);
					break;
				}
				case BANG:
				{
					GrammarAST tmp53_AST = null;
					tmp53_AST = (GrammarAST)astFactory.create(LT(1));
					astFactory.makeASTRoot(currentAST, tmp53_AST);
					match(BANG);
					break;
				}
				case ACTION:
				case SEMI:
				case STRING_LITERAL:
				case CHAR_LITERAL:
				case STAR:
				case TOKEN_REF:
				case LPAREN:
				case OR:
				case RPAREN:
				case SEMPRED:
				case RULE_REF:
				case NOT:
				case TREE_BEGIN:
				case QUESTION:
				case PLUS:
				case WILDCARD:
				case REWRITE:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				atom_AST = (GrammarAST)currentAST.root;
				break;
			}
			default:
				if ((LA(1)==CHAR_LITERAL) && (LA(2)==RANGE)) {
					range();
					astFactory.addASTChild(currentAST, returnAST);
					{
					switch ( LA(1)) {
					case ROOT:
					{
						GrammarAST tmp54_AST = null;
						tmp54_AST = (GrammarAST)astFactory.create(LT(1));
						astFactory.makeASTRoot(currentAST, tmp54_AST);
						match(ROOT);
						break;
					}
					case BANG:
					{
						GrammarAST tmp55_AST = null;
						tmp55_AST = (GrammarAST)astFactory.create(LT(1));
						astFactory.makeASTRoot(currentAST, tmp55_AST);
						match(BANG);
						break;
					}
					case ACTION:
					case SEMI:
					case STRING_LITERAL:
					case CHAR_LITERAL:
					case STAR:
					case TOKEN_REF:
					case LPAREN:
					case OR:
					case RPAREN:
					case SEMPRED:
					case RULE_REF:
					case NOT:
					case TREE_BEGIN:
					case QUESTION:
					case PLUS:
					case WILDCARD:
					case REWRITE:
					{
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					atom_AST = (GrammarAST)currentAST.root;
				}
				else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
					terminal();
					astFactory.addASTChild(currentAST, returnAST);
					atom_AST = (GrammarAST)currentAST.root;
				}
			else {
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			reportError(ex);
			recover(ex,_tokenSet_27);
		}
		returnAST = atom_AST;
	}
	
	public final GrammarAST  ebnfSuffix(
		GrammarAST elemAST, boolean inRewrite
	) throws RecognitionException, TokenStreamException {
		GrammarAST subrule=null;
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		GrammarAST ebnfSuffix_AST = null;
		
		GrammarAST ebnfRoot=null;
		
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case QUESTION:
			{
				GrammarAST tmp56_AST = null;
				tmp56_AST = (GrammarAST)astFactory.create(LT(1));
				match(QUESTION);
				ebnfRoot = (GrammarAST)astFactory.create(OPTIONAL,"?");
				break;
			}
			case STAR:
			{
				GrammarAST tmp57_AST = null;
				tmp57_AST = (GrammarAST)astFactory.create(LT(1));
				match(STAR);
				ebnfRoot = (GrammarAST)astFactory.create(CLOSURE,"*");
				break;
			}
			case PLUS:
			{
				GrammarAST tmp58_AST = null;
				tmp58_AST = (GrammarAST)astFactory.create(LT(1));
				match(PLUS);
				ebnfRoot = (GrammarAST)astFactory.create(POSITIVE_CLOSURE,"+");
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			
					GrammarAST save = currentBlockAST;
				ebnfRoot.setLine(elemAST.getLine());
				ebnfRoot.setColumn(elemAST.getColumn());
				GrammarAST blkRoot = (GrammarAST)astFactory.create(BLOCK,"BLOCK");
				currentBlockAST = blkRoot;
				GrammarAST eob = (GrammarAST)astFactory.create(EOB,"<end-of-block>");
					eob.setLine(elemAST.getLine());
					eob.setColumn(elemAST.getColumn());
					GrammarAST alt = (GrammarAST)astFactory.make( (new ASTArray(3)).add((GrammarAST)astFactory.create(ALT,"ALT")).add(elemAST).add((GrammarAST)astFactory.create(EOA,"<end-of-alt>")));
				if ( !inRewrite ) {
					prefixWithSynPred(alt);
				}
					subrule =
					     (GrammarAST)astFactory.make( (new ASTArray(2)).add(ebnfRoot).add((GrammarAST)astFactory.make( (new ASTArray(3)).add(blkRoot).add(alt).add(eob))));
					currentBlockAST = save;
					
		}
		catch (RecognitionException ex) {
			reportError(ex);
			recover(ex,_tokenSet_28);
		}
		returnAST = ebnfSuffix_AST;
		return subrule;
	}
	
/** matches ENBF blocks (and sets via block rule) */
	public final void ebnf() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		GrammarAST ebnf_AST = null;
		GrammarAST b_AST = null;
		
		int line = LT(1).getLine();
		int col = LT(1).getColumn();
		
		
		try {      // for error handling
			block();
			b_AST = (GrammarAST)returnAST;
			{
			switch ( LA(1)) {
			case QUESTION:
			{
				GrammarAST tmp59_AST = null;
				tmp59_AST = (GrammarAST)astFactory.create(LT(1));
				match(QUESTION);
				ebnf_AST = (GrammarAST)currentAST.root;
				ebnf_AST=(GrammarAST)astFactory.make( (new ASTArray(2)).add((GrammarAST)astFactory.create(OPTIONAL,"?")).add(b_AST));
				currentAST.root = ebnf_AST;
				currentAST.child = ebnf_AST!=null &&ebnf_AST.getFirstChild()!=null ?
					ebnf_AST.getFirstChild() : ebnf_AST;
				currentAST.advanceChildToEnd();
				break;
			}
			case STAR:
			{
				GrammarAST tmp60_AST = null;
				tmp60_AST = (GrammarAST)astFactory.create(LT(1));
				match(STAR);
				ebnf_AST = (GrammarAST)currentAST.root;
				ebnf_AST=(GrammarAST)astFactory.make( (new ASTArray(2)).add((GrammarAST)astFactory.create(CLOSURE,"*")).add(b_AST));
				currentAST.root = ebnf_AST;
				currentAST.child = ebnf_AST!=null &&ebnf_AST.getFirstChild()!=null ?
					ebnf_AST.getFirstChild() : ebnf_AST;
				currentAST.advanceChildToEnd();
				break;
			}
			case PLUS:
			{
				GrammarAST tmp61_AST = null;
				tmp61_AST = (GrammarAST)astFactory.create(LT(1));
				match(PLUS);
				ebnf_AST = (GrammarAST)currentAST.root;
				ebnf_AST=(GrammarAST)astFactory.make( (new ASTArray(2)).add((GrammarAST)astFactory.create(POSITIVE_CLOSURE,"+")).add(b_AST));
				currentAST.root = ebnf_AST;
				currentAST.child = ebnf_AST!=null &&ebnf_AST.getFirstChild()!=null ?
					ebnf_AST.getFirstChild() : ebnf_AST;
				currentAST.advanceChildToEnd();
				break;
			}
			case IMPLIES:
			{
				match(IMPLIES);
				ebnf_AST = (GrammarAST)currentAST.root;
				
							if ( gtype==COMBINED_GRAMMAR &&
							     Character.isUpperCase(currentRuleName.charAt(0)) )
						    {
				// ignore for lexer rules in combined
						    	ebnf_AST = (GrammarAST)astFactory.make( (new ASTArray(2)).add((GrammarAST)astFactory.create(SYNPRED,"=>")).add(b_AST)); 
						    }
						    else {
						    	// create manually specified (...)=> predicate;
				// convert to sempred
						    	ebnf_AST = createSynSemPredFromBlock(b_AST, SYN_SEMPRED);
							}
							
				currentAST.root = ebnf_AST;
				currentAST.child = ebnf_AST!=null &&ebnf_AST.getFirstChild()!=null ?
					ebnf_AST.getFirstChild() : ebnf_AST;
				currentAST.advanceChildToEnd();
				break;
			}
			case ROOT:
			{
				GrammarAST tmp63_AST = null;
				tmp63_AST = (GrammarAST)astFactory.create(LT(1));
				match(ROOT);
				ebnf_AST = (GrammarAST)currentAST.root;
				ebnf_AST = (GrammarAST)astFactory.make( (new ASTArray(2)).add(tmp63_AST).add(b_AST));
				currentAST.root = ebnf_AST;
				currentAST.child = ebnf_AST!=null &&ebnf_AST.getFirstChild()!=null ?
					ebnf_AST.getFirstChild() : ebnf_AST;
				currentAST.advanceChildToEnd();
				break;
			}
			case BANG:
			{
				GrammarAST tmp64_AST = null;
				tmp64_AST = (GrammarAST)astFactory.create(LT(1));
				match(BANG);
				ebnf_AST = (GrammarAST)currentAST.root;
				ebnf_AST = (GrammarAST)astFactory.make( (new ASTArray(2)).add(tmp64_AST).add(b_AST));
				currentAST.root = ebnf_AST;
				currentAST.child = ebnf_AST!=null &&ebnf_