forked from jasder/antlr
Stub out stg file
This commit is contained in:
Peter Boyer
parent
447452755e
commit
2c36445ac3
|
|
@ -1,26 +0,0 @@
|
|||
[The "BSD license"]
|
||||
Copyright (c) 2015 Terence Parr, Sam Harwell, Eric Vergnaud
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
3. The name of the author may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
# JavaScript target for ANTLR 4
|
||||
|
||||
JavaScript runtime libraries for ANTLR 4
|
||||
|
||||
This runtime is available through npm. The package name is 'antlr4'.
|
||||
|
||||
This runtime has been tested in Node.js, Safari, Firefox, Chrome and IE.
|
||||
|
||||
See www.antlr.org for more information on ANTLR
|
||||
|
||||
See https://raw.githubusercontent.com/antlr/antlr4/master/doc/javascript-target.md for more information on using ANTLR in JavaScript
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,855 @@
|
|||
/*
|
||||
* [The "BSD license"]
|
||||
* Copyright (c) 2012 Terence Parr
|
||||
* Copyright (c) 2012 Sam Harwell
|
||||
* Copyright (c) 2014 Eric Vergnaud
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. The name of the author may not be used to endorse or promote products
|
||||
* derived from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/** ANTLR tool checks output templates are compatible with tool code generation.
|
||||
* For now, a simple string match used on x.y of x.y.z scheme.
|
||||
* Must match Tool.VERSION during load to templates.
|
||||
*
|
||||
* REQUIRED.
|
||||
*/
|
||||
|
||||
pythonTypeInitMap ::= [
|
||||
"bool":"False",
|
||||
"int":"0",
|
||||
"float":"0.0",
|
||||
"str":"",
|
||||
default:"None" // anything other than a primitive type is an object
|
||||
]
|
||||
|
||||
// args must be <object-model-object>, <fields-resulting-in-STs>
|
||||
|
||||
ParserFile(file, parser, namedActions) ::= <<
|
||||
<fileHeader(file.grammarFileName, file.ANTLRVersion)>
|
||||
var antlr4 = require('antlr4/index');
|
||||
<if(file.genListener)>
|
||||
var <file.grammarName>Listener = require('./<file.grammarName>Listener').<file.grammarName>Listener;
|
||||
<endif>
|
||||
<if(file.genVisitor)>
|
||||
var <file.grammarName>Visitor = require('./<file.grammarName>Visitor').<file.grammarName>Visitor;
|
||||
<endif>
|
||||
|
||||
<namedActions.header>
|
||||
<parser>
|
||||
>>
|
||||
|
||||
ListenerFile(file, header) ::= <<
|
||||
<fileHeader(file.grammarFileName, file.ANTLRVersion)>
|
||||
var antlr4 = require('antlr4/index');
|
||||
|
||||
// This class defines a complete listener for a parse tree produced by <file.parserName>.
|
||||
function <file.grammarName>Listener() {
|
||||
antlr4.tree.ParseTreeListener.call(this);
|
||||
return this;
|
||||
}
|
||||
|
||||
<file.grammarName>Listener.prototype = Object.create(antlr4.tree.ParseTreeListener.prototype);
|
||||
<file.grammarName>Listener.prototype.constructor = <file.grammarName>Listener;
|
||||
|
||||
<file.listenerNames:{lname |
|
||||
// Enter a parse tree produced by <file.parserName>#<lname>.
|
||||
<file.grammarName>Listener.prototype.enter<lname; format="cap"> = function(ctx) {
|
||||
\};
|
||||
|
||||
// Exit a parse tree produced by <file.parserName>#<lname>.
|
||||
<file.grammarName>Listener.prototype.exit<lname; format="cap"> = function(ctx) {
|
||||
\};
|
||||
|
||||
}; separator="\n">
|
||||
|
||||
exports.<file.grammarName>Listener = <file.grammarName>Listener;
|
||||
>>
|
||||
|
||||
|
||||
VisitorFile(file, header) ::= <<
|
||||
<fileHeader(file.grammarFileName, file.ANTLRVersion)>
|
||||
var antlr4 = require('antlr4/index');
|
||||
<header>
|
||||
|
||||
// This class defines a complete generic visitor for a parse tree produced by <file.parserName>.
|
||||
|
||||
function <file.grammarName>Visitor() {
|
||||
antlr4.tree.ParseTreeVisitor.call(this);
|
||||
return this;
|
||||
}
|
||||
|
||||
<file.grammarName>Visitor.prototype = Object.create(antlr4.tree.ParseTreeVisitor.prototype);
|
||||
<file.grammarName>Visitor.prototype.constructor = <file.grammarName>Visitor;
|
||||
|
||||
<file.visitorNames:{lname |
|
||||
// Visit a parse tree produced by <file.parserName>#<lname>.
|
||||
<file.grammarName>Visitor.prototype.visit<lname; format="cap"> = function(ctx) {
|
||||
\};
|
||||
|
||||
}; separator="\n">
|
||||
|
||||
exports.<file.grammarName>Visitor = <file.grammarName>Visitor;
|
||||
>>
|
||||
|
||||
|
||||
fileHeader(grammarFileName, ANTLRVersion) ::= <<
|
||||
// Generated from <grammarFileName; format="java-escape"> by ANTLR <ANTLRVersion>
|
||||
// jshint ignore: start
|
||||
>>
|
||||
|
||||
Parser(parser, funcs, atn, sempredFuncs, superClass) ::= <<
|
||||
<if(superClass)>
|
||||
var <superClass> = require('./<superClass>').<superClass>;
|
||||
<endif>
|
||||
|
||||
var grammarFileName = "<parser.grammarFileName; format="java-escape">";
|
||||
|
||||
<atn>
|
||||
|
||||
var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
|
||||
|
||||
var decisionsToDFA = atn.decisionToState.map( function(ds, index) { return new antlr4.dfa.DFA(ds, index); });
|
||||
|
||||
var sharedContextCache = new antlr4.PredictionContextCache();
|
||||
|
||||
var literalNames = [ <parser.literalNames:{t | <t>}; null="null", separator=", ", wrap, anchor> ];
|
||||
|
||||
var symbolicNames = [ <parser.symbolicNames:{t | <t>}; null="null", separator=", ", wrap, anchor> ];
|
||||
|
||||
var ruleNames = [ <parser.ruleNames:{r | "<r>"}; separator=", ", wrap, anchor> ];
|
||||
|
||||
function <parser.name> (input) {
|
||||
<superClass; null="antlr4.Parser">.call(this, input);
|
||||
this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
|
||||
this.ruleNames = ruleNames;
|
||||
this.literalNames = literalNames;
|
||||
this.symbolicNames = symbolicNames;
|
||||
<namedActions.members>
|
||||
return this;
|
||||
}
|
||||
|
||||
<parser.name>.prototype = Object.create(<superClass; null="antlr4.Parser">.prototype);
|
||||
<parser.name>.prototype.constructor = <parser.name>;
|
||||
|
||||
Object.defineProperty(<parser.name>.prototype, "atn", {
|
||||
get : function() {
|
||||
return atn;
|
||||
}
|
||||
});
|
||||
|
||||
<parser.name>.EOF = antlr4.Token.EOF;
|
||||
<if(parser.tokens)>
|
||||
<parser.tokens:{k | <parser.name>.<k> = <parser.tokens.(k)>;}; separator="\n", wrap, anchor>
|
||||
<endif>
|
||||
|
||||
<parser.rules:{r | <parser.name>.RULE_<r.name> = <r.index>;}; separator="\n", wrap, anchor>
|
||||
|
||||
<funcs; separator="\n">
|
||||
|
||||
<if(sempredFuncs)>
|
||||
<parser.name>.prototype.sempred = function(localctx, ruleIndex, predIndex) {
|
||||
switch(ruleIndex) {
|
||||
<parser.sempredFuncs.values:{f | case <f.ruleIndex>:
|
||||
return this.<f.name>_sempred(localctx, predIndex);}; separator="\n">
|
||||
default:
|
||||
throw "No predicate with index:" + ruleIndex;
|
||||
}
|
||||
};
|
||||
|
||||
<sempredFuncs.values; separator="\n">
|
||||
<endif>
|
||||
|
||||
exports.<parser.name> = <parser.name>;
|
||||
|
||||
>>
|
||||
|
||||
dumpActions(recog, argFuncs, actionFuncs, sempredFuncs) ::= <<
|
||||
<if(actionFuncs)>
|
||||
<lexer.name>.prototype.action = function(localctx, ruleIndex, actionIndex) {
|
||||
switch (ruleIndex) {
|
||||
<recog.actionFuncs.values:{f|
|
||||
case <f.ruleIndex>:
|
||||
this.<f.name>_action(localctx, actionIndex);
|
||||
break;}; separator="\n">
|
||||
default:
|
||||
throw "No registered action for:" + ruleIndex;
|
||||
}
|
||||
};
|
||||
|
||||
<actionFuncs.values; separator="\n">
|
||||
<endif>
|
||||
<if(sempredFuncs)>
|
||||
<lexer.name>.prototype.sempred = function(localctx, ruleIndex, predIndex) {
|
||||
switch (ruleIndex) {
|
||||
<recog.sempredFuncs.values:{f| case <f.ruleIndex>:
|
||||
return this.<f.name>_sempred(localctx, predIndex);}; separator="\n">
|
||||
default:
|
||||
throw "No registered predicate for:" + ruleIndex;
|
||||
}
|
||||
};
|
||||
|
||||
<sempredFuncs.values; separator="\n">
|
||||
<endif>
|
||||
>>
|
||||
|
||||
|
||||
/* This generates a private method since the actionIndex is generated, making an
|
||||
* overriding implementation impossible to maintain.
|
||||
*/
|
||||
RuleActionFunction(r, actions) ::= <<
|
||||
|
||||
<lexer.name>.prototype.<r.name>_action = function(localctx , actionIndex) {
|
||||
switch (actionIndex) {
|
||||
<actions:{index|
|
||||
case <index>:
|
||||
<actions.(index)>
|
||||
break;}; separator="\n">
|
||||
default:
|
||||
throw "No registered action for:" + actionIndex;
|
||||
}
|
||||
};
|
||||
>>
|
||||
|
||||
/* This generates a private method since the predIndex is generated, making an
|
||||
* overriding implementation impossible to maintain.
|
||||
*/
|
||||
RuleSempredFunction(r, actions) ::= <<
|
||||
<if(parser)><parser.name><else><lexer.name><endif>.prototype.<r.name>_sempred = function(localctx, predIndex) {
|
||||
switch(predIndex) {
|
||||
<actions:{index| case <index>:
|
||||
return <actions.(index)>;}; separator="\n">
|
||||
default:
|
||||
throw "No predicate with index:" + predIndex;
|
||||
}
|
||||
};
|
||||
|
||||
>>
|
||||
|
||||
RuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,namedActions,finallyAction,postamble,exceptions) ::= <<
|
||||
|
||||
<ruleCtx>
|
||||
|
||||
<altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
|
||||
|
||||
<! Define fields of this parser to export the context classes !>
|
||||
<parser.name>.<currentRule.ctxType> = <currentRule.ctxType>;
|
||||
|
||||
<parser.name>.prototype.<currentRule.name> = function(<currentRule.args:{a | <a.name>}; separator=", ">) {
|
||||
|
||||
var localctx = new <currentRule.ctxType>(this, this._ctx, this.state<currentRule.args:{a | , <a.name>}>);
|
||||
this.enterRule(localctx, <currentRule.startState>, <parser.name>.RULE_<currentRule.name>);
|
||||
<namedActions.init>
|
||||
<locals; separator="\n">
|
||||
try {
|
||||
<code>
|
||||
<postamble; separator="\n">
|
||||
<namedActions.after>
|
||||
<if(exceptions)>
|
||||
<exceptions; separator="\n">
|
||||
<else>
|
||||
} catch (re) {
|
||||
if(re instanceof antlr4.error.RecognitionException) {
|
||||
localctx.exception = re;
|
||||
this._errHandler.reportError(this, re);
|
||||
this._errHandler.recover(this, re);
|
||||
} else {
|
||||
throw re;
|
||||
}
|
||||
}<endif> finally {
|
||||
<finallyAction>
|
||||
this.exitRule();
|
||||
}
|
||||
return localctx;
|
||||
};
|
||||
|
||||
>>
|
||||
|
||||
LeftRecursiveRuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,
|
||||
namedActions,finallyAction,postamble) ::=
|
||||
<<
|
||||
|
||||
<ruleCtx>
|
||||
<altLabelCtxs:{l | <altLabelCtxs.(l)>}; separator="\n">
|
||||
|
||||
<parser.name>.prototype.<currentRule.name> = function(_p<if(currentRule.args)>, <args:{a | , <a>}><endif>) {
|
||||
if(_p===undefined) {
|
||||
_p = 0;
|
||||
}
|
||||
var _parentctx = this._ctx;
|
||||
var _parentState = this.state;
|
||||
var localctx = new <currentRule.ctxType>(this, this._ctx, _parentState<args:{a | , <a.name>}>);
|
||||
var _prevctx = localctx;
|
||||
var _startState = <currentRule.startState>;
|
||||
this.enterRecursionRule(localctx, <currentRule.startState>, <parser.name>.RULE_<currentRule.name>, _p);
|
||||
<namedActions.init>
|
||||
<locals; separator="\n">
|
||||
try {
|
||||
<code>
|
||||
<postamble; separator="\n">
|
||||
<namedActions.after>
|
||||
} catch( error) {
|
||||
if(error instanceof antlr4.error.RecognitionException) {
|
||||
localctx.exception = error;
|
||||
this._errHandler.reportError(this, error);
|
||||
this._errHandler.recover(this, error);
|
||||
} else {
|
||||
throw error;
|
||||
}
|
||||
} finally {
|
||||
<finallyAction>
|
||||
this.unrollRecursionContexts(_parentctx)
|
||||
}
|
||||
return localctx;
|
||||
};
|
||||
|
||||
>>
|
||||
|
||||
CodeBlockForOuterMostAlt(currentOuterMostAltCodeBlock, locals, preamble, ops) ::= <<
|
||||
<if(currentOuterMostAltCodeBlock.altLabel)>localctx = new <currentOuterMostAltCodeBlock.altLabel; format="cap">Context(this, localctx);<endif>
|
||||
this.enterOuterAlt(localctx, <currentOuterMostAltCodeBlock.alt.altNum>);
|
||||
<CodeBlockForAlt(currentAltCodeBlock=currentOuterMostAltCodeBlock, ...)>
|
||||
>>
|
||||
|
||||
CodeBlockForAlt(currentAltCodeBlock, locals, preamble, ops) ::= <<
|
||||
<locals; separator="\n">
|
||||
<preamble; separator="\n">
|
||||
<ops; separator="\n">
|
||||
>>
|
||||
|
||||
LL1AltBlock(choice, preamble, alts, error) ::= <<
|
||||
this.state = <choice.stateNumber>;
|
||||
<if(choice.label)><labelref(choice.label)> = this._input.LT(1);<endif>
|
||||
<preamble; separator="\n">
|
||||
switch(this._input.LA(1)) {
|
||||
<choice.altLook,alts:{look,alt| <cases(ttypes=look)>
|
||||
<alt>
|
||||
break;}; separator="\n">
|
||||
default:
|
||||
<error>
|
||||
}
|
||||
>>
|
||||
|
||||
LL1OptionalBlock(choice, alts, error) ::= <<
|
||||
this.state = <choice.stateNumber>;
|
||||
switch (this._input.LA(1)) {
|
||||
<choice.altLook,alts:{look,alt| <cases(ttypes=look)>
|
||||
<alt>
|
||||
break;}; separator="\n">
|
||||
default:
|
||||
<error>
|
||||
}
|
||||
>>
|
||||
|
||||
LL1OptionalBlockSingleAlt(choice, expr, alts, preamble, error, followExpr) ::= <<
|
||||
this.state = <choice.stateNumber>;
|
||||
<preamble; separator="\n">
|
||||
if(<expr>) {
|
||||
<alts; separator="\n">
|
||||
}
|
||||
<!else if ( !(<followExpr>) ) <error>!>
|
||||
>>
|
||||
|
||||
LL1StarBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
|
||||
this.state = <choice.stateNumber>;
|
||||
this._errHandler.sync(this);
|
||||
<preamble; separator="\n">
|
||||
while(<loopExpr>) {
|
||||
<alts; separator="\n">
|
||||
this.state = <choice.loopBackStateNumber>;
|
||||
this._errHandler.sync(this);
|
||||
<iteration>
|
||||
}
|
||||
>>
|
||||
|
||||
LL1PlusBlockSingleAlt(choice, loopExpr, alts, preamble, iteration) ::= <<
|
||||
this.state = <choice.blockStartStateNumber>; <! alt block decision !>
|
||||
this._errHandler.sync(this);
|
||||
<preamble; separator="\n">
|
||||
do {
|
||||
<alts; separator="\n">
|
||||
this.state = <choice.stateNumber>; <! loopback/exit decision !>
|
||||
this._errHandler.sync(this);
|
||||
<iteration>
|
||||
} while(<loopExpr>);
|
||||
>>
|
||||
|
||||
// LL(*) stuff
|
||||
|
||||
AltBlock(choice, preamble, alts, error) ::= <<
|
||||
this.state = <choice.stateNumber>;
|
||||
this._errHandler.sync(this);
|
||||
<if(choice.label)><labelref(choice.label)> = _input.LT(1)<endif>
|
||||
<preamble; separator="\n">
|
||||
var la_ = this._interp.adaptivePredict(this._input,<choice.decision>,this._ctx);
|
||||
switch(la_) {
|
||||
<alts:{alt |
|
||||
case <i>:
|
||||
<alt>
|
||||
break;
|
||||
}; separator="\n">
|
||||
}
|
||||
>>
|
||||
|
||||
OptionalBlock(choice, alts, error) ::= <<
|
||||
this.state = <choice.stateNumber>;
|
||||
this._errHandler.sync(this);
|
||||
var la_ = this._interp.adaptivePredict(this._input,<choice.decision>,this._ctx);
|
||||
<alts:{alt |
|
||||
if(la_===<i><if(!choice.ast.greedy)>+1<endif>) {
|
||||
<alt>
|
||||
}; separator="\n} else ">
|
||||
}
|
||||
>>
|
||||
|
||||
StarBlock(choice, alts, sync, iteration) ::= <<
|
||||
this.state = <choice.stateNumber>;
|
||||
this._errHandler.sync(this);
|
||||
var _alt = this._interp.adaptivePredict(this._input,<choice.decision>,this._ctx)
|
||||
while(_alt!=<choice.exitAlt> && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
|
||||
if(_alt===1<if(!choice.ast.greedy)>+1<endif>) {
|
||||
<iteration>
|
||||
<alts> <! should only be one !>
|
||||
}
|
||||
this.state = <choice.loopBackStateNumber>;
|
||||
this._errHandler.sync(this);
|
||||
_alt = this._interp.adaptivePredict(this._input,<choice.decision>,this._ctx);
|
||||
}
|
||||
|
||||
>>
|
||||
|
||||
PlusBlock(choice, alts, error) ::= <<
|
||||
this.state = <choice.blockStartStateNumber>; <! alt block decision !>
|
||||
this._errHandler.sync(this);
|
||||
var _alt = 1<if(!choice.ast.greedy)>+1<endif>;
|
||||
do {
|
||||
switch (_alt) {
|
||||
<alts:{alt|
|
||||
case <i><if(!choice.ast.greedy)>+1<endif>:
|
||||
<alt>
|
||||
break;}; separator="\n">
|
||||
default:
|
||||
<error>
|
||||
}
|
||||
this.state = <choice.loopBackStateNumber>; <! loopback/exit decision !>
|
||||
this._errHandler.sync(this);
|
||||
_alt = this._interp.adaptivePredict(this._input,<choice.decision>, this._ctx);
|
||||
} while ( _alt!=<choice.exitAlt> && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER );
|
||||
>>
|
||||
|
||||
Sync(s) ::= "sync(<s.expecting.name>)"
|
||||
|
||||
ThrowNoViableAlt(t) ::= "throw new antlr4.error.NoViableAltException(this);"
|
||||
|
||||
TestSetInline(s) ::= <<
|
||||
<s.bitsets:{bits | <if(rest(rest(bits.ttypes)))><bitsetBitfieldComparison(s, bits)><else><bitsetInlineComparison(s, bits)><endif>}; separator=" || ">
|
||||
>>
|
||||
|
||||
// Javascript language spec - shift operators are 32 bits long max
|
||||
testShiftInRange(shiftAmount) ::= <<
|
||||
((<shiftAmount>) & ~0x1f) == 0
|
||||
>>
|
||||
|
||||
// produces smaller bytecode only when bits.ttypes contains more than two items
|
||||
bitsetBitfieldComparison(s, bits) ::= <%
|
||||
(<testShiftInRange({<offsetShiftVar(s.varName, bits.shift)>})> && ((1 \<\< <offsetShiftVar(s.varName, bits.shift)>) & (<bits.ttypes:{ttype | (1 \<\< <offsetShiftType(ttype, bits.shift)>)}; separator=" | ">)) !== 0)
|
||||
%>
|
||||
|
||||
isZero ::= [
|
||||
"0":true,
|
||||
default:false
|
||||
]
|
||||
|
||||
offsetShiftVar(shiftAmount, offset) ::= <%
|
||||
<if(!isZero.(offset))>(<shiftAmount> - <offset>)<else><shiftAmount><endif>
|
||||
%>
|
||||
|
||||
offsetShiftType(shiftAmount, offset) ::= <%
|
||||
<if(!isZero.(offset))>(<parser.name>.<shiftAmount> - <offset>)<else><parser.name>.<shiftAmount><endif>
|
||||
%>
|
||||
|
||||
// produces more efficient bytecode when bits.ttypes contains at most two items
|
||||
bitsetInlineComparison(s, bits) ::= <%
|
||||
<bits.ttypes:{ttype | <s.varName>===<parser.name>.<ttype>}; separator=" || ">
|
||||
%>
|
||||
|
||||
cases(ttypes) ::= <<
|
||||
<ttypes:{t | case <parser.name>.<t>:}; separator="\n">
|
||||
>>
|
||||
|
||||
InvokeRule(r, argExprsChunks) ::= <<
|
||||
this.state = <r.stateNumber>;
|
||||
<if(r.labels)><r.labels:{l | <labelref(l)> = }><endif>this.<r.name>(<if(r.ast.options.p)><r.ast.options.p><if(argExprsChunks)>,<endif><endif><argExprsChunks>);
|
||||
>>
|
||||
|
||||
MatchToken(m) ::= <<
|
||||
this.state = <m.stateNumber>;
|
||||
<if(m.labels)><m.labels:{l | <labelref(l)> = }><endif>this.match(<parser.name>.<m.name>);
|
||||
>>
|
||||
|
||||
MatchSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, false)>"
|
||||
|
||||
MatchNotSet(m, expr, capture) ::= "<CommonSetStuff(m, expr, capture, true)>"
|
||||
|
||||
CommonSetStuff(m, expr, capture, invert) ::= <<
|
||||
this.state = <m.stateNumber>;
|
||||
<if(m.labels)><m.labels:{l | <labelref(l)> = }>this._input.LT(1);<endif>
|
||||
<capture>
|
||||
<if(invert)>if(<m.varName>\<=0 || <expr>)<else>if(!(<expr>))<endif> {
|
||||
<if(m.labels)><m.labels:{l | <labelref(l)> = }><endif>this._errHandler.recoverInline(this);
|
||||
}
|
||||
else {
|
||||
this.consume();
|
||||
}
|
||||
>>
|
||||
|
||||
Wildcard(w) ::= <<
|
||||
this.state = <w.stateNumber>;
|
||||
<if(w.labels)><w.labels:{l | <labelref(l)> = }><endif>matchWildcard();
|
||||
>>
|
||||
|
||||
// ACTION STUFF
|
||||
|
||||
Action(a, foo, chunks) ::= "<chunks>"
|
||||
|
||||
ArgAction(a, chunks) ::= "<chunks>"
|
||||
|
||||
SemPred(p, chunks, failChunks) ::= <<
|
||||
this.state = <p.stateNumber>;
|
||||
if (!( <chunks>)) {
|
||||
throw new antlr4.error.FailedPredicateException(this, <p.predicate><if(failChunks)>, <failChunks><elseif(p.msg)>, <p.msg><endif>);
|
||||
}
|
||||
>>
|
||||
|
||||
ExceptionClause(e, catchArg, catchAction) ::= <<
|
||||
catch (<catchArg>) {
|
||||
<catchAction>
|
||||
}
|
||||
>>
|
||||
|
||||
// lexer actions are not associated with model objects
|
||||
|
||||
LexerSkipCommand() ::= "this.skip()"
|
||||
LexerMoreCommand() ::= "this.more()"
|
||||
LexerPopModeCommand() ::= "this.popMode()"
|
||||
LexerTypeCommand(arg) ::= "this._type = <arg>"
|
||||
LexerChannelCommand(arg) ::= "this._channel = <arg>"
|
||||
LexerModeCommand(arg) ::= "this._mode = <arg>"
|
||||
LexerPushModeCommand(arg) ::= "this.pushMode(<arg>)"
|
||||
|
||||
ActionText(t) ::= "<t.text>"
|
||||
ActionTemplate(t) ::= "<t.st>"
|
||||
ArgRef(a) ::= "localctx.<a.name>"
|
||||
LocalRef(a) ::= "localctx.<a.name>"
|
||||
RetValueRef(a) ::= "localctx.<a.name>"
|
||||
QRetValueRef(a) ::= "<ctx(a)>.<a.dict>.<a.name>"
|
||||
/** How to translate $tokenLabel */
|
||||
TokenRef(t) ::= "<ctx(t)>.<t.name>"
|
||||
LabelRef(t) ::= "<ctx(t)>.<t.name>"
|
||||
ListLabelRef(t) ::= "<ctx(t)>.<ListLabelName(t.name)>"
|
||||
SetAttr(s,rhsChunks) ::= "<ctx(s)>.<s.name> = <rhsChunks>"
|
||||
|
||||
TokenLabelType() ::= "<file.TokenLabelType; null={Token}>"
|
||||
InputSymbolType() ::= "<file.InputSymbolType; null={Token}>"
|
||||
|
||||
TokenPropertyRef_text(t) ::= "(<ctx(t)>.<t.label>===null ? null : <ctx(t)>.<t.label>.text)"
|
||||
TokenPropertyRef_type(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : <ctx(t)>.<t.label>.type)"
|
||||
TokenPropertyRef_line(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : <ctx(t)>.<t.label>.line)"
|
||||
TokenPropertyRef_pos(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : <ctx(t)>.<t.label>.column)"
|
||||
TokenPropertyRef_channel(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : <ctx(t)>.<t.label>.channel)"
|
||||
TokenPropertyRef_index(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : <ctx(t)>.<t.label>.tokenIndex)"
|
||||
TokenPropertyRef_int(t) ::= "(<ctx(t)>.<t.label> === null ? 0 : parseInt(<ctx(t)>.<t.label>.text))"
|
||||
|
||||
RulePropertyRef_start(r) ::= "(<ctx(r)>.<r.label>===null ? null : <ctx(r)>.<r.label>.start)"
|
||||
RulePropertyRef_stop(r) ::= "(<ctx(r)>.<r.label>===null ? null : <ctx(r)>.<r.label>.stop)"
|
||||
RulePropertyRef_text(r) ::= "(<ctx(r)>.<r.label>===null ? null : this._input.getText(new antlr4.Interval(<ctx(r)>.<r.label>.start,<ctx(r)>.<r.label>.stop)))"
|
||||
RulePropertyRef_ctx(r) ::= "<ctx(r)>.<r.label>"
|
||||
RulePropertyRef_parser(r) ::= "this"
|
||||
|
||||
ThisRulePropertyRef_start(r) ::= "localctx.start"
|
||||
ThisRulePropertyRef_stop(r) ::= "localctx.stop"
|
||||
ThisRulePropertyRef_text(r) ::= "this._input.getText(new antlr4.Interval(localctx.start, this._input.LT(-1)))"
|
||||
ThisRulePropertyRef_ctx(r) ::= "localctx"
|
||||
ThisRulePropertyRef_parser(r) ::= "this"
|
||||
|
||||
NonLocalAttrRef(s) ::= "getInvokingContext(<s.ruleIndex>).<s.name>"
|
||||
SetNonLocalAttr(s, rhsChunks) ::= "getInvokingContext(<s.ruleIndex>).<s.name> = <rhsChunks>"
|
||||
|
||||
AddToLabelList(a) ::= "<ctx(a.label)>.<a.listName>.push(<labelref(a.label)>);"
|
||||
|
||||
TokenDecl(t) ::= "this.<t.name> = null; // <TokenLabelType()>"
|
||||
TokenTypeDecl(t) ::= "var <t.name> = 0; // <TokenLabelType()> type"
|
||||
TokenListDecl(t) ::= "this.<t.name> = []; // of <TokenLabelType()>s"
|
||||
RuleContextDecl(r) ::= "this.<r.name> = null; // <r.ctxName>"
|
||||
RuleContextListDecl(rdecl) ::= "this.<rdecl.name> = []; // of <rdecl.ctxName>s"
|
||||
|
||||
ContextTokenGetterDecl(t) ::= <<
|
||||
<t.name> = function() {
|
||||
return this.getToken(<parser.name>.<t.name>, 0);
|
||||
};
|
||||
>>
|
||||
|
||||
// should never be called
|
||||
ContextTokenListGetterDecl(t) ::= <<
|
||||
def <t.name>_list(self):
|
||||
return self.getTokens(<parser.name>.<t.name>)
|
||||
>>
|
||||
|
||||
ContextTokenListIndexedGetterDecl(t) ::= <<
|
||||
<t.name> = function(i) {
|
||||
if(i===undefined) {
|
||||
i = null;
|
||||
}
|
||||
if(i===null) {
|
||||
return this.getTokens(<parser.name>.<t.name>);
|
||||
} else {
|
||||
return this.getToken(<parser.name>.<t.name>, i);
|
||||
}
|
||||
};
|
||||
|
||||
>>
|
||||
|
||||
ContextRuleGetterDecl(r) ::= <<
|
||||
<r.name> = function() {
|
||||
return this.getTypedRuleContext(<r.ctxName>,0);
|
||||
};
|
||||
>>
|
||||
|
||||
// should never be called
|
||||
ContextRuleListGetterDecl(r) ::= <<
|
||||
def <r.name>_list(self):
|
||||
return self.getTypedRuleContexts(<parser.name>.<r.ctxName>)
|
||||
|
||||
>>
|
||||
|
||||
ContextRuleListIndexedGetterDecl(r) ::= <<
|
||||
<r.name> = function(i) {
|
||||
if(i===undefined) {
|
||||
i = null;
|
||||
}
|
||||
if(i===null) {
|
||||
return this.getTypedRuleContexts(<r.ctxName>);
|
||||
} else {
|
||||
return this.getTypedRuleContext(<r.ctxName>,i);
|
||||
}
|
||||
};
|
||||
>>
|
||||
|
||||
LexerRuleContext() ::= "RuleContext"
|
||||
|
||||
/** The rule context name is the rule followed by a suffix; e.g.,
|
||||
* r becomes rContext.
|
||||
*/
|
||||
RuleContextNameSuffix() ::= "Context"
|
||||
|
||||
ImplicitTokenLabel(tokenName) ::= "_<tokenName>"
|
||||
ImplicitRuleLabel(ruleName) ::= "_<ruleName>"
|
||||
ImplicitSetLabel(id) ::= "_tset<id>"
|
||||
ListLabelName(label) ::= "<label>"
|
||||
|
||||
CaptureNextToken(d) ::= "<d.varName> = self._input.LT(1)"
|
||||
CaptureNextTokenType(d) ::= "<d.varName> = this._input.LA(1);"
|
||||
|
||||
StructDecl(struct,ctorAttrs,attrs,getters,dispatchMethods,interfaces,extensionMembers,
|
||||
superClass={antlr4.ParserRuleContext}) ::= <<
|
||||
function <struct.name>(parser, parent, invokingState<struct.ctorAttrs:{a | , <a.name>}>) {
|
||||
if(parent===undefined) {
|
||||
parent = null;
|
||||
}
|
||||
if(invokingState===undefined || invokingState===null) {
|
||||
invokingState = -1;
|
||||
}
|
||||
<superClass>.call(this, parent, invokingState);
|
||||
this.parser = parser;
|
||||
this.ruleIndex = <parser.name>.RULE_<struct.derivedFromName>;
|
||||
<attrs:{a | <a>}; separator="\n">
|
||||
<struct.ctorAttrs:{a | this.<a.name> = <a.name> || null;}; separator="\n">
|
||||
return this;
|
||||
}
|
||||
|
||||
<struct.name>.prototype = Object.create(<superClass>.prototype);
|
||||
<struct.name>.prototype.constructor = <struct.name>;
|
||||
|
||||
<getters:{g | <struct.name>.prototype.<g>}; separator="\n\n">
|
||||
|
||||
<if(struct.provideCopyFrom)> <! don't need copy unless we have subclasses !>
|
||||
<struct.name>.prototype.copyFrom = function(ctx) {
|
||||
<superClass>.prototype.copyFrom.call(this, ctx);
|
||||
<struct.attrs:{a | this.<a.name> = ctx.<a.name>;}; separator="\n">
|
||||
};
|
||||
<endif>
|
||||
<dispatchMethods; separator="\n">
|
||||
<extensionMembers; separator="\n">
|
||||
|
||||
>>
|
||||
|
||||
AltLabelStructDecl(struct,attrs,getters,dispatchMethods) ::= <<
|
||||
function <struct.name>(parser, ctx) {
|
||||
<currentRule.name; format="cap">Context.call(this, parser);
|
||||
<attrs:{a | <a>;}; separator="\n">
|
||||
<currentRule.name; format="cap">Context.prototype.copyFrom.call(this, ctx);
|
||||
return this;
|
||||
}
|
||||
|
||||
<struct.name>.prototype = Object.create(<currentRule.name; format="cap">Context.prototype);
|
||||
<struct.name>.prototype.constructor = <struct.name>;
|
||||
|
||||
<! Define fields of this parser to export this struct/context class !>
|
||||
<parser.name>.<struct.name> = <struct.name>;
|
||||
|
||||
<getters:{g | <struct.name>.prototype.<g>}; separator="\n\n">
|
||||
<dispatchMethods; separator="\n">
|
||||
|
||||
>>
|
||||
|
||||
ListenerDispatchMethod(method) ::= <<
|
||||
<struct.name>.prototype.<if(method.isEnter)>enter<else>exit<endif>Rule = function(listener) {
|
||||
if(listener instanceof <parser.grammarName>Listener ) {
|
||||
listener.<if(method.isEnter)>enter<else>exit<endif><struct.derivedFromName; format="cap">(this);
|
||||
}
|
||||
};
|
||||
|
||||
>>
|
||||
|
||||
VisitorDispatchMethod(method) ::= <<
|
||||
<struct.name>.prototype.accept = function(visitor) {
|
||||
if ( visitor instanceof <parser.grammarName>Visitor ) {
|
||||
return visitor.visit<struct.derivedFromName; format="cap">(this);
|
||||
} else {
|
||||
return visitor.visitChildren(this);
|
||||
}
|
||||
};
|
||||
|
||||
>>
|
||||
|
||||
AttributeDecl(d) ::= "this.<d.name> = <if(d.initValue)><d.initValue><else>null<endif>"
|
||||
|
||||
/** If we don't know location of label def x, use this template */
|
||||
labelref(x) ::= "<if(!x.isLocal)>localctx.<endif><x.name>"
|
||||
|
||||
/** For any action chunk, what is correctly-typed context struct ptr? */
|
||||
ctx(actionChunk) ::= "localctx"
|
||||
|
||||
// used for left-recursive rules
|
||||
recRuleAltPredicate(ruleName,opPrec) ::= "this.precpred(this._ctx, <opPrec>)"
|
||||
recRuleSetReturnAction(src,name) ::= "$<name>=$<src>.<name>"
|
||||
recRuleSetStopToken() ::= "this._ctx.stop = this._input.LT(-1);"
|
||||
|
||||
recRuleAltStartAction(ruleName, ctxName, label) ::= <<
|
||||
localctx = new <ctxName>Context(this, _parentctx, _parentState);
|
||||
<if(label)>localctx.<label> = _prevctx;<endif>
|
||||
this.pushNewRecursionContext(localctx, _startState, <parser.name>.RULE_<ruleName>);
|
||||
>>
|
||||
|
||||
recRuleLabeledAltStartAction(ruleName, currentAltLabel, label, isListLabel) ::= <<
|
||||
localctx = new <currentAltLabel; format="cap">Context(this, new <ruleName; format="cap">Context(this, _parentctx, _parentState));
|
||||
<if(label)>
|
||||
<if(isListLabel)>
|
||||
localctx.<label>.push(_prevctx);
|
||||
<else>
|
||||
localctx.<label> = _prevctx;
|
||||
<endif>
|
||||
<endif>
|
||||
this.pushNewRecursionContext(localctx, _startState, <parser.name>.RULE_<ruleName>);
|
||||
>>
|
||||
|
||||
recRuleReplaceContext(ctxName) ::= <<
|
||||
localctx = new <ctxName>Context(this, localctx);
|
||||
this._ctx = localctx;
|
||||
_prevctx = localctx;
|
||||
>>
|
||||
|
||||
recRuleSetPrevCtx() ::= <<
|
||||
if(this._parseListeners!==null) {
|
||||
this.triggerExitRuleEvent();
|
||||
}
|
||||
_prevctx = localctx;
|
||||
>>
|
||||
|
||||
|
||||
LexerFile(lexerFile, lexer, namedActions) ::= <<
|
||||
<fileHeader(lexerFile.grammarFileName, lexerFile.ANTLRVersion)>
|
||||
var antlr4 = require('antlr4/index');
|
||||
|
||||
<namedActions.header>
|
||||
|
||||
<lexer>
|
||||
|
||||
>>
|
||||
|
||||
Lexer(lexer, atn, actionFuncs, sempredFuncs, superClass) ::= <<
|
||||
|
||||
<atn>
|
||||
|
||||
var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
|
||||
|
||||
var decisionsToDFA = atn.decisionToState.map( function(ds, index) { return new antlr4.dfa.DFA(ds, index); });
|
||||
|
||||
function <lexer.name>(input) {
|
||||
<if(superClass)><superClass><else>antlr4.Lexer<endif>.call(this, input);
|
||||
this._interp = new antlr4.atn.LexerATNSimulator(this, atn, decisionsToDFA, new antlr4.PredictionContextCache());
|
||||
return this;
|
||||
}
|
||||
|
||||
<lexer.name>.prototype = Object.create(<if(superClass)><superClass><else>antlr4.Lexer<endif>.prototype);
|
||||
<lexer.name>.prototype.constructor = <lexer.name>;
|
||||
|
||||
<lexer.name>.EOF = antlr4.Token.EOF;
|
||||
<lexer.tokens:{k | <lexer.name>.<k> = <lexer.tokens.(k)>;}; separator="\n", wrap, anchor>
|
||||
|
||||
<rest(lexer.modes):{m| <lexer.name>.<m> = <i>;}; separator="\n">
|
||||
|
||||
<lexer.name>.modeNames = [ <lexer.modes:{m| "<m>"}; separator=", ", wrap, anchor> ];
|
||||
|
||||
<lexer.name>.literalNames = [ <lexer.literalNames:{t | <t>}; null="null", separator=", ", wrap, anchor> ];
|
||||
|
||||
<lexer.name>.symbolicNames = [ <lexer.symbolicNames:{t | <t>}; null="null", separator=", ", wrap, anchor> ];
|
||||
|
||||
<lexer.name>.ruleNames = [ <lexer.ruleNames:{r | "<r>"}; separator=", ", wrap, anchor> ];
|
||||
|
||||
<lexer.name>.grammarFileName = "<lexer.grammarFileName>";
|
||||
|
||||
<namedActions.members>
|
||||
|
||||
<dumpActions(lexer, "", actionFuncs, sempredFuncs)>
|
||||
|
||||
exports.<lexer.name> = <lexer.name>;
|
||||
|
||||
>>
|
||||
|
||||
SerializedATN(model) ::= <<
|
||||
<! only one segment, can be inlined !>
|
||||
|
||||
var serializedATN = ["<model.serialized; wrap={",<\n> "}>"].join("");
|
||||
|
||||
>>
|
||||
|
||||
/** Using a type to init value map, try to init a type; if not in table
|
||||
* must be an object, default value is "null".
|
||||
*/
|
||||
initValue(typeName) ::= <<
|
||||
<javaTypeInitMap.(typeName)>
|
||||
>>
|
||||
|
||||
codeFileExtension() ::= ".js"
|
||||
Loading…
Reference in New Issue