org.coode.parsers.ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase Maven / Gradle / Ivy
// $ANTLR 3.2 Sep 23, 2009 12:02:23 ManchesterOWLSyntaxAutoCompleteBase.g 2011-01-10 16:18:12
package org.coode.parsers;
import java.util.ArrayList;
import java.util.List;
import org.antlr.runtime.BaseRecognizer;
import org.antlr.runtime.BitSet;
import org.antlr.runtime.DFA;
import org.antlr.runtime.EarlyExitException;
import org.antlr.runtime.IntStream;
import org.antlr.runtime.NoViableAltException;
import org.antlr.runtime.Parser;
import org.antlr.runtime.ParserRuleReturnScope;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.RecognizerSharedState;
import org.antlr.runtime.RuleReturnScope;
import org.antlr.runtime.Token;
import org.antlr.runtime.TokenStream;
import org.antlr.runtime.tree.CommonTreeAdaptor;
import org.antlr.runtime.tree.RewriteEarlyExitException;
import org.antlr.runtime.tree.RewriteRuleSubtreeStream;
import org.antlr.runtime.tree.RewriteRuleTokenStream;
import org.antlr.runtime.tree.TreeAdaptor;
import org.coode.oppl.log.Logger;
import org.coode.oppl.log.Logging;
@SuppressWarnings({ "javadoc", "incomplete-switch", "synthetic-access" })
public class ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase
extends Parser {
public static final int COMMA = 37;
public static final int GREATER_THAN = 667;
public static final int DIFFERENT_FROM = 24;
public static final int LESS_THAN = 665;
public static final int TYPE_ASSERTION = 66;
public static final int INCOMPLETE_CONJUNCTION = 615;
public static final int SAME_AS_AXIOM = 52;
public static final int INCOMPLETE_SUB_CLASS_AXIOM = 604;
public static final int TYPES = 39;
public static final int ROLE_ASSERTION = 67;
public static final int ALL_RESTRICTION = 62;
public static final int QUESTION_MARK = 46;
public static final int AND = 10;
public static final int EXPRESSION = 69;
public static final int CONSTANT = 70;
public static final int VALUE_RESTRICTION = 63;
public static final int ONE_OF = 65;
public static final int CARDINALITY_RESTRICTION = 64;
public static final int SAME_AS = 23;
public static final int EXACTLY = 17;
public static final int TRANSITIVE = 34;
public static final int SUBCLASS_OF = 20;
public static final int ENTITY_REFERENCE = 45;
public static final int CONJUNCTION = 56;
public static final int INVERSE_OF = 25;
public static final int AT = 629;
public static final int RANGE = 28;
public static final int DATA_RANGE = 692;
public static final int CLOSED_PARENTHESYS = 8;
public static final int PROPERTY_CHAIN = 57;
public static final int OPEN_SQUARE_BRACKET = 662;
public static final int EQUIVALENT_TO_AXIOM = 49;
public static final int INCOMPLETE_ALL_RESTRICTION = 619;
public static final int SYMMETRIC = 30;
public static final int DISJOINT_WITH = 26;
public static final int INCOMPLETE_VALUE_RESTRICTION = 622;
public static final int DISJUNCTION = 55;
public static final int INCOMPLETE_CARDINALITY_RESTRICTION = 620;
public static final int NEGATED_EXPRESSION = 58;
public static final int EQUAL = 664;
public static final int DIFFERENT_FROM_AXIOM = 53;
public static final int GREATER_THAN_EQUAL = 668;
public static final int EQUIVALENT_TO = 22;
public static final int DOMAIN = 27;
public static final int SUB_PROPERTY_OF = 21;
public static final int INVERSE_OBJECT_PROPERTY_EXPRESSION = 68;
public static final int INVERSE_PROPERTY = 60;
public static final int SUB_CLASS_AXIOM = 48;
public static final int SUB_PROPERTY_AXIOM = 51;
public static final int INCOMPLETE_DIFFERENT_FROM_AXIOM = 609;
public static final int INCOMPLETE_INVERSE_OBJECT_PROPERTY_EXPRESSION = 616;
public static final int IDENTIFIER = 44;
public static final int UNARY_AXIOM = 54;
public static final int INCOMPLETE_PROPERTY_CHAIN = 613;
public static final int OPEN_CURLY_BRACES = 6;
public static final int STANDALONE_EXPRESSION = 600;
public static final int CLOSED_SQUARE_BRACKET = 663;
public static final int INSTANCE_OF = 38;
public static final int INCOMPLETE_DISJUNCTION = 614;
public static final int SOME_RESTRICTION = 61;
public static final int INCOMPLETE_SUB_PROPERTY_AXIOM = 607;
public static final int INCOMPLETE_INVERSE_OF = 612;
public static final int IRI = 110;
public static final int INCOMPLETE_DOMAIN = 610;
public static final int LESS_THAN_EQUAL = 666;
public static final int VALUE = 18;
public static final int INCOMPLETE_UNARY_AXIOM = 603;
public static final int INVERSE_FUNCTIONAL = 35;
public static final int OR = 11;
public static final int INCOMPLETE_EXPRESSION = 623;
public static final int INTEGER = 42;
public static final int INVERSE = 19;
public static final int HAS_KEY = 109;
public static final int DISJOINT_WITH_AXIOM = 50;
public static final int INCOMPLETE_DISJOINT_WITH_AXIOM = 606;
public static final int DIGIT = 41;
public static final int COMPOSITION = 4;
public static final int ANNOTATION_ASSERTION = 111;
public static final int INCOMPLETE_RANGE = 611;
public static final int FUNCTIONAL = 29;
public static final int LETTER = 43;
public static final int MAX = 16;
public static final int INCOMPLETE_ROLE_ASSERTION = 602;
public static final int NEGATED_ASSERTION = 59;
public static final int ONLY = 14;
public static final int DBLQUOTE = 40;
public static final int MIN = 15;
public static final int POW = 36;
public static final int INCOMPLETE_TYPE_ASSERTION = 601;
public static final int INCOMPLETE_ONE_OF = 621;
public static final int INCOMPLETE_NEGATED_EXPRESSION = 617;
public static final int WHITESPACE = 9;
public static final int SOME = 13;
public static final int INCOMPLETE_SAME_AS_AXIOM = 608;
public static final int INCOMPLETE_EQUIVALENT_TO_AXIOM = 605;
public static final int EOF = -1;
public static final int ANTI_SYMMETRIC = 31;
public static final int Tokens = 47;
public static final int CLOSED_CURLY_BRACES = 7;
public static final int INCOMPLETE_SOME_RESTRICTION = 618;
public static final int REFLEXIVE = 32;
public static final int NOT = 12;
public static final int OPEN_PARENTHESYS = 5;
public static final int IRREFLEXIVE = 33;
// delegates
public ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase_MOWLParser gMOWLParser;
// delegators
public ManchesterOWLSyntaxAutoCompleteCombinedParser gManchesterOWLSyntaxAutoCompleteCombined;
public ManchesterOWLSyntaxAutoCompleteCombinedParser gParent;
public ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase(
TokenStream input,
ManchesterOWLSyntaxAutoCompleteCombinedParser gManchesterOWLSyntaxAutoCompleteCombined) {
this(input, new RecognizerSharedState(), gManchesterOWLSyntaxAutoCompleteCombined);
}
public ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase(
TokenStream input,
RecognizerSharedState state,
ManchesterOWLSyntaxAutoCompleteCombinedParser gManchesterOWLSyntaxAutoCompleteCombined) {
super(input, state);
this.gManchesterOWLSyntaxAutoCompleteCombined = gManchesterOWLSyntaxAutoCompleteCombined;
gMOWLParser = new ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase_MOWLParser(
input, state, gManchesterOWLSyntaxAutoCompleteCombined, this);
gParent = gManchesterOWLSyntaxAutoCompleteCombined;
}
protected TreeAdaptor adaptor = new CommonTreeAdaptor();
public void setTreeAdaptor(TreeAdaptor adaptor) {
this.adaptor = adaptor;
gMOWLParser.setTreeAdaptor(this.adaptor);
}
public TreeAdaptor getTreeAdaptor() {
return adaptor;
}
@Override
public String[] getTokenNames() {
return ManchesterOWLSyntaxAutoCompleteCombinedParser.tokenNames;
}
@Override
public String getGrammarFileName() {
return "ManchesterOWLSyntaxAutoCompleteBase.g";
}
public static class standaloneExpression_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "standaloneExpression"
// ManchesterOWLSyntaxAutoCompleteBase.g:43:1: standaloneExpression : exp=
// expression -> ^( STANDALONE_EXPRESSION ^( EXPRESSION $exp) ) ;
public final
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.standaloneExpression_return
standaloneExpression() {
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.standaloneExpression_return retval = new ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.standaloneExpression_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase_MOWLParser.expression_return exp = null;
RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(
adaptor, "rule expression");
try {
// ManchesterOWLSyntaxAutoCompleteBase.g:44:2: (exp= expression ->
// ^( STANDALONE_EXPRESSION ^( EXPRESSION $exp) ) )
// ManchesterOWLSyntaxAutoCompleteBase.g:45:5: exp= expression
{
pushFollow(FOLLOW_expression_in_standaloneExpression190);
exp = gManchesterOWLSyntaxAutoCompleteCombined.expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(exp.getTree());
}
// AST REWRITE
// elements: exp
// token labels:
// rule labels: exp, retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_exp = new RewriteRuleSubtreeStream(
adaptor, "rule exp", exp != null ? exp.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 45:22: -> ^( STANDALONE_EXPRESSION ^( EXPRESSION $exp) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:45:25: ^(
// STANDALONE_EXPRESSION ^( EXPRESSION $exp) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(adaptor
.create(STANDALONE_EXPRESSION,
"STANDALONE_EXPRESSION"), root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:45:50: ^(
// EXPRESSION $exp)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(EXPRESSION, "EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_exp.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
retval.stop = input.LT(-1);
if (state.backtracking == 0) {
retval.tree = (ManchesterOWLSyntaxTree) adaptor
.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
} catch (RecognitionException re) {
reportError(re);
recover(input, re);
retval.tree = (ManchesterOWLSyntaxTree) adaptor.errorNode(input,
retval.start, input.LT(-1), re);
} finally {}
return retval;
}
// $ANTLR end "standaloneExpression"
public static class incompleteAxiom_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "incompleteAxiom"
// ManchesterOWLSyntaxAutoCompleteBase.g:49:1: incompleteAxiom : (
// incompleteBinaryAxiom -> ^( incompleteBinaryAxiom ) |
// incompleteUnaryAxiom -> ^( incompleteUnaryAxiom ) |
// incompleteAssertionAxiom -> ^( incompleteAssertionAxiom ) );
public final
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteAxiom_return
incompleteAxiom() {
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteAxiom_return retval = new ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteAxiom_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteBinaryAxiom_return incompleteBinaryAxiom1 = null;
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteUnaryAxiom_return incompleteUnaryAxiom2 = null;
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteAssertionAxiom_return incompleteAssertionAxiom3 = null;
RewriteRuleSubtreeStream stream_incompleteAssertionAxiom = new RewriteRuleSubtreeStream(
adaptor, "rule incompleteAssertionAxiom");
RewriteRuleSubtreeStream stream_incompleteUnaryAxiom = new RewriteRuleSubtreeStream(
adaptor, "rule incompleteUnaryAxiom");
RewriteRuleSubtreeStream stream_incompleteBinaryAxiom = new RewriteRuleSubtreeStream(
adaptor, "rule incompleteBinaryAxiom");
try {
// ManchesterOWLSyntaxAutoCompleteBase.g:49:17: (
// incompleteBinaryAxiom -> ^( incompleteBinaryAxiom ) |
// incompleteUnaryAxiom -> ^( incompleteUnaryAxiom ) |
// incompleteAssertionAxiom -> ^( incompleteAssertionAxiom ) )
int alt1 = 3;
switch (input.LA(1)) {
case IDENTIFIER: {
int LA1_1 = input.LA(2);
if (LA1_1 == COMPOSITION || LA1_1 >= AND && LA1_1 <= OR
|| LA1_1 >= SOME && LA1_1 <= VALUE || LA1_1 >= SUBCLASS_OF
&& LA1_1 <= RANGE || LA1_1 == OPEN_SQUARE_BRACKET) {
alt1 = 1;
} else if (LA1_1 >= INSTANCE_OF && LA1_1 <= TYPES) {
alt1 = 3;
} else {
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 1, 1,
input);
throw nvae;
}
}
break;
case OPEN_PARENTHESYS:
case OPEN_CURLY_BRACES:
case NOT:
case INVERSE:
case DBLQUOTE:
case ENTITY_REFERENCE: {
alt1 = 1;
}
break;
case FUNCTIONAL:
case SYMMETRIC:
case ANTI_SYMMETRIC:
case REFLEXIVE:
case IRREFLEXIVE:
case TRANSITIVE:
case INVERSE_FUNCTIONAL: {
alt1 = 2;
}
break;
default:
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 1, 0, input);
throw nvae;
}
switch (alt1) {
case 1:
// ManchesterOWLSyntaxAutoCompleteBase.g:50:5:
// incompleteBinaryAxiom
{
pushFollow(FOLLOW_incompleteBinaryAxiom_in_incompleteAxiom219);
incompleteBinaryAxiom1 = incompleteBinaryAxiom();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_incompleteBinaryAxiom
.add(incompleteBinaryAxiom1.getTree());
}
// AST REWRITE
// elements: incompleteBinaryAxiom
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 50:27: -> ^( incompleteBinaryAxiom )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:50:30: ^(
// incompleteBinaryAxiom )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_incompleteBinaryAxiom.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 2:
// ManchesterOWLSyntaxAutoCompleteBase.g:51:7:
// incompleteUnaryAxiom
{
pushFollow(FOLLOW_incompleteUnaryAxiom_in_incompleteAxiom233);
incompleteUnaryAxiom2 = incompleteUnaryAxiom();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_incompleteUnaryAxiom.add(incompleteUnaryAxiom2.getTree());
}
// AST REWRITE
// elements: incompleteUnaryAxiom
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 51:30: -> ^( incompleteUnaryAxiom )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:51:33: ^(
// incompleteUnaryAxiom )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_incompleteUnaryAxiom.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 3:
// ManchesterOWLSyntaxAutoCompleteBase.g:52:7:
// incompleteAssertionAxiom
{
pushFollow(FOLLOW_incompleteAssertionAxiom_in_incompleteAxiom249);
incompleteAssertionAxiom3 = incompleteAssertionAxiom();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_incompleteAssertionAxiom.add(incompleteAssertionAxiom3
.getTree());
}
// AST REWRITE
// elements: incompleteAssertionAxiom
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 52:32: -> ^( incompleteAssertionAxiom )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:52:35: ^(
// incompleteAssertionAxiom )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_incompleteAssertionAxiom.nextNode(),
root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
}
retval.stop = input.LT(-1);
if (state.backtracking == 0) {
retval.tree = (ManchesterOWLSyntaxTree) adaptor
.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
} catch (RecognitionException re) {
reportError(re);
recover(input, re);
retval.tree = (ManchesterOWLSyntaxTree) adaptor.errorNode(input,
retval.start, input.LT(-1), re);
} finally {}
return retval;
}
// $ANTLR end "incompleteAxiom"
public static class incompleteAssertionAxiom_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "incompleteAssertionAxiom"
// ManchesterOWLSyntaxAutoCompleteBase.g:55:1: incompleteAssertionAxiom : i=
// IDENTIFIER ( INSTANCE_OF | TYPES ) -> ^( INCOMPLETE_TYPE_ASSERTION ^(
// EXPRESSION $i) ) ;
public final
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteAssertionAxiom_return
incompleteAssertionAxiom() {
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteAssertionAxiom_return retval = new ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteAssertionAxiom_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token i = null;
Token INSTANCE_OF4 = null;
Token TYPES5 = null;
RewriteRuleTokenStream stream_TYPES = new RewriteRuleTokenStream(adaptor,
"token TYPES");
RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(adaptor,
"token IDENTIFIER");
RewriteRuleTokenStream stream_INSTANCE_OF = new RewriteRuleTokenStream(adaptor,
"token INSTANCE_OF");
try {
// ManchesterOWLSyntaxAutoCompleteBase.g:55:27: (i= IDENTIFIER (
// INSTANCE_OF | TYPES ) -> ^( INCOMPLETE_TYPE_ASSERTION ^(
// EXPRESSION $i) ) )
// ManchesterOWLSyntaxAutoCompleteBase.g:56:3: i= IDENTIFIER (
// INSTANCE_OF | TYPES )
{
i = (Token) match(input, IDENTIFIER,
FOLLOW_IDENTIFIER_in_incompleteAssertionAxiom273);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_IDENTIFIER.add(i);
}
// ManchesterOWLSyntaxAutoCompleteBase.g:56:18: ( INSTANCE_OF |
// TYPES )
int alt2 = 2;
int LA2_0 = input.LA(1);
if (LA2_0 == INSTANCE_OF) {
alt2 = 1;
} else if (LA2_0 == TYPES) {
alt2 = 2;
} else {
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 2, 0, input);
throw nvae;
}
switch (alt2) {
case 1:
// ManchesterOWLSyntaxAutoCompleteBase.g:56:19: INSTANCE_OF
{
INSTANCE_OF4 = (Token) match(input, INSTANCE_OF,
FOLLOW_INSTANCE_OF_in_incompleteAssertionAxiom276);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_INSTANCE_OF.add(INSTANCE_OF4);
}
}
break;
case 2:
// ManchesterOWLSyntaxAutoCompleteBase.g:56:33: TYPES
{
TYPES5 = (Token) match(input, TYPES,
FOLLOW_TYPES_in_incompleteAssertionAxiom280);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_TYPES.add(TYPES5);
}
}
break;
}
// AST REWRITE
// elements: i
// token labels: i
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleTokenStream stream_i = new RewriteRuleTokenStream(adaptor,
"token i", i);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 56:41: -> ^( INCOMPLETE_TYPE_ASSERTION ^( EXPRESSION $i)
// )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:56:44: ^(
// INCOMPLETE_TYPE_ASSERTION ^( EXPRESSION $i) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(adaptor
.create(INCOMPLETE_TYPE_ASSERTION,
"INCOMPLETE_TYPE_ASSERTION"), root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:56:73: ^(
// EXPRESSION $i)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(EXPRESSION, "EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_i.nextNode());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
retval.stop = input.LT(-1);
if (state.backtracking == 0) {
retval.tree = (ManchesterOWLSyntaxTree) adaptor
.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
} catch (RecognitionException re) {
reportError(re);
recover(input, re);
retval.tree = (ManchesterOWLSyntaxTree) adaptor.errorNode(input,
retval.start, input.LT(-1), re);
} finally {}
return retval;
}
// $ANTLR end "incompleteAssertionAxiom"
public static class incompleteUnaryAxiom_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "incompleteUnaryAxiom"
// ManchesterOWLSyntaxAutoCompleteBase.g:60:1: incompleteUnaryAxiom :
// unaryCharacteristic -> ^( INCOMPLETE_UNARY_AXIOM unaryCharacteristic ) ;
public final
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteUnaryAxiom_return
incompleteUnaryAxiom() {
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteUnaryAxiom_return retval = new ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteUnaryAxiom_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase_MOWLParser.unaryCharacteristic_return unaryCharacteristic6 = null;
RewriteRuleSubtreeStream stream_unaryCharacteristic = new RewriteRuleSubtreeStream(
adaptor, "rule unaryCharacteristic");
try {
// ManchesterOWLSyntaxAutoCompleteBase.g:60:23: (
// unaryCharacteristic -> ^( INCOMPLETE_UNARY_AXIOM
// unaryCharacteristic ) )
// ManchesterOWLSyntaxAutoCompleteBase.g:61:4: unaryCharacteristic
{
pushFollow(FOLLOW_unaryCharacteristic_in_incompleteUnaryAxiom318);
unaryCharacteristic6 = gManchesterOWLSyntaxAutoCompleteCombined
.unaryCharacteristic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_unaryCharacteristic.add(unaryCharacteristic6.getTree());
}
// AST REWRITE
// elements: unaryCharacteristic
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 61:25: -> ^( INCOMPLETE_UNARY_AXIOM unaryCharacteristic )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:61:28: ^(
// INCOMPLETE_UNARY_AXIOM unaryCharacteristic )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(adaptor
.create(INCOMPLETE_UNARY_AXIOM,
"INCOMPLETE_UNARY_AXIOM"), root_1);
adaptor.addChild(root_1,
stream_unaryCharacteristic.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
retval.stop = input.LT(-1);
if (state.backtracking == 0) {
retval.tree = (ManchesterOWLSyntaxTree) adaptor
.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
} catch (RecognitionException re) {
reportError(re);
recover(input, re);
retval.tree = (ManchesterOWLSyntaxTree) adaptor.errorNode(input,
retval.start, input.LT(-1), re);
} finally {}
return retval;
}
// $ANTLR end "incompleteUnaryAxiom"
public static class incompleteBinaryAxiom_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "incompleteBinaryAxiom"
// ManchesterOWLSyntaxAutoCompleteBase.g:65:1: incompleteBinaryAxiom : (lhs=
// expression ( SUBCLASS_OF -> ^( INCOMPLETE_SUB_CLASS_AXIOM ^( EXPRESSION
// $lhs) ) | SUBCLASS_OF superClass= incompleteExpression -> ^(
// INCOMPLETE_SUB_CLASS_AXIOM ^( EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION
// $superClass) ) | EQUIVALENT_TO -> ^( INCOMPLETE_EQUIVALENT_TO_AXIOM ^(
// EXPRESSION $lhs) ) | EQUIVALENT_TO rhs= incompleteExpression -> ^(
// EQUIVALENT_TO_AXIOM ^( EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION $rhs) )
// | DISJOINT_WITH -> ^( INCOMPLETE_DISJOINT_WITH_AXIOM ^( EXPRESSION $lhs)
// ) | DISJOINT_WITH disjoint= incompleteExpression -> ^(
// DISJOINT_WITH_AXIOM ^( EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION
// $disjoint) ) | SUB_PROPERTY_OF -> ^( INCOMPLETE_SUB_PROPERTY_AXIOM ^(
// EXPRESSION $lhs) ) ) | lhsID= IDENTIFIER ( SAME_AS -> ^(
// INCOMPLETE_SAME_AS_AXIOM ^( EXPRESSION $lhsID) ) | DIFFERENT_FROM -> ^(
// INCOMPLETE_DIFFERENT_FROM_AXIOM ^( EXPRESSION $lhsID) ) | DOMAIN -> ^(
// INCOMPLETE_DOMAIN ^( EXPRESSION $lhsID) ) | DOMAIN incompleteDomain=
// incompleteExpression -> ^( INCOMPLETE_DOMAIN ^( EXPRESSION $lhsID) ^(
// INCOMPLETE_EXPRESSION $incompleteDomain) ) | RANGE -> ^( INCOMPLETE_RANGE
// ^( EXPRESSION $lhsID) ) | RANGE incompleteRange= incompleteExpression ->
// ^( INCOMPLETE_RANGE ^( EXPRESSION $lhsID) ^( INCOMPLETE_EXPRESSION
// $incompleteRange) ) | INVERSE_OF -> ^( INCOMPLETE_INVERSE_OF ^(
// EXPRESSION $lhsID) ) ) );
public final
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteBinaryAxiom_return
incompleteBinaryAxiom() {
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteBinaryAxiom_return retval = new ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteBinaryAxiom_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token lhsID = null;
Token SUBCLASS_OF7 = null;
Token SUBCLASS_OF8 = null;
Token EQUIVALENT_TO9 = null;
Token EQUIVALENT_TO10 = null;
Token DISJOINT_WITH11 = null;
Token DISJOINT_WITH12 = null;
Token SUB_PROPERTY_OF13 = null;
Token SAME_AS14 = null;
Token DIFFERENT_FROM15 = null;
Token DOMAIN16 = null;
Token DOMAIN17 = null;
Token RANGE18 = null;
Token RANGE19 = null;
Token INVERSE_OF20 = null;
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase_MOWLParser.expression_return lhs = null;
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteExpression_return superClass = null;
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteExpression_return rhs = null;
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteExpression_return disjoint = null;
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteExpression_return incompleteDomain = null;
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteExpression_return incompleteRange = null;
RewriteRuleTokenStream stream_RANGE = new RewriteRuleTokenStream(adaptor,
"token RANGE");
RewriteRuleTokenStream stream_DISJOINT_WITH = new RewriteRuleTokenStream(adaptor,
"token DISJOINT_WITH");
RewriteRuleTokenStream stream_SAME_AS = new RewriteRuleTokenStream(adaptor,
"token SAME_AS");
RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(adaptor,
"token IDENTIFIER");
RewriteRuleTokenStream stream_SUBCLASS_OF = new RewriteRuleTokenStream(adaptor,
"token SUBCLASS_OF");
RewriteRuleTokenStream stream_DIFFERENT_FROM = new RewriteRuleTokenStream(
adaptor, "token DIFFERENT_FROM");
RewriteRuleTokenStream stream_INVERSE_OF = new RewriteRuleTokenStream(adaptor,
"token INVERSE_OF");
RewriteRuleTokenStream stream_EQUIVALENT_TO = new RewriteRuleTokenStream(adaptor,
"token EQUIVALENT_TO");
RewriteRuleTokenStream stream_DOMAIN = new RewriteRuleTokenStream(adaptor,
"token DOMAIN");
RewriteRuleTokenStream stream_SUB_PROPERTY_OF = new RewriteRuleTokenStream(
adaptor, "token SUB_PROPERTY_OF");
RewriteRuleSubtreeStream stream_incompleteExpression = new RewriteRuleSubtreeStream(
adaptor, "rule incompleteExpression");
RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(
adaptor, "rule expression");
try {
// ManchesterOWLSyntaxAutoCompleteBase.g:65:23: (lhs= expression (
// SUBCLASS_OF -> ^( INCOMPLETE_SUB_CLASS_AXIOM ^( EXPRESSION $lhs)
// ) | SUBCLASS_OF superClass= incompleteExpression -> ^(
// INCOMPLETE_SUB_CLASS_AXIOM ^( EXPRESSION $lhs) ^(
// INCOMPLETE_EXPRESSION $superClass) ) | EQUIVALENT_TO -> ^(
// INCOMPLETE_EQUIVALENT_TO_AXIOM ^( EXPRESSION $lhs) ) |
// EQUIVALENT_TO rhs= incompleteExpression -> ^( EQUIVALENT_TO_AXIOM
// ^( EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION $rhs) ) |
// DISJOINT_WITH -> ^( INCOMPLETE_DISJOINT_WITH_AXIOM ^( EXPRESSION
// $lhs) ) | DISJOINT_WITH disjoint= incompleteExpression -> ^(
// DISJOINT_WITH_AXIOM ^( EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION
// $disjoint) ) | SUB_PROPERTY_OF -> ^(
// INCOMPLETE_SUB_PROPERTY_AXIOM ^( EXPRESSION $lhs) ) ) | lhsID=
// IDENTIFIER ( SAME_AS -> ^( INCOMPLETE_SAME_AS_AXIOM ^( EXPRESSION
// $lhsID) ) | DIFFERENT_FROM -> ^( INCOMPLETE_DIFFERENT_FROM_AXIOM
// ^( EXPRESSION $lhsID) ) | DOMAIN -> ^( INCOMPLETE_DOMAIN ^(
// EXPRESSION $lhsID) ) | DOMAIN incompleteDomain=
// incompleteExpression -> ^( INCOMPLETE_DOMAIN ^( EXPRESSION
// $lhsID) ^( INCOMPLETE_EXPRESSION $incompleteDomain) ) | RANGE ->
// ^( INCOMPLETE_RANGE ^( EXPRESSION $lhsID) ) | RANGE
// incompleteRange= incompleteExpression -> ^( INCOMPLETE_RANGE ^(
// EXPRESSION $lhsID) ^( INCOMPLETE_EXPRESSION $incompleteRange) ) |
// INVERSE_OF -> ^( INCOMPLETE_INVERSE_OF ^( EXPRESSION $lhsID) ) )
// )
int alt5 = 2;
int LA5_0 = input.LA(1);
if (LA5_0 == IDENTIFIER) {
int LA5_1 = input.LA(2);
if (LA5_1 == COMPOSITION || LA5_1 >= AND && LA5_1 <= OR || LA5_1 >= SOME
&& LA5_1 <= VALUE || LA5_1 >= SUBCLASS_OF
&& LA5_1 <= EQUIVALENT_TO || LA5_1 == DISJOINT_WITH
|| LA5_1 == OPEN_SQUARE_BRACKET) {
alt5 = 1;
} else if (LA5_1 >= SAME_AS && LA5_1 <= INVERSE_OF || LA5_1 >= DOMAIN
&& LA5_1 <= RANGE) {
alt5 = 2;
} else {
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 5, 1, input);
throw nvae;
}
} else if (LA5_0 >= OPEN_PARENTHESYS && LA5_0 <= OPEN_CURLY_BRACES
|| LA5_0 == NOT || LA5_0 == INVERSE || LA5_0 == DBLQUOTE
|| LA5_0 == ENTITY_REFERENCE) {
alt5 = 1;
} else {
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 5, 0, input);
throw nvae;
}
switch (alt5) {
case 1:
// ManchesterOWLSyntaxAutoCompleteBase.g:66:5: lhs= expression (
// SUBCLASS_OF -> ^( INCOMPLETE_SUB_CLASS_AXIOM ^( EXPRESSION
// $lhs) ) | SUBCLASS_OF superClass= incompleteExpression -> ^(
// INCOMPLETE_SUB_CLASS_AXIOM ^( EXPRESSION $lhs) ^(
// INCOMPLETE_EXPRESSION $superClass) ) | EQUIVALENT_TO -> ^(
// INCOMPLETE_EQUIVALENT_TO_AXIOM ^( EXPRESSION $lhs) ) |
// EQUIVALENT_TO rhs= incompleteExpression -> ^(
// EQUIVALENT_TO_AXIOM ^( EXPRESSION $lhs) ^(
// INCOMPLETE_EXPRESSION $rhs) ) | DISJOINT_WITH -> ^(
// INCOMPLETE_DISJOINT_WITH_AXIOM ^( EXPRESSION $lhs) ) |
// DISJOINT_WITH disjoint= incompleteExpression -> ^(
// DISJOINT_WITH_AXIOM ^( EXPRESSION $lhs) ^(
// INCOMPLETE_EXPRESSION $disjoint) ) | SUB_PROPERTY_OF -> ^(
// INCOMPLETE_SUB_PROPERTY_AXIOM ^( EXPRESSION $lhs) ) )
{
pushFollow(FOLLOW_expression_in_incompleteBinaryAxiom366);
lhs = gManchesterOWLSyntaxAutoCompleteCombined.expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(lhs.getTree());
}
// ManchesterOWLSyntaxAutoCompleteBase.g:68:17: (
// SUBCLASS_OF -> ^( INCOMPLETE_SUB_CLASS_AXIOM ^(
// EXPRESSION $lhs) ) | SUBCLASS_OF superClass=
// incompleteExpression -> ^( INCOMPLETE_SUB_CLASS_AXIOM ^(
// EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION $superClass) )
// | EQUIVALENT_TO -> ^( INCOMPLETE_EQUIVALENT_TO_AXIOM ^(
// EXPRESSION $lhs) ) | EQUIVALENT_TO rhs=
// incompleteExpression -> ^( EQUIVALENT_TO_AXIOM ^(
// EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION $rhs) ) |
// DISJOINT_WITH -> ^( INCOMPLETE_DISJOINT_WITH_AXIOM ^(
// EXPRESSION $lhs) ) | DISJOINT_WITH disjoint=
// incompleteExpression -> ^( DISJOINT_WITH_AXIOM ^(
// EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION $disjoint) ) |
// SUB_PROPERTY_OF -> ^( INCOMPLETE_SUB_PROPERTY_AXIOM ^(
// EXPRESSION $lhs) ) )
int alt3 = 7;
alt3 = dfa3.predict(input);
switch (alt3) {
case 1:
// ManchesterOWLSyntaxAutoCompleteBase.g:69:17:
// SUBCLASS_OF
{
SUBCLASS_OF7 = (Token) match(input, SUBCLASS_OF,
FOLLOW_SUBCLASS_OF_in_incompleteBinaryAxiom421);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_SUBCLASS_OF.add(SUBCLASS_OF7);
}
// AST REWRITE
// elements: lhs
// token labels:
// rule labels: lhs, retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhs = new RewriteRuleSubtreeStream(
adaptor, "rule lhs", lhs != null ? lhs.tree
: null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 69:31: -> ^( INCOMPLETE_SUB_CLASS_AXIOM ^(
// EXPRESSION $lhs) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:69:34:
// ^( INCOMPLETE_SUB_CLASS_AXIOM ^(
// EXPRESSION $lhs) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_SUB_CLASS_AXIOM,
"INCOMPLETE_SUB_CLASS_AXIOM"),
root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:69:64:
// ^( EXPRESSION $lhs)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhs.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 2:
// ManchesterOWLSyntaxAutoCompleteBase.g:70:19:
// SUBCLASS_OF superClass= incompleteExpression
{
SUBCLASS_OF8 = (Token) match(input, SUBCLASS_OF,
FOLLOW_SUBCLASS_OF_in_incompleteBinaryAxiom457);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_SUBCLASS_OF.add(SUBCLASS_OF8);
}
pushFollow(FOLLOW_incompleteExpression_in_incompleteBinaryAxiom463);
superClass = incompleteExpression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_incompleteExpression.add(superClass.getTree());
}
// AST REWRITE
// elements: lhs, superClass
// token labels:
// rule labels: lhs, retval, superClass
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhs = new RewriteRuleSubtreeStream(
adaptor, "rule lhs", lhs != null ? lhs.tree
: null);
RewriteRuleSubtreeStream stream_superClass = new RewriteRuleSubtreeStream(
adaptor, "rule superClass",
superClass != null ? superClass.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 70:65: -> ^( INCOMPLETE_SUB_CLASS_AXIOM ^(
// EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION
// $superClass) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:70:68:
// ^( INCOMPLETE_SUB_CLASS_AXIOM ^(
// EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION
// $superClass) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_SUB_CLASS_AXIOM,
"INCOMPLETE_SUB_CLASS_AXIOM"),
root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:70:98:
// ^( EXPRESSION $lhs)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhs.nextTree());
adaptor.addChild(root_1, root_2);
}
// ManchesterOWLSyntaxAutoCompleteBase.g:70:117:
// ^( INCOMPLETE_EXPRESSION $superClass)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_EXPRESSION,
"INCOMPLETE_EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_superClass.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 3:
// ManchesterOWLSyntaxAutoCompleteBase.g:71:19:
// EQUIVALENT_TO
{
EQUIVALENT_TO9 = (Token) match(input, EQUIVALENT_TO,
FOLLOW_EQUIVALENT_TO_in_incompleteBinaryAxiom504);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_EQUIVALENT_TO.add(EQUIVALENT_TO9);
}
// AST REWRITE
// elements: lhs
// token labels:
// rule labels: lhs, retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhs = new RewriteRuleSubtreeStream(
adaptor, "rule lhs", lhs != null ? lhs.tree
: null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 71:34: -> ^( INCOMPLETE_EQUIVALENT_TO_AXIOM
// ^( EXPRESSION $lhs) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:71:37:
// ^( INCOMPLETE_EQUIVALENT_TO_AXIOM ^(
// EXPRESSION $lhs) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(
adaptor.create(
INCOMPLETE_EQUIVALENT_TO_AXIOM,
"INCOMPLETE_EQUIVALENT_TO_AXIOM"),
root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:71:70:
// ^( EXPRESSION $lhs)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhs.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 4:
// ManchesterOWLSyntaxAutoCompleteBase.g:72:19:
// EQUIVALENT_TO rhs= incompleteExpression
{
EQUIVALENT_TO10 = (Token) match(input, EQUIVALENT_TO,
FOLLOW_EQUIVALENT_TO_in_incompleteBinaryAxiom538);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_EQUIVALENT_TO.add(EQUIVALENT_TO10);
}
pushFollow(FOLLOW_incompleteExpression_in_incompleteBinaryAxiom544);
rhs = incompleteExpression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_incompleteExpression.add(rhs.getTree());
}
// AST REWRITE
// elements: lhs, rhs
// token labels:
// rule labels: lhs, retval, rhs
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhs = new RewriteRuleSubtreeStream(
adaptor, "rule lhs", lhs != null ? lhs.tree
: null);
RewriteRuleSubtreeStream stream_rhs = new RewriteRuleSubtreeStream(
adaptor, "rule rhs", rhs != null ? rhs.tree
: null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 72:60: -> ^( EQUIVALENT_TO_AXIOM ^(
// EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION
// $rhs) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:72:63:
// ^( EQUIVALENT_TO_AXIOM ^( EXPRESSION
// $lhs) ^( INCOMPLETE_EXPRESSION $rhs) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EQUIVALENT_TO_AXIOM,
"EQUIVALENT_TO_AXIOM"), root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:72:85:
// ^( EXPRESSION $lhs)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhs.nextTree());
adaptor.addChild(root_1, root_2);
}
// ManchesterOWLSyntaxAutoCompleteBase.g:72:104:
// ^( INCOMPLETE_EXPRESSION $rhs)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_EXPRESSION,
"INCOMPLETE_EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_rhs.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 5:
// ManchesterOWLSyntaxAutoCompleteBase.g:73:19:
// DISJOINT_WITH
{
DISJOINT_WITH11 = (Token) match(input, DISJOINT_WITH,
FOLLOW_DISJOINT_WITH_in_incompleteBinaryAxiom584);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_DISJOINT_WITH.add(DISJOINT_WITH11);
}
// AST REWRITE
// elements: lhs
// token labels:
// rule labels: lhs, retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhs = new RewriteRuleSubtreeStream(
adaptor, "rule lhs", lhs != null ? lhs.tree
: null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 73:33: -> ^( INCOMPLETE_DISJOINT_WITH_AXIOM
// ^( EXPRESSION $lhs) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:73:36:
// ^( INCOMPLETE_DISJOINT_WITH_AXIOM ^(
// EXPRESSION $lhs) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(
adaptor.create(
INCOMPLETE_DISJOINT_WITH_AXIOM,
"INCOMPLETE_DISJOINT_WITH_AXIOM"),
root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:73:69:
// ^( EXPRESSION $lhs)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhs.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 6:
// ManchesterOWLSyntaxAutoCompleteBase.g:74:19:
// DISJOINT_WITH disjoint= incompleteExpression
{
DISJOINT_WITH12 = (Token) match(input, DISJOINT_WITH,
FOLLOW_DISJOINT_WITH_in_incompleteBinaryAxiom617);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_DISJOINT_WITH.add(DISJOINT_WITH12);
}
pushFollow(FOLLOW_incompleteExpression_in_incompleteBinaryAxiom623);
disjoint = incompleteExpression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_incompleteExpression.add(disjoint.getTree());
}
// AST REWRITE
// elements: lhs, disjoint
// token labels:
// rule labels: lhs, disjoint, retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhs = new RewriteRuleSubtreeStream(
adaptor, "rule lhs", lhs != null ? lhs.tree
: null);
RewriteRuleSubtreeStream stream_disjoint = new RewriteRuleSubtreeStream(
adaptor, "rule disjoint",
disjoint != null ? disjoint.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 74:65: -> ^( DISJOINT_WITH_AXIOM ^(
// EXPRESSION $lhs) ^( INCOMPLETE_EXPRESSION
// $disjoint) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:74:68:
// ^( DISJOINT_WITH_AXIOM ^( EXPRESSION
// $lhs) ^( INCOMPLETE_EXPRESSION $disjoint)
// )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
DISJOINT_WITH_AXIOM,
"DISJOINT_WITH_AXIOM"), root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:74:90:
// ^( EXPRESSION $lhs)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhs.nextTree());
adaptor.addChild(root_1, root_2);
}
// ManchesterOWLSyntaxAutoCompleteBase.g:74:109:
// ^( INCOMPLETE_EXPRESSION $disjoint)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_EXPRESSION,
"INCOMPLETE_EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_disjoint.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 7:
// ManchesterOWLSyntaxAutoCompleteBase.g:75:19:
// SUB_PROPERTY_OF
{
SUB_PROPERTY_OF13 = (Token) match(input, SUB_PROPERTY_OF,
FOLLOW_SUB_PROPERTY_OF_in_incompleteBinaryAxiom663);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_SUB_PROPERTY_OF.add(SUB_PROPERTY_OF13);
}
// AST REWRITE
// elements: lhs
// token labels:
// rule labels: lhs, retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhs = new RewriteRuleSubtreeStream(
adaptor, "rule lhs", lhs != null ? lhs.tree
: null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 75:36: -> ^( INCOMPLETE_SUB_PROPERTY_AXIOM ^(
// EXPRESSION $lhs) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:75:39:
// ^( INCOMPLETE_SUB_PROPERTY_AXIOM ^(
// EXPRESSION $lhs) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_SUB_PROPERTY_AXIOM,
"INCOMPLETE_SUB_PROPERTY_AXIOM"),
root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:75:71:
// ^( EXPRESSION $lhs)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhs.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
}
}
break;
case 2:
// ManchesterOWLSyntaxAutoCompleteBase.g:78:5: lhsID= IDENTIFIER
// ( SAME_AS -> ^( INCOMPLETE_SAME_AS_AXIOM ^( EXPRESSION
// $lhsID) ) | DIFFERENT_FROM -> ^(
// INCOMPLETE_DIFFERENT_FROM_AXIOM ^( EXPRESSION $lhsID) ) |
// DOMAIN -> ^( INCOMPLETE_DOMAIN ^( EXPRESSION $lhsID) ) |
// DOMAIN incompleteDomain= incompleteExpression -> ^(
// INCOMPLETE_DOMAIN ^( EXPRESSION $lhsID) ^(
// INCOMPLETE_EXPRESSION $incompleteDomain) ) | RANGE -> ^(
// INCOMPLETE_RANGE ^( EXPRESSION $lhsID) ) | RANGE
// incompleteRange= incompleteExpression -> ^( INCOMPLETE_RANGE
// ^( EXPRESSION $lhsID) ^( INCOMPLETE_EXPRESSION
// $incompleteRange) ) | INVERSE_OF -> ^( INCOMPLETE_INVERSE_OF
// ^( EXPRESSION $lhsID) ) )
{
lhsID = (Token) match(input, IDENTIFIER,
FOLLOW_IDENTIFIER_in_incompleteBinaryAxiom734);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_IDENTIFIER.add(lhsID);
}
// ManchesterOWLSyntaxAutoCompleteBase.g:78:25: ( SAME_AS ->
// ^( INCOMPLETE_SAME_AS_AXIOM ^( EXPRESSION $lhsID) ) |
// DIFFERENT_FROM -> ^( INCOMPLETE_DIFFERENT_FROM_AXIOM ^(
// EXPRESSION $lhsID) ) | DOMAIN -> ^( INCOMPLETE_DOMAIN ^(
// EXPRESSION $lhsID) ) | DOMAIN incompleteDomain=
// incompleteExpression -> ^( INCOMPLETE_DOMAIN ^(
// EXPRESSION $lhsID) ^( INCOMPLETE_EXPRESSION
// $incompleteDomain) ) | RANGE -> ^( INCOMPLETE_RANGE ^(
// EXPRESSION $lhsID) ) | RANGE incompleteRange=
// incompleteExpression -> ^( INCOMPLETE_RANGE ^( EXPRESSION
// $lhsID) ^( INCOMPLETE_EXPRESSION $incompleteRange) ) |
// INVERSE_OF -> ^( INCOMPLETE_INVERSE_OF ^( EXPRESSION
// $lhsID) ) )
int alt4 = 7;
alt4 = dfa4.predict(input);
switch (alt4) {
case 1:
// ManchesterOWLSyntaxAutoCompleteBase.g:79:21: SAME_AS
{
SAME_AS14 = (Token) match(input, SAME_AS,
FOLLOW_SAME_AS_in_incompleteBinaryAxiom759);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_SAME_AS.add(SAME_AS14);
}
// AST REWRITE
// elements: lhsID
// token labels: lhsID
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleTokenStream stream_lhsID = new RewriteRuleTokenStream(
adaptor, "token lhsID", lhsID);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 79:31: -> ^( INCOMPLETE_SAME_AS_AXIOM ^(
// EXPRESSION $lhsID) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:79:34:
// ^( INCOMPLETE_SAME_AS_AXIOM ^( EXPRESSION
// $lhsID) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_SAME_AS_AXIOM,
"INCOMPLETE_SAME_AS_AXIOM"),
root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:79:61:
// ^( EXPRESSION $lhsID)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhsID.nextNode());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 2:
// ManchesterOWLSyntaxAutoCompleteBase.g:80:21:
// DIFFERENT_FROM
{
DIFFERENT_FROM15 = (Token) match(input, DIFFERENT_FROM,
FOLLOW_DIFFERENT_FROM_in_incompleteBinaryAxiom797);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_DIFFERENT_FROM.add(DIFFERENT_FROM15);
}
// AST REWRITE
// elements: lhsID
// token labels: lhsID
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleTokenStream stream_lhsID = new RewriteRuleTokenStream(
adaptor, "token lhsID", lhsID);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 80:37: -> ^( INCOMPLETE_DIFFERENT_FROM_AXIOM
// ^( EXPRESSION $lhsID) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:80:40:
// ^( INCOMPLETE_DIFFERENT_FROM_AXIOM ^(
// EXPRESSION $lhsID) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(
adaptor.create(
INCOMPLETE_DIFFERENT_FROM_AXIOM,
"INCOMPLETE_DIFFERENT_FROM_AXIOM"),
root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:80:74:
// ^( EXPRESSION $lhsID)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhsID.nextNode());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 3:
// ManchesterOWLSyntaxAutoCompleteBase.g:81:21: DOMAIN
{
DOMAIN16 = (Token) match(input, DOMAIN,
FOLLOW_DOMAIN_in_incompleteBinaryAxiom833);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_DOMAIN.add(DOMAIN16);
}
// AST REWRITE
// elements: lhsID
// token labels: lhsID
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleTokenStream stream_lhsID = new RewriteRuleTokenStream(
adaptor, "token lhsID", lhsID);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 81:29: -> ^( INCOMPLETE_DOMAIN ^( EXPRESSION
// $lhsID) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:81:32:
// ^( INCOMPLETE_DOMAIN ^( EXPRESSION
// $lhsID) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_DOMAIN,
"INCOMPLETE_DOMAIN"), root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:81:52:
// ^( EXPRESSION $lhsID)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhsID.nextNode());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 4:
// ManchesterOWLSyntaxAutoCompleteBase.g:82:21: DOMAIN
// incompleteDomain= incompleteExpression
{
DOMAIN17 = (Token) match(input, DOMAIN,
FOLLOW_DOMAIN_in_incompleteBinaryAxiom869);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_DOMAIN.add(DOMAIN17);
}
pushFollow(FOLLOW_incompleteExpression_in_incompleteBinaryAxiom875);
incompleteDomain = incompleteExpression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_incompleteExpression.add(incompleteDomain
.getTree());
}
// AST REWRITE
// elements: incompleteDomain, lhsID
// token labels: lhsID
// rule labels: incompleteDomain, retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleTokenStream stream_lhsID = new RewriteRuleTokenStream(
adaptor, "token lhsID", lhsID);
RewriteRuleSubtreeStream stream_incompleteDomain = new RewriteRuleSubtreeStream(
adaptor, "rule incompleteDomain",
incompleteDomain != null ? incompleteDomain.tree
: null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 82:69: -> ^( INCOMPLETE_DOMAIN ^( EXPRESSION
// $lhsID) ^( INCOMPLETE_EXPRESSION
// $incompleteDomain) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:82:72:
// ^( INCOMPLETE_DOMAIN ^( EXPRESSION
// $lhsID) ^( INCOMPLETE_EXPRESSION
// $incompleteDomain) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_DOMAIN,
"INCOMPLETE_DOMAIN"), root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:82:92:
// ^( EXPRESSION $lhsID)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhsID.nextNode());
adaptor.addChild(root_1, root_2);
}
// ManchesterOWLSyntaxAutoCompleteBase.g:82:113:
// ^( INCOMPLETE_EXPRESSION
// $incompleteDomain)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_EXPRESSION,
"INCOMPLETE_EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_incompleteDomain.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 5:
// ManchesterOWLSyntaxAutoCompleteBase.g:83:21: RANGE
{
RANGE18 = (Token) match(input, RANGE,
FOLLOW_RANGE_in_incompleteBinaryAxiom918);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_RANGE.add(RANGE18);
}
// AST REWRITE
// elements: lhsID
// token labels: lhsID
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleTokenStream stream_lhsID = new RewriteRuleTokenStream(
adaptor, "token lhsID", lhsID);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 83:28: -> ^( INCOMPLETE_RANGE ^( EXPRESSION
// $lhsID) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:83:31:
// ^( INCOMPLETE_RANGE ^( EXPRESSION $lhsID)
// )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_RANGE,
"INCOMPLETE_RANGE"), root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:83:50:
// ^( EXPRESSION $lhsID)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhsID.nextNode());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 6:
// ManchesterOWLSyntaxAutoCompleteBase.g:84:21: RANGE
// incompleteRange= incompleteExpression
{
RANGE19 = (Token) match(input, RANGE,
FOLLOW_RANGE_in_incompleteBinaryAxiom954);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_RANGE.add(RANGE19);
}
pushFollow(FOLLOW_incompleteExpression_in_incompleteBinaryAxiom961);
incompleteRange = incompleteExpression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_incompleteExpression
.add(incompleteRange.getTree());
}
// AST REWRITE
// elements: lhsID, incompleteRange
// token labels: lhsID
// rule labels: incompleteRange, retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleTokenStream stream_lhsID = new RewriteRuleTokenStream(
adaptor, "token lhsID", lhsID);
RewriteRuleSubtreeStream stream_incompleteRange = new RewriteRuleSubtreeStream(
adaptor, "rule incompleteRange",
incompleteRange != null ? incompleteRange.tree
: null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 84:67: -> ^( INCOMPLETE_RANGE ^( EXPRESSION
// $lhsID) ^( INCOMPLETE_EXPRESSION
// $incompleteRange) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:84:70:
// ^( INCOMPLETE_RANGE ^( EXPRESSION $lhsID)
// ^( INCOMPLETE_EXPRESSION
// $incompleteRange) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_RANGE,
"INCOMPLETE_RANGE"), root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:84:89:
// ^( EXPRESSION $lhsID)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhsID.nextNode());
adaptor.addChild(root_1, root_2);
}
// ManchesterOWLSyntaxAutoCompleteBase.g:84:110:
// ^( INCOMPLETE_EXPRESSION
// $incompleteRange)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_EXPRESSION,
"INCOMPLETE_EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_incompleteRange.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 7:
// ManchesterOWLSyntaxAutoCompleteBase.g:85:21:
// INVERSE_OF
{
INVERSE_OF20 = (Token) match(input, INVERSE_OF,
FOLLOW_INVERSE_OF_in_incompleteBinaryAxiom1003);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_INVERSE_OF.add(INVERSE_OF20);
}
// AST REWRITE
// elements: lhsID
// token labels: lhsID
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleTokenStream stream_lhsID = new RewriteRuleTokenStream(
adaptor, "token lhsID", lhsID);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 85:32: -> ^( INCOMPLETE_INVERSE_OF ^(
// EXPRESSION $lhsID) )
{
// ManchesterOWLSyntaxAutoCompleteBase.g:85:35:
// ^( INCOMPLETE_INVERSE_OF ^( EXPRESSION
// $lhsID) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INCOMPLETE_INVERSE_OF,
"INCOMPLETE_INVERSE_OF"), root_1);
// ManchesterOWLSyntaxAutoCompleteBase.g:85:59:
// ^( EXPRESSION $lhsID)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
EXPRESSION, "EXPRESSION"),
root_2);
adaptor.addChild(root_2,
stream_lhsID.nextNode());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
}
}
break;
}
retval.stop = input.LT(-1);
if (state.backtracking == 0) {
retval.tree = (ManchesterOWLSyntaxTree) adaptor
.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
} catch (RecognitionException re) {
reportError(re);
recover(input, re);
retval.tree = (ManchesterOWLSyntaxTree) adaptor.errorNode(input,
retval.start, input.LT(-1), re);
} finally {}
return retval;
}
// $ANTLR end "incompleteBinaryAxiom"
public static class incompleteExpression_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "incompleteExpression"
// ManchesterOWLSyntaxAutoCompleteBase.g:90:1: incompleteExpression : (
// options {backtrack=true; } : head= propertyExpression ( COMPOSITION
// rest+= propertyExpression )+ COMPOSITION -> ^( INCOMPLETE_EXPRESSION ^(
// INCOMPLETE_PROPERTY_CHAIN $head $rest) ) | ( conjunction ( OR . )* ) OR
// incompleteConjunction -> ^( INCOMPLETE_EXPRESSION ^(
// INCOMPLETE_DISJUNCTION incompleteConjunction ) ) | incompleteConjunction
// -> ^( INCOMPLETE_EXPRESSION ^( INCOMPLETE_DISJUNCTION
// incompleteConjunction ) ) | incompleteUnary -> ^( INCOMPLETE_EXPRESSION
// incompleteUnary ) | expression IDENTIFIER -> ^( INCOMPLETE_EXPRESSION ^(
// EXPRESSION expression ) IDENTIFIER ) ) ;
public final
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteExpression_return
incompleteExpression() {
ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteExpression_return retval = new ManchesterOWLSyntaxAutoCompleteCombined_ManchesterOWLSyntaxAutoCompleteBase.incompleteExpression_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token COMPOSITION21 = null;
Token COMPOSITION22 = null;
Token OR24 = null;
Token wildcard25 = null;
Token OR26 = null;
Token IDENTIFIER31 = null;
List© 2015 - 2025 Weber Informatics LLC | Privacy Policy