cariboujs 2.0.4 → 2.0.6

package/maml/MAMLParser.js

@@ -0,0 +1,935 @@
+// Generated from MAML.g4 by ANTLR 4.13.2
+// jshint ignore: start
+import antlr4 from 'antlr4';
+import MAMLListener from './MAMLListener.js';
+import MAMLVisitor from './MAMLVisitor.js';
+
+const serializedATN = [4,1,16,118,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,1,0,5,0,16,8,0,10,0,12,0,19,9,0,1,0,1,0,5,0,23,8,0,10,
+0,12,0,26,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,38,8,1,1,2,1,2,
+5,2,42,8,2,10,2,12,2,45,9,2,1,2,1,2,1,2,1,2,5,2,51,8,2,10,2,12,2,54,9,2,
+1,2,3,2,57,8,2,3,2,59,8,2,1,2,1,2,1,3,1,3,5,3,65,8,3,10,3,12,3,68,9,3,1,
+3,1,3,5,3,72,8,3,10,3,12,3,75,9,3,1,3,1,3,1,4,1,4,1,5,1,5,5,5,83,8,5,10,
+5,12,5,86,9,5,1,5,1,5,1,5,1,5,5,5,92,8,5,10,5,12,5,95,9,5,1,5,3,5,98,8,5,
+3,5,100,8,5,1,5,1,5,1,6,1,6,5,6,106,8,6,10,6,12,6,109,9,6,1,6,4,6,112,8,
+6,11,6,12,6,113,3,6,116,8,6,1,6,0,0,7,0,2,4,6,8,10,12,0,1,2,0,7,9,12,14,
+132,0,17,1,0,0,0,2,37,1,0,0,0,4,39,1,0,0,0,6,62,1,0,0,0,8,78,1,0,0,0,10,
+80,1,0,0,0,12,115,1,0,0,0,14,16,5,15,0,0,15,14,1,0,0,0,16,19,1,0,0,0,17,
+15,1,0,0,0,17,18,1,0,0,0,18,20,1,0,0,0,19,17,1,0,0,0,20,24,3,2,1,0,21,23,
+5,15,0,0,22,21,1,0,0,0,23,26,1,0,0,0,24,22,1,0,0,0,24,25,1,0,0,0,25,27,1,
+0,0,0,26,24,1,0,0,0,27,28,5,0,0,1,28,1,1,0,0,0,29,38,3,4,2,0,30,38,3,10,
+5,0,31,38,5,12,0,0,32,38,5,11,0,0,33,38,5,13,0,0,34,38,5,7,0,0,35,38,5,8,
+0,0,36,38,5,9,0,0,37,29,1,0,0,0,37,30,1,0,0,0,37,31,1,0,0,0,37,32,1,0,0,
+0,37,33,1,0,0,0,37,34,1,0,0,0,37,35,1,0,0,0,37,36,1,0,0,0,38,3,1,0,0,0,39,
+43,5,1,0,0,40,42,5,15,0,0,41,40,1,0,0,0,42,45,1,0,0,0,43,41,1,0,0,0,43,44,
+1,0,0,0,44,58,1,0,0,0,45,43,1,0,0,0,46,52,3,6,3,0,47,48,3,12,6,0,48,49,3,
+6,3,0,49,51,1,0,0,0,50,47,1,0,0,0,51,54,1,0,0,0,52,50,1,0,0,0,52,53,1,0,
+0,0,53,56,1,0,0,0,54,52,1,0,0,0,55,57,3,12,6,0,56,55,1,0,0,0,56,57,1,0,0,
+0,57,59,1,0,0,0,58,46,1,0,0,0,58,59,1,0,0,0,59,60,1,0,0,0,60,61,5,2,0,0,
+61,5,1,0,0,0,62,66,3,8,4,0,63,65,5,15,0,0,64,63,1,0,0,0,65,68,1,0,0,0,66,
+64,1,0,0,0,66,67,1,0,0,0,67,69,1,0,0,0,68,66,1,0,0,0,69,73,5,3,0,0,70,72,
+5,15,0,0,71,70,1,0,0,0,72,75,1,0,0,0,73,71,1,0,0,0,73,74,1,0,0,0,74,76,1,
+0,0,0,75,73,1,0,0,0,76,77,3,2,1,0,77,7,1,0,0,0,78,79,7,0,0,0,79,9,1,0,0,
+0,80,84,5,4,0,0,81,83,5,15,0,0,82,81,1,0,0,0,83,86,1,0,0,0,84,82,1,0,0,0,
+84,85,1,0,0,0,85,99,1,0,0,0,86,84,1,0,0,0,87,93,3,2,1,0,88,89,3,12,6,0,89,
+90,3,2,1,0,90,92,1,0,0,0,91,88,1,0,0,0,92,95,1,0,0,0,93,91,1,0,0,0,93,94,
+1,0,0,0,94,97,1,0,0,0,95,93,1,0,0,0,96,98,3,12,6,0,97,96,1,0,0,0,97,98,1,
+0,0,0,98,100,1,0,0,0,99,87,1,0,0,0,99,100,1,0,0,0,100,101,1,0,0,0,101,102,
+5,5,0,0,102,11,1,0,0,0,103,107,5,6,0,0,104,106,5,15,0,0,105,104,1,0,0,0,
+106,109,1,0,0,0,107,105,1,0,0,0,107,108,1,0,0,0,108,116,1,0,0,0,109,107,
+1,0,0,0,110,112,5,15,0,0,111,110,1,0,0,0,112,113,1,0,0,0,113,111,1,0,0,0,
+113,114,1,0,0,0,114,116,1,0,0,0,115,103,1,0,0,0,115,111,1,0,0,0,116,13,1,
+0,0,0,16,17,24,37,43,52,56,58,66,73,84,93,97,99,107,113,115];
+
+
+const atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
+
+const decisionsToDFA = atn.decisionToState.map( (ds, index) => new antlr4.dfa.DFA(ds, index) );
+
+const sharedContextCache = new antlr4.atn.PredictionContextCache();
+
+export default class MAMLParser extends antlr4.Parser {
+
+    static grammarFileName = "MAML.g4";
+    static literalNames = [ null, "'{'", "'}'", "':'", "'['", "']'", "','", 
+                            "'true'", "'false'", "'null'" ];
+    static symbolicNames = [ null, null, null, null, null, null, null, "TRUE", 
+                             "FALSE", "NULL", "COMMENT", "RAW_STRING", "STRING", 
+                             "NUMBER", "IDENTIFIER", "NL", "WS" ];
+    static ruleNames = [ "maml", "value", "object", "member", "key", "array", 
+                         "separator" ];
+
+    constructor(input) {
+        super(input);
+        this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
+        this.ruleNames = MAMLParser.ruleNames;
+        this.literalNames = MAMLParser.literalNames;
+        this.symbolicNames = MAMLParser.symbolicNames;
+    }
+
+
+
+	maml() {
+	    let localctx = new MamlContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 0, MAMLParser.RULE_maml);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 17;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===15) {
+	            this.state = 14;
+	            this.match(MAMLParser.NL);
+	            this.state = 19;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 20;
+	        this.value();
+	        this.state = 24;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===15) {
+	            this.state = 21;
+	            this.match(MAMLParser.NL);
+	            this.state = 26;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 27;
+	        this.match(MAMLParser.EOF);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	value() {
+	    let localctx = new ValueContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 2, MAMLParser.RULE_value);
+	    try {
+	        this.state = 37;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 1:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 29;
+	            this.object();
+	            break;
+	        case 4:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 30;
+	            this.array();
+	            break;
+	        case 12:
+	            this.enterOuterAlt(localctx, 3);
+	            this.state = 31;
+	            this.match(MAMLParser.STRING);
+	            break;
+	        case 11:
+	            this.enterOuterAlt(localctx, 4);
+	            this.state = 32;
+	            this.match(MAMLParser.RAW_STRING);
+	            break;
+	        case 13:
+	            this.enterOuterAlt(localctx, 5);
+	            this.state = 33;
+	            this.match(MAMLParser.NUMBER);
+	            break;
+	        case 7:
+	            this.enterOuterAlt(localctx, 6);
+	            this.state = 34;
+	            this.match(MAMLParser.TRUE);
+	            break;
+	        case 8:
+	            this.enterOuterAlt(localctx, 7);
+	            this.state = 35;
+	            this.match(MAMLParser.FALSE);
+	            break;
+	        case 9:
+	            this.enterOuterAlt(localctx, 8);
+	            this.state = 36;
+	            this.match(MAMLParser.NULL);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	object() {
+	    let localctx = new ObjectContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 4, MAMLParser.RULE_object);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 39;
+	        this.match(MAMLParser.T__0);
+	        this.state = 43;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===15) {
+	            this.state = 40;
+	            this.match(MAMLParser.NL);
+	            this.state = 45;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 58;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 29568) !== 0)) {
+	            this.state = 46;
+	            this.member();
+	            this.state = 52;
+	            this._errHandler.sync(this);
+	            var _alt = this._interp.adaptivePredict(this._input,4,this._ctx)
+	            while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+	                if(_alt===1) {
+	                    this.state = 47;
+	                    this.separator();
+	                    this.state = 48;
+	                    this.member(); 
+	                }
+	                this.state = 54;
+	                this._errHandler.sync(this);
+	                _alt = this._interp.adaptivePredict(this._input,4,this._ctx);
+	            }
+
+	            this.state = 56;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            if(_la===6 || _la===15) {
+	                this.state = 55;
+	                this.separator();
+	            }
+
+	        }
+
+	        this.state = 60;
+	        this.match(MAMLParser.T__1);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	member() {
+	    let localctx = new MemberContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 6, MAMLParser.RULE_member);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 62;
+	        this.key();
+	        this.state = 66;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===15) {
+	            this.state = 63;
+	            this.match(MAMLParser.NL);
+	            this.state = 68;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 69;
+	        this.match(MAMLParser.T__2);
+	        this.state = 73;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===15) {
+	            this.state = 70;
+	            this.match(MAMLParser.NL);
+	            this.state = 75;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 76;
+	        this.value();
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	key() {
+	    let localctx = new KeyContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 8, MAMLParser.RULE_key);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 78;
+	        _la = this._input.LA(1);
+	        if(!((((_la) & ~0x1f) === 0 && ((1 << _la) & 29568) !== 0))) {
+	        this._errHandler.recoverInline(this);
+	        }
+	        else {
+	        	this._errHandler.reportMatch(this);
+	            this.consume();
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	array() {
+	    let localctx = new ArrayContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 10, MAMLParser.RULE_array);
+	    var _la = 0;
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 80;
+	        this.match(MAMLParser.T__3);
+	        this.state = 84;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        while(_la===15) {
+	            this.state = 81;
+	            this.match(MAMLParser.NL);
+	            this.state = 86;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	        }
+	        this.state = 99;
+	        this._errHandler.sync(this);
+	        _la = this._input.LA(1);
+	        if((((_la) & ~0x1f) === 0 && ((1 << _la) & 15250) !== 0)) {
+	            this.state = 87;
+	            this.value();
+	            this.state = 93;
+	            this._errHandler.sync(this);
+	            var _alt = this._interp.adaptivePredict(this._input,10,this._ctx)
+	            while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+	                if(_alt===1) {
+	                    this.state = 88;
+	                    this.separator();
+	                    this.state = 89;
+	                    this.value(); 
+	                }
+	                this.state = 95;
+	                this._errHandler.sync(this);
+	                _alt = this._interp.adaptivePredict(this._input,10,this._ctx);
+	            }
+
+	            this.state = 97;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            if(_la===6 || _la===15) {
+	                this.state = 96;
+	                this.separator();
+	            }
+
+	        }
+
+	        this.state = 101;
+	        this.match(MAMLParser.T__4);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+
+	separator() {
+	    let localctx = new SeparatorContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 12, MAMLParser.RULE_separator);
+	    var _la = 0;
+	    try {
+	        this.state = 115;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 6:
+	            this.enterOuterAlt(localctx, 1);
+	            this.state = 103;
+	            this.match(MAMLParser.T__5);
+	            this.state = 107;
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            while(_la===15) {
+	                this.state = 104;
+	                this.match(MAMLParser.NL);
+	                this.state = 109;
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	            }
+	            break;
+	        case 15:
+	            this.enterOuterAlt(localctx, 2);
+	            this.state = 111; 
+	            this._errHandler.sync(this);
+	            _la = this._input.LA(1);
+	            do {
+	                this.state = 110;
+	                this.match(MAMLParser.NL);
+	                this.state = 113; 
+	                this._errHandler.sync(this);
+	                _la = this._input.LA(1);
+	            } while(_la===15);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+}
+
+MAMLParser.EOF = antlr4.Token.EOF;
+MAMLParser.T__0 = 1;
+MAMLParser.T__1 = 2;
+MAMLParser.T__2 = 3;
+MAMLParser.T__3 = 4;
+MAMLParser.T__4 = 5;
+MAMLParser.T__5 = 6;
+MAMLParser.TRUE = 7;
+MAMLParser.FALSE = 8;
+MAMLParser.NULL = 9;
+MAMLParser.COMMENT = 10;
+MAMLParser.RAW_STRING = 11;
+MAMLParser.STRING = 12;
+MAMLParser.NUMBER = 13;
+MAMLParser.IDENTIFIER = 14;
+MAMLParser.NL = 15;
+MAMLParser.WS = 16;
+
+MAMLParser.RULE_maml = 0;
+MAMLParser.RULE_value = 1;
+MAMLParser.RULE_object = 2;
+MAMLParser.RULE_member = 3;
+MAMLParser.RULE_key = 4;
+MAMLParser.RULE_array = 5;
+MAMLParser.RULE_separator = 6;
+
+class MamlContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MAMLParser.RULE_maml;
+    }
+
+	value() {
+	    return this.getTypedRuleContext(ValueContext,0);
+	};
+
+	EOF() {
+	    return this.getToken(MAMLParser.EOF, 0);
+	};
+
+	NL = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(MAMLParser.NL);
+	    } else {
+	        return this.getToken(MAMLParser.NL, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.enterMaml(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.exitMaml(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MAMLVisitor ) {
+	        return visitor.visitMaml(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ValueContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MAMLParser.RULE_value;
+    }
+
+	object() {
+	    return this.getTypedRuleContext(ObjectContext,0);
+	};
+
+	array() {
+	    return this.getTypedRuleContext(ArrayContext,0);
+	};
+
+	STRING() {
+	    return this.getToken(MAMLParser.STRING, 0);
+	};
+
+	RAW_STRING() {
+	    return this.getToken(MAMLParser.RAW_STRING, 0);
+	};
+
+	NUMBER() {
+	    return this.getToken(MAMLParser.NUMBER, 0);
+	};
+
+	TRUE() {
+	    return this.getToken(MAMLParser.TRUE, 0);
+	};
+
+	FALSE() {
+	    return this.getToken(MAMLParser.FALSE, 0);
+	};
+
+	NULL() {
+	    return this.getToken(MAMLParser.NULL, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.enterValue(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.exitValue(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MAMLVisitor ) {
+	        return visitor.visitValue(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ObjectContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MAMLParser.RULE_object;
+    }
+
+	NL = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(MAMLParser.NL);
+	    } else {
+	        return this.getToken(MAMLParser.NL, i);
+	    }
+	};
+
+
+	member = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(MemberContext);
+	    } else {
+	        return this.getTypedRuleContext(MemberContext,i);
+	    }
+	};
+
+	separator = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(SeparatorContext);
+	    } else {
+	        return this.getTypedRuleContext(SeparatorContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.enterObject(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.exitObject(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MAMLVisitor ) {
+	        return visitor.visitObject(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class MemberContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MAMLParser.RULE_member;
+    }
+
+	key() {
+	    return this.getTypedRuleContext(KeyContext,0);
+	};
+
+	value() {
+	    return this.getTypedRuleContext(ValueContext,0);
+	};
+
+	NL = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(MAMLParser.NL);
+	    } else {
+	        return this.getToken(MAMLParser.NL, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.enterMember(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.exitMember(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MAMLVisitor ) {
+	        return visitor.visitMember(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class KeyContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MAMLParser.RULE_key;
+    }
+
+	IDENTIFIER() {
+	    return this.getToken(MAMLParser.IDENTIFIER, 0);
+	};
+
+	STRING() {
+	    return this.getToken(MAMLParser.STRING, 0);
+	};
+
+	NUMBER() {
+	    return this.getToken(MAMLParser.NUMBER, 0);
+	};
+
+	TRUE() {
+	    return this.getToken(MAMLParser.TRUE, 0);
+	};
+
+	FALSE() {
+	    return this.getToken(MAMLParser.FALSE, 0);
+	};
+
+	NULL() {
+	    return this.getToken(MAMLParser.NULL, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.enterKey(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.exitKey(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MAMLVisitor ) {
+	        return visitor.visitKey(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class ArrayContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MAMLParser.RULE_array;
+    }
+
+	NL = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(MAMLParser.NL);
+	    } else {
+	        return this.getToken(MAMLParser.NL, i);
+	    }
+	};
+
+
+	value = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ValueContext);
+	    } else {
+	        return this.getTypedRuleContext(ValueContext,i);
+	    }
+	};
+
+	separator = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(SeparatorContext);
+	    } else {
+	        return this.getTypedRuleContext(SeparatorContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.enterArray(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.exitArray(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MAMLVisitor ) {
+	        return visitor.visitArray(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+class SeparatorContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = MAMLParser.RULE_separator;
+    }
+
+	NL = function(i) {
+		if(i===undefined) {
+			i = null;
+		}
+	    if(i===null) {
+	        return this.getTokens(MAMLParser.NL);
+	    } else {
+	        return this.getToken(MAMLParser.NL, i);
+	    }
+	};
+
+
+	enterRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.enterSeparator(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof MAMLListener ) {
+	        listener.exitSeparator(this);
+		}
+	}
+
+	accept(visitor) {
+	    if ( visitor instanceof MAMLVisitor ) {
+	        return visitor.visitSeparator(this);
+	    } else {
+	        return visitor.visitChildren(this);
+	    }
+	}
+
+
+}
+
+
+
+
+MAMLParser.MamlContext = MamlContext; 
+MAMLParser.ValueContext = ValueContext; 
+MAMLParser.ObjectContext = ObjectContext; 
+MAMLParser.MemberContext = MemberContext; 
+MAMLParser.KeyContext = KeyContext; 
+MAMLParser.ArrayContext = ArrayContext; 
+MAMLParser.SeparatorContext = SeparatorContext;