org.coode.parsers.ManchesterOWLSyntax_MOWLParser Maven / Gradle / Ivy
// $ANTLR 3.2 Sep 23, 2009 12:02:23 MOWLParser.g 2011-02-03 18:49:27
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.RewriteEmptyStreamException;
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 ManchesterOWLSyntax_MOWLParser extends Parser {
public static final int HAS_KEY = 109;
public static final int VALUE_RESTRICTION = 63;
public static final int LETTER = 43;
public static final int REMOVE = 91;
public static final int TYPES = 39;
public static final int SAME_AS_AXIOM = 52;
public static final int INVERSE_OF = 25;
public static final int NOT = 12;
public static final int SUBCLASS_OF = 20;
public static final int EOF = -1;
public static final int ESCLAMATION_MARK = 149;
public static final int ACTIONS = 101;
public static final int CREATE_IDENTIFIER = 151;
public static final int CREATE = 80;
public static final int POW = 36;
public static final int INPUT_VARIABLE_DEFINITION = 96;
public static final int NOT_EQUAL = 72;
public static final int INVERSE_OBJECT_PROPERTY_EXPRESSION = 68;
public static final int INSTANCE_OF = 38;
public static final int BEGIN = 83;
public static final int QUESTION_MARK = 46;
public static final int INEQUALITY_CONSTRAINT = 94;
public static final int VARIABLE_SCOPE = 104;
public static final int SYMMETRIC = 30;
public static final int CARDINALITY_RESTRICTION = 64;
public static final int SELECT = 75;
public static final int ROLE_ASSERTION = 67;
public static final int DIFFERENT_FROM_AXIOM = 53;
public static final int CREATE_OPPL_FUNCTION = 98;
public static final int ANTI_SYMMETRIC = 31;
public static final int TRANSITIVE = 34;
public static final int GREATER_THAN_EQUAL = 486;
public static final int ALL_RESTRICTION = 62;
public static final int CONJUNCTION = 56;
public static final int OPPL_STATEMENT = 107;
public static final int NEGATED_ASSERTION = 59;
public static final int WHITESPACE = 9;
public static final int IN_SET_CONSTRAINT = 95;
public static final int MATCH = 176;
public static final int VALUE = 18;
public static final int OPEN_CURLY_BRACES = 6;
public static final int DISJUNCTION = 55;
public static final int INVERSE = 19;
public static final int DBLQUOTE = 40;
public static final int OR = 11;
public static final int LESS_THAN = 483;
public static final int CONSTANT = 70;
public static final int QUERY = 103;
public static final int ENTITY_REFERENCE = 45;
public static final int END = 84;
public static final int COMPOSITION = 4;
public static final int ANNOTATION_ASSERTION = 111;
public static final int CLOSED_SQUARE_BRACKET = 86;
public static final int SAME_AS = 23;
public static final int WHERE = 71;
public static final int DISJOINT_WITH = 26;
public static final int SUPER_PROPERTY_OF = 88;
public static final int VARIABLE_TYPE = 89;
public static final int ATTRIBUTE_SELECTOR = 283;
public static final int CLOSED_PARENTHESYS = 8;
public static final int ONLY = 14;
public static final int EQUIVALENT_TO_AXIOM = 49;
public static final int SUB_PROPERTY_OF = 21;
public static final int NEGATED_EXPRESSION = 58;
public static final int MAX = 16;
public static final int CREATE_DISJUNCTION = 82;
public static final int AND = 10;
public static final int ASSERTED_CLAUSE = 92;
public static final int INVERSE_PROPERTY = 60;
public static final int AT = 114;
public static final int DIFFERENT_FROM = 24;
public static final int IN = 74;
public static final int EQUIVALENT_TO = 22;
public static final int UNARY_AXIOM = 54;
public static final int COMMA = 37;
public static final int CLOSED_CURLY_BRACES = 7;
public static final int IDENTIFIER = 44;
public static final int IRI = 110;
public static final int SOME = 13;
public static final int EQUAL = 73;
public static final int OPEN_PARENTHESYS = 5;
public static final int REFLEXIVE = 32;
public static final int PLUS = 79;
public static final int DIGIT = 41;
public static final int DOT = 78;
public static final int SUPER_CLASS_OF = 87;
public static final int EXPRESSION = 69;
public static final int SOME_RESTRICTION = 61;
public static final int ADD = 90;
public static final int INTEGER = 42;
public static final int GREATER_THAN = 485;
public static final int GENERATED_VARIABLE_DEFINITION = 97;
public static final int OPEN_SQUARE_BRACKET = 85;
public static final int SUB_PROPERTY_AXIOM = 51;
public static final int EXACTLY = 17;
public static final int RANGE = 28;
public static final int ONE_OF = 65;
public static final int DATA_RANGE = 108;
public static final int VARIABLE_DEFINITIONS = 102;
public static final int SUB_CLASS_AXIOM = 48;
public static final int MIN = 15;
public static final int PLAIN_CLAUSE = 93;
public static final int Tokens = 47;
public static final int DOMAIN = 27;
public static final int SUBPROPERTY_OF = 105;
public static final int COLON = 77;
public static final int OPPL_FUNCTION = 100;
public static final int DISJOINT_WITH_AXIOM = 50;
public static final int CREATE_INTERSECTION = 81;
public static final int INVERSE_FUNCTIONAL = 35;
public static final int VARIABLE_IDENTIFIER = 106;
public static final int IRREFLEXIVE = 33;
public static final int ASSERTED = 76;
public static final int VARIABLE_ATTRIBUTE = 99;
public static final int PLAIN_IDENTIFIER = 152;
public static final int LESS_THAN_EQUAL = 484;
public static final int PROPERTY_CHAIN = 57;
public static final int FUNCTIONAL = 29;
public static final int TYPE_ASSERTION = 66;
// delegates
// delegators
public ManchesterOWLSyntaxParser gManchesterOWLSyntax;
public ManchesterOWLSyntaxParser gParent;
public ManchesterOWLSyntax_MOWLParser(TokenStream input,
ManchesterOWLSyntaxParser gManchesterOWLSyntax) {
this(input, new RecognizerSharedState(), gManchesterOWLSyntax);
}
public ManchesterOWLSyntax_MOWLParser(TokenStream input, RecognizerSharedState state,
ManchesterOWLSyntaxParser gManchesterOWLSyntax) {
super(input, state);
this.gManchesterOWLSyntax = gManchesterOWLSyntax;
gParent = gManchesterOWLSyntax;
}
protected TreeAdaptor adaptor = new CommonTreeAdaptor();
public void setTreeAdaptor(TreeAdaptor adaptor) {
this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
return adaptor;
}
@Override
public String[] getTokenNames() {
return ManchesterOWLSyntaxParser.tokenNames;
}
@Override
public String getGrammarFileName() {
return "MOWLParser.g";
}
@Override
public void displayRecognitionError(String[] tokenNames, RecognitionException e) {}
public static class axiom_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "axiom"
// MOWLParser.g:64:1: axiom options {backtrack=true; } : ( binaryAxiom -> ^(
// binaryAxiom ) | unaryAxiom -> ^( unaryAxiom ) | assertionAxiom -> ^(
// assertionAxiom ) | hasKeyAxiom -> ^( hasKeyAxiom ) |
// annotationAssertionAxiom -> ^( annotationAssertionAxiom ) );
public final ManchesterOWLSyntax_MOWLParser.axiom_return axiom()
throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.axiom_return retval = new ManchesterOWLSyntax_MOWLParser.axiom_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
ManchesterOWLSyntax_MOWLParser.binaryAxiom_return binaryAxiom1 = null;
ManchesterOWLSyntax_MOWLParser.unaryAxiom_return unaryAxiom2 = null;
ManchesterOWLSyntax_MOWLParser.assertionAxiom_return assertionAxiom3 = null;
ManchesterOWLSyntax_MOWLParser.hasKeyAxiom_return hasKeyAxiom4 = null;
ManchesterOWLSyntax_MOWLParser.annotationAssertionAxiom_return annotationAssertionAxiom5 = null;
RewriteRuleSubtreeStream stream_binaryAxiom = new RewriteRuleSubtreeStream(
adaptor, "rule binaryAxiom");
RewriteRuleSubtreeStream stream_unaryAxiom = new RewriteRuleSubtreeStream(
adaptor, "rule unaryAxiom");
RewriteRuleSubtreeStream stream_annotationAssertionAxiom = new RewriteRuleSubtreeStream(
adaptor, "rule annotationAssertionAxiom");
RewriteRuleSubtreeStream stream_hasKeyAxiom = new RewriteRuleSubtreeStream(
adaptor, "rule hasKeyAxiom");
RewriteRuleSubtreeStream stream_assertionAxiom = new RewriteRuleSubtreeStream(
adaptor, "rule assertionAxiom");
try {
// MOWLParser.g:64:37: ( binaryAxiom -> ^( binaryAxiom ) |
// unaryAxiom -> ^( unaryAxiom ) | assertionAxiom -> ^(
// assertionAxiom ) | hasKeyAxiom -> ^( hasKeyAxiom ) |
// annotationAssertionAxiom -> ^( annotationAssertionAxiom ) )
int alt1 = 5;
alt1 = dfa1.predict(input);
switch (alt1) {
case 1:
// MOWLParser.g:65:3: binaryAxiom
{
pushFollow(FOLLOW_binaryAxiom_in_axiom232);
binaryAxiom1 = binaryAxiom();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_binaryAxiom.add(binaryAxiom1.getTree());
}
// AST REWRITE
// elements: binaryAxiom
// 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();
// 65:15: -> ^( binaryAxiom )
{
// MOWLParser.g:65:18: ^( binaryAxiom )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_binaryAxiom.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 2:
// MOWLParser.g:66:5: unaryAxiom
{
pushFollow(FOLLOW_unaryAxiom_in_axiom244);
unaryAxiom2 = unaryAxiom();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_unaryAxiom.add(unaryAxiom2.getTree());
}
// AST REWRITE
// elements: unaryAxiom
// 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();
// 66:16: -> ^( unaryAxiom )
{
// MOWLParser.g:66:19: ^( unaryAxiom )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_unaryAxiom.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 3:
// MOWLParser.g:67:5: assertionAxiom
{
pushFollow(FOLLOW_assertionAxiom_in_axiom256);
assertionAxiom3 = assertionAxiom();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_assertionAxiom.add(assertionAxiom3.getTree());
}
// AST REWRITE
// elements: assertionAxiom
// 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();
// 67:20: -> ^( assertionAxiom )
{
// MOWLParser.g:67:23: ^( assertionAxiom )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_assertionAxiom.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 4:
// MOWLParser.g:68:5: hasKeyAxiom
{
pushFollow(FOLLOW_hasKeyAxiom_in_axiom268);
hasKeyAxiom4 = hasKeyAxiom();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_hasKeyAxiom.add(hasKeyAxiom4.getTree());
}
// AST REWRITE
// elements: hasKeyAxiom
// 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();
// 68:17: -> ^( hasKeyAxiom )
{
// MOWLParser.g:68:19: ^( hasKeyAxiom )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_hasKeyAxiom.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 5:
// MOWLParser.g:69:5: annotationAssertionAxiom
{
pushFollow(FOLLOW_annotationAssertionAxiom_in_axiom279);
annotationAssertionAxiom5 = annotationAssertionAxiom();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_annotationAssertionAxiom.add(annotationAssertionAxiom5
.getTree());
}
// AST REWRITE
// elements: annotationAssertionAxiom
// 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();
// 69:30: -> ^( annotationAssertionAxiom )
{
// MOWLParser.g:69:32: ^( annotationAssertionAxiom )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_annotationAssertionAxiom.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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "axiom"
public static class annotationAssertionAxiom_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "annotationAssertionAxiom"
// MOWLParser.g:72:1: annotationAssertionAxiom options {backtrack=true; } :
// ( iri p= atomic o= constant -> ^( ANNOTATION_ASSERTION iri ^( EXPRESSION
// $p) ^( EXPRESSION $o) ) | iri p= atomic a= atomic -> ^(
// ANNOTATION_ASSERTION iri ^( EXPRESSION $p) ^( EXPRESSION $a) ) |
// subjectIRI= iri p= atomic objectIRI= iri -> ^( ANNOTATION_ASSERTION
// $subjectIRI ^( EXPRESSION $p) ^( EXPRESSION $objectIRI) ) );
public final ManchesterOWLSyntax_MOWLParser.annotationAssertionAxiom_return
annotationAssertionAxiom() throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.annotationAssertionAxiom_return retval = new ManchesterOWLSyntax_MOWLParser.annotationAssertionAxiom_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
ManchesterOWLSyntax_MOWLParser.atomic_return p = null;
ManchesterOWLSyntax_MOWLParser.constant_return o = null;
ManchesterOWLSyntax_MOWLParser.atomic_return a = null;
ManchesterOWLSyntax_MOWLParser.iri_return subjectIRI = null;
ManchesterOWLSyntax_MOWLParser.iri_return objectIRI = null;
ManchesterOWLSyntax_MOWLParser.iri_return iri6 = null;
ManchesterOWLSyntax_MOWLParser.iri_return iri7 = null;
RewriteRuleSubtreeStream stream_constant = new RewriteRuleSubtreeStream(adaptor,
"rule constant");
RewriteRuleSubtreeStream stream_iri = new RewriteRuleSubtreeStream(adaptor,
"rule iri");
RewriteRuleSubtreeStream stream_atomic = new RewriteRuleSubtreeStream(adaptor,
"rule atomic");
try {
// MOWLParser.g:73:32: ( iri p= atomic o= constant -> ^(
// ANNOTATION_ASSERTION iri ^( EXPRESSION $p) ^( EXPRESSION $o) ) |
// iri p= atomic a= atomic -> ^( ANNOTATION_ASSERTION iri ^(
// EXPRESSION $p) ^( EXPRESSION $a) ) | subjectIRI= iri p= atomic
// objectIRI= iri -> ^( ANNOTATION_ASSERTION $subjectIRI ^(
// EXPRESSION $p) ^( EXPRESSION $objectIRI) ) )
int alt2 = 3;
int LA2_0 = input.LA(1);
if (LA2_0 == IRI) {
int LA2_1 = input.LA(2);
if (LA2_1 == IDENTIFIER) {
switch (input.LA(3)) {
case DBLQUOTE: {
alt2 = 1;
}
break;
case IRI: {
alt2 = 3;
}
break;
case IDENTIFIER:
case ENTITY_REFERENCE: {
alt2 = 2;
}
break;
default:
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 2,
2, input);
throw nvae;
}
} else if (LA2_1 == ENTITY_REFERENCE) {
switch (input.LA(3)) {
case IRI: {
alt2 = 3;
}
break;
case DBLQUOTE: {
alt2 = 1;
}
break;
case IDENTIFIER:
case ENTITY_REFERENCE: {
alt2 = 2;
}
break;
default:
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 2,
3, input);
throw nvae;
}
} else {
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 2, 1, input);
throw nvae;
}
} else {
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 2, 0, input);
throw nvae;
}
switch (alt2) {
case 1:
// MOWLParser.g:74:3: iri p= atomic o= constant
{
pushFollow(FOLLOW_iri_in_annotationAssertionAxiom311);
iri6 = iri();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_iri.add(iri6.getTree());
}
pushFollow(FOLLOW_atomic_in_annotationAssertionAxiom316);
p = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(p.getTree());
}
pushFollow(FOLLOW_constant_in_annotationAssertionAxiom322);
o = constant();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_constant.add(o.getTree());
}
// AST REWRITE
// elements: o, p, iri
// token labels:
// rule labels: retval, p, o
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_p = new RewriteRuleSubtreeStream(
adaptor, "rule p", p != null ? p.tree : null);
RewriteRuleSubtreeStream stream_o = new RewriteRuleSubtreeStream(
adaptor, "rule o", o != null ? o.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 74:30: -> ^( ANNOTATION_ASSERTION iri ^( EXPRESSION
// $p) ^( EXPRESSION $o) )
{
// MOWLParser.g:74:33: ^( ANNOTATION_ASSERTION iri
// ^( EXPRESSION $p) ^( EXPRESSION $o) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(ANNOTATION_ASSERTION,
"ANNOTATION_ASSERTION"), root_1);
adaptor.addChild(root_1, stream_iri.nextTree());
// MOWLParser.g:74:60: ^( EXPRESSION $p)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_p.nextTree());
adaptor.addChild(root_1, root_2);
}
// MOWLParser.g:74:77: ^( EXPRESSION $o)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_o.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 2:
// MOWLParser.g:75:5: iri p= atomic a= atomic
{
pushFollow(FOLLOW_iri_in_annotationAssertionAxiom350);
iri7 = iri();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_iri.add(iri7.getTree());
}
pushFollow(FOLLOW_atomic_in_annotationAssertionAxiom355);
p = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(p.getTree());
}
pushFollow(FOLLOW_atomic_in_annotationAssertionAxiom361);
a = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(a.getTree());
}
// AST REWRITE
// elements: p, iri, a
// token labels:
// rule labels: retval, a, p
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_a = new RewriteRuleSubtreeStream(
adaptor, "rule a", a != null ? a.tree : null);
RewriteRuleSubtreeStream stream_p = new RewriteRuleSubtreeStream(
adaptor, "rule p", p != null ? p.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 75:30: -> ^( ANNOTATION_ASSERTION iri ^( EXPRESSION
// $p) ^( EXPRESSION $a) )
{
// MOWLParser.g:75:33: ^( ANNOTATION_ASSERTION iri
// ^( EXPRESSION $p) ^( EXPRESSION $a) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(ANNOTATION_ASSERTION,
"ANNOTATION_ASSERTION"), root_1);
adaptor.addChild(root_1, stream_iri.nextTree());
// MOWLParser.g:75:60: ^( EXPRESSION $p)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_p.nextTree());
adaptor.addChild(root_1, root_2);
}
// MOWLParser.g:75:77: ^( EXPRESSION $a)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_a.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 3:
// MOWLParser.g:76:5: subjectIRI= iri p= atomic objectIRI= iri
{
pushFollow(FOLLOW_iri_in_annotationAssertionAxiom393);
subjectIRI = iri();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_iri.add(subjectIRI.getTree());
}
pushFollow(FOLLOW_atomic_in_annotationAssertionAxiom398);
p = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(p.getTree());
}
pushFollow(FOLLOW_iri_in_annotationAssertionAxiom404);
objectIRI = iri();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_iri.add(objectIRI.getTree());
}
// AST REWRITE
// elements: objectIRI, subjectIRI, p
// token labels:
// rule labels: objectIRI, retval, subjectIRI, p
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_objectIRI = new RewriteRuleSubtreeStream(
adaptor, "rule objectIRI",
objectIRI != null ? objectIRI.tree : null);
RewriteRuleSubtreeStream stream_subjectIRI = new RewriteRuleSubtreeStream(
adaptor, "rule subjectIRI",
subjectIRI != null ? subjectIRI.tree : null);
RewriteRuleSubtreeStream stream_p = new RewriteRuleSubtreeStream(
adaptor, "rule p", p != null ? p.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 76:48: -> ^( ANNOTATION_ASSERTION $subjectIRI ^(
// EXPRESSION $p) ^( EXPRESSION $objectIRI) )
{
// MOWLParser.g:76:51: ^( ANNOTATION_ASSERTION
// $subjectIRI ^( EXPRESSION $p) ^( EXPRESSION
// $objectIRI) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(ANNOTATION_ASSERTION,
"ANNOTATION_ASSERTION"), root_1);
adaptor.addChild(root_1, stream_subjectIRI.nextTree());
// MOWLParser.g:76:86: ^( EXPRESSION $p)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_p.nextTree());
adaptor.addChild(root_1, root_2);
}
// MOWLParser.g:76:103: ^( EXPRESSION
// $objectIRI)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_objectIRI.nextTree());
adaptor.addChild(root_1, root_2);
}
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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "annotationAssertionAxiom"
public static class iri_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "iri"
// MOWLParser.g:80:1: iri : IRI -> IRI ;
public final ManchesterOWLSyntax_MOWLParser.iri_return iri()
throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.iri_return retval = new ManchesterOWLSyntax_MOWLParser.iri_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token IRI8 = null;
RewriteRuleTokenStream stream_IRI = new RewriteRuleTokenStream(adaptor,
"token IRI");
try {
// MOWLParser.g:81:2: ( IRI -> IRI )
// MOWLParser.g:82:2: IRI
{
IRI8 = (Token) match(input, IRI, FOLLOW_IRI_in_iri440);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_IRI.add(IRI8);
}
// AST REWRITE
// elements: IRI
// 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();
// 82:6: -> IRI
{
adaptor.addChild(root_0, stream_IRI.nextNode());
}
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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "iri"
public static class hasKeyAxiom_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "hasKeyAxiom"
// MOWLParser.g:85:1: hasKeyAxiom : exp= disjunction HAS_KEY
// propertyExpression ( COMMA propertyExpression )* -> ^( HAS_KEY ^(
// EXPRESSION $exp) ( ^( EXPRESSION propertyExpression ) )+ ) ;
public final ManchesterOWLSyntax_MOWLParser.hasKeyAxiom_return hasKeyAxiom()
throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.hasKeyAxiom_return retval = new ManchesterOWLSyntax_MOWLParser.hasKeyAxiom_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token HAS_KEY9 = null;
Token COMMA11 = null;
ManchesterOWLSyntax_MOWLParser.disjunction_return exp = null;
ManchesterOWLSyntax_MOWLParser.propertyExpression_return propertyExpression10 = null;
ManchesterOWLSyntax_MOWLParser.propertyExpression_return propertyExpression12 = null;
RewriteRuleTokenStream stream_HAS_KEY = new RewriteRuleTokenStream(adaptor,
"token HAS_KEY");
RewriteRuleTokenStream stream_COMMA = new RewriteRuleTokenStream(adaptor,
"token COMMA");
RewriteRuleSubtreeStream stream_disjunction = new RewriteRuleSubtreeStream(
adaptor, "rule disjunction");
RewriteRuleSubtreeStream stream_propertyExpression = new RewriteRuleSubtreeStream(
adaptor, "rule propertyExpression");
try {
// MOWLParser.g:86:2: (exp= disjunction HAS_KEY propertyExpression (
// COMMA propertyExpression )* -> ^( HAS_KEY ^( EXPRESSION $exp) (
// ^( EXPRESSION propertyExpression ) )+ ) )
// MOWLParser.g:87:2: exp= disjunction HAS_KEY propertyExpression (
// COMMA propertyExpression )*
{
pushFollow(FOLLOW_disjunction_in_hasKeyAxiom462);
exp = disjunction();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_disjunction.add(exp.getTree());
}
HAS_KEY9 = (Token) match(input, HAS_KEY, FOLLOW_HAS_KEY_in_hasKeyAxiom464);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_HAS_KEY.add(HAS_KEY9);
}
pushFollow(FOLLOW_propertyExpression_in_hasKeyAxiom466);
propertyExpression10 = propertyExpression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_propertyExpression.add(propertyExpression10.getTree());
}
// MOWLParser.g:87:47: ( COMMA propertyExpression )*
loop3: do {
int alt3 = 2;
int LA3_0 = input.LA(1);
if (LA3_0 == COMMA) {
alt3 = 1;
}
switch (alt3) {
case 1:
// MOWLParser.g:87:48: COMMA propertyExpression
{
COMMA11 = (Token) match(input, COMMA,
FOLLOW_COMMA_in_hasKeyAxiom469);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_COMMA.add(COMMA11);
}
pushFollow(FOLLOW_propertyExpression_in_hasKeyAxiom471);
propertyExpression12 = propertyExpression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_propertyExpression.add(propertyExpression12
.getTree());
}
}
break;
default:
break loop3;
}
} while (true);
// AST REWRITE
// elements: propertyExpression, HAS_KEY, 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();
// 87:75: -> ^( HAS_KEY ^( EXPRESSION $exp) ( ^( EXPRESSION
// propertyExpression ) )+ )
{
// MOWLParser.g:87:78: ^( HAS_KEY ^( EXPRESSION $exp) (
// ^( EXPRESSION propertyExpression ) )+ )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_HAS_KEY.nextNode(), root_1);
// MOWLParser.g:87:88: ^( 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);
}
if (!stream_propertyExpression.hasNext()) {
throw new RewriteEarlyExitException();
}
while (stream_propertyExpression.hasNext()) {
// MOWLParser.g:87:108: ^( EXPRESSION
// propertyExpression )
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2,
stream_propertyExpression.nextTree());
adaptor.addChild(root_1, root_2);
}
}
stream_propertyExpression.reset();
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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "hasKeyAxiom"
public static class assertionAxiom_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "assertionAxiom"
// MOWLParser.g:92:1: assertionAxiom options {backtrack=true; } : (i= atomic
// ( INSTANCE_OF | TYPES ) expression -> ^( TYPE_ASSERTION ^( EXPRESSION
// expression ) ^( EXPRESSION $i) ) | subject= atomic propertyExpression
// value -> ^( ROLE_ASSERTION ^( EXPRESSION $subject) ^( EXPRESSION
// propertyExpression ) ^( EXPRESSION value ) ) | NOT assertionAxiom -> ^(
// NEGATED_ASSERTION assertionAxiom ) );
public final ManchesterOWLSyntax_MOWLParser.assertionAxiom_return assertionAxiom()
throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.assertionAxiom_return retval = new ManchesterOWLSyntax_MOWLParser.assertionAxiom_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token INSTANCE_OF13 = null;
Token TYPES14 = null;
Token NOT18 = null;
ManchesterOWLSyntax_MOWLParser.atomic_return i = null;
ManchesterOWLSyntax_MOWLParser.atomic_return subject = null;
ManchesterOWLSyntax_MOWLParser.expression_return expression15 = null;
ManchesterOWLSyntax_MOWLParser.propertyExpression_return propertyExpression16 = null;
ManchesterOWLSyntax_MOWLParser.value_return value17 = null;
ManchesterOWLSyntax_MOWLParser.assertionAxiom_return assertionAxiom19 = null;
RewriteRuleTokenStream stream_TYPES = new RewriteRuleTokenStream(adaptor,
"token TYPES");
RewriteRuleTokenStream stream_NOT = new RewriteRuleTokenStream(adaptor,
"token NOT");
RewriteRuleTokenStream stream_INSTANCE_OF = new RewriteRuleTokenStream(adaptor,
"token INSTANCE_OF");
RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(
adaptor, "rule expression");
RewriteRuleSubtreeStream stream_propertyExpression = new RewriteRuleSubtreeStream(
adaptor, "rule propertyExpression");
RewriteRuleSubtreeStream stream_value = new RewriteRuleSubtreeStream(adaptor,
"rule value");
RewriteRuleSubtreeStream stream_assertionAxiom = new RewriteRuleSubtreeStream(
adaptor, "rule assertionAxiom");
RewriteRuleSubtreeStream stream_atomic = new RewriteRuleSubtreeStream(adaptor,
"rule atomic");
try {
// MOWLParser.g:92:41: (i= atomic ( INSTANCE_OF | TYPES ) expression
// -> ^( TYPE_ASSERTION ^( EXPRESSION expression ) ^( EXPRESSION $i)
// ) | subject= atomic propertyExpression value -> ^( ROLE_ASSERTION
// ^( EXPRESSION $subject) ^( EXPRESSION propertyExpression ) ^(
// EXPRESSION value ) ) | NOT assertionAxiom -> ^( NEGATED_ASSERTION
// assertionAxiom ) )
int alt5 = 3;
switch (input.LA(1)) {
case IDENTIFIER: {
int LA5_1 = input.LA(2);
if (LA5_1 == INVERSE || LA5_1 >= IDENTIFIER
&& LA5_1 <= ENTITY_REFERENCE) {
alt5 = 2;
} else if (LA5_1 >= INSTANCE_OF && LA5_1 <= TYPES) {
alt5 = 1;
} else {
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 5, 1,
input);
throw nvae;
}
}
break;
case ENTITY_REFERENCE: {
int LA5_2 = input.LA(2);
if (LA5_2 == INVERSE || LA5_2 >= IDENTIFIER
&& LA5_2 <= ENTITY_REFERENCE) {
alt5 = 2;
} else if (LA5_2 >= INSTANCE_OF && LA5_2 <= TYPES) {
alt5 = 1;
} else {
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 5, 2,
input);
throw nvae;
}
}
break;
case NOT: {
alt5 = 3;
}
break;
default:
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 5, 0, input);
throw nvae;
}
switch (alt5) {
case 1:
// MOWLParser.g:93:3: i= atomic ( INSTANCE_OF | TYPES )
// expression
{
pushFollow(FOLLOW_atomic_in_assertionAxiom520);
i = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(i.getTree());
}
// MOWLParser.g:93:14: ( INSTANCE_OF | TYPES )
int alt4 = 2;
int LA4_0 = input.LA(1);
if (LA4_0 == INSTANCE_OF) {
alt4 = 1;
} else if (LA4_0 == TYPES) {
alt4 = 2;
} else {
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 4, 0,
input);
throw nvae;
}
switch (alt4) {
case 1:
// MOWLParser.g:93:15: INSTANCE_OF
{
INSTANCE_OF13 = (Token) match(input, INSTANCE_OF,
FOLLOW_INSTANCE_OF_in_assertionAxiom523);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_INSTANCE_OF.add(INSTANCE_OF13);
}
}
break;
case 2:
// MOWLParser.g:93:29: TYPES
{
TYPES14 = (Token) match(input, TYPES,
FOLLOW_TYPES_in_assertionAxiom527);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_TYPES.add(TYPES14);
}
}
break;
}
pushFollow(FOLLOW_expression_in_assertionAxiom530);
expression15 = expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(expression15.getTree());
}
// AST REWRITE
// elements: i, expression
// token labels:
// rule labels: retval, i
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_i = new RewriteRuleSubtreeStream(
adaptor, "rule i", i != null ? i.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 93:47: -> ^( TYPE_ASSERTION ^( EXPRESSION expression
// ) ^( EXPRESSION $i) )
{
// MOWLParser.g:93:50: ^( TYPE_ASSERTION ^(
// EXPRESSION expression ) ^( EXPRESSION $i) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(TYPE_ASSERTION, "TYPE_ASSERTION"),
root_1);
// MOWLParser.g:93:67: ^( EXPRESSION expression
// )
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_expression.nextTree());
adaptor.addChild(root_1, root_2);
}
// MOWLParser.g:93:92: ^( 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.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 2:
// MOWLParser.g:94:7: subject= atomic propertyExpression value
{
pushFollow(FOLLOW_atomic_in_assertionAxiom561);
subject = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(subject.getTree());
}
pushFollow(FOLLOW_propertyExpression_in_assertionAxiom563);
propertyExpression16 = propertyExpression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_propertyExpression.add(propertyExpression16.getTree());
}
pushFollow(FOLLOW_value_in_assertionAxiom566);
value17 = value();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_value.add(value17.getTree());
}
// AST REWRITE
// elements: value, propertyExpression, subject
// token labels:
// rule labels: retval, subject
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_subject = new RewriteRuleSubtreeStream(
adaptor, "rule subject", subject != null ? subject.tree
: null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 94:50: -> ^( ROLE_ASSERTION ^( EXPRESSION $subject)
// ^( EXPRESSION propertyExpression ) ^( EXPRESSION
// value ) )
{
// MOWLParser.g:94:53: ^( ROLE_ASSERTION ^(
// EXPRESSION $subject) ^( EXPRESSION
// propertyExpression ) ^( EXPRESSION value ) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(ROLE_ASSERTION, "ROLE_ASSERTION"),
root_1);
// MOWLParser.g:94:70: ^( EXPRESSION $subject)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_subject.nextTree());
adaptor.addChild(root_1, root_2);
}
// MOWLParser.g:94:93: ^( EXPRESSION
// propertyExpression )
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2,
stream_propertyExpression.nextTree());
adaptor.addChild(root_1, root_2);
}
// MOWLParser.g:94:126: ^( EXPRESSION value )
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_value.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 3:
// MOWLParser.g:96:5: NOT assertionAxiom
{
NOT18 = (Token) match(input, NOT, FOLLOW_NOT_in_assertionAxiom600);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_NOT.add(NOT18);
}
pushFollow(FOLLOW_assertionAxiom_in_assertionAxiom602);
assertionAxiom19 = assertionAxiom();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_assertionAxiom.add(assertionAxiom19.getTree());
}
// AST REWRITE
// elements: assertionAxiom
// 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();
// 96:24: -> ^( NEGATED_ASSERTION assertionAxiom )
{
// MOWLParser.g:96:27: ^( NEGATED_ASSERTION
// assertionAxiom )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(NEGATED_ASSERTION,
"NEGATED_ASSERTION"), root_1);
adaptor.addChild(root_1, stream_assertionAxiom.nextTree());
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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "assertionAxiom"
public static class binaryAxiom_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "binaryAxiom"
// MOWLParser.g:101:1: binaryAxiom options {backtrack=true; } : (lhs=
// expression SUBCLASS_OF superClass= expression -> ^( SUB_CLASS_AXIOM ^(
// EXPRESSION $lhs) ^( EXPRESSION $superClass) ) | lhs= expression
// EQUIVALENT_TO rhs= expression -> ^( EQUIVALENT_TO_AXIOM ^( EXPRESSION
// $lhs) ^( EXPRESSION $rhs) ) | lhs= expression DISJOINT_WITH disjoint=
// expression -> ^( DISJOINT_WITH_AXIOM ^( EXPRESSION $lhs) ^( EXPRESSION
// $disjoint) ) | lhs= expression SUB_PROPERTY_OF superProperty=
// propertyExpression -> ^( SUB_PROPERTY_AXIOM ^( EXPRESSION $lhs) ^(
// EXPRESSION $superProperty) ) | lhsID= atomic INVERSE_OF rhsAtomic= atomic
// -> ^( INVERSE_OF ^( EXPRESSION $lhsID) ^( EXPRESSION $rhsAtomic) ) |
// lhsID= atomic SAME_AS rhsID= atomic -> ^( SAME_AS_AXIOM ^( EXPRESSION
// $lhsID) ^( EXPRESSION $rhsID) ) | lhsID= atomic DIFFERENT_FROM rhsID=
// atomic -> ^( DIFFERENT_FROM_AXIOM ^( EXPRESSION $lhsID) ^( EXPRESSION
// $rhsID) ) | lhsID= atomic DOMAIN expression -> ^( DOMAIN ^( EXPRESSION
// $lhsID) ^( EXPRESSION expression ) ) | lhsID= atomic RANGE expression ->
// ^( RANGE ^( EXPRESSION $lhsID) ^( EXPRESSION expression ) ) );
public final ManchesterOWLSyntax_MOWLParser.binaryAxiom_return binaryAxiom()
throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.binaryAxiom_return retval = new ManchesterOWLSyntax_MOWLParser.binaryAxiom_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token SUBCLASS_OF20 = null;
Token EQUIVALENT_TO21 = null;
Token DISJOINT_WITH22 = null;
Token SUB_PROPERTY_OF23 = null;
Token INVERSE_OF24 = null;
Token SAME_AS25 = null;
Token DIFFERENT_FROM26 = null;
Token DOMAIN27 = null;
Token RANGE29 = null;
ManchesterOWLSyntax_MOWLParser.expression_return lhs = null;
ManchesterOWLSyntax_MOWLParser.expression_return superClass = null;
ManchesterOWLSyntax_MOWLParser.expression_return rhs = null;
ManchesterOWLSyntax_MOWLParser.expression_return disjoint = null;
ManchesterOWLSyntax_MOWLParser.propertyExpression_return superProperty = null;
ManchesterOWLSyntax_MOWLParser.atomic_return lhsID = null;
ManchesterOWLSyntax_MOWLParser.atomic_return rhsAtomic = null;
ManchesterOWLSyntax_MOWLParser.atomic_return rhsID = null;
ManchesterOWLSyntax_MOWLParser.expression_return expression28 = null;
ManchesterOWLSyntax_MOWLParser.expression_return expression30 = null;
RewriteRuleTokenStream stream_RANGE = new RewriteRuleTokenStream(adaptor,
"token RANGE");
RewriteRuleTokenStream stream_SAME_AS = new RewriteRuleTokenStream(adaptor,
"token SAME_AS");
RewriteRuleTokenStream stream_DISJOINT_WITH = new RewriteRuleTokenStream(adaptor,
"token DISJOINT_WITH");
RewriteRuleTokenStream stream_INVERSE_OF = new RewriteRuleTokenStream(adaptor,
"token INVERSE_OF");
RewriteRuleTokenStream stream_DIFFERENT_FROM = new RewriteRuleTokenStream(
adaptor, "token DIFFERENT_FROM");
RewriteRuleTokenStream stream_EQUIVALENT_TO = new RewriteRuleTokenStream(adaptor,
"token EQUIVALENT_TO");
RewriteRuleTokenStream stream_SUBCLASS_OF = new RewriteRuleTokenStream(adaptor,
"token SUBCLASS_OF");
RewriteRuleTokenStream stream_DOMAIN = new RewriteRuleTokenStream(adaptor,
"token DOMAIN");
RewriteRuleTokenStream stream_SUB_PROPERTY_OF = new RewriteRuleTokenStream(
adaptor, "token SUB_PROPERTY_OF");
RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(
adaptor, "rule expression");
RewriteRuleSubtreeStream stream_propertyExpression = new RewriteRuleSubtreeStream(
adaptor, "rule propertyExpression");
RewriteRuleSubtreeStream stream_atomic = new RewriteRuleSubtreeStream(adaptor,
"rule atomic");
try {
// MOWLParser.g:102:26: (lhs= expression SUBCLASS_OF superClass=
// expression -> ^( SUB_CLASS_AXIOM ^( EXPRESSION $lhs) ^(
// EXPRESSION $superClass) ) | lhs= expression EQUIVALENT_TO rhs=
// expression -> ^( EQUIVALENT_TO_AXIOM ^( EXPRESSION $lhs) ^(
// EXPRESSION $rhs) ) | lhs= expression DISJOINT_WITH disjoint=
// expression -> ^( DISJOINT_WITH_AXIOM ^( EXPRESSION $lhs) ^(
// EXPRESSION $disjoint) ) | lhs= expression SUB_PROPERTY_OF
// superProperty= propertyExpression -> ^( SUB_PROPERTY_AXIOM ^(
// EXPRESSION $lhs) ^( EXPRESSION $superProperty) ) | lhsID= atomic
// INVERSE_OF rhsAtomic= atomic -> ^( INVERSE_OF ^( EXPRESSION
// $lhsID) ^( EXPRESSION $rhsAtomic) ) | lhsID= atomic SAME_AS
// rhsID= atomic -> ^( SAME_AS_AXIOM ^( EXPRESSION $lhsID) ^(
// EXPRESSION $rhsID) ) | lhsID= atomic DIFFERENT_FROM rhsID= atomic
// -> ^( DIFFERENT_FROM_AXIOM ^( EXPRESSION $lhsID) ^( EXPRESSION
// $rhsID) ) | lhsID= atomic DOMAIN expression -> ^( DOMAIN ^(
// EXPRESSION $lhsID) ^( EXPRESSION expression ) ) | lhsID= atomic
// RANGE expression -> ^( RANGE ^( EXPRESSION $lhsID) ^( EXPRESSION
// expression ) ) )
int alt6 = 9;
alt6 = dfa6.predict(input);
switch (alt6) {
case 1:
// MOWLParser.g:103:2: lhs= expression SUBCLASS_OF superClass=
// expression
{
pushFollow(FOLLOW_expression_in_binaryAxiom639);
lhs = expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(lhs.getTree());
}
SUBCLASS_OF20 = (Token) match(input, SUBCLASS_OF,
FOLLOW_SUBCLASS_OF_in_binaryAxiom641);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_SUBCLASS_OF.add(SUBCLASS_OF20);
}
pushFollow(FOLLOW_expression_in_binaryAxiom648);
superClass = expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(superClass.getTree());
}
// AST REWRITE
// elements: superClass, lhs
// token labels:
// rule labels: retval, superClass, lhs
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_superClass = new RewriteRuleSubtreeStream(
adaptor, "rule superClass",
superClass != null ? superClass.tree : null);
RewriteRuleSubtreeStream stream_lhs = new RewriteRuleSubtreeStream(
adaptor, "rule lhs", lhs != null ? lhs.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 103:57: -> ^( SUB_CLASS_AXIOM ^( EXPRESSION $lhs) ^(
// EXPRESSION $superClass) )
{
// MOWLParser.g:103:60: ^( SUB_CLASS_AXIOM ^(
// EXPRESSION $lhs) ^( EXPRESSION $superClass) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(SUB_CLASS_AXIOM,
"SUB_CLASS_AXIOM"), root_1);
// MOWLParser.g:103:79: ^( 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);
}
// MOWLParser.g:103:98: ^( EXPRESSION
// $superClass)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"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 2:
// MOWLParser.g:104:11: lhs= expression EQUIVALENT_TO rhs=
// expression
{
pushFollow(FOLLOW_expression_in_binaryAxiom686);
lhs = expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(lhs.getTree());
}
EQUIVALENT_TO21 = (Token) match(input, EQUIVALENT_TO,
FOLLOW_EQUIVALENT_TO_in_binaryAxiom688);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_EQUIVALENT_TO.add(EQUIVALENT_TO21);
}
pushFollow(FOLLOW_expression_in_binaryAxiom694);
rhs = expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(rhs.getTree());
}
// AST REWRITE
// elements: rhs, lhs
// token labels:
// rule labels: retval, rhs, lhs
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_rhs = new RewriteRuleSubtreeStream(
adaptor, "rule rhs", rhs != null ? rhs.tree : null);
RewriteRuleSubtreeStream stream_lhs = new RewriteRuleSubtreeStream(
adaptor, "rule lhs", lhs != null ? lhs.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 104:60: -> ^( EQUIVALENT_TO_AXIOM ^( EXPRESSION $lhs)
// ^( EXPRESSION $rhs) )
{
// MOWLParser.g:104:63: ^( EQUIVALENT_TO_AXIOM ^(
// EXPRESSION $lhs) ^( EXPRESSION $rhs) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(EQUIVALENT_TO_AXIOM,
"EQUIVALENT_TO_AXIOM"), root_1);
// MOWLParser.g:104: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);
}
// MOWLParser.g:104:104: ^( EXPRESSION $rhs)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"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 3:
// MOWLParser.g:105:11: lhs= expression DISJOINT_WITH disjoint=
// expression
{
pushFollow(FOLLOW_expression_in_binaryAxiom731);
lhs = expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(lhs.getTree());
}
DISJOINT_WITH22 = (Token) match(input, DISJOINT_WITH,
FOLLOW_DISJOINT_WITH_in_binaryAxiom733);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_DISJOINT_WITH.add(DISJOINT_WITH22);
}
pushFollow(FOLLOW_expression_in_binaryAxiom739);
disjoint = expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(disjoint.getTree());
}
// AST REWRITE
// elements: disjoint, lhs
// token labels:
// rule labels: retval, disjoint, lhs
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_disjoint = new RewriteRuleSubtreeStream(
adaptor, "rule disjoint",
disjoint != null ? disjoint.tree : null);
RewriteRuleSubtreeStream stream_lhs = new RewriteRuleSubtreeStream(
adaptor, "rule lhs", lhs != null ? lhs.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 105:65: -> ^( DISJOINT_WITH_AXIOM ^( EXPRESSION $lhs)
// ^( EXPRESSION $disjoint) )
{
// MOWLParser.g:105:68: ^( DISJOINT_WITH_AXIOM ^(
// EXPRESSION $lhs) ^( EXPRESSION $disjoint) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(DISJOINT_WITH_AXIOM,
"DISJOINT_WITH_AXIOM"), root_1);
// MOWLParser.g:105: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);
}
// MOWLParser.g:105:109: ^( EXPRESSION
// $disjoint)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"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 4:
// MOWLParser.g:106:11: lhs= expression SUB_PROPERTY_OF
// superProperty= propertyExpression
{
pushFollow(FOLLOW_expression_in_binaryAxiom776);
lhs = expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(lhs.getTree());
}
SUB_PROPERTY_OF23 = (Token) match(input, SUB_PROPERTY_OF,
FOLLOW_SUB_PROPERTY_OF_in_binaryAxiom778);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_SUB_PROPERTY_OF.add(SUB_PROPERTY_OF23);
}
pushFollow(FOLLOW_propertyExpression_in_binaryAxiom784);
superProperty = propertyExpression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_propertyExpression.add(superProperty.getTree());
}
// AST REWRITE
// elements: lhs, superProperty
// token labels:
// rule labels: retval, superProperty, lhs
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_superProperty = new RewriteRuleSubtreeStream(
adaptor, "rule superProperty",
superProperty != null ? superProperty.tree : null);
RewriteRuleSubtreeStream stream_lhs = new RewriteRuleSubtreeStream(
adaptor, "rule lhs", lhs != null ? lhs.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 106:80: -> ^( SUB_PROPERTY_AXIOM ^( EXPRESSION $lhs)
// ^( EXPRESSION $superProperty) )
{
// MOWLParser.g:106:83: ^( SUB_PROPERTY_AXIOM ^(
// EXPRESSION $lhs) ^( EXPRESSION $superProperty) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(SUB_PROPERTY_AXIOM,
"SUB_PROPERTY_AXIOM"), root_1);
// MOWLParser.g:106:104: ^( 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);
}
// MOWLParser.g:106:123: ^( EXPRESSION
// $superProperty)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2,
stream_superProperty.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 5:
// MOWLParser.g:107:11: lhsID= atomic INVERSE_OF rhsAtomic=
// atomic
{
pushFollow(FOLLOW_atomic_in_binaryAxiom821);
lhsID = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(lhsID.getTree());
}
INVERSE_OF24 = (Token) match(input, INVERSE_OF,
FOLLOW_INVERSE_OF_in_binaryAxiom823);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_INVERSE_OF.add(INVERSE_OF24);
}
pushFollow(FOLLOW_atomic_in_binaryAxiom829);
rhsAtomic = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(rhsAtomic.getTree());
}
// AST REWRITE
// elements: INVERSE_OF, rhsAtomic, lhsID
// token labels:
// rule labels: lhsID, retval, rhsAtomic
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhsID = new RewriteRuleSubtreeStream(
adaptor, "rule lhsID", lhsID != null ? lhsID.tree : null);
RewriteRuleSubtreeStream stream_rhsAtomic = new RewriteRuleSubtreeStream(
adaptor, "rule rhsAtomic",
rhsAtomic != null ? rhsAtomic.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 107:57: -> ^( INVERSE_OF ^( EXPRESSION $lhsID) ^(
// EXPRESSION $rhsAtomic) )
{
// MOWLParser.g:107:60: ^( INVERSE_OF ^( EXPRESSION
// $lhsID) ^( EXPRESSION $rhsAtomic) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_INVERSE_OF.nextNode(), root_1);
// MOWLParser.g:107:73: ^( 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.nextTree());
adaptor.addChild(root_1, root_2);
}
// MOWLParser.g:107:94: ^( EXPRESSION
// $rhsAtomic)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_rhsAtomic.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 6:
// MOWLParser.g:108:3: lhsID= atomic SAME_AS rhsID= atomic
{
pushFollow(FOLLOW_atomic_in_binaryAxiom860);
lhsID = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(lhsID.getTree());
}
SAME_AS25 = (Token) match(input, SAME_AS,
FOLLOW_SAME_AS_in_binaryAxiom862);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_SAME_AS.add(SAME_AS25);
}
pushFollow(FOLLOW_atomic_in_binaryAxiom869);
rhsID = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(rhsID.getTree());
}
// AST REWRITE
// elements: rhsID, lhsID
// token labels:
// rule labels: lhsID, retval, rhsID
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhsID = new RewriteRuleSubtreeStream(
adaptor, "rule lhsID", lhsID != null ? lhsID.tree : null);
RewriteRuleSubtreeStream stream_rhsID = new RewriteRuleSubtreeStream(
adaptor, "rule rhsID", rhsID != null ? rhsID.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 108:43: -> ^( SAME_AS_AXIOM ^( EXPRESSION $lhsID) ^(
// EXPRESSION $rhsID) )
{
// MOWLParser.g:108:46: ^( SAME_AS_AXIOM ^(
// EXPRESSION $lhsID) ^( EXPRESSION $rhsID) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(SAME_AS_AXIOM, "SAME_AS_AXIOM"),
root_1);
// MOWLParser.g:108:62: ^( 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.nextTree());
adaptor.addChild(root_1, root_2);
}
// MOWLParser.g:108:84: ^( EXPRESSION $rhsID)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_rhsID.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 7:
// MOWLParser.g:109:11: lhsID= atomic DIFFERENT_FROM rhsID=
// atomic
{
pushFollow(FOLLOW_atomic_in_binaryAxiom907);
lhsID = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(lhsID.getTree());
}
DIFFERENT_FROM26 = (Token) match(input, DIFFERENT_FROM,
FOLLOW_DIFFERENT_FROM_in_binaryAxiom909);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_DIFFERENT_FROM.add(DIFFERENT_FROM26);
}
pushFollow(FOLLOW_atomic_in_binaryAxiom916);
rhsID = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(rhsID.getTree());
}
// AST REWRITE
// elements: rhsID, lhsID
// token labels:
// rule labels: lhsID, retval, rhsID
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhsID = new RewriteRuleSubtreeStream(
adaptor, "rule lhsID", lhsID != null ? lhsID.tree : null);
RewriteRuleSubtreeStream stream_rhsID = new RewriteRuleSubtreeStream(
adaptor, "rule rhsID", rhsID != null ? rhsID.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 109:58: -> ^( DIFFERENT_FROM_AXIOM ^( EXPRESSION
// $lhsID) ^( EXPRESSION $rhsID) )
{
// MOWLParser.g:109:61: ^( DIFFERENT_FROM_AXIOM ^(
// EXPRESSION $lhsID) ^( EXPRESSION $rhsID) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(DIFFERENT_FROM_AXIOM,
"DIFFERENT_FROM_AXIOM"), root_1);
// MOWLParser.g:109:84: ^( 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.nextTree());
adaptor.addChild(root_1, root_2);
}
// MOWLParser.g:109:105: ^( EXPRESSION $rhsID)
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_rhsID.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 8:
// MOWLParser.g:110:11: lhsID= atomic DOMAIN expression
{
pushFollow(FOLLOW_atomic_in_binaryAxiom953);
lhsID = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(lhsID.getTree());
}
DOMAIN27 = (Token) match(input, DOMAIN,
FOLLOW_DOMAIN_in_binaryAxiom956);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_DOMAIN.add(DOMAIN27);
}
pushFollow(FOLLOW_expression_in_binaryAxiom958);
expression28 = expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(expression28.getTree());
}
// AST REWRITE
// elements: DOMAIN, expression, lhsID
// token labels:
// rule labels: lhsID, retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhsID = new RewriteRuleSubtreeStream(
adaptor, "rule lhsID", lhsID != null ? lhsID.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 110:46: -> ^( DOMAIN ^( EXPRESSION $lhsID) ^(
// EXPRESSION expression ) )
{
// MOWLParser.g:110:49: ^( DOMAIN ^( EXPRESSION
// $lhsID) ^( EXPRESSION expression ) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_DOMAIN.nextNode(), root_1);
// MOWLParser.g:110:58: ^( 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.nextTree());
adaptor.addChild(root_1, root_2);
}
// MOWLParser.g:110:79: ^( EXPRESSION expression
// )
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_expression.nextTree());
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 9:
// MOWLParser.g:111:11: lhsID= atomic RANGE expression
{
pushFollow(FOLLOW_atomic_in_binaryAxiom994);
lhsID = atomic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_atomic.add(lhsID.getTree());
}
RANGE29 = (Token) match(input, RANGE, FOLLOW_RANGE_in_binaryAxiom996);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_RANGE.add(RANGE29);
}
pushFollow(FOLLOW_expression_in_binaryAxiom998);
expression30 = expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(expression30.getTree());
}
// AST REWRITE
// elements: lhsID, expression, RANGE
// token labels:
// rule labels: lhsID, retval
// token list labels:
// rule list labels:
// wildcard labels:
if (state.backtracking == 0) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_lhsID = new RewriteRuleSubtreeStream(
adaptor, "rule lhsID", lhsID != null ? lhsID.tree : null);
root_0 = (ManchesterOWLSyntaxTree) adaptor.nil();
// 111:44: -> ^( RANGE ^( EXPRESSION $lhsID) ^(
// EXPRESSION expression ) )
{
// MOWLParser.g:111:47: ^( RANGE ^( EXPRESSION
// $lhsID) ^( EXPRESSION expression ) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_RANGE.nextNode(), root_1);
// MOWLParser.g:111:55: ^( 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.nextTree());
adaptor.addChild(root_1, root_2);
}
// MOWLParser.g:111:76: ^( EXPRESSION expression
// )
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(EXPRESSION,
"EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_expression.nextTree());
adaptor.addChild(root_1, root_2);
}
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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "binaryAxiom"
public static class unaryAxiom_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "unaryAxiom"
// MOWLParser.g:115:1: unaryAxiom : unaryCharacteristic unary -> ^(
// UNARY_AXIOM unaryCharacteristic ^( EXPRESSION unary ) ) ;
public final ManchesterOWLSyntax_MOWLParser.unaryAxiom_return unaryAxiom()
throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.unaryAxiom_return retval = new ManchesterOWLSyntax_MOWLParser.unaryAxiom_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
ManchesterOWLSyntax_MOWLParser.unaryCharacteristic_return unaryCharacteristic31 = null;
ManchesterOWLSyntax_MOWLParser.unary_return unary32 = null;
RewriteRuleSubtreeStream stream_unary = new RewriteRuleSubtreeStream(adaptor,
"rule unary");
RewriteRuleSubtreeStream stream_unaryCharacteristic = new RewriteRuleSubtreeStream(
adaptor, "rule unaryCharacteristic");
try {
// MOWLParser.g:115:13: ( unaryCharacteristic unary -> ^(
// UNARY_AXIOM unaryCharacteristic ^( EXPRESSION unary ) ) )
// MOWLParser.g:116:4: unaryCharacteristic unary
{
pushFollow(FOLLOW_unaryCharacteristic_in_unaryAxiom1072);
unaryCharacteristic31 = unaryCharacteristic();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_unaryCharacteristic.add(unaryCharacteristic31.getTree());
}
pushFollow(FOLLOW_unary_in_unaryAxiom1076);
unary32 = unary();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_unary.add(unary32.getTree());
}
// AST REWRITE
// elements: unary, 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();
// 116:32: -> ^( UNARY_AXIOM unaryCharacteristic ^(
// EXPRESSION unary ) )
{
// MOWLParser.g:116:35: ^( UNARY_AXIOM
// unaryCharacteristic ^( EXPRESSION unary ) )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(UNARY_AXIOM, "UNARY_AXIOM"), root_1);
adaptor.addChild(root_1,
stream_unaryCharacteristic.nextTree());
// MOWLParser.g:116:69: ^( EXPRESSION unary )
{
ManchesterOWLSyntaxTree root_2 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_2 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(EXPRESSION, "EXPRESSION"), root_2);
adaptor.addChild(root_2, stream_unary.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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "unaryAxiom"
public static class unaryCharacteristic_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "unaryCharacteristic"
// MOWLParser.g:119:1: unaryCharacteristic : ( FUNCTIONAL -> ^( FUNCTIONAL )
// | INVERSE_FUNCTIONAL -> ^( INVERSE_FUNCTIONAL ) | SYMMETRIC -> ^(
// SYMMETRIC ) | ANTI_SYMMETRIC -> ^( ANTI_SYMMETRIC ) | REFLEXIVE -> ^(
// REFLEXIVE ) | IRREFLEXIVE -> ^( IRREFLEXIVE ) | TRANSITIVE -> ^(
// TRANSITIVE ) );
public final ManchesterOWLSyntax_MOWLParser.unaryCharacteristic_return
unaryCharacteristic() throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.unaryCharacteristic_return retval = new ManchesterOWLSyntax_MOWLParser.unaryCharacteristic_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token FUNCTIONAL33 = null;
Token INVERSE_FUNCTIONAL34 = null;
Token SYMMETRIC35 = null;
Token ANTI_SYMMETRIC36 = null;
Token REFLEXIVE37 = null;
Token IRREFLEXIVE38 = null;
Token TRANSITIVE39 = null;
RewriteRuleTokenStream stream_REFLEXIVE = new RewriteRuleTokenStream(adaptor,
"token REFLEXIVE");
RewriteRuleTokenStream stream_SYMMETRIC = new RewriteRuleTokenStream(adaptor,
"token SYMMETRIC");
RewriteRuleTokenStream stream_FUNCTIONAL = new RewriteRuleTokenStream(adaptor,
"token FUNCTIONAL");
RewriteRuleTokenStream stream_TRANSITIVE = new RewriteRuleTokenStream(adaptor,
"token TRANSITIVE");
RewriteRuleTokenStream stream_ANTI_SYMMETRIC = new RewriteRuleTokenStream(
adaptor, "token ANTI_SYMMETRIC");
RewriteRuleTokenStream stream_INVERSE_FUNCTIONAL = new RewriteRuleTokenStream(
adaptor, "token INVERSE_FUNCTIONAL");
RewriteRuleTokenStream stream_IRREFLEXIVE = new RewriteRuleTokenStream(adaptor,
"token IRREFLEXIVE");
try {
// MOWLParser.g:119:21: ( FUNCTIONAL -> ^( FUNCTIONAL ) |
// INVERSE_FUNCTIONAL -> ^( INVERSE_FUNCTIONAL ) | SYMMETRIC -> ^(
// SYMMETRIC ) | ANTI_SYMMETRIC -> ^( ANTI_SYMMETRIC ) | REFLEXIVE
// -> ^( REFLEXIVE ) | IRREFLEXIVE -> ^( IRREFLEXIVE ) | TRANSITIVE
// -> ^( TRANSITIVE ) )
int alt7 = 7;
switch (input.LA(1)) {
case FUNCTIONAL: {
alt7 = 1;
}
break;
case INVERSE_FUNCTIONAL: {
alt7 = 2;
}
break;
case SYMMETRIC: {
alt7 = 3;
}
break;
case ANTI_SYMMETRIC: {
alt7 = 4;
}
break;
case REFLEXIVE: {
alt7 = 5;
}
break;
case IRREFLEXIVE: {
alt7 = 6;
}
break;
case TRANSITIVE: {
alt7 = 7;
}
break;
default:
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 7, 0, input);
throw nvae;
}
switch (alt7) {
case 1:
// MOWLParser.g:120:5: FUNCTIONAL
{
FUNCTIONAL33 = (Token) match(input, FUNCTIONAL,
FOLLOW_FUNCTIONAL_in_unaryCharacteristic1121);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_FUNCTIONAL.add(FUNCTIONAL33);
}
// AST REWRITE
// elements: FUNCTIONAL
// 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();
// 120:16: -> ^( FUNCTIONAL )
{
// MOWLParser.g:120:19: ^( FUNCTIONAL )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_FUNCTIONAL.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 2:
// MOWLParser.g:121:7: INVERSE_FUNCTIONAL
{
INVERSE_FUNCTIONAL34 = (Token) match(input, INVERSE_FUNCTIONAL,
FOLLOW_INVERSE_FUNCTIONAL_in_unaryCharacteristic1135);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_INVERSE_FUNCTIONAL.add(INVERSE_FUNCTIONAL34);
}
// AST REWRITE
// elements: INVERSE_FUNCTIONAL
// 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();
// 121:26: -> ^( INVERSE_FUNCTIONAL )
{
// MOWLParser.g:121:29: ^( INVERSE_FUNCTIONAL )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_INVERSE_FUNCTIONAL.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 3:
// MOWLParser.g:122:7: SYMMETRIC
{
SYMMETRIC35 = (Token) match(input, SYMMETRIC,
FOLLOW_SYMMETRIC_in_unaryCharacteristic1149);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_SYMMETRIC.add(SYMMETRIC35);
}
// AST REWRITE
// elements: SYMMETRIC
// 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();
// 122:17: -> ^( SYMMETRIC )
{
// MOWLParser.g:122:20: ^( SYMMETRIC )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_SYMMETRIC.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 4:
// MOWLParser.g:123:7: ANTI_SYMMETRIC
{
ANTI_SYMMETRIC36 = (Token) match(input, ANTI_SYMMETRIC,
FOLLOW_ANTI_SYMMETRIC_in_unaryCharacteristic1163);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_ANTI_SYMMETRIC.add(ANTI_SYMMETRIC36);
}
// AST REWRITE
// elements: ANTI_SYMMETRIC
// 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();
// 123:22: -> ^( ANTI_SYMMETRIC )
{
// MOWLParser.g:123:25: ^( ANTI_SYMMETRIC )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_ANTI_SYMMETRIC.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 5:
// MOWLParser.g:124:7: REFLEXIVE
{
REFLEXIVE37 = (Token) match(input, REFLEXIVE,
FOLLOW_REFLEXIVE_in_unaryCharacteristic1177);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_REFLEXIVE.add(REFLEXIVE37);
}
// AST REWRITE
// elements: REFLEXIVE
// 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();
// 124:17: -> ^( REFLEXIVE )
{
// MOWLParser.g:124:20: ^( REFLEXIVE )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_REFLEXIVE.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 6:
// MOWLParser.g:125:7: IRREFLEXIVE
{
IRREFLEXIVE38 = (Token) match(input, IRREFLEXIVE,
FOLLOW_IRREFLEXIVE_in_unaryCharacteristic1191);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_IRREFLEXIVE.add(IRREFLEXIVE38);
}
// AST REWRITE
// elements: IRREFLEXIVE
// 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();
// 125:19: -> ^( IRREFLEXIVE )
{
// MOWLParser.g:125:22: ^( IRREFLEXIVE )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_IRREFLEXIVE.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 7:
// MOWLParser.g:126:7: TRANSITIVE
{
TRANSITIVE39 = (Token) match(input, TRANSITIVE,
FOLLOW_TRANSITIVE_in_unaryCharacteristic1205);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_TRANSITIVE.add(TRANSITIVE39);
}
// AST REWRITE
// elements: TRANSITIVE
// 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();
// 126:18: -> ^( TRANSITIVE )
{
// MOWLParser.g:126:21: ^( TRANSITIVE )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
stream_TRANSITIVE.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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "unaryCharacteristic"
public static class expression_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "expression"
// MOWLParser.g:129:1: expression : ( options {backtrack=true; } :
// disjunction -> ^( disjunction ) | complexPropertyExpression -> ^(
// complexPropertyExpression ) | OPEN_PARENTHESYS expression
// CLOSED_PARENTHESYS -> ^( expression ) ) ;
public final ManchesterOWLSyntax_MOWLParser.expression_return expression()
throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.expression_return retval = new ManchesterOWLSyntax_MOWLParser.expression_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token OPEN_PARENTHESYS42 = null;
Token CLOSED_PARENTHESYS44 = null;
ManchesterOWLSyntax_MOWLParser.disjunction_return disjunction40 = null;
ManchesterOWLSyntax_MOWLParser.complexPropertyExpression_return complexPropertyExpression41 = null;
ManchesterOWLSyntax_MOWLParser.expression_return expression43 = null;
RewriteRuleTokenStream stream_CLOSED_PARENTHESYS = new RewriteRuleTokenStream(
adaptor, "token CLOSED_PARENTHESYS");
RewriteRuleTokenStream stream_OPEN_PARENTHESYS = new RewriteRuleTokenStream(
adaptor, "token OPEN_PARENTHESYS");
RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(
adaptor, "rule expression");
RewriteRuleSubtreeStream stream_disjunction = new RewriteRuleSubtreeStream(
adaptor, "rule disjunction");
RewriteRuleSubtreeStream stream_complexPropertyExpression = new RewriteRuleSubtreeStream(
adaptor, "rule complexPropertyExpression");
try {
// MOWLParser.g:129:11: ( ( options {backtrack=true; } : disjunction
// -> ^( disjunction ) | complexPropertyExpression -> ^(
// complexPropertyExpression ) | OPEN_PARENTHESYS expression
// CLOSED_PARENTHESYS -> ^( expression ) ) )
// MOWLParser.g:130:5: ( options {backtrack=true; } : disjunction ->
// ^( disjunction ) | complexPropertyExpression -> ^(
// complexPropertyExpression ) | OPEN_PARENTHESYS expression
// CLOSED_PARENTHESYS -> ^( expression ) )
{
// MOWLParser.g:130:5: ( options {backtrack=true; } :
// disjunction -> ^( disjunction ) | complexPropertyExpression
// -> ^( complexPropertyExpression ) | OPEN_PARENTHESYS
// expression CLOSED_PARENTHESYS -> ^( expression ) )
int alt8 = 3;
switch (input.LA(1)) {
case OPEN_CURLY_BRACES:
case NOT:
case DBLQUOTE:
case IDENTIFIER:
case ENTITY_REFERENCE: {
alt8 = 1;
}
break;
case INVERSE: {
input.LA(2);
if (synpred17_MOWLParser()) {
alt8 = 1;
} else if (synpred18_MOWLParser()) {
alt8 = 2;
} else {
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 8,
3, input);
throw nvae;
}
}
break;
case OPEN_PARENTHESYS: {
alt8 = 3;
}
break;
default:
if (state.backtracking > 0) {
state.failed = true;
return retval;
}
NoViableAltException nvae = new NoViableAltException("", 8, 0,
input);
throw nvae;
}
switch (alt8) {
case 1:
// MOWLParser.g:132:5: disjunction
{
pushFollow(FOLLOW_disjunction_in_expression1247);
disjunction40 = disjunction();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_disjunction.add(disjunction40.getTree());
}
// AST REWRITE
// elements: disjunction
// 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();
// 132:17: -> ^( disjunction )
{
// MOWLParser.g:132:20: ^( disjunction )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(stream_disjunction.nextNode(),
root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 2:
// MOWLParser.g:133:6: complexPropertyExpression
{
pushFollow(FOLLOW_complexPropertyExpression_in_expression1260);
complexPropertyExpression41 = complexPropertyExpression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_complexPropertyExpression
.add(complexPropertyExpression41.getTree());
}
// AST REWRITE
// elements: complexPropertyExpression
// 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();
// 133:32: -> ^( complexPropertyExpression )
{
// MOWLParser.g:133:35: ^(
// complexPropertyExpression )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(stream_complexPropertyExpression
.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
}
break;
case 3:
// MOWLParser.g:134:6: OPEN_PARENTHESYS expression
// CLOSED_PARENTHESYS
{
OPEN_PARENTHESYS42 = (Token) match(input, OPEN_PARENTHESYS,
FOLLOW_OPEN_PARENTHESYS_in_expression1273);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_OPEN_PARENTHESYS.add(OPEN_PARENTHESYS42);
}
pushFollow(FOLLOW_expression_in_expression1275);
expression43 = expression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_expression.add(expression43.getTree());
}
CLOSED_PARENTHESYS44 = (Token) match(input, CLOSED_PARENTHESYS,
FOLLOW_CLOSED_PARENTHESYS_in_expression1277);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_CLOSED_PARENTHESYS.add(CLOSED_PARENTHESYS44);
}
// AST REWRITE
// elements: expression
// 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();
// 134:53: -> ^( expression )
{
// MOWLParser.g:134:56: ^( expression )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(stream_expression.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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "expression"
public static class disjunction_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "disjunction"
// MOWLParser.g:141:1: disjunction : conjunction ( OR conjunction )* -> ^(
// DISJUNCTION ( conjunction )+ ) ;
public final ManchesterOWLSyntax_MOWLParser.disjunction_return disjunction()
throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.disjunction_return retval = new ManchesterOWLSyntax_MOWLParser.disjunction_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token OR46 = null;
ManchesterOWLSyntax_MOWLParser.conjunction_return conjunction45 = null;
ManchesterOWLSyntax_MOWLParser.conjunction_return conjunction47 = null;
RewriteRuleTokenStream stream_OR = new RewriteRuleTokenStream(adaptor, "token OR");
RewriteRuleSubtreeStream stream_conjunction = new RewriteRuleSubtreeStream(
adaptor, "rule conjunction");
try {
// MOWLParser.g:142:2: ( conjunction ( OR conjunction )* -> ^(
// DISJUNCTION ( conjunction )+ ) )
// MOWLParser.g:143:3: conjunction ( OR conjunction )*
{
pushFollow(FOLLOW_conjunction_in_disjunction1307);
conjunction45 = conjunction();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_conjunction.add(conjunction45.getTree());
}
// MOWLParser.g:143:15: ( OR conjunction )*
loop9: do {
int alt9 = 2;
int LA9_0 = input.LA(1);
if (LA9_0 == OR) {
alt9 = 1;
}
switch (alt9) {
case 1:
// MOWLParser.g:143:16: OR conjunction
{
OR46 = (Token) match(input, OR, FOLLOW_OR_in_disjunction1310);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_OR.add(OR46);
}
pushFollow(FOLLOW_conjunction_in_disjunction1312);
conjunction47 = conjunction();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_conjunction.add(conjunction47.getTree());
}
}
break;
default:
break loop9;
}
} while (true);
// AST REWRITE
// elements: conjunction
// 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();
// 143:33: -> ^( DISJUNCTION ( conjunction )+ )
{
// MOWLParser.g:143:36: ^( DISJUNCTION ( conjunction )+
// )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(DISJUNCTION, "DISJUNCTION"), root_1);
if (!stream_conjunction.hasNext()) {
throw new RewriteEarlyExitException();
}
while (stream_conjunction.hasNext()) {
adaptor.addChild(root_1, stream_conjunction.nextTree());
}
stream_conjunction.reset();
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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "disjunction"
public static class conjunction_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "conjunction"
// MOWLParser.g:146:1: conjunction : unary ( AND unary )* -> ^( CONJUNCTION
// ( unary )+ ) ;
public final ManchesterOWLSyntax_MOWLParser.conjunction_return conjunction()
throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.conjunction_return retval = new ManchesterOWLSyntax_MOWLParser.conjunction_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token AND49 = null;
ManchesterOWLSyntax_MOWLParser.unary_return unary48 = null;
ManchesterOWLSyntax_MOWLParser.unary_return unary50 = null;
RewriteRuleTokenStream stream_AND = new RewriteRuleTokenStream(adaptor,
"token AND");
RewriteRuleSubtreeStream stream_unary = new RewriteRuleSubtreeStream(adaptor,
"rule unary");
try {
// MOWLParser.g:146:13: ( unary ( AND unary )* -> ^( CONJUNCTION (
// unary )+ ) )
// MOWLParser.g:147:5: unary ( AND unary )*
{
pushFollow(FOLLOW_unary_in_conjunction1339);
unary48 = unary();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_unary.add(unary48.getTree());
}
// MOWLParser.g:147:11: ( AND unary )*
loop10: do {
int alt10 = 2;
int LA10_0 = input.LA(1);
if (LA10_0 == AND) {
alt10 = 1;
}
switch (alt10) {
case 1:
// MOWLParser.g:147:12: AND unary
{
AND49 = (Token) match(input, AND,
FOLLOW_AND_in_conjunction1342);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_AND.add(AND49);
}
pushFollow(FOLLOW_unary_in_conjunction1344);
unary50 = unary();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_unary.add(unary50.getTree());
}
}
break;
default:
break loop10;
}
} while (true);
// AST REWRITE
// elements: unary
// 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();
// 147:24: -> ^( CONJUNCTION ( unary )+ )
{
// MOWLParser.g:147:27: ^( CONJUNCTION ( unary )+ )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor.becomeRoot(
adaptor.create(CONJUNCTION, "CONJUNCTION"), root_1);
if (!stream_unary.hasNext()) {
throw new RewriteEarlyExitException();
}
while (stream_unary.hasNext()) {
adaptor.addChild(root_1, stream_unary.nextTree());
}
stream_unary.reset();
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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "conjunction"
public static class complexPropertyExpression_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "complexPropertyExpression"
// MOWLParser.g:150:1: complexPropertyExpression : INVERSE OPEN_PARENTHESYS
// propertyExpression CLOSED_PARENTHESYS -> ^(
// INVERSE_OBJECT_PROPERTY_EXPRESSION propertyExpression ) ;
public final ManchesterOWLSyntax_MOWLParser.complexPropertyExpression_return
complexPropertyExpression() throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.complexPropertyExpression_return retval = new ManchesterOWLSyntax_MOWLParser.complexPropertyExpression_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token INVERSE51 = null;
Token OPEN_PARENTHESYS52 = null;
Token CLOSED_PARENTHESYS54 = null;
ManchesterOWLSyntax_MOWLParser.propertyExpression_return propertyExpression53 = null;
RewriteRuleTokenStream stream_INVERSE = new RewriteRuleTokenStream(adaptor,
"token INVERSE");
RewriteRuleTokenStream stream_CLOSED_PARENTHESYS = new RewriteRuleTokenStream(
adaptor, "token CLOSED_PARENTHESYS");
RewriteRuleTokenStream stream_OPEN_PARENTHESYS = new RewriteRuleTokenStream(
adaptor, "token OPEN_PARENTHESYS");
RewriteRuleSubtreeStream stream_propertyExpression = new RewriteRuleSubtreeStream(
adaptor, "rule propertyExpression");
try {
// MOWLParser.g:150:26: ( INVERSE OPEN_PARENTHESYS
// propertyExpression CLOSED_PARENTHESYS -> ^(
// INVERSE_OBJECT_PROPERTY_EXPRESSION propertyExpression ) )
// MOWLParser.g:151:2: INVERSE OPEN_PARENTHESYS propertyExpression
// CLOSED_PARENTHESYS
{
INVERSE51 = (Token) match(input, INVERSE,
FOLLOW_INVERSE_in_complexPropertyExpression1365);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_INVERSE.add(INVERSE51);
}
OPEN_PARENTHESYS52 = (Token) match(input, OPEN_PARENTHESYS,
FOLLOW_OPEN_PARENTHESYS_in_complexPropertyExpression1367);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_OPEN_PARENTHESYS.add(OPEN_PARENTHESYS52);
}
pushFollow(FOLLOW_propertyExpression_in_complexPropertyExpression1369);
propertyExpression53 = propertyExpression();
state._fsp--;
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_propertyExpression.add(propertyExpression53.getTree());
}
CLOSED_PARENTHESYS54 = (Token) match(input, CLOSED_PARENTHESYS,
FOLLOW_CLOSED_PARENTHESYS_in_complexPropertyExpression1371);
if (state.failed) {
return retval;
}
if (state.backtracking == 0) {
stream_CLOSED_PARENTHESYS.add(CLOSED_PARENTHESYS54);
}
// AST REWRITE
// elements: propertyExpression
// 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();
// 151:65: -> ^( INVERSE_OBJECT_PROPERTY_EXPRESSION
// propertyExpression )
{
// MOWLParser.g:151:68: ^(
// INVERSE_OBJECT_PROPERTY_EXPRESSION propertyExpression
// )
{
ManchesterOWLSyntaxTree root_1 = (ManchesterOWLSyntaxTree) adaptor
.nil();
root_1 = (ManchesterOWLSyntaxTree) adaptor
.becomeRoot(adaptor.create(
INVERSE_OBJECT_PROPERTY_EXPRESSION,
"INVERSE_OBJECT_PROPERTY_EXPRESSION"), root_1);
adaptor.addChild(root_1, stream_propertyExpression.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 e) {
throw e;
} catch (RewriteEmptyStreamException e) {
throw e;
} finally {}
return retval;
}
// $ANTLR end "complexPropertyExpression"
public static class unary_return extends ParserRuleReturnScope {
ManchesterOWLSyntaxTree tree;
@Override
public Object getTree() {
return tree;
}
}
// $ANTLR start "unary"
// MOWLParser.g:155:1: unary options {backtrack=true; } : (head=
// propertyExpression ( COMPOSITION rest+= propertyExpression )+ -> ^(
// PROPERTY_CHAIN $head $rest) | NOT OPEN_PARENTHESYS expression
// CLOSED_PARENTHESYS -> ^( NEGATED_EXPRESSION expression ) | NOT atomic ->
// ^( NEGATED_EXPRESSION atomic ) | qualifiedRestriction -> ^(
// qualifiedRestriction ) | dataRange | constant | atomic );
public final ManchesterOWLSyntax_MOWLParser.unary_return unary()
throws RecognitionException {
ManchesterOWLSyntax_MOWLParser.unary_return retval = new ManchesterOWLSyntax_MOWLParser.unary_return();
retval.start = input.LT(1);
ManchesterOWLSyntaxTree root_0 = null;
Token COMPOSITION55 = null;
Token NOT56 = null;
Token OPEN_PARENTHESYS57 = null;
Token CLOSED_PARENTHESYS59 = null;
Token NOT60 = null;
List© 2015 - 2025 Weber Informatics LLC | Privacy Policy