dl2-core.adl-parser.1.3.3.source-code.adlParser Maven / Gradle / Ivy
// Generated from adl.g4 by ANTLR 4.5.1
package org.openehr.adl.antlr4.generated;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class adlParser extends Parser {
static { RuntimeMetaData.checkVersion("4.5.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, RANGE=6, EQUALS=7, PAREN_OPEN=8,
PAREN_CLOSE=9, BRACKET_OPEN=10, BRACKET_CLOSE=11, GT=12, LT=13, PERIOD=14,
COMMA=15, COLON=16, SEMICOLON=17, MINUS=18, UNDERSCORE=19, PIPE=20, ASTERISK=21,
CARET=22, AMP=23, EXCLAMATION=24, QUESTION=25, OTHER_SYMBOL=26, DATE_TIME_PATTERN=27,
TIME_PATTERN=28, DATE_PATTERN=29, DURATION=30, ISO_DATE_TIME=31, ISO_DATE=32,
ISO_TIME=33, AT_CODE_VALUE=34, LANGUAGE=35, ARCHETYPE=36, TEMPLATE=37,
TEMPLATE_OVERLAY=38, CONCEPT=39, DESCRIPTION=40, SPECIALISE=41, DEFINITION=42,
MATCHES=43, USE_NODE=44, OCCURRENCES=45, INCLUDE=46, EXCLUDE=47, ALLOW_ARCHETYPE=48,
CARDINALITY=49, UNORDERED=50, ORDERED=51, UNIQUE=52, EXISTENCE=53, BEFORE=54,
AFTER=55, USE_ARCHETYPE=56, USE_TEMPLATE=57, CLOSED=58, ANNOTATIONS=59,
TERMINOLOGY=60, TRUE=61, FALSE=62, TYPE_IDENTIFIER=63, NAME_IDENTIFIER=64,
INTEGER=65, STRING=66, UNICODE_CHAR=67, LINE_COMMENT=68, WS=69;
public static final int
RULE_adl = 0, RULE_alphanumeric = 1, RULE_archetypeId = 2, RULE_headerTag = 3,
RULE_header = 4, RULE_archetypePropertyList = 5, RULE_archetypeProperty = 6,
RULE_archetypePropertyValue = 7, RULE_archetypePropertyValuePart = 8,
RULE_atCode = 9, RULE_specializeTag = 10, RULE_specialize = 11, RULE_concept = 12,
RULE_language = 13, RULE_description = 14, RULE_definition = 15, RULE_typeConstraint = 16,
RULE_complexObjectConstraint = 17, RULE_occurrences = 18, RULE_occurrenceRange = 19,
RULE_attributeListMatcher = 20, RULE_orderConstraint = 21, RULE_multiValueConstraint = 22,
RULE_valueConstraint = 23, RULE_ordinalConstraint = 24, RULE_ordinalItemList = 25,
RULE_ordinalItem = 26, RULE_primitiveValueConstraint = 27, RULE_terminologyCodeConstraint = 28,
RULE_archetypeSlotConstraint = 29, RULE_archetypeSlotValueConstraint = 30,
RULE_archetypeSlotSingleConstraint = 31, RULE_archetypeReferenceConstraint = 32,
RULE_stringConstraint = 33, RULE_numberConstraint = 34, RULE_dateTimeConstraint = 35,
RULE_dateConstraint = 36, RULE_timeConstraint = 37, RULE_durationConstraint = 38,
RULE_codeIdentifierList = 39, RULE_regularExpression = 40, RULE_regularExpressionInner1 = 41,
RULE_regularExpressionInner2 = 42, RULE_attributeConstraint = 43, RULE_tupleAttributeIdentifier = 44,
RULE_tupleChildConstraints = 45, RULE_tupleChildConstraint = 46, RULE_attributeIdentifier = 47,
RULE_existence = 48, RULE_cardinality = 49, RULE_numberIntervalConstraint = 50,
RULE_dateIntervalConstraint = 51, RULE_timeIntervalConstraint = 52, RULE_dateTimeIntervalConstraint = 53,
RULE_durationIntervalConstraint = 54, RULE_terminology = 55, RULE_annotations = 56,
RULE_odinValue = 57, RULE_odinObjectValue = 58, RULE_odinObjectProperty = 59,
RULE_odinCodePhraseValueList = 60, RULE_odinCodePhraseValue = 61, RULE_odinMapValue = 62,
RULE_odinMapValueEntry = 63, RULE_openStringList = 64, RULE_stringList = 65,
RULE_numberList = 66, RULE_booleanList = 67, RULE_codeIdentifier = 68,
RULE_codeIdentifierPart = 69, RULE_identifier = 70, RULE_bool = 71, RULE_nameIdentifier = 72,
RULE_typeIdentifierWithGenerics = 73, RULE_typeIdentifier = 74, RULE_keyword = 75,
RULE_pathSegment = 76, RULE_rmPath = 77, RULE_url = 78, RULE_numberOrStar = 79,
RULE_number = 80;
public static final String[] ruleNames = {
"adl", "alphanumeric", "archetypeId", "headerTag", "header", "archetypePropertyList",
"archetypeProperty", "archetypePropertyValue", "archetypePropertyValuePart",
"atCode", "specializeTag", "specialize", "concept", "language", "description",
"definition", "typeConstraint", "complexObjectConstraint", "occurrences",
"occurrenceRange", "attributeListMatcher", "orderConstraint", "multiValueConstraint",
"valueConstraint", "ordinalConstraint", "ordinalItemList", "ordinalItem",
"primitiveValueConstraint", "terminologyCodeConstraint", "archetypeSlotConstraint",
"archetypeSlotValueConstraint", "archetypeSlotSingleConstraint", "archetypeReferenceConstraint",
"stringConstraint", "numberConstraint", "dateTimeConstraint", "dateConstraint",
"timeConstraint", "durationConstraint", "codeIdentifierList", "regularExpression",
"regularExpressionInner1", "regularExpressionInner2", "attributeConstraint",
"tupleAttributeIdentifier", "tupleChildConstraints", "tupleChildConstraint",
"attributeIdentifier", "existence", "cardinality", "numberIntervalConstraint",
"dateIntervalConstraint", "timeIntervalConstraint", "dateTimeIntervalConstraint",
"durationIntervalConstraint", "terminology", "annotations", "odinValue",
"odinObjectValue", "odinObjectProperty", "odinCodePhraseValueList", "odinCodePhraseValue",
"odinMapValue", "odinMapValueEntry", "openStringList", "stringList", "numberList",
"booleanList", "codeIdentifier", "codeIdentifierPart", "identifier", "bool",
"nameIdentifier", "typeIdentifierWithGenerics", "typeIdentifier", "keyword",
"pathSegment", "rmPath", "url", "numberOrStar", "number"
};
private static final String[] _LITERAL_NAMES = {
null, "'::'", "'{'", "'}'", "'/'", "'...'", "'..'", "'='", "'('", "')'",
"'['", "']'", "'>'", "'<'", "'.'", "','", "':'", "';'", "'-'", "'_'",
"'|'", "'*'", "'^'", "'&'", "'!'", "'?'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, "RANGE", "EQUALS", "PAREN_OPEN", "PAREN_CLOSE",
"BRACKET_OPEN", "BRACKET_CLOSE", "GT", "LT", "PERIOD", "COMMA", "COLON",
"SEMICOLON", "MINUS", "UNDERSCORE", "PIPE", "ASTERISK", "CARET", "AMP",
"EXCLAMATION", "QUESTION", "OTHER_SYMBOL", "DATE_TIME_PATTERN", "TIME_PATTERN",
"DATE_PATTERN", "DURATION", "ISO_DATE_TIME", "ISO_DATE", "ISO_TIME", "AT_CODE_VALUE",
"LANGUAGE", "ARCHETYPE", "TEMPLATE", "TEMPLATE_OVERLAY", "CONCEPT", "DESCRIPTION",
"SPECIALISE", "DEFINITION", "MATCHES", "USE_NODE", "OCCURRENCES", "INCLUDE",
"EXCLUDE", "ALLOW_ARCHETYPE", "CARDINALITY", "UNORDERED", "ORDERED", "UNIQUE",
"EXISTENCE", "BEFORE", "AFTER", "USE_ARCHETYPE", "USE_TEMPLATE", "CLOSED",
"ANNOTATIONS", "TERMINOLOGY", "TRUE", "FALSE", "TYPE_IDENTIFIER", "NAME_IDENTIFIER",
"INTEGER", "STRING", "UNICODE_CHAR", "LINE_COMMENT", "WS"
};
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "adl.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public adlParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class AdlContext extends ParserRuleContext {
public HeaderContext header() {
return getRuleContext(HeaderContext.class,0);
}
public TerminalNode EOF() { return getToken(adlParser.EOF, 0); }
public SpecializeContext specialize() {
return getRuleContext(SpecializeContext.class,0);
}
public ConceptContext concept() {
return getRuleContext(ConceptContext.class,0);
}
public LanguageContext language() {
return getRuleContext(LanguageContext.class,0);
}
public DescriptionContext description() {
return getRuleContext(DescriptionContext.class,0);
}
public DefinitionContext definition() {
return getRuleContext(DefinitionContext.class,0);
}
public TerminologyContext terminology() {
return getRuleContext(TerminologyContext.class,0);
}
public AnnotationsContext annotations() {
return getRuleContext(AnnotationsContext.class,0);
}
public AdlContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_adl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterAdl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitAdl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitAdl(this);
else return visitor.visitChildren(this);
}
}
public final AdlContext adl() throws RecognitionException {
AdlContext _localctx = new AdlContext(_ctx, getState());
enterRule(_localctx, 0, RULE_adl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(162);
header();
setState(164);
_la = _input.LA(1);
if (_la==SPECIALISE) {
{
setState(163);
specialize();
}
}
setState(167);
_la = _input.LA(1);
if (_la==CONCEPT) {
{
setState(166);
concept();
}
}
setState(170);
_la = _input.LA(1);
if (_la==LANGUAGE) {
{
setState(169);
language();
}
}
setState(173);
_la = _input.LA(1);
if (_la==DESCRIPTION) {
{
setState(172);
description();
}
}
setState(176);
_la = _input.LA(1);
if (_la==DEFINITION) {
{
setState(175);
definition();
}
}
setState(179);
_la = _input.LA(1);
if (_la==TERMINOLOGY) {
{
setState(178);
terminology();
}
}
setState(182);
_la = _input.LA(1);
if (_la==ANNOTATIONS) {
{
setState(181);
annotations();
}
}
setState(184);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AlphanumericContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode INTEGER() { return getToken(adlParser.INTEGER, 0); }
public AlphanumericContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alphanumeric; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterAlphanumeric(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitAlphanumeric(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitAlphanumeric(this);
else return visitor.visitChildren(this);
}
}
public final AlphanumericContext alphanumeric() throws RecognitionException {
AlphanumericContext _localctx = new AlphanumericContext(_ctx, getState());
enterRule(_localctx, 2, RULE_alphanumeric);
try {
enterOuterAlt(_localctx, 1);
{
setState(188);
switch (_input.LA(1)) {
case AT_CODE_VALUE:
case LANGUAGE:
case ARCHETYPE:
case TEMPLATE:
case TEMPLATE_OVERLAY:
case CONCEPT:
case DESCRIPTION:
case SPECIALISE:
case DEFINITION:
case MATCHES:
case USE_NODE:
case OCCURRENCES:
case CARDINALITY:
case UNORDERED:
case ORDERED:
case UNIQUE:
case EXISTENCE:
case CLOSED:
case ANNOTATIONS:
case TERMINOLOGY:
case TYPE_IDENTIFIER:
case NAME_IDENTIFIER:
{
setState(186);
identifier();
}
break;
case INTEGER:
{
setState(187);
match(INTEGER);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArchetypeIdContext extends ParserRuleContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List alphanumeric() {
return getRuleContexts(AlphanumericContext.class);
}
public AlphanumericContext alphanumeric(int i) {
return getRuleContext(AlphanumericContext.class,i);
}
public List INTEGER() { return getTokens(adlParser.INTEGER); }
public TerminalNode INTEGER(int i) {
return getToken(adlParser.INTEGER, i);
}
public ArchetypeIdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_archetypeId; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterArchetypeId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitArchetypeId(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitArchetypeId(this);
else return visitor.visitChildren(this);
}
}
public final ArchetypeIdContext archetypeId() throws RecognitionException {
ArchetypeIdContext _localctx = new ArchetypeIdContext(_ctx, getState());
enterRule(_localctx, 4, RULE_archetypeId);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(200);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
setState(190);
identifier();
setState(195);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==PERIOD) {
{
{
setState(191);
match(PERIOD);
setState(192);
identifier();
}
}
setState(197);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(198);
match(T__0);
}
break;
}
setState(202);
identifier();
setState(205);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
setState(205);
switch (_input.LA(1)) {
case MINUS:
{
setState(203);
match(MINUS);
}
break;
case AT_CODE_VALUE:
case LANGUAGE:
case ARCHETYPE:
case TEMPLATE:
case TEMPLATE_OVERLAY:
case CONCEPT:
case DESCRIPTION:
case SPECIALISE:
case DEFINITION:
case MATCHES:
case USE_NODE:
case OCCURRENCES:
case CARDINALITY:
case UNORDERED:
case ORDERED:
case UNIQUE:
case EXISTENCE:
case CLOSED:
case ANNOTATIONS:
case TERMINOLOGY:
case TYPE_IDENTIFIER:
case NAME_IDENTIFIER:
{
setState(204);
identifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(207);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (MINUS - 18)) | (1L << (AT_CODE_VALUE - 18)) | (1L << (LANGUAGE - 18)) | (1L << (ARCHETYPE - 18)) | (1L << (TEMPLATE - 18)) | (1L << (TEMPLATE_OVERLAY - 18)) | (1L << (CONCEPT - 18)) | (1L << (DESCRIPTION - 18)) | (1L << (SPECIALISE - 18)) | (1L << (DEFINITION - 18)) | (1L << (MATCHES - 18)) | (1L << (USE_NODE - 18)) | (1L << (OCCURRENCES - 18)) | (1L << (CARDINALITY - 18)) | (1L << (UNORDERED - 18)) | (1L << (ORDERED - 18)) | (1L << (UNIQUE - 18)) | (1L << (EXISTENCE - 18)) | (1L << (CLOSED - 18)) | (1L << (ANNOTATIONS - 18)) | (1L << (TERMINOLOGY - 18)) | (1L << (TYPE_IDENTIFIER - 18)) | (1L << (NAME_IDENTIFIER - 18)))) != 0) );
setState(209);
match(PERIOD);
setState(212);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
setState(212);
switch (_input.LA(1)) {
case AT_CODE_VALUE:
case LANGUAGE:
case ARCHETYPE:
case TEMPLATE:
case TEMPLATE_OVERLAY:
case CONCEPT:
case DESCRIPTION:
case SPECIALISE:
case DEFINITION:
case MATCHES:
case USE_NODE:
case OCCURRENCES:
case CARDINALITY:
case UNORDERED:
case ORDERED:
case UNIQUE:
case EXISTENCE:
case CLOSED:
case ANNOTATIONS:
case TERMINOLOGY:
case TYPE_IDENTIFIER:
case NAME_IDENTIFIER:
case INTEGER:
{
setState(210);
alphanumeric();
}
break;
case MINUS:
{
setState(211);
match(MINUS);
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(214);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (MINUS - 18)) | (1L << (AT_CODE_VALUE - 18)) | (1L << (LANGUAGE - 18)) | (1L << (ARCHETYPE - 18)) | (1L << (TEMPLATE - 18)) | (1L << (TEMPLATE_OVERLAY - 18)) | (1L << (CONCEPT - 18)) | (1L << (DESCRIPTION - 18)) | (1L << (SPECIALISE - 18)) | (1L << (DEFINITION - 18)) | (1L << (MATCHES - 18)) | (1L << (USE_NODE - 18)) | (1L << (OCCURRENCES - 18)) | (1L << (CARDINALITY - 18)) | (1L << (UNORDERED - 18)) | (1L << (ORDERED - 18)) | (1L << (UNIQUE - 18)) | (1L << (EXISTENCE - 18)) | (1L << (CLOSED - 18)) | (1L << (ANNOTATIONS - 18)) | (1L << (TERMINOLOGY - 18)) | (1L << (TYPE_IDENTIFIER - 18)) | (1L << (NAME_IDENTIFIER - 18)) | (1L << (INTEGER - 18)))) != 0) );
setState(216);
match(PERIOD);
setState(217);
identifier();
setState(222);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==PERIOD) {
{
{
setState(218);
match(PERIOD);
setState(219);
match(INTEGER);
}
}
setState(224);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(227);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(225);
match(MINUS);
setState(226);
identifier();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HeaderTagContext extends ParserRuleContext {
public TerminalNode ARCHETYPE() { return getToken(adlParser.ARCHETYPE, 0); }
public TerminalNode TEMPLATE() { return getToken(adlParser.TEMPLATE, 0); }
public TerminalNode TEMPLATE_OVERLAY() { return getToken(adlParser.TEMPLATE_OVERLAY, 0); }
public HeaderTagContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_headerTag; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterHeaderTag(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitHeaderTag(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitHeaderTag(this);
else return visitor.visitChildren(this);
}
}
public final HeaderTagContext headerTag() throws RecognitionException {
HeaderTagContext _localctx = new HeaderTagContext(_ctx, getState());
enterRule(_localctx, 6, RULE_headerTag);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(229);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ARCHETYPE) | (1L << TEMPLATE) | (1L << TEMPLATE_OVERLAY))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HeaderContext extends ParserRuleContext {
public HeaderTagContext headerTag() {
return getRuleContext(HeaderTagContext.class,0);
}
public ArchetypeIdContext archetypeId() {
return getRuleContext(ArchetypeIdContext.class,0);
}
public ArchetypePropertyListContext archetypePropertyList() {
return getRuleContext(ArchetypePropertyListContext.class,0);
}
public HeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_header; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitHeader(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitHeader(this);
else return visitor.visitChildren(this);
}
}
public final HeaderContext header() throws RecognitionException {
HeaderContext _localctx = new HeaderContext(_ctx, getState());
enterRule(_localctx, 8, RULE_header);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(231);
headerTag();
setState(236);
_la = _input.LA(1);
if (_la==PAREN_OPEN) {
{
setState(232);
match(PAREN_OPEN);
setState(233);
archetypePropertyList();
setState(234);
match(PAREN_CLOSE);
}
}
setState(238);
archetypeId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArchetypePropertyListContext extends ParserRuleContext {
public List archetypeProperty() {
return getRuleContexts(ArchetypePropertyContext.class);
}
public ArchetypePropertyContext archetypeProperty(int i) {
return getRuleContext(ArchetypePropertyContext.class,i);
}
public ArchetypePropertyListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_archetypePropertyList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterArchetypePropertyList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitArchetypePropertyList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitArchetypePropertyList(this);
else return visitor.visitChildren(this);
}
}
public final ArchetypePropertyListContext archetypePropertyList() throws RecognitionException {
ArchetypePropertyListContext _localctx = new ArchetypePropertyListContext(_ctx, getState());
enterRule(_localctx, 10, RULE_archetypePropertyList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(240);
archetypeProperty();
setState(245);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SEMICOLON) {
{
{
setState(241);
match(SEMICOLON);
setState(242);
archetypeProperty();
}
}
setState(247);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArchetypePropertyContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ArchetypePropertyValueContext archetypePropertyValue() {
return getRuleContext(ArchetypePropertyValueContext.class,0);
}
public ArchetypePropertyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_archetypeProperty; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterArchetypeProperty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitArchetypeProperty(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitArchetypeProperty(this);
else return visitor.visitChildren(this);
}
}
public final ArchetypePropertyContext archetypeProperty() throws RecognitionException {
ArchetypePropertyContext _localctx = new ArchetypePropertyContext(_ctx, getState());
enterRule(_localctx, 12, RULE_archetypeProperty);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(248);
identifier();
setState(251);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(249);
match(EQUALS);
setState(250);
archetypePropertyValue();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArchetypePropertyValueContext extends ParserRuleContext {
public List archetypePropertyValuePart() {
return getRuleContexts(ArchetypePropertyValuePartContext.class);
}
public ArchetypePropertyValuePartContext archetypePropertyValuePart(int i) {
return getRuleContext(ArchetypePropertyValuePartContext.class,i);
}
public ArchetypePropertyValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_archetypePropertyValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterArchetypePropertyValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitArchetypePropertyValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitArchetypePropertyValue(this);
else return visitor.visitChildren(this);
}
}
public final ArchetypePropertyValueContext archetypePropertyValue() throws RecognitionException {
ArchetypePropertyValueContext _localctx = new ArchetypePropertyValueContext(_ctx, getState());
enterRule(_localctx, 14, RULE_archetypePropertyValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(256);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << RANGE) | (1L << EQUALS) | (1L << PAREN_OPEN) | (1L << BRACKET_OPEN) | (1L << BRACKET_CLOSE) | (1L << GT) | (1L << LT) | (1L << PERIOD) | (1L << COMMA) | (1L << COLON) | (1L << MINUS) | (1L << UNDERSCORE) | (1L << PIPE) | (1L << ASTERISK) | (1L << CARET) | (1L << AMP) | (1L << EXCLAMATION) | (1L << QUESTION) | (1L << OTHER_SYMBOL) | (1L << DATE_TIME_PATTERN) | (1L << TIME_PATTERN) | (1L << DATE_PATTERN) | (1L << DURATION) | (1L << ISO_DATE_TIME) | (1L << ISO_DATE) | (1L << ISO_TIME) | (1L << AT_CODE_VALUE) | (1L << LANGUAGE) | (1L << ARCHETYPE) | (1L << TEMPLATE) | (1L << TEMPLATE_OVERLAY) | (1L << CONCEPT) | (1L << DESCRIPTION) | (1L << SPECIALISE) | (1L << DEFINITION) | (1L << MATCHES) | (1L << USE_NODE) | (1L << OCCURRENCES) | (1L << INCLUDE) | (1L << EXCLUDE) | (1L << ALLOW_ARCHETYPE) | (1L << CARDINALITY) | (1L << UNORDERED) | (1L << ORDERED) | (1L << UNIQUE) | (1L << EXISTENCE) | (1L << BEFORE) | (1L << AFTER) | (1L << USE_ARCHETYPE) | (1L << USE_TEMPLATE) | (1L << CLOSED) | (1L << ANNOTATIONS) | (1L << TERMINOLOGY) | (1L << TRUE) | (1L << FALSE) | (1L << TYPE_IDENTIFIER))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAME_IDENTIFIER - 64)) | (1L << (INTEGER - 64)) | (1L << (STRING - 64)) | (1L << (UNICODE_CHAR - 64)) | (1L << (LINE_COMMENT - 64)) | (1L << (WS - 64)))) != 0)) {
{
{
setState(253);
archetypePropertyValuePart();
}
}
setState(258);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArchetypePropertyValuePartContext extends ParserRuleContext {
public ArchetypePropertyValuePartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_archetypePropertyValuePart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterArchetypePropertyValuePart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitArchetypePropertyValuePart(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitArchetypePropertyValuePart(this);
else return visitor.visitChildren(this);
}
}
public final ArchetypePropertyValuePartContext archetypePropertyValuePart() throws RecognitionException {
ArchetypePropertyValuePartContext _localctx = new ArchetypePropertyValuePartContext(_ctx, getState());
enterRule(_localctx, 16, RULE_archetypePropertyValuePart);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(259);
_la = _input.LA(1);
if ( _la <= 0 || (_la==PAREN_CLOSE || _la==SEMICOLON) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AtCodeContext extends ParserRuleContext {
public TerminalNode AT_CODE_VALUE() { return getToken(adlParser.AT_CODE_VALUE, 0); }
public AtCodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atCode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterAtCode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitAtCode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitAtCode(this);
else return visitor.visitChildren(this);
}
}
public final AtCodeContext atCode() throws RecognitionException {
AtCodeContext _localctx = new AtCodeContext(_ctx, getState());
enterRule(_localctx, 18, RULE_atCode);
try {
enterOuterAlt(_localctx, 1);
{
setState(261);
match(BRACKET_OPEN);
setState(262);
match(AT_CODE_VALUE);
setState(263);
match(BRACKET_CLOSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SpecializeTagContext extends ParserRuleContext {
public TerminalNode SPECIALISE() { return getToken(adlParser.SPECIALISE, 0); }
public SpecializeTagContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_specializeTag; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterSpecializeTag(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitSpecializeTag(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitSpecializeTag(this);
else return visitor.visitChildren(this);
}
}
public final SpecializeTagContext specializeTag() throws RecognitionException {
SpecializeTagContext _localctx = new SpecializeTagContext(_ctx, getState());
enterRule(_localctx, 20, RULE_specializeTag);
try {
enterOuterAlt(_localctx, 1);
{
setState(265);
match(SPECIALISE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SpecializeContext extends ParserRuleContext {
public SpecializeTagContext specializeTag() {
return getRuleContext(SpecializeTagContext.class,0);
}
public ArchetypeIdContext archetypeId() {
return getRuleContext(ArchetypeIdContext.class,0);
}
public SpecializeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_specialize; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterSpecialize(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitSpecialize(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitSpecialize(this);
else return visitor.visitChildren(this);
}
}
public final SpecializeContext specialize() throws RecognitionException {
SpecializeContext _localctx = new SpecializeContext(_ctx, getState());
enterRule(_localctx, 22, RULE_specialize);
try {
enterOuterAlt(_localctx, 1);
{
setState(267);
specializeTag();
setState(268);
archetypeId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConceptContext extends ParserRuleContext {
public TerminalNode CONCEPT() { return getToken(adlParser.CONCEPT, 0); }
public AtCodeContext atCode() {
return getRuleContext(AtCodeContext.class,0);
}
public ConceptContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_concept; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterConcept(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitConcept(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitConcept(this);
else return visitor.visitChildren(this);
}
}
public final ConceptContext concept() throws RecognitionException {
ConceptContext _localctx = new ConceptContext(_ctx, getState());
enterRule(_localctx, 24, RULE_concept);
try {
enterOuterAlt(_localctx, 1);
{
setState(270);
match(CONCEPT);
setState(271);
atCode();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LanguageContext extends ParserRuleContext {
public TerminalNode LANGUAGE() { return getToken(adlParser.LANGUAGE, 0); }
public OdinObjectValueContext odinObjectValue() {
return getRuleContext(OdinObjectValueContext.class,0);
}
public LanguageContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_language; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterLanguage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitLanguage(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitLanguage(this);
else return visitor.visitChildren(this);
}
}
public final LanguageContext language() throws RecognitionException {
LanguageContext _localctx = new LanguageContext(_ctx, getState());
enterRule(_localctx, 26, RULE_language);
try {
enterOuterAlt(_localctx, 1);
{
setState(273);
match(LANGUAGE);
setState(274);
odinObjectValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DescriptionContext extends ParserRuleContext {
public TerminalNode DESCRIPTION() { return getToken(adlParser.DESCRIPTION, 0); }
public OdinObjectValueContext odinObjectValue() {
return getRuleContext(OdinObjectValueContext.class,0);
}
public DescriptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_description; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterDescription(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitDescription(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitDescription(this);
else return visitor.visitChildren(this);
}
}
public final DescriptionContext description() throws RecognitionException {
DescriptionContext _localctx = new DescriptionContext(_ctx, getState());
enterRule(_localctx, 28, RULE_description);
try {
enterOuterAlt(_localctx, 1);
{
setState(276);
match(DESCRIPTION);
setState(277);
odinObjectValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefinitionContext extends ParserRuleContext {
public TerminalNode DEFINITION() { return getToken(adlParser.DEFINITION, 0); }
public ComplexObjectConstraintContext complexObjectConstraint() {
return getRuleContext(ComplexObjectConstraintContext.class,0);
}
public DefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_definition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitDefinition(this);
else return visitor.visitChildren(this);
}
}
public final DefinitionContext definition() throws RecognitionException {
DefinitionContext _localctx = new DefinitionContext(_ctx, getState());
enterRule(_localctx, 30, RULE_definition);
try {
enterOuterAlt(_localctx, 1);
{
setState(279);
match(DEFINITION);
setState(280);
complexObjectConstraint();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeConstraintContext extends ParserRuleContext {
public OdinValueContext odinValue() {
return getRuleContext(OdinValueContext.class,0);
}
public OrderConstraintContext orderConstraint() {
return getRuleContext(OrderConstraintContext.class,0);
}
public ComplexObjectConstraintContext complexObjectConstraint() {
return getRuleContext(ComplexObjectConstraintContext.class,0);
}
public TerminalNode USE_NODE() { return getToken(adlParser.USE_NODE, 0); }
public TypeIdentifierWithGenericsContext typeIdentifierWithGenerics() {
return getRuleContext(TypeIdentifierWithGenericsContext.class,0);
}
public RmPathContext rmPath() {
return getRuleContext(RmPathContext.class,0);
}
public AtCodeContext atCode() {
return getRuleContext(AtCodeContext.class,0);
}
public OccurrencesContext occurrences() {
return getRuleContext(OccurrencesContext.class,0);
}
public ArchetypeSlotConstraintContext archetypeSlotConstraint() {
return getRuleContext(ArchetypeSlotConstraintContext.class,0);
}
public ArchetypeReferenceConstraintContext archetypeReferenceConstraint() {
return getRuleContext(ArchetypeReferenceConstraintContext.class,0);
}
public TypeConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterTypeConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitTypeConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitTypeConstraint(this);
else return visitor.visitChildren(this);
}
}
public final TypeConstraintContext typeConstraint() throws RecognitionException {
TypeConstraintContext _localctx = new TypeConstraintContext(_ctx, getState());
enterRule(_localctx, 32, RULE_typeConstraint);
int _la;
try {
setState(311);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(283);
_la = _input.LA(1);
if (_la==BEFORE || _la==AFTER) {
{
setState(282);
orderConstraint();
}
}
setState(285);
odinValue();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(287);
_la = _input.LA(1);
if (_la==BEFORE || _la==AFTER) {
{
setState(286);
orderConstraint();
}
}
setState(289);
complexObjectConstraint();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(291);
_la = _input.LA(1);
if (_la==BEFORE || _la==AFTER) {
{
setState(290);
orderConstraint();
}
}
setState(293);
match(USE_NODE);
setState(294);
typeIdentifierWithGenerics();
setState(296);
_la = _input.LA(1);
if (_la==BRACKET_OPEN) {
{
setState(295);
atCode();
}
}
setState(299);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(298);
occurrences();
}
break;
}
setState(301);
rmPath();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(304);
_la = _input.LA(1);
if (_la==BEFORE || _la==AFTER) {
{
setState(303);
orderConstraint();
}
}
setState(306);
archetypeSlotConstraint();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(308);
_la = _input.LA(1);
if (_la==BEFORE || _la==AFTER) {
{
setState(307);
orderConstraint();
}
}
setState(310);
archetypeReferenceConstraint();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ComplexObjectConstraintContext extends ParserRuleContext {
public TypeIdentifierWithGenericsContext typeIdentifierWithGenerics() {
return getRuleContext(TypeIdentifierWithGenericsContext.class,0);
}
public AtCodeContext atCode() {
return getRuleContext(AtCodeContext.class,0);
}
public OccurrencesContext occurrences() {
return getRuleContext(OccurrencesContext.class,0);
}
public AttributeListMatcherContext attributeListMatcher() {
return getRuleContext(AttributeListMatcherContext.class,0);
}
public ComplexObjectConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_complexObjectConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterComplexObjectConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitComplexObjectConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitComplexObjectConstraint(this);
else return visitor.visitChildren(this);
}
}
public final ComplexObjectConstraintContext complexObjectConstraint() throws RecognitionException {
ComplexObjectConstraintContext _localctx = new ComplexObjectConstraintContext(_ctx, getState());
enterRule(_localctx, 34, RULE_complexObjectConstraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(313);
typeIdentifierWithGenerics();
setState(315);
switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
case 1:
{
setState(314);
atCode();
}
break;
}
setState(318);
_la = _input.LA(1);
if (_la==OCCURRENCES) {
{
setState(317);
occurrences();
}
}
setState(321);
_la = _input.LA(1);
if (_la==MATCHES) {
{
setState(320);
attributeListMatcher();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OccurrencesContext extends ParserRuleContext {
public TerminalNode OCCURRENCES() { return getToken(adlParser.OCCURRENCES, 0); }
public TerminalNode MATCHES() { return getToken(adlParser.MATCHES, 0); }
public OccurrenceRangeContext occurrenceRange() {
return getRuleContext(OccurrenceRangeContext.class,0);
}
public OccurrencesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_occurrences; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOccurrences(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOccurrences(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOccurrences(this);
else return visitor.visitChildren(this);
}
}
public final OccurrencesContext occurrences() throws RecognitionException {
OccurrencesContext _localctx = new OccurrencesContext(_ctx, getState());
enterRule(_localctx, 36, RULE_occurrences);
try {
enterOuterAlt(_localctx, 1);
{
setState(323);
match(OCCURRENCES);
setState(324);
match(MATCHES);
setState(325);
match(T__1);
setState(326);
occurrenceRange();
setState(327);
match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OccurrenceRangeContext extends ParserRuleContext {
public Token lower;
public Token upper;
public Token val;
public List INTEGER() { return getTokens(adlParser.INTEGER); }
public TerminalNode INTEGER(int i) {
return getToken(adlParser.INTEGER, i);
}
public OccurrenceRangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_occurrenceRange; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOccurrenceRange(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOccurrenceRange(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOccurrenceRange(this);
else return visitor.visitChildren(this);
}
}
public final OccurrenceRangeContext occurrenceRange() throws RecognitionException {
OccurrenceRangeContext _localctx = new OccurrenceRangeContext(_ctx, getState());
enterRule(_localctx, 38, RULE_occurrenceRange);
try {
setState(336);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(329);
((OccurrenceRangeContext)_localctx).lower = match(INTEGER);
setState(330);
match(RANGE);
setState(331);
((OccurrenceRangeContext)_localctx).upper = match(INTEGER);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(332);
((OccurrenceRangeContext)_localctx).lower = match(INTEGER);
setState(333);
match(RANGE);
setState(334);
match(ASTERISK);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(335);
((OccurrenceRangeContext)_localctx).val = match(INTEGER);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeListMatcherContext extends ParserRuleContext {
public TerminalNode MATCHES() { return getToken(adlParser.MATCHES, 0); }
public List attributeConstraint() {
return getRuleContexts(AttributeConstraintContext.class);
}
public AttributeConstraintContext attributeConstraint(int i) {
return getRuleContext(AttributeConstraintContext.class,i);
}
public AttributeListMatcherContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeListMatcher; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterAttributeListMatcher(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitAttributeListMatcher(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitAttributeListMatcher(this);
else return visitor.visitChildren(this);
}
}
public final AttributeListMatcherContext attributeListMatcher() throws RecognitionException {
AttributeListMatcherContext _localctx = new AttributeListMatcherContext(_ctx, getState());
enterRule(_localctx, 40, RULE_attributeListMatcher);
int _la;
try {
setState(351);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(338);
match(MATCHES);
setState(339);
match(T__1);
setState(341);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(340);
attributeConstraint();
}
}
setState(343);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & ((1L << (T__3 - 4)) | (1L << (BRACKET_OPEN - 4)) | (1L << (AT_CODE_VALUE - 4)) | (1L << (LANGUAGE - 4)) | (1L << (ARCHETYPE - 4)) | (1L << (TEMPLATE - 4)) | (1L << (TEMPLATE_OVERLAY - 4)) | (1L << (CONCEPT - 4)) | (1L << (DESCRIPTION - 4)) | (1L << (SPECIALISE - 4)) | (1L << (DEFINITION - 4)) | (1L << (MATCHES - 4)) | (1L << (USE_NODE - 4)) | (1L << (OCCURRENCES - 4)) | (1L << (CARDINALITY - 4)) | (1L << (UNORDERED - 4)) | (1L << (ORDERED - 4)) | (1L << (UNIQUE - 4)) | (1L << (EXISTENCE - 4)) | (1L << (CLOSED - 4)) | (1L << (ANNOTATIONS - 4)) | (1L << (TERMINOLOGY - 4)) | (1L << (NAME_IDENTIFIER - 4)))) != 0) );
setState(345);
match(T__2);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(347);
match(MATCHES);
setState(348);
match(T__1);
setState(349);
match(ASTERISK);
setState(350);
match(T__2);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderConstraintContext extends ParserRuleContext {
public TerminalNode BEFORE() { return getToken(adlParser.BEFORE, 0); }
public AtCodeContext atCode() {
return getRuleContext(AtCodeContext.class,0);
}
public TerminalNode AFTER() { return getToken(adlParser.AFTER, 0); }
public OrderConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOrderConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOrderConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOrderConstraint(this);
else return visitor.visitChildren(this);
}
}
public final OrderConstraintContext orderConstraint() throws RecognitionException {
OrderConstraintContext _localctx = new OrderConstraintContext(_ctx, getState());
enterRule(_localctx, 42, RULE_orderConstraint);
try {
setState(357);
switch (_input.LA(1)) {
case BEFORE:
enterOuterAlt(_localctx, 1);
{
setState(353);
match(BEFORE);
setState(354);
atCode();
}
break;
case AFTER:
enterOuterAlt(_localctx, 2);
{
setState(355);
match(AFTER);
setState(356);
atCode();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultiValueConstraintContext extends ParserRuleContext {
public List valueConstraint() {
return getRuleContexts(ValueConstraintContext.class);
}
public ValueConstraintContext valueConstraint(int i) {
return getRuleContext(ValueConstraintContext.class,i);
}
public MultiValueConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiValueConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterMultiValueConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitMultiValueConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitMultiValueConstraint(this);
else return visitor.visitChildren(this);
}
}
public final MultiValueConstraintContext multiValueConstraint() throws RecognitionException {
MultiValueConstraintContext _localctx = new MultiValueConstraintContext(_ctx, getState());
enterRule(_localctx, 44, RULE_multiValueConstraint);
int _la;
try {
setState(365);
switch (_input.LA(1)) {
case ASTERISK:
enterOuterAlt(_localctx, 1);
{
setState(359);
match(ASTERISK);
}
break;
case T__3:
case PAREN_OPEN:
case BRACKET_OPEN:
case LT:
case MINUS:
case PIPE:
case CARET:
case DATE_TIME_PATTERN:
case TIME_PATTERN:
case DATE_PATTERN:
case DURATION:
case ISO_DATE_TIME:
case ISO_DATE:
case ISO_TIME:
case USE_NODE:
case ALLOW_ARCHETYPE:
case BEFORE:
case AFTER:
case USE_ARCHETYPE:
case USE_TEMPLATE:
case TRUE:
case FALSE:
case TYPE_IDENTIFIER:
case INTEGER:
case STRING:
enterOuterAlt(_localctx, 2);
{
setState(361);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(360);
valueConstraint();
}
}
setState(363);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & ((1L << (T__3 - 4)) | (1L << (PAREN_OPEN - 4)) | (1L << (BRACKET_OPEN - 4)) | (1L << (LT - 4)) | (1L << (MINUS - 4)) | (1L << (PIPE - 4)) | (1L << (CARET - 4)) | (1L << (DATE_TIME_PATTERN - 4)) | (1L << (TIME_PATTERN - 4)) | (1L << (DATE_PATTERN - 4)) | (1L << (DURATION - 4)) | (1L << (ISO_DATE_TIME - 4)) | (1L << (ISO_DATE - 4)) | (1L << (ISO_TIME - 4)) | (1L << (USE_NODE - 4)) | (1L << (ALLOW_ARCHETYPE - 4)) | (1L << (BEFORE - 4)) | (1L << (AFTER - 4)) | (1L << (USE_ARCHETYPE - 4)) | (1L << (USE_TEMPLATE - 4)) | (1L << (TRUE - 4)) | (1L << (FALSE - 4)) | (1L << (TYPE_IDENTIFIER - 4)) | (1L << (INTEGER - 4)) | (1L << (STRING - 4)))) != 0) );
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ValueConstraintContext extends ParserRuleContext {
public TypeConstraintContext typeConstraint() {
return getRuleContext(TypeConstraintContext.class,0);
}
public PrimitiveValueConstraintContext primitiveValueConstraint() {
return getRuleContext(PrimitiveValueConstraintContext.class,0);
}
public OrdinalConstraintContext ordinalConstraint() {
return getRuleContext(OrdinalConstraintContext.class,0);
}
public ValueConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterValueConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitValueConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitValueConstraint(this);
else return visitor.visitChildren(this);
}
}
public final ValueConstraintContext valueConstraint() throws RecognitionException {
ValueConstraintContext _localctx = new ValueConstraintContext(_ctx, getState());
enterRule(_localctx, 46, RULE_valueConstraint);
try {
setState(370);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(367);
typeConstraint();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(368);
primitiveValueConstraint();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(369);
ordinalConstraint();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrdinalConstraintContext extends ParserRuleContext {
public OrdinalItemListContext ordinalItemList() {
return getRuleContext(OrdinalItemListContext.class,0);
}
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public OrdinalConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ordinalConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOrdinalConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOrdinalConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOrdinalConstraint(this);
else return visitor.visitChildren(this);
}
}
public final OrdinalConstraintContext ordinalConstraint() throws RecognitionException {
OrdinalConstraintContext _localctx = new OrdinalConstraintContext(_ctx, getState());
enterRule(_localctx, 48, RULE_ordinalConstraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(372);
ordinalItemList();
setState(375);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(373);
match(SEMICOLON);
setState(374);
number();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrdinalItemListContext extends ParserRuleContext {
public List ordinalItem() {
return getRuleContexts(OrdinalItemContext.class);
}
public OrdinalItemContext ordinalItem(int i) {
return getRuleContext(OrdinalItemContext.class,i);
}
public OrdinalItemListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ordinalItemList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOrdinalItemList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOrdinalItemList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOrdinalItemList(this);
else return visitor.visitChildren(this);
}
}
public final OrdinalItemListContext ordinalItemList() throws RecognitionException {
OrdinalItemListContext _localctx = new OrdinalItemListContext(_ctx, getState());
enterRule(_localctx, 50, RULE_ordinalItemList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(377);
ordinalItem();
setState(382);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(378);
match(COMMA);
setState(379);
ordinalItem();
}
}
setState(384);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrdinalItemContext extends ParserRuleContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public OdinCodePhraseValueContext odinCodePhraseValue() {
return getRuleContext(OdinCodePhraseValueContext.class,0);
}
public OrdinalItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ordinalItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOrdinalItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOrdinalItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOrdinalItem(this);
else return visitor.visitChildren(this);
}
}
public final OrdinalItemContext ordinalItem() throws RecognitionException {
OrdinalItemContext _localctx = new OrdinalItemContext(_ctx, getState());
enterRule(_localctx, 52, RULE_ordinalItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(385);
number();
setState(386);
match(PIPE);
setState(387);
odinCodePhraseValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimitiveValueConstraintContext extends ParserRuleContext {
public Token assumedValue;
public StringConstraintContext stringConstraint() {
return getRuleContext(StringConstraintContext.class,0);
}
public TerminalNode STRING() { return getToken(adlParser.STRING, 0); }
public NumberConstraintContext numberConstraint() {
return getRuleContext(NumberConstraintContext.class,0);
}
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public BooleanListContext booleanList() {
return getRuleContext(BooleanListContext.class,0);
}
public BoolContext bool() {
return getRuleContext(BoolContext.class,0);
}
public DateTimeConstraintContext dateTimeConstraint() {
return getRuleContext(DateTimeConstraintContext.class,0);
}
public TerminalNode ISO_DATE_TIME() { return getToken(adlParser.ISO_DATE_TIME, 0); }
public DateConstraintContext dateConstraint() {
return getRuleContext(DateConstraintContext.class,0);
}
public TerminalNode ISO_DATE() { return getToken(adlParser.ISO_DATE, 0); }
public TimeConstraintContext timeConstraint() {
return getRuleContext(TimeConstraintContext.class,0);
}
public TerminalNode ISO_TIME() { return getToken(adlParser.ISO_TIME, 0); }
public DurationConstraintContext durationConstraint() {
return getRuleContext(DurationConstraintContext.class,0);
}
public TerminalNode DURATION() { return getToken(adlParser.DURATION, 0); }
public TerminologyCodeConstraintContext terminologyCodeConstraint() {
return getRuleContext(TerminologyCodeConstraintContext.class,0);
}
public PrimitiveValueConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primitiveValueConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterPrimitiveValueConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitPrimitiveValueConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitPrimitiveValueConstraint(this);
else return visitor.visitChildren(this);
}
}
public final PrimitiveValueConstraintContext primitiveValueConstraint() throws RecognitionException {
PrimitiveValueConstraintContext _localctx = new PrimitiveValueConstraintContext(_ctx, getState());
enterRule(_localctx, 54, RULE_primitiveValueConstraint);
int _la;
try {
setState(425);
switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(389);
stringConstraint();
setState(392);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(390);
match(SEMICOLON);
setState(391);
((PrimitiveValueConstraintContext)_localctx).assumedValue = match(STRING);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(394);
numberConstraint();
setState(397);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(395);
match(SEMICOLON);
setState(396);
number();
}
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(399);
booleanList();
setState(402);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(400);
match(SEMICOLON);
setState(401);
bool();
}
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(404);
dateTimeConstraint();
setState(407);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(405);
match(SEMICOLON);
setState(406);
match(ISO_DATE_TIME);
}
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(409);
dateConstraint();
setState(412);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(410);
match(SEMICOLON);
setState(411);
match(ISO_DATE);
}
}
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(414);
timeConstraint();
setState(417);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(415);
match(SEMICOLON);
setState(416);
match(ISO_TIME);
}
}
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(419);
durationConstraint();
setState(422);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(420);
match(SEMICOLON);
setState(421);
match(DURATION);
}
}
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(424);
terminologyCodeConstraint();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TerminologyCodeConstraintContext extends ParserRuleContext {
public Token constraint;
public Token assumedValue;
public List AT_CODE_VALUE() { return getTokens(adlParser.AT_CODE_VALUE); }
public TerminalNode AT_CODE_VALUE(int i) {
return getToken(adlParser.AT_CODE_VALUE, i);
}
public TerminologyCodeConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_terminologyCodeConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterTerminologyCodeConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitTerminologyCodeConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitTerminologyCodeConstraint(this);
else return visitor.visitChildren(this);
}
}
public final TerminologyCodeConstraintContext terminologyCodeConstraint() throws RecognitionException {
TerminologyCodeConstraintContext _localctx = new TerminologyCodeConstraintContext(_ctx, getState());
enterRule(_localctx, 56, RULE_terminologyCodeConstraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(427);
match(BRACKET_OPEN);
setState(428);
((TerminologyCodeConstraintContext)_localctx).constraint = match(AT_CODE_VALUE);
setState(431);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(429);
match(SEMICOLON);
setState(430);
((TerminologyCodeConstraintContext)_localctx).assumedValue = match(AT_CODE_VALUE);
}
}
setState(433);
match(BRACKET_CLOSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArchetypeSlotConstraintContext extends ParserRuleContext {
public TerminalNode ALLOW_ARCHETYPE() { return getToken(adlParser.ALLOW_ARCHETYPE, 0); }
public TypeIdentifierWithGenericsContext typeIdentifierWithGenerics() {
return getRuleContext(TypeIdentifierWithGenericsContext.class,0);
}
public AtCodeContext atCode() {
return getRuleContext(AtCodeContext.class,0);
}
public OccurrencesContext occurrences() {
return getRuleContext(OccurrencesContext.class,0);
}
public TerminalNode MATCHES() { return getToken(adlParser.MATCHES, 0); }
public ArchetypeSlotValueConstraintContext archetypeSlotValueConstraint() {
return getRuleContext(ArchetypeSlotValueConstraintContext.class,0);
}
public TerminalNode CLOSED() { return getToken(adlParser.CLOSED, 0); }
public ArchetypeSlotConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_archetypeSlotConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterArchetypeSlotConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitArchetypeSlotConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitArchetypeSlotConstraint(this);
else return visitor.visitChildren(this);
}
}
public final ArchetypeSlotConstraintContext archetypeSlotConstraint() throws RecognitionException {
ArchetypeSlotConstraintContext _localctx = new ArchetypeSlotConstraintContext(_ctx, getState());
enterRule(_localctx, 58, RULE_archetypeSlotConstraint);
int _la;
try {
setState(457);
switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(435);
match(ALLOW_ARCHETYPE);
setState(436);
typeIdentifierWithGenerics();
setState(438);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
{
setState(437);
atCode();
}
break;
}
setState(441);
_la = _input.LA(1);
if (_la==OCCURRENCES) {
{
setState(440);
occurrences();
}
}
setState(448);
_la = _input.LA(1);
if (_la==MATCHES) {
{
setState(443);
match(MATCHES);
setState(444);
match(T__1);
setState(445);
archetypeSlotValueConstraint();
setState(446);
match(T__2);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(450);
match(ALLOW_ARCHETYPE);
setState(451);
typeIdentifierWithGenerics();
setState(453);
_la = _input.LA(1);
if (_la==BRACKET_OPEN) {
{
setState(452);
atCode();
}
}
setState(455);
match(CLOSED);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArchetypeSlotValueConstraintContext extends ParserRuleContext {
public ArchetypeSlotSingleConstraintContext archetypeSlotSingleConstraint;
public List include = new ArrayList();
public List exclude = new ArrayList();
public TerminalNode INCLUDE() { return getToken(adlParser.INCLUDE, 0); }
public TerminalNode EXCLUDE() { return getToken(adlParser.EXCLUDE, 0); }
public List archetypeSlotSingleConstraint() {
return getRuleContexts(ArchetypeSlotSingleConstraintContext.class);
}
public ArchetypeSlotSingleConstraintContext archetypeSlotSingleConstraint(int i) {
return getRuleContext(ArchetypeSlotSingleConstraintContext.class,i);
}
public ArchetypeSlotValueConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_archetypeSlotValueConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterArchetypeSlotValueConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitArchetypeSlotValueConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitArchetypeSlotValueConstraint(this);
else return visitor.visitChildren(this);
}
}
public final ArchetypeSlotValueConstraintContext archetypeSlotValueConstraint() throws RecognitionException {
ArchetypeSlotValueConstraintContext _localctx = new ArchetypeSlotValueConstraintContext(_ctx, getState());
enterRule(_localctx, 60, RULE_archetypeSlotValueConstraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(466);
_la = _input.LA(1);
if (_la==INCLUDE) {
{
setState(459);
match(INCLUDE);
setState(463);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & ((1L << (T__3 - 4)) | (1L << (AT_CODE_VALUE - 4)) | (1L << (LANGUAGE - 4)) | (1L << (ARCHETYPE - 4)) | (1L << (TEMPLATE - 4)) | (1L << (TEMPLATE_OVERLAY - 4)) | (1L << (CONCEPT - 4)) | (1L << (DESCRIPTION - 4)) | (1L << (SPECIALISE - 4)) | (1L << (DEFINITION - 4)) | (1L << (MATCHES - 4)) | (1L << (USE_NODE - 4)) | (1L << (OCCURRENCES - 4)) | (1L << (CARDINALITY - 4)) | (1L << (UNORDERED - 4)) | (1L << (ORDERED - 4)) | (1L << (UNIQUE - 4)) | (1L << (EXISTENCE - 4)) | (1L << (CLOSED - 4)) | (1L << (ANNOTATIONS - 4)) | (1L << (TERMINOLOGY - 4)) | (1L << (NAME_IDENTIFIER - 4)))) != 0)) {
{
{
setState(460);
((ArchetypeSlotValueConstraintContext)_localctx).archetypeSlotSingleConstraint = archetypeSlotSingleConstraint();
((ArchetypeSlotValueConstraintContext)_localctx).include.add(((ArchetypeSlotValueConstraintContext)_localctx).archetypeSlotSingleConstraint);
}
}
setState(465);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(475);
_la = _input.LA(1);
if (_la==EXCLUDE) {
{
setState(468);
match(EXCLUDE);
setState(472);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & ((1L << (T__3 - 4)) | (1L << (AT_CODE_VALUE - 4)) | (1L << (LANGUAGE - 4)) | (1L << (ARCHETYPE - 4)) | (1L << (TEMPLATE - 4)) | (1L << (TEMPLATE_OVERLAY - 4)) | (1L << (CONCEPT - 4)) | (1L << (DESCRIPTION - 4)) | (1L << (SPECIALISE - 4)) | (1L << (DEFINITION - 4)) | (1L << (MATCHES - 4)) | (1L << (USE_NODE - 4)) | (1L << (OCCURRENCES - 4)) | (1L << (CARDINALITY - 4)) | (1L << (UNORDERED - 4)) | (1L << (ORDERED - 4)) | (1L << (UNIQUE - 4)) | (1L << (EXISTENCE - 4)) | (1L << (CLOSED - 4)) | (1L << (ANNOTATIONS - 4)) | (1L << (TERMINOLOGY - 4)) | (1L << (NAME_IDENTIFIER - 4)))) != 0)) {
{
{
setState(469);
((ArchetypeSlotValueConstraintContext)_localctx).archetypeSlotSingleConstraint = archetypeSlotSingleConstraint();
((ArchetypeSlotValueConstraintContext)_localctx).exclude.add(((ArchetypeSlotValueConstraintContext)_localctx).archetypeSlotSingleConstraint);
}
}
setState(474);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArchetypeSlotSingleConstraintContext extends ParserRuleContext {
public RmPathContext rmPath() {
return getRuleContext(RmPathContext.class,0);
}
public TerminalNode MATCHES() { return getToken(adlParser.MATCHES, 0); }
public PrimitiveValueConstraintContext primitiveValueConstraint() {
return getRuleContext(PrimitiveValueConstraintContext.class,0);
}
public ArchetypeSlotSingleConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_archetypeSlotSingleConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterArchetypeSlotSingleConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitArchetypeSlotSingleConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitArchetypeSlotSingleConstraint(this);
else return visitor.visitChildren(this);
}
}
public final ArchetypeSlotSingleConstraintContext archetypeSlotSingleConstraint() throws RecognitionException {
ArchetypeSlotSingleConstraintContext _localctx = new ArchetypeSlotSingleConstraintContext(_ctx, getState());
enterRule(_localctx, 62, RULE_archetypeSlotSingleConstraint);
try {
enterOuterAlt(_localctx, 1);
{
setState(477);
rmPath();
setState(478);
match(MATCHES);
setState(479);
match(T__1);
setState(480);
primitiveValueConstraint();
setState(481);
match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArchetypeReferenceConstraintContext extends ParserRuleContext {
public Token start;
public TypeIdentifierContext typeIdentifier() {
return getRuleContext(TypeIdentifierContext.class,0);
}
public TerminalNode AT_CODE_VALUE() { return getToken(adlParser.AT_CODE_VALUE, 0); }
public ArchetypeIdContext archetypeId() {
return getRuleContext(ArchetypeIdContext.class,0);
}
public TerminalNode USE_ARCHETYPE() { return getToken(adlParser.USE_ARCHETYPE, 0); }
public TerminalNode USE_TEMPLATE() { return getToken(adlParser.USE_TEMPLATE, 0); }
public OccurrencesContext occurrences() {
return getRuleContext(OccurrencesContext.class,0);
}
public ArchetypeReferenceConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_archetypeReferenceConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterArchetypeReferenceConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitArchetypeReferenceConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitArchetypeReferenceConstraint(this);
else return visitor.visitChildren(this);
}
}
public final ArchetypeReferenceConstraintContext archetypeReferenceConstraint() throws RecognitionException {
ArchetypeReferenceConstraintContext _localctx = new ArchetypeReferenceConstraintContext(_ctx, getState());
enterRule(_localctx, 64, RULE_archetypeReferenceConstraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(485);
switch (_input.LA(1)) {
case USE_ARCHETYPE:
{
setState(483);
((ArchetypeReferenceConstraintContext)_localctx).start = match(USE_ARCHETYPE);
}
break;
case USE_TEMPLATE:
{
setState(484);
((ArchetypeReferenceConstraintContext)_localctx).start = match(USE_TEMPLATE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(487);
typeIdentifier();
setState(488);
match(BRACKET_OPEN);
setState(489);
match(AT_CODE_VALUE);
setState(490);
match(COMMA);
setState(491);
archetypeId();
setState(492);
match(BRACKET_CLOSE);
setState(494);
_la = _input.LA(1);
if (_la==OCCURRENCES) {
{
setState(493);
occurrences();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringConstraintContext extends ParserRuleContext {
public StringListContext stringList() {
return getRuleContext(StringListContext.class,0);
}
public RegularExpressionContext regularExpression() {
return getRuleContext(RegularExpressionContext.class,0);
}
public StringConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterStringConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitStringConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitStringConstraint(this);
else return visitor.visitChildren(this);
}
}
public final StringConstraintContext stringConstraint() throws RecognitionException {
StringConstraintContext _localctx = new StringConstraintContext(_ctx, getState());
enterRule(_localctx, 66, RULE_stringConstraint);
try {
setState(498);
switch (_input.LA(1)) {
case STRING:
enterOuterAlt(_localctx, 1);
{
setState(496);
stringList();
}
break;
case T__3:
case CARET:
enterOuterAlt(_localctx, 2);
{
setState(497);
regularExpression();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberConstraintContext extends ParserRuleContext {
public NumberListContext numberList() {
return getRuleContext(NumberListContext.class,0);
}
public List numberIntervalConstraint() {
return getRuleContexts(NumberIntervalConstraintContext.class);
}
public NumberIntervalConstraintContext numberIntervalConstraint(int i) {
return getRuleContext(NumberIntervalConstraintContext.class,i);
}
public NumberConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numberConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterNumberConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitNumberConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitNumberConstraint(this);
else return visitor.visitChildren(this);
}
}
public final NumberConstraintContext numberConstraint() throws RecognitionException {
NumberConstraintContext _localctx = new NumberConstraintContext(_ctx, getState());
enterRule(_localctx, 68, RULE_numberConstraint);
int _la;
try {
setState(509);
switch (_input.LA(1)) {
case MINUS:
case INTEGER:
enterOuterAlt(_localctx, 1);
{
setState(500);
numberList();
}
break;
case PIPE:
enterOuterAlt(_localctx, 2);
{
setState(501);
numberIntervalConstraint();
setState(506);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(502);
match(COMMA);
setState(503);
numberIntervalConstraint();
}
}
setState(508);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DateTimeConstraintContext extends ParserRuleContext {
public TerminalNode DATE_TIME_PATTERN() { return getToken(adlParser.DATE_TIME_PATTERN, 0); }
public TerminalNode ISO_DATE_TIME() { return getToken(adlParser.ISO_DATE_TIME, 0); }
public List dateTimeIntervalConstraint() {
return getRuleContexts(DateTimeIntervalConstraintContext.class);
}
public DateTimeIntervalConstraintContext dateTimeIntervalConstraint(int i) {
return getRuleContext(DateTimeIntervalConstraintContext.class,i);
}
public DateTimeConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateTimeConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterDateTimeConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitDateTimeConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitDateTimeConstraint(this);
else return visitor.visitChildren(this);
}
}
public final DateTimeConstraintContext dateTimeConstraint() throws RecognitionException {
DateTimeConstraintContext _localctx = new DateTimeConstraintContext(_ctx, getState());
enterRule(_localctx, 70, RULE_dateTimeConstraint);
int _la;
try {
setState(521);
switch (_input.LA(1)) {
case DATE_TIME_PATTERN:
enterOuterAlt(_localctx, 1);
{
setState(511);
match(DATE_TIME_PATTERN);
}
break;
case ISO_DATE_TIME:
enterOuterAlt(_localctx, 2);
{
setState(512);
match(ISO_DATE_TIME);
}
break;
case PIPE:
enterOuterAlt(_localctx, 3);
{
setState(513);
dateTimeIntervalConstraint();
setState(518);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(514);
match(COMMA);
setState(515);
dateTimeIntervalConstraint();
}
}
setState(520);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DateConstraintContext extends ParserRuleContext {
public TerminalNode DATE_PATTERN() { return getToken(adlParser.DATE_PATTERN, 0); }
public TerminalNode ISO_DATE() { return getToken(adlParser.ISO_DATE, 0); }
public List dateIntervalConstraint() {
return getRuleContexts(DateIntervalConstraintContext.class);
}
public DateIntervalConstraintContext dateIntervalConstraint(int i) {
return getRuleContext(DateIntervalConstraintContext.class,i);
}
public DateConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterDateConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitDateConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitDateConstraint(this);
else return visitor.visitChildren(this);
}
}
public final DateConstraintContext dateConstraint() throws RecognitionException {
DateConstraintContext _localctx = new DateConstraintContext(_ctx, getState());
enterRule(_localctx, 72, RULE_dateConstraint);
int _la;
try {
setState(533);
switch (_input.LA(1)) {
case DATE_PATTERN:
enterOuterAlt(_localctx, 1);
{
setState(523);
match(DATE_PATTERN);
}
break;
case ISO_DATE:
enterOuterAlt(_localctx, 2);
{
setState(524);
match(ISO_DATE);
}
break;
case PIPE:
enterOuterAlt(_localctx, 3);
{
setState(525);
dateIntervalConstraint();
setState(530);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(526);
match(COMMA);
setState(527);
dateIntervalConstraint();
}
}
setState(532);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TimeConstraintContext extends ParserRuleContext {
public TerminalNode TIME_PATTERN() { return getToken(adlParser.TIME_PATTERN, 0); }
public TerminalNode ISO_TIME() { return getToken(adlParser.ISO_TIME, 0); }
public List timeIntervalConstraint() {
return getRuleContexts(TimeIntervalConstraintContext.class);
}
public TimeIntervalConstraintContext timeIntervalConstraint(int i) {
return getRuleContext(TimeIntervalConstraintContext.class,i);
}
public TimeConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timeConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterTimeConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitTimeConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitTimeConstraint(this);
else return visitor.visitChildren(this);
}
}
public final TimeConstraintContext timeConstraint() throws RecognitionException {
TimeConstraintContext _localctx = new TimeConstraintContext(_ctx, getState());
enterRule(_localctx, 74, RULE_timeConstraint);
int _la;
try {
setState(545);
switch (_input.LA(1)) {
case TIME_PATTERN:
enterOuterAlt(_localctx, 1);
{
setState(535);
match(TIME_PATTERN);
}
break;
case ISO_TIME:
enterOuterAlt(_localctx, 2);
{
setState(536);
match(ISO_TIME);
}
break;
case PIPE:
enterOuterAlt(_localctx, 3);
{
setState(537);
timeIntervalConstraint();
setState(542);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(538);
match(COMMA);
setState(539);
timeIntervalConstraint();
}
}
setState(544);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DurationConstraintContext extends ParserRuleContext {
public Token pattern;
public Token singleInterval;
public List DURATION() { return getTokens(adlParser.DURATION); }
public TerminalNode DURATION(int i) {
return getToken(adlParser.DURATION, i);
}
public DurationIntervalConstraintContext durationIntervalConstraint() {
return getRuleContext(DurationIntervalConstraintContext.class,0);
}
public DurationConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_durationConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterDurationConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitDurationConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitDurationConstraint(this);
else return visitor.visitChildren(this);
}
}
public final DurationConstraintContext durationConstraint() throws RecognitionException {
DurationConstraintContext _localctx = new DurationConstraintContext(_ctx, getState());
enterRule(_localctx, 76, RULE_durationConstraint);
try {
setState(556);
switch (_input.LA(1)) {
case DURATION:
enterOuterAlt(_localctx, 1);
{
{
setState(547);
((DurationConstraintContext)_localctx).pattern = match(DURATION);
}
setState(553);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
{
setState(548);
match(T__3);
setState(551);
switch (_input.LA(1)) {
case PIPE:
{
setState(549);
durationIntervalConstraint();
}
break;
case DURATION:
{
setState(550);
((DurationConstraintContext)_localctx).singleInterval = match(DURATION);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
break;
case PIPE:
enterOuterAlt(_localctx, 2);
{
setState(555);
durationIntervalConstraint();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CodeIdentifierListContext extends ParserRuleContext {
public List codeIdentifier() {
return getRuleContexts(CodeIdentifierContext.class);
}
public CodeIdentifierContext codeIdentifier(int i) {
return getRuleContext(CodeIdentifierContext.class,i);
}
public CodeIdentifierListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codeIdentifierList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterCodeIdentifierList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitCodeIdentifierList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitCodeIdentifierList(this);
else return visitor.visitChildren(this);
}
}
public final CodeIdentifierListContext codeIdentifierList() throws RecognitionException {
CodeIdentifierListContext _localctx = new CodeIdentifierListContext(_ctx, getState());
enterRule(_localctx, 78, RULE_codeIdentifierList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(559);
_la = _input.LA(1);
if (((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & ((1L << (T__3 - 4)) | (1L << (PAREN_OPEN - 4)) | (1L << (PAREN_CLOSE - 4)) | (1L << (PERIOD - 4)) | (1L << (COLON - 4)) | (1L << (MINUS - 4)) | (1L << (ISO_DATE_TIME - 4)) | (1L << (ISO_DATE - 4)) | (1L << (AT_CODE_VALUE - 4)) | (1L << (LANGUAGE - 4)) | (1L << (ARCHETYPE - 4)) | (1L << (TEMPLATE - 4)) | (1L << (TEMPLATE_OVERLAY - 4)) | (1L << (CONCEPT - 4)) | (1L << (DESCRIPTION - 4)) | (1L << (SPECIALISE - 4)) | (1L << (DEFINITION - 4)) | (1L << (MATCHES - 4)) | (1L << (USE_NODE - 4)) | (1L << (OCCURRENCES - 4)) | (1L << (CARDINALITY - 4)) | (1L << (UNORDERED - 4)) | (1L << (ORDERED - 4)) | (1L << (UNIQUE - 4)) | (1L << (EXISTENCE - 4)) | (1L << (CLOSED - 4)) | (1L << (ANNOTATIONS - 4)) | (1L << (TERMINOLOGY - 4)) | (1L << (TYPE_IDENTIFIER - 4)) | (1L << (NAME_IDENTIFIER - 4)) | (1L << (INTEGER - 4)))) != 0)) {
{
setState(558);
codeIdentifier();
}
}
setState(565);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(561);
match(COMMA);
setState(562);
codeIdentifier();
}
}
setState(567);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RegularExpressionContext extends ParserRuleContext {
public RegularExpressionInner1Context regularExpressionInner1() {
return getRuleContext(RegularExpressionInner1Context.class,0);
}
public RegularExpressionInner2Context regularExpressionInner2() {
return getRuleContext(RegularExpressionInner2Context.class,0);
}
public RegularExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regularExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterRegularExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitRegularExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitRegularExpression(this);
else return visitor.visitChildren(this);
}
}
public final RegularExpressionContext regularExpression() throws RecognitionException {
RegularExpressionContext _localctx = new RegularExpressionContext(_ctx, getState());
enterRule(_localctx, 80, RULE_regularExpression);
try {
setState(576);
switch (_input.LA(1)) {
case T__3:
enterOuterAlt(_localctx, 1);
{
setState(568);
match(T__3);
setState(569);
regularExpressionInner1();
setState(570);
match(T__3);
}
break;
case CARET:
enterOuterAlt(_localctx, 2);
{
setState(572);
match(CARET);
setState(573);
regularExpressionInner2();
setState(574);
match(CARET);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RegularExpressionInner1Context extends ParserRuleContext {
public RegularExpressionInner1Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regularExpressionInner1; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterRegularExpressionInner1(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitRegularExpressionInner1(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitRegularExpressionInner1(this);
else return visitor.visitChildren(this);
}
}
public final RegularExpressionInner1Context regularExpressionInner1() throws RecognitionException {
RegularExpressionInner1Context _localctx = new RegularExpressionInner1Context(_ctx, getState());
enterRule(_localctx, 82, RULE_regularExpressionInner1);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(581);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__4) | (1L << RANGE) | (1L << EQUALS) | (1L << PAREN_OPEN) | (1L << PAREN_CLOSE) | (1L << BRACKET_OPEN) | (1L << BRACKET_CLOSE) | (1L << GT) | (1L << LT) | (1L << PERIOD) | (1L << COMMA) | (1L << COLON) | (1L << SEMICOLON) | (1L << MINUS) | (1L << UNDERSCORE) | (1L << PIPE) | (1L << ASTERISK) | (1L << CARET) | (1L << AMP) | (1L << EXCLAMATION) | (1L << QUESTION) | (1L << OTHER_SYMBOL) | (1L << DATE_TIME_PATTERN) | (1L << TIME_PATTERN) | (1L << DATE_PATTERN) | (1L << DURATION) | (1L << ISO_DATE_TIME) | (1L << ISO_DATE) | (1L << ISO_TIME) | (1L << AT_CODE_VALUE) | (1L << LANGUAGE) | (1L << ARCHETYPE) | (1L << TEMPLATE) | (1L << TEMPLATE_OVERLAY) | (1L << CONCEPT) | (1L << DESCRIPTION) | (1L << SPECIALISE) | (1L << DEFINITION) | (1L << MATCHES) | (1L << USE_NODE) | (1L << OCCURRENCES) | (1L << INCLUDE) | (1L << EXCLUDE) | (1L << ALLOW_ARCHETYPE) | (1L << CARDINALITY) | (1L << UNORDERED) | (1L << ORDERED) | (1L << UNIQUE) | (1L << EXISTENCE) | (1L << BEFORE) | (1L << AFTER) | (1L << USE_ARCHETYPE) | (1L << USE_TEMPLATE) | (1L << CLOSED) | (1L << ANNOTATIONS) | (1L << TERMINOLOGY) | (1L << TRUE) | (1L << FALSE) | (1L << TYPE_IDENTIFIER))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAME_IDENTIFIER - 64)) | (1L << (INTEGER - 64)) | (1L << (STRING - 64)) | (1L << (UNICODE_CHAR - 64)) | (1L << (LINE_COMMENT - 64)) | (1L << (WS - 64)))) != 0)) {
{
{
setState(578);
_la = _input.LA(1);
if ( _la <= 0 || (_la==T__3) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(583);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RegularExpressionInner2Context extends ParserRuleContext {
public RegularExpressionInner2Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regularExpressionInner2; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterRegularExpressionInner2(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitRegularExpressionInner2(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitRegularExpressionInner2(this);
else return visitor.visitChildren(this);
}
}
public final RegularExpressionInner2Context regularExpressionInner2() throws RecognitionException {
RegularExpressionInner2Context _localctx = new RegularExpressionInner2Context(_ctx, getState());
enterRule(_localctx, 84, RULE_regularExpressionInner2);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(587);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << RANGE) | (1L << EQUALS) | (1L << PAREN_OPEN) | (1L << PAREN_CLOSE) | (1L << BRACKET_OPEN) | (1L << BRACKET_CLOSE) | (1L << GT) | (1L << LT) | (1L << PERIOD) | (1L << COMMA) | (1L << COLON) | (1L << SEMICOLON) | (1L << MINUS) | (1L << UNDERSCORE) | (1L << PIPE) | (1L << ASTERISK) | (1L << AMP) | (1L << EXCLAMATION) | (1L << QUESTION) | (1L << OTHER_SYMBOL) | (1L << DATE_TIME_PATTERN) | (1L << TIME_PATTERN) | (1L << DATE_PATTERN) | (1L << DURATION) | (1L << ISO_DATE_TIME) | (1L << ISO_DATE) | (1L << ISO_TIME) | (1L << AT_CODE_VALUE) | (1L << LANGUAGE) | (1L << ARCHETYPE) | (1L << TEMPLATE) | (1L << TEMPLATE_OVERLAY) | (1L << CONCEPT) | (1L << DESCRIPTION) | (1L << SPECIALISE) | (1L << DEFINITION) | (1L << MATCHES) | (1L << USE_NODE) | (1L << OCCURRENCES) | (1L << INCLUDE) | (1L << EXCLUDE) | (1L << ALLOW_ARCHETYPE) | (1L << CARDINALITY) | (1L << UNORDERED) | (1L << ORDERED) | (1L << UNIQUE) | (1L << EXISTENCE) | (1L << BEFORE) | (1L << AFTER) | (1L << USE_ARCHETYPE) | (1L << USE_TEMPLATE) | (1L << CLOSED) | (1L << ANNOTATIONS) | (1L << TERMINOLOGY) | (1L << TRUE) | (1L << FALSE) | (1L << TYPE_IDENTIFIER))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (NAME_IDENTIFIER - 64)) | (1L << (INTEGER - 64)) | (1L << (STRING - 64)) | (1L << (UNICODE_CHAR - 64)) | (1L << (LINE_COMMENT - 64)) | (1L << (WS - 64)))) != 0)) {
{
{
setState(584);
_la = _input.LA(1);
if ( _la <= 0 || (_la==CARET) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(589);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeConstraintContext extends ParserRuleContext {
public AttributeIdentifierContext attributeIdentifier() {
return getRuleContext(AttributeIdentifierContext.class,0);
}
public ExistenceContext existence() {
return getRuleContext(ExistenceContext.class,0);
}
public CardinalityContext cardinality() {
return getRuleContext(CardinalityContext.class,0);
}
public TerminalNode MATCHES() { return getToken(adlParser.MATCHES, 0); }
public MultiValueConstraintContext multiValueConstraint() {
return getRuleContext(MultiValueConstraintContext.class,0);
}
public TupleAttributeIdentifierContext tupleAttributeIdentifier() {
return getRuleContext(TupleAttributeIdentifierContext.class,0);
}
public TupleChildConstraintsContext tupleChildConstraints() {
return getRuleContext(TupleChildConstraintsContext.class,0);
}
public AttributeConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterAttributeConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitAttributeConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitAttributeConstraint(this);
else return visitor.visitChildren(this);
}
}
public final AttributeConstraintContext attributeConstraint() throws RecognitionException {
AttributeConstraintContext _localctx = new AttributeConstraintContext(_ctx, getState());
enterRule(_localctx, 86, RULE_attributeConstraint);
int _la;
try {
setState(613);
switch (_input.LA(1)) {
case T__3:
case AT_CODE_VALUE:
case LANGUAGE:
case ARCHETYPE:
case TEMPLATE:
case TEMPLATE_OVERLAY:
case CONCEPT:
case DESCRIPTION:
case SPECIALISE:
case DEFINITION:
case MATCHES:
case USE_NODE:
case OCCURRENCES:
case CARDINALITY:
case UNORDERED:
case ORDERED:
case UNIQUE:
case EXISTENCE:
case CLOSED:
case ANNOTATIONS:
case TERMINOLOGY:
case NAME_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(590);
attributeIdentifier();
setState(592);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
{
setState(591);
existence();
}
break;
}
setState(595);
switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
case 1:
{
setState(594);
cardinality();
}
break;
}
setState(602);
switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
case 1:
{
setState(597);
match(MATCHES);
setState(598);
match(T__1);
setState(599);
multiValueConstraint();
setState(600);
match(T__2);
}
break;
}
}
break;
case BRACKET_OPEN:
enterOuterAlt(_localctx, 2);
{
setState(604);
tupleAttributeIdentifier();
setState(606);
_la = _input.LA(1);
if (_la==EXISTENCE) {
{
setState(605);
existence();
}
}
setState(608);
match(MATCHES);
setState(609);
match(T__1);
setState(610);
tupleChildConstraints();
setState(611);
match(T__2);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TupleAttributeIdentifierContext extends ParserRuleContext {
public List attributeIdentifier() {
return getRuleContexts(AttributeIdentifierContext.class);
}
public AttributeIdentifierContext attributeIdentifier(int i) {
return getRuleContext(AttributeIdentifierContext.class,i);
}
public TupleAttributeIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleAttributeIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterTupleAttributeIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitTupleAttributeIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitTupleAttributeIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final TupleAttributeIdentifierContext tupleAttributeIdentifier() throws RecognitionException {
TupleAttributeIdentifierContext _localctx = new TupleAttributeIdentifierContext(_ctx, getState());
enterRule(_localctx, 88, RULE_tupleAttributeIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(615);
match(BRACKET_OPEN);
setState(616);
attributeIdentifier();
setState(621);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(617);
match(COMMA);
setState(618);
attributeIdentifier();
}
}
setState(623);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(624);
match(BRACKET_CLOSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TupleChildConstraintsContext extends ParserRuleContext {
public List tupleChildConstraint() {
return getRuleContexts(TupleChildConstraintContext.class);
}
public TupleChildConstraintContext tupleChildConstraint(int i) {
return getRuleContext(TupleChildConstraintContext.class,i);
}
public TupleChildConstraintsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleChildConstraints; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterTupleChildConstraints(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitTupleChildConstraints(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitTupleChildConstraints(this);
else return visitor.visitChildren(this);
}
}
public final TupleChildConstraintsContext tupleChildConstraints() throws RecognitionException {
TupleChildConstraintsContext _localctx = new TupleChildConstraintsContext(_ctx, getState());
enterRule(_localctx, 90, RULE_tupleChildConstraints);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(626);
tupleChildConstraint();
setState(631);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(627);
match(COMMA);
setState(628);
tupleChildConstraint();
}
}
setState(633);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TupleChildConstraintContext extends ParserRuleContext {
public List primitiveValueConstraint() {
return getRuleContexts(PrimitiveValueConstraintContext.class);
}
public PrimitiveValueConstraintContext primitiveValueConstraint(int i) {
return getRuleContext(PrimitiveValueConstraintContext.class,i);
}
public TupleChildConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleChildConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterTupleChildConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitTupleChildConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitTupleChildConstraint(this);
else return visitor.visitChildren(this);
}
}
public final TupleChildConstraintContext tupleChildConstraint() throws RecognitionException {
TupleChildConstraintContext _localctx = new TupleChildConstraintContext(_ctx, getState());
enterRule(_localctx, 92, RULE_tupleChildConstraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(634);
match(BRACKET_OPEN);
setState(635);
match(T__1);
setState(636);
primitiveValueConstraint();
setState(637);
match(T__2);
setState(645);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(638);
match(COMMA);
setState(639);
match(T__1);
setState(640);
primitiveValueConstraint();
setState(641);
match(T__2);
}
}
setState(647);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(648);
match(BRACKET_CLOSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeIdentifierContext extends ParserRuleContext {
public RmPathContext rmPath() {
return getRuleContext(RmPathContext.class,0);
}
public AttributeIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterAttributeIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitAttributeIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitAttributeIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final AttributeIdentifierContext attributeIdentifier() throws RecognitionException {
AttributeIdentifierContext _localctx = new AttributeIdentifierContext(_ctx, getState());
enterRule(_localctx, 94, RULE_attributeIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(650);
rmPath();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExistenceContext extends ParserRuleContext {
public TerminalNode EXISTENCE() { return getToken(adlParser.EXISTENCE, 0); }
public TerminalNode MATCHES() { return getToken(adlParser.MATCHES, 0); }
public OccurrenceRangeContext occurrenceRange() {
return getRuleContext(OccurrenceRangeContext.class,0);
}
public ExistenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_existence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterExistence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitExistence(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitExistence(this);
else return visitor.visitChildren(this);
}
}
public final ExistenceContext existence() throws RecognitionException {
ExistenceContext _localctx = new ExistenceContext(_ctx, getState());
enterRule(_localctx, 96, RULE_existence);
try {
enterOuterAlt(_localctx, 1);
{
setState(652);
match(EXISTENCE);
setState(653);
match(MATCHES);
setState(654);
match(T__1);
setState(655);
occurrenceRange();
setState(656);
match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CardinalityContext extends ParserRuleContext {
public Token ord;
public Token uq;
public TerminalNode CARDINALITY() { return getToken(adlParser.CARDINALITY, 0); }
public TerminalNode MATCHES() { return getToken(adlParser.MATCHES, 0); }
public OccurrenceRangeContext occurrenceRange() {
return getRuleContext(OccurrenceRangeContext.class,0);
}
public TerminalNode ORDERED() { return getToken(adlParser.ORDERED, 0); }
public TerminalNode UNORDERED() { return getToken(adlParser.UNORDERED, 0); }
public TerminalNode UNIQUE() { return getToken(adlParser.UNIQUE, 0); }
public CardinalityContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cardinality; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterCardinality(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitCardinality(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitCardinality(this);
else return visitor.visitChildren(this);
}
}
public final CardinalityContext cardinality() throws RecognitionException {
CardinalityContext _localctx = new CardinalityContext(_ctx, getState());
enterRule(_localctx, 98, RULE_cardinality);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(658);
match(CARDINALITY);
setState(659);
match(MATCHES);
setState(660);
match(T__1);
setState(661);
occurrenceRange();
setState(667);
switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
case 1:
{
setState(662);
match(SEMICOLON);
setState(665);
switch (_input.LA(1)) {
case ORDERED:
{
setState(663);
((CardinalityContext)_localctx).ord = match(ORDERED);
}
break;
case UNORDERED:
{
setState(664);
((CardinalityContext)_localctx).ord = match(UNORDERED);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
setState(671);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(669);
match(SEMICOLON);
{
setState(670);
((CardinalityContext)_localctx).uq = match(UNIQUE);
}
}
}
setState(673);
match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberIntervalConstraintContext extends ParserRuleContext {
public Token gt;
public NumberContext lower;
public Token lt;
public NumberContext upper;
public Token gte;
public Token lte;
public NumberContext val;
public List number() {
return getRuleContexts(NumberContext.class);
}
public NumberContext number(int i) {
return getRuleContext(NumberContext.class,i);
}
public NumberIntervalConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numberIntervalConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterNumberIntervalConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitNumberIntervalConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitNumberIntervalConstraint(this);
else return visitor.visitChildren(this);
}
}
public final NumberIntervalConstraintContext numberIntervalConstraint() throws RecognitionException {
NumberIntervalConstraintContext _localctx = new NumberIntervalConstraintContext(_ctx, getState());
enterRule(_localctx, 100, RULE_numberIntervalConstraint);
int _la;
try {
setState(705);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(675);
match(PIPE);
setState(677);
_la = _input.LA(1);
if (_la==GT) {
{
setState(676);
((NumberIntervalConstraintContext)_localctx).gt = match(GT);
}
}
{
setState(679);
((NumberIntervalConstraintContext)_localctx).lower = number();
}
setState(680);
match(RANGE);
setState(682);
_la = _input.LA(1);
if (_la==LT) {
{
setState(681);
((NumberIntervalConstraintContext)_localctx).lt = match(LT);
}
}
{
setState(684);
((NumberIntervalConstraintContext)_localctx).upper = number();
}
setState(685);
match(PIPE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(687);
match(PIPE);
setState(700);
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
case 1:
{
setState(692);
_la = _input.LA(1);
if (_la==GT) {
{
setState(688);
((NumberIntervalConstraintContext)_localctx).gt = match(GT);
setState(690);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(689);
((NumberIntervalConstraintContext)_localctx).gte = match(EQUALS);
}
}
}
}
}
break;
case 2:
{
setState(698);
_la = _input.LA(1);
if (_la==LT) {
{
setState(694);
((NumberIntervalConstraintContext)_localctx).lt = match(LT);
setState(696);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(695);
((NumberIntervalConstraintContext)_localctx).lte = match(EQUALS);
}
}
}
}
}
break;
}
setState(702);
((NumberIntervalConstraintContext)_localctx).val = number();
setState(703);
match(PIPE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DateIntervalConstraintContext extends ParserRuleContext {
public Token gt;
public Token lower;
public Token lt;
public Token upper;
public Token gte;
public Token lte;
public Token val;
public List ISO_DATE() { return getTokens(adlParser.ISO_DATE); }
public TerminalNode ISO_DATE(int i) {
return getToken(adlParser.ISO_DATE, i);
}
public DateIntervalConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateIntervalConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterDateIntervalConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitDateIntervalConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitDateIntervalConstraint(this);
else return visitor.visitChildren(this);
}
}
public final DateIntervalConstraintContext dateIntervalConstraint() throws RecognitionException {
DateIntervalConstraintContext _localctx = new DateIntervalConstraintContext(_ctx, getState());
enterRule(_localctx, 102, RULE_dateIntervalConstraint);
int _la;
try {
setState(735);
switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(707);
match(PIPE);
setState(709);
_la = _input.LA(1);
if (_la==GT) {
{
setState(708);
((DateIntervalConstraintContext)_localctx).gt = match(GT);
}
}
{
setState(711);
((DateIntervalConstraintContext)_localctx).lower = match(ISO_DATE);
}
setState(712);
match(RANGE);
setState(714);
_la = _input.LA(1);
if (_la==LT) {
{
setState(713);
((DateIntervalConstraintContext)_localctx).lt = match(LT);
}
}
{
setState(716);
((DateIntervalConstraintContext)_localctx).upper = match(ISO_DATE);
}
setState(717);
match(PIPE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(718);
match(PIPE);
setState(731);
switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
case 1:
{
setState(723);
_la = _input.LA(1);
if (_la==GT) {
{
setState(719);
((DateIntervalConstraintContext)_localctx).gt = match(GT);
setState(721);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(720);
((DateIntervalConstraintContext)_localctx).gte = match(EQUALS);
}
}
}
}
}
break;
case 2:
{
setState(729);
_la = _input.LA(1);
if (_la==LT) {
{
setState(725);
((DateIntervalConstraintContext)_localctx).lt = match(LT);
setState(727);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(726);
((DateIntervalConstraintContext)_localctx).lte = match(EQUALS);
}
}
}
}
}
break;
}
setState(733);
((DateIntervalConstraintContext)_localctx).val = match(ISO_DATE);
setState(734);
match(PIPE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TimeIntervalConstraintContext extends ParserRuleContext {
public Token gt;
public Token lower;
public Token lt;
public Token upper;
public Token gte;
public Token lte;
public Token val;
public List ISO_TIME() { return getTokens(adlParser.ISO_TIME); }
public TerminalNode ISO_TIME(int i) {
return getToken(adlParser.ISO_TIME, i);
}
public TimeIntervalConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timeIntervalConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterTimeIntervalConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitTimeIntervalConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitTimeIntervalConstraint(this);
else return visitor.visitChildren(this);
}
}
public final TimeIntervalConstraintContext timeIntervalConstraint() throws RecognitionException {
TimeIntervalConstraintContext _localctx = new TimeIntervalConstraintContext(_ctx, getState());
enterRule(_localctx, 104, RULE_timeIntervalConstraint);
int _la;
try {
setState(765);
switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(737);
match(PIPE);
setState(739);
_la = _input.LA(1);
if (_la==GT) {
{
setState(738);
((TimeIntervalConstraintContext)_localctx).gt = match(GT);
}
}
{
setState(741);
((TimeIntervalConstraintContext)_localctx).lower = match(ISO_TIME);
}
setState(742);
match(RANGE);
setState(744);
_la = _input.LA(1);
if (_la==LT) {
{
setState(743);
((TimeIntervalConstraintContext)_localctx).lt = match(LT);
}
}
{
setState(746);
((TimeIntervalConstraintContext)_localctx).upper = match(ISO_TIME);
}
setState(747);
match(PIPE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(748);
match(PIPE);
setState(761);
switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
case 1:
{
setState(753);
_la = _input.LA(1);
if (_la==GT) {
{
setState(749);
((TimeIntervalConstraintContext)_localctx).gt = match(GT);
setState(751);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(750);
((TimeIntervalConstraintContext)_localctx).gte = match(EQUALS);
}
}
}
}
}
break;
case 2:
{
setState(759);
_la = _input.LA(1);
if (_la==LT) {
{
setState(755);
((TimeIntervalConstraintContext)_localctx).lt = match(LT);
setState(757);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(756);
((TimeIntervalConstraintContext)_localctx).lte = match(EQUALS);
}
}
}
}
}
break;
}
setState(763);
((TimeIntervalConstraintContext)_localctx).val = match(ISO_TIME);
setState(764);
match(PIPE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DateTimeIntervalConstraintContext extends ParserRuleContext {
public Token gt;
public Token lower;
public Token lt;
public Token upper;
public Token gte;
public Token lte;
public Token val;
public List ISO_DATE_TIME() { return getTokens(adlParser.ISO_DATE_TIME); }
public TerminalNode ISO_DATE_TIME(int i) {
return getToken(adlParser.ISO_DATE_TIME, i);
}
public DateTimeIntervalConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateTimeIntervalConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterDateTimeIntervalConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitDateTimeIntervalConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitDateTimeIntervalConstraint(this);
else return visitor.visitChildren(this);
}
}
public final DateTimeIntervalConstraintContext dateTimeIntervalConstraint() throws RecognitionException {
DateTimeIntervalConstraintContext _localctx = new DateTimeIntervalConstraintContext(_ctx, getState());
enterRule(_localctx, 106, RULE_dateTimeIntervalConstraint);
int _la;
try {
setState(795);
switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(767);
match(PIPE);
setState(769);
_la = _input.LA(1);
if (_la==GT) {
{
setState(768);
((DateTimeIntervalConstraintContext)_localctx).gt = match(GT);
}
}
{
setState(771);
((DateTimeIntervalConstraintContext)_localctx).lower = match(ISO_DATE_TIME);
}
setState(772);
match(RANGE);
setState(774);
_la = _input.LA(1);
if (_la==LT) {
{
setState(773);
((DateTimeIntervalConstraintContext)_localctx).lt = match(LT);
}
}
{
setState(776);
((DateTimeIntervalConstraintContext)_localctx).upper = match(ISO_DATE_TIME);
}
setState(777);
match(PIPE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(778);
match(PIPE);
setState(791);
switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) {
case 1:
{
setState(783);
_la = _input.LA(1);
if (_la==GT) {
{
setState(779);
((DateTimeIntervalConstraintContext)_localctx).gt = match(GT);
setState(781);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(780);
((DateTimeIntervalConstraintContext)_localctx).gte = match(EQUALS);
}
}
}
}
}
break;
case 2:
{
setState(789);
_la = _input.LA(1);
if (_la==LT) {
{
setState(785);
((DateTimeIntervalConstraintContext)_localctx).lt = match(LT);
setState(787);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(786);
((DateTimeIntervalConstraintContext)_localctx).lte = match(EQUALS);
}
}
}
}
}
break;
}
setState(793);
((DateTimeIntervalConstraintContext)_localctx).val = match(ISO_DATE_TIME);
setState(794);
match(PIPE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DurationIntervalConstraintContext extends ParserRuleContext {
public Token gt;
public Token lower;
public Token lt;
public Token upper;
public Token gte;
public Token lte;
public Token val;
public List DURATION() { return getTokens(adlParser.DURATION); }
public TerminalNode DURATION(int i) {
return getToken(adlParser.DURATION, i);
}
public DurationIntervalConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_durationIntervalConstraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterDurationIntervalConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitDurationIntervalConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitDurationIntervalConstraint(this);
else return visitor.visitChildren(this);
}
}
public final DurationIntervalConstraintContext durationIntervalConstraint() throws RecognitionException {
DurationIntervalConstraintContext _localctx = new DurationIntervalConstraintContext(_ctx, getState());
enterRule(_localctx, 108, RULE_durationIntervalConstraint);
int _la;
try {
setState(831);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(797);
match(PIPE);
setState(799);
_la = _input.LA(1);
if (_la==GT) {
{
setState(798);
((DurationIntervalConstraintContext)_localctx).gt = match(GT);
}
}
setState(803);
switch (_input.LA(1)) {
case DURATION:
{
setState(801);
((DurationIntervalConstraintContext)_localctx).lower = match(DURATION);
}
break;
case ASTERISK:
{
setState(802);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(805);
match(RANGE);
setState(807);
_la = _input.LA(1);
if (_la==LT) {
{
setState(806);
((DurationIntervalConstraintContext)_localctx).lt = match(LT);
}
}
setState(811);
switch (_input.LA(1)) {
case DURATION:
{
setState(809);
((DurationIntervalConstraintContext)_localctx).upper = match(DURATION);
}
break;
case ASTERISK:
{
setState(810);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(813);
match(PIPE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(814);
match(PIPE);
setState(827);
switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
case 1:
{
setState(819);
_la = _input.LA(1);
if (_la==GT) {
{
setState(815);
((DurationIntervalConstraintContext)_localctx).gt = match(GT);
setState(817);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(816);
((DurationIntervalConstraintContext)_localctx).gte = match(EQUALS);
}
}
}
}
}
break;
case 2:
{
setState(825);
_la = _input.LA(1);
if (_la==LT) {
{
setState(821);
((DurationIntervalConstraintContext)_localctx).lt = match(LT);
setState(823);
_la = _input.LA(1);
if (_la==EQUALS) {
{
setState(822);
((DurationIntervalConstraintContext)_localctx).lte = match(EQUALS);
}
}
}
}
}
break;
}
setState(829);
((DurationIntervalConstraintContext)_localctx).val = match(DURATION);
setState(830);
match(PIPE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TerminologyContext extends ParserRuleContext {
public TerminalNode TERMINOLOGY() { return getToken(adlParser.TERMINOLOGY, 0); }
public OdinObjectValueContext odinObjectValue() {
return getRuleContext(OdinObjectValueContext.class,0);
}
public TerminologyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_terminology; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterTerminology(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitTerminology(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitTerminology(this);
else return visitor.visitChildren(this);
}
}
public final TerminologyContext terminology() throws RecognitionException {
TerminologyContext _localctx = new TerminologyContext(_ctx, getState());
enterRule(_localctx, 110, RULE_terminology);
try {
enterOuterAlt(_localctx, 1);
{
setState(833);
match(TERMINOLOGY);
setState(834);
odinObjectValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationsContext extends ParserRuleContext {
public TerminalNode ANNOTATIONS() { return getToken(adlParser.ANNOTATIONS, 0); }
public OdinObjectValueContext odinObjectValue() {
return getRuleContext(OdinObjectValueContext.class,0);
}
public AnnotationsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotations; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterAnnotations(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitAnnotations(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitAnnotations(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationsContext annotations() throws RecognitionException {
AnnotationsContext _localctx = new AnnotationsContext(_ctx, getState());
enterRule(_localctx, 112, RULE_annotations);
try {
enterOuterAlt(_localctx, 1);
{
setState(836);
match(ANNOTATIONS);
setState(837);
odinObjectValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OdinValueContext extends ParserRuleContext {
public OdinMapValueContext odinMapValue() {
return getRuleContext(OdinMapValueContext.class,0);
}
public OdinCodePhraseValueListContext odinCodePhraseValueList() {
return getRuleContext(OdinCodePhraseValueListContext.class,0);
}
public OpenStringListContext openStringList() {
return getRuleContext(OpenStringListContext.class,0);
}
public NumberIntervalConstraintContext numberIntervalConstraint() {
return getRuleContext(NumberIntervalConstraintContext.class,0);
}
public TypeIdentifierContext typeIdentifier() {
return getRuleContext(TypeIdentifierContext.class,0);
}
public OdinObjectValueContext odinObjectValue() {
return getRuleContext(OdinObjectValueContext.class,0);
}
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public UrlContext url() {
return getRuleContext(UrlContext.class,0);
}
public OdinValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_odinValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOdinValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOdinValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOdinValue(this);
else return visitor.visitChildren(this);
}
}
public final OdinValueContext odinValue() throws RecognitionException {
OdinValueContext _localctx = new OdinValueContext(_ctx, getState());
enterRule(_localctx, 114, RULE_odinValue);
int _la;
try {
setState(873);
switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(839);
match(LT);
setState(844);
switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
case 1:
{
setState(840);
odinMapValue();
}
break;
case 2:
{
setState(841);
odinCodePhraseValueList();
}
break;
case 3:
{
setState(842);
openStringList();
}
break;
case 4:
{
setState(843);
numberIntervalConstraint();
}
break;
}
setState(846);
match(GT);
setState(848);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(847);
match(SEMICOLON);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(855);
switch (_input.LA(1)) {
case PAREN_OPEN:
{
{
setState(850);
match(PAREN_OPEN);
setState(851);
typeIdentifier();
setState(852);
match(PAREN_CLOSE);
}
}
break;
case TYPE_IDENTIFIER:
{
setState(854);
typeIdentifier();
}
break;
case LT:
break;
default:
throw new NoViableAltException(this);
}
setState(857);
match(LT);
setState(859);
_la = _input.LA(1);
if (((((_la - 34)) & ~0x3f) == 0 && ((1L << (_la - 34)) & ((1L << (AT_CODE_VALUE - 34)) | (1L << (LANGUAGE - 34)) | (1L << (ARCHETYPE - 34)) | (1L << (TEMPLATE - 34)) | (1L << (TEMPLATE_OVERLAY - 34)) | (1L << (CONCEPT - 34)) | (1L << (DESCRIPTION - 34)) | (1L << (SPECIALISE - 34)) | (1L << (DEFINITION - 34)) | (1L << (MATCHES - 34)) | (1L << (USE_NODE - 34)) | (1L << (OCCURRENCES - 34)) | (1L << (CARDINALITY - 34)) | (1L << (UNORDERED - 34)) | (1L << (ORDERED - 34)) | (1L << (UNIQUE - 34)) | (1L << (EXISTENCE - 34)) | (1L << (CLOSED - 34)) | (1L << (ANNOTATIONS - 34)) | (1L << (TERMINOLOGY - 34)) | (1L << (TYPE_IDENTIFIER - 34)) | (1L << (NAME_IDENTIFIER - 34)))) != 0)) {
{
setState(858);
odinObjectValue();
}
}
setState(861);
match(GT);
setState(863);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(862);
match(SEMICOLON);
}
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(865);
match(LT);
setState(866);
number();
setState(867);
match(GT);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(869);
match(LT);
setState(870);
url();
setState(871);
match(GT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OdinObjectValueContext extends ParserRuleContext {
public List odinObjectProperty() {
return getRuleContexts(OdinObjectPropertyContext.class);
}
public OdinObjectPropertyContext odinObjectProperty(int i) {
return getRuleContext(OdinObjectPropertyContext.class,i);
}
public OdinObjectValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_odinObjectValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOdinObjectValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOdinObjectValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOdinObjectValue(this);
else return visitor.visitChildren(this);
}
}
public final OdinObjectValueContext odinObjectValue() throws RecognitionException {
OdinObjectValueContext _localctx = new OdinObjectValueContext(_ctx, getState());
enterRule(_localctx, 116, RULE_odinObjectValue);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(876);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(875);
odinObjectProperty();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(878);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,136,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OdinObjectPropertyContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public OdinValueContext odinValue() {
return getRuleContext(OdinValueContext.class,0);
}
public OdinObjectPropertyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_odinObjectProperty; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOdinObjectProperty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOdinObjectProperty(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOdinObjectProperty(this);
else return visitor.visitChildren(this);
}
}
public final OdinObjectPropertyContext odinObjectProperty() throws RecognitionException {
OdinObjectPropertyContext _localctx = new OdinObjectPropertyContext(_ctx, getState());
enterRule(_localctx, 118, RULE_odinObjectProperty);
try {
enterOuterAlt(_localctx, 1);
{
setState(880);
identifier();
setState(881);
match(EQUALS);
setState(882);
odinValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OdinCodePhraseValueListContext extends ParserRuleContext {
public List odinCodePhraseValue() {
return getRuleContexts(OdinCodePhraseValueContext.class);
}
public OdinCodePhraseValueContext odinCodePhraseValue(int i) {
return getRuleContext(OdinCodePhraseValueContext.class,i);
}
public OdinCodePhraseValueListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_odinCodePhraseValueList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOdinCodePhraseValueList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOdinCodePhraseValueList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOdinCodePhraseValueList(this);
else return visitor.visitChildren(this);
}
}
public final OdinCodePhraseValueListContext odinCodePhraseValueList() throws RecognitionException {
OdinCodePhraseValueListContext _localctx = new OdinCodePhraseValueListContext(_ctx, getState());
enterRule(_localctx, 120, RULE_odinCodePhraseValueList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(884);
odinCodePhraseValue();
setState(889);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(885);
match(COMMA);
setState(886);
odinCodePhraseValue();
}
}
setState(891);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OdinCodePhraseValueContext extends ParserRuleContext {
public CodeIdentifierContext tid;
public CodeIdentifierContext code;
public List codeIdentifier() {
return getRuleContexts(CodeIdentifierContext.class);
}
public CodeIdentifierContext codeIdentifier(int i) {
return getRuleContext(CodeIdentifierContext.class,i);
}
public OdinCodePhraseValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_odinCodePhraseValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOdinCodePhraseValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOdinCodePhraseValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOdinCodePhraseValue(this);
else return visitor.visitChildren(this);
}
}
public final OdinCodePhraseValueContext odinCodePhraseValue() throws RecognitionException {
OdinCodePhraseValueContext _localctx = new OdinCodePhraseValueContext(_ctx, getState());
enterRule(_localctx, 122, RULE_odinCodePhraseValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(892);
match(BRACKET_OPEN);
setState(893);
((OdinCodePhraseValueContext)_localctx).tid = codeIdentifier();
setState(894);
match(T__0);
setState(895);
((OdinCodePhraseValueContext)_localctx).code = codeIdentifier();
setState(896);
match(BRACKET_CLOSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OdinMapValueContext extends ParserRuleContext {
public List odinMapValueEntry() {
return getRuleContexts(OdinMapValueEntryContext.class);
}
public OdinMapValueEntryContext odinMapValueEntry(int i) {
return getRuleContext(OdinMapValueEntryContext.class,i);
}
public OdinMapValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_odinMapValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOdinMapValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOdinMapValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOdinMapValue(this);
else return visitor.visitChildren(this);
}
}
public final OdinMapValueContext odinMapValue() throws RecognitionException {
OdinMapValueContext _localctx = new OdinMapValueContext(_ctx, getState());
enterRule(_localctx, 124, RULE_odinMapValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(899);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(898);
odinMapValueEntry();
}
}
setState(901);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==BRACKET_OPEN );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OdinMapValueEntryContext extends ParserRuleContext {
public Token key;
public OdinValueContext value;
public TerminalNode STRING() { return getToken(adlParser.STRING, 0); }
public OdinValueContext odinValue() {
return getRuleContext(OdinValueContext.class,0);
}
public OdinMapValueEntryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_odinMapValueEntry; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOdinMapValueEntry(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOdinMapValueEntry(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOdinMapValueEntry(this);
else return visitor.visitChildren(this);
}
}
public final OdinMapValueEntryContext odinMapValueEntry() throws RecognitionException {
OdinMapValueEntryContext _localctx = new OdinMapValueEntryContext(_ctx, getState());
enterRule(_localctx, 126, RULE_odinMapValueEntry);
try {
enterOuterAlt(_localctx, 1);
{
setState(903);
match(BRACKET_OPEN);
setState(904);
((OdinMapValueEntryContext)_localctx).key = match(STRING);
setState(905);
match(BRACKET_CLOSE);
setState(906);
match(EQUALS);
setState(907);
((OdinMapValueEntryContext)_localctx).value = odinValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OpenStringListContext extends ParserRuleContext {
public List STRING() { return getTokens(adlParser.STRING); }
public TerminalNode STRING(int i) {
return getToken(adlParser.STRING, i);
}
public OpenStringListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_openStringList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterOpenStringList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitOpenStringList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitOpenStringList(this);
else return visitor.visitChildren(this);
}
}
public final OpenStringListContext openStringList() throws RecognitionException {
OpenStringListContext _localctx = new OpenStringListContext(_ctx, getState());
enterRule(_localctx, 128, RULE_openStringList);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(909);
match(STRING);
setState(914);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,139,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(910);
match(COMMA);
setState(911);
match(STRING);
}
}
}
setState(916);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,139,_ctx);
}
setState(919);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(917);
match(COMMA);
setState(918);
match(T__4);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringListContext extends ParserRuleContext {
public List STRING() { return getTokens(adlParser.STRING); }
public TerminalNode STRING(int i) {
return getToken(adlParser.STRING, i);
}
public StringListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterStringList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitStringList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitStringList(this);
else return visitor.visitChildren(this);
}
}
public final StringListContext stringList() throws RecognitionException {
StringListContext _localctx = new StringListContext(_ctx, getState());
enterRule(_localctx, 130, RULE_stringList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(921);
match(STRING);
setState(926);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(922);
match(COMMA);
setState(923);
match(STRING);
}
}
setState(928);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberListContext extends ParserRuleContext {
public List number() {
return getRuleContexts(NumberContext.class);
}
public NumberContext number(int i) {
return getRuleContext(NumberContext.class,i);
}
public NumberListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numberList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterNumberList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitNumberList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitNumberList(this);
else return visitor.visitChildren(this);
}
}
public final NumberListContext numberList() throws RecognitionException {
NumberListContext _localctx = new NumberListContext(_ctx, getState());
enterRule(_localctx, 132, RULE_numberList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(929);
number();
setState(934);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(930);
match(COMMA);
setState(931);
number();
}
}
setState(936);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BooleanListContext extends ParserRuleContext {
public List bool() {
return getRuleContexts(BoolContext.class);
}
public BoolContext bool(int i) {
return getRuleContext(BoolContext.class,i);
}
public BooleanListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterBooleanList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitBooleanList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitBooleanList(this);
else return visitor.visitChildren(this);
}
}
public final BooleanListContext booleanList() throws RecognitionException {
BooleanListContext _localctx = new BooleanListContext(_ctx, getState());
enterRule(_localctx, 134, RULE_booleanList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(937);
bool();
setState(942);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(938);
match(COMMA);
setState(939);
bool();
}
}
setState(944);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CodeIdentifierContext extends ParserRuleContext {
public List codeIdentifierPart() {
return getRuleContexts(CodeIdentifierPartContext.class);
}
public CodeIdentifierPartContext codeIdentifierPart(int i) {
return getRuleContext(CodeIdentifierPartContext.class,i);
}
public CodeIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codeIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterCodeIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitCodeIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitCodeIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final CodeIdentifierContext codeIdentifier() throws RecognitionException {
CodeIdentifierContext _localctx = new CodeIdentifierContext(_ctx, getState());
enterRule(_localctx, 136, RULE_codeIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(946);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(945);
codeIdentifierPart();
}
}
setState(948);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & ((1L << (T__3 - 4)) | (1L << (PAREN_OPEN - 4)) | (1L << (PAREN_CLOSE - 4)) | (1L << (PERIOD - 4)) | (1L << (COLON - 4)) | (1L << (MINUS - 4)) | (1L << (ISO_DATE_TIME - 4)) | (1L << (ISO_DATE - 4)) | (1L << (AT_CODE_VALUE - 4)) | (1L << (LANGUAGE - 4)) | (1L << (ARCHETYPE - 4)) | (1L << (TEMPLATE - 4)) | (1L << (TEMPLATE_OVERLAY - 4)) | (1L << (CONCEPT - 4)) | (1L << (DESCRIPTION - 4)) | (1L << (SPECIALISE - 4)) | (1L << (DEFINITION - 4)) | (1L << (MATCHES - 4)) | (1L << (USE_NODE - 4)) | (1L << (OCCURRENCES - 4)) | (1L << (CARDINALITY - 4)) | (1L << (UNORDERED - 4)) | (1L << (ORDERED - 4)) | (1L << (UNIQUE - 4)) | (1L << (EXISTENCE - 4)) | (1L << (CLOSED - 4)) | (1L << (ANNOTATIONS - 4)) | (1L << (TERMINOLOGY - 4)) | (1L << (TYPE_IDENTIFIER - 4)) | (1L << (NAME_IDENTIFIER - 4)) | (1L << (INTEGER - 4)))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CodeIdentifierPartContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public TerminalNode ISO_DATE_TIME() { return getToken(adlParser.ISO_DATE_TIME, 0); }
public TerminalNode ISO_DATE() { return getToken(adlParser.ISO_DATE, 0); }
public CodeIdentifierPartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_codeIdentifierPart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterCodeIdentifierPart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitCodeIdentifierPart(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitCodeIdentifierPart(this);
else return visitor.visitChildren(this);
}
}
public final CodeIdentifierPartContext codeIdentifierPart() throws RecognitionException {
CodeIdentifierPartContext _localctx = new CodeIdentifierPartContext(_ctx, getState());
enterRule(_localctx, 138, RULE_codeIdentifierPart);
try {
enterOuterAlt(_localctx, 1);
{
setState(960);
switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
case 1:
{
setState(950);
identifier();
}
break;
case 2:
{
setState(951);
number();
}
break;
case 3:
{
setState(952);
match(ISO_DATE_TIME);
}
break;
case 4:
{
setState(953);
match(ISO_DATE);
}
break;
case 5:
{
setState(954);
match(PERIOD);
}
break;
case 6:
{
setState(955);
match(MINUS);
}
break;
case 7:
{
setState(956);
match(PAREN_OPEN);
}
break;
case 8:
{
setState(957);
match(PAREN_CLOSE);
}
break;
case 9:
{
setState(958);
match(COLON);
}
break;
case 10:
{
setState(959);
match(T__3);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierContext extends ParserRuleContext {
public NameIdentifierContext nameIdentifier() {
return getRuleContext(NameIdentifierContext.class,0);
}
public TypeIdentifierContext typeIdentifier() {
return getRuleContext(TypeIdentifierContext.class,0);
}
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 140, RULE_identifier);
try {
setState(964);
switch (_input.LA(1)) {
case AT_CODE_VALUE:
case LANGUAGE:
case ARCHETYPE:
case TEMPLATE:
case TEMPLATE_OVERLAY:
case CONCEPT:
case DESCRIPTION:
case SPECIALISE:
case DEFINITION:
case MATCHES:
case USE_NODE:
case OCCURRENCES:
case CARDINALITY:
case UNORDERED:
case ORDERED:
case UNIQUE:
case EXISTENCE:
case CLOSED:
case ANNOTATIONS:
case TERMINOLOGY:
case NAME_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(962);
nameIdentifier();
}
break;
case TYPE_IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(963);
typeIdentifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BoolContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(adlParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(adlParser.FALSE, 0); }
public BoolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bool; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterBool(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitBool(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitBool(this);
else return visitor.visitChildren(this);
}
}
public final BoolContext bool() throws RecognitionException {
BoolContext _localctx = new BoolContext(_ctx, getState());
enterRule(_localctx, 142, RULE_bool);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(966);
_la = _input.LA(1);
if ( !(_la==TRUE || _la==FALSE) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NameIdentifierContext extends ParserRuleContext {
public TerminalNode NAME_IDENTIFIER() { return getToken(adlParser.NAME_IDENTIFIER, 0); }
public KeywordContext keyword() {
return getRuleContext(KeywordContext.class,0);
}
public TerminalNode AT_CODE_VALUE() { return getToken(adlParser.AT_CODE_VALUE, 0); }
public NameIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nameIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterNameIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitNameIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitNameIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final NameIdentifierContext nameIdentifier() throws RecognitionException {
NameIdentifierContext _localctx = new NameIdentifierContext(_ctx, getState());
enterRule(_localctx, 144, RULE_nameIdentifier);
try {
setState(971);
switch (_input.LA(1)) {
case NAME_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(968);
match(NAME_IDENTIFIER);
}
break;
case LANGUAGE:
case ARCHETYPE:
case TEMPLATE:
case TEMPLATE_OVERLAY:
case CONCEPT:
case DESCRIPTION:
case SPECIALISE:
case DEFINITION:
case MATCHES:
case USE_NODE:
case OCCURRENCES:
case CARDINALITY:
case UNORDERED:
case ORDERED:
case UNIQUE:
case EXISTENCE:
case CLOSED:
case ANNOTATIONS:
case TERMINOLOGY:
enterOuterAlt(_localctx, 2);
{
setState(969);
keyword();
}
break;
case AT_CODE_VALUE:
enterOuterAlt(_localctx, 3);
{
setState(970);
match(AT_CODE_VALUE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeIdentifierWithGenericsContext extends ParserRuleContext {
public TypeIdentifierContext mainType;
public TypeIdentifierContext genericType;
public List typeIdentifier() {
return getRuleContexts(TypeIdentifierContext.class);
}
public TypeIdentifierContext typeIdentifier(int i) {
return getRuleContext(TypeIdentifierContext.class,i);
}
public TypeIdentifierWithGenericsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeIdentifierWithGenerics; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterTypeIdentifierWithGenerics(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitTypeIdentifierWithGenerics(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitTypeIdentifierWithGenerics(this);
else return visitor.visitChildren(this);
}
}
public final TypeIdentifierWithGenericsContext typeIdentifierWithGenerics() throws RecognitionException {
TypeIdentifierWithGenericsContext _localctx = new TypeIdentifierWithGenericsContext(_ctx, getState());
enterRule(_localctx, 146, RULE_typeIdentifierWithGenerics);
try {
enterOuterAlt(_localctx, 1);
{
setState(973);
((TypeIdentifierWithGenericsContext)_localctx).mainType = typeIdentifier();
setState(978);
switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
case 1:
{
setState(974);
match(LT);
setState(975);
((TypeIdentifierWithGenericsContext)_localctx).genericType = typeIdentifier();
setState(976);
match(GT);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeIdentifierContext extends ParserRuleContext {
public TerminalNode TYPE_IDENTIFIER() { return getToken(adlParser.TYPE_IDENTIFIER, 0); }
public TypeIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterTypeIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitTypeIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitTypeIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final TypeIdentifierContext typeIdentifier() throws RecognitionException {
TypeIdentifierContext _localctx = new TypeIdentifierContext(_ctx, getState());
enterRule(_localctx, 148, RULE_typeIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(980);
match(TYPE_IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KeywordContext extends ParserRuleContext {
public TerminalNode LANGUAGE() { return getToken(adlParser.LANGUAGE, 0); }
public TerminalNode ARCHETYPE() { return getToken(adlParser.ARCHETYPE, 0); }
public TerminalNode DESCRIPTION() { return getToken(adlParser.DESCRIPTION, 0); }
public TerminalNode CONCEPT() { return getToken(adlParser.CONCEPT, 0); }
public TerminalNode TERMINOLOGY() { return getToken(adlParser.TERMINOLOGY, 0); }
public TerminalNode DEFINITION() { return getToken(adlParser.DEFINITION, 0); }
public TerminalNode MATCHES() { return getToken(adlParser.MATCHES, 0); }
public TerminalNode USE_NODE() { return getToken(adlParser.USE_NODE, 0); }
public TerminalNode OCCURRENCES() { return getToken(adlParser.OCCURRENCES, 0); }
public TerminalNode CARDINALITY() { return getToken(adlParser.CARDINALITY, 0); }
public TerminalNode ORDERED() { return getToken(adlParser.ORDERED, 0); }
public TerminalNode UNORDERED() { return getToken(adlParser.UNORDERED, 0); }
public TerminalNode EXISTENCE() { return getToken(adlParser.EXISTENCE, 0); }
public TerminalNode CLOSED() { return getToken(adlParser.CLOSED, 0); }
public TerminalNode ANNOTATIONS() { return getToken(adlParser.ANNOTATIONS, 0); }
public TerminalNode TEMPLATE() { return getToken(adlParser.TEMPLATE, 0); }
public TerminalNode TEMPLATE_OVERLAY() { return getToken(adlParser.TEMPLATE_OVERLAY, 0); }
public TerminalNode SPECIALISE() { return getToken(adlParser.SPECIALISE, 0); }
public TerminalNode UNIQUE() { return getToken(adlParser.UNIQUE, 0); }
public KeywordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_keyword; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterKeyword(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitKeyword(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitKeyword(this);
else return visitor.visitChildren(this);
}
}
public final KeywordContext keyword() throws RecognitionException {
KeywordContext _localctx = new KeywordContext(_ctx, getState());
enterRule(_localctx, 150, RULE_keyword);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(982);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LANGUAGE) | (1L << ARCHETYPE) | (1L << TEMPLATE) | (1L << TEMPLATE_OVERLAY) | (1L << CONCEPT) | (1L << DESCRIPTION) | (1L << SPECIALISE) | (1L << DEFINITION) | (1L << MATCHES) | (1L << USE_NODE) | (1L << OCCURRENCES) | (1L << CARDINALITY) | (1L << UNORDERED) | (1L << ORDERED) | (1L << UNIQUE) | (1L << EXISTENCE) | (1L << CLOSED) | (1L << ANNOTATIONS) | (1L << TERMINOLOGY))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathSegmentContext extends ParserRuleContext {
public NameIdentifierContext nameIdentifier() {
return getRuleContext(NameIdentifierContext.class,0);
}
public AtCodeContext atCode() {
return getRuleContext(AtCodeContext.class,0);
}
public PathSegmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathSegment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterPathSegment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitPathSegment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitPathSegment(this);
else return visitor.visitChildren(this);
}
}
public final PathSegmentContext pathSegment() throws RecognitionException {
PathSegmentContext _localctx = new PathSegmentContext(_ctx, getState());
enterRule(_localctx, 152, RULE_pathSegment);
try {
enterOuterAlt(_localctx, 1);
{
setState(984);
nameIdentifier();
setState(986);
switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
case 1:
{
setState(985);
atCode();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RmPathContext extends ParserRuleContext {
public List pathSegment() {
return getRuleContexts(PathSegmentContext.class);
}
public PathSegmentContext pathSegment(int i) {
return getRuleContext(PathSegmentContext.class,i);
}
public RmPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rmPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterRmPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitRmPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitRmPath(this);
else return visitor.visitChildren(this);
}
}
public final RmPathContext rmPath() throws RecognitionException {
RmPathContext _localctx = new RmPathContext(_ctx, getState());
enterRule(_localctx, 154, RULE_rmPath);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(989);
_la = _input.LA(1);
if (_la==T__3) {
{
setState(988);
match(T__3);
}
}
setState(991);
pathSegment();
setState(996);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,151,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(992);
match(T__3);
setState(993);
pathSegment();
}
}
}
setState(998);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,151,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UrlContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List codeIdentifierPart() {
return getRuleContexts(CodeIdentifierPartContext.class);
}
public CodeIdentifierPartContext codeIdentifierPart(int i) {
return getRuleContext(CodeIdentifierPartContext.class,i);
}
public List UNICODE_CHAR() { return getTokens(adlParser.UNICODE_CHAR); }
public TerminalNode UNICODE_CHAR(int i) {
return getToken(adlParser.UNICODE_CHAR, i);
}
public UrlContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_url; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterUrl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitUrl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitUrl(this);
else return visitor.visitChildren(this);
}
}
public final UrlContext url() throws RecognitionException {
UrlContext _localctx = new UrlContext(_ctx, getState());
enterRule(_localctx, 156, RULE_url);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(999);
identifier();
setState(1000);
match(COLON);
setState(1011);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
setState(1011);
switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) {
case 1:
{
setState(1001);
codeIdentifierPart();
}
break;
case 2:
{
setState(1002);
match(UNDERSCORE);
}
break;
case 3:
{
setState(1003);
match(PERIOD);
}
break;
case 4:
{
setState(1004);
match(EQUALS);
}
break;
case 5:
{
setState(1005);
match(QUESTION);
}
break;
case 6:
{
setState(1006);
match(MINUS);
}
break;
case 7:
{
setState(1007);
match(T__3);
}
break;
case 8:
{
setState(1008);
match(AMP);
}
break;
case 9:
{
setState(1009);
match(SEMICOLON);
}
break;
case 10:
{
setState(1010);
match(UNICODE_CHAR);
}
break;
}
}
setState(1013);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 4)) & ~0x3f) == 0 && ((1L << (_la - 4)) & ((1L << (T__3 - 4)) | (1L << (EQUALS - 4)) | (1L << (PAREN_OPEN - 4)) | (1L << (PAREN_CLOSE - 4)) | (1L << (PERIOD - 4)) | (1L << (COLON - 4)) | (1L << (SEMICOLON - 4)) | (1L << (MINUS - 4)) | (1L << (UNDERSCORE - 4)) | (1L << (AMP - 4)) | (1L << (QUESTION - 4)) | (1L << (ISO_DATE_TIME - 4)) | (1L << (ISO_DATE - 4)) | (1L << (AT_CODE_VALUE - 4)) | (1L << (LANGUAGE - 4)) | (1L << (ARCHETYPE - 4)) | (1L << (TEMPLATE - 4)) | (1L << (TEMPLATE_OVERLAY - 4)) | (1L << (CONCEPT - 4)) | (1L << (DESCRIPTION - 4)) | (1L << (SPECIALISE - 4)) | (1L << (DEFINITION - 4)) | (1L << (MATCHES - 4)) | (1L << (USE_NODE - 4)) | (1L << (OCCURRENCES - 4)) | (1L << (CARDINALITY - 4)) | (1L << (UNORDERED - 4)) | (1L << (ORDERED - 4)) | (1L << (UNIQUE - 4)) | (1L << (EXISTENCE - 4)) | (1L << (CLOSED - 4)) | (1L << (ANNOTATIONS - 4)) | (1L << (TERMINOLOGY - 4)) | (1L << (TYPE_IDENTIFIER - 4)) | (1L << (NAME_IDENTIFIER - 4)) | (1L << (INTEGER - 4)) | (1L << (UNICODE_CHAR - 4)))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberOrStarContext extends ParserRuleContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public NumberOrStarContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numberOrStar; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterNumberOrStar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitNumberOrStar(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitNumberOrStar(this);
else return visitor.visitChildren(this);
}
}
public final NumberOrStarContext numberOrStar() throws RecognitionException {
NumberOrStarContext _localctx = new NumberOrStarContext(_ctx, getState());
enterRule(_localctx, 158, RULE_numberOrStar);
try {
setState(1017);
switch (_input.LA(1)) {
case MINUS:
case INTEGER:
enterOuterAlt(_localctx, 1);
{
setState(1015);
number();
}
break;
case ASTERISK:
enterOuterAlt(_localctx, 2);
{
setState(1016);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberContext extends ParserRuleContext {
public List INTEGER() { return getTokens(adlParser.INTEGER); }
public TerminalNode INTEGER(int i) {
return getToken(adlParser.INTEGER, i);
}
public NumberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_number; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).enterNumber(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof adlListener ) ((adlListener)listener).exitNumber(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof adlVisitor ) return ((adlVisitor)visitor).visitNumber(this);
else return visitor.visitChildren(this);
}
}
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 160, RULE_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1020);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(1019);
match(MINUS);
}
}
setState(1022);
match(INTEGER);
setState(1025);
switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
case 1:
{
setState(1023);
match(PERIOD);
setState(1024);
match(INTEGER);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3G\u0406\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\3\2\3\2\5\2"+
"\u00a7\n\2\3\2\5\2\u00aa\n\2\3\2\5\2\u00ad\n\2\3\2\5\2\u00b0\n\2\3\2\5"+
"\2\u00b3\n\2\3\2\5\2\u00b6\n\2\3\2\5\2\u00b9\n\2\3\2\3\2\3\3\3\3\5\3\u00bf"+
"\n\3\3\4\3\4\3\4\7\4\u00c4\n\4\f\4\16\4\u00c7\13\4\3\4\3\4\5\4\u00cb\n"+
"\4\3\4\3\4\3\4\6\4\u00d0\n\4\r\4\16\4\u00d1\3\4\3\4\3\4\6\4\u00d7\n\4"+
"\r\4\16\4\u00d8\3\4\3\4\3\4\3\4\7\4\u00df\n\4\f\4\16\4\u00e2\13\4\3\4"+
"\3\4\5\4\u00e6\n\4\3\5\3\5\3\6\3\6\3\6\3\6\3\6\5\6\u00ef\n\6\3\6\3\6\3"+
"\7\3\7\3\7\7\7\u00f6\n\7\f\7\16\7\u00f9\13\7\3\b\3\b\3\b\5\b\u00fe\n\b"+
"\3\t\7\t\u0101\n\t\f\t\16\t\u0104\13\t\3\n\3\n\3\13\3\13\3\13\3\13\3\f"+
"\3\f\3\r\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\20\3\20\3\20\3\21\3\21"+
"\3\21\3\22\5\22\u011e\n\22\3\22\3\22\5\22\u0122\n\22\3\22\3\22\5\22\u0126"+
"\n\22\3\22\3\22\3\22\5\22\u012b\n\22\3\22\5\22\u012e\n\22\3\22\3\22\3"+
"\22\5\22\u0133\n\22\3\22\3\22\5\22\u0137\n\22\3\22\5\22\u013a\n\22\3\23"+
"\3\23\5\23\u013e\n\23\3\23\5\23\u0141\n\23\3\23\5\23\u0144\n\23\3\24\3"+
"\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u0153"+
"\n\25\3\26\3\26\3\26\6\26\u0158\n\26\r\26\16\26\u0159\3\26\3\26\3\26\3"+
"\26\3\26\3\26\5\26\u0162\n\26\3\27\3\27\3\27\3\27\5\27\u0168\n\27\3\30"+
"\3\30\6\30\u016c\n\30\r\30\16\30\u016d\5\30\u0170\n\30\3\31\3\31\3\31"+
"\5\31\u0175\n\31\3\32\3\32\3\32\5\32\u017a\n\32\3\33\3\33\3\33\7\33\u017f"+
"\n\33\f\33\16\33\u0182\13\33\3\34\3\34\3\34\3\34\3\35\3\35\3\35\5\35\u018b"+
"\n\35\3\35\3\35\3\35\5\35\u0190\n\35\3\35\3\35\3\35\5\35\u0195\n\35\3"+
"\35\3\35\3\35\5\35\u019a\n\35\3\35\3\35\3\35\5\35\u019f\n\35\3\35\3\35"+
"\3\35\5\35\u01a4\n\35\3\35\3\35\3\35\5\35\u01a9\n\35\3\35\5\35\u01ac\n"+
"\35\3\36\3\36\3\36\3\36\5\36\u01b2\n\36\3\36\3\36\3\37\3\37\3\37\5\37"+
"\u01b9\n\37\3\37\5\37\u01bc\n\37\3\37\3\37\3\37\3\37\3\37\5\37\u01c3\n"+
"\37\3\37\3\37\3\37\5\37\u01c8\n\37\3\37\3\37\5\37\u01cc\n\37\3 \3 \7 "+
"\u01d0\n \f \16 \u01d3\13 \5 \u01d5\n \3 \3 \7 \u01d9\n \f \16 \u01dc"+
"\13 \5 \u01de\n \3!\3!\3!\3!\3!\3!\3\"\3\"\5\"\u01e8\n\"\3\"\3\"\3\"\3"+
"\"\3\"\3\"\3\"\5\"\u01f1\n\"\3#\3#\5#\u01f5\n#\3$\3$\3$\3$\7$\u01fb\n"+
"$\f$\16$\u01fe\13$\5$\u0200\n$\3%\3%\3%\3%\3%\7%\u0207\n%\f%\16%\u020a"+
"\13%\5%\u020c\n%\3&\3&\3&\3&\3&\7&\u0213\n&\f&\16&\u0216\13&\5&\u0218"+
"\n&\3\'\3\'\3\'\3\'\3\'\7\'\u021f\n\'\f\'\16\'\u0222\13\'\5\'\u0224\n"+
"\'\3(\3(\3(\3(\5(\u022a\n(\5(\u022c\n(\3(\5(\u022f\n(\3)\5)\u0232\n)\3"+
")\3)\7)\u0236\n)\f)\16)\u0239\13)\3*\3*\3*\3*\3*\3*\3*\3*\5*\u0243\n*"+
"\3+\7+\u0246\n+\f+\16+\u0249\13+\3,\7,\u024c\n,\f,\16,\u024f\13,\3-\3"+
"-\5-\u0253\n-\3-\5-\u0256\n-\3-\3-\3-\3-\3-\5-\u025d\n-\3-\3-\5-\u0261"+
"\n-\3-\3-\3-\3-\3-\5-\u0268\n-\3.\3.\3.\3.\7.\u026e\n.\f.\16.\u0271\13"+
".\3.\3.\3/\3/\3/\7/\u0278\n/\f/\16/\u027b\13/\3\60\3\60\3\60\3\60\3\60"+
"\3\60\3\60\3\60\3\60\7\60\u0286\n\60\f\60\16\60\u0289\13\60\3\60\3\60"+
"\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63"+
"\3\63\5\63\u029c\n\63\5\63\u029e\n\63\3\63\3\63\5\63\u02a2\n\63\3\63\3"+
"\63\3\64\3\64\5\64\u02a8\n\64\3\64\3\64\3\64\5\64\u02ad\n\64\3\64\3\64"+
"\3\64\3\64\3\64\3\64\5\64\u02b5\n\64\5\64\u02b7\n\64\3\64\3\64\5\64\u02bb"+
"\n\64\5\64\u02bd\n\64\5\64\u02bf\n\64\3\64\3\64\3\64\5\64\u02c4\n\64\3"+
"\65\3\65\5\65\u02c8\n\65\3\65\3\65\3\65\5\65\u02cd\n\65\3\65\3\65\3\65"+
"\3\65\3\65\5\65\u02d4\n\65\5\65\u02d6\n\65\3\65\3\65\5\65\u02da\n\65\5"+
"\65\u02dc\n\65\5\65\u02de\n\65\3\65\3\65\5\65\u02e2\n\65\3\66\3\66\5\66"+
"\u02e6\n\66\3\66\3\66\3\66\5\66\u02eb\n\66\3\66\3\66\3\66\3\66\3\66\5"+
"\66\u02f2\n\66\5\66\u02f4\n\66\3\66\3\66\5\66\u02f8\n\66\5\66\u02fa\n"+
"\66\5\66\u02fc\n\66\3\66\3\66\5\66\u0300\n\66\3\67\3\67\5\67\u0304\n\67"+
"\3\67\3\67\3\67\5\67\u0309\n\67\3\67\3\67\3\67\3\67\3\67\5\67\u0310\n"+
"\67\5\67\u0312\n\67\3\67\3\67\5\67\u0316\n\67\5\67\u0318\n\67\5\67\u031a"+
"\n\67\3\67\3\67\5\67\u031e\n\67\38\38\58\u0322\n8\38\38\58\u0326\n8\3"+
"8\38\58\u032a\n8\38\38\58\u032e\n8\38\38\38\38\58\u0334\n8\58\u0336\n"+
"8\38\38\58\u033a\n8\58\u033c\n8\58\u033e\n8\38\38\58\u0342\n8\39\39\3"+
"9\3:\3:\3:\3;\3;\3;\3;\3;\5;\u034f\n;\3;\3;\5;\u0353\n;\3;\3;\3;\3;\3"+
";\5;\u035a\n;\3;\3;\5;\u035e\n;\3;\3;\5;\u0362\n;\3;\3;\3;\3;\3;\3;\3"+
";\3;\5;\u036c\n;\3<\6<\u036f\n<\r<\16<\u0370\3=\3=\3=\3=\3>\3>\3>\7>\u037a"+
"\n>\f>\16>\u037d\13>\3?\3?\3?\3?\3?\3?\3@\6@\u0386\n@\r@\16@\u0387\3A"+
"\3A\3A\3A\3A\3A\3B\3B\3B\7B\u0393\nB\fB\16B\u0396\13B\3B\3B\5B\u039a\n"+
"B\3C\3C\3C\7C\u039f\nC\fC\16C\u03a2\13C\3D\3D\3D\7D\u03a7\nD\fD\16D\u03aa"+
"\13D\3E\3E\3E\7E\u03af\nE\fE\16E\u03b2\13E\3F\6F\u03b5\nF\rF\16F\u03b6"+
"\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\5G\u03c3\nG\3H\3H\5H\u03c7\nH\3I\3I\3J"+
"\3J\3J\5J\u03ce\nJ\3K\3K\3K\3K\3K\5K\u03d5\nK\3L\3L\3M\3M\3N\3N\5N\u03dd"+
"\nN\3O\5O\u03e0\nO\3O\3O\3O\7O\u03e5\nO\fO\16O\u03e8\13O\3P\3P\3P\3P\3"+
"P\3P\3P\3P\3P\3P\3P\3P\6P\u03f6\nP\rP\16P\u03f7\3Q\3Q\5Q\u03fc\nQ\3R\5"+
"R\u03ff\nR\3R\3R\3R\5R\u0404\nR\3R\2\2S\2\4\6\b\n\f\16\20\22\24\26\30"+
"\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080"+
"\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098"+
"\u009a\u009c\u009e\u00a0\u00a2\2\b\3\2&(\4\2\13\13\23\23\3\2\6\6\3\2\30"+
"\30\3\2?@\5\2%/\63\67<>\u0475\2\u00a4\3\2\2\2\4\u00be\3\2\2\2\6\u00ca"+
"\3\2\2\2\b\u00e7\3\2\2\2\n\u00e9\3\2\2\2\f\u00f2\3\2\2\2\16\u00fa\3\2"+
"\2\2\20\u0102\3\2\2\2\22\u0105\3\2\2\2\24\u0107\3\2\2\2\26\u010b\3\2\2"+
"\2\30\u010d\3\2\2\2\32\u0110\3\2\2\2\34\u0113\3\2\2\2\36\u0116\3\2\2\2"+
" \u0119\3\2\2\2\"\u0139\3\2\2\2$\u013b\3\2\2\2&\u0145\3\2\2\2(\u0152\3"+
"\2\2\2*\u0161\3\2\2\2,\u0167\3\2\2\2.\u016f\3\2\2\2\60\u0174\3\2\2\2\62"+
"\u0176\3\2\2\2\64\u017b\3\2\2\2\66\u0183\3\2\2\28\u01ab\3\2\2\2:\u01ad"+
"\3\2\2\2<\u01cb\3\2\2\2>\u01d4\3\2\2\2@\u01df\3\2\2\2B\u01e7\3\2\2\2D"+
"\u01f4\3\2\2\2F\u01ff\3\2\2\2H\u020b\3\2\2\2J\u0217\3\2\2\2L\u0223\3\2"+
"\2\2N\u022e\3\2\2\2P\u0231\3\2\2\2R\u0242\3\2\2\2T\u0247\3\2\2\2V\u024d"+
"\3\2\2\2X\u0267\3\2\2\2Z\u0269\3\2\2\2\\\u0274\3\2\2\2^\u027c\3\2\2\2"+
"`\u028c\3\2\2\2b\u028e\3\2\2\2d\u0294\3\2\2\2f\u02c3\3\2\2\2h\u02e1\3"+
"\2\2\2j\u02ff\3\2\2\2l\u031d\3\2\2\2n\u0341\3\2\2\2p\u0343\3\2\2\2r\u0346"+
"\3\2\2\2t\u036b\3\2\2\2v\u036e\3\2\2\2x\u0372\3\2\2\2z\u0376\3\2\2\2|"+
"\u037e\3\2\2\2~\u0385\3\2\2\2\u0080\u0389\3\2\2\2\u0082\u038f\3\2\2\2"+
"\u0084\u039b\3\2\2\2\u0086\u03a3\3\2\2\2\u0088\u03ab\3\2\2\2\u008a\u03b4"+
"\3\2\2\2\u008c\u03c2\3\2\2\2\u008e\u03c6\3\2\2\2\u0090\u03c8\3\2\2\2\u0092"+
"\u03cd\3\2\2\2\u0094\u03cf\3\2\2\2\u0096\u03d6\3\2\2\2\u0098\u03d8\3\2"+
"\2\2\u009a\u03da\3\2\2\2\u009c\u03df\3\2\2\2\u009e\u03e9\3\2\2\2\u00a0"+
"\u03fb\3\2\2\2\u00a2\u03fe\3\2\2\2\u00a4\u00a6\5\n\6\2\u00a5\u00a7\5\30"+
"\r\2\u00a6\u00a5\3\2\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00a9\3\2\2\2\u00a8"+
"\u00aa\5\32\16\2\u00a9\u00a8\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ac\3"+
"\2\2\2\u00ab\u00ad\5\34\17\2\u00ac\u00ab\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad"+
"\u00af\3\2\2\2\u00ae\u00b0\5\36\20\2\u00af\u00ae\3\2\2\2\u00af\u00b0\3"+
"\2\2\2\u00b0\u00b2\3\2\2\2\u00b1\u00b3\5 \21\2\u00b2\u00b1\3\2\2\2\u00b2"+
"\u00b3\3\2\2\2\u00b3\u00b5\3\2\2\2\u00b4\u00b6\5p9\2\u00b5\u00b4\3\2\2"+
"\2\u00b5\u00b6\3\2\2\2\u00b6\u00b8\3\2\2\2\u00b7\u00b9\5r:\2\u00b8\u00b7"+
"\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bb\7\2\2\3\u00bb"+
"\3\3\2\2\2\u00bc\u00bf\5\u008eH\2\u00bd\u00bf\7C\2\2\u00be\u00bc\3\2\2"+
"\2\u00be\u00bd\3\2\2\2\u00bf\5\3\2\2\2\u00c0\u00c5\5\u008eH\2\u00c1\u00c2"+
"\7\20\2\2\u00c2\u00c4\5\u008eH\2\u00c3\u00c1\3\2\2\2\u00c4\u00c7\3\2\2"+
"\2\u00c5\u00c3\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6\u00c8\3\2\2\2\u00c7\u00c5"+
"\3\2\2\2\u00c8\u00c9\7\3\2\2\u00c9\u00cb\3\2\2\2\u00ca\u00c0\3\2\2\2\u00ca"+
"\u00cb\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cf\5\u008eH\2\u00cd\u00d0"+
"\7\24\2\2\u00ce\u00d0\5\u008eH\2\u00cf\u00cd\3\2\2\2\u00cf\u00ce\3\2\2"+
"\2\u00d0\u00d1\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d3"+
"\3\2\2\2\u00d3\u00d6\7\20\2\2\u00d4\u00d7\5\4\3\2\u00d5\u00d7\7\24\2\2"+
"\u00d6\u00d4\3\2\2\2\u00d6\u00d5\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8\u00d6"+
"\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9\u00da\3\2\2\2\u00da\u00db\7\20\2\2"+
"\u00db\u00e0\5\u008eH\2\u00dc\u00dd\7\20\2\2\u00dd\u00df\7C\2\2\u00de"+
"\u00dc\3\2\2\2\u00df\u00e2\3\2\2\2\u00e0\u00de\3\2\2\2\u00e0\u00e1\3\2"+
"\2\2\u00e1\u00e5\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e3\u00e4\7\24\2\2\u00e4"+
"\u00e6\5\u008eH\2\u00e5\u00e3\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\7\3\2"+
"\2\2\u00e7\u00e8\t\2\2\2\u00e8\t\3\2\2\2\u00e9\u00ee\5\b\5\2\u00ea\u00eb"+
"\7\n\2\2\u00eb\u00ec\5\f\7\2\u00ec\u00ed\7\13\2\2\u00ed\u00ef\3\2\2\2"+
"\u00ee\u00ea\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f1"+
"\5\6\4\2\u00f1\13\3\2\2\2\u00f2\u00f7\5\16\b\2\u00f3\u00f4\7\23\2\2\u00f4"+
"\u00f6\5\16\b\2\u00f5\u00f3\3\2\2\2\u00f6\u00f9\3\2\2\2\u00f7\u00f5\3"+
"\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\r\3\2\2\2\u00f9\u00f7\3\2\2\2\u00fa\u00fd"+
"\5\u008eH\2\u00fb\u00fc\7\t\2\2\u00fc\u00fe\5\20\t\2\u00fd\u00fb\3\2\2"+
"\2\u00fd\u00fe\3\2\2\2\u00fe\17\3\2\2\2\u00ff\u0101\5\22\n\2\u0100\u00ff"+
"\3\2\2\2\u0101\u0104\3\2\2\2\u0102\u0100\3\2\2\2\u0102\u0103\3\2\2\2\u0103"+
"\21\3\2\2\2\u0104\u0102\3\2\2\2\u0105\u0106\n\3\2\2\u0106\23\3\2\2\2\u0107"+
"\u0108\7\f\2\2\u0108\u0109\7$\2\2\u0109\u010a\7\r\2\2\u010a\25\3\2\2\2"+
"\u010b\u010c\7+\2\2\u010c\27\3\2\2\2\u010d\u010e\5\26\f\2\u010e\u010f"+
"\5\6\4\2\u010f\31\3\2\2\2\u0110\u0111\7)\2\2\u0111\u0112\5\24\13\2\u0112"+
"\33\3\2\2\2\u0113\u0114\7%\2\2\u0114\u0115\5v<\2\u0115\35\3\2\2\2\u0116"+
"\u0117\7*\2\2\u0117\u0118\5v<\2\u0118\37\3\2\2\2\u0119\u011a\7,\2\2\u011a"+
"\u011b\5$\23\2\u011b!\3\2\2\2\u011c\u011e\5,\27\2\u011d\u011c\3\2\2\2"+
"\u011d\u011e\3\2\2\2\u011e\u011f\3\2\2\2\u011f\u013a\5t;\2\u0120\u0122"+
"\5,\27\2\u0121\u0120\3\2\2\2\u0121\u0122\3\2\2\2\u0122\u0123\3\2\2\2\u0123"+
"\u013a\5$\23\2\u0124\u0126\5,\27\2\u0125\u0124\3\2\2\2\u0125\u0126\3\2"+
"\2\2\u0126\u0127\3\2\2\2\u0127\u0128\7.\2\2\u0128\u012a\5\u0094K\2\u0129"+
"\u012b\5\24\13\2\u012a\u0129\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u012d\3"+
"\2\2\2\u012c\u012e\5&\24\2\u012d\u012c\3\2\2\2\u012d\u012e\3\2\2\2\u012e"+
"\u012f\3\2\2\2\u012f\u0130\5\u009cO\2\u0130\u013a\3\2\2\2\u0131\u0133"+
"\5,\27\2\u0132\u0131\3\2\2\2\u0132\u0133\3\2\2\2\u0133\u0134\3\2\2\2\u0134"+
"\u013a\5<\37\2\u0135\u0137\5,\27\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2"+
"\2\2\u0137\u0138\3\2\2\2\u0138\u013a\5B\"\2\u0139\u011d\3\2\2\2\u0139"+
"\u0121\3\2\2\2\u0139\u0125\3\2\2\2\u0139\u0132\3\2\2\2\u0139\u0136\3\2"+
"\2\2\u013a#\3\2\2\2\u013b\u013d\5\u0094K\2\u013c\u013e\5\24\13\2\u013d"+
"\u013c\3\2\2\2\u013d\u013e\3\2\2\2\u013e\u0140\3\2\2\2\u013f\u0141\5&"+
"\24\2\u0140\u013f\3\2\2\2\u0140\u0141\3\2\2\2\u0141\u0143\3\2\2\2\u0142"+
"\u0144\5*\26\2\u0143\u0142\3\2\2\2\u0143\u0144\3\2\2\2\u0144%\3\2\2\2"+
"\u0145\u0146\7/\2\2\u0146\u0147\7-\2\2\u0147\u0148\7\4\2\2\u0148\u0149"+
"\5(\25\2\u0149\u014a\7\5\2\2\u014a\'\3\2\2\2\u014b\u014c\7C\2\2\u014c"+
"\u014d\7\b\2\2\u014d\u0153\7C\2\2\u014e\u014f\7C\2\2\u014f\u0150\7\b\2"+
"\2\u0150\u0153\7\27\2\2\u0151\u0153\7C\2\2\u0152\u014b\3\2\2\2\u0152\u014e"+
"\3\2\2\2\u0152\u0151\3\2\2\2\u0153)\3\2\2\2\u0154\u0155\7-\2\2\u0155\u0157"+
"\7\4\2\2\u0156\u0158\5X-\2\u0157\u0156\3\2\2\2\u0158\u0159\3\2\2\2\u0159"+
"\u0157\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u015b\3\2\2\2\u015b\u015c\7\5"+
"\2\2\u015c\u0162\3\2\2\2\u015d\u015e\7-\2\2\u015e\u015f\7\4\2\2\u015f"+
"\u0160\7\27\2\2\u0160\u0162\7\5\2\2\u0161\u0154\3\2\2\2\u0161\u015d\3"+
"\2\2\2\u0162+\3\2\2\2\u0163\u0164\78\2\2\u0164\u0168\5\24\13\2\u0165\u0166"+
"\79\2\2\u0166\u0168\5\24\13\2\u0167\u0163\3\2\2\2\u0167\u0165\3\2\2\2"+
"\u0168-\3\2\2\2\u0169\u0170\7\27\2\2\u016a\u016c\5\60\31\2\u016b\u016a"+
"\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016b\3\2\2\2\u016d\u016e\3\2\2\2\u016e"+
"\u0170\3\2\2\2\u016f\u0169\3\2\2\2\u016f\u016b\3\2\2\2\u0170/\3\2\2\2"+
"\u0171\u0175\5\"\22\2\u0172\u0175\58\35\2\u0173\u0175\5\62\32\2\u0174"+
"\u0171\3\2\2\2\u0174\u0172\3\2\2\2\u0174\u0173\3\2\2\2\u0175\61\3\2\2"+
"\2\u0176\u0179\5\64\33\2\u0177\u0178\7\23\2\2\u0178\u017a\5\u00a2R\2\u0179"+
"\u0177\3\2\2\2\u0179\u017a\3\2\2\2\u017a\63\3\2\2\2\u017b\u0180\5\66\34"+
"\2\u017c\u017d\7\21\2\2\u017d\u017f\5\66\34\2\u017e\u017c\3\2\2\2\u017f"+
"\u0182\3\2\2\2\u0180\u017e\3\2\2\2\u0180\u0181\3\2\2\2\u0181\65\3\2\2"+
"\2\u0182\u0180\3\2\2\2\u0183\u0184\5\u00a2R\2\u0184\u0185\7\26\2\2\u0185"+
"\u0186\5|?\2\u0186\67\3\2\2\2\u0187\u018a\5D#\2\u0188\u0189\7\23\2\2\u0189"+
"\u018b\7D\2\2\u018a\u0188\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u01ac\3\2"+
"\2\2\u018c\u018f\5F$\2\u018d\u018e\7\23\2\2\u018e\u0190\5\u00a2R\2\u018f"+
"\u018d\3\2\2\2\u018f\u0190\3\2\2\2\u0190\u01ac\3\2\2\2\u0191\u0194\5\u0088"+
"E\2\u0192\u0193\7\23\2\2\u0193\u0195\5\u0090I\2\u0194\u0192\3\2\2\2\u0194"+
"\u0195\3\2\2\2\u0195\u01ac\3\2\2\2\u0196\u0199\5H%\2\u0197\u0198\7\23"+
"\2\2\u0198\u019a\7!\2\2\u0199\u0197\3\2\2\2\u0199\u019a\3\2\2\2\u019a"+
"\u01ac\3\2\2\2\u019b\u019e\5J&\2\u019c\u019d\7\23\2\2\u019d\u019f\7\""+
"\2\2\u019e\u019c\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01ac\3\2\2\2\u01a0"+
"\u01a3\5L\'\2\u01a1\u01a2\7\23\2\2\u01a2\u01a4\7#\2\2\u01a3\u01a1\3\2"+
"\2\2\u01a3\u01a4\3\2\2\2\u01a4\u01ac\3\2\2\2\u01a5\u01a8\5N(\2\u01a6\u01a7"+
"\7\23\2\2\u01a7\u01a9\7 \2\2\u01a8\u01a6\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9"+
"\u01ac\3\2\2\2\u01aa\u01ac\5:\36\2\u01ab\u0187\3\2\2\2\u01ab\u018c\3\2"+
"\2\2\u01ab\u0191\3\2\2\2\u01ab\u0196\3\2\2\2\u01ab\u019b\3\2\2\2\u01ab"+
"\u01a0\3\2\2\2\u01ab\u01a5\3\2\2\2\u01ab\u01aa\3\2\2\2\u01ac9\3\2\2\2"+
"\u01ad\u01ae\7\f\2\2\u01ae\u01b1\7$\2\2\u01af\u01b0\7\23\2\2\u01b0\u01b2"+
"\7$\2\2\u01b1\u01af\3\2\2\2\u01b1\u01b2\3\2\2\2\u01b2\u01b3\3\2\2\2\u01b3"+
"\u01b4\7\r\2\2\u01b4;\3\2\2\2\u01b5\u01b6\7\62\2\2\u01b6\u01b8\5\u0094"+
"K\2\u01b7\u01b9\5\24\13\2\u01b8\u01b7\3\2\2\2\u01b8\u01b9\3\2\2\2\u01b9"+
"\u01bb\3\2\2\2\u01ba\u01bc\5&\24\2\u01bb\u01ba\3\2\2\2\u01bb\u01bc\3\2"+
"\2\2\u01bc\u01c2\3\2\2\2\u01bd\u01be\7-\2\2\u01be\u01bf\7\4\2\2\u01bf"+
"\u01c0\5> \2\u01c0\u01c1\7\5\2\2\u01c1\u01c3\3\2\2\2\u01c2\u01bd\3\2\2"+
"\2\u01c2\u01c3\3\2\2\2\u01c3\u01cc\3\2\2\2\u01c4\u01c5\7\62\2\2\u01c5"+
"\u01c7\5\u0094K\2\u01c6\u01c8\5\24\13\2\u01c7\u01c6\3\2\2\2\u01c7\u01c8"+
"\3\2\2\2\u01c8\u01c9\3\2\2\2\u01c9\u01ca\7<\2\2\u01ca\u01cc\3\2\2\2\u01cb"+
"\u01b5\3\2\2\2\u01cb\u01c4\3\2\2\2\u01cc=\3\2\2\2\u01cd\u01d1\7\60\2\2"+
"\u01ce\u01d0\5@!\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+
"\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d5\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+
"\u01cd\3\2\2\2\u01d4\u01d5\3\2\2\2\u01d5\u01dd\3\2\2\2\u01d6\u01da\7\61"+
"\2\2\u01d7\u01d9\5@!\2\u01d8\u01d7\3\2\2\2\u01d9\u01dc\3\2\2\2\u01da\u01d8"+
"\3\2\2\2\u01da\u01db\3\2\2\2\u01db\u01de\3\2\2\2\u01dc\u01da\3\2\2\2\u01dd"+
"\u01d6\3\2\2\2\u01dd\u01de\3\2\2\2\u01de?\3\2\2\2\u01df\u01e0\5\u009c"+
"O\2\u01e0\u01e1\7-\2\2\u01e1\u01e2\7\4\2\2\u01e2\u01e3\58\35\2\u01e3\u01e4"+
"\7\5\2\2\u01e4A\3\2\2\2\u01e5\u01e8\7:\2\2\u01e6\u01e8\7;\2\2\u01e7\u01e5"+
"\3\2\2\2\u01e7\u01e6\3\2\2\2\u01e8\u01e9\3\2\2\2\u01e9\u01ea\5\u0096L"+
"\2\u01ea\u01eb\7\f\2\2\u01eb\u01ec\7$\2\2\u01ec\u01ed\7\21\2\2\u01ed\u01ee"+
"\5\6\4\2\u01ee\u01f0\7\r\2\2\u01ef\u01f1\5&\24\2\u01f0\u01ef\3\2\2\2\u01f0"+
"\u01f1\3\2\2\2\u01f1C\3\2\2\2\u01f2\u01f5\5\u0084C\2\u01f3\u01f5\5R*\2"+
"\u01f4\u01f2\3\2\2\2\u01f4\u01f3\3\2\2\2\u01f5E\3\2\2\2\u01f6\u0200\5"+
"\u0086D\2\u01f7\u01fc\5f\64\2\u01f8\u01f9\7\21\2\2\u01f9\u01fb\5f\64\2"+
"\u01fa\u01f8\3\2\2\2\u01fb\u01fe\3\2\2\2\u01fc\u01fa\3\2\2\2\u01fc\u01fd"+
"\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2\2\2\u01ff\u01f6\3\2\2\2\u01ff"+
"\u01f7\3\2\2\2\u0200G\3\2\2\2\u0201\u020c\7\35\2\2\u0202\u020c\7!\2\2"+
"\u0203\u0208\5l\67\2\u0204\u0205\7\21\2\2\u0205\u0207\5l\67\2\u0206\u0204"+
"\3\2\2\2\u0207\u020a\3\2\2\2\u0208\u0206\3\2\2\2\u0208\u0209\3\2\2\2\u0209"+
"\u020c\3\2\2\2\u020a\u0208\3\2\2\2\u020b\u0201\3\2\2\2\u020b\u0202\3\2"+
"\2\2\u020b\u0203\3\2\2\2\u020cI\3\2\2\2\u020d\u0218\7\37\2\2\u020e\u0218"+
"\7\"\2\2\u020f\u0214\5h\65\2\u0210\u0211\7\21\2\2\u0211\u0213\5h\65\2"+
"\u0212\u0210\3\2\2\2\u0213\u0216\3\2\2\2\u0214\u0212\3\2\2\2\u0214\u0215"+
"\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2\2\2\u0217\u020d\3\2\2\2\u0217"+
"\u020e\3\2\2\2\u0217\u020f\3\2\2\2\u0218K\3\2\2\2\u0219\u0224\7\36\2\2"+
"\u021a\u0224\7#\2\2\u021b\u0220\5j\66\2\u021c\u021d\7\21\2\2\u021d\u021f"+
"\5j\66\2\u021e\u021c\3\2\2\2\u021f\u0222\3\2\2\2\u0220\u021e\3\2\2\2\u0220"+
"\u0221\3\2\2\2\u0221\u0224\3\2\2\2\u0222\u0220\3\2\2\2\u0223\u0219\3\2"+
"\2\2\u0223\u021a\3\2\2\2\u0223\u021b\3\2\2\2\u0224M\3\2\2\2\u0225\u022b"+
"\7 \2\2\u0226\u0229\7\6\2\2\u0227\u022a\5n8\2\u0228\u022a\7 \2\2\u0229"+
"\u0227\3\2\2\2\u0229\u0228\3\2\2\2\u022a\u022c\3\2\2\2\u022b\u0226\3\2"+
"\2\2\u022b\u022c\3\2\2\2\u022c\u022f\3\2\2\2\u022d\u022f\5n8\2\u022e\u0225"+
"\3\2\2\2\u022e\u022d\3\2\2\2\u022fO\3\2\2\2\u0230\u0232\5\u008aF\2\u0231"+
"\u0230\3\2\2\2\u0231\u0232\3\2\2\2\u0232\u0237\3\2\2\2\u0233\u0234\7\21"+
"\2\2\u0234\u0236\5\u008aF\2\u0235\u0233\3\2\2\2\u0236\u0239\3\2\2\2\u0237"+
"\u0235\3\2\2\2\u0237\u0238\3\2\2\2\u0238Q\3\2\2\2\u0239\u0237\3\2\2\2"+
"\u023a\u023b\7\6\2\2\u023b\u023c\5T+\2\u023c\u023d\7\6\2\2\u023d\u0243"+
"\3\2\2\2\u023e\u023f\7\30\2\2\u023f\u0240\5V,\2\u0240\u0241\7\30\2\2\u0241"+
"\u0243\3\2\2\2\u0242\u023a\3\2\2\2\u0242\u023e\3\2\2\2\u0243S\3\2\2\2"+
"\u0244\u0246\n\4\2\2\u0245\u0244\3\2\2\2\u0246\u0249\3\2\2\2\u0247\u0245"+
"\3\2\2\2\u0247\u0248\3\2\2\2\u0248U\3\2\2\2\u0249\u0247\3\2\2\2\u024a"+
"\u024c\n\5\2\2\u024b\u024a\3\2\2\2\u024c\u024f\3\2\2\2\u024d\u024b\3\2"+
"\2\2\u024d\u024e\3\2\2\2\u024eW\3\2\2\2\u024f\u024d\3\2\2\2\u0250\u0252"+
"\5`\61\2\u0251\u0253\5b\62\2\u0252\u0251\3\2\2\2\u0252\u0253\3\2\2\2\u0253"+
"\u0255\3\2\2\2\u0254\u0256\5d\63\2\u0255\u0254\3\2\2\2\u0255\u0256\3\2"+
"\2\2\u0256\u025c\3\2\2\2\u0257\u0258\7-\2\2\u0258\u0259\7\4\2\2\u0259"+
"\u025a\5.\30\2\u025a\u025b\7\5\2\2\u025b\u025d\3\2\2\2\u025c\u0257\3\2"+
"\2\2\u025c\u025d\3\2\2\2\u025d\u0268\3\2\2\2\u025e\u0260\5Z.\2\u025f\u0261"+
"\5b\62\2\u0260\u025f\3\2\2\2\u0260\u0261\3\2\2\2\u0261\u0262\3\2\2\2\u0262"+
"\u0263\7-\2\2\u0263\u0264\7\4\2\2\u0264\u0265\5\\/\2\u0265\u0266\7\5\2"+
"\2\u0266\u0268\3\2\2\2\u0267\u0250\3\2\2\2\u0267\u025e\3\2\2\2\u0268Y"+
"\3\2\2\2\u0269\u026a\7\f\2\2\u026a\u026f\5`\61\2\u026b\u026c\7\21\2\2"+
"\u026c\u026e\5`\61\2\u026d\u026b\3\2\2\2\u026e\u0271\3\2\2\2\u026f\u026d"+
"\3\2\2\2\u026f\u0270\3\2\2\2\u0270\u0272\3\2\2\2\u0271\u026f\3\2\2\2\u0272"+
"\u0273\7\r\2\2\u0273[\3\2\2\2\u0274\u0279\5^\60\2\u0275\u0276\7\21\2\2"+
"\u0276\u0278\5^\60\2\u0277\u0275\3\2\2\2\u0278\u027b\3\2\2\2\u0279\u0277"+
"\3\2\2\2\u0279\u027a\3\2\2\2\u027a]\3\2\2\2\u027b\u0279\3\2\2\2\u027c"+
"\u027d\7\f\2\2\u027d\u027e\7\4\2\2\u027e\u027f\58\35\2\u027f\u0287\7\5"+
"\2\2\u0280\u0281\7\21\2\2\u0281\u0282\7\4\2\2\u0282\u0283\58\35\2\u0283"+
"\u0284\7\5\2\2\u0284\u0286\3\2\2\2\u0285\u0280\3\2\2\2\u0286\u0289\3\2"+
"\2\2\u0287\u0285\3\2\2\2\u0287\u0288\3\2\2\2\u0288\u028a\3\2\2\2\u0289"+
"\u0287\3\2\2\2\u028a\u028b\7\r\2\2\u028b_\3\2\2\2\u028c\u028d\5\u009c"+
"O\2\u028da\3\2\2\2\u028e\u028f\7\67\2\2\u028f\u0290\7-\2\2\u0290\u0291"+
"\7\4\2\2\u0291\u0292\5(\25\2\u0292\u0293\7\5\2\2\u0293c\3\2\2\2\u0294"+
"\u0295\7\63\2\2\u0295\u0296\7-\2\2\u0296\u0297\7\4\2\2\u0297\u029d\5("+
"\25\2\u0298\u029b\7\23\2\2\u0299\u029c\7\65\2\2\u029a\u029c\7\64\2\2\u029b"+
"\u0299\3\2\2\2\u029b\u029a\3\2\2\2\u029c\u029e\3\2\2\2\u029d\u0298\3\2"+
"\2\2\u029d\u029e\3\2\2\2\u029e\u02a1\3\2\2\2\u029f\u02a0\7\23\2\2\u02a0"+
"\u02a2\7\66\2\2\u02a1\u029f\3\2\2\2\u02a1\u02a2\3\2\2\2\u02a2\u02a3\3"+
"\2\2\2\u02a3\u02a4\7\5\2\2\u02a4e\3\2\2\2\u02a5\u02a7\7\26\2\2\u02a6\u02a8"+
"\7\16\2\2\u02a7\u02a6\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8\u02a9\3\2\2\2"+
"\u02a9\u02aa\5\u00a2R\2\u02aa\u02ac\7\b\2\2\u02ab\u02ad\7\17\2\2\u02ac"+
"\u02ab\3\2\2\2\u02ac\u02ad\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae\u02af\5\u00a2"+
"R\2\u02af\u02b0\7\26\2\2\u02b0\u02c4\3\2\2\2\u02b1\u02be\7\26\2\2\u02b2"+
"\u02b4\7\16\2\2\u02b3\u02b5\7\t\2\2\u02b4\u02b3\3\2\2\2\u02b4\u02b5\3"+
"\2\2\2\u02b5\u02b7\3\2\2\2\u02b6\u02b2\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7"+
"\u02bf\3\2\2\2\u02b8\u02ba\7\17\2\2\u02b9\u02bb\7\t\2\2\u02ba\u02b9\3"+
"\2\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bd\3\2\2\2\u02bc\u02b8\3\2\2\2\u02bc"+
"\u02bd\3\2\2\2\u02bd\u02bf\3\2\2\2\u02be\u02b6\3\2\2\2\u02be\u02bc\3\2"+
"\2\2\u02bf\u02c0\3\2\2\2\u02c0\u02c1\5\u00a2R\2\u02c1\u02c2\7\26\2\2\u02c2"+
"\u02c4\3\2\2\2\u02c3\u02a5\3\2\2\2\u02c3\u02b1\3\2\2\2\u02c4g\3\2\2\2"+
"\u02c5\u02c7\7\26\2\2\u02c6\u02c8\7\16\2\2\u02c7\u02c6\3\2\2\2\u02c7\u02c8"+
"\3\2\2\2\u02c8\u02c9\3\2\2\2\u02c9\u02ca\7\"\2\2\u02ca\u02cc\7\b\2\2\u02cb"+
"\u02cd\7\17\2\2\u02cc\u02cb\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd\u02ce\3"+
"\2\2\2\u02ce\u02cf\7\"\2\2\u02cf\u02e2\7\26\2\2\u02d0\u02dd\7\26\2\2\u02d1"+
"\u02d3\7\16\2\2\u02d2\u02d4\7\t\2\2\u02d3\u02d2\3\2\2\2\u02d3\u02d4\3"+
"\2\2\2\u02d4\u02d6\3\2\2\2\u02d5\u02d1\3\2\2\2\u02d5\u02d6\3\2\2\2\u02d6"+
"\u02de\3\2\2\2\u02d7\u02d9\7\17\2\2\u02d8\u02da\7\t\2\2\u02d9\u02d8\3"+
"\2\2\2\u02d9\u02da\3\2\2\2\u02da\u02dc\3\2\2\2\u02db\u02d7\3\2\2\2\u02db"+
"\u02dc\3\2\2\2\u02dc\u02de\3\2\2\2\u02dd\u02d5\3\2\2\2\u02dd\u02db\3\2"+
"\2\2\u02de\u02df\3\2\2\2\u02df\u02e0\7\"\2\2\u02e0\u02e2\7\26\2\2\u02e1"+
"\u02c5\3\2\2\2\u02e1\u02d0\3\2\2\2\u02e2i\3\2\2\2\u02e3\u02e5\7\26\2\2"+
"\u02e4\u02e6\7\16\2\2\u02e5\u02e4\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6\u02e7"+
"\3\2\2\2\u02e7\u02e8\7#\2\2\u02e8\u02ea\7\b\2\2\u02e9\u02eb\7\17\2\2\u02ea"+
"\u02e9\3\2\2\2\u02ea\u02eb\3\2\2\2\u02eb\u02ec\3\2\2\2\u02ec\u02ed\7#"+
"\2\2\u02ed\u0300\7\26\2\2\u02ee\u02fb\7\26\2\2\u02ef\u02f1\7\16\2\2\u02f0"+
"\u02f2\7\t\2\2\u02f1\u02f0\3\2\2\2\u02f1\u02f2\3\2\2\2\u02f2\u02f4\3\2"+
"\2\2\u02f3\u02ef\3\2\2\2\u02f3\u02f4\3\2\2\2\u02f4\u02fc\3\2\2\2\u02f5"+
"\u02f7\7\17\2\2\u02f6\u02f8\7\t\2\2\u02f7\u02f6\3\2\2\2\u02f7\u02f8\3"+
"\2\2\2\u02f8\u02fa\3\2\2\2\u02f9\u02f5\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa"+
"\u02fc\3\2\2\2\u02fb\u02f3\3\2\2\2\u02fb\u02f9\3\2\2\2\u02fc\u02fd\3\2"+
"\2\2\u02fd\u02fe\7#\2\2\u02fe\u0300\7\26\2\2\u02ff\u02e3\3\2\2\2\u02ff"+
"\u02ee\3\2\2\2\u0300k\3\2\2\2\u0301\u0303\7\26\2\2\u0302\u0304\7\16\2"+
"\2\u0303\u0302\3\2\2\2\u0303\u0304\3\2\2\2\u0304\u0305\3\2\2\2\u0305\u0306"+
"\7!\2\2\u0306\u0308\7\b\2\2\u0307\u0309\7\17\2\2\u0308\u0307\3\2\2\2\u0308"+
"\u0309\3\2\2\2\u0309\u030a\3\2\2\2\u030a\u030b\7!\2\2\u030b\u031e\7\26"+
"\2\2\u030c\u0319\7\26\2\2\u030d\u030f\7\16\2\2\u030e\u0310\7\t\2\2\u030f"+
"\u030e\3\2\2\2\u030f\u0310\3\2\2\2\u0310\u0312\3\2\2\2\u0311\u030d\3\2"+
"\2\2\u0311\u0312\3\2\2\2\u0312\u031a\3\2\2\2\u0313\u0315\7\17\2\2\u0314"+
"\u0316\7\t\2\2\u0315\u0314\3\2\2\2\u0315\u0316\3\2\2\2\u0316\u0318\3\2"+
"\2\2\u0317\u0313\3\2\2\2\u0317\u0318\3\2\2\2\u0318\u031a\3\2\2\2\u0319"+
"\u0311\3\2\2\2\u0319\u0317\3\2\2\2\u031a\u031b\3\2\2\2\u031b\u031c\7!"+
"\2\2\u031c\u031e\7\26\2\2\u031d\u0301\3\2\2\2\u031d\u030c\3\2\2\2\u031e"+
"m\3\2\2\2\u031f\u0321\7\26\2\2\u0320\u0322\7\16\2\2\u0321\u0320\3\2\2"+
"\2\u0321\u0322\3\2\2\2\u0322\u0325\3\2\2\2\u0323\u0326\7 \2\2\u0324\u0326"+
"\7\27\2\2\u0325\u0323\3\2\2\2\u0325\u0324\3\2\2\2\u0326\u0327\3\2\2\2"+
"\u0327\u0329\7\b\2\2\u0328\u032a\7\17\2\2\u0329\u0328\3\2\2\2\u0329\u032a"+
"\3\2\2\2\u032a\u032d\3\2\2\2\u032b\u032e\7 \2\2\u032c\u032e\7\27\2\2\u032d"+
"\u032b\3\2\2\2\u032d\u032c\3\2\2\2\u032e\u032f\3\2\2\2\u032f\u0342\7\26"+
"\2\2\u0330\u033d\7\26\2\2\u0331\u0333\7\16\2\2\u0332\u0334\7\t\2\2\u0333"+
"\u0332\3\2\2\2\u0333\u0334\3\2\2\2\u0334\u0336\3\2\2\2\u0335\u0331\3\2"+
"\2\2\u0335\u0336\3\2\2\2\u0336\u033e\3\2\2\2\u0337\u0339\7\17\2\2\u0338"+
"\u033a\7\t\2\2\u0339\u0338\3\2\2\2\u0339\u033a\3\2\2\2\u033a\u033c\3\2"+
"\2\2\u033b\u0337\3\2\2\2\u033b\u033c\3\2\2\2\u033c\u033e\3\2\2\2\u033d"+
"\u0335\3\2\2\2\u033d\u033b\3\2\2\2\u033e\u033f\3\2\2\2\u033f\u0340\7 "+
"\2\2\u0340\u0342\7\26\2\2\u0341\u031f\3\2\2\2\u0341\u0330\3\2\2\2\u0342"+
"o\3\2\2\2\u0343\u0344\7>\2\2\u0344\u0345\5v<\2\u0345q\3\2\2\2\u0346\u0347"+
"\7=\2\2\u0347\u0348\5v<\2\u0348s\3\2\2\2\u0349\u034e\7\17\2\2\u034a\u034f"+
"\5~@\2\u034b\u034f\5z>\2\u034c\u034f\5\u0082B\2\u034d\u034f\5f\64\2\u034e"+
"\u034a\3\2\2\2\u034e\u034b\3\2\2\2\u034e\u034c\3\2\2\2\u034e\u034d\3\2"+
"\2\2\u034f\u0350\3\2\2\2\u0350\u0352\7\16\2\2\u0351\u0353\7\23\2\2\u0352"+
"\u0351\3\2\2\2\u0352\u0353\3\2\2\2\u0353\u036c\3\2\2\2\u0354\u0355\7\n"+
"\2\2\u0355\u0356\5\u0096L\2\u0356\u0357\7\13\2\2\u0357\u035a\3\2\2\2\u0358"+
"\u035a\5\u0096L\2\u0359\u0354\3\2\2\2\u0359\u0358\3\2\2\2\u0359\u035a"+
"\3\2\2\2\u035a\u035b\3\2\2\2\u035b\u035d\7\17\2\2\u035c\u035e\5v<\2\u035d"+
"\u035c\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035f\3\2\2\2\u035f\u0361\7\16"+
"\2\2\u0360\u0362\7\23\2\2\u0361\u0360\3\2\2\2\u0361\u0362\3\2\2\2\u0362"+
"\u036c\3\2\2\2\u0363\u0364\7\17\2\2\u0364\u0365\5\u00a2R\2\u0365\u0366"+
"\7\16\2\2\u0366\u036c\3\2\2\2\u0367\u0368\7\17\2\2\u0368\u0369\5\u009e"+
"P\2\u0369\u036a\7\16\2\2\u036a\u036c\3\2\2\2\u036b\u0349\3\2\2\2\u036b"+
"\u0359\3\2\2\2\u036b\u0363\3\2\2\2\u036b\u0367\3\2\2\2\u036cu\3\2\2\2"+
"\u036d\u036f\5x=\2\u036e\u036d\3\2\2\2\u036f\u0370\3\2\2\2\u0370\u036e"+
"\3\2\2\2\u0370\u0371\3\2\2\2\u0371w\3\2\2\2\u0372\u0373\5\u008eH\2\u0373"+
"\u0374\7\t\2\2\u0374\u0375\5t;\2\u0375y\3\2\2\2\u0376\u037b\5|?\2\u0377"+
"\u0378\7\21\2\2\u0378\u037a\5|?\2\u0379\u0377\3\2\2\2\u037a\u037d\3\2"+
"\2\2\u037b\u0379\3\2\2\2\u037b\u037c\3\2\2\2\u037c{\3\2\2\2\u037d\u037b"+
"\3\2\2\2\u037e\u037f\7\f\2\2\u037f\u0380\5\u008aF\2\u0380\u0381\7\3\2"+
"\2\u0381\u0382\5\u008aF\2\u0382\u0383\7\r\2\2\u0383}\3\2\2\2\u0384\u0386"+
"\5\u0080A\2\u0385\u0384\3\2\2\2\u0386\u0387\3\2\2\2\u0387\u0385\3\2\2"+
"\2\u0387\u0388\3\2\2\2\u0388\177\3\2\2\2\u0389\u038a\7\f\2\2\u038a\u038b"+
"\7D\2\2\u038b\u038c\7\r\2\2\u038c\u038d\7\t\2\2\u038d\u038e\5t;\2\u038e"+
"\u0081\3\2\2\2\u038f\u0394\7D\2\2\u0390\u0391\7\21\2\2\u0391\u0393\7D"+
"\2\2\u0392\u0390\3\2\2\2\u0393\u0396\3\2\2\2\u0394\u0392\3\2\2\2\u0394"+
"\u0395\3\2\2\2\u0395\u0399\3\2\2\2\u0396\u0394\3\2\2\2\u0397\u0398\7\21"+
"\2\2\u0398\u039a\7\7\2\2\u0399\u0397\3\2\2\2\u0399\u039a\3\2\2\2\u039a"+
"\u0083\3\2\2\2\u039b\u03a0\7D\2\2\u039c\u039d\7\21\2\2\u039d\u039f\7D"+
"\2\2\u039e\u039c\3\2\2\2\u039f\u03a2\3\2\2\2\u03a0\u039e\3\2\2\2\u03a0"+
"\u03a1\3\2\2\2\u03a1\u0085\3\2\2\2\u03a2\u03a0\3\2\2\2\u03a3\u03a8\5\u00a2"+
"R\2\u03a4\u03a5\7\21\2\2\u03a5\u03a7\5\u00a2R\2\u03a6\u03a4\3\2\2\2\u03a7"+
"\u03aa\3\2\2\2\u03a8\u03a6\3\2\2\2\u03a8\u03a9\3\2\2\2\u03a9\u0087\3\2"+
"\2\2\u03aa\u03a8\3\2\2\2\u03ab\u03b0\5\u0090I\2\u03ac\u03ad\7\21\2\2\u03ad"+
"\u03af\5\u0090I\2\u03ae\u03ac\3\2\2\2\u03af\u03b2\3\2\2\2\u03b0\u03ae"+
"\3\2\2\2\u03b0\u03b1\3\2\2\2\u03b1\u0089\3\2\2\2\u03b2\u03b0\3\2\2\2\u03b3"+
"\u03b5\5\u008cG\2\u03b4\u03b3\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6\u03b4"+
"\3\2\2\2\u03b6\u03b7\3\2\2\2\u03b7\u008b\3\2\2\2\u03b8\u03c3\5\u008eH"+
"\2\u03b9\u03c3\5\u00a2R\2\u03ba\u03c3\7!\2\2\u03bb\u03c3\7\"\2\2\u03bc"+
"\u03c3\7\20\2\2\u03bd\u03c3\7\24\2\2\u03be\u03c3\7\n\2\2\u03bf\u03c3\7"+
"\13\2\2\u03c0\u03c3\7\22\2\2\u03c1\u03c3\7\6\2\2\u03c2\u03b8\3\2\2\2\u03c2"+
"\u03b9\3\2\2\2\u03c2\u03ba\3\2\2\2\u03c2\u03bb\3\2\2\2\u03c2\u03bc\3\2"+
"\2\2\u03c2\u03bd\3\2\2\2\u03c2\u03be\3\2\2\2\u03c2\u03bf\3\2\2\2\u03c2"+
"\u03c0\3\2\2\2\u03c2\u03c1\3\2\2\2\u03c3\u008d\3\2\2\2\u03c4\u03c7\5\u0092"+
"J\2\u03c5\u03c7\5\u0096L\2\u03c6\u03c4\3\2\2\2\u03c6\u03c5\3\2\2\2\u03c7"+
"\u008f\3\2\2\2\u03c8\u03c9\t\6\2\2\u03c9\u0091\3\2\2\2\u03ca\u03ce\7B"+
"\2\2\u03cb\u03ce\5\u0098M\2\u03cc\u03ce\7$\2\2\u03cd\u03ca\3\2\2\2\u03cd"+
"\u03cb\3\2\2\2\u03cd\u03cc\3\2\2\2\u03ce\u0093\3\2\2\2\u03cf\u03d4\5\u0096"+
"L\2\u03d0\u03d1\7\17\2\2\u03d1\u03d2\5\u0096L\2\u03d2\u03d3\7\16\2\2\u03d3"+
"\u03d5\3\2\2\2\u03d4\u03d0\3\2\2\2\u03d4\u03d5\3\2\2\2\u03d5\u0095\3\2"+
"\2\2\u03d6\u03d7\7A\2\2\u03d7\u0097\3\2\2\2\u03d8\u03d9\t\7\2\2\u03d9"+
"\u0099\3\2\2\2\u03da\u03dc\5\u0092J\2\u03db\u03dd\5\24\13\2\u03dc\u03db"+
"\3\2\2\2\u03dc\u03dd\3\2\2\2\u03dd\u009b\3\2\2\2\u03de\u03e0\7\6\2\2\u03df"+
"\u03de\3\2\2\2\u03df\u03e0\3\2\2\2\u03e0\u03e1\3\2\2\2\u03e1\u03e6\5\u009a"+
"N\2\u03e2\u03e3\7\6\2\2\u03e3\u03e5\5\u009aN\2\u03e4\u03e2\3\2\2\2\u03e5"+
"\u03e8\3\2\2\2\u03e6\u03e4\3\2\2\2\u03e6\u03e7\3\2\2\2\u03e7\u009d\3\2"+
"\2\2\u03e8\u03e6\3\2\2\2\u03e9\u03ea\5\u008eH\2\u03ea\u03f5\7\22\2\2\u03eb"+
"\u03f6\5\u008cG\2\u03ec\u03f6\7\25\2\2\u03ed\u03f6\7\20\2\2\u03ee\u03f6"+
"\7\t\2\2\u03ef\u03f6\7\33\2\2\u03f0\u03f6\7\24\2\2\u03f1\u03f6\7\6\2\2"+
"\u03f2\u03f6\7\31\2\2\u03f3\u03f6\7\23\2\2\u03f4\u03f6\7E\2\2\u03f5\u03eb"+
"\3\2\2\2\u03f5\u03ec\3\2\2\2\u03f5\u03ed\3\2\2\2\u03f5\u03ee\3\2\2\2\u03f5"+
"\u03ef\3\2\2\2\u03f5\u03f0\3\2\2\2\u03f5\u03f1\3\2\2\2\u03f5\u03f2\3\2"+
"\2\2\u03f5\u03f3\3\2\2\2\u03f5\u03f4\3\2\2\2\u03f6\u03f7\3\2\2\2\u03f7"+
"\u03f5\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8\u009f\3\2\2\2\u03f9\u03fc\5\u00a2"+
"R\2\u03fa\u03fc\7\27\2\2\u03fb\u03f9\3\2\2\2\u03fb\u03fa\3\2\2\2\u03fc"+
"\u00a1\3\2\2\2\u03fd\u03ff\7\24\2\2\u03fe\u03fd\3\2\2\2\u03fe\u03ff\3"+
"\2\2\2\u03ff\u0400\3\2\2\2\u0400\u0403\7C\2\2\u0401\u0402\7\20\2\2\u0402"+
"\u0404\7C\2\2\u0403\u0401\3\2\2\2\u0403\u0404\3\2\2\2\u0404\u00a3\3\2"+
"\2\2\u009f\u00a6\u00a9\u00ac\u00af\u00b2\u00b5\u00b8\u00be\u00c5\u00ca"+
"\u00cf\u00d1\u00d6\u00d8\u00e0\u00e5\u00ee\u00f7\u00fd\u0102\u011d\u0121"+
"\u0125\u012a\u012d\u0132\u0136\u0139\u013d\u0140\u0143\u0152\u0159\u0161"+
"\u0167\u016d\u016f\u0174\u0179\u0180\u018a\u018f\u0194\u0199\u019e\u01a3"+
"\u01a8\u01ab\u01b1\u01b8\u01bb\u01c2\u01c7\u01cb\u01d1\u01d4\u01da\u01dd"+
"\u01e7\u01f0\u01f4\u01fc\u01ff\u0208\u020b\u0214\u0217\u0220\u0223\u0229"+
"\u022b\u022e\u0231\u0237\u0242\u0247\u024d\u0252\u0255\u025c\u0260\u0267"+
"\u026f\u0279\u0287\u029b\u029d\u02a1\u02a7\u02ac\u02b4\u02b6\u02ba\u02bc"+
"\u02be\u02c3\u02c7\u02cc\u02d3\u02d5\u02d9\u02db\u02dd\u02e1\u02e5\u02ea"+
"\u02f1\u02f3\u02f7\u02f9\u02fb\u02ff\u0303\u0308\u030f\u0311\u0315\u0317"+
"\u0319\u031d\u0321\u0325\u0329\u032d\u0333\u0335\u0339\u033b\u033d\u0341"+
"\u034e\u0352\u0359\u035d\u0361\u036b\u0370\u037b\u0387\u0394\u0399\u03a0"+
"\u03a8\u03b0\u03b6\u03c2\u03c6\u03cd\u03d4\u03dc\u03df\u03e6\u03f5\u03f7"+
"\u03fb\u03fe\u0403";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy