10217 lines
388 KiB
TypeScript
10217 lines
388 KiB
TypeScript
|
|
import * as antlr from "antlr4ng";
|
|
import { Token } from "antlr4ng";
|
|
|
|
import { QuixosCapabilityVisitor } from "./QuixosCapabilityVisitor.js";
|
|
|
|
// for running tests with parameters, TODO: discuss strategy for typed parameters in CI
|
|
// eslint-disable-next-line no-unused-vars
|
|
type int = number;
|
|
|
|
|
|
export class QuixosCapabilityParser extends antlr.Parser {
|
|
public static readonly EDIT = 1;
|
|
public static readonly MODULE = 2;
|
|
public static readonly CONTRACT = 3;
|
|
public static readonly PRESENTATION = 4;
|
|
public static readonly SUBJECT = 5;
|
|
public static readonly FOR = 6;
|
|
public static readonly CREATION = 7;
|
|
public static readonly VARIANT = 8;
|
|
public static readonly PREPARES = 9;
|
|
public static readonly INITIALIZE = 10;
|
|
public static readonly WORKSPACE = 11;
|
|
public static readonly EXECUTION = 12;
|
|
public static readonly SNAPSHOT = 13;
|
|
public static readonly TRANSACTION = 14;
|
|
public static readonly REMOTE = 15;
|
|
public static readonly TARGETS = 16;
|
|
public static readonly PORTABLE = 17;
|
|
public static readonly REPLICA = 18;
|
|
public static readonly LOCAL = 19;
|
|
public static readonly FROM = 20;
|
|
public static readonly RESULT_BYTES = 21;
|
|
public static readonly RPC_CALLS = 22;
|
|
public static readonly DEADLINE_MS = 23;
|
|
public static readonly QUERY = 24;
|
|
public static readonly REFLECTION = 25;
|
|
public static readonly SPECIALIZE = 26;
|
|
public static readonly ROOT = 27;
|
|
public static readonly DOCUMENT = 28;
|
|
public static readonly FRAGMENTS = 29;
|
|
public static readonly VIEW = 30;
|
|
public static readonly MAX = 31;
|
|
public static readonly ALLOW = 32;
|
|
public static readonly POLL = 33;
|
|
public static readonly QUERYABLE = 34;
|
|
public static readonly RPC = 35;
|
|
public static readonly QUERY_REASON = 36;
|
|
public static readonly TYPE = 37;
|
|
public static readonly OBJECT = 38;
|
|
public static readonly STORABLE = 39;
|
|
public static readonly IMPLEMENTS = 40;
|
|
public static readonly REF = 41;
|
|
public static readonly FRAGMENT = 42;
|
|
public static readonly IMPORT = 43;
|
|
public static readonly EXTERNAL = 44;
|
|
public static readonly SYMBOL = 45;
|
|
public static readonly ATOM = 46;
|
|
public static readonly INTERFACE = 47;
|
|
public static readonly INTERFACES = 48;
|
|
public static readonly PACKAGE = 49;
|
|
public static readonly VALUE = 50;
|
|
public static readonly FIELD = 51;
|
|
public static readonly RELATION = 52;
|
|
public static readonly OPERATION = 53;
|
|
public static readonly FUNCTION = 54;
|
|
public static readonly CONSTRUCTOR = 55;
|
|
public static readonly CONSTRUCTS = 56;
|
|
public static readonly INPUT = 57;
|
|
public static readonly CONFORM = 58;
|
|
public static readonly AS = 59;
|
|
public static readonly BIND = 60;
|
|
public static readonly STATIC = 61;
|
|
public static readonly TO = 62;
|
|
public static readonly PRIVATE = 63;
|
|
public static readonly SHARED = 64;
|
|
public static readonly STATE = 65;
|
|
public static readonly EDGE = 66;
|
|
public static readonly PROJECTION = 67;
|
|
public static readonly WITH = 68;
|
|
public static readonly USING = 69;
|
|
public static readonly ACCEPT = 70;
|
|
public static readonly VIA = 71;
|
|
public static readonly MATERIALIZE = 72;
|
|
public static readonly IF = 73;
|
|
public static readonly ABSENT = 74;
|
|
public static readonly ON = 75;
|
|
public static readonly POLICY = 76;
|
|
public static readonly DEFAULT = 77;
|
|
public static readonly SOURCE = 78;
|
|
public static readonly REPOSITORY = 79;
|
|
public static readonly COMMIT = 80;
|
|
public static readonly REVISION = 81;
|
|
public static readonly SEMANTIC_MAJOR = 82;
|
|
public static readonly ON_DELETE = 83;
|
|
public static readonly LIFECYCLE = 84;
|
|
public static readonly JOURNAL = 85;
|
|
public static readonly SUBSCRIPTION = 86;
|
|
public static readonly RETAIN_OTHER = 87;
|
|
public static readonly KEYED = 88;
|
|
public static readonly PUBLIC_TRAVERSAL = 89;
|
|
public static readonly ID = 90;
|
|
public static readonly DOC = 91;
|
|
public static readonly MODE = 92;
|
|
public static readonly EMITS = 93;
|
|
public static readonly RECEIVER = 94;
|
|
public static readonly REQUIRES = 95;
|
|
public static readonly ANY = 96;
|
|
public static readonly GET = 97;
|
|
public static readonly SET = 98;
|
|
public static readonly WATCH = 99;
|
|
public static readonly START = 100;
|
|
public static readonly STOP = 101;
|
|
public static readonly READ = 102;
|
|
public static readonly WRITE = 103;
|
|
public static readonly RESOLVE = 104;
|
|
public static readonly CONNECT = 105;
|
|
public static readonly DISCONNECT = 106;
|
|
public static readonly CALL = 107;
|
|
public static readonly WATCH_START = 108;
|
|
public static readonly WATCH_STOP = 109;
|
|
public static readonly SUBSCRIBE = 110;
|
|
public static readonly UNSUBSCRIBE = 111;
|
|
public static readonly REGISTER = 112;
|
|
public static readonly CRDT = 113;
|
|
public static readonly OPTIONAL_ONE = 114;
|
|
public static readonly EXACTLY_ONE = 115;
|
|
public static readonly MANY_UNIQUE = 116;
|
|
public static readonly MANY = 117;
|
|
public static readonly ORDERED = 118;
|
|
public static readonly UNIT = 119;
|
|
public static readonly WATCH_HANDLE = 120;
|
|
public static readonly MESSAGE = 121;
|
|
public static readonly ATOM_REF = 122;
|
|
public static readonly INTERFACE_REF = 123;
|
|
public static readonly OPTIONAL = 124;
|
|
public static readonly LIST = 125;
|
|
public static readonly RECORD = 126;
|
|
public static readonly BOOL = 127;
|
|
public static readonly BYTES = 128;
|
|
public static readonly DOUBLE = 129;
|
|
public static readonly INT32 = 130;
|
|
public static readonly INT64 = 131;
|
|
public static readonly STRING = 132;
|
|
public static readonly UINT32 = 133;
|
|
public static readonly UINT64 = 134;
|
|
public static readonly TRUE = 135;
|
|
public static readonly FALSE = 136;
|
|
public static readonly NULL = 137;
|
|
public static readonly ARROW = 138;
|
|
public static readonly COLON = 139;
|
|
public static readonly SEMI = 140;
|
|
public static readonly COMMA = 141;
|
|
public static readonly DOT = 142;
|
|
public static readonly LBRACE = 143;
|
|
public static readonly RBRACE = 144;
|
|
public static readonly LBRACK = 145;
|
|
public static readonly RBRACK = 146;
|
|
public static readonly LPAREN = 147;
|
|
public static readonly RPAREN = 148;
|
|
public static readonly LT = 149;
|
|
public static readonly GT = 150;
|
|
public static readonly AMP = 151;
|
|
public static readonly EQUAL = 152;
|
|
public static readonly INTEGER = 153;
|
|
public static readonly JSON_NUMBER = 154;
|
|
public static readonly IDENTIFIER = 155;
|
|
public static readonly STRING_LITERAL = 156;
|
|
public static readonly LINE_COMMENT = 157;
|
|
public static readonly BLOCK_COMMENT = 158;
|
|
public static readonly WS = 159;
|
|
public static readonly RULE_document = 0;
|
|
public static readonly RULE_fragmentDecl = 1;
|
|
public static readonly RULE_sourceImportDecl = 2;
|
|
public static readonly RULE_workspaceDecl = 3;
|
|
public static readonly RULE_workspaceItem = 4;
|
|
public static readonly RULE_resourceImportDecl = 5;
|
|
public static readonly RULE_externalAtomDecl = 6;
|
|
public static readonly RULE_externalInterfaceDecl = 7;
|
|
public static readonly RULE_symbolDecl = 8;
|
|
public static readonly RULE_resourcePreamble = 9;
|
|
public static readonly RULE_atomDecl = 10;
|
|
public static readonly RULE_interfaceResourceDecl = 11;
|
|
public static readonly RULE_typeParameters = 12;
|
|
public static readonly RULE_typeParameter = 13;
|
|
public static readonly RULE_interfaceType = 14;
|
|
public static readonly RULE_typeArguments = 15;
|
|
public static readonly RULE_typeArgument = 16;
|
|
public static readonly RULE_typeAliasDecl = 17;
|
|
public static readonly RULE_interfaceMember = 18;
|
|
public static readonly RULE_moduleMember = 19;
|
|
public static readonly RULE_operationMember = 20;
|
|
public static readonly RULE_valueMember = 21;
|
|
public static readonly RULE_valueMemberOperation = 22;
|
|
public static readonly RULE_relationshipMember = 23;
|
|
public static readonly RULE_queryReadContract = 24;
|
|
public static readonly RULE_relationshipOperation = 25;
|
|
public static readonly RULE_targetConstraint = 26;
|
|
public static readonly RULE_packageResourceDecl = 27;
|
|
public static readonly RULE_packageExport = 28;
|
|
public static readonly RULE_moduleExport = 29;
|
|
public static readonly RULE_presentationDecl = 30;
|
|
public static readonly RULE_packageQuery = 31;
|
|
public static readonly RULE_packageQuerySpecialization = 32;
|
|
public static readonly RULE_queryClause = 33;
|
|
public static readonly RULE_fragmentVariable = 34;
|
|
public static readonly RULE_packageOperationExport = 35;
|
|
public static readonly RULE_packageFunctionExport = 36;
|
|
public static readonly RULE_acceptanceClause = 37;
|
|
public static readonly RULE_preparationClause = 38;
|
|
public static readonly RULE_executionClause = 39;
|
|
public static readonly RULE_selectedOperations = 40;
|
|
public static readonly RULE_packageConstructorExport = 41;
|
|
public static readonly RULE_eventClause = 42;
|
|
public static readonly RULE_operationMode = 43;
|
|
public static readonly RULE_receiverRequirement = 44;
|
|
public static readonly RULE_identifierList = 45;
|
|
public static readonly RULE_dependencyBlock = 46;
|
|
public static readonly RULE_dependencyPort = 47;
|
|
public static readonly RULE_primitiveList = 48;
|
|
public static readonly RULE_primitive = 49;
|
|
public static readonly RULE_sharedAttachmentDecl = 50;
|
|
public static readonly RULE_attachmentDecl = 51;
|
|
public static readonly RULE_stateDecl = 52;
|
|
public static readonly RULE_storagePolicy = 53;
|
|
public static readonly RULE_edgeDecl = 54;
|
|
public static readonly RULE_edgeEndpoint = 55;
|
|
public static readonly RULE_conformanceDecl = 56;
|
|
public static readonly RULE_conformanceSourceArguments = 57;
|
|
public static readonly RULE_conformanceItem = 58;
|
|
public static readonly RULE_moduleBindingDecl = 59;
|
|
public static readonly RULE_initializationDecl = 60;
|
|
public static readonly RULE_initializationField = 61;
|
|
public static readonly RULE_creationOwnerMapping = 62;
|
|
public static readonly RULE_stateFieldBindingDecl = 63;
|
|
public static readonly RULE_relationshipMaterializationDecl = 64;
|
|
public static readonly RULE_operationBindingDecl = 65;
|
|
public static readonly RULE_memberOperationRef = 66;
|
|
public static readonly RULE_operationName = 67;
|
|
public static readonly RULE_operationProvider = 68;
|
|
public static readonly RULE_acceptanceBinding = 69;
|
|
public static readonly RULE_statePrimitive = 70;
|
|
public static readonly RULE_edgePrimitive = 71;
|
|
public static readonly RULE_dependencyBindingBlock = 72;
|
|
public static readonly RULE_dependencyBinding = 73;
|
|
public static readonly RULE_constructorBindingDecl = 74;
|
|
public static readonly RULE_valueType = 75;
|
|
public static readonly RULE_recordField = 76;
|
|
public static readonly RULE_variantCase = 77;
|
|
public static readonly RULE_scalarType = 78;
|
|
public static readonly RULE_cardinality = 79;
|
|
public static readonly RULE_jsonLiteral = 80;
|
|
public static readonly RULE_jsonObject = 81;
|
|
public static readonly RULE_jsonMember = 82;
|
|
public static readonly RULE_jsonArray = 83;
|
|
public static readonly RULE_identifier = 84;
|
|
public static readonly RULE_stringLiteral = 85;
|
|
|
|
public static readonly literalNames = [
|
|
null, "'edit'", "'module'", "'contract'", "'presentation'", "'subject'",
|
|
"'for'", "'creation'", "'variant'", "'prepares'", "'initialize'",
|
|
"'workspace'", "'execution'", "'snapshot'", "'transaction'", "'remote'",
|
|
"'targets'", "'portable'", "'replica'", "'local'", "'from'", "'result-bytes'",
|
|
"'rpc-calls'", "'deadline-ms'", "'query'", "'reflection'", "'specialize'",
|
|
"'root'", "'document'", "'fragments'", "'view'", "'max'", "'allow'",
|
|
"'poll'", "'queryable'", "'rpc'", "'query-reason'", "'type'", "'object'",
|
|
"'storable'", "'implements'", "'ref'", "'fragment'", "'import'",
|
|
"'external'", "'symbol'", "'atom'", "'interface'", "'interfaces'",
|
|
"'package'", "'value'", "'field'", "'relation'", "'operation'",
|
|
"'function'", "'constructor'", "'constructs'", "'input'", "'conform'",
|
|
"'as'", "'bind'", "'static'", "'to'", "'private'", "'shared'", "'state'",
|
|
"'edge'", "'projection'", "'with'", "'using'", "'accept'", "'via'",
|
|
"'materialize'", "'if'", "'absent'", "'on'", "'policy'", "'default'",
|
|
"'source'", "'repository'", "'commit'", "'revision'", "'semantic-major'",
|
|
"'on-delete'", "'lifecycle'", "'journal'", "'subscription'", "'retain-other'",
|
|
"'keyed'", "'public-traversal'", "'id'", "'doc'", "'mode'", "'emits'",
|
|
"'receiver'", "'requires'", "'any'", "'get'", "'set'", "'watch'",
|
|
"'start'", "'stop'", "'read'", "'write'", "'resolve'", "'connect'",
|
|
"'disconnect'", "'call'", "'watch-start'", "'watch-stop'", "'subscribe'",
|
|
"'unsubscribe'", "'register'", "'crdt'", "'optional-one'", "'exactly-one'",
|
|
"'many-unique'", "'many'", "'ordered'", "'unit'", "'watch-handle'",
|
|
"'message'", "'atom-ref'", "'interface-ref'", "'optional'", "'list'",
|
|
"'record'", "'bool'", "'bytes'", "'double'", "'int32'", "'int64'",
|
|
"'string'", "'uint32'", "'uint64'", "'true'", "'false'", "'null'",
|
|
"'->'", "':'", "';'", "','", "'.'", "'{'", "'}'", "'['", "']'",
|
|
"'('", "')'", "'<'", "'>'", "'&'", "'='"
|
|
];
|
|
|
|
public static readonly symbolicNames = [
|
|
null, "EDIT", "MODULE", "CONTRACT", "PRESENTATION", "SUBJECT", "FOR",
|
|
"CREATION", "VARIANT", "PREPARES", "INITIALIZE", "WORKSPACE", "EXECUTION",
|
|
"SNAPSHOT", "TRANSACTION", "REMOTE", "TARGETS", "PORTABLE", "REPLICA",
|
|
"LOCAL", "FROM", "RESULT_BYTES", "RPC_CALLS", "DEADLINE_MS", "QUERY",
|
|
"REFLECTION", "SPECIALIZE", "ROOT", "DOCUMENT", "FRAGMENTS", "VIEW",
|
|
"MAX", "ALLOW", "POLL", "QUERYABLE", "RPC", "QUERY_REASON", "TYPE",
|
|
"OBJECT", "STORABLE", "IMPLEMENTS", "REF", "FRAGMENT", "IMPORT",
|
|
"EXTERNAL", "SYMBOL", "ATOM", "INTERFACE", "INTERFACES", "PACKAGE",
|
|
"VALUE", "FIELD", "RELATION", "OPERATION", "FUNCTION", "CONSTRUCTOR",
|
|
"CONSTRUCTS", "INPUT", "CONFORM", "AS", "BIND", "STATIC", "TO",
|
|
"PRIVATE", "SHARED", "STATE", "EDGE", "PROJECTION", "WITH", "USING",
|
|
"ACCEPT", "VIA", "MATERIALIZE", "IF", "ABSENT", "ON", "POLICY",
|
|
"DEFAULT", "SOURCE", "REPOSITORY", "COMMIT", "REVISION", "SEMANTIC_MAJOR",
|
|
"ON_DELETE", "LIFECYCLE", "JOURNAL", "SUBSCRIPTION", "RETAIN_OTHER",
|
|
"KEYED", "PUBLIC_TRAVERSAL", "ID", "DOC", "MODE", "EMITS", "RECEIVER",
|
|
"REQUIRES", "ANY", "GET", "SET", "WATCH", "START", "STOP", "READ",
|
|
"WRITE", "RESOLVE", "CONNECT", "DISCONNECT", "CALL", "WATCH_START",
|
|
"WATCH_STOP", "SUBSCRIBE", "UNSUBSCRIBE", "REGISTER", "CRDT", "OPTIONAL_ONE",
|
|
"EXACTLY_ONE", "MANY_UNIQUE", "MANY", "ORDERED", "UNIT", "WATCH_HANDLE",
|
|
"MESSAGE", "ATOM_REF", "INTERFACE_REF", "OPTIONAL", "LIST", "RECORD",
|
|
"BOOL", "BYTES", "DOUBLE", "INT32", "INT64", "STRING", "UINT32",
|
|
"UINT64", "TRUE", "FALSE", "NULL", "ARROW", "COLON", "SEMI", "COMMA",
|
|
"DOT", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "LPAREN", "RPAREN",
|
|
"LT", "GT", "AMP", "EQUAL", "INTEGER", "JSON_NUMBER", "IDENTIFIER",
|
|
"STRING_LITERAL", "LINE_COMMENT", "BLOCK_COMMENT", "WS"
|
|
];
|
|
public static readonly ruleNames = [
|
|
"document", "fragmentDecl", "sourceImportDecl", "workspaceDecl",
|
|
"workspaceItem", "resourceImportDecl", "externalAtomDecl", "externalInterfaceDecl",
|
|
"symbolDecl", "resourcePreamble", "atomDecl", "interfaceResourceDecl",
|
|
"typeParameters", "typeParameter", "interfaceType", "typeArguments",
|
|
"typeArgument", "typeAliasDecl", "interfaceMember", "moduleMember",
|
|
"operationMember", "valueMember", "valueMemberOperation", "relationshipMember",
|
|
"queryReadContract", "relationshipOperation", "targetConstraint",
|
|
"packageResourceDecl", "packageExport", "moduleExport", "presentationDecl",
|
|
"packageQuery", "packageQuerySpecialization", "queryClause", "fragmentVariable",
|
|
"packageOperationExport", "packageFunctionExport", "acceptanceClause",
|
|
"preparationClause", "executionClause", "selectedOperations", "packageConstructorExport",
|
|
"eventClause", "operationMode", "receiverRequirement", "identifierList",
|
|
"dependencyBlock", "dependencyPort", "primitiveList", "primitive",
|
|
"sharedAttachmentDecl", "attachmentDecl", "stateDecl", "storagePolicy",
|
|
"edgeDecl", "edgeEndpoint", "conformanceDecl", "conformanceSourceArguments",
|
|
"conformanceItem", "moduleBindingDecl", "initializationDecl", "initializationField",
|
|
"creationOwnerMapping", "stateFieldBindingDecl", "relationshipMaterializationDecl",
|
|
"operationBindingDecl", "memberOperationRef", "operationName", "operationProvider",
|
|
"acceptanceBinding", "statePrimitive", "edgePrimitive", "dependencyBindingBlock",
|
|
"dependencyBinding", "constructorBindingDecl", "valueType", "recordField",
|
|
"variantCase", "scalarType", "cardinality", "jsonLiteral", "jsonObject",
|
|
"jsonMember", "jsonArray", "identifier", "stringLiteral",
|
|
];
|
|
|
|
public get grammarFileName(): string { return "QuixosCapability.g4"; }
|
|
public get literalNames(): (string | null)[] { return QuixosCapabilityParser.literalNames; }
|
|
public get symbolicNames(): (string | null)[] { return QuixosCapabilityParser.symbolicNames; }
|
|
public get ruleNames(): string[] { return QuixosCapabilityParser.ruleNames; }
|
|
public get serializedATN(): number[] { return QuixosCapabilityParser._serializedATN; }
|
|
|
|
protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException {
|
|
return new antlr.FailedPredicateException(this, predicate, message);
|
|
}
|
|
|
|
public constructor(input: antlr.TokenStream) {
|
|
super(input);
|
|
this.interpreter = new antlr.ParserATNSimulator(this, QuixosCapabilityParser._ATN, QuixosCapabilityParser.decisionsToDFA, new antlr.PredictionContextCache());
|
|
}
|
|
public document(): DocumentContext {
|
|
let localContext = new DocumentContext(this.context, this.state);
|
|
this.enterRule(localContext, 0, QuixosCapabilityParser.RULE_document);
|
|
try {
|
|
this.state = 184;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 0, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 172;
|
|
this.workspaceDecl();
|
|
this.state = 173;
|
|
this.match(QuixosCapabilityParser.EOF);
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 175;
|
|
this.interfaceResourceDecl();
|
|
this.state = 176;
|
|
this.match(QuixosCapabilityParser.EOF);
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 178;
|
|
this.packageResourceDecl();
|
|
this.state = 179;
|
|
this.match(QuixosCapabilityParser.EOF);
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 181;
|
|
this.fragmentDecl();
|
|
this.state = 182;
|
|
this.match(QuixosCapabilityParser.EOF);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public fragmentDecl(): FragmentDeclContext {
|
|
let localContext = new FragmentDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 2, QuixosCapabilityParser.RULE_fragmentDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 186;
|
|
this.match(QuixosCapabilityParser.FRAGMENT);
|
|
this.state = 187;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 191;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 4 || ((((_la - 37)) & ~0x1F) === 0 && ((1 << (_la - 37)) & 136577601) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 188;
|
|
this.workspaceItem();
|
|
}
|
|
}
|
|
this.state = 193;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 194;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public sourceImportDecl(): SourceImportDeclContext {
|
|
let localContext = new SourceImportDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 4, QuixosCapabilityParser.RULE_sourceImportDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 196;
|
|
this.match(QuixosCapabilityParser.IMPORT);
|
|
this.state = 197;
|
|
this.stringLiteral();
|
|
this.state = 198;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public workspaceDecl(): WorkspaceDeclContext {
|
|
let localContext = new WorkspaceDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 6, QuixosCapabilityParser.RULE_workspaceDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 200;
|
|
this.match(QuixosCapabilityParser.WORKSPACE);
|
|
this.state = 201;
|
|
this.identifier();
|
|
this.state = 202;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 203;
|
|
this.stringLiteral();
|
|
this.state = 204;
|
|
this.match(QuixosCapabilityParser.REVISION);
|
|
this.state = 205;
|
|
this.stringLiteral();
|
|
this.state = 206;
|
|
this.match(QuixosCapabilityParser.COMMIT);
|
|
this.state = 207;
|
|
this.stringLiteral();
|
|
this.state = 208;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 212;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 4 || ((((_la - 37)) & ~0x1F) === 0 && ((1 << (_la - 37)) & 136577601) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 209;
|
|
this.workspaceItem();
|
|
}
|
|
}
|
|
this.state = 214;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 215;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public workspaceItem(): WorkspaceItemContext {
|
|
let localContext = new WorkspaceItemContext(this.context, this.state);
|
|
this.enterRule(localContext, 8, QuixosCapabilityParser.RULE_workspaceItem);
|
|
try {
|
|
this.state = 225;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 217;
|
|
this.sourceImportDecl();
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 218;
|
|
this.atomDecl();
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 219;
|
|
this.resourceImportDecl();
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 220;
|
|
this.sharedAttachmentDecl();
|
|
}
|
|
break;
|
|
case 5:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 221;
|
|
this.conformanceDecl();
|
|
}
|
|
break;
|
|
case 6:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 222;
|
|
this.constructorBindingDecl();
|
|
}
|
|
break;
|
|
case 7:
|
|
this.enterOuterAlt(localContext, 7);
|
|
{
|
|
this.state = 223;
|
|
this.presentationDecl();
|
|
}
|
|
break;
|
|
case 8:
|
|
this.enterOuterAlt(localContext, 8);
|
|
{
|
|
this.state = 224;
|
|
this.typeAliasDecl();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public resourceImportDecl(): ResourceImportDeclContext {
|
|
let localContext = new ResourceImportDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 10, QuixosCapabilityParser.RULE_resourceImportDecl);
|
|
try {
|
|
this.state = 237;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 4, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 227;
|
|
this.match(QuixosCapabilityParser.IMPORT);
|
|
this.state = 228;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 229;
|
|
this.identifier();
|
|
this.state = 230;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 232;
|
|
this.match(QuixosCapabilityParser.IMPORT);
|
|
this.state = 233;
|
|
this.match(QuixosCapabilityParser.PACKAGE);
|
|
this.state = 234;
|
|
this.identifier();
|
|
this.state = 235;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public externalAtomDecl(): ExternalAtomDeclContext {
|
|
let localContext = new ExternalAtomDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 12, QuixosCapabilityParser.RULE_externalAtomDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 239;
|
|
this.match(QuixosCapabilityParser.EXTERNAL);
|
|
this.state = 240;
|
|
this.match(QuixosCapabilityParser.ATOM);
|
|
this.state = 241;
|
|
this.identifier();
|
|
this.state = 242;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 243;
|
|
this.stringLiteral();
|
|
this.state = 244;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public externalInterfaceDecl(): ExternalInterfaceDeclContext {
|
|
let localContext = new ExternalInterfaceDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 14, QuixosCapabilityParser.RULE_externalInterfaceDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 246;
|
|
this.match(QuixosCapabilityParser.EXTERNAL);
|
|
this.state = 247;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 248;
|
|
this.identifier();
|
|
this.state = 249;
|
|
this.match(QuixosCapabilityParser.REVISION);
|
|
this.state = 250;
|
|
this.stringLiteral();
|
|
this.state = 251;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public symbolDecl(): SymbolDeclContext {
|
|
let localContext = new SymbolDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 16, QuixosCapabilityParser.RULE_symbolDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 253;
|
|
this.match(QuixosCapabilityParser.SYMBOL);
|
|
this.state = 254;
|
|
this.identifier();
|
|
this.state = 255;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 256;
|
|
this.stringLiteral();
|
|
this.state = 257;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public resourcePreamble(): ResourcePreambleContext {
|
|
let localContext = new ResourcePreambleContext(this.context, this.state);
|
|
this.enterRule(localContext, 18, QuixosCapabilityParser.RULE_resourcePreamble);
|
|
try {
|
|
this.state = 264;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 5, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 259;
|
|
this.resourceImportDecl();
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 260;
|
|
this.externalAtomDecl();
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 261;
|
|
this.externalInterfaceDecl();
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 262;
|
|
this.symbolDecl();
|
|
}
|
|
break;
|
|
case 5:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 263;
|
|
this.typeAliasDecl();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public atomDecl(): AtomDeclContext {
|
|
let localContext = new AtomDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 20, QuixosCapabilityParser.RULE_atomDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 266;
|
|
this.match(QuixosCapabilityParser.ATOM);
|
|
this.state = 267;
|
|
this.identifier();
|
|
this.state = 268;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 269;
|
|
this.stringLiteral();
|
|
this.state = 272;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 91) {
|
|
{
|
|
this.state = 270;
|
|
this.match(QuixosCapabilityParser.DOC);
|
|
this.state = 271;
|
|
this.stringLiteral();
|
|
}
|
|
}
|
|
|
|
this.state = 274;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public interfaceResourceDecl(): InterfaceResourceDeclContext {
|
|
let localContext = new InterfaceResourceDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 22, QuixosCapabilityParser.RULE_interfaceResourceDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 279;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (((((_la - 37)) & ~0x1F) === 0 && ((1 << (_la - 37)) & 449) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 276;
|
|
this.resourcePreamble();
|
|
}
|
|
}
|
|
this.state = 281;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 282;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 283;
|
|
this.identifier();
|
|
this.state = 285;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 284;
|
|
this.typeParameters();
|
|
}
|
|
}
|
|
|
|
this.state = 287;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 288;
|
|
this.stringLiteral();
|
|
this.state = 289;
|
|
this.match(QuixosCapabilityParser.REVISION);
|
|
this.state = 290;
|
|
this.stringLiteral();
|
|
this.state = 300;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 95) {
|
|
{
|
|
this.state = 291;
|
|
this.match(QuixosCapabilityParser.REQUIRES);
|
|
this.state = 292;
|
|
this.interfaceType();
|
|
this.state = 297;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 141) {
|
|
{
|
|
{
|
|
this.state = 293;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 294;
|
|
this.interfaceType();
|
|
}
|
|
}
|
|
this.state = 299;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.state = 302;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 306;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 2 || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 135200769) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 303;
|
|
this.interfaceMember();
|
|
}
|
|
}
|
|
this.state = 308;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 309;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public typeParameters(): TypeParametersContext {
|
|
let localContext = new TypeParametersContext(this.context, this.state);
|
|
this.enterRule(localContext, 24, QuixosCapabilityParser.RULE_typeParameters);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 311;
|
|
this.match(QuixosCapabilityParser.LT);
|
|
this.state = 312;
|
|
this.typeParameter();
|
|
this.state = 317;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 141) {
|
|
{
|
|
{
|
|
this.state = 313;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 314;
|
|
this.typeParameter();
|
|
}
|
|
}
|
|
this.state = 319;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 320;
|
|
this.match(QuixosCapabilityParser.GT);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public typeParameter(): TypeParameterContext {
|
|
let localContext = new TypeParameterContext(this.context, this.state);
|
|
this.enterRule(localContext, 26, QuixosCapabilityParser.RULE_typeParameter);
|
|
let _la: number;
|
|
try {
|
|
this.state = 341;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.VALUE:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 322;
|
|
this.match(QuixosCapabilityParser.VALUE);
|
|
this.state = 323;
|
|
this.identifier();
|
|
this.state = 326;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 139) {
|
|
{
|
|
this.state = 324;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 325;
|
|
this.match(QuixosCapabilityParser.STORABLE);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.OBJECT:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 328;
|
|
this.match(QuixosCapabilityParser.OBJECT);
|
|
this.state = 329;
|
|
this.identifier();
|
|
this.state = 339;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 40) {
|
|
{
|
|
this.state = 330;
|
|
this.match(QuixosCapabilityParser.IMPLEMENTS);
|
|
this.state = 331;
|
|
this.interfaceType();
|
|
this.state = 336;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 151) {
|
|
{
|
|
{
|
|
this.state = 332;
|
|
this.match(QuixosCapabilityParser.AMP);
|
|
this.state = 333;
|
|
this.interfaceType();
|
|
}
|
|
}
|
|
this.state = 338;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public interfaceType(): InterfaceTypeContext {
|
|
let localContext = new InterfaceTypeContext(this.context, this.state);
|
|
this.enterRule(localContext, 28, QuixosCapabilityParser.RULE_interfaceType);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 343;
|
|
this.identifier();
|
|
this.state = 345;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 344;
|
|
this.typeArguments();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public typeArguments(): TypeArgumentsContext {
|
|
let localContext = new TypeArgumentsContext(this.context, this.state);
|
|
this.enterRule(localContext, 30, QuixosCapabilityParser.RULE_typeArguments);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 347;
|
|
this.match(QuixosCapabilityParser.LT);
|
|
this.state = 348;
|
|
this.typeArgument();
|
|
this.state = 353;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 141) {
|
|
{
|
|
{
|
|
this.state = 349;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 350;
|
|
this.typeArgument();
|
|
}
|
|
}
|
|
this.state = 355;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 356;
|
|
this.match(QuixosCapabilityParser.GT);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public typeArgument(): TypeArgumentContext {
|
|
let localContext = new TypeArgumentContext(this.context, this.state);
|
|
this.enterRule(localContext, 32, QuixosCapabilityParser.RULE_typeArgument);
|
|
try {
|
|
this.state = 365;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.ATOM:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 358;
|
|
this.match(QuixosCapabilityParser.ATOM);
|
|
this.state = 359;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.INTERFACE:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 360;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 361;
|
|
this.interfaceType();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.OBJECT:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 362;
|
|
this.match(QuixosCapabilityParser.OBJECT);
|
|
this.state = 363;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.EDIT:
|
|
case QuixosCapabilityParser.PRESENTATION:
|
|
case QuixosCapabilityParser.SUBJECT:
|
|
case QuixosCapabilityParser.FOR:
|
|
case QuixosCapabilityParser.CREATION:
|
|
case QuixosCapabilityParser.VARIANT:
|
|
case QuixosCapabilityParser.INITIALIZE:
|
|
case QuixosCapabilityParser.EXECUTION:
|
|
case QuixosCapabilityParser.SNAPSHOT:
|
|
case QuixosCapabilityParser.TRANSACTION:
|
|
case QuixosCapabilityParser.REMOTE:
|
|
case QuixosCapabilityParser.TARGETS:
|
|
case QuixosCapabilityParser.PORTABLE:
|
|
case QuixosCapabilityParser.REPLICA:
|
|
case QuixosCapabilityParser.LOCAL:
|
|
case QuixosCapabilityParser.FROM:
|
|
case QuixosCapabilityParser.RESULT_BYTES:
|
|
case QuixosCapabilityParser.RPC_CALLS:
|
|
case QuixosCapabilityParser.DEADLINE_MS:
|
|
case QuixosCapabilityParser.QUERY:
|
|
case QuixosCapabilityParser.REFLECTION:
|
|
case QuixosCapabilityParser.SPECIALIZE:
|
|
case QuixosCapabilityParser.ROOT:
|
|
case QuixosCapabilityParser.DOCUMENT:
|
|
case QuixosCapabilityParser.FRAGMENTS:
|
|
case QuixosCapabilityParser.VIEW:
|
|
case QuixosCapabilityParser.MAX:
|
|
case QuixosCapabilityParser.ALLOW:
|
|
case QuixosCapabilityParser.POLL:
|
|
case QuixosCapabilityParser.QUERYABLE:
|
|
case QuixosCapabilityParser.RPC:
|
|
case QuixosCapabilityParser.REF:
|
|
case QuixosCapabilityParser.FRAGMENT:
|
|
case QuixosCapabilityParser.INTERFACES:
|
|
case QuixosCapabilityParser.SOURCE:
|
|
case QuixosCapabilityParser.JOURNAL:
|
|
case QuixosCapabilityParser.SUBSCRIPTION:
|
|
case QuixosCapabilityParser.START:
|
|
case QuixosCapabilityParser.STOP:
|
|
case QuixosCapabilityParser.CONNECT:
|
|
case QuixosCapabilityParser.REGISTER:
|
|
case QuixosCapabilityParser.UNIT:
|
|
case QuixosCapabilityParser.WATCH_HANDLE:
|
|
case QuixosCapabilityParser.MESSAGE:
|
|
case QuixosCapabilityParser.ATOM_REF:
|
|
case QuixosCapabilityParser.INTERFACE_REF:
|
|
case QuixosCapabilityParser.OPTIONAL:
|
|
case QuixosCapabilityParser.LIST:
|
|
case QuixosCapabilityParser.RECORD:
|
|
case QuixosCapabilityParser.BOOL:
|
|
case QuixosCapabilityParser.BYTES:
|
|
case QuixosCapabilityParser.DOUBLE:
|
|
case QuixosCapabilityParser.INT32:
|
|
case QuixosCapabilityParser.INT64:
|
|
case QuixosCapabilityParser.STRING:
|
|
case QuixosCapabilityParser.UINT32:
|
|
case QuixosCapabilityParser.UINT64:
|
|
case QuixosCapabilityParser.IDENTIFIER:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 364;
|
|
this.valueType();
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public typeAliasDecl(): TypeAliasDeclContext {
|
|
let localContext = new TypeAliasDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 34, QuixosCapabilityParser.RULE_typeAliasDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 367;
|
|
this.match(QuixosCapabilityParser.TYPE);
|
|
this.state = 368;
|
|
this.identifier();
|
|
this.state = 370;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 369;
|
|
this.typeParameters();
|
|
}
|
|
}
|
|
|
|
this.state = 372;
|
|
this.match(QuixosCapabilityParser.EQUAL);
|
|
this.state = 373;
|
|
this.valueType();
|
|
this.state = 374;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public interfaceMember(): InterfaceMemberContext {
|
|
let localContext = new InterfaceMemberContext(this.context, this.state);
|
|
this.enterRule(localContext, 36, QuixosCapabilityParser.RULE_interfaceMember);
|
|
try {
|
|
this.state = 380;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 21, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 376;
|
|
this.valueMember();
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 377;
|
|
this.relationshipMember();
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 378;
|
|
this.operationMember();
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 379;
|
|
this.moduleMember();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public moduleMember(): ModuleMemberContext {
|
|
let localContext = new ModuleMemberContext(this.context, this.state);
|
|
this.enterRule(localContext, 38, QuixosCapabilityParser.RULE_moduleMember);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 382;
|
|
this.match(QuixosCapabilityParser.MODULE);
|
|
this.state = 383;
|
|
this.identifier();
|
|
this.state = 384;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 385;
|
|
this.stringLiteral();
|
|
this.state = 386;
|
|
this.match(QuixosCapabilityParser.CONTRACT);
|
|
this.state = 387;
|
|
this.stringLiteral();
|
|
this.state = 390;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 5) {
|
|
{
|
|
this.state = 388;
|
|
this.match(QuixosCapabilityParser.SUBJECT);
|
|
this.state = 389;
|
|
this.targetConstraint();
|
|
}
|
|
}
|
|
|
|
this.state = 392;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public operationMember(): OperationMemberContext {
|
|
let localContext = new OperationMemberContext(this.context, this.state);
|
|
this.enterRule(localContext, 40, QuixosCapabilityParser.RULE_operationMember);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 395;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 61) {
|
|
{
|
|
this.state = 394;
|
|
this.match(QuixosCapabilityParser.STATIC);
|
|
}
|
|
}
|
|
|
|
this.state = 397;
|
|
this.match(QuixosCapabilityParser.OPERATION);
|
|
this.state = 398;
|
|
this.identifier();
|
|
this.state = 399;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 400;
|
|
this.stringLiteral();
|
|
this.state = 401;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 402;
|
|
this.valueType();
|
|
this.state = 403;
|
|
this.match(QuixosCapabilityParser.ARROW);
|
|
this.state = 404;
|
|
this.valueType();
|
|
this.state = 405;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 406;
|
|
this.match(QuixosCapabilityParser.CALL);
|
|
this.state = 407;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 408;
|
|
this.stringLiteral();
|
|
this.state = 410;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 12) {
|
|
{
|
|
this.state = 409;
|
|
this.executionClause();
|
|
}
|
|
}
|
|
|
|
this.state = 412;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
this.state = 413;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public valueMember(): ValueMemberContext {
|
|
let localContext = new ValueMemberContext(this.context, this.state);
|
|
this.enterRule(localContext, 42, QuixosCapabilityParser.RULE_valueMember);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 416;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 34) {
|
|
{
|
|
this.state = 415;
|
|
this.queryReadContract();
|
|
}
|
|
}
|
|
|
|
this.state = 418;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(_la === 50 || _la === 51)) {
|
|
this.errorHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
this.errorHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 419;
|
|
this.identifier();
|
|
this.state = 420;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 421;
|
|
this.stringLiteral();
|
|
this.state = 422;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 423;
|
|
this.valueType();
|
|
this.state = 424;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 428;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 1 || ((((_la - 97)) & ~0x1F) === 0 && ((1 << (_la - 97)) & 7) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 425;
|
|
this.valueMemberOperation();
|
|
}
|
|
}
|
|
this.state = 430;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 431;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public valueMemberOperation(): ValueMemberOperationContext {
|
|
let localContext = new ValueMemberOperationContext(this.context, this.state);
|
|
this.enterRule(localContext, 44, QuixosCapabilityParser.RULE_valueMemberOperation);
|
|
let _la: number;
|
|
try {
|
|
this.state = 466;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.GET:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 433;
|
|
this.match(QuixosCapabilityParser.GET);
|
|
this.state = 434;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 435;
|
|
this.stringLiteral();
|
|
this.state = 437;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 12) {
|
|
{
|
|
this.state = 436;
|
|
this.executionClause();
|
|
}
|
|
}
|
|
|
|
this.state = 439;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.SET:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 441;
|
|
this.match(QuixosCapabilityParser.SET);
|
|
this.state = 442;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 443;
|
|
this.stringLiteral();
|
|
this.state = 445;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 12) {
|
|
{
|
|
this.state = 444;
|
|
this.executionClause();
|
|
}
|
|
}
|
|
|
|
this.state = 447;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.EDIT:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 449;
|
|
this.match(QuixosCapabilityParser.EDIT);
|
|
this.state = 450;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 451;
|
|
this.stringLiteral();
|
|
this.state = 453;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 12) {
|
|
{
|
|
this.state = 452;
|
|
this.executionClause();
|
|
}
|
|
}
|
|
|
|
this.state = 455;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.WATCH:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 457;
|
|
this.match(QuixosCapabilityParser.WATCH);
|
|
this.state = 458;
|
|
this.match(QuixosCapabilityParser.START);
|
|
this.state = 459;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 460;
|
|
this.stringLiteral();
|
|
this.state = 461;
|
|
this.match(QuixosCapabilityParser.STOP);
|
|
this.state = 462;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 463;
|
|
this.stringLiteral();
|
|
this.state = 464;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public relationshipMember(): RelationshipMemberContext {
|
|
let localContext = new RelationshipMemberContext(this.context, this.state);
|
|
this.enterRule(localContext, 46, QuixosCapabilityParser.RULE_relationshipMember);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 469;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 34) {
|
|
{
|
|
this.state = 468;
|
|
this.queryReadContract();
|
|
}
|
|
}
|
|
|
|
this.state = 471;
|
|
this.match(QuixosCapabilityParser.RELATION);
|
|
this.state = 472;
|
|
this.identifier();
|
|
this.state = 473;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 474;
|
|
this.stringLiteral();
|
|
this.state = 475;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 476;
|
|
this.cardinality();
|
|
this.state = 477;
|
|
this.targetConstraint();
|
|
this.state = 479;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 118) {
|
|
{
|
|
this.state = 478;
|
|
this.match(QuixosCapabilityParser.ORDERED);
|
|
}
|
|
}
|
|
|
|
this.state = 483;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 88) {
|
|
{
|
|
this.state = 481;
|
|
this.match(QuixosCapabilityParser.KEYED);
|
|
this.state = 482;
|
|
this.stringLiteral();
|
|
}
|
|
}
|
|
|
|
this.state = 485;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 489;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (((((_la - 99)) & ~0x1F) === 0 && ((1 << (_la - 99)) & 225) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 486;
|
|
this.relationshipOperation();
|
|
}
|
|
}
|
|
this.state = 491;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 492;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public queryReadContract(): QueryReadContractContext {
|
|
let localContext = new QueryReadContractContext(this.context, this.state);
|
|
this.enterRule(localContext, 48, QuixosCapabilityParser.RULE_queryReadContract);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 494;
|
|
this.match(QuixosCapabilityParser.QUERYABLE);
|
|
this.state = 496;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 17 || _la === 35) {
|
|
{
|
|
this.state = 495;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(_la === 17 || _la === 35)) {
|
|
this.errorHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
this.errorHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public relationshipOperation(): RelationshipOperationContext {
|
|
let localContext = new RelationshipOperationContext(this.context, this.state);
|
|
this.enterRule(localContext, 50, QuixosCapabilityParser.RULE_relationshipOperation);
|
|
let _la: number;
|
|
try {
|
|
this.state = 531;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.RESOLVE:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 498;
|
|
this.match(QuixosCapabilityParser.RESOLVE);
|
|
this.state = 499;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 500;
|
|
this.stringLiteral();
|
|
this.state = 502;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 12) {
|
|
{
|
|
this.state = 501;
|
|
this.executionClause();
|
|
}
|
|
}
|
|
|
|
this.state = 504;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.CONNECT:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 506;
|
|
this.match(QuixosCapabilityParser.CONNECT);
|
|
this.state = 507;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 508;
|
|
this.stringLiteral();
|
|
this.state = 510;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 12) {
|
|
{
|
|
this.state = 509;
|
|
this.executionClause();
|
|
}
|
|
}
|
|
|
|
this.state = 512;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.DISCONNECT:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 514;
|
|
this.match(QuixosCapabilityParser.DISCONNECT);
|
|
this.state = 515;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 516;
|
|
this.stringLiteral();
|
|
this.state = 518;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 12) {
|
|
{
|
|
this.state = 517;
|
|
this.executionClause();
|
|
}
|
|
}
|
|
|
|
this.state = 520;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.WATCH:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 522;
|
|
this.match(QuixosCapabilityParser.WATCH);
|
|
this.state = 523;
|
|
this.match(QuixosCapabilityParser.START);
|
|
this.state = 524;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 525;
|
|
this.stringLiteral();
|
|
this.state = 526;
|
|
this.match(QuixosCapabilityParser.STOP);
|
|
this.state = 527;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 528;
|
|
this.stringLiteral();
|
|
this.state = 529;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public targetConstraint(): TargetConstraintContext {
|
|
let localContext = new TargetConstraintContext(this.context, this.state);
|
|
this.enterRule(localContext, 52, QuixosCapabilityParser.RULE_targetConstraint);
|
|
let _la: number;
|
|
try {
|
|
this.state = 542;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.ATOM:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 533;
|
|
this.match(QuixosCapabilityParser.ATOM);
|
|
this.state = 534;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.INTERFACE:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 535;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 536;
|
|
this.identifier();
|
|
this.state = 538;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 537;
|
|
this.typeArguments();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.OBJECT:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 540;
|
|
this.match(QuixosCapabilityParser.OBJECT);
|
|
this.state = 541;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public packageResourceDecl(): PackageResourceDeclContext {
|
|
let localContext = new PackageResourceDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 54, QuixosCapabilityParser.RULE_packageResourceDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 547;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (((((_la - 37)) & ~0x1F) === 0 && ((1 << (_la - 37)) & 449) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 544;
|
|
this.resourcePreamble();
|
|
}
|
|
}
|
|
this.state = 549;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 550;
|
|
this.match(QuixosCapabilityParser.PACKAGE);
|
|
this.state = 551;
|
|
this.identifier();
|
|
this.state = 552;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 553;
|
|
this.stringLiteral();
|
|
this.state = 554;
|
|
this.match(QuixosCapabilityParser.REVISION);
|
|
this.state = 555;
|
|
this.stringLiteral();
|
|
this.state = 558;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 82) {
|
|
{
|
|
this.state = 556;
|
|
this.match(QuixosCapabilityParser.SEMANTIC_MAJOR);
|
|
this.state = 557;
|
|
this.match(QuixosCapabilityParser.INTEGER);
|
|
}
|
|
}
|
|
|
|
this.state = 560;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 564;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 2 || _la === 24 || ((((_la - 53)) & ~0x1F) === 0 && ((1 << (_la - 53)) & 7) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 561;
|
|
this.packageExport();
|
|
}
|
|
}
|
|
this.state = 566;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 567;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public packageExport(): PackageExportContext {
|
|
let localContext = new PackageExportContext(this.context, this.state);
|
|
this.enterRule(localContext, 56, QuixosCapabilityParser.RULE_packageExport);
|
|
try {
|
|
this.state = 575;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 45, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 569;
|
|
this.packageOperationExport();
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 570;
|
|
this.packageFunctionExport();
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 571;
|
|
this.packageConstructorExport();
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 572;
|
|
this.packageQuery();
|
|
}
|
|
break;
|
|
case 5:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 573;
|
|
this.packageQuerySpecialization();
|
|
}
|
|
break;
|
|
case 6:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 574;
|
|
this.moduleExport();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public moduleExport(): ModuleExportContext {
|
|
let localContext = new ModuleExportContext(this.context, this.state);
|
|
this.enterRule(localContext, 58, QuixosCapabilityParser.RULE_moduleExport);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 577;
|
|
this.match(QuixosCapabilityParser.MODULE);
|
|
this.state = 578;
|
|
this.identifier();
|
|
this.state = 579;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 580;
|
|
this.stringLiteral();
|
|
this.state = 581;
|
|
this.match(QuixosCapabilityParser.IMPLEMENTS);
|
|
this.state = 582;
|
|
this.interfaceType();
|
|
this.state = 583;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 584;
|
|
this.identifier();
|
|
this.state = 585;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public presentationDecl(): PresentationDeclContext {
|
|
let localContext = new PresentationDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 60, QuixosCapabilityParser.RULE_presentationDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 587;
|
|
this.match(QuixosCapabilityParser.PRESENTATION);
|
|
this.state = 588;
|
|
this.identifier();
|
|
this.state = 589;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 590;
|
|
this.stringLiteral();
|
|
this.state = 591;
|
|
this.match(QuixosCapabilityParser.FOR);
|
|
this.state = 592;
|
|
this.interfaceType();
|
|
this.state = 593;
|
|
this.match(QuixosCapabilityParser.USING);
|
|
this.state = 594;
|
|
this.identifier();
|
|
this.state = 595;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 596;
|
|
this.identifier();
|
|
this.state = 597;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public packageQuery(): PackageQueryContext {
|
|
let localContext = new PackageQueryContext(this.context, this.state);
|
|
this.enterRule(localContext, 62, QuixosCapabilityParser.RULE_packageQuery);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 599;
|
|
this.match(QuixosCapabilityParser.QUERY);
|
|
this.state = 601;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 46, this.context) ) {
|
|
case 1:
|
|
{
|
|
this.state = 600;
|
|
this.match(QuixosCapabilityParser.FRAGMENT);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 603;
|
|
this.identifier();
|
|
this.state = 605;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 604;
|
|
this.typeParameters();
|
|
}
|
|
}
|
|
|
|
this.state = 607;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 608;
|
|
this.stringLiteral();
|
|
this.state = 609;
|
|
this.match(QuixosCapabilityParser.ROOT);
|
|
this.state = 611;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 11) {
|
|
{
|
|
this.state = 610;
|
|
this.match(QuixosCapabilityParser.WORKSPACE);
|
|
}
|
|
}
|
|
|
|
this.state = 613;
|
|
this.interfaceType();
|
|
this.state = 614;
|
|
this.match(QuixosCapabilityParser.DOCUMENT);
|
|
this.state = 615;
|
|
this.stringLiteral();
|
|
this.state = 644;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.OPERATION:
|
|
{
|
|
this.state = 616;
|
|
this.match(QuixosCapabilityParser.OPERATION);
|
|
this.state = 617;
|
|
this.stringLiteral();
|
|
this.state = 618;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 622;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (((((_la - 18)) & ~0x1F) === 0 && ((1 << (_la - 18)) & 63491) !== 0) || _la === 99) {
|
|
{
|
|
{
|
|
this.state = 619;
|
|
this.queryClause();
|
|
}
|
|
}
|
|
this.state = 624;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 625;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.FRAGMENT:
|
|
{
|
|
this.state = 627;
|
|
this.match(QuixosCapabilityParser.FRAGMENT);
|
|
this.state = 628;
|
|
this.stringLiteral();
|
|
this.state = 631;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 53) {
|
|
{
|
|
this.state = 629;
|
|
this.match(QuixosCapabilityParser.OPERATION);
|
|
this.state = 630;
|
|
this.stringLiteral();
|
|
}
|
|
}
|
|
|
|
this.state = 642;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.LBRACE:
|
|
{
|
|
this.state = 633;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 637;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (((((_la - 18)) & ~0x1F) === 0 && ((1 << (_la - 18)) & 63491) !== 0) || _la === 99) {
|
|
{
|
|
{
|
|
this.state = 634;
|
|
this.queryClause();
|
|
}
|
|
}
|
|
this.state = 639;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 640;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.SEMI:
|
|
{
|
|
this.state = 641;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public packageQuerySpecialization(): PackageQuerySpecializationContext {
|
|
let localContext = new PackageQuerySpecializationContext(this.context, this.state);
|
|
this.enterRule(localContext, 64, QuixosCapabilityParser.RULE_packageQuerySpecialization);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 646;
|
|
this.match(QuixosCapabilityParser.QUERY);
|
|
this.state = 647;
|
|
this.identifier();
|
|
this.state = 648;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 649;
|
|
this.stringLiteral();
|
|
this.state = 650;
|
|
this.match(QuixosCapabilityParser.SPECIALIZE);
|
|
this.state = 651;
|
|
this.identifier();
|
|
this.state = 652;
|
|
this.typeArguments();
|
|
this.state = 653;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public queryClause(): QueryClauseContext {
|
|
let localContext = new QueryClauseContext(this.context, this.state);
|
|
this.enterRule(localContext, 66, QuixosCapabilityParser.RULE_queryClause);
|
|
let _la: number;
|
|
try {
|
|
this.state = 712;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 57, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 655;
|
|
this.match(QuixosCapabilityParser.REPLICA);
|
|
this.state = 656;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 657;
|
|
this.match(QuixosCapabilityParser.LOCAL);
|
|
this.state = 658;
|
|
this.match(QuixosCapabilityParser.FROM);
|
|
this.state = 659;
|
|
this.identifier();
|
|
this.state = 660;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 662;
|
|
this.match(QuixosCapabilityParser.FRAGMENTS);
|
|
this.state = 663;
|
|
this.stringLiteral();
|
|
this.state = 664;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 666;
|
|
this.match(QuixosCapabilityParser.FRAGMENTS);
|
|
this.state = 667;
|
|
this.identifier();
|
|
this.state = 668;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 669;
|
|
this.identifier();
|
|
this.state = 679;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 68) {
|
|
{
|
|
this.state = 670;
|
|
this.match(QuixosCapabilityParser.WITH);
|
|
this.state = 671;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 675;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294964466) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 66575) !== 0) || ((((_la - 78)) & ~0x1F) === 0 && ((1 << (_la - 78)) & 146801025) !== 0) || _la === 112 || _la === 121 || _la === 155) {
|
|
{
|
|
{
|
|
this.state = 672;
|
|
this.fragmentVariable();
|
|
}
|
|
}
|
|
this.state = 677;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 678;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
|
|
this.state = 681;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 5:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 683;
|
|
this.match(QuixosCapabilityParser.VIEW);
|
|
this.state = 685;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 38) {
|
|
{
|
|
this.state = 684;
|
|
this.match(QuixosCapabilityParser.OBJECT);
|
|
}
|
|
}
|
|
|
|
this.state = 687;
|
|
this.identifier();
|
|
this.state = 688;
|
|
this.match(QuixosCapabilityParser.AS);
|
|
this.state = 689;
|
|
this.interfaceType();
|
|
this.state = 690;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 6:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 692;
|
|
this.match(QuixosCapabilityParser.MAX);
|
|
this.state = 693;
|
|
this.identifier();
|
|
this.state = 694;
|
|
this.match(QuixosCapabilityParser.INTEGER);
|
|
this.state = 695;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 7:
|
|
this.enterOuterAlt(localContext, 7);
|
|
{
|
|
this.state = 697;
|
|
this.match(QuixosCapabilityParser.ALLOW);
|
|
this.state = 698;
|
|
this.interfaceType();
|
|
this.state = 699;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 700;
|
|
this.identifier();
|
|
this.state = 701;
|
|
this.identifier();
|
|
this.state = 702;
|
|
this.stringLiteral();
|
|
this.state = 703;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 8:
|
|
this.enterOuterAlt(localContext, 8);
|
|
{
|
|
this.state = 705;
|
|
this.match(QuixosCapabilityParser.WATCH);
|
|
this.state = 706;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 9:
|
|
this.enterOuterAlt(localContext, 9);
|
|
{
|
|
this.state = 707;
|
|
this.match(QuixosCapabilityParser.POLL);
|
|
this.state = 708;
|
|
this.match(QuixosCapabilityParser.INTEGER);
|
|
this.state = 709;
|
|
this.stringLiteral();
|
|
this.state = 710;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public fragmentVariable(): FragmentVariableContext {
|
|
let localContext = new FragmentVariableContext(this.context, this.state);
|
|
this.enterRule(localContext, 68, QuixosCapabilityParser.RULE_fragmentVariable);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 714;
|
|
this.identifier();
|
|
this.state = 715;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 716;
|
|
this.identifier();
|
|
this.state = 717;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public packageOperationExport(): PackageOperationExportContext {
|
|
let localContext = new PackageOperationExportContext(this.context, this.state);
|
|
this.enterRule(localContext, 70, QuixosCapabilityParser.RULE_packageOperationExport);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 719;
|
|
this.match(QuixosCapabilityParser.OPERATION);
|
|
this.state = 720;
|
|
this.identifier();
|
|
this.state = 722;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 721;
|
|
this.typeParameters();
|
|
}
|
|
}
|
|
|
|
this.state = 724;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 725;
|
|
this.stringLiteral();
|
|
this.state = 726;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 727;
|
|
this.valueType();
|
|
this.state = 728;
|
|
this.match(QuixosCapabilityParser.ARROW);
|
|
this.state = 729;
|
|
this.valueType();
|
|
this.state = 730;
|
|
this.match(QuixosCapabilityParser.MODE);
|
|
this.state = 731;
|
|
this.operationMode();
|
|
this.state = 733;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 12) {
|
|
{
|
|
this.state = 732;
|
|
this.executionClause();
|
|
}
|
|
}
|
|
|
|
this.state = 736;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 93) {
|
|
{
|
|
this.state = 735;
|
|
this.eventClause();
|
|
}
|
|
}
|
|
|
|
this.state = 738;
|
|
this.match(QuixosCapabilityParser.RECEIVER);
|
|
this.state = 739;
|
|
this.receiverRequirement();
|
|
this.state = 741;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 95) {
|
|
{
|
|
this.state = 740;
|
|
this.dependencyBlock();
|
|
}
|
|
}
|
|
|
|
this.state = 744;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 9) {
|
|
{
|
|
this.state = 743;
|
|
this.preparationClause();
|
|
}
|
|
}
|
|
|
|
this.state = 747;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 70) {
|
|
{
|
|
this.state = 746;
|
|
this.acceptanceClause();
|
|
}
|
|
}
|
|
|
|
this.state = 749;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public packageFunctionExport(): PackageFunctionExportContext {
|
|
let localContext = new PackageFunctionExportContext(this.context, this.state);
|
|
this.enterRule(localContext, 72, QuixosCapabilityParser.RULE_packageFunctionExport);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 751;
|
|
this.match(QuixosCapabilityParser.FUNCTION);
|
|
this.state = 752;
|
|
this.identifier();
|
|
this.state = 754;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 753;
|
|
this.typeParameters();
|
|
}
|
|
}
|
|
|
|
this.state = 756;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 757;
|
|
this.stringLiteral();
|
|
this.state = 758;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 759;
|
|
this.valueType();
|
|
this.state = 760;
|
|
this.match(QuixosCapabilityParser.ARROW);
|
|
this.state = 761;
|
|
this.valueType();
|
|
this.state = 763;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 12) {
|
|
{
|
|
this.state = 762;
|
|
this.executionClause();
|
|
}
|
|
}
|
|
|
|
this.state = 766;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 95) {
|
|
{
|
|
this.state = 765;
|
|
this.dependencyBlock();
|
|
}
|
|
}
|
|
|
|
this.state = 769;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 9) {
|
|
{
|
|
this.state = 768;
|
|
this.preparationClause();
|
|
}
|
|
}
|
|
|
|
this.state = 772;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 70) {
|
|
{
|
|
this.state = 771;
|
|
this.acceptanceClause();
|
|
}
|
|
}
|
|
|
|
this.state = 774;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public acceptanceClause(): AcceptanceClauseContext {
|
|
let localContext = new AcceptanceClauseContext(this.context, this.state);
|
|
this.enterRule(localContext, 74, QuixosCapabilityParser.RULE_acceptanceClause);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 776;
|
|
this.match(QuixosCapabilityParser.ACCEPT);
|
|
this.state = 777;
|
|
this.match(QuixosCapabilityParser.USING);
|
|
this.state = 778;
|
|
this.identifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public preparationClause(): PreparationClauseContext {
|
|
let localContext = new PreparationClauseContext(this.context, this.state);
|
|
this.enterRule(localContext, 76, QuixosCapabilityParser.RULE_preparationClause);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 780;
|
|
this.match(QuixosCapabilityParser.PREPARES);
|
|
this.state = 781;
|
|
this.match(QuixosCapabilityParser.CREATION);
|
|
this.state = 782;
|
|
this.identifier();
|
|
this.state = 783;
|
|
this.match(QuixosCapabilityParser.USING);
|
|
this.state = 784;
|
|
this.stringLiteral();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public executionClause(): ExecutionClauseContext {
|
|
let localContext = new ExecutionClauseContext(this.context, this.state);
|
|
this.enterRule(localContext, 78, QuixosCapabilityParser.RULE_executionClause);
|
|
let _la: number;
|
|
try {
|
|
this.state = 797;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 70, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 786;
|
|
this.match(QuixosCapabilityParser.EXECUTION);
|
|
this.state = 787;
|
|
this.match(QuixosCapabilityParser.REMOTE);
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 788;
|
|
this.match(QuixosCapabilityParser.EXECUTION);
|
|
this.state = 789;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(_la === 13 || _la === 14)) {
|
|
this.errorHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
this.errorHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 795;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 16) {
|
|
{
|
|
this.state = 790;
|
|
this.match(QuixosCapabilityParser.TARGETS);
|
|
this.state = 791;
|
|
this.match(QuixosCapabilityParser.LBRACK);
|
|
this.state = 792;
|
|
this.identifierList();
|
|
this.state = 793;
|
|
this.match(QuixosCapabilityParser.RBRACK);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public selectedOperations(): SelectedOperationsContext {
|
|
let localContext = new SelectedOperationsContext(this.context, this.state);
|
|
this.enterRule(localContext, 80, QuixosCapabilityParser.RULE_selectedOperations);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 799;
|
|
this.match(QuixosCapabilityParser.USING);
|
|
this.state = 800;
|
|
this.match(QuixosCapabilityParser.LBRACK);
|
|
this.state = 801;
|
|
this.memberOperationRef();
|
|
this.state = 806;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 141) {
|
|
{
|
|
{
|
|
this.state = 802;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 803;
|
|
this.memberOperationRef();
|
|
}
|
|
}
|
|
this.state = 808;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 809;
|
|
this.match(QuixosCapabilityParser.RBRACK);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public packageConstructorExport(): PackageConstructorExportContext {
|
|
let localContext = new PackageConstructorExportContext(this.context, this.state);
|
|
this.enterRule(localContext, 82, QuixosCapabilityParser.RULE_packageConstructorExport);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 811;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTOR);
|
|
this.state = 812;
|
|
this.identifier();
|
|
this.state = 813;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 814;
|
|
this.stringLiteral();
|
|
this.state = 815;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTS);
|
|
this.state = 816;
|
|
this.identifier();
|
|
this.state = 817;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 818;
|
|
this.valueType();
|
|
this.state = 820;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 95) {
|
|
{
|
|
this.state = 819;
|
|
this.dependencyBlock();
|
|
}
|
|
}
|
|
|
|
this.state = 822;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public eventClause(): EventClauseContext {
|
|
let localContext = new EventClauseContext(this.context, this.state);
|
|
this.enterRule(localContext, 84, QuixosCapabilityParser.RULE_eventClause);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 824;
|
|
this.match(QuixosCapabilityParser.EMITS);
|
|
this.state = 825;
|
|
this.valueType();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public operationMode(): OperationModeContext {
|
|
let localContext = new OperationModeContext(this.context, this.state);
|
|
this.enterRule(localContext, 86, QuixosCapabilityParser.RULE_operationMode);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 827;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 31) !== 0))) {
|
|
this.errorHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
this.errorHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public receiverRequirement(): ReceiverRequirementContext {
|
|
let localContext = new ReceiverRequirementContext(this.context, this.state);
|
|
this.enterRule(localContext, 88, QuixosCapabilityParser.RULE_receiverRequirement);
|
|
let _la: number;
|
|
try {
|
|
this.state = 847;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.ANY:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 829;
|
|
this.match(QuixosCapabilityParser.ANY);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.ATOM:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 830;
|
|
this.match(QuixosCapabilityParser.ATOM);
|
|
this.state = 831;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.OBJECT:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 832;
|
|
this.match(QuixosCapabilityParser.OBJECT);
|
|
this.state = 833;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.INTERFACES:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 834;
|
|
this.match(QuixosCapabilityParser.INTERFACES);
|
|
this.state = 835;
|
|
this.match(QuixosCapabilityParser.LBRACK);
|
|
this.state = 844;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294964466) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 66575) !== 0) || ((((_la - 78)) & ~0x1F) === 0 && ((1 << (_la - 78)) & 146801025) !== 0) || _la === 112 || _la === 121 || _la === 155) {
|
|
{
|
|
this.state = 836;
|
|
this.interfaceType();
|
|
this.state = 841;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 141) {
|
|
{
|
|
{
|
|
this.state = 837;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 838;
|
|
this.interfaceType();
|
|
}
|
|
}
|
|
this.state = 843;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.state = 846;
|
|
this.match(QuixosCapabilityParser.RBRACK);
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public identifierList(): IdentifierListContext {
|
|
let localContext = new IdentifierListContext(this.context, this.state);
|
|
this.enterRule(localContext, 90, QuixosCapabilityParser.RULE_identifierList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 849;
|
|
this.identifier();
|
|
this.state = 854;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 141) {
|
|
{
|
|
{
|
|
this.state = 850;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 851;
|
|
this.identifier();
|
|
}
|
|
}
|
|
this.state = 856;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public dependencyBlock(): DependencyBlockContext {
|
|
let localContext = new DependencyBlockContext(this.context, this.state);
|
|
this.enterRule(localContext, 92, QuixosCapabilityParser.RULE_dependencyBlock);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 857;
|
|
this.match(QuixosCapabilityParser.REQUIRES);
|
|
this.state = 858;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 862;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 50331776) !== 0) || ((((_la - 47)) & ~0x1F) === 0 && ((1 << (_la - 47)) & 786689) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 859;
|
|
this.dependencyPort();
|
|
}
|
|
}
|
|
this.state = 864;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 865;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public dependencyPort(): DependencyPortContext {
|
|
let localContext = new DependencyPortContext(this.context, this.state);
|
|
this.enterRule(localContext, 94, QuixosCapabilityParser.RULE_dependencyPort);
|
|
let _la: number;
|
|
try {
|
|
this.state = 949;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.REFLECTION:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 867;
|
|
this.match(QuixosCapabilityParser.REFLECTION);
|
|
this.state = 868;
|
|
this.identifier();
|
|
this.state = 869;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 870;
|
|
this.stringLiteral();
|
|
this.state = 871;
|
|
this.match(QuixosCapabilityParser.LBRACK);
|
|
this.state = 872;
|
|
this.identifierList();
|
|
this.state = 873;
|
|
this.match(QuixosCapabilityParser.RBRACK);
|
|
this.state = 874;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.STATE:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 876;
|
|
this.match(QuixosCapabilityParser.STATE);
|
|
this.state = 877;
|
|
this.identifier();
|
|
this.state = 878;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 879;
|
|
this.stringLiteral();
|
|
this.state = 880;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 881;
|
|
this.valueType();
|
|
this.state = 882;
|
|
this.primitiveList();
|
|
this.state = 883;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.EDGE:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 885;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 886;
|
|
this.identifier();
|
|
this.state = 887;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 888;
|
|
this.stringLiteral();
|
|
this.state = 889;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 890;
|
|
this.cardinality();
|
|
this.state = 891;
|
|
this.targetConstraint();
|
|
this.state = 894;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 88) {
|
|
{
|
|
this.state = 892;
|
|
this.match(QuixosCapabilityParser.KEYED);
|
|
this.state = 893;
|
|
this.stringLiteral();
|
|
}
|
|
}
|
|
|
|
this.state = 896;
|
|
this.primitiveList();
|
|
this.state = 897;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.INTERFACE:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 899;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 900;
|
|
this.identifier();
|
|
this.state = 901;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 902;
|
|
this.stringLiteral();
|
|
this.state = 903;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 904;
|
|
this.identifier();
|
|
this.state = 906;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 905;
|
|
this.typeArguments();
|
|
}
|
|
}
|
|
|
|
this.state = 909;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 69) {
|
|
{
|
|
this.state = 908;
|
|
this.selectedOperations();
|
|
}
|
|
}
|
|
|
|
this.state = 913;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 20) {
|
|
{
|
|
this.state = 911;
|
|
this.match(QuixosCapabilityParser.FROM);
|
|
this.state = 912;
|
|
this.match(QuixosCapabilityParser.INPUT);
|
|
}
|
|
}
|
|
|
|
this.state = 915;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.CREATION:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 917;
|
|
this.match(QuixosCapabilityParser.CREATION);
|
|
this.state = 918;
|
|
this.identifier();
|
|
this.state = 919;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 920;
|
|
this.stringLiteral();
|
|
this.state = 921;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 922;
|
|
this.identifier();
|
|
this.state = 923;
|
|
this.match(QuixosCapabilityParser.INPUT);
|
|
this.state = 924;
|
|
this.valueType();
|
|
this.state = 925;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.CONSTRUCTOR:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 927;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTOR);
|
|
this.state = 928;
|
|
this.identifier();
|
|
this.state = 929;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 930;
|
|
this.stringLiteral();
|
|
this.state = 931;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 932;
|
|
this.identifier();
|
|
this.state = 935;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 57) {
|
|
{
|
|
this.state = 933;
|
|
this.match(QuixosCapabilityParser.INPUT);
|
|
this.state = 934;
|
|
this.valueType();
|
|
}
|
|
}
|
|
|
|
this.state = 937;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.QUERY:
|
|
this.enterOuterAlt(localContext, 7);
|
|
{
|
|
this.state = 939;
|
|
this.match(QuixosCapabilityParser.QUERY);
|
|
this.state = 940;
|
|
this.identifier();
|
|
this.state = 941;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 942;
|
|
this.stringLiteral();
|
|
this.state = 943;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 944;
|
|
this.identifier();
|
|
this.state = 945;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 946;
|
|
this.identifier();
|
|
this.state = 947;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public primitiveList(): PrimitiveListContext {
|
|
let localContext = new PrimitiveListContext(this.context, this.state);
|
|
this.enterRule(localContext, 96, QuixosCapabilityParser.RULE_primitiveList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 951;
|
|
this.match(QuixosCapabilityParser.LBRACK);
|
|
this.state = 952;
|
|
this.primitive();
|
|
this.state = 957;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 141) {
|
|
{
|
|
{
|
|
this.state = 953;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 954;
|
|
this.primitive();
|
|
}
|
|
}
|
|
this.state = 959;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 960;
|
|
this.match(QuixosCapabilityParser.RBRACK);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public primitive(): PrimitiveContext {
|
|
let localContext = new PrimitiveContext(this.context, this.state);
|
|
this.enterRule(localContext, 98, QuixosCapabilityParser.RULE_primitive);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 962;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(_la === 1 || ((((_la - 102)) & ~0x1F) === 0 && ((1 << (_la - 102)) & 223) !== 0))) {
|
|
this.errorHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
this.errorHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public sharedAttachmentDecl(): SharedAttachmentDeclContext {
|
|
let localContext = new SharedAttachmentDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 100, QuixosCapabilityParser.RULE_sharedAttachmentDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 964;
|
|
this.match(QuixosCapabilityParser.SHARED);
|
|
this.state = 965;
|
|
this.attachmentDecl();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public attachmentDecl(): AttachmentDeclContext {
|
|
let localContext = new AttachmentDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 102, QuixosCapabilityParser.RULE_attachmentDecl);
|
|
try {
|
|
this.state = 969;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.STATE:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 967;
|
|
this.stateDecl();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.EDGE:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 968;
|
|
this.edgeDecl();
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public stateDecl(): StateDeclContext {
|
|
let localContext = new StateDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 104, QuixosCapabilityParser.RULE_stateDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 971;
|
|
this.match(QuixosCapabilityParser.STATE);
|
|
this.state = 972;
|
|
this.identifier();
|
|
this.state = 973;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 974;
|
|
this.stringLiteral();
|
|
this.state = 975;
|
|
this.match(QuixosCapabilityParser.ON);
|
|
this.state = 976;
|
|
this.identifier();
|
|
this.state = 977;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 978;
|
|
this.valueType();
|
|
this.state = 979;
|
|
this.match(QuixosCapabilityParser.POLICY);
|
|
this.state = 980;
|
|
this.storagePolicy();
|
|
this.state = 983;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 77) {
|
|
{
|
|
this.state = 981;
|
|
this.match(QuixosCapabilityParser.DEFAULT);
|
|
this.state = 982;
|
|
this.jsonLiteral();
|
|
}
|
|
}
|
|
|
|
this.state = 985;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public storagePolicy(): StoragePolicyContext {
|
|
let localContext = new StoragePolicyContext(this.context, this.state);
|
|
this.enterRule(localContext, 106, QuixosCapabilityParser.RULE_storagePolicy);
|
|
try {
|
|
this.state = 1000;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.REGISTER:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 987;
|
|
this.match(QuixosCapabilityParser.REGISTER);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.CRDT:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 988;
|
|
this.match(QuixosCapabilityParser.CRDT);
|
|
this.state = 989;
|
|
this.match(QuixosCapabilityParser.LPAREN);
|
|
this.state = 990;
|
|
this.valueType();
|
|
this.state = 991;
|
|
this.match(QuixosCapabilityParser.RPAREN);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.JOURNAL:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 993;
|
|
this.match(QuixosCapabilityParser.JOURNAL);
|
|
this.state = 994;
|
|
this.jsonObject();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.SUBSCRIPTION:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 995;
|
|
this.match(QuixosCapabilityParser.SUBSCRIPTION);
|
|
this.state = 996;
|
|
this.match(QuixosCapabilityParser.LPAREN);
|
|
this.state = 997;
|
|
this.valueType();
|
|
this.state = 998;
|
|
this.match(QuixosCapabilityParser.RPAREN);
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public edgeDecl(): EdgeDeclContext {
|
|
let localContext = new EdgeDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 108, QuixosCapabilityParser.RULE_edgeDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1002;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 1003;
|
|
this.identifier();
|
|
this.state = 1004;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 1005;
|
|
this.stringLiteral();
|
|
this.state = 1006;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 1007;
|
|
this.edgeEndpoint();
|
|
this.state = 1008;
|
|
this.edgeEndpoint();
|
|
this.state = 1009;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public edgeEndpoint(): EdgeEndpointContext {
|
|
let localContext = new EdgeEndpointContext(this.context, this.state);
|
|
this.enterRule(localContext, 110, QuixosCapabilityParser.RULE_edgeEndpoint);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1011;
|
|
this.targetConstraint();
|
|
this.state = 1012;
|
|
this.match(QuixosCapabilityParser.PROJECTION);
|
|
this.state = 1013;
|
|
this.identifier();
|
|
this.state = 1014;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 1015;
|
|
this.stringLiteral();
|
|
this.state = 1016;
|
|
this.cardinality();
|
|
this.state = 1018;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 118) {
|
|
{
|
|
this.state = 1017;
|
|
this.match(QuixosCapabilityParser.ORDERED);
|
|
}
|
|
}
|
|
|
|
this.state = 1022;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 83) {
|
|
{
|
|
this.state = 1020;
|
|
this.match(QuixosCapabilityParser.ON_DELETE);
|
|
this.state = 1021;
|
|
this.stringLiteral();
|
|
}
|
|
}
|
|
|
|
this.state = 1025;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 87) {
|
|
{
|
|
this.state = 1024;
|
|
this.match(QuixosCapabilityParser.RETAIN_OTHER);
|
|
}
|
|
}
|
|
|
|
this.state = 1029;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 88) {
|
|
{
|
|
this.state = 1027;
|
|
this.match(QuixosCapabilityParser.KEYED);
|
|
this.state = 1028;
|
|
this.stringLiteral();
|
|
}
|
|
}
|
|
|
|
this.state = 1032;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 89) {
|
|
{
|
|
this.state = 1031;
|
|
this.match(QuixosCapabilityParser.PUBLIC_TRAVERSAL);
|
|
}
|
|
}
|
|
|
|
this.state = 1034;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public conformanceDecl(): ConformanceDeclContext {
|
|
let localContext = new ConformanceDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 112, QuixosCapabilityParser.RULE_conformanceDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1036;
|
|
this.match(QuixosCapabilityParser.CONFORM);
|
|
this.state = 1038;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 1037;
|
|
this.typeParameters();
|
|
}
|
|
}
|
|
|
|
this.state = 1040;
|
|
this.identifier();
|
|
this.state = 1042;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 1041;
|
|
this.conformanceSourceArguments();
|
|
}
|
|
}
|
|
|
|
this.state = 1044;
|
|
this.match(QuixosCapabilityParser.AS);
|
|
this.state = 1045;
|
|
this.identifier();
|
|
this.state = 1047;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 1046;
|
|
this.typeArguments();
|
|
}
|
|
}
|
|
|
|
this.state = 1051;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 90) {
|
|
{
|
|
this.state = 1049;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 1050;
|
|
this.stringLiteral();
|
|
}
|
|
}
|
|
|
|
this.state = 1055;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 82) {
|
|
{
|
|
this.state = 1053;
|
|
this.match(QuixosCapabilityParser.SEMANTIC_MAJOR);
|
|
this.state = 1054;
|
|
this.match(QuixosCapabilityParser.INTEGER);
|
|
}
|
|
}
|
|
|
|
this.state = 1057;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 1061;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 10 || ((((_la - 60)) & ~0x1F) === 0 && ((1 << (_la - 60)) & 4105) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 1058;
|
|
this.conformanceItem();
|
|
}
|
|
}
|
|
this.state = 1063;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 1064;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public conformanceSourceArguments(): ConformanceSourceArgumentsContext {
|
|
let localContext = new ConformanceSourceArgumentsContext(this.context, this.state);
|
|
this.enterRule(localContext, 114, QuixosCapabilityParser.RULE_conformanceSourceArguments);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1066;
|
|
this.typeArguments();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public conformanceItem(): ConformanceItemContext {
|
|
let localContext = new ConformanceItemContext(this.context, this.state);
|
|
this.enterRule(localContext, 116, QuixosCapabilityParser.RULE_conformanceItem);
|
|
try {
|
|
this.state = 1075;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 99, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1068;
|
|
this.match(QuixosCapabilityParser.PRIVATE);
|
|
this.state = 1069;
|
|
this.attachmentDecl();
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 1070;
|
|
this.operationBindingDecl();
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 1071;
|
|
this.stateFieldBindingDecl();
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 1072;
|
|
this.initializationDecl();
|
|
}
|
|
break;
|
|
case 5:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 1073;
|
|
this.relationshipMaterializationDecl();
|
|
}
|
|
break;
|
|
case 6:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 1074;
|
|
this.moduleBindingDecl();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public moduleBindingDecl(): ModuleBindingDeclContext {
|
|
let localContext = new ModuleBindingDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 118, QuixosCapabilityParser.RULE_moduleBindingDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1077;
|
|
this.match(QuixosCapabilityParser.BIND);
|
|
this.state = 1078;
|
|
this.identifier();
|
|
this.state = 1079;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1080;
|
|
this.identifier();
|
|
this.state = 1081;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1082;
|
|
this.identifier();
|
|
this.state = 1083;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public initializationDecl(): InitializationDeclContext {
|
|
let localContext = new InitializationDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 120, QuixosCapabilityParser.RULE_initializationDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1085;
|
|
this.match(QuixosCapabilityParser.INITIALIZE);
|
|
this.state = 1086;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 1090;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294964466) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 66575) !== 0) || ((((_la - 78)) & ~0x1F) === 0 && ((1 << (_la - 78)) & 146801025) !== 0) || _la === 112 || _la === 121 || _la === 155) {
|
|
{
|
|
{
|
|
this.state = 1087;
|
|
this.initializationField();
|
|
}
|
|
}
|
|
this.state = 1092;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 1093;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
this.state = 1094;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public initializationField(): InitializationFieldContext {
|
|
let localContext = new InitializationFieldContext(this.context, this.state);
|
|
this.enterRule(localContext, 122, QuixosCapabilityParser.RULE_initializationField);
|
|
try {
|
|
this.state = 1110;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 101, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1096;
|
|
this.identifier();
|
|
this.state = 1097;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1098;
|
|
this.match(QuixosCapabilityParser.STATE);
|
|
this.state = 1099;
|
|
this.identifier();
|
|
this.state = 1100;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 1102;
|
|
this.identifier();
|
|
this.state = 1103;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1104;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 1105;
|
|
this.identifier();
|
|
this.state = 1106;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1107;
|
|
this.identifier();
|
|
this.state = 1108;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public creationOwnerMapping(): CreationOwnerMappingContext {
|
|
let localContext = new CreationOwnerMappingContext(this.context, this.state);
|
|
this.enterRule(localContext, 124, QuixosCapabilityParser.RULE_creationOwnerMapping);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1112;
|
|
this.interfaceType();
|
|
this.state = 1113;
|
|
this.match(QuixosCapabilityParser.FROM);
|
|
this.state = 1114;
|
|
this.match(QuixosCapabilityParser.INPUT);
|
|
this.state = 1119;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 142) {
|
|
{
|
|
{
|
|
this.state = 1115;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1116;
|
|
this.identifier();
|
|
}
|
|
}
|
|
this.state = 1121;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 1122;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public stateFieldBindingDecl(): StateFieldBindingDeclContext {
|
|
let localContext = new StateFieldBindingDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 126, QuixosCapabilityParser.RULE_stateFieldBindingDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1124;
|
|
this.match(QuixosCapabilityParser.BIND);
|
|
this.state = 1125;
|
|
this.identifier();
|
|
this.state = 1126;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1127;
|
|
this.match(QuixosCapabilityParser.STATE);
|
|
this.state = 1128;
|
|
this.identifier();
|
|
this.state = 1129;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public relationshipMaterializationDecl(): RelationshipMaterializationDeclContext {
|
|
let localContext = new RelationshipMaterializationDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 128, QuixosCapabilityParser.RULE_relationshipMaterializationDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1131;
|
|
this.match(QuixosCapabilityParser.MATERIALIZE);
|
|
this.state = 1132;
|
|
this.identifier();
|
|
this.state = 1133;
|
|
this.match(QuixosCapabilityParser.IF);
|
|
this.state = 1134;
|
|
this.match(QuixosCapabilityParser.ABSENT);
|
|
this.state = 1135;
|
|
this.match(QuixosCapabilityParser.USING);
|
|
this.state = 1136;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTOR);
|
|
this.state = 1137;
|
|
this.identifier();
|
|
this.state = 1138;
|
|
this.match(QuixosCapabilityParser.VIA);
|
|
this.state = 1139;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 1140;
|
|
this.identifier();
|
|
this.state = 1141;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1142;
|
|
this.identifier();
|
|
this.state = 1143;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public operationBindingDecl(): OperationBindingDeclContext {
|
|
let localContext = new OperationBindingDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 130, QuixosCapabilityParser.RULE_operationBindingDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1145;
|
|
this.match(QuixosCapabilityParser.BIND);
|
|
this.state = 1146;
|
|
this.memberOperationRef();
|
|
this.state = 1147;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1148;
|
|
this.operationProvider();
|
|
this.state = 1151;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 36) {
|
|
{
|
|
this.state = 1149;
|
|
this.match(QuixosCapabilityParser.QUERY_REASON);
|
|
this.state = 1150;
|
|
this.stringLiteral();
|
|
}
|
|
}
|
|
|
|
this.state = 1153;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public memberOperationRef(): MemberOperationRefContext {
|
|
let localContext = new MemberOperationRefContext(this.context, this.state);
|
|
this.enterRule(localContext, 132, QuixosCapabilityParser.RULE_memberOperationRef);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1155;
|
|
this.identifier();
|
|
this.state = 1156;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1157;
|
|
this.operationName();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public operationName(): OperationNameContext {
|
|
let localContext = new OperationNameContext(this.context, this.state);
|
|
this.enterRule(localContext, 134, QuixosCapabilityParser.RULE_operationName);
|
|
try {
|
|
this.state = 1171;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 104, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1159;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 1160;
|
|
this.match(QuixosCapabilityParser.CALL);
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 1161;
|
|
this.match(QuixosCapabilityParser.GET);
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 1162;
|
|
this.match(QuixosCapabilityParser.SET);
|
|
}
|
|
break;
|
|
case 5:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 1163;
|
|
this.match(QuixosCapabilityParser.EDIT);
|
|
}
|
|
break;
|
|
case 6:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 1164;
|
|
this.match(QuixosCapabilityParser.RESOLVE);
|
|
}
|
|
break;
|
|
case 7:
|
|
this.enterOuterAlt(localContext, 7);
|
|
{
|
|
this.state = 1165;
|
|
this.match(QuixosCapabilityParser.CONNECT);
|
|
}
|
|
break;
|
|
case 8:
|
|
this.enterOuterAlt(localContext, 8);
|
|
{
|
|
this.state = 1166;
|
|
this.match(QuixosCapabilityParser.DISCONNECT);
|
|
}
|
|
break;
|
|
case 9:
|
|
this.enterOuterAlt(localContext, 9);
|
|
{
|
|
this.state = 1167;
|
|
this.match(QuixosCapabilityParser.WATCH_START);
|
|
}
|
|
break;
|
|
case 10:
|
|
this.enterOuterAlt(localContext, 10);
|
|
{
|
|
this.state = 1168;
|
|
this.match(QuixosCapabilityParser.WATCH_STOP);
|
|
}
|
|
break;
|
|
case 11:
|
|
this.enterOuterAlt(localContext, 11);
|
|
{
|
|
this.state = 1169;
|
|
this.match(QuixosCapabilityParser.SUBSCRIBE);
|
|
}
|
|
break;
|
|
case 12:
|
|
this.enterOuterAlt(localContext, 12);
|
|
{
|
|
this.state = 1170;
|
|
this.match(QuixosCapabilityParser.UNSUBSCRIBE);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public operationProvider(): OperationProviderContext {
|
|
let localContext = new OperationProviderContext(this.context, this.state);
|
|
this.enterRule(localContext, 136, QuixosCapabilityParser.RULE_operationProvider);
|
|
let _la: number;
|
|
try {
|
|
this.state = 1219;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.LIFECYCLE:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1173;
|
|
this.match(QuixosCapabilityParser.LIFECYCLE);
|
|
this.state = 1174;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1175;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.JOURNAL:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 1176;
|
|
this.match(QuixosCapabilityParser.JOURNAL);
|
|
this.state = 1177;
|
|
this.identifier();
|
|
this.state = 1178;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1179;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.SUBSCRIPTION:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 1181;
|
|
this.match(QuixosCapabilityParser.SUBSCRIPTION);
|
|
this.state = 1182;
|
|
this.identifier();
|
|
this.state = 1183;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1184;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.STATE:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 1186;
|
|
this.match(QuixosCapabilityParser.STATE);
|
|
this.state = 1187;
|
|
this.identifier();
|
|
this.state = 1188;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1189;
|
|
this.statePrimitive();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.EDGE:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 1191;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 1192;
|
|
this.identifier();
|
|
this.state = 1193;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1194;
|
|
this.identifier();
|
|
this.state = 1195;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1196;
|
|
this.edgePrimitive();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.INTERFACE:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 1198;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 1199;
|
|
this.identifier();
|
|
this.state = 1201;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 1200;
|
|
this.typeArguments();
|
|
}
|
|
}
|
|
|
|
this.state = 1203;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1204;
|
|
this.memberOperationRef();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.PACKAGE:
|
|
this.enterOuterAlt(localContext, 7);
|
|
{
|
|
this.state = 1206;
|
|
this.match(QuixosCapabilityParser.PACKAGE);
|
|
this.state = 1207;
|
|
this.identifier();
|
|
this.state = 1208;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1209;
|
|
this.identifier();
|
|
this.state = 1211;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 1210;
|
|
this.typeArguments();
|
|
}
|
|
}
|
|
|
|
this.state = 1214;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 68) {
|
|
{
|
|
this.state = 1213;
|
|
this.dependencyBindingBlock();
|
|
}
|
|
}
|
|
|
|
this.state = 1217;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 70) {
|
|
{
|
|
this.state = 1216;
|
|
this.acceptanceBinding();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public acceptanceBinding(): AcceptanceBindingContext {
|
|
let localContext = new AcceptanceBindingContext(this.context, this.state);
|
|
this.enterRule(localContext, 138, QuixosCapabilityParser.RULE_acceptanceBinding);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1221;
|
|
this.match(QuixosCapabilityParser.ACCEPT);
|
|
this.state = 1222;
|
|
this.dependencyBindingBlock();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public statePrimitive(): StatePrimitiveContext {
|
|
let localContext = new StatePrimitiveContext(this.context, this.state);
|
|
this.enterRule(localContext, 140, QuixosCapabilityParser.RULE_statePrimitive);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1224;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(_la === 1 || ((((_la - 102)) & ~0x1F) === 0 && ((1 << (_la - 102)) & 195) !== 0))) {
|
|
this.errorHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
this.errorHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public edgePrimitive(): EdgePrimitiveContext {
|
|
let localContext = new EdgePrimitiveContext(this.context, this.state);
|
|
this.enterRule(localContext, 142, QuixosCapabilityParser.RULE_edgePrimitive);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1226;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(((((_la - 104)) & ~0x1F) === 0 && ((1 << (_la - 104)) & 55) !== 0))) {
|
|
this.errorHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
this.errorHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public dependencyBindingBlock(): DependencyBindingBlockContext {
|
|
let localContext = new DependencyBindingBlockContext(this.context, this.state);
|
|
this.enterRule(localContext, 144, QuixosCapabilityParser.RULE_dependencyBindingBlock);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1228;
|
|
this.match(QuixosCapabilityParser.WITH);
|
|
this.state = 1229;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 1233;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294964466) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 66575) !== 0) || ((((_la - 78)) & ~0x1F) === 0 && ((1 << (_la - 78)) & 146801025) !== 0) || _la === 112 || _la === 121 || _la === 155) {
|
|
{
|
|
{
|
|
this.state = 1230;
|
|
this.dependencyBinding();
|
|
}
|
|
}
|
|
this.state = 1235;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 1236;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public dependencyBinding(): DependencyBindingContext {
|
|
let localContext = new DependencyBindingContext(this.context, this.state);
|
|
this.enterRule(localContext, 146, QuixosCapabilityParser.RULE_dependencyBinding);
|
|
let _la: number;
|
|
try {
|
|
this.state = 1336;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 118, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1238;
|
|
this.identifier();
|
|
this.state = 1239;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1240;
|
|
this.match(QuixosCapabilityParser.WORKSPACE);
|
|
this.state = 1241;
|
|
this.match(QuixosCapabilityParser.REFLECTION);
|
|
this.state = 1242;
|
|
this.match(QuixosCapabilityParser.LBRACK);
|
|
this.state = 1243;
|
|
this.identifierList();
|
|
this.state = 1244;
|
|
this.match(QuixosCapabilityParser.RBRACK);
|
|
this.state = 1245;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 1247;
|
|
this.identifier();
|
|
this.state = 1248;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1249;
|
|
this.match(QuixosCapabilityParser.STATE);
|
|
this.state = 1250;
|
|
this.identifier();
|
|
this.state = 1257;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 71) {
|
|
{
|
|
this.state = 1251;
|
|
this.match(QuixosCapabilityParser.VIA);
|
|
this.state = 1252;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 1253;
|
|
this.identifier();
|
|
this.state = 1254;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1255;
|
|
this.identifier();
|
|
}
|
|
}
|
|
|
|
this.state = 1259;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 1261;
|
|
this.identifier();
|
|
this.state = 1262;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1263;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 1264;
|
|
this.identifier();
|
|
this.state = 1265;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1266;
|
|
this.identifier();
|
|
this.state = 1273;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 71) {
|
|
{
|
|
this.state = 1267;
|
|
this.match(QuixosCapabilityParser.VIA);
|
|
this.state = 1268;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 1269;
|
|
this.identifier();
|
|
this.state = 1270;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1271;
|
|
this.identifier();
|
|
}
|
|
}
|
|
|
|
this.state = 1275;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 1277;
|
|
this.identifier();
|
|
this.state = 1278;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1279;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 1280;
|
|
this.identifier();
|
|
this.state = 1282;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 1281;
|
|
this.typeArguments();
|
|
}
|
|
}
|
|
|
|
this.state = 1292;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.VIA:
|
|
{
|
|
{
|
|
this.state = 1284;
|
|
this.match(QuixosCapabilityParser.VIA);
|
|
this.state = 1285;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 1286;
|
|
this.identifier();
|
|
this.state = 1287;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1288;
|
|
this.identifier();
|
|
}
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.FROM:
|
|
{
|
|
{
|
|
this.state = 1290;
|
|
this.match(QuixosCapabilityParser.FROM);
|
|
this.state = 1291;
|
|
this.match(QuixosCapabilityParser.INPUT);
|
|
}
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.SEMI:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
this.state = 1294;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 5:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 1296;
|
|
this.identifier();
|
|
this.state = 1297;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1298;
|
|
this.match(QuixosCapabilityParser.CREATION);
|
|
this.state = 1299;
|
|
this.identifier();
|
|
this.state = 1300;
|
|
this.match(QuixosCapabilityParser.WITH);
|
|
this.state = 1301;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 1305;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294964466) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 66575) !== 0) || ((((_la - 78)) & ~0x1F) === 0 && ((1 << (_la - 78)) & 146801025) !== 0) || _la === 112 || _la === 121 || _la === 155) {
|
|
{
|
|
{
|
|
this.state = 1302;
|
|
this.creationOwnerMapping();
|
|
}
|
|
}
|
|
this.state = 1307;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 1308;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
this.state = 1309;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 6:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 1311;
|
|
this.identifier();
|
|
this.state = 1312;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1313;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTOR);
|
|
this.state = 1314;
|
|
this.identifier();
|
|
this.state = 1315;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 7:
|
|
this.enterOuterAlt(localContext, 7);
|
|
{
|
|
this.state = 1317;
|
|
this.identifier();
|
|
this.state = 1318;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1320;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 11) {
|
|
{
|
|
this.state = 1319;
|
|
this.match(QuixosCapabilityParser.WORKSPACE);
|
|
}
|
|
}
|
|
|
|
this.state = 1322;
|
|
this.match(QuixosCapabilityParser.QUERY);
|
|
this.state = 1323;
|
|
this.identifier();
|
|
this.state = 1324;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1325;
|
|
this.identifier();
|
|
this.state = 1332;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 71) {
|
|
{
|
|
this.state = 1326;
|
|
this.match(QuixosCapabilityParser.VIA);
|
|
this.state = 1327;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 1328;
|
|
this.identifier();
|
|
this.state = 1329;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1330;
|
|
this.identifier();
|
|
}
|
|
}
|
|
|
|
this.state = 1334;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public constructorBindingDecl(): ConstructorBindingDeclContext {
|
|
let localContext = new ConstructorBindingDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 148, QuixosCapabilityParser.RULE_constructorBindingDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1338;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTOR);
|
|
this.state = 1339;
|
|
this.identifier();
|
|
this.state = 1340;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 1341;
|
|
this.identifier();
|
|
this.state = 1342;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 1343;
|
|
this.identifier();
|
|
this.state = 1345;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 68) {
|
|
{
|
|
this.state = 1344;
|
|
this.dependencyBindingBlock();
|
|
}
|
|
}
|
|
|
|
this.state = 1347;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public valueType(): ValueTypeContext {
|
|
let localContext = new ValueTypeContext(this.context, this.state);
|
|
this.enterRule(localContext, 150, QuixosCapabilityParser.RULE_valueType);
|
|
let _la: number;
|
|
try {
|
|
this.state = 1406;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 124, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1349;
|
|
this.scalarType();
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 1350;
|
|
this.match(QuixosCapabilityParser.UNIT);
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 1351;
|
|
this.match(QuixosCapabilityParser.WATCH_HANDLE);
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 1352;
|
|
this.match(QuixosCapabilityParser.MESSAGE);
|
|
this.state = 1353;
|
|
this.stringLiteral();
|
|
}
|
|
break;
|
|
case 5:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 1354;
|
|
this.match(QuixosCapabilityParser.ATOM_REF);
|
|
this.state = 1355;
|
|
this.match(QuixosCapabilityParser.LT);
|
|
this.state = 1356;
|
|
this.identifier();
|
|
this.state = 1357;
|
|
this.match(QuixosCapabilityParser.GT);
|
|
}
|
|
break;
|
|
case 6:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 1359;
|
|
this.match(QuixosCapabilityParser.INTERFACE_REF);
|
|
this.state = 1360;
|
|
this.match(QuixosCapabilityParser.LT);
|
|
this.state = 1361;
|
|
this.identifier();
|
|
this.state = 1363;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 1362;
|
|
this.typeArguments();
|
|
}
|
|
}
|
|
|
|
this.state = 1365;
|
|
this.match(QuixosCapabilityParser.GT);
|
|
}
|
|
break;
|
|
case 7:
|
|
this.enterOuterAlt(localContext, 7);
|
|
{
|
|
this.state = 1367;
|
|
this.match(QuixosCapabilityParser.REF);
|
|
this.state = 1368;
|
|
this.match(QuixosCapabilityParser.LT);
|
|
this.state = 1369;
|
|
this.identifier();
|
|
this.state = 1370;
|
|
this.match(QuixosCapabilityParser.GT);
|
|
}
|
|
break;
|
|
case 8:
|
|
this.enterOuterAlt(localContext, 8);
|
|
{
|
|
this.state = 1372;
|
|
this.match(QuixosCapabilityParser.OPTIONAL);
|
|
this.state = 1373;
|
|
this.match(QuixosCapabilityParser.LT);
|
|
this.state = 1374;
|
|
this.valueType();
|
|
this.state = 1375;
|
|
this.match(QuixosCapabilityParser.GT);
|
|
}
|
|
break;
|
|
case 9:
|
|
this.enterOuterAlt(localContext, 9);
|
|
{
|
|
this.state = 1377;
|
|
this.match(QuixosCapabilityParser.LIST);
|
|
this.state = 1378;
|
|
this.match(QuixosCapabilityParser.LT);
|
|
this.state = 1379;
|
|
this.valueType();
|
|
this.state = 1380;
|
|
this.match(QuixosCapabilityParser.GT);
|
|
}
|
|
break;
|
|
case 10:
|
|
this.enterOuterAlt(localContext, 10);
|
|
{
|
|
this.state = 1382;
|
|
this.match(QuixosCapabilityParser.RECORD);
|
|
this.state = 1383;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 1387;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294964466) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 66575) !== 0) || ((((_la - 78)) & ~0x1F) === 0 && ((1 << (_la - 78)) & 146801025) !== 0) || _la === 112 || _la === 121 || _la === 155) {
|
|
{
|
|
{
|
|
this.state = 1384;
|
|
this.recordField();
|
|
}
|
|
}
|
|
this.state = 1389;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 1390;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
break;
|
|
case 11:
|
|
this.enterOuterAlt(localContext, 11);
|
|
{
|
|
this.state = 1391;
|
|
this.match(QuixosCapabilityParser.VARIANT);
|
|
this.state = 1392;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 1393;
|
|
this.stringLiteral();
|
|
this.state = 1394;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 1396;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
this.state = 1395;
|
|
this.variantCase();
|
|
}
|
|
}
|
|
this.state = 1398;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
} while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294964466) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 66575) !== 0) || ((((_la - 78)) & ~0x1F) === 0 && ((1 << (_la - 78)) & 146801025) !== 0) || _la === 112 || _la === 121 || _la === 155);
|
|
this.state = 1400;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
break;
|
|
case 12:
|
|
this.enterOuterAlt(localContext, 12);
|
|
{
|
|
this.state = 1402;
|
|
this.identifier();
|
|
this.state = 1404;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 149) {
|
|
{
|
|
this.state = 1403;
|
|
this.typeArguments();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public recordField(): RecordFieldContext {
|
|
let localContext = new RecordFieldContext(this.context, this.state);
|
|
this.enterRule(localContext, 152, QuixosCapabilityParser.RULE_recordField);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1408;
|
|
this.identifier();
|
|
this.state = 1409;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 1410;
|
|
this.valueType();
|
|
this.state = 1411;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public variantCase(): VariantCaseContext {
|
|
let localContext = new VariantCaseContext(this.context, this.state);
|
|
this.enterRule(localContext, 154, QuixosCapabilityParser.RULE_variantCase);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1413;
|
|
this.identifier();
|
|
this.state = 1414;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 1415;
|
|
this.stringLiteral();
|
|
this.state = 1416;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 1417;
|
|
this.valueType();
|
|
this.state = 1418;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public scalarType(): ScalarTypeContext {
|
|
let localContext = new ScalarTypeContext(this.context, this.state);
|
|
this.enterRule(localContext, 156, QuixosCapabilityParser.RULE_scalarType);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1420;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(((((_la - 127)) & ~0x1F) === 0 && ((1 << (_la - 127)) & 255) !== 0))) {
|
|
this.errorHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
this.errorHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public cardinality(): CardinalityContext {
|
|
let localContext = new CardinalityContext(this.context, this.state);
|
|
this.enterRule(localContext, 158, QuixosCapabilityParser.RULE_cardinality);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1422;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(((((_la - 114)) & ~0x1F) === 0 && ((1 << (_la - 114)) & 15) !== 0))) {
|
|
this.errorHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
this.errorHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public jsonLiteral(): JsonLiteralContext {
|
|
let localContext = new JsonLiteralContext(this.context, this.state);
|
|
this.enterRule(localContext, 160, QuixosCapabilityParser.RULE_jsonLiteral);
|
|
try {
|
|
this.state = 1432;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.STRING_LITERAL:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1424;
|
|
this.stringLiteral();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.INTEGER:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 1425;
|
|
this.match(QuixosCapabilityParser.INTEGER);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.JSON_NUMBER:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 1426;
|
|
this.match(QuixosCapabilityParser.JSON_NUMBER);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.TRUE:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 1427;
|
|
this.match(QuixosCapabilityParser.TRUE);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.FALSE:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 1428;
|
|
this.match(QuixosCapabilityParser.FALSE);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.NULL:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 1429;
|
|
this.match(QuixosCapabilityParser.NULL);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.LBRACE:
|
|
this.enterOuterAlt(localContext, 7);
|
|
{
|
|
this.state = 1430;
|
|
this.jsonObject();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.LBRACK:
|
|
this.enterOuterAlt(localContext, 8);
|
|
{
|
|
this.state = 1431;
|
|
this.jsonArray();
|
|
}
|
|
break;
|
|
default:
|
|
throw new antlr.NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public jsonObject(): JsonObjectContext {
|
|
let localContext = new JsonObjectContext(this.context, this.state);
|
|
this.enterRule(localContext, 162, QuixosCapabilityParser.RULE_jsonObject);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1434;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 1443;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 156) {
|
|
{
|
|
this.state = 1435;
|
|
this.jsonMember();
|
|
this.state = 1440;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 141) {
|
|
{
|
|
{
|
|
this.state = 1436;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 1437;
|
|
this.jsonMember();
|
|
}
|
|
}
|
|
this.state = 1442;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.state = 1445;
|
|
this.match(QuixosCapabilityParser.RBRACE);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public jsonMember(): JsonMemberContext {
|
|
let localContext = new JsonMemberContext(this.context, this.state);
|
|
this.enterRule(localContext, 164, QuixosCapabilityParser.RULE_jsonMember);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1447;
|
|
this.stringLiteral();
|
|
this.state = 1448;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 1449;
|
|
this.jsonLiteral();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public jsonArray(): JsonArrayContext {
|
|
let localContext = new JsonArrayContext(this.context, this.state);
|
|
this.enterRule(localContext, 166, QuixosCapabilityParser.RULE_jsonArray);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1451;
|
|
this.match(QuixosCapabilityParser.LBRACK);
|
|
this.state = 1460;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (((((_la - 135)) & ~0x1F) === 0 && ((1 << (_la - 135)) & 2884871) !== 0)) {
|
|
{
|
|
this.state = 1452;
|
|
this.jsonLiteral();
|
|
this.state = 1457;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 141) {
|
|
{
|
|
{
|
|
this.state = 1453;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 1454;
|
|
this.jsonLiteral();
|
|
}
|
|
}
|
|
this.state = 1459;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.state = 1462;
|
|
this.match(QuixosCapabilityParser.RBRACK);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
let localContext = new IdentifierContext(this.context, this.state);
|
|
this.enterRule(localContext, 168, QuixosCapabilityParser.RULE_identifier);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1464;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294964466) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 66575) !== 0) || ((((_la - 78)) & ~0x1F) === 0 && ((1 << (_la - 78)) & 146801025) !== 0) || _la === 112 || _la === 121 || _la === 155)) {
|
|
this.errorHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
this.errorHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
let localContext = new StringLiteralContext(this.context, this.state);
|
|
this.enterRule(localContext, 170, QuixosCapabilityParser.RULE_stringLiteral);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 1466;
|
|
this.match(QuixosCapabilityParser.STRING_LITERAL);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof antlr.RecognitionException) {
|
|
this.errorHandler.reportError(this, re);
|
|
this.errorHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return localContext;
|
|
}
|
|
|
|
public static readonly _serializedATN: number[] = [
|
|
4,1,159,1469,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
|
|
7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
|
|
13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
|
|
20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
|
|
26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
|
|
33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
|
|
39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
|
|
46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
|
|
52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
|
|
59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
|
|
65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
|
|
72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
|
|
78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
|
|
85,7,85,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,3,0,185,
|
|
8,0,1,1,1,1,1,1,5,1,190,8,1,10,1,12,1,193,9,1,1,1,1,1,1,2,1,2,1,
|
|
2,1,2,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,5,3,211,8,3,10,3,12,
|
|
3,214,9,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,226,8,4,1,
|
|
5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,238,8,5,1,6,1,6,1,6,1,
|
|
6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,
|
|
8,1,9,1,9,1,9,1,9,1,9,3,9,265,8,9,1,10,1,10,1,10,1,10,1,10,1,10,
|
|
3,10,273,8,10,1,10,1,10,1,11,5,11,278,8,11,10,11,12,11,281,9,11,
|
|
1,11,1,11,1,11,3,11,286,8,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,
|
|
1,11,5,11,296,8,11,10,11,12,11,299,9,11,3,11,301,8,11,1,11,1,11,
|
|
5,11,305,8,11,10,11,12,11,308,9,11,1,11,1,11,1,12,1,12,1,12,1,12,
|
|
5,12,316,8,12,10,12,12,12,319,9,12,1,12,1,12,1,13,1,13,1,13,1,13,
|
|
3,13,327,8,13,1,13,1,13,1,13,1,13,1,13,1,13,5,13,335,8,13,10,13,
|
|
12,13,338,9,13,3,13,340,8,13,3,13,342,8,13,1,14,1,14,3,14,346,8,
|
|
14,1,15,1,15,1,15,1,15,5,15,352,8,15,10,15,12,15,355,9,15,1,15,1,
|
|
15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,366,8,16,1,17,1,17,1,
|
|
17,3,17,371,8,17,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,18,3,18,381,
|
|
8,18,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,391,8,19,1,19,
|
|
1,19,1,20,3,20,396,8,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,
|
|
1,20,1,20,1,20,1,20,1,20,3,20,411,8,20,1,20,1,20,1,20,1,21,3,21,
|
|
417,8,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,5,21,427,8,21,10,
|
|
21,12,21,430,9,21,1,21,1,21,1,22,1,22,1,22,1,22,3,22,438,8,22,1,
|
|
22,1,22,1,22,1,22,1,22,1,22,3,22,446,8,22,1,22,1,22,1,22,1,22,1,
|
|
22,1,22,3,22,454,8,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,
|
|
22,1,22,1,22,3,22,467,8,22,1,23,3,23,470,8,23,1,23,1,23,1,23,1,23,
|
|
1,23,1,23,1,23,1,23,3,23,480,8,23,1,23,1,23,3,23,484,8,23,1,23,1,
|
|
23,5,23,488,8,23,10,23,12,23,491,9,23,1,23,1,23,1,24,1,24,3,24,497,
|
|
8,24,1,25,1,25,1,25,1,25,3,25,503,8,25,1,25,1,25,1,25,1,25,1,25,
|
|
1,25,3,25,511,8,25,1,25,1,25,1,25,1,25,1,25,1,25,3,25,519,8,25,1,
|
|
25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,3,25,532,8,
|
|
25,1,26,1,26,1,26,1,26,1,26,3,26,539,8,26,1,26,1,26,3,26,543,8,26,
|
|
1,27,5,27,546,8,27,10,27,12,27,549,9,27,1,27,1,27,1,27,1,27,1,27,
|
|
1,27,1,27,1,27,3,27,559,8,27,1,27,1,27,5,27,563,8,27,10,27,12,27,
|
|
566,9,27,1,27,1,27,1,28,1,28,1,28,1,28,1,28,1,28,3,28,576,8,28,1,
|
|
29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,30,1,30,1,30,1,
|
|
30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,31,1,31,3,31,602,8,
|
|
31,1,31,1,31,3,31,606,8,31,1,31,1,31,1,31,1,31,3,31,612,8,31,1,31,
|
|
1,31,1,31,1,31,1,31,1,31,1,31,5,31,621,8,31,10,31,12,31,624,9,31,
|
|
1,31,1,31,1,31,1,31,1,31,1,31,3,31,632,8,31,1,31,1,31,5,31,636,8,
|
|
31,10,31,12,31,639,9,31,1,31,1,31,3,31,643,8,31,3,31,645,8,31,1,
|
|
32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,33,1,33,1,33,1,33,1,
|
|
33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,
|
|
33,5,33,674,8,33,10,33,12,33,677,9,33,1,33,3,33,680,8,33,1,33,1,
|
|
33,1,33,1,33,3,33,686,8,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,
|
|
33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,
|
|
33,1,33,1,33,1,33,1,33,3,33,713,8,33,1,34,1,34,1,34,1,34,1,34,1,
|
|
35,1,35,1,35,3,35,723,8,35,1,35,1,35,1,35,1,35,1,35,1,35,1,35,1,
|
|
35,1,35,3,35,734,8,35,1,35,3,35,737,8,35,1,35,1,35,1,35,3,35,742,
|
|
8,35,1,35,3,35,745,8,35,1,35,3,35,748,8,35,1,35,1,35,1,36,1,36,1,
|
|
36,3,36,755,8,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,3,36,764,8,36,
|
|
1,36,3,36,767,8,36,1,36,3,36,770,8,36,1,36,3,36,773,8,36,1,36,1,
|
|
36,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1,38,1,38,1,38,1,39,1,39,1,
|
|
39,1,39,1,39,1,39,1,39,1,39,1,39,3,39,796,8,39,3,39,798,8,39,1,40,
|
|
1,40,1,40,1,40,1,40,5,40,805,8,40,10,40,12,40,808,9,40,1,40,1,40,
|
|
1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41,3,41,821,8,41,1,41,
|
|
1,41,1,42,1,42,1,42,1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,
|
|
1,44,1,44,1,44,5,44,840,8,44,10,44,12,44,843,9,44,3,44,845,8,44,
|
|
1,44,3,44,848,8,44,1,45,1,45,1,45,5,45,853,8,45,10,45,12,45,856,
|
|
9,45,1,46,1,46,1,46,5,46,861,8,46,10,46,12,46,864,9,46,1,46,1,46,
|
|
1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,
|
|
1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,
|
|
1,47,3,47,895,8,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,
|
|
1,47,3,47,907,8,47,1,47,3,47,910,8,47,1,47,1,47,3,47,914,8,47,1,
|
|
47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,
|
|
47,1,47,1,47,1,47,1,47,1,47,1,47,3,47,936,8,47,1,47,1,47,1,47,1,
|
|
47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,3,47,950,8,47,1,48,1,
|
|
48,1,48,1,48,5,48,956,8,48,10,48,12,48,959,9,48,1,48,1,48,1,49,1,
|
|
49,1,50,1,50,1,50,1,51,1,51,3,51,970,8,51,1,52,1,52,1,52,1,52,1,
|
|
52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,984,8,52,1,52,1,52,1,
|
|
53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,
|
|
53,1001,8,53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,55,1,
|
|
55,1,55,1,55,1,55,1,55,1,55,3,55,1019,8,55,1,55,1,55,3,55,1023,8,
|
|
55,1,55,3,55,1026,8,55,1,55,1,55,3,55,1030,8,55,1,55,3,55,1033,8,
|
|
55,1,55,1,55,1,56,1,56,3,56,1039,8,56,1,56,1,56,3,56,1043,8,56,1,
|
|
56,1,56,1,56,3,56,1048,8,56,1,56,1,56,3,56,1052,8,56,1,56,1,56,3,
|
|
56,1056,8,56,1,56,1,56,5,56,1060,8,56,10,56,12,56,1063,9,56,1,56,
|
|
1,56,1,57,1,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58,1076,8,58,
|
|
1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,60,1,60,1,60,5,60,1089,
|
|
8,60,10,60,12,60,1092,9,60,1,60,1,60,1,60,1,61,1,61,1,61,1,61,1,
|
|
61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,3,61,1111,8,61,1,
|
|
62,1,62,1,62,1,62,1,62,5,62,1118,8,62,10,62,12,62,1121,9,62,1,62,
|
|
1,62,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,64,1,64,1,64,1,64,1,64,
|
|
1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,65,1,65,1,65,1,65,
|
|
1,65,1,65,3,65,1152,8,65,1,65,1,65,1,66,1,66,1,66,1,66,1,67,1,67,
|
|
1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,3,67,1172,8,67,
|
|
1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,
|
|
1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,
|
|
1,68,1,68,3,68,1202,8,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,
|
|
3,68,1212,8,68,1,68,3,68,1215,8,68,1,68,3,68,1218,8,68,3,68,1220,
|
|
8,68,1,69,1,69,1,69,1,70,1,70,1,71,1,71,1,72,1,72,1,72,5,72,1232,
|
|
8,72,10,72,12,72,1235,9,72,1,72,1,72,1,73,1,73,1,73,1,73,1,73,1,
|
|
73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,
|
|
73,3,73,1258,8,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,
|
|
73,1,73,1,73,1,73,1,73,3,73,1274,8,73,1,73,1,73,1,73,1,73,1,73,1,
|
|
73,1,73,3,73,1283,8,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,
|
|
73,1293,8,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,5,73,1304,
|
|
8,73,10,73,12,73,1307,9,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,
|
|
73,1,73,1,73,1,73,1,73,3,73,1321,8,73,1,73,1,73,1,73,1,73,1,73,1,
|
|
73,1,73,1,73,1,73,1,73,3,73,1333,8,73,1,73,1,73,3,73,1337,8,73,1,
|
|
74,1,74,1,74,1,74,1,74,1,74,1,74,3,74,1346,8,74,1,74,1,74,1,75,1,
|
|
75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,3,
|
|
75,1364,8,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,
|
|
75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,5,75,1386,8,75,10,
|
|
75,12,75,1389,9,75,1,75,1,75,1,75,1,75,1,75,1,75,4,75,1397,8,75,
|
|
11,75,12,75,1398,1,75,1,75,1,75,1,75,3,75,1405,8,75,3,75,1407,8,
|
|
75,1,76,1,76,1,76,1,76,1,76,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,
|
|
78,1,78,1,79,1,79,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,3,80,1433,
|
|
8,80,1,81,1,81,1,81,1,81,5,81,1439,8,81,10,81,12,81,1442,9,81,3,
|
|
81,1444,8,81,1,81,1,81,1,82,1,82,1,82,1,82,1,83,1,83,1,83,1,83,5,
|
|
83,1456,8,83,10,83,12,83,1459,9,83,3,83,1461,8,83,1,83,1,83,1,84,
|
|
1,84,1,85,1,85,1,85,0,0,86,0,2,4,6,8,10,12,14,16,18,20,22,24,26,
|
|
28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,
|
|
72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,
|
|
112,114,116,118,120,122,124,126,128,130,132,134,136,138,140,142,
|
|
144,146,148,150,152,154,156,158,160,162,164,166,168,170,0,10,1,0,
|
|
50,51,2,0,17,17,35,35,1,0,13,14,1,0,107,111,3,0,1,1,102,106,108,
|
|
109,3,0,1,1,102,103,108,109,2,0,104,106,108,109,1,0,127,134,1,0,
|
|
114,117,13,0,1,1,4,7,10,10,12,35,42,42,48,48,78,78,85,86,100,101,
|
|
105,105,112,112,121,121,155,155,1593,0,184,1,0,0,0,2,186,1,0,0,0,
|
|
4,196,1,0,0,0,6,200,1,0,0,0,8,225,1,0,0,0,10,237,1,0,0,0,12,239,
|
|
1,0,0,0,14,246,1,0,0,0,16,253,1,0,0,0,18,264,1,0,0,0,20,266,1,0,
|
|
0,0,22,279,1,0,0,0,24,311,1,0,0,0,26,341,1,0,0,0,28,343,1,0,0,0,
|
|
30,347,1,0,0,0,32,365,1,0,0,0,34,367,1,0,0,0,36,380,1,0,0,0,38,382,
|
|
1,0,0,0,40,395,1,0,0,0,42,416,1,0,0,0,44,466,1,0,0,0,46,469,1,0,
|
|
0,0,48,494,1,0,0,0,50,531,1,0,0,0,52,542,1,0,0,0,54,547,1,0,0,0,
|
|
56,575,1,0,0,0,58,577,1,0,0,0,60,587,1,0,0,0,62,599,1,0,0,0,64,646,
|
|
1,0,0,0,66,712,1,0,0,0,68,714,1,0,0,0,70,719,1,0,0,0,72,751,1,0,
|
|
0,0,74,776,1,0,0,0,76,780,1,0,0,0,78,797,1,0,0,0,80,799,1,0,0,0,
|
|
82,811,1,0,0,0,84,824,1,0,0,0,86,827,1,0,0,0,88,847,1,0,0,0,90,849,
|
|
1,0,0,0,92,857,1,0,0,0,94,949,1,0,0,0,96,951,1,0,0,0,98,962,1,0,
|
|
0,0,100,964,1,0,0,0,102,969,1,0,0,0,104,971,1,0,0,0,106,1000,1,0,
|
|
0,0,108,1002,1,0,0,0,110,1011,1,0,0,0,112,1036,1,0,0,0,114,1066,
|
|
1,0,0,0,116,1075,1,0,0,0,118,1077,1,0,0,0,120,1085,1,0,0,0,122,1110,
|
|
1,0,0,0,124,1112,1,0,0,0,126,1124,1,0,0,0,128,1131,1,0,0,0,130,1145,
|
|
1,0,0,0,132,1155,1,0,0,0,134,1171,1,0,0,0,136,1219,1,0,0,0,138,1221,
|
|
1,0,0,0,140,1224,1,0,0,0,142,1226,1,0,0,0,144,1228,1,0,0,0,146,1336,
|
|
1,0,0,0,148,1338,1,0,0,0,150,1406,1,0,0,0,152,1408,1,0,0,0,154,1413,
|
|
1,0,0,0,156,1420,1,0,0,0,158,1422,1,0,0,0,160,1432,1,0,0,0,162,1434,
|
|
1,0,0,0,164,1447,1,0,0,0,166,1451,1,0,0,0,168,1464,1,0,0,0,170,1466,
|
|
1,0,0,0,172,173,3,6,3,0,173,174,5,0,0,1,174,185,1,0,0,0,175,176,
|
|
3,22,11,0,176,177,5,0,0,1,177,185,1,0,0,0,178,179,3,54,27,0,179,
|
|
180,5,0,0,1,180,185,1,0,0,0,181,182,3,2,1,0,182,183,5,0,0,1,183,
|
|
185,1,0,0,0,184,172,1,0,0,0,184,175,1,0,0,0,184,178,1,0,0,0,184,
|
|
181,1,0,0,0,185,1,1,0,0,0,186,187,5,42,0,0,187,191,5,143,0,0,188,
|
|
190,3,8,4,0,189,188,1,0,0,0,190,193,1,0,0,0,191,189,1,0,0,0,191,
|
|
192,1,0,0,0,192,194,1,0,0,0,193,191,1,0,0,0,194,195,5,144,0,0,195,
|
|
3,1,0,0,0,196,197,5,43,0,0,197,198,3,170,85,0,198,199,5,140,0,0,
|
|
199,5,1,0,0,0,200,201,5,11,0,0,201,202,3,168,84,0,202,203,5,90,0,
|
|
0,203,204,3,170,85,0,204,205,5,81,0,0,205,206,3,170,85,0,206,207,
|
|
5,80,0,0,207,208,3,170,85,0,208,212,5,143,0,0,209,211,3,8,4,0,210,
|
|
209,1,0,0,0,211,214,1,0,0,0,212,210,1,0,0,0,212,213,1,0,0,0,213,
|
|
215,1,0,0,0,214,212,1,0,0,0,215,216,5,144,0,0,216,7,1,0,0,0,217,
|
|
226,3,4,2,0,218,226,3,20,10,0,219,226,3,10,5,0,220,226,3,100,50,
|
|
0,221,226,3,112,56,0,222,226,3,148,74,0,223,226,3,60,30,0,224,226,
|
|
3,34,17,0,225,217,1,0,0,0,225,218,1,0,0,0,225,219,1,0,0,0,225,220,
|
|
1,0,0,0,225,221,1,0,0,0,225,222,1,0,0,0,225,223,1,0,0,0,225,224,
|
|
1,0,0,0,226,9,1,0,0,0,227,228,5,43,0,0,228,229,5,47,0,0,229,230,
|
|
3,168,84,0,230,231,5,140,0,0,231,238,1,0,0,0,232,233,5,43,0,0,233,
|
|
234,5,49,0,0,234,235,3,168,84,0,235,236,5,140,0,0,236,238,1,0,0,
|
|
0,237,227,1,0,0,0,237,232,1,0,0,0,238,11,1,0,0,0,239,240,5,44,0,
|
|
0,240,241,5,46,0,0,241,242,3,168,84,0,242,243,5,90,0,0,243,244,3,
|
|
170,85,0,244,245,5,140,0,0,245,13,1,0,0,0,246,247,5,44,0,0,247,248,
|
|
5,47,0,0,248,249,3,168,84,0,249,250,5,81,0,0,250,251,3,170,85,0,
|
|
251,252,5,140,0,0,252,15,1,0,0,0,253,254,5,45,0,0,254,255,3,168,
|
|
84,0,255,256,5,90,0,0,256,257,3,170,85,0,257,258,5,140,0,0,258,17,
|
|
1,0,0,0,259,265,3,10,5,0,260,265,3,12,6,0,261,265,3,14,7,0,262,265,
|
|
3,16,8,0,263,265,3,34,17,0,264,259,1,0,0,0,264,260,1,0,0,0,264,261,
|
|
1,0,0,0,264,262,1,0,0,0,264,263,1,0,0,0,265,19,1,0,0,0,266,267,5,
|
|
46,0,0,267,268,3,168,84,0,268,269,5,90,0,0,269,272,3,170,85,0,270,
|
|
271,5,91,0,0,271,273,3,170,85,0,272,270,1,0,0,0,272,273,1,0,0,0,
|
|
273,274,1,0,0,0,274,275,5,140,0,0,275,21,1,0,0,0,276,278,3,18,9,
|
|
0,277,276,1,0,0,0,278,281,1,0,0,0,279,277,1,0,0,0,279,280,1,0,0,
|
|
0,280,282,1,0,0,0,281,279,1,0,0,0,282,283,5,47,0,0,283,285,3,168,
|
|
84,0,284,286,3,24,12,0,285,284,1,0,0,0,285,286,1,0,0,0,286,287,1,
|
|
0,0,0,287,288,5,90,0,0,288,289,3,170,85,0,289,290,5,81,0,0,290,300,
|
|
3,170,85,0,291,292,5,95,0,0,292,297,3,28,14,0,293,294,5,141,0,0,
|
|
294,296,3,28,14,0,295,293,1,0,0,0,296,299,1,0,0,0,297,295,1,0,0,
|
|
0,297,298,1,0,0,0,298,301,1,0,0,0,299,297,1,0,0,0,300,291,1,0,0,
|
|
0,300,301,1,0,0,0,301,302,1,0,0,0,302,306,5,143,0,0,303,305,3,36,
|
|
18,0,304,303,1,0,0,0,305,308,1,0,0,0,306,304,1,0,0,0,306,307,1,0,
|
|
0,0,307,309,1,0,0,0,308,306,1,0,0,0,309,310,5,144,0,0,310,23,1,0,
|
|
0,0,311,312,5,149,0,0,312,317,3,26,13,0,313,314,5,141,0,0,314,316,
|
|
3,26,13,0,315,313,1,0,0,0,316,319,1,0,0,0,317,315,1,0,0,0,317,318,
|
|
1,0,0,0,318,320,1,0,0,0,319,317,1,0,0,0,320,321,5,150,0,0,321,25,
|
|
1,0,0,0,322,323,5,50,0,0,323,326,3,168,84,0,324,325,5,139,0,0,325,
|
|
327,5,39,0,0,326,324,1,0,0,0,326,327,1,0,0,0,327,342,1,0,0,0,328,
|
|
329,5,38,0,0,329,339,3,168,84,0,330,331,5,40,0,0,331,336,3,28,14,
|
|
0,332,333,5,151,0,0,333,335,3,28,14,0,334,332,1,0,0,0,335,338,1,
|
|
0,0,0,336,334,1,0,0,0,336,337,1,0,0,0,337,340,1,0,0,0,338,336,1,
|
|
0,0,0,339,330,1,0,0,0,339,340,1,0,0,0,340,342,1,0,0,0,341,322,1,
|
|
0,0,0,341,328,1,0,0,0,342,27,1,0,0,0,343,345,3,168,84,0,344,346,
|
|
3,30,15,0,345,344,1,0,0,0,345,346,1,0,0,0,346,29,1,0,0,0,347,348,
|
|
5,149,0,0,348,353,3,32,16,0,349,350,5,141,0,0,350,352,3,32,16,0,
|
|
351,349,1,0,0,0,352,355,1,0,0,0,353,351,1,0,0,0,353,354,1,0,0,0,
|
|
354,356,1,0,0,0,355,353,1,0,0,0,356,357,5,150,0,0,357,31,1,0,0,0,
|
|
358,359,5,46,0,0,359,366,3,168,84,0,360,361,5,47,0,0,361,366,3,28,
|
|
14,0,362,363,5,38,0,0,363,366,3,168,84,0,364,366,3,150,75,0,365,
|
|
358,1,0,0,0,365,360,1,0,0,0,365,362,1,0,0,0,365,364,1,0,0,0,366,
|
|
33,1,0,0,0,367,368,5,37,0,0,368,370,3,168,84,0,369,371,3,24,12,0,
|
|
370,369,1,0,0,0,370,371,1,0,0,0,371,372,1,0,0,0,372,373,5,152,0,
|
|
0,373,374,3,150,75,0,374,375,5,140,0,0,375,35,1,0,0,0,376,381,3,
|
|
42,21,0,377,381,3,46,23,0,378,381,3,40,20,0,379,381,3,38,19,0,380,
|
|
376,1,0,0,0,380,377,1,0,0,0,380,378,1,0,0,0,380,379,1,0,0,0,381,
|
|
37,1,0,0,0,382,383,5,2,0,0,383,384,3,168,84,0,384,385,5,90,0,0,385,
|
|
386,3,170,85,0,386,387,5,3,0,0,387,390,3,170,85,0,388,389,5,5,0,
|
|
0,389,391,3,52,26,0,390,388,1,0,0,0,390,391,1,0,0,0,391,392,1,0,
|
|
0,0,392,393,5,140,0,0,393,39,1,0,0,0,394,396,5,61,0,0,395,394,1,
|
|
0,0,0,395,396,1,0,0,0,396,397,1,0,0,0,397,398,5,53,0,0,398,399,3,
|
|
168,84,0,399,400,5,90,0,0,400,401,3,170,85,0,401,402,5,139,0,0,402,
|
|
403,3,150,75,0,403,404,5,138,0,0,404,405,3,150,75,0,405,406,5,143,
|
|
0,0,406,407,5,107,0,0,407,408,5,90,0,0,408,410,3,170,85,0,409,411,
|
|
3,78,39,0,410,409,1,0,0,0,410,411,1,0,0,0,411,412,1,0,0,0,412,413,
|
|
5,140,0,0,413,414,5,144,0,0,414,41,1,0,0,0,415,417,3,48,24,0,416,
|
|
415,1,0,0,0,416,417,1,0,0,0,417,418,1,0,0,0,418,419,7,0,0,0,419,
|
|
420,3,168,84,0,420,421,5,90,0,0,421,422,3,170,85,0,422,423,5,139,
|
|
0,0,423,424,3,150,75,0,424,428,5,143,0,0,425,427,3,44,22,0,426,425,
|
|
1,0,0,0,427,430,1,0,0,0,428,426,1,0,0,0,428,429,1,0,0,0,429,431,
|
|
1,0,0,0,430,428,1,0,0,0,431,432,5,144,0,0,432,43,1,0,0,0,433,434,
|
|
5,97,0,0,434,435,5,90,0,0,435,437,3,170,85,0,436,438,3,78,39,0,437,
|
|
436,1,0,0,0,437,438,1,0,0,0,438,439,1,0,0,0,439,440,5,140,0,0,440,
|
|
467,1,0,0,0,441,442,5,98,0,0,442,443,5,90,0,0,443,445,3,170,85,0,
|
|
444,446,3,78,39,0,445,444,1,0,0,0,445,446,1,0,0,0,446,447,1,0,0,
|
|
0,447,448,5,140,0,0,448,467,1,0,0,0,449,450,5,1,0,0,450,451,5,90,
|
|
0,0,451,453,3,170,85,0,452,454,3,78,39,0,453,452,1,0,0,0,453,454,
|
|
1,0,0,0,454,455,1,0,0,0,455,456,5,140,0,0,456,467,1,0,0,0,457,458,
|
|
5,99,0,0,458,459,5,100,0,0,459,460,5,90,0,0,460,461,3,170,85,0,461,
|
|
462,5,101,0,0,462,463,5,90,0,0,463,464,3,170,85,0,464,465,5,140,
|
|
0,0,465,467,1,0,0,0,466,433,1,0,0,0,466,441,1,0,0,0,466,449,1,0,
|
|
0,0,466,457,1,0,0,0,467,45,1,0,0,0,468,470,3,48,24,0,469,468,1,0,
|
|
0,0,469,470,1,0,0,0,470,471,1,0,0,0,471,472,5,52,0,0,472,473,3,168,
|
|
84,0,473,474,5,90,0,0,474,475,3,170,85,0,475,476,5,139,0,0,476,477,
|
|
3,158,79,0,477,479,3,52,26,0,478,480,5,118,0,0,479,478,1,0,0,0,479,
|
|
480,1,0,0,0,480,483,1,0,0,0,481,482,5,88,0,0,482,484,3,170,85,0,
|
|
483,481,1,0,0,0,483,484,1,0,0,0,484,485,1,0,0,0,485,489,5,143,0,
|
|
0,486,488,3,50,25,0,487,486,1,0,0,0,488,491,1,0,0,0,489,487,1,0,
|
|
0,0,489,490,1,0,0,0,490,492,1,0,0,0,491,489,1,0,0,0,492,493,5,144,
|
|
0,0,493,47,1,0,0,0,494,496,5,34,0,0,495,497,7,1,0,0,496,495,1,0,
|
|
0,0,496,497,1,0,0,0,497,49,1,0,0,0,498,499,5,104,0,0,499,500,5,90,
|
|
0,0,500,502,3,170,85,0,501,503,3,78,39,0,502,501,1,0,0,0,502,503,
|
|
1,0,0,0,503,504,1,0,0,0,504,505,5,140,0,0,505,532,1,0,0,0,506,507,
|
|
5,105,0,0,507,508,5,90,0,0,508,510,3,170,85,0,509,511,3,78,39,0,
|
|
510,509,1,0,0,0,510,511,1,0,0,0,511,512,1,0,0,0,512,513,5,140,0,
|
|
0,513,532,1,0,0,0,514,515,5,106,0,0,515,516,5,90,0,0,516,518,3,170,
|
|
85,0,517,519,3,78,39,0,518,517,1,0,0,0,518,519,1,0,0,0,519,520,1,
|
|
0,0,0,520,521,5,140,0,0,521,532,1,0,0,0,522,523,5,99,0,0,523,524,
|
|
5,100,0,0,524,525,5,90,0,0,525,526,3,170,85,0,526,527,5,101,0,0,
|
|
527,528,5,90,0,0,528,529,3,170,85,0,529,530,5,140,0,0,530,532,1,
|
|
0,0,0,531,498,1,0,0,0,531,506,1,0,0,0,531,514,1,0,0,0,531,522,1,
|
|
0,0,0,532,51,1,0,0,0,533,534,5,46,0,0,534,543,3,168,84,0,535,536,
|
|
5,47,0,0,536,538,3,168,84,0,537,539,3,30,15,0,538,537,1,0,0,0,538,
|
|
539,1,0,0,0,539,543,1,0,0,0,540,541,5,38,0,0,541,543,3,168,84,0,
|
|
542,533,1,0,0,0,542,535,1,0,0,0,542,540,1,0,0,0,543,53,1,0,0,0,544,
|
|
546,3,18,9,0,545,544,1,0,0,0,546,549,1,0,0,0,547,545,1,0,0,0,547,
|
|
548,1,0,0,0,548,550,1,0,0,0,549,547,1,0,0,0,550,551,5,49,0,0,551,
|
|
552,3,168,84,0,552,553,5,90,0,0,553,554,3,170,85,0,554,555,5,81,
|
|
0,0,555,558,3,170,85,0,556,557,5,82,0,0,557,559,5,153,0,0,558,556,
|
|
1,0,0,0,558,559,1,0,0,0,559,560,1,0,0,0,560,564,5,143,0,0,561,563,
|
|
3,56,28,0,562,561,1,0,0,0,563,566,1,0,0,0,564,562,1,0,0,0,564,565,
|
|
1,0,0,0,565,567,1,0,0,0,566,564,1,0,0,0,567,568,5,144,0,0,568,55,
|
|
1,0,0,0,569,576,3,70,35,0,570,576,3,72,36,0,571,576,3,82,41,0,572,
|
|
576,3,62,31,0,573,576,3,64,32,0,574,576,3,58,29,0,575,569,1,0,0,
|
|
0,575,570,1,0,0,0,575,571,1,0,0,0,575,572,1,0,0,0,575,573,1,0,0,
|
|
0,575,574,1,0,0,0,576,57,1,0,0,0,577,578,5,2,0,0,578,579,3,168,84,
|
|
0,579,580,5,90,0,0,580,581,3,170,85,0,581,582,5,40,0,0,582,583,3,
|
|
28,14,0,583,584,5,142,0,0,584,585,3,168,84,0,585,586,5,140,0,0,586,
|
|
59,1,0,0,0,587,588,5,4,0,0,588,589,3,168,84,0,589,590,5,90,0,0,590,
|
|
591,3,170,85,0,591,592,5,6,0,0,592,593,3,28,14,0,593,594,5,69,0,
|
|
0,594,595,3,168,84,0,595,596,5,142,0,0,596,597,3,168,84,0,597,598,
|
|
5,140,0,0,598,61,1,0,0,0,599,601,5,24,0,0,600,602,5,42,0,0,601,600,
|
|
1,0,0,0,601,602,1,0,0,0,602,603,1,0,0,0,603,605,3,168,84,0,604,606,
|
|
3,24,12,0,605,604,1,0,0,0,605,606,1,0,0,0,606,607,1,0,0,0,607,608,
|
|
5,90,0,0,608,609,3,170,85,0,609,611,5,27,0,0,610,612,5,11,0,0,611,
|
|
610,1,0,0,0,611,612,1,0,0,0,612,613,1,0,0,0,613,614,3,28,14,0,614,
|
|
615,5,28,0,0,615,644,3,170,85,0,616,617,5,53,0,0,617,618,3,170,85,
|
|
0,618,622,5,143,0,0,619,621,3,66,33,0,620,619,1,0,0,0,621,624,1,
|
|
0,0,0,622,620,1,0,0,0,622,623,1,0,0,0,623,625,1,0,0,0,624,622,1,
|
|
0,0,0,625,626,5,144,0,0,626,645,1,0,0,0,627,628,5,42,0,0,628,631,
|
|
3,170,85,0,629,630,5,53,0,0,630,632,3,170,85,0,631,629,1,0,0,0,631,
|
|
632,1,0,0,0,632,642,1,0,0,0,633,637,5,143,0,0,634,636,3,66,33,0,
|
|
635,634,1,0,0,0,636,639,1,0,0,0,637,635,1,0,0,0,637,638,1,0,0,0,
|
|
638,640,1,0,0,0,639,637,1,0,0,0,640,643,5,144,0,0,641,643,5,140,
|
|
0,0,642,633,1,0,0,0,642,641,1,0,0,0,643,645,1,0,0,0,644,616,1,0,
|
|
0,0,644,627,1,0,0,0,645,63,1,0,0,0,646,647,5,24,0,0,647,648,3,168,
|
|
84,0,648,649,5,90,0,0,649,650,3,170,85,0,650,651,5,26,0,0,651,652,
|
|
3,168,84,0,652,653,3,30,15,0,653,654,5,140,0,0,654,65,1,0,0,0,655,
|
|
656,5,18,0,0,656,713,5,140,0,0,657,658,5,19,0,0,658,659,5,20,0,0,
|
|
659,660,3,168,84,0,660,661,5,140,0,0,661,713,1,0,0,0,662,663,5,29,
|
|
0,0,663,664,3,170,85,0,664,665,5,140,0,0,665,713,1,0,0,0,666,667,
|
|
5,29,0,0,667,668,3,168,84,0,668,669,5,142,0,0,669,679,3,168,84,0,
|
|
670,671,5,68,0,0,671,675,5,143,0,0,672,674,3,68,34,0,673,672,1,0,
|
|
0,0,674,677,1,0,0,0,675,673,1,0,0,0,675,676,1,0,0,0,676,678,1,0,
|
|
0,0,677,675,1,0,0,0,678,680,5,144,0,0,679,670,1,0,0,0,679,680,1,
|
|
0,0,0,680,681,1,0,0,0,681,682,5,140,0,0,682,713,1,0,0,0,683,685,
|
|
5,30,0,0,684,686,5,38,0,0,685,684,1,0,0,0,685,686,1,0,0,0,686,687,
|
|
1,0,0,0,687,688,3,168,84,0,688,689,5,59,0,0,689,690,3,28,14,0,690,
|
|
691,5,140,0,0,691,713,1,0,0,0,692,693,5,31,0,0,693,694,3,168,84,
|
|
0,694,695,5,153,0,0,695,696,5,140,0,0,696,713,1,0,0,0,697,698,5,
|
|
32,0,0,698,699,3,28,14,0,699,700,5,142,0,0,700,701,3,168,84,0,701,
|
|
702,3,168,84,0,702,703,3,170,85,0,703,704,5,140,0,0,704,713,1,0,
|
|
0,0,705,706,5,99,0,0,706,713,5,140,0,0,707,708,5,33,0,0,708,709,
|
|
5,153,0,0,709,710,3,170,85,0,710,711,5,140,0,0,711,713,1,0,0,0,712,
|
|
655,1,0,0,0,712,657,1,0,0,0,712,662,1,0,0,0,712,666,1,0,0,0,712,
|
|
683,1,0,0,0,712,692,1,0,0,0,712,697,1,0,0,0,712,705,1,0,0,0,712,
|
|
707,1,0,0,0,713,67,1,0,0,0,714,715,3,168,84,0,715,716,5,62,0,0,716,
|
|
717,3,168,84,0,717,718,5,140,0,0,718,69,1,0,0,0,719,720,5,53,0,0,
|
|
720,722,3,168,84,0,721,723,3,24,12,0,722,721,1,0,0,0,722,723,1,0,
|
|
0,0,723,724,1,0,0,0,724,725,5,90,0,0,725,726,3,170,85,0,726,727,
|
|
5,139,0,0,727,728,3,150,75,0,728,729,5,138,0,0,729,730,3,150,75,
|
|
0,730,731,5,92,0,0,731,733,3,86,43,0,732,734,3,78,39,0,733,732,1,
|
|
0,0,0,733,734,1,0,0,0,734,736,1,0,0,0,735,737,3,84,42,0,736,735,
|
|
1,0,0,0,736,737,1,0,0,0,737,738,1,0,0,0,738,739,5,94,0,0,739,741,
|
|
3,88,44,0,740,742,3,92,46,0,741,740,1,0,0,0,741,742,1,0,0,0,742,
|
|
744,1,0,0,0,743,745,3,76,38,0,744,743,1,0,0,0,744,745,1,0,0,0,745,
|
|
747,1,0,0,0,746,748,3,74,37,0,747,746,1,0,0,0,747,748,1,0,0,0,748,
|
|
749,1,0,0,0,749,750,5,140,0,0,750,71,1,0,0,0,751,752,5,54,0,0,752,
|
|
754,3,168,84,0,753,755,3,24,12,0,754,753,1,0,0,0,754,755,1,0,0,0,
|
|
755,756,1,0,0,0,756,757,5,90,0,0,757,758,3,170,85,0,758,759,5,139,
|
|
0,0,759,760,3,150,75,0,760,761,5,138,0,0,761,763,3,150,75,0,762,
|
|
764,3,78,39,0,763,762,1,0,0,0,763,764,1,0,0,0,764,766,1,0,0,0,765,
|
|
767,3,92,46,0,766,765,1,0,0,0,766,767,1,0,0,0,767,769,1,0,0,0,768,
|
|
770,3,76,38,0,769,768,1,0,0,0,769,770,1,0,0,0,770,772,1,0,0,0,771,
|
|
773,3,74,37,0,772,771,1,0,0,0,772,773,1,0,0,0,773,774,1,0,0,0,774,
|
|
775,5,140,0,0,775,73,1,0,0,0,776,777,5,70,0,0,777,778,5,69,0,0,778,
|
|
779,3,168,84,0,779,75,1,0,0,0,780,781,5,9,0,0,781,782,5,7,0,0,782,
|
|
783,3,168,84,0,783,784,5,69,0,0,784,785,3,170,85,0,785,77,1,0,0,
|
|
0,786,787,5,12,0,0,787,798,5,15,0,0,788,789,5,12,0,0,789,795,7,2,
|
|
0,0,790,791,5,16,0,0,791,792,5,145,0,0,792,793,3,90,45,0,793,794,
|
|
5,146,0,0,794,796,1,0,0,0,795,790,1,0,0,0,795,796,1,0,0,0,796,798,
|
|
1,0,0,0,797,786,1,0,0,0,797,788,1,0,0,0,798,79,1,0,0,0,799,800,5,
|
|
69,0,0,800,801,5,145,0,0,801,806,3,132,66,0,802,803,5,141,0,0,803,
|
|
805,3,132,66,0,804,802,1,0,0,0,805,808,1,0,0,0,806,804,1,0,0,0,806,
|
|
807,1,0,0,0,807,809,1,0,0,0,808,806,1,0,0,0,809,810,5,146,0,0,810,
|
|
81,1,0,0,0,811,812,5,55,0,0,812,813,3,168,84,0,813,814,5,90,0,0,
|
|
814,815,3,170,85,0,815,816,5,56,0,0,816,817,3,168,84,0,817,818,5,
|
|
139,0,0,818,820,3,150,75,0,819,821,3,92,46,0,820,819,1,0,0,0,820,
|
|
821,1,0,0,0,821,822,1,0,0,0,822,823,5,140,0,0,823,83,1,0,0,0,824,
|
|
825,5,93,0,0,825,826,3,150,75,0,826,85,1,0,0,0,827,828,7,3,0,0,828,
|
|
87,1,0,0,0,829,848,5,96,0,0,830,831,5,46,0,0,831,848,3,168,84,0,
|
|
832,833,5,38,0,0,833,848,3,168,84,0,834,835,5,48,0,0,835,844,5,145,
|
|
0,0,836,841,3,28,14,0,837,838,5,141,0,0,838,840,3,28,14,0,839,837,
|
|
1,0,0,0,840,843,1,0,0,0,841,839,1,0,0,0,841,842,1,0,0,0,842,845,
|
|
1,0,0,0,843,841,1,0,0,0,844,836,1,0,0,0,844,845,1,0,0,0,845,846,
|
|
1,0,0,0,846,848,5,146,0,0,847,829,1,0,0,0,847,830,1,0,0,0,847,832,
|
|
1,0,0,0,847,834,1,0,0,0,848,89,1,0,0,0,849,854,3,168,84,0,850,851,
|
|
5,141,0,0,851,853,3,168,84,0,852,850,1,0,0,0,853,856,1,0,0,0,854,
|
|
852,1,0,0,0,854,855,1,0,0,0,855,91,1,0,0,0,856,854,1,0,0,0,857,858,
|
|
5,95,0,0,858,862,5,143,0,0,859,861,3,94,47,0,860,859,1,0,0,0,861,
|
|
864,1,0,0,0,862,860,1,0,0,0,862,863,1,0,0,0,863,865,1,0,0,0,864,
|
|
862,1,0,0,0,865,866,5,144,0,0,866,93,1,0,0,0,867,868,5,25,0,0,868,
|
|
869,3,168,84,0,869,870,5,90,0,0,870,871,3,170,85,0,871,872,5,145,
|
|
0,0,872,873,3,90,45,0,873,874,5,146,0,0,874,875,5,140,0,0,875,950,
|
|
1,0,0,0,876,877,5,65,0,0,877,878,3,168,84,0,878,879,5,90,0,0,879,
|
|
880,3,170,85,0,880,881,5,139,0,0,881,882,3,150,75,0,882,883,3,96,
|
|
48,0,883,884,5,140,0,0,884,950,1,0,0,0,885,886,5,66,0,0,886,887,
|
|
3,168,84,0,887,888,5,90,0,0,888,889,3,170,85,0,889,890,5,139,0,0,
|
|
890,891,3,158,79,0,891,894,3,52,26,0,892,893,5,88,0,0,893,895,3,
|
|
170,85,0,894,892,1,0,0,0,894,895,1,0,0,0,895,896,1,0,0,0,896,897,
|
|
3,96,48,0,897,898,5,140,0,0,898,950,1,0,0,0,899,900,5,47,0,0,900,
|
|
901,3,168,84,0,901,902,5,90,0,0,902,903,3,170,85,0,903,904,5,139,
|
|
0,0,904,906,3,168,84,0,905,907,3,30,15,0,906,905,1,0,0,0,906,907,
|
|
1,0,0,0,907,909,1,0,0,0,908,910,3,80,40,0,909,908,1,0,0,0,909,910,
|
|
1,0,0,0,910,913,1,0,0,0,911,912,5,20,0,0,912,914,5,57,0,0,913,911,
|
|
1,0,0,0,913,914,1,0,0,0,914,915,1,0,0,0,915,916,5,140,0,0,916,950,
|
|
1,0,0,0,917,918,5,7,0,0,918,919,3,168,84,0,919,920,5,90,0,0,920,
|
|
921,3,170,85,0,921,922,5,139,0,0,922,923,3,168,84,0,923,924,5,57,
|
|
0,0,924,925,3,150,75,0,925,926,5,140,0,0,926,950,1,0,0,0,927,928,
|
|
5,55,0,0,928,929,3,168,84,0,929,930,5,90,0,0,930,931,3,170,85,0,
|
|
931,932,5,139,0,0,932,935,3,168,84,0,933,934,5,57,0,0,934,936,3,
|
|
150,75,0,935,933,1,0,0,0,935,936,1,0,0,0,936,937,1,0,0,0,937,938,
|
|
5,140,0,0,938,950,1,0,0,0,939,940,5,24,0,0,940,941,3,168,84,0,941,
|
|
942,5,90,0,0,942,943,3,170,85,0,943,944,5,139,0,0,944,945,3,168,
|
|
84,0,945,946,5,142,0,0,946,947,3,168,84,0,947,948,5,140,0,0,948,
|
|
950,1,0,0,0,949,867,1,0,0,0,949,876,1,0,0,0,949,885,1,0,0,0,949,
|
|
899,1,0,0,0,949,917,1,0,0,0,949,927,1,0,0,0,949,939,1,0,0,0,950,
|
|
95,1,0,0,0,951,952,5,145,0,0,952,957,3,98,49,0,953,954,5,141,0,0,
|
|
954,956,3,98,49,0,955,953,1,0,0,0,956,959,1,0,0,0,957,955,1,0,0,
|
|
0,957,958,1,0,0,0,958,960,1,0,0,0,959,957,1,0,0,0,960,961,5,146,
|
|
0,0,961,97,1,0,0,0,962,963,7,4,0,0,963,99,1,0,0,0,964,965,5,64,0,
|
|
0,965,966,3,102,51,0,966,101,1,0,0,0,967,970,3,104,52,0,968,970,
|
|
3,108,54,0,969,967,1,0,0,0,969,968,1,0,0,0,970,103,1,0,0,0,971,972,
|
|
5,65,0,0,972,973,3,168,84,0,973,974,5,90,0,0,974,975,3,170,85,0,
|
|
975,976,5,75,0,0,976,977,3,168,84,0,977,978,5,139,0,0,978,979,3,
|
|
150,75,0,979,980,5,76,0,0,980,983,3,106,53,0,981,982,5,77,0,0,982,
|
|
984,3,160,80,0,983,981,1,0,0,0,983,984,1,0,0,0,984,985,1,0,0,0,985,
|
|
986,5,140,0,0,986,105,1,0,0,0,987,1001,5,112,0,0,988,989,5,113,0,
|
|
0,989,990,5,147,0,0,990,991,3,150,75,0,991,992,5,148,0,0,992,1001,
|
|
1,0,0,0,993,994,5,85,0,0,994,1001,3,162,81,0,995,996,5,86,0,0,996,
|
|
997,5,147,0,0,997,998,3,150,75,0,998,999,5,148,0,0,999,1001,1,0,
|
|
0,0,1000,987,1,0,0,0,1000,988,1,0,0,0,1000,993,1,0,0,0,1000,995,
|
|
1,0,0,0,1001,107,1,0,0,0,1002,1003,5,66,0,0,1003,1004,3,168,84,0,
|
|
1004,1005,5,90,0,0,1005,1006,3,170,85,0,1006,1007,5,143,0,0,1007,
|
|
1008,3,110,55,0,1008,1009,3,110,55,0,1009,1010,5,144,0,0,1010,109,
|
|
1,0,0,0,1011,1012,3,52,26,0,1012,1013,5,67,0,0,1013,1014,3,168,84,
|
|
0,1014,1015,5,90,0,0,1015,1016,3,170,85,0,1016,1018,3,158,79,0,1017,
|
|
1019,5,118,0,0,1018,1017,1,0,0,0,1018,1019,1,0,0,0,1019,1022,1,0,
|
|
0,0,1020,1021,5,83,0,0,1021,1023,3,170,85,0,1022,1020,1,0,0,0,1022,
|
|
1023,1,0,0,0,1023,1025,1,0,0,0,1024,1026,5,87,0,0,1025,1024,1,0,
|
|
0,0,1025,1026,1,0,0,0,1026,1029,1,0,0,0,1027,1028,5,88,0,0,1028,
|
|
1030,3,170,85,0,1029,1027,1,0,0,0,1029,1030,1,0,0,0,1030,1032,1,
|
|
0,0,0,1031,1033,5,89,0,0,1032,1031,1,0,0,0,1032,1033,1,0,0,0,1033,
|
|
1034,1,0,0,0,1034,1035,5,140,0,0,1035,111,1,0,0,0,1036,1038,5,58,
|
|
0,0,1037,1039,3,24,12,0,1038,1037,1,0,0,0,1038,1039,1,0,0,0,1039,
|
|
1040,1,0,0,0,1040,1042,3,168,84,0,1041,1043,3,114,57,0,1042,1041,
|
|
1,0,0,0,1042,1043,1,0,0,0,1043,1044,1,0,0,0,1044,1045,5,59,0,0,1045,
|
|
1047,3,168,84,0,1046,1048,3,30,15,0,1047,1046,1,0,0,0,1047,1048,
|
|
1,0,0,0,1048,1051,1,0,0,0,1049,1050,5,90,0,0,1050,1052,3,170,85,
|
|
0,1051,1049,1,0,0,0,1051,1052,1,0,0,0,1052,1055,1,0,0,0,1053,1054,
|
|
5,82,0,0,1054,1056,5,153,0,0,1055,1053,1,0,0,0,1055,1056,1,0,0,0,
|
|
1056,1057,1,0,0,0,1057,1061,5,143,0,0,1058,1060,3,116,58,0,1059,
|
|
1058,1,0,0,0,1060,1063,1,0,0,0,1061,1059,1,0,0,0,1061,1062,1,0,0,
|
|
0,1062,1064,1,0,0,0,1063,1061,1,0,0,0,1064,1065,5,144,0,0,1065,113,
|
|
1,0,0,0,1066,1067,3,30,15,0,1067,115,1,0,0,0,1068,1069,5,63,0,0,
|
|
1069,1076,3,102,51,0,1070,1076,3,130,65,0,1071,1076,3,126,63,0,1072,
|
|
1076,3,120,60,0,1073,1076,3,128,64,0,1074,1076,3,118,59,0,1075,1068,
|
|
1,0,0,0,1075,1070,1,0,0,0,1075,1071,1,0,0,0,1075,1072,1,0,0,0,1075,
|
|
1073,1,0,0,0,1075,1074,1,0,0,0,1076,117,1,0,0,0,1077,1078,5,60,0,
|
|
0,1078,1079,3,168,84,0,1079,1080,5,62,0,0,1080,1081,3,168,84,0,1081,
|
|
1082,5,142,0,0,1082,1083,3,168,84,0,1083,1084,5,140,0,0,1084,119,
|
|
1,0,0,0,1085,1086,5,10,0,0,1086,1090,5,143,0,0,1087,1089,3,122,61,
|
|
0,1088,1087,1,0,0,0,1089,1092,1,0,0,0,1090,1088,1,0,0,0,1090,1091,
|
|
1,0,0,0,1091,1093,1,0,0,0,1092,1090,1,0,0,0,1093,1094,5,144,0,0,
|
|
1094,1095,5,140,0,0,1095,121,1,0,0,0,1096,1097,3,168,84,0,1097,1098,
|
|
5,62,0,0,1098,1099,5,65,0,0,1099,1100,3,168,84,0,1100,1101,5,140,
|
|
0,0,1101,1111,1,0,0,0,1102,1103,3,168,84,0,1103,1104,5,62,0,0,1104,
|
|
1105,5,66,0,0,1105,1106,3,168,84,0,1106,1107,5,142,0,0,1107,1108,
|
|
3,168,84,0,1108,1109,5,140,0,0,1109,1111,1,0,0,0,1110,1096,1,0,0,
|
|
0,1110,1102,1,0,0,0,1111,123,1,0,0,0,1112,1113,3,28,14,0,1113,1114,
|
|
5,20,0,0,1114,1119,5,57,0,0,1115,1116,5,142,0,0,1116,1118,3,168,
|
|
84,0,1117,1115,1,0,0,0,1118,1121,1,0,0,0,1119,1117,1,0,0,0,1119,
|
|
1120,1,0,0,0,1120,1122,1,0,0,0,1121,1119,1,0,0,0,1122,1123,5,140,
|
|
0,0,1123,125,1,0,0,0,1124,1125,5,60,0,0,1125,1126,3,168,84,0,1126,
|
|
1127,5,62,0,0,1127,1128,5,65,0,0,1128,1129,3,168,84,0,1129,1130,
|
|
5,140,0,0,1130,127,1,0,0,0,1131,1132,5,72,0,0,1132,1133,3,168,84,
|
|
0,1133,1134,5,73,0,0,1134,1135,5,74,0,0,1135,1136,5,69,0,0,1136,
|
|
1137,5,55,0,0,1137,1138,3,168,84,0,1138,1139,5,71,0,0,1139,1140,
|
|
5,66,0,0,1140,1141,3,168,84,0,1141,1142,5,142,0,0,1142,1143,3,168,
|
|
84,0,1143,1144,5,140,0,0,1144,129,1,0,0,0,1145,1146,5,60,0,0,1146,
|
|
1147,3,132,66,0,1147,1148,5,62,0,0,1148,1151,3,136,68,0,1149,1150,
|
|
5,36,0,0,1150,1152,3,170,85,0,1151,1149,1,0,0,0,1151,1152,1,0,0,
|
|
0,1152,1153,1,0,0,0,1153,1154,5,140,0,0,1154,131,1,0,0,0,1155,1156,
|
|
3,168,84,0,1156,1157,5,142,0,0,1157,1158,3,134,67,0,1158,133,1,0,
|
|
0,0,1159,1172,3,168,84,0,1160,1172,5,107,0,0,1161,1172,5,97,0,0,
|
|
1162,1172,5,98,0,0,1163,1172,5,1,0,0,1164,1172,5,104,0,0,1165,1172,
|
|
5,105,0,0,1166,1172,5,106,0,0,1167,1172,5,108,0,0,1168,1172,5,109,
|
|
0,0,1169,1172,5,110,0,0,1170,1172,5,111,0,0,1171,1159,1,0,0,0,1171,
|
|
1160,1,0,0,0,1171,1161,1,0,0,0,1171,1162,1,0,0,0,1171,1163,1,0,0,
|
|
0,1171,1164,1,0,0,0,1171,1165,1,0,0,0,1171,1166,1,0,0,0,1171,1167,
|
|
1,0,0,0,1171,1168,1,0,0,0,1171,1169,1,0,0,0,1171,1170,1,0,0,0,1172,
|
|
135,1,0,0,0,1173,1174,5,84,0,0,1174,1175,5,142,0,0,1175,1220,3,168,
|
|
84,0,1176,1177,5,85,0,0,1177,1178,3,168,84,0,1178,1179,5,142,0,0,
|
|
1179,1180,3,168,84,0,1180,1220,1,0,0,0,1181,1182,5,86,0,0,1182,1183,
|
|
3,168,84,0,1183,1184,5,142,0,0,1184,1185,3,168,84,0,1185,1220,1,
|
|
0,0,0,1186,1187,5,65,0,0,1187,1188,3,168,84,0,1188,1189,5,142,0,
|
|
0,1189,1190,3,140,70,0,1190,1220,1,0,0,0,1191,1192,5,66,0,0,1192,
|
|
1193,3,168,84,0,1193,1194,5,142,0,0,1194,1195,3,168,84,0,1195,1196,
|
|
5,142,0,0,1196,1197,3,142,71,0,1197,1220,1,0,0,0,1198,1199,5,47,
|
|
0,0,1199,1201,3,168,84,0,1200,1202,3,30,15,0,1201,1200,1,0,0,0,1201,
|
|
1202,1,0,0,0,1202,1203,1,0,0,0,1203,1204,5,142,0,0,1204,1205,3,132,
|
|
66,0,1205,1220,1,0,0,0,1206,1207,5,49,0,0,1207,1208,3,168,84,0,1208,
|
|
1209,5,142,0,0,1209,1211,3,168,84,0,1210,1212,3,30,15,0,1211,1210,
|
|
1,0,0,0,1211,1212,1,0,0,0,1212,1214,1,0,0,0,1213,1215,3,144,72,0,
|
|
1214,1213,1,0,0,0,1214,1215,1,0,0,0,1215,1217,1,0,0,0,1216,1218,
|
|
3,138,69,0,1217,1216,1,0,0,0,1217,1218,1,0,0,0,1218,1220,1,0,0,0,
|
|
1219,1173,1,0,0,0,1219,1176,1,0,0,0,1219,1181,1,0,0,0,1219,1186,
|
|
1,0,0,0,1219,1191,1,0,0,0,1219,1198,1,0,0,0,1219,1206,1,0,0,0,1220,
|
|
137,1,0,0,0,1221,1222,5,70,0,0,1222,1223,3,144,72,0,1223,139,1,0,
|
|
0,0,1224,1225,7,5,0,0,1225,141,1,0,0,0,1226,1227,7,6,0,0,1227,143,
|
|
1,0,0,0,1228,1229,5,68,0,0,1229,1233,5,143,0,0,1230,1232,3,146,73,
|
|
0,1231,1230,1,0,0,0,1232,1235,1,0,0,0,1233,1231,1,0,0,0,1233,1234,
|
|
1,0,0,0,1234,1236,1,0,0,0,1235,1233,1,0,0,0,1236,1237,5,144,0,0,
|
|
1237,145,1,0,0,0,1238,1239,3,168,84,0,1239,1240,5,62,0,0,1240,1241,
|
|
5,11,0,0,1241,1242,5,25,0,0,1242,1243,5,145,0,0,1243,1244,3,90,45,
|
|
0,1244,1245,5,146,0,0,1245,1246,5,140,0,0,1246,1337,1,0,0,0,1247,
|
|
1248,3,168,84,0,1248,1249,5,62,0,0,1249,1250,5,65,0,0,1250,1257,
|
|
3,168,84,0,1251,1252,5,71,0,0,1252,1253,5,66,0,0,1253,1254,3,168,
|
|
84,0,1254,1255,5,142,0,0,1255,1256,3,168,84,0,1256,1258,1,0,0,0,
|
|
1257,1251,1,0,0,0,1257,1258,1,0,0,0,1258,1259,1,0,0,0,1259,1260,
|
|
5,140,0,0,1260,1337,1,0,0,0,1261,1262,3,168,84,0,1262,1263,5,62,
|
|
0,0,1263,1264,5,66,0,0,1264,1265,3,168,84,0,1265,1266,5,142,0,0,
|
|
1266,1273,3,168,84,0,1267,1268,5,71,0,0,1268,1269,5,66,0,0,1269,
|
|
1270,3,168,84,0,1270,1271,5,142,0,0,1271,1272,3,168,84,0,1272,1274,
|
|
1,0,0,0,1273,1267,1,0,0,0,1273,1274,1,0,0,0,1274,1275,1,0,0,0,1275,
|
|
1276,5,140,0,0,1276,1337,1,0,0,0,1277,1278,3,168,84,0,1278,1279,
|
|
5,62,0,0,1279,1280,5,47,0,0,1280,1282,3,168,84,0,1281,1283,3,30,
|
|
15,0,1282,1281,1,0,0,0,1282,1283,1,0,0,0,1283,1292,1,0,0,0,1284,
|
|
1285,5,71,0,0,1285,1286,5,66,0,0,1286,1287,3,168,84,0,1287,1288,
|
|
5,142,0,0,1288,1289,3,168,84,0,1289,1293,1,0,0,0,1290,1291,5,20,
|
|
0,0,1291,1293,5,57,0,0,1292,1284,1,0,0,0,1292,1290,1,0,0,0,1292,
|
|
1293,1,0,0,0,1293,1294,1,0,0,0,1294,1295,5,140,0,0,1295,1337,1,0,
|
|
0,0,1296,1297,3,168,84,0,1297,1298,5,62,0,0,1298,1299,5,7,0,0,1299,
|
|
1300,3,168,84,0,1300,1301,5,68,0,0,1301,1305,5,143,0,0,1302,1304,
|
|
3,124,62,0,1303,1302,1,0,0,0,1304,1307,1,0,0,0,1305,1303,1,0,0,0,
|
|
1305,1306,1,0,0,0,1306,1308,1,0,0,0,1307,1305,1,0,0,0,1308,1309,
|
|
5,144,0,0,1309,1310,5,140,0,0,1310,1337,1,0,0,0,1311,1312,3,168,
|
|
84,0,1312,1313,5,62,0,0,1313,1314,5,55,0,0,1314,1315,3,168,84,0,
|
|
1315,1316,5,140,0,0,1316,1337,1,0,0,0,1317,1318,3,168,84,0,1318,
|
|
1320,5,62,0,0,1319,1321,5,11,0,0,1320,1319,1,0,0,0,1320,1321,1,0,
|
|
0,0,1321,1322,1,0,0,0,1322,1323,5,24,0,0,1323,1324,3,168,84,0,1324,
|
|
1325,5,142,0,0,1325,1332,3,168,84,0,1326,1327,5,71,0,0,1327,1328,
|
|
5,66,0,0,1328,1329,3,168,84,0,1329,1330,5,142,0,0,1330,1331,3,168,
|
|
84,0,1331,1333,1,0,0,0,1332,1326,1,0,0,0,1332,1333,1,0,0,0,1333,
|
|
1334,1,0,0,0,1334,1335,5,140,0,0,1335,1337,1,0,0,0,1336,1238,1,0,
|
|
0,0,1336,1247,1,0,0,0,1336,1261,1,0,0,0,1336,1277,1,0,0,0,1336,1296,
|
|
1,0,0,0,1336,1311,1,0,0,0,1336,1317,1,0,0,0,1337,147,1,0,0,0,1338,
|
|
1339,5,55,0,0,1339,1340,3,168,84,0,1340,1341,5,62,0,0,1341,1342,
|
|
3,168,84,0,1342,1343,5,142,0,0,1343,1345,3,168,84,0,1344,1346,3,
|
|
144,72,0,1345,1344,1,0,0,0,1345,1346,1,0,0,0,1346,1347,1,0,0,0,1347,
|
|
1348,5,140,0,0,1348,149,1,0,0,0,1349,1407,3,156,78,0,1350,1407,5,
|
|
119,0,0,1351,1407,5,120,0,0,1352,1353,5,121,0,0,1353,1407,3,170,
|
|
85,0,1354,1355,5,122,0,0,1355,1356,5,149,0,0,1356,1357,3,168,84,
|
|
0,1357,1358,5,150,0,0,1358,1407,1,0,0,0,1359,1360,5,123,0,0,1360,
|
|
1361,5,149,0,0,1361,1363,3,168,84,0,1362,1364,3,30,15,0,1363,1362,
|
|
1,0,0,0,1363,1364,1,0,0,0,1364,1365,1,0,0,0,1365,1366,5,150,0,0,
|
|
1366,1407,1,0,0,0,1367,1368,5,41,0,0,1368,1369,5,149,0,0,1369,1370,
|
|
3,168,84,0,1370,1371,5,150,0,0,1371,1407,1,0,0,0,1372,1373,5,124,
|
|
0,0,1373,1374,5,149,0,0,1374,1375,3,150,75,0,1375,1376,5,150,0,0,
|
|
1376,1407,1,0,0,0,1377,1378,5,125,0,0,1378,1379,5,149,0,0,1379,1380,
|
|
3,150,75,0,1380,1381,5,150,0,0,1381,1407,1,0,0,0,1382,1383,5,126,
|
|
0,0,1383,1387,5,143,0,0,1384,1386,3,152,76,0,1385,1384,1,0,0,0,1386,
|
|
1389,1,0,0,0,1387,1385,1,0,0,0,1387,1388,1,0,0,0,1388,1390,1,0,0,
|
|
0,1389,1387,1,0,0,0,1390,1407,5,144,0,0,1391,1392,5,8,0,0,1392,1393,
|
|
5,90,0,0,1393,1394,3,170,85,0,1394,1396,5,143,0,0,1395,1397,3,154,
|
|
77,0,1396,1395,1,0,0,0,1397,1398,1,0,0,0,1398,1396,1,0,0,0,1398,
|
|
1399,1,0,0,0,1399,1400,1,0,0,0,1400,1401,5,144,0,0,1401,1407,1,0,
|
|
0,0,1402,1404,3,168,84,0,1403,1405,3,30,15,0,1404,1403,1,0,0,0,1404,
|
|
1405,1,0,0,0,1405,1407,1,0,0,0,1406,1349,1,0,0,0,1406,1350,1,0,0,
|
|
0,1406,1351,1,0,0,0,1406,1352,1,0,0,0,1406,1354,1,0,0,0,1406,1359,
|
|
1,0,0,0,1406,1367,1,0,0,0,1406,1372,1,0,0,0,1406,1377,1,0,0,0,1406,
|
|
1382,1,0,0,0,1406,1391,1,0,0,0,1406,1402,1,0,0,0,1407,151,1,0,0,
|
|
0,1408,1409,3,168,84,0,1409,1410,5,139,0,0,1410,1411,3,150,75,0,
|
|
1411,1412,5,140,0,0,1412,153,1,0,0,0,1413,1414,3,168,84,0,1414,1415,
|
|
5,90,0,0,1415,1416,3,170,85,0,1416,1417,5,139,0,0,1417,1418,3,150,
|
|
75,0,1418,1419,5,140,0,0,1419,155,1,0,0,0,1420,1421,7,7,0,0,1421,
|
|
157,1,0,0,0,1422,1423,7,8,0,0,1423,159,1,0,0,0,1424,1433,3,170,85,
|
|
0,1425,1433,5,153,0,0,1426,1433,5,154,0,0,1427,1433,5,135,0,0,1428,
|
|
1433,5,136,0,0,1429,1433,5,137,0,0,1430,1433,3,162,81,0,1431,1433,
|
|
3,166,83,0,1432,1424,1,0,0,0,1432,1425,1,0,0,0,1432,1426,1,0,0,0,
|
|
1432,1427,1,0,0,0,1432,1428,1,0,0,0,1432,1429,1,0,0,0,1432,1430,
|
|
1,0,0,0,1432,1431,1,0,0,0,1433,161,1,0,0,0,1434,1443,5,143,0,0,1435,
|
|
1440,3,164,82,0,1436,1437,5,141,0,0,1437,1439,3,164,82,0,1438,1436,
|
|
1,0,0,0,1439,1442,1,0,0,0,1440,1438,1,0,0,0,1440,1441,1,0,0,0,1441,
|
|
1444,1,0,0,0,1442,1440,1,0,0,0,1443,1435,1,0,0,0,1443,1444,1,0,0,
|
|
0,1444,1445,1,0,0,0,1445,1446,5,144,0,0,1446,163,1,0,0,0,1447,1448,
|
|
3,170,85,0,1448,1449,5,139,0,0,1449,1450,3,160,80,0,1450,165,1,0,
|
|
0,0,1451,1460,5,145,0,0,1452,1457,3,160,80,0,1453,1454,5,141,0,0,
|
|
1454,1456,3,160,80,0,1455,1453,1,0,0,0,1456,1459,1,0,0,0,1457,1455,
|
|
1,0,0,0,1457,1458,1,0,0,0,1458,1461,1,0,0,0,1459,1457,1,0,0,0,1460,
|
|
1452,1,0,0,0,1460,1461,1,0,0,0,1461,1462,1,0,0,0,1462,1463,5,146,
|
|
0,0,1463,167,1,0,0,0,1464,1465,7,9,0,0,1465,169,1,0,0,0,1466,1467,
|
|
5,156,0,0,1467,171,1,0,0,0,130,184,191,212,225,237,264,272,279,285,
|
|
297,300,306,317,326,336,339,341,345,353,365,370,380,390,395,410,
|
|
416,428,437,445,453,466,469,479,483,489,496,502,510,518,531,538,
|
|
542,547,558,564,575,601,605,611,622,631,637,642,644,675,679,685,
|
|
712,722,733,736,741,744,747,754,763,766,769,772,795,797,806,820,
|
|
841,844,847,854,862,894,906,909,913,935,949,957,969,983,1000,1018,
|
|
1022,1025,1029,1032,1038,1042,1047,1051,1055,1061,1075,1090,1110,
|
|
1119,1151,1171,1201,1211,1214,1217,1219,1233,1257,1273,1282,1292,
|
|
1305,1320,1332,1336,1345,1363,1387,1398,1404,1406,1432,1440,1443,
|
|
1457,1460
|
|
];
|
|
|
|
private static __ATN: antlr.ATN;
|
|
public static get _ATN(): antlr.ATN {
|
|
if (!QuixosCapabilityParser.__ATN) {
|
|
QuixosCapabilityParser.__ATN = new antlr.ATNDeserializer().deserialize(QuixosCapabilityParser._serializedATN);
|
|
}
|
|
|
|
return QuixosCapabilityParser.__ATN;
|
|
}
|
|
|
|
|
|
private static readonly vocabulary = new antlr.Vocabulary(QuixosCapabilityParser.literalNames, QuixosCapabilityParser.symbolicNames, []);
|
|
|
|
public override get vocabulary(): antlr.Vocabulary {
|
|
return QuixosCapabilityParser.vocabulary;
|
|
}
|
|
|
|
private static readonly decisionsToDFA = QuixosCapabilityParser._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) );
|
|
}
|
|
|
|
export class DocumentContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public workspaceDecl(): WorkspaceDeclContext | null {
|
|
return this.getRuleContext(0, WorkspaceDeclContext);
|
|
}
|
|
public EOF(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.EOF, 0)!;
|
|
}
|
|
public interfaceResourceDecl(): InterfaceResourceDeclContext | null {
|
|
return this.getRuleContext(0, InterfaceResourceDeclContext);
|
|
}
|
|
public packageResourceDecl(): PackageResourceDeclContext | null {
|
|
return this.getRuleContext(0, PackageResourceDeclContext);
|
|
}
|
|
public fragmentDecl(): FragmentDeclContext | null {
|
|
return this.getRuleContext(0, FragmentDeclContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_document;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitDocument) {
|
|
return visitor.visitDocument(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FragmentDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public FRAGMENT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.FRAGMENT, 0)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public workspaceItem(): WorkspaceItemContext[];
|
|
public workspaceItem(i: number): WorkspaceItemContext | null;
|
|
public workspaceItem(i?: number): WorkspaceItemContext[] | WorkspaceItemContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(WorkspaceItemContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, WorkspaceItemContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_fragmentDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitFragmentDecl) {
|
|
return visitor.visitFragmentDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SourceImportDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public IMPORT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.IMPORT, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_sourceImportDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitSourceImportDecl) {
|
|
return visitor.visitSourceImportDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class WorkspaceDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public WORKSPACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.WORKSPACE, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public REVISION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.REVISION, 0)!;
|
|
}
|
|
public COMMIT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.COMMIT, 0)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public workspaceItem(): WorkspaceItemContext[];
|
|
public workspaceItem(i: number): WorkspaceItemContext | null;
|
|
public workspaceItem(i?: number): WorkspaceItemContext[] | WorkspaceItemContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(WorkspaceItemContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, WorkspaceItemContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_workspaceDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitWorkspaceDecl) {
|
|
return visitor.visitWorkspaceDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class WorkspaceItemContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public sourceImportDecl(): SourceImportDeclContext | null {
|
|
return this.getRuleContext(0, SourceImportDeclContext);
|
|
}
|
|
public atomDecl(): AtomDeclContext | null {
|
|
return this.getRuleContext(0, AtomDeclContext);
|
|
}
|
|
public resourceImportDecl(): ResourceImportDeclContext | null {
|
|
return this.getRuleContext(0, ResourceImportDeclContext);
|
|
}
|
|
public sharedAttachmentDecl(): SharedAttachmentDeclContext | null {
|
|
return this.getRuleContext(0, SharedAttachmentDeclContext);
|
|
}
|
|
public conformanceDecl(): ConformanceDeclContext | null {
|
|
return this.getRuleContext(0, ConformanceDeclContext);
|
|
}
|
|
public constructorBindingDecl(): ConstructorBindingDeclContext | null {
|
|
return this.getRuleContext(0, ConstructorBindingDeclContext);
|
|
}
|
|
public presentationDecl(): PresentationDeclContext | null {
|
|
return this.getRuleContext(0, PresentationDeclContext);
|
|
}
|
|
public typeAliasDecl(): TypeAliasDeclContext | null {
|
|
return this.getRuleContext(0, TypeAliasDeclContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_workspaceItem;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitWorkspaceItem) {
|
|
return visitor.visitWorkspaceItem(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ResourceImportDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public IMPORT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.IMPORT, 0)!;
|
|
}
|
|
public INTERFACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public PACKAGE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.PACKAGE, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_resourceImportDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitResourceImportDecl) {
|
|
return visitor.visitResourceImportDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ExternalAtomDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public EXTERNAL(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.EXTERNAL, 0)!;
|
|
}
|
|
public ATOM(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ATOM, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_externalAtomDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitExternalAtomDecl) {
|
|
return visitor.visitExternalAtomDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ExternalInterfaceDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public EXTERNAL(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.EXTERNAL, 0)!;
|
|
}
|
|
public INTERFACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACE, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public REVISION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.REVISION, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_externalInterfaceDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitExternalInterfaceDecl) {
|
|
return visitor.visitExternalInterfaceDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SymbolDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public SYMBOL(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SYMBOL, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_symbolDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitSymbolDecl) {
|
|
return visitor.visitSymbolDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ResourcePreambleContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public resourceImportDecl(): ResourceImportDeclContext | null {
|
|
return this.getRuleContext(0, ResourceImportDeclContext);
|
|
}
|
|
public externalAtomDecl(): ExternalAtomDeclContext | null {
|
|
return this.getRuleContext(0, ExternalAtomDeclContext);
|
|
}
|
|
public externalInterfaceDecl(): ExternalInterfaceDeclContext | null {
|
|
return this.getRuleContext(0, ExternalInterfaceDeclContext);
|
|
}
|
|
public symbolDecl(): SymbolDeclContext | null {
|
|
return this.getRuleContext(0, SymbolDeclContext);
|
|
}
|
|
public typeAliasDecl(): TypeAliasDeclContext | null {
|
|
return this.getRuleContext(0, TypeAliasDeclContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_resourcePreamble;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitResourcePreamble) {
|
|
return visitor.visitResourcePreamble(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class AtomDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public ATOM(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ATOM, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public DOC(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DOC, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_atomDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitAtomDecl) {
|
|
return visitor.visitAtomDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class InterfaceResourceDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public INTERFACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACE, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public REVISION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.REVISION, 0)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public resourcePreamble(): ResourcePreambleContext[];
|
|
public resourcePreamble(i: number): ResourcePreambleContext | null;
|
|
public resourcePreamble(i?: number): ResourcePreambleContext[] | ResourcePreambleContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ResourcePreambleContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, ResourcePreambleContext);
|
|
}
|
|
public typeParameters(): TypeParametersContext | null {
|
|
return this.getRuleContext(0, TypeParametersContext);
|
|
}
|
|
public REQUIRES(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.REQUIRES, 0);
|
|
}
|
|
public interfaceType(): InterfaceTypeContext[];
|
|
public interfaceType(i: number): InterfaceTypeContext | null;
|
|
public interfaceType(i?: number): InterfaceTypeContext[] | InterfaceTypeContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(InterfaceTypeContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, InterfaceTypeContext);
|
|
}
|
|
public interfaceMember(): InterfaceMemberContext[];
|
|
public interfaceMember(i: number): InterfaceMemberContext | null;
|
|
public interfaceMember(i?: number): InterfaceMemberContext[] | InterfaceMemberContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(InterfaceMemberContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, InterfaceMemberContext);
|
|
}
|
|
public COMMA(): antlr.TerminalNode[];
|
|
public COMMA(i: number): antlr.TerminalNode | null;
|
|
public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.COMMA);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.COMMA, i);
|
|
}
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_interfaceResourceDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitInterfaceResourceDecl) {
|
|
return visitor.visitInterfaceResourceDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TypeParametersContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public LT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LT, 0)!;
|
|
}
|
|
public typeParameter(): TypeParameterContext[];
|
|
public typeParameter(i: number): TypeParameterContext | null;
|
|
public typeParameter(i?: number): TypeParameterContext[] | TypeParameterContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(TypeParameterContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, TypeParameterContext);
|
|
}
|
|
public GT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.GT, 0)!;
|
|
}
|
|
public COMMA(): antlr.TerminalNode[];
|
|
public COMMA(i: number): antlr.TerminalNode | null;
|
|
public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.COMMA);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.COMMA, i);
|
|
}
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_typeParameters;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitTypeParameters) {
|
|
return visitor.visitTypeParameters(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TypeParameterContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public VALUE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.VALUE, 0);
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public COLON(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0);
|
|
}
|
|
public STORABLE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.STORABLE, 0);
|
|
}
|
|
public OBJECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.OBJECT, 0);
|
|
}
|
|
public IMPLEMENTS(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.IMPLEMENTS, 0);
|
|
}
|
|
public interfaceType(): InterfaceTypeContext[];
|
|
public interfaceType(i: number): InterfaceTypeContext | null;
|
|
public interfaceType(i?: number): InterfaceTypeContext[] | InterfaceTypeContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(InterfaceTypeContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, InterfaceTypeContext);
|
|
}
|
|
public AMP(): antlr.TerminalNode[];
|
|
public AMP(i: number): antlr.TerminalNode | null;
|
|
public AMP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.AMP);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.AMP, i);
|
|
}
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_typeParameter;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitTypeParameter) {
|
|
return visitor.visitTypeParameter(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class InterfaceTypeContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public typeArguments(): TypeArgumentsContext | null {
|
|
return this.getRuleContext(0, TypeArgumentsContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_interfaceType;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitInterfaceType) {
|
|
return visitor.visitInterfaceType(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TypeArgumentsContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public LT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LT, 0)!;
|
|
}
|
|
public typeArgument(): TypeArgumentContext[];
|
|
public typeArgument(i: number): TypeArgumentContext | null;
|
|
public typeArgument(i?: number): TypeArgumentContext[] | TypeArgumentContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(TypeArgumentContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, TypeArgumentContext);
|
|
}
|
|
public GT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.GT, 0)!;
|
|
}
|
|
public COMMA(): antlr.TerminalNode[];
|
|
public COMMA(i: number): antlr.TerminalNode | null;
|
|
public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.COMMA);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.COMMA, i);
|
|
}
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_typeArguments;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitTypeArguments) {
|
|
return visitor.visitTypeArguments(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TypeArgumentContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public ATOM(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ATOM, 0);
|
|
}
|
|
public identifier(): IdentifierContext | null {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public INTERFACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
|
|
}
|
|
public interfaceType(): InterfaceTypeContext | null {
|
|
return this.getRuleContext(0, InterfaceTypeContext);
|
|
}
|
|
public OBJECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.OBJECT, 0);
|
|
}
|
|
public valueType(): ValueTypeContext | null {
|
|
return this.getRuleContext(0, ValueTypeContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_typeArgument;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitTypeArgument) {
|
|
return visitor.visitTypeArgument(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TypeAliasDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public TYPE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.TYPE, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public EQUAL(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.EQUAL, 0)!;
|
|
}
|
|
public valueType(): ValueTypeContext {
|
|
return this.getRuleContext(0, ValueTypeContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public typeParameters(): TypeParametersContext | null {
|
|
return this.getRuleContext(0, TypeParametersContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_typeAliasDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitTypeAliasDecl) {
|
|
return visitor.visitTypeAliasDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class InterfaceMemberContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public valueMember(): ValueMemberContext | null {
|
|
return this.getRuleContext(0, ValueMemberContext);
|
|
}
|
|
public relationshipMember(): RelationshipMemberContext | null {
|
|
return this.getRuleContext(0, RelationshipMemberContext);
|
|
}
|
|
public operationMember(): OperationMemberContext | null {
|
|
return this.getRuleContext(0, OperationMemberContext);
|
|
}
|
|
public moduleMember(): ModuleMemberContext | null {
|
|
return this.getRuleContext(0, ModuleMemberContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_interfaceMember;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitInterfaceMember) {
|
|
return visitor.visitInterfaceMember(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ModuleMemberContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public MODULE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.MODULE, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public CONTRACT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.CONTRACT, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public SUBJECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SUBJECT, 0);
|
|
}
|
|
public targetConstraint(): TargetConstraintContext | null {
|
|
return this.getRuleContext(0, TargetConstraintContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_moduleMember;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitModuleMember) {
|
|
return visitor.visitModuleMember(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class OperationMemberContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public OPERATION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.OPERATION, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode[];
|
|
public ID(i: number): antlr.TerminalNode | null;
|
|
public ID(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.ID);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.ID, i);
|
|
}
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public COLON(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0)!;
|
|
}
|
|
public valueType(): ValueTypeContext[];
|
|
public valueType(i: number): ValueTypeContext | null;
|
|
public valueType(i?: number): ValueTypeContext[] | ValueTypeContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ValueTypeContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, ValueTypeContext);
|
|
}
|
|
public ARROW(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ARROW, 0)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public CALL(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.CALL, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public STATIC(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.STATIC, 0);
|
|
}
|
|
public executionClause(): ExecutionClauseContext | null {
|
|
return this.getRuleContext(0, ExecutionClauseContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_operationMember;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitOperationMember) {
|
|
return visitor.visitOperationMember(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ValueMemberContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public COLON(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0)!;
|
|
}
|
|
public valueType(): ValueTypeContext {
|
|
return this.getRuleContext(0, ValueTypeContext)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public VALUE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.VALUE, 0);
|
|
}
|
|
public FIELD(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.FIELD, 0);
|
|
}
|
|
public queryReadContract(): QueryReadContractContext | null {
|
|
return this.getRuleContext(0, QueryReadContractContext);
|
|
}
|
|
public valueMemberOperation(): ValueMemberOperationContext[];
|
|
public valueMemberOperation(i: number): ValueMemberOperationContext | null;
|
|
public valueMemberOperation(i?: number): ValueMemberOperationContext[] | ValueMemberOperationContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ValueMemberOperationContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, ValueMemberOperationContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_valueMember;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitValueMember) {
|
|
return visitor.visitValueMember(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ValueMemberOperationContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public GET(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.GET, 0);
|
|
}
|
|
public ID(): antlr.TerminalNode[];
|
|
public ID(i: number): antlr.TerminalNode | null;
|
|
public ID(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.ID);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.ID, i);
|
|
}
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public executionClause(): ExecutionClauseContext | null {
|
|
return this.getRuleContext(0, ExecutionClauseContext);
|
|
}
|
|
public SET(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SET, 0);
|
|
}
|
|
public EDIT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.EDIT, 0);
|
|
}
|
|
public WATCH(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH, 0);
|
|
}
|
|
public START(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.START, 0);
|
|
}
|
|
public STOP(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.STOP, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_valueMemberOperation;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitValueMemberOperation) {
|
|
return visitor.visitValueMemberOperation(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class RelationshipMemberContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public RELATION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RELATION, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public COLON(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0)!;
|
|
}
|
|
public cardinality(): CardinalityContext {
|
|
return this.getRuleContext(0, CardinalityContext)!;
|
|
}
|
|
public targetConstraint(): TargetConstraintContext {
|
|
return this.getRuleContext(0, TargetConstraintContext)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public queryReadContract(): QueryReadContractContext | null {
|
|
return this.getRuleContext(0, QueryReadContractContext);
|
|
}
|
|
public ORDERED(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ORDERED, 0);
|
|
}
|
|
public KEYED(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.KEYED, 0);
|
|
}
|
|
public relationshipOperation(): RelationshipOperationContext[];
|
|
public relationshipOperation(i: number): RelationshipOperationContext | null;
|
|
public relationshipOperation(i?: number): RelationshipOperationContext[] | RelationshipOperationContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(RelationshipOperationContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, RelationshipOperationContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_relationshipMember;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitRelationshipMember) {
|
|
return visitor.visitRelationshipMember(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QueryReadContractContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public QUERYABLE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.QUERYABLE, 0)!;
|
|
}
|
|
public RPC(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RPC, 0);
|
|
}
|
|
public PORTABLE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.PORTABLE, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_queryReadContract;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitQueryReadContract) {
|
|
return visitor.visitQueryReadContract(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class RelationshipOperationContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public RESOLVE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RESOLVE, 0);
|
|
}
|
|
public ID(): antlr.TerminalNode[];
|
|
public ID(i: number): antlr.TerminalNode | null;
|
|
public ID(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.ID);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.ID, i);
|
|
}
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public executionClause(): ExecutionClauseContext | null {
|
|
return this.getRuleContext(0, ExecutionClauseContext);
|
|
}
|
|
public CONNECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CONNECT, 0);
|
|
}
|
|
public DISCONNECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DISCONNECT, 0);
|
|
}
|
|
public WATCH(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH, 0);
|
|
}
|
|
public START(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.START, 0);
|
|
}
|
|
public STOP(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.STOP, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_relationshipOperation;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitRelationshipOperation) {
|
|
return visitor.visitRelationshipOperation(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TargetConstraintContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public ATOM(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ATOM, 0);
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public INTERFACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
|
|
}
|
|
public typeArguments(): TypeArgumentsContext | null {
|
|
return this.getRuleContext(0, TypeArgumentsContext);
|
|
}
|
|
public OBJECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.OBJECT, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_targetConstraint;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitTargetConstraint) {
|
|
return visitor.visitTargetConstraint(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PackageResourceDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public PACKAGE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.PACKAGE, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public REVISION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.REVISION, 0)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public resourcePreamble(): ResourcePreambleContext[];
|
|
public resourcePreamble(i: number): ResourcePreambleContext | null;
|
|
public resourcePreamble(i?: number): ResourcePreambleContext[] | ResourcePreambleContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ResourcePreambleContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, ResourcePreambleContext);
|
|
}
|
|
public SEMANTIC_MAJOR(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SEMANTIC_MAJOR, 0);
|
|
}
|
|
public INTEGER(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTEGER, 0);
|
|
}
|
|
public packageExport(): PackageExportContext[];
|
|
public packageExport(i: number): PackageExportContext | null;
|
|
public packageExport(i?: number): PackageExportContext[] | PackageExportContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PackageExportContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, PackageExportContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_packageResourceDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitPackageResourceDecl) {
|
|
return visitor.visitPackageResourceDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PackageExportContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public packageOperationExport(): PackageOperationExportContext | null {
|
|
return this.getRuleContext(0, PackageOperationExportContext);
|
|
}
|
|
public packageFunctionExport(): PackageFunctionExportContext | null {
|
|
return this.getRuleContext(0, PackageFunctionExportContext);
|
|
}
|
|
public packageConstructorExport(): PackageConstructorExportContext | null {
|
|
return this.getRuleContext(0, PackageConstructorExportContext);
|
|
}
|
|
public packageQuery(): PackageQueryContext | null {
|
|
return this.getRuleContext(0, PackageQueryContext);
|
|
}
|
|
public packageQuerySpecialization(): PackageQuerySpecializationContext | null {
|
|
return this.getRuleContext(0, PackageQuerySpecializationContext);
|
|
}
|
|
public moduleExport(): ModuleExportContext | null {
|
|
return this.getRuleContext(0, ModuleExportContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_packageExport;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitPackageExport) {
|
|
return visitor.visitPackageExport(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ModuleExportContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public MODULE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.MODULE, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public IMPLEMENTS(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.IMPLEMENTS, 0)!;
|
|
}
|
|
public interfaceType(): InterfaceTypeContext {
|
|
return this.getRuleContext(0, InterfaceTypeContext)!;
|
|
}
|
|
public DOT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.DOT, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_moduleExport;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitModuleExport) {
|
|
return visitor.visitModuleExport(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PresentationDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public PRESENTATION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.PRESENTATION, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public FOR(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.FOR, 0)!;
|
|
}
|
|
public interfaceType(): InterfaceTypeContext {
|
|
return this.getRuleContext(0, InterfaceTypeContext)!;
|
|
}
|
|
public USING(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.USING, 0)!;
|
|
}
|
|
public DOT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.DOT, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_presentationDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitPresentationDecl) {
|
|
return visitor.visitPresentationDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PackageQueryContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public QUERY(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.QUERY, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public ROOT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ROOT, 0)!;
|
|
}
|
|
public interfaceType(): InterfaceTypeContext {
|
|
return this.getRuleContext(0, InterfaceTypeContext)!;
|
|
}
|
|
public DOCUMENT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.DOCUMENT, 0)!;
|
|
}
|
|
public OPERATION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.OPERATION, 0);
|
|
}
|
|
public LBRACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0);
|
|
}
|
|
public RBRACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0);
|
|
}
|
|
public FRAGMENT(): antlr.TerminalNode[];
|
|
public FRAGMENT(i: number): antlr.TerminalNode | null;
|
|
public FRAGMENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.FRAGMENT);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.FRAGMENT, i);
|
|
}
|
|
}
|
|
public typeParameters(): TypeParametersContext | null {
|
|
return this.getRuleContext(0, TypeParametersContext);
|
|
}
|
|
public WORKSPACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WORKSPACE, 0);
|
|
}
|
|
public SEMI(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0);
|
|
}
|
|
public queryClause(): QueryClauseContext[];
|
|
public queryClause(i: number): QueryClauseContext | null;
|
|
public queryClause(i?: number): QueryClauseContext[] | QueryClauseContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(QueryClauseContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, QueryClauseContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_packageQuery;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitPackageQuery) {
|
|
return visitor.visitPackageQuery(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PackageQuerySpecializationContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public QUERY(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.QUERY, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public SPECIALIZE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SPECIALIZE, 0)!;
|
|
}
|
|
public typeArguments(): TypeArgumentsContext {
|
|
return this.getRuleContext(0, TypeArgumentsContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_packageQuerySpecialization;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitPackageQuerySpecialization) {
|
|
return visitor.visitPackageQuerySpecialization(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QueryClauseContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public REPLICA(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.REPLICA, 0);
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public LOCAL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LOCAL, 0);
|
|
}
|
|
public FROM(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.FROM, 0);
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public FRAGMENTS(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.FRAGMENTS, 0);
|
|
}
|
|
public stringLiteral(): StringLiteralContext | null {
|
|
return this.getRuleContext(0, StringLiteralContext);
|
|
}
|
|
public DOT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DOT, 0);
|
|
}
|
|
public WITH(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WITH, 0);
|
|
}
|
|
public LBRACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0);
|
|
}
|
|
public RBRACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0);
|
|
}
|
|
public fragmentVariable(): FragmentVariableContext[];
|
|
public fragmentVariable(i: number): FragmentVariableContext | null;
|
|
public fragmentVariable(i?: number): FragmentVariableContext[] | FragmentVariableContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(FragmentVariableContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, FragmentVariableContext);
|
|
}
|
|
public VIEW(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.VIEW, 0);
|
|
}
|
|
public AS(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.AS, 0);
|
|
}
|
|
public interfaceType(): InterfaceTypeContext | null {
|
|
return this.getRuleContext(0, InterfaceTypeContext);
|
|
}
|
|
public OBJECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.OBJECT, 0);
|
|
}
|
|
public MAX(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.MAX, 0);
|
|
}
|
|
public INTEGER(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTEGER, 0);
|
|
}
|
|
public ALLOW(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ALLOW, 0);
|
|
}
|
|
public WATCH(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH, 0);
|
|
}
|
|
public POLL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.POLL, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_queryClause;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitQueryClause) {
|
|
return visitor.visitQueryClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FragmentVariableContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public TO(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.TO, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_fragmentVariable;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitFragmentVariable) {
|
|
return visitor.visitFragmentVariable(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PackageOperationExportContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public OPERATION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.OPERATION, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public COLON(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0)!;
|
|
}
|
|
public valueType(): ValueTypeContext[];
|
|
public valueType(i: number): ValueTypeContext | null;
|
|
public valueType(i?: number): ValueTypeContext[] | ValueTypeContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ValueTypeContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, ValueTypeContext);
|
|
}
|
|
public ARROW(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ARROW, 0)!;
|
|
}
|
|
public MODE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.MODE, 0)!;
|
|
}
|
|
public operationMode(): OperationModeContext {
|
|
return this.getRuleContext(0, OperationModeContext)!;
|
|
}
|
|
public RECEIVER(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RECEIVER, 0)!;
|
|
}
|
|
public receiverRequirement(): ReceiverRequirementContext {
|
|
return this.getRuleContext(0, ReceiverRequirementContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public typeParameters(): TypeParametersContext | null {
|
|
return this.getRuleContext(0, TypeParametersContext);
|
|
}
|
|
public executionClause(): ExecutionClauseContext | null {
|
|
return this.getRuleContext(0, ExecutionClauseContext);
|
|
}
|
|
public eventClause(): EventClauseContext | null {
|
|
return this.getRuleContext(0, EventClauseContext);
|
|
}
|
|
public dependencyBlock(): DependencyBlockContext | null {
|
|
return this.getRuleContext(0, DependencyBlockContext);
|
|
}
|
|
public preparationClause(): PreparationClauseContext | null {
|
|
return this.getRuleContext(0, PreparationClauseContext);
|
|
}
|
|
public acceptanceClause(): AcceptanceClauseContext | null {
|
|
return this.getRuleContext(0, AcceptanceClauseContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_packageOperationExport;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitPackageOperationExport) {
|
|
return visitor.visitPackageOperationExport(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PackageFunctionExportContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public FUNCTION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.FUNCTION, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public COLON(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0)!;
|
|
}
|
|
public valueType(): ValueTypeContext[];
|
|
public valueType(i: number): ValueTypeContext | null;
|
|
public valueType(i?: number): ValueTypeContext[] | ValueTypeContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ValueTypeContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, ValueTypeContext);
|
|
}
|
|
public ARROW(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ARROW, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public typeParameters(): TypeParametersContext | null {
|
|
return this.getRuleContext(0, TypeParametersContext);
|
|
}
|
|
public executionClause(): ExecutionClauseContext | null {
|
|
return this.getRuleContext(0, ExecutionClauseContext);
|
|
}
|
|
public dependencyBlock(): DependencyBlockContext | null {
|
|
return this.getRuleContext(0, DependencyBlockContext);
|
|
}
|
|
public preparationClause(): PreparationClauseContext | null {
|
|
return this.getRuleContext(0, PreparationClauseContext);
|
|
}
|
|
public acceptanceClause(): AcceptanceClauseContext | null {
|
|
return this.getRuleContext(0, AcceptanceClauseContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_packageFunctionExport;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitPackageFunctionExport) {
|
|
return visitor.visitPackageFunctionExport(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class AcceptanceClauseContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public ACCEPT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ACCEPT, 0)!;
|
|
}
|
|
public USING(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.USING, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_acceptanceClause;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitAcceptanceClause) {
|
|
return visitor.visitAcceptanceClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PreparationClauseContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public PREPARES(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.PREPARES, 0)!;
|
|
}
|
|
public CREATION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.CREATION, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public USING(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.USING, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_preparationClause;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitPreparationClause) {
|
|
return visitor.visitPreparationClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ExecutionClauseContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public EXECUTION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.EXECUTION, 0)!;
|
|
}
|
|
public REMOTE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.REMOTE, 0);
|
|
}
|
|
public SNAPSHOT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SNAPSHOT, 0);
|
|
}
|
|
public TRANSACTION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.TRANSACTION, 0);
|
|
}
|
|
public TARGETS(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.TARGETS, 0);
|
|
}
|
|
public LBRACK(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LBRACK, 0);
|
|
}
|
|
public identifierList(): IdentifierListContext | null {
|
|
return this.getRuleContext(0, IdentifierListContext);
|
|
}
|
|
public RBRACK(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RBRACK, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_executionClause;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitExecutionClause) {
|
|
return visitor.visitExecutionClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SelectedOperationsContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public USING(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.USING, 0)!;
|
|
}
|
|
public LBRACK(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACK, 0)!;
|
|
}
|
|
public memberOperationRef(): MemberOperationRefContext[];
|
|
public memberOperationRef(i: number): MemberOperationRefContext | null;
|
|
public memberOperationRef(i?: number): MemberOperationRefContext[] | MemberOperationRefContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(MemberOperationRefContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, MemberOperationRefContext);
|
|
}
|
|
public RBRACK(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACK, 0)!;
|
|
}
|
|
public COMMA(): antlr.TerminalNode[];
|
|
public COMMA(i: number): antlr.TerminalNode | null;
|
|
public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.COMMA);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.COMMA, i);
|
|
}
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_selectedOperations;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitSelectedOperations) {
|
|
return visitor.visitSelectedOperations(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PackageConstructorExportContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public CONSTRUCTOR(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public CONSTRUCTS(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.CONSTRUCTS, 0)!;
|
|
}
|
|
public COLON(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0)!;
|
|
}
|
|
public valueType(): ValueTypeContext {
|
|
return this.getRuleContext(0, ValueTypeContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public dependencyBlock(): DependencyBlockContext | null {
|
|
return this.getRuleContext(0, DependencyBlockContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_packageConstructorExport;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitPackageConstructorExport) {
|
|
return visitor.visitPackageConstructorExport(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class EventClauseContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public EMITS(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.EMITS, 0)!;
|
|
}
|
|
public valueType(): ValueTypeContext {
|
|
return this.getRuleContext(0, ValueTypeContext)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_eventClause;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitEventClause) {
|
|
return visitor.visitEventClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class OperationModeContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public CALL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CALL, 0);
|
|
}
|
|
public WATCH_START(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH_START, 0);
|
|
}
|
|
public WATCH_STOP(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH_STOP, 0);
|
|
}
|
|
public SUBSCRIBE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SUBSCRIBE, 0);
|
|
}
|
|
public UNSUBSCRIBE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.UNSUBSCRIBE, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_operationMode;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitOperationMode) {
|
|
return visitor.visitOperationMode(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ReceiverRequirementContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public ANY(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ANY, 0);
|
|
}
|
|
public ATOM(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ATOM, 0);
|
|
}
|
|
public identifier(): IdentifierContext | null {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public OBJECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.OBJECT, 0);
|
|
}
|
|
public INTERFACES(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACES, 0);
|
|
}
|
|
public LBRACK(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LBRACK, 0);
|
|
}
|
|
public RBRACK(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RBRACK, 0);
|
|
}
|
|
public interfaceType(): InterfaceTypeContext[];
|
|
public interfaceType(i: number): InterfaceTypeContext | null;
|
|
public interfaceType(i?: number): InterfaceTypeContext[] | InterfaceTypeContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(InterfaceTypeContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, InterfaceTypeContext);
|
|
}
|
|
public COMMA(): antlr.TerminalNode[];
|
|
public COMMA(i: number): antlr.TerminalNode | null;
|
|
public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.COMMA);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.COMMA, i);
|
|
}
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_receiverRequirement;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitReceiverRequirement) {
|
|
return visitor.visitReceiverRequirement(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IdentifierListContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public COMMA(): antlr.TerminalNode[];
|
|
public COMMA(i: number): antlr.TerminalNode | null;
|
|
public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.COMMA);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.COMMA, i);
|
|
}
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_identifierList;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitIdentifierList) {
|
|
return visitor.visitIdentifierList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DependencyBlockContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public REQUIRES(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.REQUIRES, 0)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public dependencyPort(): DependencyPortContext[];
|
|
public dependencyPort(i: number): DependencyPortContext | null;
|
|
public dependencyPort(i?: number): DependencyPortContext[] | DependencyPortContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(DependencyPortContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, DependencyPortContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_dependencyBlock;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitDependencyBlock) {
|
|
return visitor.visitDependencyBlock(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DependencyPortContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public REFLECTION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.REFLECTION, 0);
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public LBRACK(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LBRACK, 0);
|
|
}
|
|
public identifierList(): IdentifierListContext | null {
|
|
return this.getRuleContext(0, IdentifierListContext);
|
|
}
|
|
public RBRACK(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RBRACK, 0);
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public STATE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.STATE, 0);
|
|
}
|
|
public COLON(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0);
|
|
}
|
|
public valueType(): ValueTypeContext | null {
|
|
return this.getRuleContext(0, ValueTypeContext);
|
|
}
|
|
public primitiveList(): PrimitiveListContext | null {
|
|
return this.getRuleContext(0, PrimitiveListContext);
|
|
}
|
|
public EDGE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.EDGE, 0);
|
|
}
|
|
public cardinality(): CardinalityContext | null {
|
|
return this.getRuleContext(0, CardinalityContext);
|
|
}
|
|
public targetConstraint(): TargetConstraintContext | null {
|
|
return this.getRuleContext(0, TargetConstraintContext);
|
|
}
|
|
public KEYED(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.KEYED, 0);
|
|
}
|
|
public INTERFACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
|
|
}
|
|
public typeArguments(): TypeArgumentsContext | null {
|
|
return this.getRuleContext(0, TypeArgumentsContext);
|
|
}
|
|
public selectedOperations(): SelectedOperationsContext | null {
|
|
return this.getRuleContext(0, SelectedOperationsContext);
|
|
}
|
|
public FROM(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.FROM, 0);
|
|
}
|
|
public INPUT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INPUT, 0);
|
|
}
|
|
public CREATION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CREATION, 0);
|
|
}
|
|
public CONSTRUCTOR(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0);
|
|
}
|
|
public QUERY(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.QUERY, 0);
|
|
}
|
|
public DOT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DOT, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_dependencyPort;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitDependencyPort) {
|
|
return visitor.visitDependencyPort(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PrimitiveListContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public LBRACK(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACK, 0)!;
|
|
}
|
|
public primitive(): PrimitiveContext[];
|
|
public primitive(i: number): PrimitiveContext | null;
|
|
public primitive(i?: number): PrimitiveContext[] | PrimitiveContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PrimitiveContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, PrimitiveContext);
|
|
}
|
|
public RBRACK(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACK, 0)!;
|
|
}
|
|
public COMMA(): antlr.TerminalNode[];
|
|
public COMMA(i: number): antlr.TerminalNode | null;
|
|
public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.COMMA);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.COMMA, i);
|
|
}
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_primitiveList;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitPrimitiveList) {
|
|
return visitor.visitPrimitiveList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PrimitiveContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public READ(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.READ, 0);
|
|
}
|
|
public WRITE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WRITE, 0);
|
|
}
|
|
public EDIT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.EDIT, 0);
|
|
}
|
|
public RESOLVE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RESOLVE, 0);
|
|
}
|
|
public CONNECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CONNECT, 0);
|
|
}
|
|
public DISCONNECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DISCONNECT, 0);
|
|
}
|
|
public WATCH_START(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH_START, 0);
|
|
}
|
|
public WATCH_STOP(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH_STOP, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_primitive;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitPrimitive) {
|
|
return visitor.visitPrimitive(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SharedAttachmentDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public SHARED(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SHARED, 0)!;
|
|
}
|
|
public attachmentDecl(): AttachmentDeclContext {
|
|
return this.getRuleContext(0, AttachmentDeclContext)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_sharedAttachmentDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitSharedAttachmentDecl) {
|
|
return visitor.visitSharedAttachmentDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class AttachmentDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public stateDecl(): StateDeclContext | null {
|
|
return this.getRuleContext(0, StateDeclContext);
|
|
}
|
|
public edgeDecl(): EdgeDeclContext | null {
|
|
return this.getRuleContext(0, EdgeDeclContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_attachmentDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitAttachmentDecl) {
|
|
return visitor.visitAttachmentDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class StateDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public STATE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.STATE, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public ON(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ON, 0)!;
|
|
}
|
|
public COLON(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0)!;
|
|
}
|
|
public valueType(): ValueTypeContext {
|
|
return this.getRuleContext(0, ValueTypeContext)!;
|
|
}
|
|
public POLICY(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.POLICY, 0)!;
|
|
}
|
|
public storagePolicy(): StoragePolicyContext {
|
|
return this.getRuleContext(0, StoragePolicyContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public DEFAULT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DEFAULT, 0);
|
|
}
|
|
public jsonLiteral(): JsonLiteralContext | null {
|
|
return this.getRuleContext(0, JsonLiteralContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_stateDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitStateDecl) {
|
|
return visitor.visitStateDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class StoragePolicyContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public REGISTER(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.REGISTER, 0);
|
|
}
|
|
public CRDT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CRDT, 0);
|
|
}
|
|
public LPAREN(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LPAREN, 0);
|
|
}
|
|
public valueType(): ValueTypeContext | null {
|
|
return this.getRuleContext(0, ValueTypeContext);
|
|
}
|
|
public RPAREN(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RPAREN, 0);
|
|
}
|
|
public JOURNAL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.JOURNAL, 0);
|
|
}
|
|
public jsonObject(): JsonObjectContext | null {
|
|
return this.getRuleContext(0, JsonObjectContext);
|
|
}
|
|
public SUBSCRIPTION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SUBSCRIPTION, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_storagePolicy;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitStoragePolicy) {
|
|
return visitor.visitStoragePolicy(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class EdgeDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public EDGE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.EDGE, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public edgeEndpoint(): EdgeEndpointContext[];
|
|
public edgeEndpoint(i: number): EdgeEndpointContext | null;
|
|
public edgeEndpoint(i?: number): EdgeEndpointContext[] | EdgeEndpointContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(EdgeEndpointContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, EdgeEndpointContext);
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_edgeDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitEdgeDecl) {
|
|
return visitor.visitEdgeDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class EdgeEndpointContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public targetConstraint(): TargetConstraintContext {
|
|
return this.getRuleContext(0, TargetConstraintContext)!;
|
|
}
|
|
public PROJECTION(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.PROJECTION, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext[];
|
|
public stringLiteral(i: number): StringLiteralContext | null;
|
|
public stringLiteral(i?: number): StringLiteralContext[] | StringLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, StringLiteralContext);
|
|
}
|
|
public cardinality(): CardinalityContext {
|
|
return this.getRuleContext(0, CardinalityContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public ORDERED(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ORDERED, 0);
|
|
}
|
|
public ON_DELETE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ON_DELETE, 0);
|
|
}
|
|
public RETAIN_OTHER(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RETAIN_OTHER, 0);
|
|
}
|
|
public KEYED(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.KEYED, 0);
|
|
}
|
|
public PUBLIC_TRAVERSAL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.PUBLIC_TRAVERSAL, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_edgeEndpoint;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitEdgeEndpoint) {
|
|
return visitor.visitEdgeEndpoint(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ConformanceDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public CONFORM(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.CONFORM, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public AS(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.AS, 0)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public typeParameters(): TypeParametersContext | null {
|
|
return this.getRuleContext(0, TypeParametersContext);
|
|
}
|
|
public conformanceSourceArguments(): ConformanceSourceArgumentsContext | null {
|
|
return this.getRuleContext(0, ConformanceSourceArgumentsContext);
|
|
}
|
|
public typeArguments(): TypeArgumentsContext | null {
|
|
return this.getRuleContext(0, TypeArgumentsContext);
|
|
}
|
|
public ID(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0);
|
|
}
|
|
public stringLiteral(): StringLiteralContext | null {
|
|
return this.getRuleContext(0, StringLiteralContext);
|
|
}
|
|
public SEMANTIC_MAJOR(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SEMANTIC_MAJOR, 0);
|
|
}
|
|
public INTEGER(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTEGER, 0);
|
|
}
|
|
public conformanceItem(): ConformanceItemContext[];
|
|
public conformanceItem(i: number): ConformanceItemContext | null;
|
|
public conformanceItem(i?: number): ConformanceItemContext[] | ConformanceItemContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ConformanceItemContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, ConformanceItemContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_conformanceDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitConformanceDecl) {
|
|
return visitor.visitConformanceDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ConformanceSourceArgumentsContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public typeArguments(): TypeArgumentsContext {
|
|
return this.getRuleContext(0, TypeArgumentsContext)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_conformanceSourceArguments;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitConformanceSourceArguments) {
|
|
return visitor.visitConformanceSourceArguments(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ConformanceItemContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public PRIVATE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.PRIVATE, 0);
|
|
}
|
|
public attachmentDecl(): AttachmentDeclContext | null {
|
|
return this.getRuleContext(0, AttachmentDeclContext);
|
|
}
|
|
public operationBindingDecl(): OperationBindingDeclContext | null {
|
|
return this.getRuleContext(0, OperationBindingDeclContext);
|
|
}
|
|
public stateFieldBindingDecl(): StateFieldBindingDeclContext | null {
|
|
return this.getRuleContext(0, StateFieldBindingDeclContext);
|
|
}
|
|
public initializationDecl(): InitializationDeclContext | null {
|
|
return this.getRuleContext(0, InitializationDeclContext);
|
|
}
|
|
public relationshipMaterializationDecl(): RelationshipMaterializationDeclContext | null {
|
|
return this.getRuleContext(0, RelationshipMaterializationDeclContext);
|
|
}
|
|
public moduleBindingDecl(): ModuleBindingDeclContext | null {
|
|
return this.getRuleContext(0, ModuleBindingDeclContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_conformanceItem;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitConformanceItem) {
|
|
return visitor.visitConformanceItem(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ModuleBindingDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public BIND(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.BIND, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public TO(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.TO, 0)!;
|
|
}
|
|
public DOT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.DOT, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_moduleBindingDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitModuleBindingDecl) {
|
|
return visitor.visitModuleBindingDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class InitializationDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public INITIALIZE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.INITIALIZE, 0)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public initializationField(): InitializationFieldContext[];
|
|
public initializationField(i: number): InitializationFieldContext | null;
|
|
public initializationField(i?: number): InitializationFieldContext[] | InitializationFieldContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(InitializationFieldContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, InitializationFieldContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_initializationDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitInitializationDecl) {
|
|
return visitor.visitInitializationDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class InitializationFieldContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public TO(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.TO, 0)!;
|
|
}
|
|
public STATE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.STATE, 0);
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public EDGE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.EDGE, 0);
|
|
}
|
|
public DOT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DOT, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_initializationField;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitInitializationField) {
|
|
return visitor.visitInitializationField(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class CreationOwnerMappingContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public interfaceType(): InterfaceTypeContext {
|
|
return this.getRuleContext(0, InterfaceTypeContext)!;
|
|
}
|
|
public FROM(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.FROM, 0)!;
|
|
}
|
|
public INPUT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.INPUT, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public DOT(): antlr.TerminalNode[];
|
|
public DOT(i: number): antlr.TerminalNode | null;
|
|
public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.DOT);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.DOT, i);
|
|
}
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_creationOwnerMapping;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitCreationOwnerMapping) {
|
|
return visitor.visitCreationOwnerMapping(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class StateFieldBindingDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public BIND(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.BIND, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public TO(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.TO, 0)!;
|
|
}
|
|
public STATE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.STATE, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_stateFieldBindingDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitStateFieldBindingDecl) {
|
|
return visitor.visitStateFieldBindingDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class RelationshipMaterializationDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public MATERIALIZE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.MATERIALIZE, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public IF(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.IF, 0)!;
|
|
}
|
|
public ABSENT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ABSENT, 0)!;
|
|
}
|
|
public USING(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.USING, 0)!;
|
|
}
|
|
public CONSTRUCTOR(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0)!;
|
|
}
|
|
public VIA(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.VIA, 0)!;
|
|
}
|
|
public EDGE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.EDGE, 0)!;
|
|
}
|
|
public DOT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.DOT, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_relationshipMaterializationDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitRelationshipMaterializationDecl) {
|
|
return visitor.visitRelationshipMaterializationDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class OperationBindingDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public BIND(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.BIND, 0)!;
|
|
}
|
|
public memberOperationRef(): MemberOperationRefContext {
|
|
return this.getRuleContext(0, MemberOperationRefContext)!;
|
|
}
|
|
public TO(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.TO, 0)!;
|
|
}
|
|
public operationProvider(): OperationProviderContext {
|
|
return this.getRuleContext(0, OperationProviderContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public QUERY_REASON(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.QUERY_REASON, 0);
|
|
}
|
|
public stringLiteral(): StringLiteralContext | null {
|
|
return this.getRuleContext(0, StringLiteralContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_operationBindingDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitOperationBindingDecl) {
|
|
return visitor.visitOperationBindingDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class MemberOperationRefContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public DOT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.DOT, 0)!;
|
|
}
|
|
public operationName(): OperationNameContext {
|
|
return this.getRuleContext(0, OperationNameContext)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_memberOperationRef;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitMemberOperationRef) {
|
|
return visitor.visitMemberOperationRef(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class OperationNameContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public identifier(): IdentifierContext | null {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public CALL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CALL, 0);
|
|
}
|
|
public GET(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.GET, 0);
|
|
}
|
|
public SET(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SET, 0);
|
|
}
|
|
public EDIT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.EDIT, 0);
|
|
}
|
|
public RESOLVE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RESOLVE, 0);
|
|
}
|
|
public CONNECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CONNECT, 0);
|
|
}
|
|
public DISCONNECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DISCONNECT, 0);
|
|
}
|
|
public WATCH_START(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH_START, 0);
|
|
}
|
|
public WATCH_STOP(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH_STOP, 0);
|
|
}
|
|
public SUBSCRIBE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SUBSCRIBE, 0);
|
|
}
|
|
public UNSUBSCRIBE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.UNSUBSCRIBE, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_operationName;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitOperationName) {
|
|
return visitor.visitOperationName(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class OperationProviderContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public LIFECYCLE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LIFECYCLE, 0);
|
|
}
|
|
public DOT(): antlr.TerminalNode[];
|
|
public DOT(i: number): antlr.TerminalNode | null;
|
|
public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.DOT);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.DOT, i);
|
|
}
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public JOURNAL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.JOURNAL, 0);
|
|
}
|
|
public SUBSCRIPTION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SUBSCRIPTION, 0);
|
|
}
|
|
public STATE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.STATE, 0);
|
|
}
|
|
public statePrimitive(): StatePrimitiveContext | null {
|
|
return this.getRuleContext(0, StatePrimitiveContext);
|
|
}
|
|
public EDGE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.EDGE, 0);
|
|
}
|
|
public edgePrimitive(): EdgePrimitiveContext | null {
|
|
return this.getRuleContext(0, EdgePrimitiveContext);
|
|
}
|
|
public INTERFACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
|
|
}
|
|
public memberOperationRef(): MemberOperationRefContext | null {
|
|
return this.getRuleContext(0, MemberOperationRefContext);
|
|
}
|
|
public typeArguments(): TypeArgumentsContext | null {
|
|
return this.getRuleContext(0, TypeArgumentsContext);
|
|
}
|
|
public PACKAGE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.PACKAGE, 0);
|
|
}
|
|
public dependencyBindingBlock(): DependencyBindingBlockContext | null {
|
|
return this.getRuleContext(0, DependencyBindingBlockContext);
|
|
}
|
|
public acceptanceBinding(): AcceptanceBindingContext | null {
|
|
return this.getRuleContext(0, AcceptanceBindingContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_operationProvider;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitOperationProvider) {
|
|
return visitor.visitOperationProvider(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class AcceptanceBindingContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public ACCEPT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ACCEPT, 0)!;
|
|
}
|
|
public dependencyBindingBlock(): DependencyBindingBlockContext {
|
|
return this.getRuleContext(0, DependencyBindingBlockContext)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_acceptanceBinding;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitAcceptanceBinding) {
|
|
return visitor.visitAcceptanceBinding(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class StatePrimitiveContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public READ(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.READ, 0);
|
|
}
|
|
public WRITE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WRITE, 0);
|
|
}
|
|
public EDIT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.EDIT, 0);
|
|
}
|
|
public WATCH_START(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH_START, 0);
|
|
}
|
|
public WATCH_STOP(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH_STOP, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_statePrimitive;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitStatePrimitive) {
|
|
return visitor.visitStatePrimitive(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class EdgePrimitiveContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public RESOLVE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RESOLVE, 0);
|
|
}
|
|
public CONNECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CONNECT, 0);
|
|
}
|
|
public DISCONNECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DISCONNECT, 0);
|
|
}
|
|
public WATCH_START(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH_START, 0);
|
|
}
|
|
public WATCH_STOP(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH_STOP, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_edgePrimitive;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitEdgePrimitive) {
|
|
return visitor.visitEdgePrimitive(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DependencyBindingBlockContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public WITH(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.WITH, 0)!;
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public dependencyBinding(): DependencyBindingContext[];
|
|
public dependencyBinding(i: number): DependencyBindingContext | null;
|
|
public dependencyBinding(i?: number): DependencyBindingContext[] | DependencyBindingContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(DependencyBindingContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, DependencyBindingContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_dependencyBindingBlock;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitDependencyBindingBlock) {
|
|
return visitor.visitDependencyBindingBlock(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DependencyBindingContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public TO(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.TO, 0)!;
|
|
}
|
|
public WORKSPACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WORKSPACE, 0);
|
|
}
|
|
public REFLECTION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.REFLECTION, 0);
|
|
}
|
|
public LBRACK(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LBRACK, 0);
|
|
}
|
|
public identifierList(): IdentifierListContext | null {
|
|
return this.getRuleContext(0, IdentifierListContext);
|
|
}
|
|
public RBRACK(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RBRACK, 0);
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public STATE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.STATE, 0);
|
|
}
|
|
public VIA(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.VIA, 0);
|
|
}
|
|
public EDGE(): antlr.TerminalNode[];
|
|
public EDGE(i: number): antlr.TerminalNode | null;
|
|
public EDGE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.EDGE);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.EDGE, i);
|
|
}
|
|
}
|
|
public DOT(): antlr.TerminalNode[];
|
|
public DOT(i: number): antlr.TerminalNode | null;
|
|
public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.DOT);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.DOT, i);
|
|
}
|
|
}
|
|
public INTERFACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
|
|
}
|
|
public typeArguments(): TypeArgumentsContext | null {
|
|
return this.getRuleContext(0, TypeArgumentsContext);
|
|
}
|
|
public FROM(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.FROM, 0);
|
|
}
|
|
public INPUT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INPUT, 0);
|
|
}
|
|
public CREATION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CREATION, 0);
|
|
}
|
|
public WITH(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WITH, 0);
|
|
}
|
|
public LBRACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0);
|
|
}
|
|
public RBRACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0);
|
|
}
|
|
public creationOwnerMapping(): CreationOwnerMappingContext[];
|
|
public creationOwnerMapping(i: number): CreationOwnerMappingContext | null;
|
|
public creationOwnerMapping(i?: number): CreationOwnerMappingContext[] | CreationOwnerMappingContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(CreationOwnerMappingContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, CreationOwnerMappingContext);
|
|
}
|
|
public CONSTRUCTOR(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0);
|
|
}
|
|
public QUERY(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.QUERY, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_dependencyBinding;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitDependencyBinding) {
|
|
return visitor.visitDependencyBinding(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ConstructorBindingDeclContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public CONSTRUCTOR(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0)!;
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext | null;
|
|
public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
public TO(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.TO, 0)!;
|
|
}
|
|
public DOT(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.DOT, 0)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public dependencyBindingBlock(): DependencyBindingBlockContext | null {
|
|
return this.getRuleContext(0, DependencyBindingBlockContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_constructorBindingDecl;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitConstructorBindingDecl) {
|
|
return visitor.visitConstructorBindingDecl(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ValueTypeContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public scalarType(): ScalarTypeContext | null {
|
|
return this.getRuleContext(0, ScalarTypeContext);
|
|
}
|
|
public UNIT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.UNIT, 0);
|
|
}
|
|
public WATCH_HANDLE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.WATCH_HANDLE, 0);
|
|
}
|
|
public MESSAGE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.MESSAGE, 0);
|
|
}
|
|
public stringLiteral(): StringLiteralContext | null {
|
|
return this.getRuleContext(0, StringLiteralContext);
|
|
}
|
|
public ATOM_REF(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ATOM_REF, 0);
|
|
}
|
|
public LT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LT, 0);
|
|
}
|
|
public identifier(): IdentifierContext | null {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public GT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.GT, 0);
|
|
}
|
|
public INTERFACE_REF(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACE_REF, 0);
|
|
}
|
|
public typeArguments(): TypeArgumentsContext | null {
|
|
return this.getRuleContext(0, TypeArgumentsContext);
|
|
}
|
|
public REF(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.REF, 0);
|
|
}
|
|
public OPTIONAL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.OPTIONAL, 0);
|
|
}
|
|
public valueType(): ValueTypeContext | null {
|
|
return this.getRuleContext(0, ValueTypeContext);
|
|
}
|
|
public LIST(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LIST, 0);
|
|
}
|
|
public RECORD(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RECORD, 0);
|
|
}
|
|
public LBRACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0);
|
|
}
|
|
public RBRACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0);
|
|
}
|
|
public recordField(): RecordFieldContext[];
|
|
public recordField(i: number): RecordFieldContext | null;
|
|
public recordField(i?: number): RecordFieldContext[] | RecordFieldContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(RecordFieldContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, RecordFieldContext);
|
|
}
|
|
public VARIANT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.VARIANT, 0);
|
|
}
|
|
public ID(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0);
|
|
}
|
|
public variantCase(): VariantCaseContext[];
|
|
public variantCase(i: number): VariantCaseContext | null;
|
|
public variantCase(i?: number): VariantCaseContext[] | VariantCaseContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(VariantCaseContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, VariantCaseContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_valueType;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitValueType) {
|
|
return visitor.visitValueType(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class RecordFieldContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public COLON(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0)!;
|
|
}
|
|
public valueType(): ValueTypeContext {
|
|
return this.getRuleContext(0, ValueTypeContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_recordField;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitRecordField) {
|
|
return visitor.visitRecordField(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class VariantCaseContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext)!;
|
|
}
|
|
public ID(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.ID, 0)!;
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public COLON(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0)!;
|
|
}
|
|
public valueType(): ValueTypeContext {
|
|
return this.getRuleContext(0, ValueTypeContext)!;
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_variantCase;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitVariantCase) {
|
|
return visitor.visitVariantCase(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ScalarTypeContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public BOOL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.BOOL, 0);
|
|
}
|
|
public BYTES(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.BYTES, 0);
|
|
}
|
|
public DOUBLE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DOUBLE, 0);
|
|
}
|
|
public INT32(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INT32, 0);
|
|
}
|
|
public INT64(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INT64, 0);
|
|
}
|
|
public STRING(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.STRING, 0);
|
|
}
|
|
public UINT32(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.UINT32, 0);
|
|
}
|
|
public UINT64(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.UINT64, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_scalarType;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitScalarType) {
|
|
return visitor.visitScalarType(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class CardinalityContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public OPTIONAL_ONE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.OPTIONAL_ONE, 0);
|
|
}
|
|
public EXACTLY_ONE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.EXACTLY_ONE, 0);
|
|
}
|
|
public MANY(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.MANY, 0);
|
|
}
|
|
public MANY_UNIQUE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.MANY_UNIQUE, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_cardinality;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitCardinality) {
|
|
return visitor.visitCardinality(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class JsonLiteralContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public stringLiteral(): StringLiteralContext | null {
|
|
return this.getRuleContext(0, StringLiteralContext);
|
|
}
|
|
public INTEGER(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTEGER, 0);
|
|
}
|
|
public JSON_NUMBER(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.JSON_NUMBER, 0);
|
|
}
|
|
public TRUE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.TRUE, 0);
|
|
}
|
|
public FALSE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.FALSE, 0);
|
|
}
|
|
public NULL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.NULL, 0);
|
|
}
|
|
public jsonObject(): JsonObjectContext | null {
|
|
return this.getRuleContext(0, JsonObjectContext);
|
|
}
|
|
public jsonArray(): JsonArrayContext | null {
|
|
return this.getRuleContext(0, JsonArrayContext);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_jsonLiteral;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitJsonLiteral) {
|
|
return visitor.visitJsonLiteral(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class JsonObjectContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public LBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACE, 0)!;
|
|
}
|
|
public RBRACE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACE, 0)!;
|
|
}
|
|
public jsonMember(): JsonMemberContext[];
|
|
public jsonMember(i: number): JsonMemberContext | null;
|
|
public jsonMember(i?: number): JsonMemberContext[] | JsonMemberContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(JsonMemberContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, JsonMemberContext);
|
|
}
|
|
public COMMA(): antlr.TerminalNode[];
|
|
public COMMA(i: number): antlr.TerminalNode | null;
|
|
public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.COMMA);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.COMMA, i);
|
|
}
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_jsonObject;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitJsonObject) {
|
|
return visitor.visitJsonObject(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class JsonMemberContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public stringLiteral(): StringLiteralContext {
|
|
return this.getRuleContext(0, StringLiteralContext)!;
|
|
}
|
|
public COLON(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.COLON, 0)!;
|
|
}
|
|
public jsonLiteral(): JsonLiteralContext {
|
|
return this.getRuleContext(0, JsonLiteralContext)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_jsonMember;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitJsonMember) {
|
|
return visitor.visitJsonMember(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class JsonArrayContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public LBRACK(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.LBRACK, 0)!;
|
|
}
|
|
public RBRACK(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.RBRACK, 0)!;
|
|
}
|
|
public jsonLiteral(): JsonLiteralContext[];
|
|
public jsonLiteral(i: number): JsonLiteralContext | null;
|
|
public jsonLiteral(i?: number): JsonLiteralContext[] | JsonLiteralContext | null {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(JsonLiteralContext);
|
|
}
|
|
|
|
return this.getRuleContext(i, JsonLiteralContext);
|
|
}
|
|
public COMMA(): antlr.TerminalNode[];
|
|
public COMMA(i: number): antlr.TerminalNode | null;
|
|
public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(QuixosCapabilityParser.COMMA);
|
|
} else {
|
|
return this.getToken(QuixosCapabilityParser.COMMA, i);
|
|
}
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_jsonArray;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitJsonArray) {
|
|
return visitor.visitJsonArray(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IdentifierContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public IDENTIFIER(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.IDENTIFIER, 0);
|
|
}
|
|
public START(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.START, 0);
|
|
}
|
|
public STOP(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.STOP, 0);
|
|
}
|
|
public EDIT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.EDIT, 0);
|
|
}
|
|
public CREATION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CREATION, 0);
|
|
}
|
|
public INITIALIZE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INITIALIZE, 0);
|
|
}
|
|
public EXECUTION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.EXECUTION, 0);
|
|
}
|
|
public SNAPSHOT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SNAPSHOT, 0);
|
|
}
|
|
public TRANSACTION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.TRANSACTION, 0);
|
|
}
|
|
public REMOTE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.REMOTE, 0);
|
|
}
|
|
public TARGETS(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.TARGETS, 0);
|
|
}
|
|
public PORTABLE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.PORTABLE, 0);
|
|
}
|
|
public REPLICA(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.REPLICA, 0);
|
|
}
|
|
public LOCAL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.LOCAL, 0);
|
|
}
|
|
public FROM(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.FROM, 0);
|
|
}
|
|
public REGISTER(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.REGISTER, 0);
|
|
}
|
|
public INTERFACES(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACES, 0);
|
|
}
|
|
public REFLECTION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.REFLECTION, 0);
|
|
}
|
|
public SOURCE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SOURCE, 0);
|
|
}
|
|
public QUERY(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.QUERY, 0);
|
|
}
|
|
public SPECIALIZE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SPECIALIZE, 0);
|
|
}
|
|
public ROOT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ROOT, 0);
|
|
}
|
|
public DOCUMENT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DOCUMENT, 0);
|
|
}
|
|
public FRAGMENTS(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.FRAGMENTS, 0);
|
|
}
|
|
public FRAGMENT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.FRAGMENT, 0);
|
|
}
|
|
public VIEW(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.VIEW, 0);
|
|
}
|
|
public MAX(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.MAX, 0);
|
|
}
|
|
public ALLOW(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ALLOW, 0);
|
|
}
|
|
public POLL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.POLL, 0);
|
|
}
|
|
public RPC(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RPC, 0);
|
|
}
|
|
public QUERYABLE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.QUERYABLE, 0);
|
|
}
|
|
public RESULT_BYTES(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RESULT_BYTES, 0);
|
|
}
|
|
public RPC_CALLS(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.RPC_CALLS, 0);
|
|
}
|
|
public DEADLINE_MS(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.DEADLINE_MS, 0);
|
|
}
|
|
public PRESENTATION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.PRESENTATION, 0);
|
|
}
|
|
public SUBJECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SUBJECT, 0);
|
|
}
|
|
public MESSAGE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.MESSAGE, 0);
|
|
}
|
|
public JOURNAL(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.JOURNAL, 0);
|
|
}
|
|
public SUBSCRIPTION(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SUBSCRIPTION, 0);
|
|
}
|
|
public CONNECT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CONNECT, 0);
|
|
}
|
|
public FOR(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.FOR, 0);
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_identifier;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitIdentifier) {
|
|
return visitor.visitIdentifier(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class StringLiteralContext extends antlr.ParserRuleContext {
|
|
public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
public STRING_LITERAL(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.STRING_LITERAL, 0)!;
|
|
}
|
|
public override get ruleIndex(): number {
|
|
return QuixosCapabilityParser.RULE_stringLiteral;
|
|
}
|
|
public override accept<Result>(visitor: QuixosCapabilityVisitor<Result>): Result | null {
|
|
if (visitor.visitStringLiteral) {
|
|
return visitor.visitStringLiteral(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|