oaaprologparser.java

SRI international 发布的OAA框架软件

// $ANTLR 2.7.1: "OaaPrologNetParse.g" -> "OaaPrologParser.java"$

package com.sri.oaa2.icl;

import java.util.Stack;

import antlr_oaa.TokenBuffer;
import antlr_oaa.TokenStreamException;
import antlr_oaa.TokenStreamIOException;
import antlr_oaa.ANTLRException;
import antlr_oaa.LLkParser;
import antlr_oaa.Token;
import antlr_oaa.TokenStream;
import antlr_oaa.RecognitionException;
import antlr_oaa.NoViableAltException;
import antlr_oaa.MismatchedTokenException;
import antlr_oaa.SemanticException;
import antlr_oaa.ParserSharedInputState;
import antlr_oaa.collections.impl.BitSet;
import antlr_oaa.collections.AST;
import antlr_oaa.ASTPair;
import antlr_oaa.collections.impl.ASTArray;

public class OaaPrologParser extends antlr_oaa.LLkParser
       implements OaaPrologVocabTokenTypes
 {

    private Stack listStack = new Stack();

protected OaaPrologParser(TokenBuffer tokenBuf, int k) {
  super(tokenBuf,k);
  tokenNames = _tokenNames;
}

public OaaPrologParser(TokenBuffer tokenBuf) {
  this(tokenBuf,2);
}

protected OaaPrologParser(TokenStream lexer, int k) {
  super(lexer,k);
  tokenNames = _tokenNames;
}

public OaaPrologParser(TokenStream lexer) {
  this(lexer,2);
}

public OaaPrologParser(ParserSharedInputState state) {
  super(state,2);
  tokenNames = _tokenNames;
}

	public final void startMulti() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST startMulti_AST = null;
		
		{
		switch ( LA(1)) {
		case DOT:
		{
			LT(1);
			match(DOT);
			break;
		}
		case TERM_LITERAL:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		netstruct();
		astFactory.addASTChild(currentAST, returnAST);
		startMulti_AST = (AST)currentAST.root;
		returnAST = startMulti_AST;
	}
	
	public final void netstruct() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST netstruct_AST = null;
		
		IclASTStruct tmp2_AST = null;
		tmp2_AST = new IclASTStruct(LT(1));
		astFactory.makeASTRoot(currentAST, tmp2_AST);
		match(TERM_LITERAL);
		LT(1);
		match(LPAREN);
		commaSeparatedStructs();
		astFactory.addASTChild(currentAST, returnAST);
		LT(1);
		match(RPAREN);
		currentAST.root.setType(STRUCT);
		netstruct_AST = (AST)currentAST.root;
		returnAST = netstruct_AST;
	}
	
	public final void startOneOnly() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST startOneOnly_AST = null;
		
		{
		switch ( LA(1)) {
		case TERM_LITERAL:
		case ICLDATAQ_LITERAL:
		case LBRACE:
		case LPAREN:
		case LBRACK:
		case VARIABLE:
		case TURNSTILE:
		case SEMI:
		case BACKSLASH:
		case EQUAL:
		case COLON:
		case DBL_COLON:
		case PLUS:
		case MINUS:
		case STAR:
		case DIV:
		case NUM_INT:
		case NUM_FLOAT:
		case BANG:
		case STRING_LITERAL:
		case SPECIAL_CHAR_LITERAL:
		case IDENT:
		{
			struct();
			astFactory.addASTChild(currentAST, returnAST);
			{
			switch ( LA(1)) {
			case DOT:
			{
				LT(1);
				match(DOT);
				break;
			}
			case EOF:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			break;
		}
		case EOF:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		LT(1);
		match(Token.EOF_TYPE);
		startOneOnly_AST = (AST)currentAST.root;
		returnAST = startOneOnly_AST;
	}
	
	public final void struct() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST struct_AST = null;
		
		semiExpression();
		astFactory.addASTChild(currentAST, returnAST);
		{
		_loop27:
		do {
			if ((LA(1)==TURNSTILE)) {
				{
				IclASTStruct tmp7_AST = null;
				tmp7_AST = new IclASTStruct(LT(1));
				astFactory.makeASTRoot(currentAST, tmp7_AST);
				match(TURNSTILE);
				}
				semiExpression();
				astFactory.addASTChild(currentAST, returnAST);
			}
			else {
				break _loop27;
			}
			
		} while (true);
		}
		struct_AST = (AST)currentAST.root;
		returnAST = struct_AST;
	}
	
	public final void startMultiNonNet() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST startMultiNonNet_AST = null;
		
		struct();
		astFactory.addASTChild(currentAST, returnAST);
		{
		switch ( LA(1)) {
		case DOT:
		{
			LT(1);
			match(DOT);
			break;
		}
		case EOF:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		startMultiNonNet_AST = (AST)currentAST.root;
		returnAST = startMultiNonNet_AST;
	}
	
	public final void icldataqTest() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST icldataqTest_AST = null;
		
		{
		switch ( LA(1)) {
		case ICLDATAQ_LITERAL:
		{
			icldataqStruct();
			astFactory.addASTChild(currentAST, returnAST);
			break;
		}
		case EOF:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		LT(1);
		match(Token.EOF_TYPE);
		icldataqTest_AST = (AST)currentAST.root;
		returnAST = icldataqTest_AST;
	}
	
	public final void icldataqStruct() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST icldataqStruct_AST = null;
		
		LT(1);
		match(ICLDATAQ_LITERAL);
		LT(1);
		match(LPAREN);
		{
		switch ( LA(1)) {
		case DBLQUOTED:
		{
			icldataqShortStruct();
			astFactory.addASTChild(currentAST, returnAST);
			break;
		}
		case NUM_INT:
		{
			icldataqLongStruct();
			astFactory.addASTChild(currentAST, returnAST);
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		LT(1);
		match(RPAREN);
		icldataqStruct_AST = (AST)currentAST.root;
		returnAST = icldataqStruct_AST;
	}
	
	public final void commaSeparatedStructs() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST commaSeparatedStructs_AST = null;
		
		struct();
		astFactory.addASTChild(currentAST, returnAST);
		{
		_loop12:
		do {
			if ((LA(1)==COMMA)) {
				LT(1);
				match(COMMA);
				struct();
				astFactory.addASTChild(currentAST, returnAST);
			}
			else {
				break _loop12;
			}
			
		} while (true);
		}
		commaSeparatedStructs_AST = (AST)currentAST.root;
		returnAST = commaSeparatedStructs_AST;
	}
	
	public final void listOnlyExpressionList() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST listOnlyExpressionList_AST = null;
		
		{
		switch ( LA(1)) {
		case TERM_LITERAL:
		case ICLDATAQ_LITERAL:
		case LBRACE:
		case LPAREN:
		case LBRACK:
		case VARIABLE:
		case TURNSTILE:
		case SEMI:
		case BACKSLASH:
		case EQUAL:
		case COLON:
		case DBL_COLON:
		case PLUS:
		case MINUS:
		case STAR:
		case DIV:
		case NUM_INT:
		case NUM_FLOAT:
		case BANG:
		case STRING_LITERAL:
		case SPECIAL_CHAR_LITERAL:
		case IDENT:
		{
			struct();
			astFactory.addASTChild(currentAST, returnAST);
			{
			_loop16:
			do {
				if ((LA(1)==COMMA)) {
					LT(1);
					match(COMMA);
					struct();
					astFactory.addASTChild(currentAST, returnAST);
				}
				else {
					break _loop16;
				}
				
			} while (true);
			}
			{
			switch ( LA(1)) {
			case PIPE:
			{
				LT(1);
				match(PIPE);
				{
				switch ( LA(1)) {
				case VARIABLE:
				{
					var();
					astFactory.addASTChild(currentAST, returnAST);
					((IclASTList)this.listStack.peek()).setHeadTailList(true);
					break;
				}
				case LBRACK:
				{
					recursiveList();
					AST child = returnAST; AST nextChild = null; while(child != null){nextChild = child.getNextSibling();astFactory.addASTChild(currentAST, child); child = nextChild;}
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				break;
			}
			case RBRACK:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			break;
		}
		case RBRACK:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		listOnlyExpressionList_AST = (AST)currentAST.root;
		returnAST = listOnlyExpressionList_AST;
	}
	
	public final void var() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST var_AST = null;
		
		IclASTVar tmp16_AST = null;
		tmp16_AST = new IclASTVar(LT(1));
		astFactory.addASTChild(currentAST, tmp16_AST);
		match(VARIABLE);
		currentAST.root.setType(VAR);
		var_AST = (AST)currentAST.root;
		returnAST = var_AST;
	}
	
	public final void recursiveList() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST recursiveList_AST = null;
		
		LT(1);
		match(LBRACK);
		listOnlyExpressionList();
		astFactory.addASTChild(currentAST, returnAST);
		LT(1);
		match(RBRACK);
		recursiveList_AST = (AST)currentAST.root;
		returnAST = recursiveList_AST;
	}
	
	public final void group() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST group_AST = null;
		
		switch ( LA(1)) {
		case LBRACE:
		{
			IclASTGroup tmp19_AST = null;
			tmp19_AST = new IclASTGroup(LT(1));
			astFactory.makeASTRoot(currentAST, tmp19_AST);
			match(LBRACE);
			commaSeparatedStructs();
			astFactory.addASTChild(currentAST, returnAST);
			LT(1);
			match(RBRACE);
			currentAST.root.setType(GROUP);
			group_AST = (AST)currentAST.root;
			break;
		}
		case LPAREN:
		{
			IclASTGroup tmp21_AST = null;
			tmp21_AST = new IclASTGroup(LT(1));
			astFactory.makeASTRoot(currentAST, tmp21_AST);
			match(LPAREN);
			commaSeparatedStructs();
			astFactory.addASTChild(currentAST, returnAST);
			LT(1);
			match(RPAREN);
			currentAST.root.setType(GROUP);
			group_AST = (AST)currentAST.root;
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		returnAST = group_AST;
	}
	
	public final void list() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST list_AST = null;
		
		IclASTList tmp23_AST = null;
		tmp23_AST = new IclASTList(LT(1));
		astFactory.makeASTRoot(currentAST, tmp23_AST);
		match(LBRACK);
		this.listStack.push(currentAST.root);
		listOnlyExpressionList();
		astFactory.addASTChild(currentAST, returnAST);
		LT(1);
		match(RBRACK);
		this.listStack.pop();currentAST.root.setType(LIST);
		list_AST = (AST)currentAST.root;
		returnAST = list_AST;
	}
	
	public final void semiExpression() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST semiExpression_AST = null;
		
		backslashExpression();
		astFactory.addASTChild(currentAST, returnAST);
		{
		_loop31:
		do {
			if ((LA(1)==SEMI)) {
				{
				IclASTStruct tmp25_AST = null;
				tmp25_AST = new IclASTStruct(LT(1));
				astFactory.makeASTRoot(currentAST, tmp25_AST);
				match(SEMI);
				}
				backslashExpression();
				astFactory.addASTChild(currentAST, returnAST);
			}
			else {
				break _loop31;
			}
			
		} while (true);
		}
		semiExpression_AST = (AST)currentAST.root;
		returnAST = semiExpression_AST;
	}
	
	public final void backslashExpression() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST backslashExpression_AST = null;
		
		equalsExpression();
		astFactory.addASTChild(currentAST, returnAST);
		{
		_loop35:
		do {
			if ((LA(1)==BACKSLASH)) {
				{
				IclASTStruct tmp26_AST = null;
				tmp26_AST = new IclASTStruct(LT(1));
				astFactory.makeASTRoot(currentAST, tmp26_AST);
				match(BACKSLASH);
				}
				equalsExpression();
				astFactory.addASTChild(currentAST, returnAST);
			}
			else {
				break _loop35;
			}
			
		} while (true);
		}
		backslashExpression_AST = (AST)currentAST.root;
		returnAST = backslashExpression_AST;
	}
	
	public final void equalsExpression() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST equalsExpression_AST = null;
		
		colonExpression();
		astFactory.addASTChild(currentAST, returnAST);
		{
		_loop39:
		do {
			if ((LA(1)==EQUAL)) {
				{
				IclASTStruct tmp27_AST = null;
				tmp27_AST = new IclASTStruct(LT(1));
				astFactory.makeASTRoot(currentAST, tmp27_AST);
				match(EQUAL);
				}
				colonExpression();
				astFactory.addASTChild(currentAST, returnAST);
			}
			else {
				break _loop39;
			}
			
		} while (true);
		}
		equalsExpression_AST = (AST)currentAST.root;
		returnAST = equalsExpression_AST;
	}
	
	public final void colonExpression() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST colonExpression_AST = null;
		
		plusMinusExpression();
		astFactory.addASTChild(currentAST, returnAST);
		{
		_loop43:
		do {
			if ((LA(1)==COLON||LA(1)==DBL_COLON)) {
				{
				switch ( LA(1)) {
				case COLON:
				{
					IclASTStruct tmp28_AST = null;
					tmp28_AST = new IclASTStruct(LT(1));
					astFactory.makeASTRoot(currentAST, tmp28_AST);
					match(COLON);
					break;
				}
				case DBL_COLON:
				{
					IclASTStruct tmp29_AST = null;
					tmp29_AST = new IclASTStruct(LT(1));
					astFactory.makeASTRoot(currentAST, tmp29_AST);
					match(DBL_COLON);
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				plusMinusExpression();