Timothy J. Aveni
5838 lines
219 KiB
TypeScript
5838 lines
219 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 WORKSPACE = 1;
|
|
public static readonly FRAGMENT = 2;
|
|
public static readonly IMPORT = 3;
|
|
public static readonly EXTERNAL = 4;
|
|
public static readonly ATOM = 5;
|
|
public static readonly INTERFACE = 6;
|
|
public static readonly INTERFACES = 7;
|
|
public static readonly PACKAGE = 8;
|
|
public static readonly VALUE = 9;
|
|
public static readonly RELATION = 10;
|
|
public static readonly OPERATION = 11;
|
|
public static readonly FUNCTION = 12;
|
|
public static readonly CONSTRUCTOR = 13;
|
|
public static readonly CONSTRUCTS = 14;
|
|
public static readonly INPUT = 15;
|
|
public static readonly CONFORM = 16;
|
|
public static readonly AS = 17;
|
|
public static readonly BIND = 18;
|
|
public static readonly TO = 19;
|
|
public static readonly PRIVATE = 20;
|
|
public static readonly SHARED = 21;
|
|
public static readonly STATE = 22;
|
|
public static readonly EDGE = 23;
|
|
public static readonly PROJECTION = 24;
|
|
public static readonly WITH = 25;
|
|
public static readonly USING = 26;
|
|
public static readonly VIA = 27;
|
|
public static readonly MATERIALIZE = 28;
|
|
public static readonly IF = 29;
|
|
public static readonly ABSENT = 30;
|
|
public static readonly ON = 31;
|
|
public static readonly POLICY = 32;
|
|
public static readonly DEFAULT = 33;
|
|
public static readonly SOURCE = 34;
|
|
public static readonly REPOSITORY = 35;
|
|
public static readonly COMMIT = 36;
|
|
public static readonly REVISION = 37;
|
|
public static readonly ID = 38;
|
|
public static readonly DOC = 39;
|
|
public static readonly MODE = 40;
|
|
public static readonly EMITS = 41;
|
|
public static readonly RECEIVER = 42;
|
|
public static readonly REQUIRES = 43;
|
|
public static readonly ANY = 44;
|
|
public static readonly GET = 45;
|
|
public static readonly SET = 46;
|
|
public static readonly WATCH = 47;
|
|
public static readonly START = 48;
|
|
public static readonly STOP = 49;
|
|
public static readonly READ = 50;
|
|
public static readonly WRITE = 51;
|
|
public static readonly RESOLVE = 52;
|
|
public static readonly CONNECT = 53;
|
|
public static readonly DISCONNECT = 54;
|
|
public static readonly CALL = 55;
|
|
public static readonly WATCH_START = 56;
|
|
public static readonly WATCH_STOP = 57;
|
|
public static readonly SUBSCRIBE = 58;
|
|
public static readonly UNSUBSCRIBE = 59;
|
|
public static readonly OPTIMISTIC_REGISTER = 60;
|
|
public static readonly CRDT = 61;
|
|
public static readonly OPTIONAL_ONE = 62;
|
|
public static readonly EXACTLY_ONE = 63;
|
|
public static readonly MANY_UNIQUE = 64;
|
|
public static readonly MANY = 65;
|
|
public static readonly ORDERED = 66;
|
|
public static readonly UNIT = 67;
|
|
public static readonly WATCH_HANDLE = 68;
|
|
public static readonly MESSAGE = 69;
|
|
public static readonly ATOM_REF = 70;
|
|
public static readonly INTERFACE_REF = 71;
|
|
public static readonly OPTIONAL = 72;
|
|
public static readonly LIST = 73;
|
|
public static readonly BOOL = 74;
|
|
public static readonly BYTES = 75;
|
|
public static readonly DOUBLE = 76;
|
|
public static readonly INT32 = 77;
|
|
public static readonly INT64 = 78;
|
|
public static readonly STRING = 79;
|
|
public static readonly UINT32 = 80;
|
|
public static readonly UINT64 = 81;
|
|
public static readonly TRUE = 82;
|
|
public static readonly FALSE = 83;
|
|
public static readonly NULL = 84;
|
|
public static readonly ARROW = 85;
|
|
public static readonly COLON = 86;
|
|
public static readonly SEMI = 87;
|
|
public static readonly COMMA = 88;
|
|
public static readonly DOT = 89;
|
|
public static readonly LBRACE = 90;
|
|
public static readonly RBRACE = 91;
|
|
public static readonly LBRACK = 92;
|
|
public static readonly RBRACK = 93;
|
|
public static readonly LPAREN = 94;
|
|
public static readonly RPAREN = 95;
|
|
public static readonly LT = 96;
|
|
public static readonly GT = 97;
|
|
public static readonly INTEGER = 98;
|
|
public static readonly JSON_NUMBER = 99;
|
|
public static readonly IDENTIFIER = 100;
|
|
public static readonly STRING_LITERAL = 101;
|
|
public static readonly LINE_COMMENT = 102;
|
|
public static readonly BLOCK_COMMENT = 103;
|
|
public static readonly WS = 104;
|
|
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_resourcePreamble = 8;
|
|
public static readonly RULE_atomDecl = 9;
|
|
public static readonly RULE_interfaceResourceDecl = 10;
|
|
public static readonly RULE_interfaceMember = 11;
|
|
public static readonly RULE_operationMember = 12;
|
|
public static readonly RULE_valueMember = 13;
|
|
public static readonly RULE_valueMemberOperation = 14;
|
|
public static readonly RULE_relationshipMember = 15;
|
|
public static readonly RULE_relationshipOperation = 16;
|
|
public static readonly RULE_targetConstraint = 17;
|
|
public static readonly RULE_packageResourceDecl = 18;
|
|
public static readonly RULE_packageExport = 19;
|
|
public static readonly RULE_packageOperationExport = 20;
|
|
public static readonly RULE_packageFunctionExport = 21;
|
|
public static readonly RULE_packageConstructorExport = 22;
|
|
public static readonly RULE_eventClause = 23;
|
|
public static readonly RULE_operationMode = 24;
|
|
public static readonly RULE_receiverRequirement = 25;
|
|
public static readonly RULE_identifierList = 26;
|
|
public static readonly RULE_dependencyBlock = 27;
|
|
public static readonly RULE_dependencyPort = 28;
|
|
public static readonly RULE_primitiveList = 29;
|
|
public static readonly RULE_primitive = 30;
|
|
public static readonly RULE_sharedAttachmentDecl = 31;
|
|
public static readonly RULE_attachmentDecl = 32;
|
|
public static readonly RULE_stateDecl = 33;
|
|
public static readonly RULE_storagePolicy = 34;
|
|
public static readonly RULE_edgeDecl = 35;
|
|
public static readonly RULE_edgeEndpoint = 36;
|
|
public static readonly RULE_conformanceDecl = 37;
|
|
public static readonly RULE_conformanceItem = 38;
|
|
public static readonly RULE_relationshipMaterializationDecl = 39;
|
|
public static readonly RULE_operationBindingDecl = 40;
|
|
public static readonly RULE_memberOperationRef = 41;
|
|
public static readonly RULE_operationName = 42;
|
|
public static readonly RULE_operationProvider = 43;
|
|
public static readonly RULE_statePrimitive = 44;
|
|
public static readonly RULE_edgePrimitive = 45;
|
|
public static readonly RULE_dependencyBindingBlock = 46;
|
|
public static readonly RULE_dependencyBinding = 47;
|
|
public static readonly RULE_constructorBindingDecl = 48;
|
|
public static readonly RULE_valueType = 49;
|
|
public static readonly RULE_scalarType = 50;
|
|
public static readonly RULE_cardinality = 51;
|
|
public static readonly RULE_jsonLiteral = 52;
|
|
public static readonly RULE_jsonObject = 53;
|
|
public static readonly RULE_jsonMember = 54;
|
|
public static readonly RULE_jsonArray = 55;
|
|
public static readonly RULE_identifier = 56;
|
|
public static readonly RULE_stringLiteral = 57;
|
|
|
|
public static readonly literalNames = [
|
|
null, "'workspace'", "'fragment'", "'import'", "'external'", "'atom'",
|
|
"'interface'", "'interfaces'", "'package'", "'value'", "'relation'",
|
|
"'operation'", "'function'", "'constructor'", "'constructs'", "'input'",
|
|
"'conform'", "'as'", "'bind'", "'to'", "'private'", "'shared'",
|
|
"'state'", "'edge'", "'projection'", "'with'", "'using'", "'via'",
|
|
"'materialize'", "'if'", "'absent'", "'on'", "'policy'", "'default'",
|
|
"'source'", "'repository'", "'commit'", "'revision'", "'id'", "'doc'",
|
|
"'mode'", "'emits'", "'receiver'", "'requires'", "'any'", "'get'",
|
|
"'set'", "'watch'", "'start'", "'stop'", "'read'", "'write'", "'resolve'",
|
|
"'connect'", "'disconnect'", "'call'", "'watch-start'", "'watch-stop'",
|
|
"'subscribe'", "'unsubscribe'", "'optimistic-register'", "'crdt'",
|
|
"'optional-one'", "'exactly-one'", "'many-unique'", "'many'", "'ordered'",
|
|
"'unit'", "'watch-handle'", "'message'", "'atom-ref'", "'interface-ref'",
|
|
"'optional'", "'list'", "'bool'", "'bytes'", "'double'", "'int32'",
|
|
"'int64'", "'string'", "'uint32'", "'uint64'", "'true'", "'false'",
|
|
"'null'", "'->'", "':'", "';'", "','", "'.'", "'{'", "'}'", "'['",
|
|
"']'", "'('", "')'", "'<'", "'>'"
|
|
];
|
|
|
|
public static readonly symbolicNames = [
|
|
null, "WORKSPACE", "FRAGMENT", "IMPORT", "EXTERNAL", "ATOM", "INTERFACE",
|
|
"INTERFACES", "PACKAGE", "VALUE", "RELATION", "OPERATION", "FUNCTION",
|
|
"CONSTRUCTOR", "CONSTRUCTS", "INPUT", "CONFORM", "AS", "BIND", "TO",
|
|
"PRIVATE", "SHARED", "STATE", "EDGE", "PROJECTION", "WITH", "USING",
|
|
"VIA", "MATERIALIZE", "IF", "ABSENT", "ON", "POLICY", "DEFAULT",
|
|
"SOURCE", "REPOSITORY", "COMMIT", "REVISION", "ID", "DOC", "MODE",
|
|
"EMITS", "RECEIVER", "REQUIRES", "ANY", "GET", "SET", "WATCH", "START",
|
|
"STOP", "READ", "WRITE", "RESOLVE", "CONNECT", "DISCONNECT", "CALL",
|
|
"WATCH_START", "WATCH_STOP", "SUBSCRIBE", "UNSUBSCRIBE", "OPTIMISTIC_REGISTER",
|
|
"CRDT", "OPTIONAL_ONE", "EXACTLY_ONE", "MANY_UNIQUE", "MANY", "ORDERED",
|
|
"UNIT", "WATCH_HANDLE", "MESSAGE", "ATOM_REF", "INTERFACE_REF",
|
|
"OPTIONAL", "LIST", "BOOL", "BYTES", "DOUBLE", "INT32", "INT64",
|
|
"STRING", "UINT32", "UINT64", "TRUE", "FALSE", "NULL", "ARROW",
|
|
"COLON", "SEMI", "COMMA", "DOT", "LBRACE", "RBRACE", "LBRACK", "RBRACK",
|
|
"LPAREN", "RPAREN", "LT", "GT", "INTEGER", "JSON_NUMBER", "IDENTIFIER",
|
|
"STRING_LITERAL", "LINE_COMMENT", "BLOCK_COMMENT", "WS"
|
|
];
|
|
public static readonly ruleNames = [
|
|
"document", "fragmentDecl", "sourceImportDecl", "workspaceDecl",
|
|
"workspaceItem", "resourceImportDecl", "externalAtomDecl", "externalInterfaceDecl",
|
|
"resourcePreamble", "atomDecl", "interfaceResourceDecl", "interfaceMember",
|
|
"operationMember", "valueMember", "valueMemberOperation", "relationshipMember",
|
|
"relationshipOperation", "targetConstraint", "packageResourceDecl",
|
|
"packageExport", "packageOperationExport", "packageFunctionExport",
|
|
"packageConstructorExport", "eventClause", "operationMode", "receiverRequirement",
|
|
"identifierList", "dependencyBlock", "dependencyPort", "primitiveList",
|
|
"primitive", "sharedAttachmentDecl", "attachmentDecl", "stateDecl",
|
|
"storagePolicy", "edgeDecl", "edgeEndpoint", "conformanceDecl",
|
|
"conformanceItem", "relationshipMaterializationDecl", "operationBindingDecl",
|
|
"memberOperationRef", "operationName", "operationProvider", "statePrimitive",
|
|
"edgePrimitive", "dependencyBindingBlock", "dependencyBinding",
|
|
"constructorBindingDecl", "valueType", "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 = 128;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 0, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 116;
|
|
this.workspaceDecl();
|
|
this.state = 117;
|
|
this.match(QuixosCapabilityParser.EOF);
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 119;
|
|
this.interfaceResourceDecl();
|
|
this.state = 120;
|
|
this.match(QuixosCapabilityParser.EOF);
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 122;
|
|
this.packageResourceDecl();
|
|
this.state = 123;
|
|
this.match(QuixosCapabilityParser.EOF);
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 125;
|
|
this.fragmentDecl();
|
|
this.state = 126;
|
|
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 = 130;
|
|
this.match(QuixosCapabilityParser.FRAGMENT);
|
|
this.state = 131;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 135;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2170920) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 132;
|
|
this.workspaceItem();
|
|
}
|
|
}
|
|
this.state = 137;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 138;
|
|
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 = 140;
|
|
this.match(QuixosCapabilityParser.IMPORT);
|
|
this.state = 141;
|
|
this.stringLiteral();
|
|
this.state = 142;
|
|
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 = 144;
|
|
this.match(QuixosCapabilityParser.WORKSPACE);
|
|
this.state = 145;
|
|
this.identifier();
|
|
this.state = 146;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 147;
|
|
this.stringLiteral();
|
|
this.state = 148;
|
|
this.match(QuixosCapabilityParser.REVISION);
|
|
this.state = 149;
|
|
this.stringLiteral();
|
|
this.state = 150;
|
|
this.match(QuixosCapabilityParser.COMMIT);
|
|
this.state = 151;
|
|
this.stringLiteral();
|
|
this.state = 152;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 156;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2170920) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 153;
|
|
this.workspaceItem();
|
|
}
|
|
}
|
|
this.state = 158;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 159;
|
|
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 = 167;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 161;
|
|
this.sourceImportDecl();
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 162;
|
|
this.atomDecl();
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 163;
|
|
this.resourceImportDecl();
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 164;
|
|
this.sharedAttachmentDecl();
|
|
}
|
|
break;
|
|
case 5:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 165;
|
|
this.conformanceDecl();
|
|
}
|
|
break;
|
|
case 6:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 166;
|
|
this.constructorBindingDecl();
|
|
}
|
|
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 = 179;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 4, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 169;
|
|
this.match(QuixosCapabilityParser.IMPORT);
|
|
this.state = 170;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 171;
|
|
this.identifier();
|
|
this.state = 172;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 174;
|
|
this.match(QuixosCapabilityParser.IMPORT);
|
|
this.state = 175;
|
|
this.match(QuixosCapabilityParser.PACKAGE);
|
|
this.state = 176;
|
|
this.identifier();
|
|
this.state = 177;
|
|
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 = 181;
|
|
this.match(QuixosCapabilityParser.EXTERNAL);
|
|
this.state = 182;
|
|
this.match(QuixosCapabilityParser.ATOM);
|
|
this.state = 183;
|
|
this.identifier();
|
|
this.state = 184;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 185;
|
|
this.stringLiteral();
|
|
this.state = 186;
|
|
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 = 188;
|
|
this.match(QuixosCapabilityParser.EXTERNAL);
|
|
this.state = 189;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 190;
|
|
this.identifier();
|
|
this.state = 191;
|
|
this.match(QuixosCapabilityParser.REVISION);
|
|
this.state = 192;
|
|
this.stringLiteral();
|
|
this.state = 193;
|
|
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, 16, QuixosCapabilityParser.RULE_resourcePreamble);
|
|
try {
|
|
this.state = 198;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 5, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 195;
|
|
this.resourceImportDecl();
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 196;
|
|
this.externalAtomDecl();
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 197;
|
|
this.externalInterfaceDecl();
|
|
}
|
|
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, 18, QuixosCapabilityParser.RULE_atomDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 200;
|
|
this.match(QuixosCapabilityParser.ATOM);
|
|
this.state = 201;
|
|
this.identifier();
|
|
this.state = 202;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 203;
|
|
this.stringLiteral();
|
|
this.state = 206;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 39) {
|
|
{
|
|
this.state = 204;
|
|
this.match(QuixosCapabilityParser.DOC);
|
|
this.state = 205;
|
|
this.stringLiteral();
|
|
}
|
|
}
|
|
|
|
this.state = 208;
|
|
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, 20, QuixosCapabilityParser.RULE_interfaceResourceDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 213;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 3 || _la === 4) {
|
|
{
|
|
{
|
|
this.state = 210;
|
|
this.resourcePreamble();
|
|
}
|
|
}
|
|
this.state = 215;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 216;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 217;
|
|
this.identifier();
|
|
this.state = 218;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 219;
|
|
this.stringLiteral();
|
|
this.state = 220;
|
|
this.match(QuixosCapabilityParser.REVISION);
|
|
this.state = 221;
|
|
this.stringLiteral();
|
|
this.state = 222;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 226;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 3584) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 223;
|
|
this.interfaceMember();
|
|
}
|
|
}
|
|
this.state = 228;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 229;
|
|
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 interfaceMember(): InterfaceMemberContext {
|
|
let localContext = new InterfaceMemberContext(this.context, this.state);
|
|
this.enterRule(localContext, 22, QuixosCapabilityParser.RULE_interfaceMember);
|
|
try {
|
|
this.state = 234;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.VALUE:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 231;
|
|
this.valueMember();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.RELATION:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 232;
|
|
this.relationshipMember();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.OPERATION:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 233;
|
|
this.operationMember();
|
|
}
|
|
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 operationMember(): OperationMemberContext {
|
|
let localContext = new OperationMemberContext(this.context, this.state);
|
|
this.enterRule(localContext, 24, QuixosCapabilityParser.RULE_operationMember);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 236;
|
|
this.match(QuixosCapabilityParser.OPERATION);
|
|
this.state = 237;
|
|
this.identifier();
|
|
this.state = 238;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 239;
|
|
this.stringLiteral();
|
|
this.state = 240;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 241;
|
|
this.valueType();
|
|
this.state = 242;
|
|
this.match(QuixosCapabilityParser.ARROW);
|
|
this.state = 243;
|
|
this.valueType();
|
|
this.state = 244;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 245;
|
|
this.match(QuixosCapabilityParser.CALL);
|
|
this.state = 246;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 247;
|
|
this.stringLiteral();
|
|
this.state = 248;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
this.state = 249;
|
|
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, 26, QuixosCapabilityParser.RULE_valueMember);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 251;
|
|
this.match(QuixosCapabilityParser.VALUE);
|
|
this.state = 252;
|
|
this.identifier();
|
|
this.state = 253;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 254;
|
|
this.stringLiteral();
|
|
this.state = 255;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 256;
|
|
this.valueType();
|
|
this.state = 257;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 261;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (((((_la - 45)) & ~0x1F) === 0 && ((1 << (_la - 45)) & 7) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 258;
|
|
this.valueMemberOperation();
|
|
}
|
|
}
|
|
this.state = 263;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 264;
|
|
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, 28, QuixosCapabilityParser.RULE_valueMemberOperation);
|
|
try {
|
|
this.state = 285;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.GET:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 266;
|
|
this.match(QuixosCapabilityParser.GET);
|
|
this.state = 267;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 268;
|
|
this.stringLiteral();
|
|
this.state = 269;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.SET:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 271;
|
|
this.match(QuixosCapabilityParser.SET);
|
|
this.state = 272;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 273;
|
|
this.stringLiteral();
|
|
this.state = 274;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.WATCH:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 276;
|
|
this.match(QuixosCapabilityParser.WATCH);
|
|
this.state = 277;
|
|
this.match(QuixosCapabilityParser.START);
|
|
this.state = 278;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 279;
|
|
this.stringLiteral();
|
|
this.state = 280;
|
|
this.match(QuixosCapabilityParser.STOP);
|
|
this.state = 281;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 282;
|
|
this.stringLiteral();
|
|
this.state = 283;
|
|
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, 30, QuixosCapabilityParser.RULE_relationshipMember);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 287;
|
|
this.match(QuixosCapabilityParser.RELATION);
|
|
this.state = 288;
|
|
this.identifier();
|
|
this.state = 289;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 290;
|
|
this.stringLiteral();
|
|
this.state = 291;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 292;
|
|
this.cardinality();
|
|
this.state = 293;
|
|
this.targetConstraint();
|
|
this.state = 295;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 66) {
|
|
{
|
|
this.state = 294;
|
|
this.match(QuixosCapabilityParser.ORDERED);
|
|
}
|
|
}
|
|
|
|
this.state = 297;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 301;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (((((_la - 47)) & ~0x1F) === 0 && ((1 << (_la - 47)) & 225) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 298;
|
|
this.relationshipOperation();
|
|
}
|
|
}
|
|
this.state = 303;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 304;
|
|
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 relationshipOperation(): RelationshipOperationContext {
|
|
let localContext = new RelationshipOperationContext(this.context, this.state);
|
|
this.enterRule(localContext, 32, QuixosCapabilityParser.RULE_relationshipOperation);
|
|
try {
|
|
this.state = 330;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.RESOLVE:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 306;
|
|
this.match(QuixosCapabilityParser.RESOLVE);
|
|
this.state = 307;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 308;
|
|
this.stringLiteral();
|
|
this.state = 309;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.CONNECT:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 311;
|
|
this.match(QuixosCapabilityParser.CONNECT);
|
|
this.state = 312;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 313;
|
|
this.stringLiteral();
|
|
this.state = 314;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.DISCONNECT:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 316;
|
|
this.match(QuixosCapabilityParser.DISCONNECT);
|
|
this.state = 317;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 318;
|
|
this.stringLiteral();
|
|
this.state = 319;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.WATCH:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 321;
|
|
this.match(QuixosCapabilityParser.WATCH);
|
|
this.state = 322;
|
|
this.match(QuixosCapabilityParser.START);
|
|
this.state = 323;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 324;
|
|
this.stringLiteral();
|
|
this.state = 325;
|
|
this.match(QuixosCapabilityParser.STOP);
|
|
this.state = 326;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 327;
|
|
this.stringLiteral();
|
|
this.state = 328;
|
|
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, 34, QuixosCapabilityParser.RULE_targetConstraint);
|
|
try {
|
|
this.state = 336;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.ATOM:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 332;
|
|
this.match(QuixosCapabilityParser.ATOM);
|
|
this.state = 333;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.INTERFACE:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 334;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 335;
|
|
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, 36, QuixosCapabilityParser.RULE_packageResourceDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 341;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 3 || _la === 4) {
|
|
{
|
|
{
|
|
this.state = 338;
|
|
this.resourcePreamble();
|
|
}
|
|
}
|
|
this.state = 343;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 344;
|
|
this.match(QuixosCapabilityParser.PACKAGE);
|
|
this.state = 345;
|
|
this.identifier();
|
|
this.state = 346;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 347;
|
|
this.stringLiteral();
|
|
this.state = 348;
|
|
this.match(QuixosCapabilityParser.REVISION);
|
|
this.state = 349;
|
|
this.stringLiteral();
|
|
this.state = 350;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 354;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 14336) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 351;
|
|
this.packageExport();
|
|
}
|
|
}
|
|
this.state = 356;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 357;
|
|
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, 38, QuixosCapabilityParser.RULE_packageExport);
|
|
try {
|
|
this.state = 362;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.OPERATION:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 359;
|
|
this.packageOperationExport();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.FUNCTION:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 360;
|
|
this.packageFunctionExport();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.CONSTRUCTOR:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 361;
|
|
this.packageConstructorExport();
|
|
}
|
|
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 packageOperationExport(): PackageOperationExportContext {
|
|
let localContext = new PackageOperationExportContext(this.context, this.state);
|
|
this.enterRule(localContext, 40, QuixosCapabilityParser.RULE_packageOperationExport);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 364;
|
|
this.match(QuixosCapabilityParser.OPERATION);
|
|
this.state = 365;
|
|
this.identifier();
|
|
this.state = 366;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 367;
|
|
this.stringLiteral();
|
|
this.state = 368;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 369;
|
|
this.valueType();
|
|
this.state = 370;
|
|
this.match(QuixosCapabilityParser.ARROW);
|
|
this.state = 371;
|
|
this.valueType();
|
|
this.state = 372;
|
|
this.match(QuixosCapabilityParser.MODE);
|
|
this.state = 373;
|
|
this.operationMode();
|
|
this.state = 375;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 41) {
|
|
{
|
|
this.state = 374;
|
|
this.eventClause();
|
|
}
|
|
}
|
|
|
|
this.state = 377;
|
|
this.match(QuixosCapabilityParser.RECEIVER);
|
|
this.state = 378;
|
|
this.receiverRequirement();
|
|
this.state = 380;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 43) {
|
|
{
|
|
this.state = 379;
|
|
this.dependencyBlock();
|
|
}
|
|
}
|
|
|
|
this.state = 382;
|
|
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, 42, QuixosCapabilityParser.RULE_packageFunctionExport);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 384;
|
|
this.match(QuixosCapabilityParser.FUNCTION);
|
|
this.state = 385;
|
|
this.identifier();
|
|
this.state = 386;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 387;
|
|
this.stringLiteral();
|
|
this.state = 388;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 389;
|
|
this.valueType();
|
|
this.state = 390;
|
|
this.match(QuixosCapabilityParser.ARROW);
|
|
this.state = 391;
|
|
this.valueType();
|
|
this.state = 393;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 43) {
|
|
{
|
|
this.state = 392;
|
|
this.dependencyBlock();
|
|
}
|
|
}
|
|
|
|
this.state = 395;
|
|
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 packageConstructorExport(): PackageConstructorExportContext {
|
|
let localContext = new PackageConstructorExportContext(this.context, this.state);
|
|
this.enterRule(localContext, 44, QuixosCapabilityParser.RULE_packageConstructorExport);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 397;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTOR);
|
|
this.state = 398;
|
|
this.identifier();
|
|
this.state = 399;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 400;
|
|
this.stringLiteral();
|
|
this.state = 401;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTS);
|
|
this.state = 402;
|
|
this.identifier();
|
|
this.state = 403;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 404;
|
|
this.valueType();
|
|
this.state = 406;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 43) {
|
|
{
|
|
this.state = 405;
|
|
this.dependencyBlock();
|
|
}
|
|
}
|
|
|
|
this.state = 408;
|
|
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, 46, QuixosCapabilityParser.RULE_eventClause);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 410;
|
|
this.match(QuixosCapabilityParser.EMITS);
|
|
this.state = 411;
|
|
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, 48, QuixosCapabilityParser.RULE_operationMode);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 413;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(((((_la - 55)) & ~0x1F) === 0 && ((1 << (_la - 55)) & 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, 50, QuixosCapabilityParser.RULE_receiverRequirement);
|
|
let _la: number;
|
|
try {
|
|
this.state = 424;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.ANY:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 415;
|
|
this.match(QuixosCapabilityParser.ANY);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.ATOM:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 416;
|
|
this.match(QuixosCapabilityParser.ATOM);
|
|
this.state = 417;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.INTERFACES:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 418;
|
|
this.match(QuixosCapabilityParser.INTERFACES);
|
|
this.state = 419;
|
|
this.match(QuixosCapabilityParser.LBRACK);
|
|
this.state = 421;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 34 || _la === 100) {
|
|
{
|
|
this.state = 420;
|
|
this.identifierList();
|
|
}
|
|
}
|
|
|
|
this.state = 423;
|
|
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, 52, QuixosCapabilityParser.RULE_identifierList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 426;
|
|
this.identifier();
|
|
this.state = 431;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 88) {
|
|
{
|
|
{
|
|
this.state = 427;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 428;
|
|
this.identifier();
|
|
}
|
|
}
|
|
this.state = 433;
|
|
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, 54, QuixosCapabilityParser.RULE_dependencyBlock);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 434;
|
|
this.match(QuixosCapabilityParser.REQUIRES);
|
|
this.state = 435;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 439;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 12591168) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 436;
|
|
this.dependencyPort();
|
|
}
|
|
}
|
|
this.state = 441;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 442;
|
|
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, 56, QuixosCapabilityParser.RULE_dependencyPort);
|
|
let _la: number;
|
|
try {
|
|
this.state = 483;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.STATE:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 444;
|
|
this.match(QuixosCapabilityParser.STATE);
|
|
this.state = 445;
|
|
this.identifier();
|
|
this.state = 446;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 447;
|
|
this.stringLiteral();
|
|
this.state = 448;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 449;
|
|
this.valueType();
|
|
this.state = 450;
|
|
this.primitiveList();
|
|
this.state = 451;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.EDGE:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 453;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 454;
|
|
this.identifier();
|
|
this.state = 455;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 456;
|
|
this.stringLiteral();
|
|
this.state = 457;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 458;
|
|
this.cardinality();
|
|
this.state = 459;
|
|
this.targetConstraint();
|
|
this.state = 460;
|
|
this.primitiveList();
|
|
this.state = 461;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.INTERFACE:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 463;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 464;
|
|
this.identifier();
|
|
this.state = 465;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 466;
|
|
this.stringLiteral();
|
|
this.state = 467;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 468;
|
|
this.identifier();
|
|
this.state = 469;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.CONSTRUCTOR:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 471;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTOR);
|
|
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.identifier();
|
|
this.state = 479;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 15) {
|
|
{
|
|
this.state = 477;
|
|
this.match(QuixosCapabilityParser.INPUT);
|
|
this.state = 478;
|
|
this.valueType();
|
|
}
|
|
}
|
|
|
|
this.state = 481;
|
|
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, 58, QuixosCapabilityParser.RULE_primitiveList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 485;
|
|
this.match(QuixosCapabilityParser.LBRACK);
|
|
this.state = 486;
|
|
this.primitive();
|
|
this.state = 491;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 88) {
|
|
{
|
|
{
|
|
this.state = 487;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 488;
|
|
this.primitive();
|
|
}
|
|
}
|
|
this.state = 493;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 494;
|
|
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, 60, QuixosCapabilityParser.RULE_primitive);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 496;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(((((_la - 50)) & ~0x1F) === 0 && ((1 << (_la - 50)) & 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, 62, QuixosCapabilityParser.RULE_sharedAttachmentDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 498;
|
|
this.match(QuixosCapabilityParser.SHARED);
|
|
this.state = 499;
|
|
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, 64, QuixosCapabilityParser.RULE_attachmentDecl);
|
|
try {
|
|
this.state = 503;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.STATE:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 501;
|
|
this.stateDecl();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.EDGE:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 502;
|
|
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, 66, QuixosCapabilityParser.RULE_stateDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 505;
|
|
this.match(QuixosCapabilityParser.STATE);
|
|
this.state = 506;
|
|
this.identifier();
|
|
this.state = 507;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 508;
|
|
this.stringLiteral();
|
|
this.state = 509;
|
|
this.match(QuixosCapabilityParser.ON);
|
|
this.state = 510;
|
|
this.identifier();
|
|
this.state = 511;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 512;
|
|
this.valueType();
|
|
this.state = 513;
|
|
this.match(QuixosCapabilityParser.POLICY);
|
|
this.state = 514;
|
|
this.storagePolicy();
|
|
this.state = 517;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 33) {
|
|
{
|
|
this.state = 515;
|
|
this.match(QuixosCapabilityParser.DEFAULT);
|
|
this.state = 516;
|
|
this.jsonLiteral();
|
|
}
|
|
}
|
|
|
|
this.state = 519;
|
|
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, 68, QuixosCapabilityParser.RULE_storagePolicy);
|
|
try {
|
|
this.state = 527;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.OPTIMISTIC_REGISTER:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 521;
|
|
this.match(QuixosCapabilityParser.OPTIMISTIC_REGISTER);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.CRDT:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 522;
|
|
this.match(QuixosCapabilityParser.CRDT);
|
|
this.state = 523;
|
|
this.match(QuixosCapabilityParser.LPAREN);
|
|
this.state = 524;
|
|
this.valueType();
|
|
this.state = 525;
|
|
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, 70, QuixosCapabilityParser.RULE_edgeDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 529;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 530;
|
|
this.identifier();
|
|
this.state = 531;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 532;
|
|
this.stringLiteral();
|
|
this.state = 533;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 534;
|
|
this.edgeEndpoint();
|
|
this.state = 535;
|
|
this.edgeEndpoint();
|
|
this.state = 536;
|
|
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, 72, QuixosCapabilityParser.RULE_edgeEndpoint);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 538;
|
|
this.targetConstraint();
|
|
this.state = 539;
|
|
this.match(QuixosCapabilityParser.PROJECTION);
|
|
this.state = 540;
|
|
this.identifier();
|
|
this.state = 541;
|
|
this.match(QuixosCapabilityParser.ID);
|
|
this.state = 542;
|
|
this.stringLiteral();
|
|
this.state = 543;
|
|
this.cardinality();
|
|
this.state = 545;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 66) {
|
|
{
|
|
this.state = 544;
|
|
this.match(QuixosCapabilityParser.ORDERED);
|
|
}
|
|
}
|
|
|
|
this.state = 547;
|
|
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, 74, QuixosCapabilityParser.RULE_conformanceDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 549;
|
|
this.match(QuixosCapabilityParser.CONFORM);
|
|
this.state = 550;
|
|
this.identifier();
|
|
this.state = 551;
|
|
this.match(QuixosCapabilityParser.AS);
|
|
this.state = 552;
|
|
this.identifier();
|
|
this.state = 553;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 557;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 269746176) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 554;
|
|
this.conformanceItem();
|
|
}
|
|
}
|
|
this.state = 559;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 560;
|
|
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 conformanceItem(): ConformanceItemContext {
|
|
let localContext = new ConformanceItemContext(this.context, this.state);
|
|
this.enterRule(localContext, 76, QuixosCapabilityParser.RULE_conformanceItem);
|
|
try {
|
|
this.state = 566;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.PRIVATE:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 562;
|
|
this.match(QuixosCapabilityParser.PRIVATE);
|
|
this.state = 563;
|
|
this.attachmentDecl();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.BIND:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 564;
|
|
this.operationBindingDecl();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.MATERIALIZE:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 565;
|
|
this.relationshipMaterializationDecl();
|
|
}
|
|
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 relationshipMaterializationDecl(): RelationshipMaterializationDeclContext {
|
|
let localContext = new RelationshipMaterializationDeclContext(this.context, this.state);
|
|
this.enterRule(localContext, 78, QuixosCapabilityParser.RULE_relationshipMaterializationDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 568;
|
|
this.match(QuixosCapabilityParser.MATERIALIZE);
|
|
this.state = 569;
|
|
this.identifier();
|
|
this.state = 570;
|
|
this.match(QuixosCapabilityParser.IF);
|
|
this.state = 571;
|
|
this.match(QuixosCapabilityParser.ABSENT);
|
|
this.state = 572;
|
|
this.match(QuixosCapabilityParser.USING);
|
|
this.state = 573;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTOR);
|
|
this.state = 574;
|
|
this.identifier();
|
|
this.state = 575;
|
|
this.match(QuixosCapabilityParser.VIA);
|
|
this.state = 576;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 577;
|
|
this.identifier();
|
|
this.state = 578;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 579;
|
|
this.identifier();
|
|
this.state = 580;
|
|
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, 80, QuixosCapabilityParser.RULE_operationBindingDecl);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 582;
|
|
this.match(QuixosCapabilityParser.BIND);
|
|
this.state = 583;
|
|
this.memberOperationRef();
|
|
this.state = 584;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 585;
|
|
this.operationProvider();
|
|
this.state = 586;
|
|
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, 82, QuixosCapabilityParser.RULE_memberOperationRef);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 588;
|
|
this.identifier();
|
|
this.state = 589;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 590;
|
|
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, 84, QuixosCapabilityParser.RULE_operationName);
|
|
try {
|
|
this.state = 603;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.SOURCE:
|
|
case QuixosCapabilityParser.IDENTIFIER:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 592;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.CALL:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 593;
|
|
this.match(QuixosCapabilityParser.CALL);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.GET:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 594;
|
|
this.match(QuixosCapabilityParser.GET);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.SET:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 595;
|
|
this.match(QuixosCapabilityParser.SET);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.RESOLVE:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 596;
|
|
this.match(QuixosCapabilityParser.RESOLVE);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.CONNECT:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 597;
|
|
this.match(QuixosCapabilityParser.CONNECT);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.DISCONNECT:
|
|
this.enterOuterAlt(localContext, 7);
|
|
{
|
|
this.state = 598;
|
|
this.match(QuixosCapabilityParser.DISCONNECT);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.WATCH_START:
|
|
this.enterOuterAlt(localContext, 8);
|
|
{
|
|
this.state = 599;
|
|
this.match(QuixosCapabilityParser.WATCH_START);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.WATCH_STOP:
|
|
this.enterOuterAlt(localContext, 9);
|
|
{
|
|
this.state = 600;
|
|
this.match(QuixosCapabilityParser.WATCH_STOP);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.SUBSCRIBE:
|
|
this.enterOuterAlt(localContext, 10);
|
|
{
|
|
this.state = 601;
|
|
this.match(QuixosCapabilityParser.SUBSCRIBE);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.UNSUBSCRIBE:
|
|
this.enterOuterAlt(localContext, 11);
|
|
{
|
|
this.state = 602;
|
|
this.match(QuixosCapabilityParser.UNSUBSCRIBE);
|
|
}
|
|
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 operationProvider(): OperationProviderContext {
|
|
let localContext = new OperationProviderContext(this.context, this.state);
|
|
this.enterRule(localContext, 86, QuixosCapabilityParser.RULE_operationProvider);
|
|
let _la: number;
|
|
try {
|
|
this.state = 624;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.STATE:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 605;
|
|
this.match(QuixosCapabilityParser.STATE);
|
|
this.state = 606;
|
|
this.identifier();
|
|
this.state = 607;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 608;
|
|
this.statePrimitive();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.EDGE:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 610;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 611;
|
|
this.identifier();
|
|
this.state = 612;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 613;
|
|
this.identifier();
|
|
this.state = 614;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 615;
|
|
this.edgePrimitive();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.PACKAGE:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 617;
|
|
this.match(QuixosCapabilityParser.PACKAGE);
|
|
this.state = 618;
|
|
this.identifier();
|
|
this.state = 619;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 620;
|
|
this.identifier();
|
|
this.state = 622;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 25) {
|
|
{
|
|
this.state = 621;
|
|
this.dependencyBindingBlock();
|
|
}
|
|
}
|
|
|
|
}
|
|
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 statePrimitive(): StatePrimitiveContext {
|
|
let localContext = new StatePrimitiveContext(this.context, this.state);
|
|
this.enterRule(localContext, 88, QuixosCapabilityParser.RULE_statePrimitive);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 626;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(((((_la - 50)) & ~0x1F) === 0 && ((1 << (_la - 50)) & 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, 90, QuixosCapabilityParser.RULE_edgePrimitive);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 628;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(((((_la - 52)) & ~0x1F) === 0 && ((1 << (_la - 52)) & 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, 92, QuixosCapabilityParser.RULE_dependencyBindingBlock);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 630;
|
|
this.match(QuixosCapabilityParser.WITH);
|
|
this.state = 631;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 635;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 34 || _la === 100) {
|
|
{
|
|
{
|
|
this.state = 632;
|
|
this.dependencyBinding();
|
|
}
|
|
}
|
|
this.state = 637;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
this.state = 638;
|
|
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, 94, QuixosCapabilityParser.RULE_dependencyBinding);
|
|
let _la: number;
|
|
try {
|
|
this.state = 690;
|
|
this.errorHandler.sync(this);
|
|
switch (this.interpreter.adaptivePredict(this.tokenStream, 43, this.context) ) {
|
|
case 1:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 640;
|
|
this.identifier();
|
|
this.state = 641;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 642;
|
|
this.match(QuixosCapabilityParser.STATE);
|
|
this.state = 643;
|
|
this.identifier();
|
|
this.state = 650;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 27) {
|
|
{
|
|
this.state = 644;
|
|
this.match(QuixosCapabilityParser.VIA);
|
|
this.state = 645;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 646;
|
|
this.identifier();
|
|
this.state = 647;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 648;
|
|
this.identifier();
|
|
}
|
|
}
|
|
|
|
this.state = 652;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 2:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 654;
|
|
this.identifier();
|
|
this.state = 655;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 656;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 657;
|
|
this.identifier();
|
|
this.state = 658;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 659;
|
|
this.identifier();
|
|
this.state = 666;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 27) {
|
|
{
|
|
this.state = 660;
|
|
this.match(QuixosCapabilityParser.VIA);
|
|
this.state = 661;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 662;
|
|
this.identifier();
|
|
this.state = 663;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 664;
|
|
this.identifier();
|
|
}
|
|
}
|
|
|
|
this.state = 668;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 3:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 670;
|
|
this.identifier();
|
|
this.state = 671;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 672;
|
|
this.match(QuixosCapabilityParser.INTERFACE);
|
|
this.state = 673;
|
|
this.identifier();
|
|
this.state = 680;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 27) {
|
|
{
|
|
this.state = 674;
|
|
this.match(QuixosCapabilityParser.VIA);
|
|
this.state = 675;
|
|
this.match(QuixosCapabilityParser.EDGE);
|
|
this.state = 676;
|
|
this.identifier();
|
|
this.state = 677;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 678;
|
|
this.identifier();
|
|
}
|
|
}
|
|
|
|
this.state = 682;
|
|
this.match(QuixosCapabilityParser.SEMI);
|
|
}
|
|
break;
|
|
case 4:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 684;
|
|
this.identifier();
|
|
this.state = 685;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 686;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTOR);
|
|
this.state = 687;
|
|
this.identifier();
|
|
this.state = 688;
|
|
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, 96, QuixosCapabilityParser.RULE_constructorBindingDecl);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 692;
|
|
this.match(QuixosCapabilityParser.CONSTRUCTOR);
|
|
this.state = 693;
|
|
this.identifier();
|
|
this.state = 694;
|
|
this.match(QuixosCapabilityParser.TO);
|
|
this.state = 695;
|
|
this.identifier();
|
|
this.state = 696;
|
|
this.match(QuixosCapabilityParser.DOT);
|
|
this.state = 697;
|
|
this.identifier();
|
|
this.state = 699;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 25) {
|
|
{
|
|
this.state = 698;
|
|
this.dependencyBindingBlock();
|
|
}
|
|
}
|
|
|
|
this.state = 701;
|
|
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, 98, QuixosCapabilityParser.RULE_valueType);
|
|
try {
|
|
this.state = 728;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.BOOL:
|
|
case QuixosCapabilityParser.BYTES:
|
|
case QuixosCapabilityParser.DOUBLE:
|
|
case QuixosCapabilityParser.INT32:
|
|
case QuixosCapabilityParser.INT64:
|
|
case QuixosCapabilityParser.STRING:
|
|
case QuixosCapabilityParser.UINT32:
|
|
case QuixosCapabilityParser.UINT64:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 703;
|
|
this.scalarType();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.UNIT:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 704;
|
|
this.match(QuixosCapabilityParser.UNIT);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.WATCH_HANDLE:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 705;
|
|
this.match(QuixosCapabilityParser.WATCH_HANDLE);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.MESSAGE:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 706;
|
|
this.match(QuixosCapabilityParser.MESSAGE);
|
|
this.state = 707;
|
|
this.stringLiteral();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.ATOM_REF:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 708;
|
|
this.match(QuixosCapabilityParser.ATOM_REF);
|
|
this.state = 709;
|
|
this.match(QuixosCapabilityParser.LT);
|
|
this.state = 710;
|
|
this.identifier();
|
|
this.state = 711;
|
|
this.match(QuixosCapabilityParser.GT);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.INTERFACE_REF:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 713;
|
|
this.match(QuixosCapabilityParser.INTERFACE_REF);
|
|
this.state = 714;
|
|
this.match(QuixosCapabilityParser.LT);
|
|
this.state = 715;
|
|
this.identifier();
|
|
this.state = 716;
|
|
this.match(QuixosCapabilityParser.GT);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.OPTIONAL:
|
|
this.enterOuterAlt(localContext, 7);
|
|
{
|
|
this.state = 718;
|
|
this.match(QuixosCapabilityParser.OPTIONAL);
|
|
this.state = 719;
|
|
this.match(QuixosCapabilityParser.LT);
|
|
this.state = 720;
|
|
this.valueType();
|
|
this.state = 721;
|
|
this.match(QuixosCapabilityParser.GT);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.LIST:
|
|
this.enterOuterAlt(localContext, 8);
|
|
{
|
|
this.state = 723;
|
|
this.match(QuixosCapabilityParser.LIST);
|
|
this.state = 724;
|
|
this.match(QuixosCapabilityParser.LT);
|
|
this.state = 725;
|
|
this.valueType();
|
|
this.state = 726;
|
|
this.match(QuixosCapabilityParser.GT);
|
|
}
|
|
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 scalarType(): ScalarTypeContext {
|
|
let localContext = new ScalarTypeContext(this.context, this.state);
|
|
this.enterRule(localContext, 100, QuixosCapabilityParser.RULE_scalarType);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 730;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(((((_la - 74)) & ~0x1F) === 0 && ((1 << (_la - 74)) & 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, 102, QuixosCapabilityParser.RULE_cardinality);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 732;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(((((_la - 62)) & ~0x1F) === 0 && ((1 << (_la - 62)) & 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, 104, QuixosCapabilityParser.RULE_jsonLiteral);
|
|
try {
|
|
this.state = 742;
|
|
this.errorHandler.sync(this);
|
|
switch (this.tokenStream.LA(1)) {
|
|
case QuixosCapabilityParser.STRING_LITERAL:
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 734;
|
|
this.stringLiteral();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.INTEGER:
|
|
this.enterOuterAlt(localContext, 2);
|
|
{
|
|
this.state = 735;
|
|
this.match(QuixosCapabilityParser.INTEGER);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.JSON_NUMBER:
|
|
this.enterOuterAlt(localContext, 3);
|
|
{
|
|
this.state = 736;
|
|
this.match(QuixosCapabilityParser.JSON_NUMBER);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.TRUE:
|
|
this.enterOuterAlt(localContext, 4);
|
|
{
|
|
this.state = 737;
|
|
this.match(QuixosCapabilityParser.TRUE);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.FALSE:
|
|
this.enterOuterAlt(localContext, 5);
|
|
{
|
|
this.state = 738;
|
|
this.match(QuixosCapabilityParser.FALSE);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.NULL:
|
|
this.enterOuterAlt(localContext, 6);
|
|
{
|
|
this.state = 739;
|
|
this.match(QuixosCapabilityParser.NULL);
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.LBRACE:
|
|
this.enterOuterAlt(localContext, 7);
|
|
{
|
|
this.state = 740;
|
|
this.jsonObject();
|
|
}
|
|
break;
|
|
case QuixosCapabilityParser.LBRACK:
|
|
this.enterOuterAlt(localContext, 8);
|
|
{
|
|
this.state = 741;
|
|
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, 106, QuixosCapabilityParser.RULE_jsonObject);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 744;
|
|
this.match(QuixosCapabilityParser.LBRACE);
|
|
this.state = 753;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (_la === 101) {
|
|
{
|
|
this.state = 745;
|
|
this.jsonMember();
|
|
this.state = 750;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 88) {
|
|
{
|
|
{
|
|
this.state = 746;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 747;
|
|
this.jsonMember();
|
|
}
|
|
}
|
|
this.state = 752;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.state = 755;
|
|
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, 108, QuixosCapabilityParser.RULE_jsonMember);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 757;
|
|
this.stringLiteral();
|
|
this.state = 758;
|
|
this.match(QuixosCapabilityParser.COLON);
|
|
this.state = 759;
|
|
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, 110, QuixosCapabilityParser.RULE_jsonArray);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 761;
|
|
this.match(QuixosCapabilityParser.LBRACK);
|
|
this.state = 770;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
if (((((_la - 82)) & ~0x1F) === 0 && ((1 << (_la - 82)) & 722183) !== 0)) {
|
|
{
|
|
this.state = 762;
|
|
this.jsonLiteral();
|
|
this.state = 767;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
while (_la === 88) {
|
|
{
|
|
{
|
|
this.state = 763;
|
|
this.match(QuixosCapabilityParser.COMMA);
|
|
this.state = 764;
|
|
this.jsonLiteral();
|
|
}
|
|
}
|
|
this.state = 769;
|
|
this.errorHandler.sync(this);
|
|
_la = this.tokenStream.LA(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.state = 772;
|
|
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, 112, QuixosCapabilityParser.RULE_identifier);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 774;
|
|
_la = this.tokenStream.LA(1);
|
|
if(!(_la === 34 || _la === 100)) {
|
|
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, 114, QuixosCapabilityParser.RULE_stringLiteral);
|
|
try {
|
|
this.enterOuterAlt(localContext, 1);
|
|
{
|
|
this.state = 776;
|
|
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,104,779,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,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,129,8,0,1,1,1,1,1,1,5,1,
|
|
134,8,1,10,1,12,1,137,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,155,8,3,10,3,12,3,158,9,3,1,3,1,3,
|
|
1,4,1,4,1,4,1,4,1,4,1,4,3,4,168,8,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,
|
|
1,5,1,5,1,5,3,5,180,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,3,8,199,8,8,1,9,1,9,1,9,1,9,1,9,1,9,
|
|
3,9,207,8,9,1,9,1,9,1,10,5,10,212,8,10,10,10,12,10,215,9,10,1,10,
|
|
1,10,1,10,1,10,1,10,1,10,1,10,1,10,5,10,225,8,10,10,10,12,10,228,
|
|
9,10,1,10,1,10,1,11,1,11,1,11,3,11,235,8,11,1,12,1,12,1,12,1,12,
|
|
1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,13,1,13,
|
|
1,13,1,13,1,13,1,13,1,13,1,13,5,13,260,8,13,10,13,12,13,263,9,13,
|
|
1,13,1,13,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,
|
|
1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,3,14,286,8,14,1,15,1,15,
|
|
1,15,1,15,1,15,1,15,1,15,1,15,3,15,296,8,15,1,15,1,15,5,15,300,8,
|
|
15,10,15,12,15,303,9,15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,1,16,
|
|
1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
|
|
1,16,1,16,1,16,1,16,1,16,3,16,331,8,16,1,17,1,17,1,17,1,17,3,17,
|
|
337,8,17,1,18,5,18,340,8,18,10,18,12,18,343,9,18,1,18,1,18,1,18,
|
|
1,18,1,18,1,18,1,18,1,18,5,18,353,8,18,10,18,12,18,356,9,18,1,18,
|
|
1,18,1,19,1,19,1,19,3,19,363,8,19,1,20,1,20,1,20,1,20,1,20,1,20,
|
|
1,20,1,20,1,20,1,20,1,20,3,20,376,8,20,1,20,1,20,1,20,3,20,381,8,
|
|
20,1,20,1,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,3,21,394,
|
|
8,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,
|
|
407,8,22,1,22,1,22,1,23,1,23,1,23,1,24,1,24,1,25,1,25,1,25,1,25,
|
|
1,25,1,25,3,25,422,8,25,1,25,3,25,425,8,25,1,26,1,26,1,26,5,26,430,
|
|
8,26,10,26,12,26,433,9,26,1,27,1,27,1,27,5,27,438,8,27,10,27,12,
|
|
27,441,9,27,1,27,1,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,
|
|
28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,
|
|
28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,
|
|
28,3,28,480,8,28,1,28,1,28,3,28,484,8,28,1,29,1,29,1,29,1,29,5,29,
|
|
490,8,29,10,29,12,29,493,9,29,1,29,1,29,1,30,1,30,1,31,1,31,1,31,
|
|
1,32,1,32,3,32,504,8,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,3,33,518,8,33,1,33,1,33,1,34,1,34,1,34,1,34,
|
|
1,34,1,34,3,34,528,8,34,1,35,1,35,1,35,1,35,1,35,1,35,1,35,1,35,
|
|
1,35,1,36,1,36,1,36,1,36,1,36,1,36,1,36,3,36,546,8,36,1,36,1,36,
|
|
1,37,1,37,1,37,1,37,1,37,1,37,5,37,556,8,37,10,37,12,37,559,9,37,
|
|
1,37,1,37,1,38,1,38,1,38,1,38,3,38,567,8,38,1,39,1,39,1,39,1,39,
|
|
1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,40,1,40,1,40,
|
|
1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,42,1,42,1,42,1,42,1,42,1,42,
|
|
1,42,1,42,1,42,1,42,1,42,3,42,604,8,42,1,43,1,43,1,43,1,43,1,43,
|
|
1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43,3,43,
|
|
623,8,43,3,43,625,8,43,1,44,1,44,1,45,1,45,1,46,1,46,1,46,5,46,634,
|
|
8,46,10,46,12,46,637,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,3,47,651,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,3,47,667,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,681,8,47,
|
|
1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,3,47,691,8,47,1,48,1,48,
|
|
1,48,1,48,1,48,1,48,1,48,3,48,700,8,48,1,48,1,48,1,49,1,49,1,49,
|
|
1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,
|
|
1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,3,49,729,8,49,1,50,
|
|
1,50,1,51,1,51,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,743,
|
|
8,52,1,53,1,53,1,53,1,53,5,53,749,8,53,10,53,12,53,752,9,53,3,53,
|
|
754,8,53,1,53,1,53,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,5,55,
|
|
766,8,55,10,55,12,55,769,9,55,3,55,771,8,55,1,55,1,55,1,56,1,56,
|
|
1,57,1,57,1,57,0,0,58,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,0,7,1,0,55,59,2,0,50,54,56,57,2,0,50,51,56,57,2,0,52,54,56,57,
|
|
1,0,74,81,1,0,62,65,2,0,34,34,100,100,811,0,128,1,0,0,0,2,130,1,
|
|
0,0,0,4,140,1,0,0,0,6,144,1,0,0,0,8,167,1,0,0,0,10,179,1,0,0,0,12,
|
|
181,1,0,0,0,14,188,1,0,0,0,16,198,1,0,0,0,18,200,1,0,0,0,20,213,
|
|
1,0,0,0,22,234,1,0,0,0,24,236,1,0,0,0,26,251,1,0,0,0,28,285,1,0,
|
|
0,0,30,287,1,0,0,0,32,330,1,0,0,0,34,336,1,0,0,0,36,341,1,0,0,0,
|
|
38,362,1,0,0,0,40,364,1,0,0,0,42,384,1,0,0,0,44,397,1,0,0,0,46,410,
|
|
1,0,0,0,48,413,1,0,0,0,50,424,1,0,0,0,52,426,1,0,0,0,54,434,1,0,
|
|
0,0,56,483,1,0,0,0,58,485,1,0,0,0,60,496,1,0,0,0,62,498,1,0,0,0,
|
|
64,503,1,0,0,0,66,505,1,0,0,0,68,527,1,0,0,0,70,529,1,0,0,0,72,538,
|
|
1,0,0,0,74,549,1,0,0,0,76,566,1,0,0,0,78,568,1,0,0,0,80,582,1,0,
|
|
0,0,82,588,1,0,0,0,84,603,1,0,0,0,86,624,1,0,0,0,88,626,1,0,0,0,
|
|
90,628,1,0,0,0,92,630,1,0,0,0,94,690,1,0,0,0,96,692,1,0,0,0,98,728,
|
|
1,0,0,0,100,730,1,0,0,0,102,732,1,0,0,0,104,742,1,0,0,0,106,744,
|
|
1,0,0,0,108,757,1,0,0,0,110,761,1,0,0,0,112,774,1,0,0,0,114,776,
|
|
1,0,0,0,116,117,3,6,3,0,117,118,5,0,0,1,118,129,1,0,0,0,119,120,
|
|
3,20,10,0,120,121,5,0,0,1,121,129,1,0,0,0,122,123,3,36,18,0,123,
|
|
124,5,0,0,1,124,129,1,0,0,0,125,126,3,2,1,0,126,127,5,0,0,1,127,
|
|
129,1,0,0,0,128,116,1,0,0,0,128,119,1,0,0,0,128,122,1,0,0,0,128,
|
|
125,1,0,0,0,129,1,1,0,0,0,130,131,5,2,0,0,131,135,5,90,0,0,132,134,
|
|
3,8,4,0,133,132,1,0,0,0,134,137,1,0,0,0,135,133,1,0,0,0,135,136,
|
|
1,0,0,0,136,138,1,0,0,0,137,135,1,0,0,0,138,139,5,91,0,0,139,3,1,
|
|
0,0,0,140,141,5,3,0,0,141,142,3,114,57,0,142,143,5,87,0,0,143,5,
|
|
1,0,0,0,144,145,5,1,0,0,145,146,3,112,56,0,146,147,5,38,0,0,147,
|
|
148,3,114,57,0,148,149,5,37,0,0,149,150,3,114,57,0,150,151,5,36,
|
|
0,0,151,152,3,114,57,0,152,156,5,90,0,0,153,155,3,8,4,0,154,153,
|
|
1,0,0,0,155,158,1,0,0,0,156,154,1,0,0,0,156,157,1,0,0,0,157,159,
|
|
1,0,0,0,158,156,1,0,0,0,159,160,5,91,0,0,160,7,1,0,0,0,161,168,3,
|
|
4,2,0,162,168,3,18,9,0,163,168,3,10,5,0,164,168,3,62,31,0,165,168,
|
|
3,74,37,0,166,168,3,96,48,0,167,161,1,0,0,0,167,162,1,0,0,0,167,
|
|
163,1,0,0,0,167,164,1,0,0,0,167,165,1,0,0,0,167,166,1,0,0,0,168,
|
|
9,1,0,0,0,169,170,5,3,0,0,170,171,5,6,0,0,171,172,3,112,56,0,172,
|
|
173,5,87,0,0,173,180,1,0,0,0,174,175,5,3,0,0,175,176,5,8,0,0,176,
|
|
177,3,112,56,0,177,178,5,87,0,0,178,180,1,0,0,0,179,169,1,0,0,0,
|
|
179,174,1,0,0,0,180,11,1,0,0,0,181,182,5,4,0,0,182,183,5,5,0,0,183,
|
|
184,3,112,56,0,184,185,5,38,0,0,185,186,3,114,57,0,186,187,5,87,
|
|
0,0,187,13,1,0,0,0,188,189,5,4,0,0,189,190,5,6,0,0,190,191,3,112,
|
|
56,0,191,192,5,37,0,0,192,193,3,114,57,0,193,194,5,87,0,0,194,15,
|
|
1,0,0,0,195,199,3,10,5,0,196,199,3,12,6,0,197,199,3,14,7,0,198,195,
|
|
1,0,0,0,198,196,1,0,0,0,198,197,1,0,0,0,199,17,1,0,0,0,200,201,5,
|
|
5,0,0,201,202,3,112,56,0,202,203,5,38,0,0,203,206,3,114,57,0,204,
|
|
205,5,39,0,0,205,207,3,114,57,0,206,204,1,0,0,0,206,207,1,0,0,0,
|
|
207,208,1,0,0,0,208,209,5,87,0,0,209,19,1,0,0,0,210,212,3,16,8,0,
|
|
211,210,1,0,0,0,212,215,1,0,0,0,213,211,1,0,0,0,213,214,1,0,0,0,
|
|
214,216,1,0,0,0,215,213,1,0,0,0,216,217,5,6,0,0,217,218,3,112,56,
|
|
0,218,219,5,38,0,0,219,220,3,114,57,0,220,221,5,37,0,0,221,222,3,
|
|
114,57,0,222,226,5,90,0,0,223,225,3,22,11,0,224,223,1,0,0,0,225,
|
|
228,1,0,0,0,226,224,1,0,0,0,226,227,1,0,0,0,227,229,1,0,0,0,228,
|
|
226,1,0,0,0,229,230,5,91,0,0,230,21,1,0,0,0,231,235,3,26,13,0,232,
|
|
235,3,30,15,0,233,235,3,24,12,0,234,231,1,0,0,0,234,232,1,0,0,0,
|
|
234,233,1,0,0,0,235,23,1,0,0,0,236,237,5,11,0,0,237,238,3,112,56,
|
|
0,238,239,5,38,0,0,239,240,3,114,57,0,240,241,5,86,0,0,241,242,3,
|
|
98,49,0,242,243,5,85,0,0,243,244,3,98,49,0,244,245,5,90,0,0,245,
|
|
246,5,55,0,0,246,247,5,38,0,0,247,248,3,114,57,0,248,249,5,87,0,
|
|
0,249,250,5,91,0,0,250,25,1,0,0,0,251,252,5,9,0,0,252,253,3,112,
|
|
56,0,253,254,5,38,0,0,254,255,3,114,57,0,255,256,5,86,0,0,256,257,
|
|
3,98,49,0,257,261,5,90,0,0,258,260,3,28,14,0,259,258,1,0,0,0,260,
|
|
263,1,0,0,0,261,259,1,0,0,0,261,262,1,0,0,0,262,264,1,0,0,0,263,
|
|
261,1,0,0,0,264,265,5,91,0,0,265,27,1,0,0,0,266,267,5,45,0,0,267,
|
|
268,5,38,0,0,268,269,3,114,57,0,269,270,5,87,0,0,270,286,1,0,0,0,
|
|
271,272,5,46,0,0,272,273,5,38,0,0,273,274,3,114,57,0,274,275,5,87,
|
|
0,0,275,286,1,0,0,0,276,277,5,47,0,0,277,278,5,48,0,0,278,279,5,
|
|
38,0,0,279,280,3,114,57,0,280,281,5,49,0,0,281,282,5,38,0,0,282,
|
|
283,3,114,57,0,283,284,5,87,0,0,284,286,1,0,0,0,285,266,1,0,0,0,
|
|
285,271,1,0,0,0,285,276,1,0,0,0,286,29,1,0,0,0,287,288,5,10,0,0,
|
|
288,289,3,112,56,0,289,290,5,38,0,0,290,291,3,114,57,0,291,292,5,
|
|
86,0,0,292,293,3,102,51,0,293,295,3,34,17,0,294,296,5,66,0,0,295,
|
|
294,1,0,0,0,295,296,1,0,0,0,296,297,1,0,0,0,297,301,5,90,0,0,298,
|
|
300,3,32,16,0,299,298,1,0,0,0,300,303,1,0,0,0,301,299,1,0,0,0,301,
|
|
302,1,0,0,0,302,304,1,0,0,0,303,301,1,0,0,0,304,305,5,91,0,0,305,
|
|
31,1,0,0,0,306,307,5,52,0,0,307,308,5,38,0,0,308,309,3,114,57,0,
|
|
309,310,5,87,0,0,310,331,1,0,0,0,311,312,5,53,0,0,312,313,5,38,0,
|
|
0,313,314,3,114,57,0,314,315,5,87,0,0,315,331,1,0,0,0,316,317,5,
|
|
54,0,0,317,318,5,38,0,0,318,319,3,114,57,0,319,320,5,87,0,0,320,
|
|
331,1,0,0,0,321,322,5,47,0,0,322,323,5,48,0,0,323,324,5,38,0,0,324,
|
|
325,3,114,57,0,325,326,5,49,0,0,326,327,5,38,0,0,327,328,3,114,57,
|
|
0,328,329,5,87,0,0,329,331,1,0,0,0,330,306,1,0,0,0,330,311,1,0,0,
|
|
0,330,316,1,0,0,0,330,321,1,0,0,0,331,33,1,0,0,0,332,333,5,5,0,0,
|
|
333,337,3,112,56,0,334,335,5,6,0,0,335,337,3,112,56,0,336,332,1,
|
|
0,0,0,336,334,1,0,0,0,337,35,1,0,0,0,338,340,3,16,8,0,339,338,1,
|
|
0,0,0,340,343,1,0,0,0,341,339,1,0,0,0,341,342,1,0,0,0,342,344,1,
|
|
0,0,0,343,341,1,0,0,0,344,345,5,8,0,0,345,346,3,112,56,0,346,347,
|
|
5,38,0,0,347,348,3,114,57,0,348,349,5,37,0,0,349,350,3,114,57,0,
|
|
350,354,5,90,0,0,351,353,3,38,19,0,352,351,1,0,0,0,353,356,1,0,0,
|
|
0,354,352,1,0,0,0,354,355,1,0,0,0,355,357,1,0,0,0,356,354,1,0,0,
|
|
0,357,358,5,91,0,0,358,37,1,0,0,0,359,363,3,40,20,0,360,363,3,42,
|
|
21,0,361,363,3,44,22,0,362,359,1,0,0,0,362,360,1,0,0,0,362,361,1,
|
|
0,0,0,363,39,1,0,0,0,364,365,5,11,0,0,365,366,3,112,56,0,366,367,
|
|
5,38,0,0,367,368,3,114,57,0,368,369,5,86,0,0,369,370,3,98,49,0,370,
|
|
371,5,85,0,0,371,372,3,98,49,0,372,373,5,40,0,0,373,375,3,48,24,
|
|
0,374,376,3,46,23,0,375,374,1,0,0,0,375,376,1,0,0,0,376,377,1,0,
|
|
0,0,377,378,5,42,0,0,378,380,3,50,25,0,379,381,3,54,27,0,380,379,
|
|
1,0,0,0,380,381,1,0,0,0,381,382,1,0,0,0,382,383,5,87,0,0,383,41,
|
|
1,0,0,0,384,385,5,12,0,0,385,386,3,112,56,0,386,387,5,38,0,0,387,
|
|
388,3,114,57,0,388,389,5,86,0,0,389,390,3,98,49,0,390,391,5,85,0,
|
|
0,391,393,3,98,49,0,392,394,3,54,27,0,393,392,1,0,0,0,393,394,1,
|
|
0,0,0,394,395,1,0,0,0,395,396,5,87,0,0,396,43,1,0,0,0,397,398,5,
|
|
13,0,0,398,399,3,112,56,0,399,400,5,38,0,0,400,401,3,114,57,0,401,
|
|
402,5,14,0,0,402,403,3,112,56,0,403,404,5,86,0,0,404,406,3,98,49,
|
|
0,405,407,3,54,27,0,406,405,1,0,0,0,406,407,1,0,0,0,407,408,1,0,
|
|
0,0,408,409,5,87,0,0,409,45,1,0,0,0,410,411,5,41,0,0,411,412,3,98,
|
|
49,0,412,47,1,0,0,0,413,414,7,0,0,0,414,49,1,0,0,0,415,425,5,44,
|
|
0,0,416,417,5,5,0,0,417,425,3,112,56,0,418,419,5,7,0,0,419,421,5,
|
|
92,0,0,420,422,3,52,26,0,421,420,1,0,0,0,421,422,1,0,0,0,422,423,
|
|
1,0,0,0,423,425,5,93,0,0,424,415,1,0,0,0,424,416,1,0,0,0,424,418,
|
|
1,0,0,0,425,51,1,0,0,0,426,431,3,112,56,0,427,428,5,88,0,0,428,430,
|
|
3,112,56,0,429,427,1,0,0,0,430,433,1,0,0,0,431,429,1,0,0,0,431,432,
|
|
1,0,0,0,432,53,1,0,0,0,433,431,1,0,0,0,434,435,5,43,0,0,435,439,
|
|
5,90,0,0,436,438,3,56,28,0,437,436,1,0,0,0,438,441,1,0,0,0,439,437,
|
|
1,0,0,0,439,440,1,0,0,0,440,442,1,0,0,0,441,439,1,0,0,0,442,443,
|
|
5,91,0,0,443,55,1,0,0,0,444,445,5,22,0,0,445,446,3,112,56,0,446,
|
|
447,5,38,0,0,447,448,3,114,57,0,448,449,5,86,0,0,449,450,3,98,49,
|
|
0,450,451,3,58,29,0,451,452,5,87,0,0,452,484,1,0,0,0,453,454,5,23,
|
|
0,0,454,455,3,112,56,0,455,456,5,38,0,0,456,457,3,114,57,0,457,458,
|
|
5,86,0,0,458,459,3,102,51,0,459,460,3,34,17,0,460,461,3,58,29,0,
|
|
461,462,5,87,0,0,462,484,1,0,0,0,463,464,5,6,0,0,464,465,3,112,56,
|
|
0,465,466,5,38,0,0,466,467,3,114,57,0,467,468,5,86,0,0,468,469,3,
|
|
112,56,0,469,470,5,87,0,0,470,484,1,0,0,0,471,472,5,13,0,0,472,473,
|
|
3,112,56,0,473,474,5,38,0,0,474,475,3,114,57,0,475,476,5,86,0,0,
|
|
476,479,3,112,56,0,477,478,5,15,0,0,478,480,3,98,49,0,479,477,1,
|
|
0,0,0,479,480,1,0,0,0,480,481,1,0,0,0,481,482,5,87,0,0,482,484,1,
|
|
0,0,0,483,444,1,0,0,0,483,453,1,0,0,0,483,463,1,0,0,0,483,471,1,
|
|
0,0,0,484,57,1,0,0,0,485,486,5,92,0,0,486,491,3,60,30,0,487,488,
|
|
5,88,0,0,488,490,3,60,30,0,489,487,1,0,0,0,490,493,1,0,0,0,491,489,
|
|
1,0,0,0,491,492,1,0,0,0,492,494,1,0,0,0,493,491,1,0,0,0,494,495,
|
|
5,93,0,0,495,59,1,0,0,0,496,497,7,1,0,0,497,61,1,0,0,0,498,499,5,
|
|
21,0,0,499,500,3,64,32,0,500,63,1,0,0,0,501,504,3,66,33,0,502,504,
|
|
3,70,35,0,503,501,1,0,0,0,503,502,1,0,0,0,504,65,1,0,0,0,505,506,
|
|
5,22,0,0,506,507,3,112,56,0,507,508,5,38,0,0,508,509,3,114,57,0,
|
|
509,510,5,31,0,0,510,511,3,112,56,0,511,512,5,86,0,0,512,513,3,98,
|
|
49,0,513,514,5,32,0,0,514,517,3,68,34,0,515,516,5,33,0,0,516,518,
|
|
3,104,52,0,517,515,1,0,0,0,517,518,1,0,0,0,518,519,1,0,0,0,519,520,
|
|
5,87,0,0,520,67,1,0,0,0,521,528,5,60,0,0,522,523,5,61,0,0,523,524,
|
|
5,94,0,0,524,525,3,98,49,0,525,526,5,95,0,0,526,528,1,0,0,0,527,
|
|
521,1,0,0,0,527,522,1,0,0,0,528,69,1,0,0,0,529,530,5,23,0,0,530,
|
|
531,3,112,56,0,531,532,5,38,0,0,532,533,3,114,57,0,533,534,5,90,
|
|
0,0,534,535,3,72,36,0,535,536,3,72,36,0,536,537,5,91,0,0,537,71,
|
|
1,0,0,0,538,539,3,34,17,0,539,540,5,24,0,0,540,541,3,112,56,0,541,
|
|
542,5,38,0,0,542,543,3,114,57,0,543,545,3,102,51,0,544,546,5,66,
|
|
0,0,545,544,1,0,0,0,545,546,1,0,0,0,546,547,1,0,0,0,547,548,5,87,
|
|
0,0,548,73,1,0,0,0,549,550,5,16,0,0,550,551,3,112,56,0,551,552,5,
|
|
17,0,0,552,553,3,112,56,0,553,557,5,90,0,0,554,556,3,76,38,0,555,
|
|
554,1,0,0,0,556,559,1,0,0,0,557,555,1,0,0,0,557,558,1,0,0,0,558,
|
|
560,1,0,0,0,559,557,1,0,0,0,560,561,5,91,0,0,561,75,1,0,0,0,562,
|
|
563,5,20,0,0,563,567,3,64,32,0,564,567,3,80,40,0,565,567,3,78,39,
|
|
0,566,562,1,0,0,0,566,564,1,0,0,0,566,565,1,0,0,0,567,77,1,0,0,0,
|
|
568,569,5,28,0,0,569,570,3,112,56,0,570,571,5,29,0,0,571,572,5,30,
|
|
0,0,572,573,5,26,0,0,573,574,5,13,0,0,574,575,3,112,56,0,575,576,
|
|
5,27,0,0,576,577,5,23,0,0,577,578,3,112,56,0,578,579,5,89,0,0,579,
|
|
580,3,112,56,0,580,581,5,87,0,0,581,79,1,0,0,0,582,583,5,18,0,0,
|
|
583,584,3,82,41,0,584,585,5,19,0,0,585,586,3,86,43,0,586,587,5,87,
|
|
0,0,587,81,1,0,0,0,588,589,3,112,56,0,589,590,5,89,0,0,590,591,3,
|
|
84,42,0,591,83,1,0,0,0,592,604,3,112,56,0,593,604,5,55,0,0,594,604,
|
|
5,45,0,0,595,604,5,46,0,0,596,604,5,52,0,0,597,604,5,53,0,0,598,
|
|
604,5,54,0,0,599,604,5,56,0,0,600,604,5,57,0,0,601,604,5,58,0,0,
|
|
602,604,5,59,0,0,603,592,1,0,0,0,603,593,1,0,0,0,603,594,1,0,0,0,
|
|
603,595,1,0,0,0,603,596,1,0,0,0,603,597,1,0,0,0,603,598,1,0,0,0,
|
|
603,599,1,0,0,0,603,600,1,0,0,0,603,601,1,0,0,0,603,602,1,0,0,0,
|
|
604,85,1,0,0,0,605,606,5,22,0,0,606,607,3,112,56,0,607,608,5,89,
|
|
0,0,608,609,3,88,44,0,609,625,1,0,0,0,610,611,5,23,0,0,611,612,3,
|
|
112,56,0,612,613,5,89,0,0,613,614,3,112,56,0,614,615,5,89,0,0,615,
|
|
616,3,90,45,0,616,625,1,0,0,0,617,618,5,8,0,0,618,619,3,112,56,0,
|
|
619,620,5,89,0,0,620,622,3,112,56,0,621,623,3,92,46,0,622,621,1,
|
|
0,0,0,622,623,1,0,0,0,623,625,1,0,0,0,624,605,1,0,0,0,624,610,1,
|
|
0,0,0,624,617,1,0,0,0,625,87,1,0,0,0,626,627,7,2,0,0,627,89,1,0,
|
|
0,0,628,629,7,3,0,0,629,91,1,0,0,0,630,631,5,25,0,0,631,635,5,90,
|
|
0,0,632,634,3,94,47,0,633,632,1,0,0,0,634,637,1,0,0,0,635,633,1,
|
|
0,0,0,635,636,1,0,0,0,636,638,1,0,0,0,637,635,1,0,0,0,638,639,5,
|
|
91,0,0,639,93,1,0,0,0,640,641,3,112,56,0,641,642,5,19,0,0,642,643,
|
|
5,22,0,0,643,650,3,112,56,0,644,645,5,27,0,0,645,646,5,23,0,0,646,
|
|
647,3,112,56,0,647,648,5,89,0,0,648,649,3,112,56,0,649,651,1,0,0,
|
|
0,650,644,1,0,0,0,650,651,1,0,0,0,651,652,1,0,0,0,652,653,5,87,0,
|
|
0,653,691,1,0,0,0,654,655,3,112,56,0,655,656,5,19,0,0,656,657,5,
|
|
23,0,0,657,658,3,112,56,0,658,659,5,89,0,0,659,666,3,112,56,0,660,
|
|
661,5,27,0,0,661,662,5,23,0,0,662,663,3,112,56,0,663,664,5,89,0,
|
|
0,664,665,3,112,56,0,665,667,1,0,0,0,666,660,1,0,0,0,666,667,1,0,
|
|
0,0,667,668,1,0,0,0,668,669,5,87,0,0,669,691,1,0,0,0,670,671,3,112,
|
|
56,0,671,672,5,19,0,0,672,673,5,6,0,0,673,680,3,112,56,0,674,675,
|
|
5,27,0,0,675,676,5,23,0,0,676,677,3,112,56,0,677,678,5,89,0,0,678,
|
|
679,3,112,56,0,679,681,1,0,0,0,680,674,1,0,0,0,680,681,1,0,0,0,681,
|
|
682,1,0,0,0,682,683,5,87,0,0,683,691,1,0,0,0,684,685,3,112,56,0,
|
|
685,686,5,19,0,0,686,687,5,13,0,0,687,688,3,112,56,0,688,689,5,87,
|
|
0,0,689,691,1,0,0,0,690,640,1,0,0,0,690,654,1,0,0,0,690,670,1,0,
|
|
0,0,690,684,1,0,0,0,691,95,1,0,0,0,692,693,5,13,0,0,693,694,3,112,
|
|
56,0,694,695,5,19,0,0,695,696,3,112,56,0,696,697,5,89,0,0,697,699,
|
|
3,112,56,0,698,700,3,92,46,0,699,698,1,0,0,0,699,700,1,0,0,0,700,
|
|
701,1,0,0,0,701,702,5,87,0,0,702,97,1,0,0,0,703,729,3,100,50,0,704,
|
|
729,5,67,0,0,705,729,5,68,0,0,706,707,5,69,0,0,707,729,3,114,57,
|
|
0,708,709,5,70,0,0,709,710,5,96,0,0,710,711,3,112,56,0,711,712,5,
|
|
97,0,0,712,729,1,0,0,0,713,714,5,71,0,0,714,715,5,96,0,0,715,716,
|
|
3,112,56,0,716,717,5,97,0,0,717,729,1,0,0,0,718,719,5,72,0,0,719,
|
|
720,5,96,0,0,720,721,3,98,49,0,721,722,5,97,0,0,722,729,1,0,0,0,
|
|
723,724,5,73,0,0,724,725,5,96,0,0,725,726,3,98,49,0,726,727,5,97,
|
|
0,0,727,729,1,0,0,0,728,703,1,0,0,0,728,704,1,0,0,0,728,705,1,0,
|
|
0,0,728,706,1,0,0,0,728,708,1,0,0,0,728,713,1,0,0,0,728,718,1,0,
|
|
0,0,728,723,1,0,0,0,729,99,1,0,0,0,730,731,7,4,0,0,731,101,1,0,0,
|
|
0,732,733,7,5,0,0,733,103,1,0,0,0,734,743,3,114,57,0,735,743,5,98,
|
|
0,0,736,743,5,99,0,0,737,743,5,82,0,0,738,743,5,83,0,0,739,743,5,
|
|
84,0,0,740,743,3,106,53,0,741,743,3,110,55,0,742,734,1,0,0,0,742,
|
|
735,1,0,0,0,742,736,1,0,0,0,742,737,1,0,0,0,742,738,1,0,0,0,742,
|
|
739,1,0,0,0,742,740,1,0,0,0,742,741,1,0,0,0,743,105,1,0,0,0,744,
|
|
753,5,90,0,0,745,750,3,108,54,0,746,747,5,88,0,0,747,749,3,108,54,
|
|
0,748,746,1,0,0,0,749,752,1,0,0,0,750,748,1,0,0,0,750,751,1,0,0,
|
|
0,751,754,1,0,0,0,752,750,1,0,0,0,753,745,1,0,0,0,753,754,1,0,0,
|
|
0,754,755,1,0,0,0,755,756,5,91,0,0,756,107,1,0,0,0,757,758,3,114,
|
|
57,0,758,759,5,86,0,0,759,760,3,104,52,0,760,109,1,0,0,0,761,770,
|
|
5,92,0,0,762,767,3,104,52,0,763,764,5,88,0,0,764,766,3,104,52,0,
|
|
765,763,1,0,0,0,766,769,1,0,0,0,767,765,1,0,0,0,767,768,1,0,0,0,
|
|
768,771,1,0,0,0,769,767,1,0,0,0,770,762,1,0,0,0,770,771,1,0,0,0,
|
|
771,772,1,0,0,0,772,773,5,93,0,0,773,111,1,0,0,0,774,775,7,6,0,0,
|
|
775,113,1,0,0,0,776,777,5,101,0,0,777,115,1,0,0,0,51,128,135,156,
|
|
167,179,198,206,213,226,234,261,285,295,301,330,336,341,354,362,
|
|
375,380,393,406,421,424,431,439,479,483,491,503,517,527,545,557,
|
|
566,603,622,624,635,650,666,680,690,699,728,742,750,753,767,770
|
|
];
|
|
|
|
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 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 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 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 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 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 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 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 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 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 VALUE(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.VALUE, 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 {
|
|
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 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 SET(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SET, 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 {
|
|
return this.getRuleContext(0, 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 ORDERED(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.ORDERED, 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 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 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 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 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 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 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 eventClause(): EventClauseContext | null {
|
|
return this.getRuleContext(0, EventClauseContext);
|
|
}
|
|
public dependencyBlock(): DependencyBlockContext | null {
|
|
return this.getRuleContext(0, DependencyBlockContext);
|
|
}
|
|
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 dependencyBlock(): DependencyBlockContext | null {
|
|
return this.getRuleContext(0, DependencyBlockContext);
|
|
}
|
|
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 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 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 identifierList(): IdentifierListContext | null {
|
|
return this.getRuleContext(0, IdentifierListContext);
|
|
}
|
|
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 STATE(): antlr.TerminalNode | null {
|
|
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 COLON(): antlr.TerminalNode {
|
|
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 SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 0)!;
|
|
}
|
|
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 INTERFACE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INTERFACE, 0);
|
|
}
|
|
public CONSTRUCTOR(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 0);
|
|
}
|
|
public INPUT(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.INPUT, 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 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 OPTIMISTIC_REGISTER(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.OPTIMISTIC_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 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 {
|
|
return this.getRuleContext(0, 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 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 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 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 relationshipMaterializationDecl(): RelationshipMaterializationDeclContext | null {
|
|
return this.getRuleContext(0, RelationshipMaterializationDeclContext);
|
|
}
|
|
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 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 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 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 STATE(): antlr.TerminalNode | null {
|
|
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 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 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 PACKAGE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.PACKAGE, 0);
|
|
}
|
|
public dependencyBindingBlock(): DependencyBindingBlockContext | null {
|
|
return this.getRuleContext(0, DependencyBindingBlockContext);
|
|
}
|
|
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 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 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 STATE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.STATE, 0);
|
|
}
|
|
public SEMI(): antlr.TerminalNode {
|
|
return this.getToken(QuixosCapabilityParser.SEMI, 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 CONSTRUCTOR(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.CONSTRUCTOR, 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 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 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 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 SOURCE(): antlr.TerminalNode | null {
|
|
return this.getToken(QuixosCapabilityParser.SOURCE, 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);
|
|
}
|
|
}
|
|
}
|