@nidomiro/relation-tuple-parser/src/lib/generated/antlr/RelationTupleParser.js

[](https://www.npmjs.com/package/@nidomiro/relation-tuple-parser)

"use strict";
// Generated from RelationTuple.g4 by ANTLR 4.9.0-SNAPSHOT
Object.defineProperty(exports, "__esModule", { value: true });
exports.SubjectSetContext = exports.SubjectIdContext = exports.SubjectContext = exports.NamespacedObjectContext = exports.RelationTupleContext = exports.RelationTupleParser = void 0;
const ATNDeserializer_1 = require("antlr4ts/atn/ATNDeserializer");
const FailedPredicateException_1 = require("antlr4ts/FailedPredicateException");
const Parser_1 = require("antlr4ts/Parser");
const ParserRuleContext_1 = require("antlr4ts/ParserRuleContext");
const ParserATNSimulator_1 = require("antlr4ts/atn/ParserATNSimulator");
const RecognitionException_1 = require("antlr4ts/RecognitionException");
const VocabularyImpl_1 = require("antlr4ts/VocabularyImpl");
const Utils = require("antlr4ts/misc/Utils");
class RelationTupleParser extends Parser_1.Parser {
    constructor(input) {
        super(input);
        this._interp = new ParserATNSimulator_1.ParserATNSimulator(RelationTupleParser._ATN, this);
    }
    // @Override
    // @NotNull
    get vocabulary() {
        return RelationTupleParser.VOCABULARY;
    }
    // tslint:enable:no-trailing-whitespace
    // @Override
    get grammarFileName() { return "RelationTuple.g4"; }
    // @Override
    get ruleNames() { return RelationTupleParser.ruleNames; }
    // @Override
    get serializedATN() { return RelationTupleParser._serializedATN; }
    createFailedPredicateException(predicate, message) {
        return new FailedPredicateException_1.FailedPredicateException(this, predicate, message);
    }
    // @RuleVersion(0)
    relationTuple() {
        let _localctx = new RelationTupleContext(this._ctx, this.state);
        this.enterRule(_localctx, 0, RelationTupleParser.RULE_relationTuple);
        try {
            this.enterOuterAlt(_localctx, 1);
            {
                this.state = 10;
                this.namespacedObject();
                this.state = 11;
                this.match(RelationTupleParser.T__0);
                this.state = 12;
                _localctx._relation = this.match(RelationTupleParser.STRING);
                this.state = 13;
                this.match(RelationTupleParser.T__1);
                this.state = 14;
                this.subject();
                this.state = 15;
                this.match(RelationTupleParser.EOF);
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    // @RuleVersion(0)
    namespacedObject() {
        let _localctx = new NamespacedObjectContext(this._ctx, this.state);
        this.enterRule(_localctx, 2, RelationTupleParser.RULE_namespacedObject);
        try {
            this.enterOuterAlt(_localctx, 1);
            {
                this.state = 17;
                _localctx._namespace = this.match(RelationTupleParser.STRING);
                this.state = 18;
                this.match(RelationTupleParser.T__2);
                this.state = 19;
                _localctx._object = this.match(RelationTupleParser.STRING);
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    // @RuleVersion(0)
    subject() {
        let _localctx = new SubjectContext(this._ctx, this.state);
        this.enterRule(_localctx, 4, RelationTupleParser.RULE_subject);
        try {
            this.state = 31;
            this._errHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this._input, 0, this._ctx)) {
                case 1:
                    this.enterOuterAlt(_localctx, 1);
                    {
                        this.state = 21;
                        this.subjectId();
                    }
                    break;
                case 2:
                    this.enterOuterAlt(_localctx, 2);
                    {
                        this.state = 22;
                        this.subjectSet();
                    }
                    break;
                case 3:
                    this.enterOuterAlt(_localctx, 3);
                    {
                        this.state = 23;
                        this.match(RelationTupleParser.T__3);
                        this.state = 24;
                        this.subjectId();
                        this.state = 25;
                        this.match(RelationTupleParser.T__4);
                    }
                    break;
                case 4:
                    this.enterOuterAlt(_localctx, 4);
                    {
                        this.state = 27;
                        this.match(RelationTupleParser.T__3);
                        this.state = 28;
                        this.subjectSet();
                        this.state = 29;
                        this.match(RelationTupleParser.T__4);
                    }
                    break;
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    // @RuleVersion(0)
    subjectId() {
        let _localctx = new SubjectIdContext(this._ctx, this.state);
        this.enterRule(_localctx, 6, RelationTupleParser.RULE_subjectId);
        try {
            this.enterOuterAlt(_localctx, 1);
            {
                this.state = 33;
                this.match(RelationTupleParser.STRING);
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    // @RuleVersion(0)
    subjectSet() {
        let _localctx = new SubjectSetContext(this._ctx, this.state);
        this.enterRule(_localctx, 8, RelationTupleParser.RULE_subjectSet);
        let _la;
        try {
            this.state = 41;
            this._errHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this._input, 2, this._ctx)) {
                case 1:
                    this.enterOuterAlt(_localctx, 1);
                    {
                        this.state = 35;
                        this.namespacedObject();
                        this.state = 36;
                        this.match(RelationTupleParser.T__0);
                        this.state = 38;
                        this._errHandler.sync(this);
                        _la = this._input.LA(1);
                        if (_la === RelationTupleParser.STRING) {
                            {
                                this.state = 37;
                                _localctx._subjectRelation = this.match(RelationTupleParser.STRING);
                            }
                        }
                    }
                    break;
                case 2:
                    this.enterOuterAlt(_localctx, 2);
                    {
                        this.state = 40;
                        this.namespacedObject();
                    }
                    break;
            }
        }
        catch (re) {
            if (re instanceof RecognitionException_1.RecognitionException) {
                _localctx.exception = re;
                this._errHandler.reportError(this, re);
                this._errHandler.recover(this, re);
            }
            else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return _localctx;
    }
    static get _ATN() {
        if (!RelationTupleParser.__ATN) {
            RelationTupleParser.__ATN = new ATNDeserializer_1.ATNDeserializer().deserialize(Utils.toCharArray(RelationTupleParser._serializedATN));
        }
        return RelationTupleParser.__ATN;
    }
}
exports.RelationTupleParser = RelationTupleParser;
RelationTupleParser.T__0 = 1;
RelationTupleParser.T__1 = 2;
RelationTupleParser.T__2 = 3;
RelationTupleParser.T__3 = 4;
RelationTupleParser.T__4 = 5;
RelationTupleParser.STRING = 6;
RelationTupleParser.CHAR = 7;
RelationTupleParser.RULE_relationTuple = 0;
RelationTupleParser.RULE_namespacedObject = 1;
RelationTupleParser.RULE_subject = 2;
RelationTupleParser.RULE_subjectId = 3;
RelationTupleParser.RULE_subjectSet = 4;
// tslint:disable:no-trailing-whitespace
RelationTupleParser.ruleNames = [
    "relationTuple", "namespacedObject", "subject", "subjectId", "subjectSet",
];
RelationTupleParser._LITERAL_NAMES = [
    undefined, "'#'", "'@'", "':'", "'('", "')'",
];
RelationTupleParser._SYMBOLIC_NAMES = [
    undefined, undefined, undefined, undefined, undefined, undefined, "STRING",
    "CHAR",
];
RelationTupleParser.VOCABULARY = new VocabularyImpl_1.VocabularyImpl(RelationTupleParser._LITERAL_NAMES, RelationTupleParser._SYMBOLIC_NAMES, []);
RelationTupleParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\t.\x04\x02\t" +
    "\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x03\x02\x03" +
    "\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x03\x03\x03\x03\x03\x03" +
    "\x03\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
    "\x04\x03\x04\x05\x04\"\n\x04\x03\x05\x03\x05\x03\x06\x03\x06\x03\x06\x05" +
    "\x06)\n\x06\x03\x06\x05\x06,\n\x06\x03\x06\x02\x02\x02\x07\x02\x02\x04" +
    "\x02\x06\x02\b\x02\n\x02\x02\x02\x02-\x02\f\x03\x02\x02\x02\x04\x13\x03" +
    "\x02\x02\x02\x06!\x03\x02\x02\x02\b#\x03\x02\x02\x02\n+\x03\x02\x02\x02" +
    "\f\r\x05\x04\x03\x02\r\x0E\x07\x03\x02\x02\x0E\x0F\x07\b\x02\x02\x0F\x10" +
    "\x07\x04\x02\x02\x10\x11\x05\x06\x04\x02\x11\x12\x07\x02\x02\x03\x12\x03" +
    "\x03\x02\x02\x02\x13\x14\x07\b\x02\x02\x14\x15\x07\x05\x02\x02\x15\x16" +
    "\x07\b\x02\x02\x16\x05\x03\x02\x02\x02\x17\"\x05\b\x05\x02\x18\"\x05\n" +
    "\x06\x02\x19\x1A\x07\x06\x02\x02\x1A\x1B\x05\b\x05\x02\x1B\x1C\x07\x07" +
    "\x02\x02\x1C\"\x03\x02\x02\x02\x1D\x1E\x07\x06\x02\x02\x1E\x1F\x05\n\x06" +
    "\x02\x1F \x07\x07\x02\x02 \"\x03\x02\x02\x02!\x17\x03\x02\x02\x02!\x18" +
    "\x03\x02\x02\x02!\x19\x03\x02\x02\x02!\x1D\x03\x02\x02\x02\"\x07\x03\x02" +
    "\x02\x02#$\x07\b\x02\x02$\t\x03\x02\x02\x02%&\x05\x04\x03\x02&(\x07\x03" +
    "\x02\x02\')\x07\b\x02\x02(\'\x03\x02\x02\x02()\x03\x02\x02\x02),\x03\x02" +
    "\x02\x02*,\x05\x04\x03\x02+%\x03\x02\x02\x02+*\x03\x02\x02\x02,\v\x03" +
    "\x02\x02\x02\x05!(+";
class RelationTupleContext extends ParserRuleContext_1.ParserRuleContext {
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    namespacedObject() {
        return this.getRuleContext(0, NamespacedObjectContext);
    }
    subject() {
        return this.getRuleContext(0, SubjectContext);
    }
    EOF() { return this.getToken(RelationTupleParser.EOF, 0); }
    STRING() { return this.getToken(RelationTupleParser.STRING, 0); }
    // @Override
    get ruleIndex() { return RelationTupleParser.RULE_relationTuple; }
    // @Override
    accept(visitor) {
        if (visitor.visitRelationTuple) {
            return visitor.visitRelationTuple(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.RelationTupleContext = RelationTupleContext;
class NamespacedObjectContext extends ParserRuleContext_1.ParserRuleContext {
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    STRING(i) {
        if (i === undefined) {
            return this.getTokens(RelationTupleParser.STRING);
        }
        else {
            return this.getToken(RelationTupleParser.STRING, i);
        }
    }
    // @Override
    get ruleIndex() { return RelationTupleParser.RULE_namespacedObject; }
    // @Override
    accept(visitor) {
        if (visitor.visitNamespacedObject) {
            return visitor.visitNamespacedObject(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.NamespacedObjectContext = NamespacedObjectContext;
class SubjectContext extends ParserRuleContext_1.ParserRuleContext {
    subjectId() {
        return this.tryGetRuleContext(0, SubjectIdContext);
    }
    subjectSet() {
        return this.tryGetRuleContext(0, SubjectSetContext);
    }
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    // @Override
    get ruleIndex() { return RelationTupleParser.RULE_subject; }
    // @Override
    accept(visitor) {
        if (visitor.visitSubject) {
            return visitor.visitSubject(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.SubjectContext = SubjectContext;
class SubjectIdContext extends ParserRuleContext_1.ParserRuleContext {
    STRING() { return this.getToken(RelationTupleParser.STRING, 0); }
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    // @Override
    get ruleIndex() { return RelationTupleParser.RULE_subjectId; }
    // @Override
    accept(visitor) {
        if (visitor.visitSubjectId) {
            return visitor.visitSubjectId(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.SubjectIdContext = SubjectIdContext;
class SubjectSetContext extends ParserRuleContext_1.ParserRuleContext {
    constructor(parent, invokingState) {
        super(parent, invokingState);
    }
    namespacedObject() {
        return this.getRuleContext(0, NamespacedObjectContext);
    }
    STRING() { return this.tryGetToken(RelationTupleParser.STRING, 0); }
    // @Override
    get ruleIndex() { return RelationTupleParser.RULE_subjectSet; }
    // @Override
    accept(visitor) {
        if (visitor.visitSubjectSet) {
            return visitor.visitSubjectSet(this);
        }
        else {
            return visitor.visitChildren(this);
        }
    }
}
exports.SubjectSetContext = SubjectSetContext;
//# sourceMappingURL=RelationTupleParser.js.map