mmir-lib
Version:
MMIR (Mobile Multimodal Interaction and Relay) library
1,645 lines (1,403 loc) • 463 kB
JavaScript
define(['mmirf/antlr3'], function(org){
// $ANTLR 3.3 Nov 30, 2010 12:50:56
var ES3Parser = function(input, state) {
if (!state) {
state = new org.antlr.runtime.RecognizerSharedState();
}
(function(){
//MODIFICATION: array for tracking ampersat-Identifiers
this.ampersatIdentifiers = new Array();
var theParser = ES3Parser;
this.theParser = theParser;
this.input = input;
//private final boolean
function isLeftHandSideAssign(lhs, cached)//RuleReturnScope lhs, Object[] cached)
{
if (cached[0] != null)
{
return cached[0] == true;//((Boolean)cached[0]).booleanValue();
}
// boolean
var result;
if (this.isLeftHandSideExpression(lhs) == true)
{
switch (input.LA(1))
{
case theParser.ASSIGN:
case theParser.MULASS:
case theParser.DIVASS:
case theParser.MODASS:
case theParser.ADDASS:
case theParser.SUBASS:
case theParser.SHLASS:
case theParser.SHRASS:
case theParser.SHUASS:
case theParser.ANDASS:
case theParser.XORASS:
case theParser.ORASS:
result = true;
break;
default:
result = false;
break;
}
}
else
{
result = false;
}
cached[0] = result;// new Boolean(result);
return result;
}
this.isLeftHandSideAssign = isLeftHandSideAssign;
//private final static boolean
function isLeftHandSideExpression(lhs)//RuleReturnScope lhs)
{
if (lhs.getTree() == null) // e.g. during backtracking
{
return true;
}
else
{
switch ((/*(Tree)*/lhs.getTree()).getType())
{
// primaryExpression
case theParser.THIS:
case theParser.Identifier:
case theParser.IdentifierNameAmpersatStart://MODIFICATION: do accept special amperat-Identifier as valid lhs
case theParser.NULL:
case theParser.TRUE:
case theParser.FALSE:
case theParser.DecimalLiteral:
case theParser.OctalIntegerLiteral:
case theParser.HexIntegerLiteral:
case theParser.StringLiteral:
case theParser.RegularExpressionLiteral:
case theParser.ARRAY:
case theParser.OBJECT:
case theParser.PAREXPR:
// functionExpression
case theParser.FUNCTION:
// newExpression
case theParser.NEW:
// leftHandSideExpression
case theParser.CALL:
case theParser.BYFIELD:
case theParser.BYINDEX:
return true;
default:
return false;
}
}
}
this.isLeftHandSideExpression = isLeftHandSideExpression;
//private final boolean
function isLeftHandSideIn(lhs, cached)//RuleReturnScope lhs, Object[] cached)
{
if (cached[0] != null)
{
return cached[0] == true;// ((Boolean)cached[0]).booleanValue();
}
//boolean
var result = this.isLeftHandSideExpression(lhs) == true && (this.input.LA(1) == theParser.IN);
cached[0] = result;//new Boolean(result);
return result;
}
this.isLeftHandSideIn = isLeftHandSideIn;
//private final void
function promoteEOL(rule)//ParserRuleReturnScope rule)
{
// Get current token and its type (the possibly offending token).
//Token
var lt = this.input.LT(1);
//int
var la = lt.getType();
// We only need to promote an EOL when the current token is offending (not a SEMIC, EOF, RBRACE, EOL or MultiLineComment).
// EOL and MultiLineComment are not offending as they're already promoted in a previous call to this method.
// Promoting an EOL means switching it from off channel to on channel.
// A MultiLineComment gets promoted when it contains an EOL.
if (!(la == theParser.SEMIC || la == theParser.EOF || la == theParser.RBRACE || la == theParser.EOL || la == theParser.MultiLineComment))
{
// Start on the possition before the current token and scan backwards off channel tokens until the previous on channel token.
for (/*int*/var ix = lt.getTokenIndex() - 1; ix > 0; ix--)
{
lt = this.input.get(ix);
if (lt.getChannel() == org.antlr.runtime.Token.DEFAULT_CHANNEL)
{
// On channel token found: stop scanning.
break;
}
else if (lt.getType() == theParser.EOL || (lt.getType() == theParser.MultiLineComment && lt.getText().matches("/.*\r\n|\r|\n")))
{
// We found our EOL: promote the token to on channel, position the input on it and reset the rule start.
lt.setChannel(org.antlr.runtime.Token.DEFAULT_CHANNEL);
this.input.seek(lt.getTokenIndex());
if (rule != null)
{
rule.start = lt;
}
break;
}
}
}
}
this.promoteEOL = promoteEOL
}).call(this);
ES3Parser.superclass.constructor.call(this, input, state);
this.dfa43 = new ES3Parser.DFA43(this);
this.dfa44 = new ES3Parser.DFA44(this);
this.dfa74 = new ES3Parser.DFA74(this);
/* @todo only create adaptor if output=AST */
this.adaptor = new org.antlr.runtime.tree.CommonTreeAdaptor();
};
org.antlr.lang.augmentObject(ES3Parser, {
EOF: -1,
RENDER: 4,
AMPERSAT: 5,
NULL: 6,
TRUE: 7,
FALSE: 8,
BREAK: 9,
CASE: 10,
CATCH: 11,
CONTINUE: 12,
DEFAULT: 13,
DELETE: 14,
DO: 15,
ELSE: 16,
FINALLY: 17,
FOR: 18,
FUNCTION: 19,
IF: 20,
IN: 21,
INSTANCEOF: 22,
NEW: 23,
RETURN: 24,
SWITCH: 25,
THIS: 26,
THROW: 27,
TRY: 28,
TYPEOF: 29,
VAR: 30,
VOID: 31,
WHILE: 32,
WITH: 33,
ABSTRACT: 34,
BOOLEAN: 35,
BYTE: 36,
CHAR: 37,
CLASS: 38,
CONST: 39,
DEBUGGER: 40,
DOUBLE: 41,
ENUM: 42,
EXPORT: 43,
EXTENDS: 44,
FINAL: 45,
FLOAT: 46,
GOTO: 47,
IMPLEMENTS: 48,
IMPORT: 49,
INT: 50,
INTERFACE: 51,
LONG: 52,
NATIVE: 53,
PACKAGE: 54,
PRIVATE: 55,
PROTECTED: 56,
PUBLIC: 57,
SHORT: 58,
STATIC: 59,
SUPER: 60,
SYNCHRONIZED: 61,
THROWS: 62,
TRANSIENT: 63,
VOLATILE: 64,
LBRACE: 65,
RBRACE: 66,
LBRACK: 67,
RBRACK: 68,
DOT: 69,
SEMIC: 70,
COMMA: 71,
LT: 72,
GT: 73,
LTE: 74,
GTE: 75,
EQ: 76,
NEQ: 77,
SAME: 78,
NSAME: 79,
ADD: 80,
SUB: 81,
MUL: 82,
MOD: 83,
INC: 84,
DEC: 85,
SHL: 86,
SHR: 87,
SHU: 88,
AND: 89,
OR: 90,
XOR: 91,
NOT: 92,
INV: 93,
LAND: 94,
LOR: 95,
QUE: 96,
COLON: 97,
ASSIGN: 98,
ADDASS: 99,
SUBASS: 100,
MULASS: 101,
MODASS: 102,
SHLASS: 103,
SHRASS: 104,
SHUASS: 105,
ANDASS: 106,
ORASS: 107,
XORASS: 108,
DIV: 109,
DIVASS: 110,
ARGS: 111,
ARRAY: 112,
BLOCK: 113,
BYFIELD: 114,
BYINDEX: 115,
CALL: 116,
CEXPR: 117,
EXPR: 118,
FORITER: 119,
FORSTEP: 120,
ITEM: 121,
LABELLED: 122,
NAMEDVALUE: 123,
NEG: 124,
OBJECT: 125,
PAREXPR: 126,
PDEC: 127,
PINC: 128,
POS: 129,
BSLASH: 130,
DQUOTE: 131,
SQUOTE: 132,
TAB: 133,
VT: 134,
FF: 135,
SP: 136,
NBSP: 137,
USP: 138,
WhiteSpace: 139,
LF: 140,
CR: 141,
LS: 142,
PS: 143,
LineTerminator: 144,
EOL: 145,
MultiLineComment: 146,
SingleLineComment: 147,
Identifier: 148,
StringLiteral: 149,
HexDigit: 150,
IdentifierStartASCII: 151,
DecimalDigit: 152,
IdentifierPart: 153,
IdentifierNameASCIIStart: 154,
IdentifierNameAmpersatStart: 155,
LPAREN: 156,
RPAREN: 157,
RegularExpressionLiteral: 158,
OctalDigit: 159,
ExponentPart: 160,
DecimalIntegerLiteral: 161,
DecimalLiteral: 162,
OctalIntegerLiteral: 163,
HexIntegerLiteral: 164,
CharacterEscapeSequence: 165,
ZeroToThree: 166,
OctalEscapeSequence: 167,
HexEscapeSequence: 168,
UnicodeEscapeSequence: 169,
EscapeSequence: 170,
BackslashSequence: 171,
RegularExpressionFirstChar: 172,
RegularExpressionChar: 173
});
(function(){
// public class variables
var EOF= -1,
RENDER= 4,
AMPERSAT= 5,
NULL= 6,
TRUE= 7,
FALSE= 8,
BREAK= 9,
CASE= 10,
CATCH= 11,
CONTINUE= 12,
DEFAULT= 13,
DELETE= 14,
DO= 15,
ELSE= 16,
FINALLY= 17,
FOR= 18,
FUNCTION= 19,
IF= 20,
IN= 21,
INSTANCEOF= 22,
NEW= 23,
RETURN= 24,
SWITCH= 25,
THIS= 26,
THROW= 27,
TRY= 28,
TYPEOF= 29,
VAR= 30,
VOID= 31,
WHILE= 32,
WITH= 33,
ABSTRACT= 34,
BOOLEAN= 35,
BYTE= 36,
CHAR= 37,
CLASS= 38,
CONST= 39,
DEBUGGER= 40,
DOUBLE= 41,
ENUM= 42,
EXPORT= 43,
EXTENDS= 44,
FINAL= 45,
FLOAT= 46,
GOTO= 47,
IMPLEMENTS= 48,
IMPORT= 49,
INT= 50,
INTERFACE= 51,
LONG= 52,
NATIVE= 53,
PACKAGE= 54,
PRIVATE= 55,
PROTECTED= 56,
PUBLIC= 57,
SHORT= 58,
STATIC= 59,
SUPER= 60,
SYNCHRONIZED= 61,
THROWS= 62,
TRANSIENT= 63,
VOLATILE= 64,
LBRACE= 65,
RBRACE= 66,
LBRACK= 67,
RBRACK= 68,
DOT= 69,
SEMIC= 70,
COMMA= 71,
LT= 72,
GT= 73,
LTE= 74,
GTE= 75,
EQ= 76,
NEQ= 77,
SAME= 78,
NSAME= 79,
ADD= 80,
SUB= 81,
MUL= 82,
MOD= 83,
INC= 84,
DEC= 85,
SHL= 86,
SHR= 87,
SHU= 88,
AND= 89,
OR= 90,
XOR= 91,
NOT= 92,
INV= 93,
LAND= 94,
LOR= 95,
QUE= 96,
COLON= 97,
ASSIGN= 98,
ADDASS= 99,
SUBASS= 100,
MULASS= 101,
MODASS= 102,
SHLASS= 103,
SHRASS= 104,
SHUASS= 105,
ANDASS= 106,
ORASS= 107,
XORASS= 108,
DIV= 109,
DIVASS= 110,
ARGS= 111,
ARRAY= 112,
BLOCK= 113,
BYFIELD= 114,
BYINDEX= 115,
CALL= 116,
CEXPR= 117,
EXPR= 118,
FORITER= 119,
FORSTEP= 120,
ITEM= 121,
LABELLED= 122,
NAMEDVALUE= 123,
NEG= 124,
OBJECT= 125,
PAREXPR= 126,
PDEC= 127,
PINC= 128,
POS= 129,
BSLASH= 130,
DQUOTE= 131,
SQUOTE= 132,
TAB= 133,
VT= 134,
FF= 135,
SP= 136,
NBSP= 137,
USP= 138,
WhiteSpace= 139,
LF= 140,
CR= 141,
LS= 142,
PS= 143,
LineTerminator= 144,
EOL= 145,
MultiLineComment= 146,
SingleLineComment= 147,
Identifier= 148,
StringLiteral= 149,
HexDigit= 150,
IdentifierStartASCII= 151,
DecimalDigit= 152,
IdentifierPart= 153,
IdentifierNameASCIIStart= 154,
IdentifierNameAmpersatStart= 155,
LPAREN= 156,
RPAREN= 157,
RegularExpressionLiteral= 158,
OctalDigit= 159,
ExponentPart= 160,
DecimalIntegerLiteral= 161,
DecimalLiteral= 162,
OctalIntegerLiteral= 163,
HexIntegerLiteral= 164,
CharacterEscapeSequence= 165,
ZeroToThree= 166,
OctalEscapeSequence= 167,
HexEscapeSequence= 168,
UnicodeEscapeSequence= 169,
EscapeSequence= 170,
BackslashSequence= 171,
RegularExpressionFirstChar= 172,
RegularExpressionChar= 173;
// public instance methods/vars
org.antlr.lang.extend(ES3Parser, org.antlr.runtime.Parser, {
setTreeAdaptor: function(adaptor) {
this.adaptor = adaptor;
},
getTreeAdaptor: function() {
return this.adaptor;
},
getTokenNames: function() { return ES3Parser.tokenNames; },
getGrammarFileName: function() { return "ES3.g3"; }
});
org.antlr.lang.augmentObject(ES3Parser.prototype, {
// inline static return class
token_return: (function() {
ES3Parser.token_return = function(){};
org.antlr.lang.extend(ES3Parser.token_return,
org.antlr.runtime.ParserRuleReturnScope,
{
getTree: function() { return this.tree; }
});
return;
})(),
// ES3.g3:830:1: token : ( reservedWord | Identifier | punctuator | numericLiteral | StringLiteral );
// $ANTLR start "token"
token: function() {
var retval = new ES3Parser.token_return();
retval.start = this.input.LT(1);
var root_0 = null;
var Identifier2 = null;
var StringLiteral5 = null;
var reservedWord1 = null;
var punctuator3 = null;
var numericLiteral4 = null;
var Identifier2_tree=null;
var StringLiteral5_tree=null;
try {
// ES3.g3:831:2: ( reservedWord | Identifier | punctuator | numericLiteral | StringLiteral )
var alt1=5;
switch ( this.input.LA(1) ) {
case NULL:
case TRUE:
case FALSE:
case BREAK:
case CASE:
case CATCH:
case CONTINUE:
case DEFAULT:
case DELETE:
case DO:
case ELSE:
case FINALLY:
case FOR:
case FUNCTION:
case IF:
case IN:
case INSTANCEOF:
case NEW:
case RETURN:
case SWITCH:
case THIS:
case THROW:
case TRY:
case TYPEOF:
case VAR:
case VOID:
case WHILE:
case WITH:
case ABSTRACT:
case BOOLEAN:
case BYTE:
case CHAR:
case CLASS:
case CONST:
case DEBUGGER:
case DOUBLE:
case ENUM:
case EXPORT:
case EXTENDS:
case FINAL:
case FLOAT:
case GOTO:
case IMPLEMENTS:
case IMPORT:
case INT:
case INTERFACE:
case LONG:
case NATIVE:
case PACKAGE:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case SHORT:
case STATIC:
case SUPER:
case SYNCHRONIZED:
case THROWS:
case TRANSIENT:
case VOLATILE:
alt1=1;
break;
case Identifier:
alt1=2;
break;
case LBRACE:
case RBRACE:
case LBRACK:
case RBRACK:
case DOT:
case SEMIC:
case COMMA:
case LT:
case GT:
case LTE:
case GTE:
case EQ:
case NEQ:
case SAME:
case NSAME:
case ADD:
case SUB:
case MUL:
case MOD:
case INC:
case DEC:
case SHL:
case SHR:
case SHU:
case AND:
case OR:
case XOR:
case NOT:
case INV:
case LAND:
case LOR:
case QUE:
case COLON:
case ASSIGN:
case ADDASS:
case SUBASS:
case MULASS:
case MODASS:
case SHLASS:
case SHRASS:
case SHUASS:
case ANDASS:
case ORASS:
case XORASS:
case DIV:
case DIVASS:
case LPAREN:
case RPAREN:
alt1=3;
break;
case DecimalLiteral:
case OctalIntegerLiteral:
case HexIntegerLiteral:
alt1=4;
break;
case StringLiteral:
alt1=5;
break;
default:
var nvae =
new org.antlr.runtime.NoViableAltException("", 1, 0, this.input);
throw nvae;
}
switch (alt1) {
case 1 :
// ES3.g3:831:4: reservedWord
root_0 = this.adaptor.nil();
this.pushFollow(ES3Parser.FOLLOW_reservedWord_in_token1735);
reservedWord1=this.reservedWord();
this.state._fsp--;
this.adaptor.addChild(root_0, reservedWord1.getTree());
break;
case 2 :
// ES3.g3:832:4: Identifier
root_0 = this.adaptor.nil();
Identifier2=this.match(this.input,Identifier,ES3Parser.FOLLOW_Identifier_in_token1740);
Identifier2_tree = this.adaptor.create(Identifier2);
this.adaptor.addChild(root_0, Identifier2_tree);
break;
case 3 :
// ES3.g3:833:4: punctuator
root_0 = this.adaptor.nil();
this.pushFollow(ES3Parser.FOLLOW_punctuator_in_token1745);
punctuator3=this.punctuator();
this.state._fsp--;
this.adaptor.addChild(root_0, punctuator3.getTree());
break;
case 4 :
// ES3.g3:834:4: numericLiteral
root_0 = this.adaptor.nil();
this.pushFollow(ES3Parser.FOLLOW_numericLiteral_in_token1750);
numericLiteral4=this.numericLiteral();
this.state._fsp--;
this.adaptor.addChild(root_0, numericLiteral4.getTree());
break;
case 5 :
// ES3.g3:835:4: StringLiteral
root_0 = this.adaptor.nil();
StringLiteral5=this.match(this.input,StringLiteral,ES3Parser.FOLLOW_StringLiteral_in_token1755);
StringLiteral5_tree = this.adaptor.create(StringLiteral5);
this.adaptor.addChild(root_0, StringLiteral5_tree);
break;
}
retval.stop = this.input.LT(-1);
retval.tree = this.adaptor.rulePostProcessing(root_0);
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (re) {
if (re instanceof org.antlr.runtime.RecognitionException) {
this.reportError(re);
this.recover(this.input,re);
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
} else {
throw re;
}
}
finally {
}
return retval;
},
// inline static return class
reservedWord_return: (function() {
ES3Parser.reservedWord_return = function(){};
org.antlr.lang.extend(ES3Parser.reservedWord_return,
org.antlr.runtime.ParserRuleReturnScope,
{
getTree: function() { return this.tree; }
});
return;
})(),
// ES3.g3:840:1: reservedWord : ( keyword | futureReservedWord | NULL | booleanLiteral );
// $ANTLR start "reservedWord"
reservedWord: function() {
var retval = new ES3Parser.reservedWord_return();
retval.start = this.input.LT(1);
var root_0 = null;
var NULL8 = null;
var keyword6 = null;
var futureReservedWord7 = null;
var booleanLiteral9 = null;
var NULL8_tree=null;
try {
// ES3.g3:841:2: ( keyword | futureReservedWord | NULL | booleanLiteral )
var alt2=4;
switch ( this.input.LA(1) ) {
case BREAK:
case CASE:
case CATCH:
case CONTINUE:
case DEFAULT:
case DELETE:
case DO:
case ELSE:
case FINALLY:
case FOR:
case FUNCTION:
case IF:
case IN:
case INSTANCEOF:
case NEW:
case RETURN:
case SWITCH:
case THIS:
case THROW:
case TRY:
case TYPEOF:
case VAR:
case VOID:
case WHILE:
case WITH:
alt2=1;
break;
case ABSTRACT:
case BOOLEAN:
case BYTE:
case CHAR:
case CLASS:
case CONST:
case DEBUGGER:
case DOUBLE:
case ENUM:
case EXPORT:
case EXTENDS:
case FINAL:
case FLOAT:
case GOTO:
case IMPLEMENTS:
case IMPORT:
case INT:
case INTERFACE:
case LONG:
case NATIVE:
case PACKAGE:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case SHORT:
case STATIC:
case SUPER:
case SYNCHRONIZED:
case THROWS:
case TRANSIENT:
case VOLATILE:
alt2=2;
break;
case NULL:
alt2=3;
break;
case TRUE:
case FALSE:
alt2=4;
break;
default:
var nvae =
new org.antlr.runtime.NoViableAltException("", 2, 0, this.input);
throw nvae;
}
switch (alt2) {
case 1 :
// ES3.g3:841:4: keyword
root_0 = this.adaptor.nil();
this.pushFollow(ES3Parser.FOLLOW_keyword_in_reservedWord1768);
keyword6=this.keyword();
this.state._fsp--;
this.adaptor.addChild(root_0, keyword6.getTree());
break;
case 2 :
// ES3.g3:842:4: futureReservedWord
root_0 = this.adaptor.nil();
this.pushFollow(ES3Parser.FOLLOW_futureReservedWord_in_reservedWord1773);
futureReservedWord7=this.futureReservedWord();
this.state._fsp--;
this.adaptor.addChild(root_0, futureReservedWord7.getTree());
break;
case 3 :
// ES3.g3:843:4: NULL
root_0 = this.adaptor.nil();
NULL8=this.match(this.input,NULL,ES3Parser.FOLLOW_NULL_in_reservedWord1778);
NULL8_tree = this.adaptor.create(NULL8);
this.adaptor.addChild(root_0, NULL8_tree);
break;
case 4 :
// ES3.g3:844:4: booleanLiteral
root_0 = this.adaptor.nil();
this.pushFollow(ES3Parser.FOLLOW_booleanLiteral_in_reservedWord1783);
booleanLiteral9=this.booleanLiteral();
this.state._fsp--;
this.adaptor.addChild(root_0, booleanLiteral9.getTree());
break;
}
retval.stop = this.input.LT(-1);
retval.tree = this.adaptor.rulePostProcessing(root_0);
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (re) {
if (re instanceof org.antlr.runtime.RecognitionException) {
this.reportError(re);
this.recover(this.input,re);
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
} else {
throw re;
}
}
finally {
}
return retval;
},
// inline static return class
keyword_return: (function() {
ES3Parser.keyword_return = function(){};
org.antlr.lang.extend(ES3Parser.keyword_return,
org.antlr.runtime.ParserRuleReturnScope,
{
getTree: function() { return this.tree; }
});
return;
})(),
// ES3.g3:851:1: keyword : ( BREAK | CASE | CATCH | CONTINUE | DEFAULT | DELETE | DO | ELSE | FINALLY | FOR | FUNCTION | IF | IN | INSTANCEOF | NEW | RETURN | SWITCH | THIS | THROW | TRY | TYPEOF | VAR | VOID | WHILE | WITH );
// $ANTLR start "keyword"
keyword: function() {
var retval = new ES3Parser.keyword_return();
retval.start = this.input.LT(1);
var root_0 = null;
var set10 = null;
var set10_tree=null;
try {
// ES3.g3:852:2: ( BREAK | CASE | CATCH | CONTINUE | DEFAULT | DELETE | DO | ELSE | FINALLY | FOR | FUNCTION | IF | IN | INSTANCEOF | NEW | RETURN | SWITCH | THIS | THROW | TRY | TYPEOF | VAR | VOID | WHILE | WITH )
// ES3.g3:
root_0 = this.adaptor.nil();
set10=this.input.LT(1);
if ( (this.input.LA(1)>=BREAK && this.input.LA(1)<=WITH) ) {
this.input.consume();
this.adaptor.addChild(root_0, this.adaptor.create(set10));
this.state.errorRecovery=false;
}
else {
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
throw mse;
}
retval.stop = this.input.LT(-1);
retval.tree = this.adaptor.rulePostProcessing(root_0);
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (re) {
if (re instanceof org.antlr.runtime.RecognitionException) {
this.reportError(re);
this.recover(this.input,re);
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
} else {
throw re;
}
}
finally {
}
return retval;
},
// inline static return class
futureReservedWord_return: (function() {
ES3Parser.futureReservedWord_return = function(){};
org.antlr.lang.extend(ES3Parser.futureReservedWord_return,
org.antlr.runtime.ParserRuleReturnScope,
{
getTree: function() { return this.tree; }
});
return;
})(),
// ES3.g3:883:1: futureReservedWord : ( ABSTRACT | BOOLEAN | BYTE | CHAR | CLASS | CONST | DEBUGGER | DOUBLE | ENUM | EXPORT | EXTENDS | FINAL | FLOAT | GOTO | IMPLEMENTS | IMPORT | INT | INTERFACE | LONG | NATIVE | PACKAGE | PRIVATE | PROTECTED | PUBLIC | SHORT | STATIC | SUPER | SYNCHRONIZED | THROWS | TRANSIENT | VOLATILE );
// $ANTLR start "futureReservedWord"
futureReservedWord: function() {
var retval = new ES3Parser.futureReservedWord_return();
retval.start = this.input.LT(1);
var root_0 = null;
var set11 = null;
var set11_tree=null;
try {
// ES3.g3:884:2: ( ABSTRACT | BOOLEAN | BYTE | CHAR | CLASS | CONST | DEBUGGER | DOUBLE | ENUM | EXPORT | EXTENDS | FINAL | FLOAT | GOTO | IMPLEMENTS | IMPORT | INT | INTERFACE | LONG | NATIVE | PACKAGE | PRIVATE | PROTECTED | PUBLIC | SHORT | STATIC | SUPER | SYNCHRONIZED | THROWS | TRANSIENT | VOLATILE )
// ES3.g3:
root_0 = this.adaptor.nil();
set11=this.input.LT(1);
if ( (this.input.LA(1)>=ABSTRACT && this.input.LA(1)<=VOLATILE) ) {
this.input.consume();
this.adaptor.addChild(root_0, this.adaptor.create(set11));
this.state.errorRecovery=false;
}
else {
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
throw mse;
}
retval.stop = this.input.LT(-1);
retval.tree = this.adaptor.rulePostProcessing(root_0);
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (re) {
if (re instanceof org.antlr.runtime.RecognitionException) {
this.reportError(re);
this.recover(this.input,re);
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
} else {
throw re;
}
}
finally {
}
return retval;
},
// inline static return class
punctuator_return: (function() {
ES3Parser.punctuator_return = function(){};
org.antlr.lang.extend(ES3Parser.punctuator_return,
org.antlr.runtime.ParserRuleReturnScope,
{
getTree: function() { return this.tree; }
});
return;
})(),
// ES3.g3:968:1: punctuator : ( LBRACE | RBRACE | LPAREN | RPAREN | LBRACK | RBRACK | DOT | SEMIC | COMMA | LT | GT | LTE | GTE | EQ | NEQ | SAME | NSAME | ADD | SUB | MUL | MOD | INC | DEC | SHL | SHR | SHU | AND | OR | XOR | NOT | INV | LAND | LOR | QUE | COLON | ASSIGN | ADDASS | SUBASS | MULASS | MODASS | SHLASS | SHRASS | SHUASS | ANDASS | ORASS | XORASS | DIV | DIVASS );
// $ANTLR start "punctuator"
punctuator: function() {
var retval = new ES3Parser.punctuator_return();
retval.start = this.input.LT(1);
var root_0 = null;
var set12 = null;
var set12_tree=null;
try {
// ES3.g3:969:2: ( LBRACE | RBRACE | LPAREN | RPAREN | LBRACK | RBRACK | DOT | SEMIC | COMMA | LT | GT | LTE | GTE | EQ | NEQ | SAME | NSAME | ADD | SUB | MUL | MOD | INC | DEC | SHL | SHR | SHU | AND | OR | XOR | NOT | INV | LAND | LOR | QUE | COLON | ASSIGN | ADDASS | SUBASS | MULASS | MODASS | SHLASS | SHRASS | SHUASS | ANDASS | ORASS | XORASS | DIV | DIVASS )
// ES3.g3:
root_0 = this.adaptor.nil();
set12=this.input.LT(1);
if ( (this.input.LA(1)>=LBRACE && this.input.LA(1)<=DIVASS)||(this.input.LA(1)>=LPAREN && this.input.LA(1)<=RPAREN) ) {
this.input.consume();
this.adaptor.addChild(root_0, this.adaptor.create(set12));
this.state.errorRecovery=false;
}
else {
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
throw mse;
}
retval.stop = this.input.LT(-1);
retval.tree = this.adaptor.rulePostProcessing(root_0);
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (re) {
if (re instanceof org.antlr.runtime.RecognitionException) {
this.reportError(re);
this.recover(this.input,re);
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
} else {
throw re;
}
}
finally {
}
return retval;
},
// inline static return class
literal_return: (function() {
ES3Parser.literal_return = function(){};
org.antlr.lang.extend(ES3Parser.literal_return,
org.antlr.runtime.ParserRuleReturnScope,
{
getTree: function() { return this.tree; }
});
return;
})(),
// ES3.g3:1023:1: literal : ( NULL | booleanLiteral | numericLiteral | StringLiteral | RegularExpressionLiteral );
// $ANTLR start "literal"
literal: function() {
var retval = new ES3Parser.literal_return();
retval.start = this.input.LT(1);
var root_0 = null;
var NULL13 = null;
var StringLiteral16 = null;
var RegularExpressionLiteral17 = null;
var booleanLiteral14 = null;
var numericLiteral15 = null;
var NULL13_tree=null;
var StringLiteral16_tree=null;
var RegularExpressionLiteral17_tree=null;
try {
// ES3.g3:1024:2: ( NULL | booleanLiteral | numericLiteral | StringLiteral | RegularExpressionLiteral )
var alt3=5;
switch ( this.input.LA(1) ) {
case NULL:
alt3=1;
break;
case TRUE:
case FALSE:
alt3=2;
break;
case DecimalLiteral:
case OctalIntegerLiteral:
case HexIntegerLiteral:
alt3=3;
break;
case StringLiteral:
alt3=4;
break;
case RegularExpressionLiteral:
alt3=5;
break;
default:
var nvae =
new org.antlr.runtime.NoViableAltException("", 3, 0, this.input);
throw nvae;
}
switch (alt3) {
case 1 :
// ES3.g3:1024:4: NULL
root_0 = this.adaptor.nil();
NULL13=this.match(this.input,NULL,ES3Parser.FOLLOW_NULL_in_literal2480);
NULL13_tree = this.adaptor.create(NULL13);
this.adaptor.addChild(root_0, NULL13_tree);
break;
case 2 :
// ES3.g3:1025:4: booleanLiteral
root_0 = this.adaptor.nil();
this.pushFollow(ES3Parser.FOLLOW_booleanLiteral_in_literal2485);
booleanLiteral14=this.booleanLiteral();
this.state._fsp--;
this.adaptor.addChild(root_0, booleanLiteral14.getTree());
break;
case 3 :
// ES3.g3:1026:4: numericLiteral
root_0 = this.adaptor.nil();
this.pushFollow(ES3Parser.FOLLOW_numericLiteral_in_literal2490);
numericLiteral15=this.numericLiteral();
this.state._fsp--;
this.adaptor.addChild(root_0, numericLiteral15.getTree());
break;
case 4 :
// ES3.g3:1027:4: StringLiteral
root_0 = this.adaptor.nil();
StringLiteral16=this.match(this.input,StringLiteral,ES3Parser.FOLLOW_StringLiteral_in_literal2495);
StringLiteral16_tree = this.adaptor.create(StringLiteral16);
this.adaptor.addChild(root_0, StringLiteral16_tree);
break;
case 5 :
// ES3.g3:1028:4: RegularExpressionLiteral
root_0 = this.adaptor.nil();
RegularExpressionLiteral17=this.match(this.input,RegularExpressionLiteral,ES3Parser.FOLLOW_RegularExpressionLiteral_in_literal2500);
RegularExpressionLiteral17_tree = this.adaptor.create(RegularExpressionLiteral17);
this.adaptor.addChild(root_0, RegularExpressionLiteral17_tree);
break;
}
retval.stop = this.input.LT(-1);
retval.tree = this.adaptor.rulePostProcessing(root_0);
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (re) {
if (re instanceof org.antlr.runtime.RecognitionException) {
this.reportError(re);
this.recover(this.input,re);
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
} else {
throw re;
}
}
finally {
}
return retval;
},
// inline static return class
booleanLiteral_return: (function() {
ES3Parser.booleanLiteral_return = function(){};
org.antlr.lang.extend(ES3Parser.booleanLiteral_return,
org.antlr.runtime.ParserRuleReturnScope,
{
getTree: function() { return this.tree; }
});
return;
})(),
// ES3.g3:1031:1: booleanLiteral : ( TRUE | FALSE );
// $ANTLR start "booleanLiteral"
booleanLiteral: function() {
var retval = new ES3Parser.booleanLiteral_return();
retval.start = this.input.LT(1);
var root_0 = null;
var set18 = null;
var set18_tree=null;
try {
// ES3.g3:1032:2: ( TRUE | FALSE )
// ES3.g3:
root_0 = this.adaptor.nil();
set18=this.input.LT(1);
if ( (this.input.LA(1)>=TRUE && this.input.LA(1)<=FALSE) ) {
this.input.consume();
this.adaptor.addChild(root_0, this.adaptor.create(set18));
this.state.errorRecovery=false;
}
else {
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
throw mse;
}
retval.stop = this.input.LT(-1);
retval.tree = this.adaptor.rulePostProcessing(root_0);
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (re) {
if (re instanceof org.antlr.runtime.RecognitionException) {
this.reportError(re);
this.recover(this.input,re);
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
} else {
throw re;
}
}
finally {
}
return retval;
},
// inline static return class
numericLiteral_return: (function() {
ES3Parser.numericLiteral_return = function(){};
org.antlr.lang.extend(ES3Parser.numericLiteral_return,
org.antlr.runtime.ParserRuleReturnScope,
{
getTree: function() { return this.tree; }
});
return;
})(),
// ES3.g3:1078:1: numericLiteral : ( DecimalLiteral | OctalIntegerLiteral | HexIntegerLiteral );
// $ANTLR start "numericLiteral"
numericLiteral: function() {
var retval = new ES3Parser.numericLiteral_return();
retval.start = this.input.LT(1);
var root_0 = null;
var set19 = null;
var set19_tree=null;
try {
// ES3.g3:1079:2: ( DecimalLiteral | OctalIntegerLiteral | HexIntegerLiteral )
// ES3.g3:
root_0 = this.adaptor.nil();
set19=this.input.LT(1);
if ( (this.input.LA(1)>=DecimalLiteral && this.input.LA(1)<=HexIntegerLiteral) ) {
this.input.consume();
this.adaptor.addChild(root_0, this.adaptor.create(set19));
this.state.errorRecovery=false;
}
else {
var mse = new org.antlr.runtime.MismatchedSetException(null,this.input);
throw mse;
}
retval.stop = this.input.LT(-1);
retval.tree = this.adaptor.rulePostProcessing(root_0);
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (re) {
if (re instanceof org.antlr.runtime.RecognitionException) {
this.reportError(re);
this.recover(this.input,re);
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
} else {
throw re;
}
}
finally {
}
return retval;
},
// inline static return class
primaryExpression_return: (function() {
ES3Parser.primaryExpression_return = function(){};
org.antlr.lang.extend(ES3Parser.primaryExpression_return,
org.antlr.runtime.ParserRuleReturnScope,
{
getTree: function() { return this.tree; }
});
return;
})(),
// ES3.g3:1185:1: primaryExpression : ( THIS | Identifier | amp= IdentifierNameAmpersatStart | literal | arrayLiteral | objectLiteral | lpar= LPAREN expression RPAREN -> ^( PAREXPR[$lpar, \"PAREXPR\"] expression ) );
// $ANTLR start "primaryExpression"
primaryExpression: function() {
var retval = new ES3Parser.primaryExpression_return();
retval.start = this.input.LT(1);
var root_0 = null;
var amp = null;
var lpar = null;
var THIS20 = null;
var Identifier21 = null;
var RPAREN26 = null;
var literal22 = null;
var arrayLiteral23 = null;
var objectLiteral24 = null;
var expression25 = null;
var amp_tree=null;
var lpar_tree=null;
var THIS20_tree=null;
var Identifier21_tree=null;
var RPAREN26_tree=null;
var stream_LPAREN=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token LPAREN");
var stream_RPAREN=new org.antlr.runtime.tree.RewriteRuleTokenStream(this.adaptor,"token RPAREN");
var stream_expression=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"rule expression");
try {
// ES3.g3:1186:2: ( THIS | Identifier | amp= IdentifierNameAmpersatStart | literal | arrayLiteral | objectLiteral | lpar= LPAREN expression RPAREN -> ^( PAREXPR[$lpar, \"PAREXPR\"] expression ) )
var alt4=7;
switch ( this.input.LA(1) ) {
case THIS:
alt4=1;
break;
case Identifier:
alt4=2;
break;
case IdentifierNameAmpersatStart:
alt4=3;
break;
case NULL:
case TRUE:
case FALSE:
case StringLiteral:
case RegularExpressionLiteral:
case DecimalLiteral:
case OctalIntegerLiteral:
case HexIntegerLiteral:
alt4=4;
break;
case LBRACK:
alt4=5;
break;
case LBRACE:
alt4=6;
break;
case LPAREN:
alt4=7;
break;
default:
var nvae =
new org.antlr.runtime.NoViableAltException("", 4, 0, this.input);
throw nvae;
}
switch (alt4) {
case 1 :
// ES3.g3:1186:4: THIS
root_0 = this.adaptor.nil();
THIS20=this.match(this.input,THIS,ES3Parser.FOLLOW_THIS_in_primaryExpression3138);
THIS20_tree = this.adaptor.create(THIS20);
this.adaptor.addChild(root_0, THIS20_tree);
break;
case 2 :
// ES3.g3:1187:4: Identifier
root_0 = this.adaptor.nil();
Identifier21=this.match(this.input,Identifier,ES3Parser.FOLLOW_Identifier_in_primaryExpression3143);
Identifier21_tree = this.adaptor.create(Identifier21);
this.adaptor.addChild(root_0, Identifier21_tree);
break;
case 3 :
// ES3.g3:1188:4: amp= IdentifierNameAmpersatStart
root_0 = this.adaptor.nil();
amp=this.match(this.input,IdentifierNameAmpersatStart,ES3Parser.FOLLOW_IdentifierNameAmpersatStart_in_primaryExpression3150);
amp_tree = this.adaptor.create(amp);
this.adaptor.addChild(root_0, amp_tree);
this.ampersatIdentifiers.push(amp); /*MODIFICATION: keep trac of additional special ampersat-Identifier */
break;
case 4 :
// ES3.g3:1189:4: literal
root_0 = this.adaptor.nil();
this.pushFollow(ES3Parser.FOLLOW_literal_in_primaryExpression3157);
literal22=this.literal();
this.state._fsp--;
this.adaptor.addChild(root_0, literal22.getTree());
break;
case 5 :
// ES3.g3:1190:4: arrayLiteral
root_0 = this.adaptor.nil();
this.pushFollow(ES3Parser.FOLLOW_arrayLiteral_in_primaryExpression3162);
arrayLiteral23=this.arrayLiteral();
this.state._fsp--;
this.adaptor.addChild(root_0, arrayLiteral23.getTree());
break;
case 6 :
// ES3.g3:1191:4: objectLiteral
root_0 = this.adaptor.nil();
this.pushFollow(ES3Parser.FOLLOW_objectLiteral_in_primaryExpression3167);
objectLiteral24=this.objectLiteral();
this.state._fsp--;
this.adaptor.addChild(root_0, objectLiteral24.getTree());
break;
case 7 :
// ES3.g3:1192:4: lpar= LPAREN expression RPAREN
lpar=this.match(this.input,LPAREN,ES3Parser.FOLLOW_LPAREN_in_primaryExpression3174);
stream_LPAREN.add(lpar);
this.pushFollow(ES3Parser.FOLLOW_expression_in_primaryExpression3176);
expression25=this.expression();
this.state._fsp--;
stream_expression.add(expression25.getTree());
RPAREN26=this.match(this.input,RPAREN,ES3Parser.FOLLOW_RPAREN_in_primaryExpression3178);
stream_RPAREN.add(RPAREN26);
// AST REWRITE
// elements: expression
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
retval.tree = root_0;
var stream_retval=new org.antlr.runtime.tree.RewriteRuleSubtreeStream(this.adaptor,"token retval",retval!=null?retval.tree:null);
root_0 = this.adaptor.nil();
// 1192:34: -> ^( PAREXPR[$lpar, \"PAREXPR\"] expression )
{
// ES3.g3:1192:37: ^( PAREXPR[$lpar, \"PAREXPR\"] expression )
{
var root_1 = this.adaptor.nil();
root_1 = this.adaptor.becomeRoot(this.adaptor.create(PAREXPR, lpar, "PAREXPR"), root_1);
this.adaptor.addChild(root_1, stream_expression.nextTree());
this.adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
break;
}
retval.stop = this.input.LT(-1);
retval.tree = this.adaptor.rulePostProcessing(root_0);
this.adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (re) {
if (re instanceof org.antlr.runtime.RecognitionException) {
this.reportError(re);
this.recover(this.input,re);
retval.tree = this.adaptor.errorNode(this.input, retval.start, this.input.LT(-1), re);
} else {
throw re;
}
}
finally {
}
return retval;
},
// inline static return class
arrayLiteral_return: (function() {
ES3Parser.arrayLiteral_return = function(){};
org.antlr.lang.extend(ES3Parser.arrayLiteral_return,
org.antlr.runtime.ParserRuleReturnScope,
{
getTree: function() { return this.tree; }
});
return;
})(),
// ES3.g3:1195:1: arrayLiteral : lb= LBRACK ( arrayItem ( COMMA arrayItem )* )? RBRACK -> ^( ARRAY[$lb, \"ARRAY\"] ( arrayItem )* ) ;
// $ANTLR start "arrayLiteral"
arrayLiteral: function() {
var retval = new ES3Parser.arrayLiteral_return();
retval.start = this.input.LT(1);
var root_0 = null;
var lb