2020-02-04 01:06:47 -05:00
/* parser generated by jison 0.4.18 */
/ *
Returns a Parser object of the following structure :
Parser : {
yy : { }
}
Parser . prototype : {
yy : { } ,
trace : function ( ) ,
symbols _ : { associative list : name == > number } ,
terminals _ : { associative list : number == > name } ,
productions _ : [ ... ] ,
performAction : function anonymous ( yytext , yyleng , yylineno , yy , yystate , $$ , _$ ) ,
table : [ ... ] ,
defaultActions : { ... } ,
parseError : function ( str , hash ) ,
parse : function ( input ) ,
lexer : {
EOF : 1 ,
parseError : function ( str , hash ) ,
setInput : function ( input ) ,
input : function ( ) ,
unput : function ( str ) ,
more : function ( ) ,
less : function ( n ) ,
pastInput : function ( ) ,
upcomingInput : function ( ) ,
showPosition : function ( ) ,
test _match : function ( regex _match _array , rule _index ) ,
next : function ( ) ,
lex : function ( ) ,
begin : function ( condition ) ,
popState : function ( ) ,
_currentRules : function ( ) ,
topState : function ( ) ,
pushState : function ( condition ) ,
options : {
ranges : boolean ( optional : true == > token location info will include a . range [ ] member )
flex : boolean ( optional : true == > flex - like lexing behaviour where the rules are tested exhaustively to find the longest match )
backtrack _lexer : boolean ( optional : true == > lexer regexes are tested in order and for each matching regex the action code is invoked ; the lexer terminates the scan when a token is returned by the action code )
} ,
performAction : function ( yy , yy _ , $avoiding _name _collisions , YY _START ) ,
rules : [ ... ] ,
conditions : { associative list : name == > set } ,
}
}
token location info ( @ $ , _$ , etc . ) : {
first _line : n ,
last _line : n ,
first _column : n ,
last _column : n ,
range : [ start _number , end _number ] ( where the numbers are indexes into the input string , regular zero - based )
}
the parseError function receives a 'hash' object with these members for lexer and parser errors : {
text : ( matched text )
token : ( the produced terminal token , if any )
line : ( yylineno )
}
while parser ( grammar ) errors will also provide these members , i . e . parser errors deliver a superset of attributes : {
loc : ( yylloc )
expected : ( string describing the set of expected tokens )
recoverable : ( boolean : TRUE when the parser has a error recovery rule available for this particular error )
}
* /
var parser = ( function ( ) {
2020-02-10 15:51:58 -05:00
var o = function ( k , v , o , l ) { for ( o = o || { } , l = k . length ; l -- ; o [ k [ l ] ] = v ) ; return o } , $V0 = [ 2 , 23 ] , $V1 = [ 1 , 7 ] , $V2 = [ 1 , 8 ] , $V3 = [ 1 , 9 ] , $V4 = [ 1 , 10 ] , $V5 = [ 1 , 11 ] , $V6 = [ 1 , 12 ] , $V7 = [ 1 , 13 ] , $V8 = [ 1 , 14 ] , $V9 = [ 1 , 15 ] , $Va = [ 1 , 5 ] , $Vb = [ 1 , 6 ] , $Vc = [ 5 , 28 ] , $Vd = [ 5 , 11 , 14 , 15 , 16 , 17 , 18 , 19 , 20 , 21 , 25 , 28 , 31 ] , $Ve = [ 2 , 2 ] , $Vf = [ 1 , 22 ] , $Vg = [ 5 , 10 , 11 , 13 , 14 , 15 , 16 , 17 , 18 , 19 , 20 , 21 , 25 , 28 , 31 ] , $Vh = [ 1 , 28 ] , $Vi = [ 1 , 29 ] , $Vj = [ 1 , 30 ] , $Vk = [ 1 , 31 ] , $Vl = [ 2 , 17 ] , $Vm = [ 5 , 10 , 11 , 13 , 14 , 15 , 16 , 17 , 18 , 19 , 20 , 21 , 25 , 28 , 30 , 31 ] , $Vn = [ 16 , 17 , 18 , 21 , 30 ] ;
2020-02-04 01:06:47 -05:00
var parser = { trace : function trace ( ) { } ,
yy : { } ,
2020-02-10 15:51:58 -05:00
symbols _ : { "error" : 2 , "program" : 3 , "statement_list" : 4 , "EOF" : 5 , "javascript" : 6 , "SCRIPT_TOKEN" : 7 , "opcode_list" : 8 , "opcode" : 9 , "COMMA" : 10 , "ID" : 11 , "OPEN_PAREN" : 12 , "CLOSE_PAREN" : 13 , "HASH_ID" : 14 , "DOLLAR_ID" : 15 , "HEX" : 16 , "DECIMAL" : 17 , "BINARY" : 18 , "DOLLAR_DOLLAR" : 19 , "DOLLAR_INDEX" : 20 , "SCRIPT_EVAL" : 21 , "hex_list" : 22 , "hex" : 23 , "statement" : 24 , "AT_ID" : 25 , "COLON" : 26 , "OPEN_BRACE" : 27 , "CLOSE_BRACE" : 28 , "OPEN_BRACKET" : 29 , "CLOSE_BRACKET" : 30 , "SCRIPT_EXEC" : 31 , "$accept" : 0 , "$end" : 1 } ,
terminals _ : { 2 : "error" , 5 : "EOF" , 7 : "SCRIPT_TOKEN" , 10 : "COMMA" , 11 : "ID" , 12 : "OPEN_PAREN" , 13 : "CLOSE_PAREN" , 14 : "HASH_ID" , 15 : "DOLLAR_ID" , 16 : "HEX" , 17 : "DECIMAL" , 18 : "BINARY" , 19 : "DOLLAR_DOLLAR" , 20 : "DOLLAR_INDEX" , 21 : "SCRIPT_EVAL" , 25 : "AT_ID" , 26 : "COLON" , 27 : "OPEN_BRACE" , 28 : "CLOSE_BRACE" , 29 : "OPEN_BRACKET" , 30 : "CLOSE_BRACKET" , 31 : "SCRIPT_EXEC" } ,
productions _ : [ 0 , [ 3 , 2 ] , [ 6 , 0 ] , [ 6 , 2 ] , [ 8 , 1 ] , [ 8 , 3 ] , [ 9 , 1 ] , [ 9 , 3 ] , [ 9 , 4 ] , [ 9 , 1 ] , [ 9 , 1 ] , [ 9 , 1 ] , [ 9 , 1 ] , [ 9 , 1 ] , [ 9 , 1 ] , [ 9 , 1 ] , [ 9 , 2 ] , [ 22 , 0 ] , [ 22 , 2 ] , [ 23 , 1 ] , [ 23 , 1 ] , [ 23 , 1 ] , [ 23 , 2 ] , [ 4 , 0 ] , [ 4 , 2 ] , [ 24 , 1 ] , [ 24 , 2 ] , [ 24 , 4 ] , [ 24 , 4 ] , [ 24 , 2 ] ] ,
2020-02-04 01:06:47 -05:00
performAction : function anonymous ( yytext , yyleng , yylineno , yy , yystate /* action[1] */ , $$ /* vstack */ , _$ /* lstack */ ) {
/* this == yyval */
var $0 = $$ . length - 1 ;
switch ( yystate ) {
case 1 :
return { type : "scope" , name : "_" , statements : $$ [ $0 - 1 ] , loc : getLoc ( yy , null ) } ;
break ;
case 2 :
this . $ = "" ;
break ;
case 3 :
this . $ = $$ [ $0 - 1 ] + $$ [ $0 ] ;
break ;
case 4 :
this . $ = [ $$ [ $0 ] ] ;
break ;
case 5 :
{
const opcodes = $$ [ $0 ] . slice ( ) ;
opcodes . unshift ( $$ [ $0 - 2 ] ) ;
this . $ = opcodes ;
}
break ;
case 6 :
this . $ = { type : "opcode" , bare : true , mnemonic : $$ [ $0 ] , operands : [ ] , loc : getLoc ( yy , _$ [ $0 ] ) } ;
break ;
case 7 :
this . $ = { type : "opcode" , mnemonic : $$ [ $0 - 2 ] , operands : [ ] , loc : getLoc ( yy , _$ [ $0 - 2 ] , _$ [ $0 ] ) } ;
break ;
case 8 :
this . $ = { type : "opcode" , mnemonic : $$ [ $0 - 3 ] , operands : $$ [ $0 - 1 ] , loc : getLoc ( yy , _$ [ $0 - 3 ] , _$ [ $0 ] ) } ;
break ;
case 9 :
this . $ = { type : "length" , label : $$ [ $0 ] . substring ( 1 ) , loc : getLoc ( yy , _$ [ $0 ] ) } ;
break ;
case 10 :
this . $ = { type : "offset" , label : $$ [ $0 ] . substring ( 1 ) , loc : getLoc ( yy , _$ [ $0 ] ) } ;
break ;
case 11 :
this . $ = { type : "hex" , value : $$ [ $0 ] , loc : getLoc ( yy , _$ [ $0 ] ) } ;
break ;
case 12 :
this . $ = { type : "decimal" , value : $$ [ $0 ] , loc : getLoc ( yy , _$ [ $0 ] ) } ;
break ;
case 13 :
2020-02-10 15:51:58 -05:00
{
const hex = "0x" + parseInt ( ( "0" + ( $$ [ $0 ] ) . substring ( 2 ) ) , 2 ) . toString ( 16 ) ;
this . $ = { type : "hex" , value : hex , loc : getLoc ( yy , _$ [ $0 ] ) } ;
}
2020-02-06 18:21:34 -05:00
break ;
case 14 :
2020-02-10 15:51:58 -05:00
this . $ = { type : "pop" , index : 0 , loc : getLoc ( yy , _$ [ $0 ] ) } ;
2020-02-06 18:21:34 -05:00
break ;
case 15 :
2020-02-10 15:51:58 -05:00
this . $ = { type : "pop" , index : parseInt ( ( $$ [ $0 ] ) . substring ( 1 ) ) , loc : getLoc ( yy , _$ [ $0 ] ) } ;
break ;
case 16 :
2020-02-04 01:06:47 -05:00
this . $ = { type : "eval" , script : $$ [ $0 ] , loc : getLoc ( yy , _$ [ $0 - 1 ] , _$ [ $0 ] ) } ;
break ;
2020-02-10 15:51:58 -05:00
case 17 : case 23 :
2020-02-04 01:06:47 -05:00
this . $ = [ ] ;
break ;
2020-02-10 15:51:58 -05:00
case 18 :
2020-02-04 01:06:47 -05:00
{
const hexes = $$ [ $0 ] . slice ( ) ; ;
hexes . unshift ( $$ [ $0 - 1 ] ) ;
this . $ = hexes ;
}
break ;
2020-02-10 15:51:58 -05:00
case 19 :
2020-02-04 01:06:47 -05:00
this . $ = { type : "hex" , verbatim : true , value : $$ [ $0 ] , loc : getLoc ( yy , _$ [ $0 ] ) } ;
break ;
2020-02-10 15:51:58 -05:00
case 20 :
2020-02-04 01:06:47 -05:00
{
const value = parseInt ( $$ [ $0 ] ) ;
if ( value >= 256 ) { throw new Error ( "decimal data values must be single bytes" ) ; }
2020-02-06 18:21:34 -05:00
let hex = ( value ) . toString ( 16 ) ;
while ( hex . length < 2 ) { hex = "0" + hex ; }
this . $ = { type : "hex" , verbatim : true , value : ( "0x" + hex ) , loc : getLoc ( yy , _$ [ $0 ] ) } ;
2020-02-04 01:06:47 -05:00
}
break ;
2020-02-10 15:51:58 -05:00
case 21 :
{
const value = parseInt ( ( $$ [ $0 ] ) . substring ( 2 ) , 2 ) ;
if ( value >= 256 ) { throw new Error ( "binary data values must be single bytes" ) ; }
const hex = ( "0x" + ( value ) . toString ( 16 ) ) ;
this . $ = { type : "hex" , verbatim : true , value : hex , loc : getLoc ( yy , _$ [ $0 ] ) } ;
}
2020-02-04 01:06:47 -05:00
break ;
2020-02-06 18:21:34 -05:00
case 22 :
2020-02-10 15:51:58 -05:00
this . $ = { type : "eval" , verbatim : true , script : $$ [ $0 ] , loc : getLoc ( yy , _$ [ $0 - 1 ] , _$ [ $0 ] ) } ;
break ;
case 24 :
2020-02-04 01:06:47 -05:00
{
const statements = $$ [ $0 ] . slice ( ) ;
statements . unshift ( $$ [ $0 - 1 ] ) ;
this . $ = statements ;
}
break ;
2020-02-10 15:51:58 -05:00
case 25 :
2020-02-06 18:21:34 -05:00
{
const statement = $$ [ $0 ] ;
statement . loc . statement = true ;
this . $ = statement ;
}
2020-02-04 01:06:47 -05:00
break ;
2020-02-10 15:51:58 -05:00
case 26 :
2020-02-06 18:21:34 -05:00
this . $ = { type : "label" , name : $$ [ $0 - 1 ] . substring ( 1 ) , loc : getLoc ( yy , _$ [ $0 - 1 ] , _$ [ $0 ] , true ) } ;
2020-02-04 01:06:47 -05:00
break ;
2020-02-10 15:51:58 -05:00
case 27 :
2020-02-06 18:21:34 -05:00
this . $ = { type : "scope" , name : $$ [ $0 - 3 ] . substring ( 1 ) , statements : $$ [ $0 - 1 ] , loc : getLoc ( yy , _$ [ $0 - 3 ] , _$ [ $0 ] , true ) } ;
break ;
2020-02-10 15:51:58 -05:00
case 28 :
2020-02-06 18:21:34 -05:00
this . $ = { type : "data" , name : $$ [ $0 - 3 ] . substring ( 1 ) , data : $$ [ $0 - 1 ] , loc : getLoc ( yy , _$ [ $0 - 3 ] , _$ [ $0 ] , true ) } ;
break ;
2020-02-10 15:51:58 -05:00
case 29 :
2020-02-06 18:21:34 -05:00
this . $ = { type : "exec" , script : $$ [ $0 ] , loc : getLoc ( yy , _$ [ $0 - 1 ] , _$ [ $0 ] , true ) } ;
2020-02-04 01:06:47 -05:00
break ;
}
} ,
2020-02-10 15:51:58 -05:00
table : [ { 3 : 1 , 4 : 2 , 5 : $V0 , 9 : 4 , 11 : $V1 , 14 : $V2 , 15 : $V3 , 16 : $V4 , 17 : $V5 , 18 : $V6 , 19 : $V7 , 20 : $V8 , 21 : $V9 , 24 : 3 , 25 : $Va , 31 : $Vb } , { 1 : [ 3 ] } , { 5 : [ 1 , 16 ] } , o ( $Vc , $V0 , { 24 : 3 , 9 : 4 , 4 : 17 , 11 : $V1 , 14 : $V2 , 15 : $V3 , 16 : $V4 , 17 : $V5 , 18 : $V6 , 19 : $V7 , 20 : $V8 , 21 : $V9 , 25 : $Va , 31 : $Vb } ) , o ( $Vd , [ 2 , 25 ] ) , { 26 : [ 1 , 18 ] , 27 : [ 1 , 19 ] , 29 : [ 1 , 20 ] } , o ( $Vd , $Ve , { 6 : 21 , 7 : $Vf } ) , o ( $Vg , [ 2 , 6 ] , { 12 : [ 1 , 23 ] } ) , o ( $Vg , [ 2 , 9 ] ) , o ( $Vg , [ 2 , 10 ] ) , o ( $Vg , [ 2 , 11 ] ) , o ( $Vg , [ 2 , 12 ] ) , o ( $Vg , [ 2 , 13 ] ) , o ( $Vg , [ 2 , 14 ] ) , o ( $Vg , [ 2 , 15 ] ) , o ( $Vg , $Ve , { 6 : 24 , 7 : $Vf } ) , { 1 : [ 2 , 1 ] } , o ( $Vc , [ 2 , 24 ] ) , o ( $Vd , [ 2 , 26 ] ) , { 4 : 25 , 9 : 4 , 11 : $V1 , 14 : $V2 , 15 : $V3 , 16 : $V4 , 17 : $V5 , 18 : $V6 , 19 : $V7 , 20 : $V8 , 21 : $V9 , 24 : 3 , 25 : $Va , 28 : $V0 , 31 : $Vb } , { 16 : $Vh , 17 : $Vi , 18 : $Vj , 21 : $Vk , 22 : 26 , 23 : 27 , 30 : $Vl } , o ( $Vd , [ 2 , 29 ] ) , o ( $Vm , $Ve , { 6 : 32 , 7 : $Vf } ) , { 8 : 34 , 9 : 35 , 11 : $V1 , 13 : [ 1 , 33 ] , 14 : $V2 , 15 : $V3 , 16 : $V4 , 17 : $V5 , 18 : $V6 , 19 : $V7 , 20 : $V8 , 21 : $V9 } , o ( $Vg , [ 2 , 16 ] ) , { 28 : [ 1 , 36 ] } , { 30 : [ 1 , 37 ] } , { 16 : $Vh , 17 : $Vi , 18 : $Vj , 21 : $Vk , 22 : 38 , 23 : 27 , 30 : $Vl } , o ( $Vn , [ 2 , 19 ] ) , o ( $Vn , [ 2 , 20 ] ) , o ( $Vn , [ 2 , 21 ] ) , o ( $Vn , $Ve , { 6 : 39 , 7 : $Vf } ) , o ( $Vm , [ 2 , 3 ] ) , o ( $Vg , [ 2 , 7 ] ) , { 13 : [ 1 , 40 ] } , { 10 : [ 1 , 41 ] , 13 : [ 2 , 4 ] } , o ( $Vd , [ 2 , 27 ] ) , o ( $Vd , [ 2 , 28 ] ) , { 30 : [ 2 , 18 ] } , o ( $Vn , [ 2 , 22 ] ) , o ( $Vg , [ 2 , 8 ] ) , { 8 : 42 , 9 : 35 , 11 : $V1 , 14 : $V2 , 15 : $V3 , 16 : $V4 , 17 : $V5 , 18 : $V6 , 19 : $V7 , 20 : $V8 , 21 : $V9 } , { 13 : [ 2 , 5 ] } ] ,
defaultActions : { 16 : [ 2 , 1 ] , 38 : [ 2 , 18 ] , 42 : [ 2 , 5 ] } ,
2020-02-04 01:06:47 -05:00
parseError : function parseError ( str , hash ) {
if ( hash . recoverable ) {
this . trace ( str ) ;
} else {
var error = new Error ( str ) ;
error . hash = hash ;
throw error ;
}
} ,
parse : function parse ( input ) {
var self = this , stack = [ 0 ] , tstack = [ ] , vstack = [ null ] , lstack = [ ] , table = this . table , yytext = '' , yylineno = 0 , yyleng = 0 , recovering = 0 , TERROR = 2 , EOF = 1 ;
var args = lstack . slice . call ( arguments , 1 ) ;
var lexer = Object . create ( this . lexer ) ;
var sharedState = { yy : { } } ;
for ( var k in this . yy ) {
if ( Object . prototype . hasOwnProperty . call ( this . yy , k ) ) {
sharedState . yy [ k ] = this . yy [ k ] ;
}
}
lexer . setInput ( input , sharedState . yy ) ;
sharedState . yy . lexer = lexer ;
sharedState . yy . parser = this ;
if ( typeof lexer . yylloc == 'undefined' ) {
lexer . yylloc = { } ;
}
var yyloc = lexer . yylloc ;
lstack . push ( yyloc ) ;
var ranges = lexer . options && lexer . options . ranges ;
if ( typeof sharedState . yy . parseError === 'function' ) {
this . parseError = sharedState . yy . parseError ;
} else {
this . parseError = Object . getPrototypeOf ( this ) . parseError ;
}
function popStack ( n ) {
stack . length = stack . length - 2 * n ;
vstack . length = vstack . length - n ;
lstack . length = lstack . length - n ;
}
_token _stack :
var lex = function ( ) {
var token ;
token = lexer . lex ( ) || EOF ;
if ( typeof token !== 'number' ) {
token = self . symbols _ [ token ] || token ;
}
return token ;
} ;
var symbol , preErrorSymbol , state , action , a , r , yyval = { } , p , len , newState , expected ;
while ( true ) {
state = stack [ stack . length - 1 ] ;
if ( this . defaultActions [ state ] ) {
action = this . defaultActions [ state ] ;
} else {
if ( symbol === null || typeof symbol == 'undefined' ) {
symbol = lex ( ) ;
}
action = table [ state ] && table [ state ] [ symbol ] ;
}
if ( typeof action === 'undefined' || ! action . length || ! action [ 0 ] ) {
var errStr = '' ;
expected = [ ] ;
for ( p in table [ state ] ) {
if ( this . terminals _ [ p ] && p > TERROR ) {
expected . push ( '\'' + this . terminals _ [ p ] + '\'' ) ;
}
}
if ( lexer . showPosition ) {
errStr = 'Parse error on line ' + ( yylineno + 1 ) + ':\n' + lexer . showPosition ( ) + '\nExpecting ' + expected . join ( ', ' ) + ', got \'' + ( this . terminals _ [ symbol ] || symbol ) + '\'' ;
} else {
errStr = 'Parse error on line ' + ( yylineno + 1 ) + ': Unexpected ' + ( symbol == EOF ? 'end of input' : '\'' + ( this . terminals _ [ symbol ] || symbol ) + '\'' ) ;
}
this . parseError ( errStr , {
text : lexer . match ,
token : this . terminals _ [ symbol ] || symbol ,
line : lexer . yylineno ,
loc : yyloc ,
expected : expected
} ) ;
}
if ( action [ 0 ] instanceof Array && action . length > 1 ) {
throw new Error ( 'Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol ) ;
}
switch ( action [ 0 ] ) {
case 1 :
stack . push ( symbol ) ;
vstack . push ( lexer . yytext ) ;
lstack . push ( lexer . yylloc ) ;
stack . push ( action [ 1 ] ) ;
symbol = null ;
if ( ! preErrorSymbol ) {
yyleng = lexer . yyleng ;
yytext = lexer . yytext ;
yylineno = lexer . yylineno ;
yyloc = lexer . yylloc ;
if ( recovering > 0 ) {
recovering -- ;
}
} else {
symbol = preErrorSymbol ;
preErrorSymbol = null ;
}
break ;
case 2 :
len = this . productions _ [ action [ 1 ] ] [ 1 ] ;
yyval . $ = vstack [ vstack . length - len ] ;
yyval . _$ = {
first _line : lstack [ lstack . length - ( len || 1 ) ] . first _line ,
last _line : lstack [ lstack . length - 1 ] . last _line ,
first _column : lstack [ lstack . length - ( len || 1 ) ] . first _column ,
last _column : lstack [ lstack . length - 1 ] . last _column
} ;
if ( ranges ) {
yyval . _$ . range = [
lstack [ lstack . length - ( len || 1 ) ] . range [ 0 ] ,
lstack [ lstack . length - 1 ] . range [ 1 ]
] ;
}
r = this . performAction . apply ( yyval , [
yytext ,
yyleng ,
yylineno ,
sharedState . yy ,
action [ 1 ] ,
vstack ,
lstack
] . concat ( args ) ) ;
if ( typeof r !== 'undefined' ) {
return r ;
}
if ( len ) {
stack = stack . slice ( 0 , - 1 * len * 2 ) ;
vstack = vstack . slice ( 0 , - 1 * len ) ;
lstack = lstack . slice ( 0 , - 1 * len ) ;
}
stack . push ( this . productions _ [ action [ 1 ] ] [ 0 ] ) ;
vstack . push ( yyval . $ ) ;
lstack . push ( yyval . _$ ) ;
newState = table [ stack [ stack . length - 2 ] ] [ stack [ stack . length - 1 ] ] ;
stack . push ( newState ) ;
break ;
case 3 :
return true ;
}
}
return true ;
} } ;
2020-02-06 18:21:34 -05:00
function getLoc ( yy , start , end , statement ) {
2020-02-04 01:06:47 -05:00
if ( end == null ) { end = start ; }
let result = null ;
if ( start ) {
result = {
first _line : start . first _line ,
first _column : start . first _column ,
last _line : end . last _line ,
2020-02-06 18:21:34 -05:00
last _column : end . last _column ,
statement : ! ! statement
2020-02-04 01:06:47 -05:00
} ;
}
if ( yy . _ethersLocation ) {
return yy . _ethersLocation ( result ) ;
}
2020-02-06 18:21:34 -05:00
return result ;
2020-02-04 01:06:47 -05:00
}
/* generated by jison-lex 0.3.4 */
var lexer = ( function ( ) {
var lexer = ( {
EOF : 1 ,
parseError : function parseError ( str , hash ) {
if ( this . yy . parser ) {
this . yy . parser . parseError ( str , hash ) ;
} else {
throw new Error ( str ) ;
}
} ,
// resets the lexer, sets new input
setInput : function ( input , yy ) {
this . yy = yy || this . yy || { } ;
this . _input = input ;
this . _more = this . _backtrack = this . done = false ;
this . yylineno = this . yyleng = 0 ;
this . yytext = this . matched = this . match = '' ;
this . conditionStack = [ 'INITIAL' ] ;
this . yylloc = {
first _line : 1 ,
first _column : 0 ,
last _line : 1 ,
last _column : 0
} ;
if ( this . options . ranges ) {
this . yylloc . range = [ 0 , 0 ] ;
}
this . offset = 0 ;
return this ;
} ,
// consumes and returns one char from the input
input : function ( ) {
var ch = this . _input [ 0 ] ;
this . yytext += ch ;
this . yyleng ++ ;
this . offset ++ ;
this . match += ch ;
this . matched += ch ;
var lines = ch . match ( /(?:\r\n?|\n).*/g ) ;
if ( lines ) {
this . yylineno ++ ;
this . yylloc . last _line ++ ;
} else {
this . yylloc . last _column ++ ;
}
if ( this . options . ranges ) {
this . yylloc . range [ 1 ] ++ ;
}
this . _input = this . _input . slice ( 1 ) ;
return ch ;
} ,
// unshifts one char (or a string) into the input
unput : function ( ch ) {
var len = ch . length ;
var lines = ch . split ( /(?:\r\n?|\n)/g ) ;
this . _input = ch + this . _input ;
this . yytext = this . yytext . substr ( 0 , this . yytext . length - len ) ;
//this.yyleng -= len;
this . offset -= len ;
var oldLines = this . match . split ( /(?:\r\n?|\n)/g ) ;
this . match = this . match . substr ( 0 , this . match . length - 1 ) ;
this . matched = this . matched . substr ( 0 , this . matched . length - 1 ) ;
if ( lines . length - 1 ) {
this . yylineno -= lines . length - 1 ;
}
var r = this . yylloc . range ;
this . yylloc = {
first _line : this . yylloc . first _line ,
last _line : this . yylineno + 1 ,
first _column : this . yylloc . first _column ,
last _column : lines ?
( lines . length === oldLines . length ? this . yylloc . first _column : 0 )
+ oldLines [ oldLines . length - lines . length ] . length - lines [ 0 ] . length :
this . yylloc . first _column - len
} ;
if ( this . options . ranges ) {
this . yylloc . range = [ r [ 0 ] , r [ 0 ] + this . yyleng - len ] ;
}
this . yyleng = this . yytext . length ;
return this ;
} ,
// When called from action, caches matched text and appends it on next action
more : function ( ) {
this . _more = true ;
return this ;
} ,
// When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
reject : function ( ) {
if ( this . options . backtrack _lexer ) {
this . _backtrack = true ;
} else {
return this . parseError ( 'Lexical error on line ' + ( this . yylineno + 1 ) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this . showPosition ( ) , {
text : "" ,
token : null ,
line : this . yylineno
} ) ;
}
return this ;
} ,
// retain first n characters of the match
less : function ( n ) {
this . unput ( this . match . slice ( n ) ) ;
} ,
// displays already matched input, i.e. for error messages
pastInput : function ( ) {
var past = this . matched . substr ( 0 , this . matched . length - this . match . length ) ;
return ( past . length > 20 ? '...' : '' ) + past . substr ( - 20 ) . replace ( /\n/g , "" ) ;
} ,
// displays upcoming input, i.e. for error messages
upcomingInput : function ( ) {
var next = this . match ;
if ( next . length < 20 ) {
next += this . _input . substr ( 0 , 20 - next . length ) ;
}
return ( next . substr ( 0 , 20 ) + ( next . length > 20 ? '...' : '' ) ) . replace ( /\n/g , "" ) ;
} ,
// displays the character position where the lexing error occurred, i.e. for error messages
showPosition : function ( ) {
var pre = this . pastInput ( ) ;
var c = new Array ( pre . length + 1 ) . join ( "-" ) ;
return pre + this . upcomingInput ( ) + "\n" + c + "^" ;
} ,
// test the lexed token: return FALSE when not a match, otherwise return token
test _match : function ( match , indexed _rule ) {
var token ,
lines ,
backup ;
if ( this . options . backtrack _lexer ) {
// save context
backup = {
yylineno : this . yylineno ,
yylloc : {
first _line : this . yylloc . first _line ,
last _line : this . last _line ,
first _column : this . yylloc . first _column ,
last _column : this . yylloc . last _column
} ,
yytext : this . yytext ,
match : this . match ,
matches : this . matches ,
matched : this . matched ,
yyleng : this . yyleng ,
offset : this . offset ,
_more : this . _more ,
_input : this . _input ,
yy : this . yy ,
conditionStack : this . conditionStack . slice ( 0 ) ,
done : this . done
} ;
if ( this . options . ranges ) {
backup . yylloc . range = this . yylloc . range . slice ( 0 ) ;
}
}
lines = match [ 0 ] . match ( /(?:\r\n?|\n).*/g ) ;
if ( lines ) {
this . yylineno += lines . length ;
}
this . yylloc = {
first _line : this . yylloc . last _line ,
last _line : this . yylineno + 1 ,
first _column : this . yylloc . last _column ,
last _column : lines ?
lines [ lines . length - 1 ] . length - lines [ lines . length - 1 ] . match ( /\r?\n?/ ) [ 0 ] . length :
this . yylloc . last _column + match [ 0 ] . length
} ;
this . yytext += match [ 0 ] ;
this . match += match [ 0 ] ;
this . matches = match ;
this . yyleng = this . yytext . length ;
if ( this . options . ranges ) {
this . yylloc . range = [ this . offset , this . offset += this . yyleng ] ;
}
this . _more = false ;
this . _backtrack = false ;
this . _input = this . _input . slice ( match [ 0 ] . length ) ;
this . matched += match [ 0 ] ;
token = this . performAction . call ( this , this . yy , this , indexed _rule , this . conditionStack [ this . conditionStack . length - 1 ] ) ;
if ( this . done && this . _input ) {
this . done = false ;
}
if ( token ) {
return token ;
} else if ( this . _backtrack ) {
// recover context
for ( var k in backup ) {
this [ k ] = backup [ k ] ;
}
return false ; // rule action called reject() implying the next rule should be tested instead.
}
return false ;
} ,
// return next match in input
next : function ( ) {
if ( this . done ) {
return this . EOF ;
}
if ( ! this . _input ) {
this . done = true ;
}
var token ,
match ,
tempMatch ,
index ;
if ( ! this . _more ) {
this . yytext = '' ;
this . match = '' ;
}
var rules = this . _currentRules ( ) ;
for ( var i = 0 ; i < rules . length ; i ++ ) {
tempMatch = this . _input . match ( this . rules [ rules [ i ] ] ) ;
if ( tempMatch && ( ! match || tempMatch [ 0 ] . length > match [ 0 ] . length ) ) {
match = tempMatch ;
index = i ;
if ( this . options . backtrack _lexer ) {
token = this . test _match ( tempMatch , rules [ i ] ) ;
if ( token !== false ) {
return token ;
} else if ( this . _backtrack ) {
match = false ;
continue ; // rule action called reject() implying a rule MISmatch.
} else {
// else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
return false ;
}
} else if ( ! this . options . flex ) {
break ;
}
}
}
if ( match ) {
token = this . test _match ( match , rules [ index ] ) ;
if ( token !== false ) {
return token ;
}
// else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
return false ;
}
if ( this . _input === "" ) {
return this . EOF ;
} else {
return this . parseError ( 'Lexical error on line ' + ( this . yylineno + 1 ) + '. Unrecognized text.\n' + this . showPosition ( ) , {
text : "" ,
token : null ,
line : this . yylineno
} ) ;
}
} ,
// return next match that has a token
lex : function lex ( ) {
var r = this . next ( ) ;
if ( r ) {
return r ;
} else {
return this . lex ( ) ;
}
} ,
// activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
begin : function begin ( condition ) {
this . conditionStack . push ( condition ) ;
} ,
// pop the previously active lexer condition state off the condition stack
popState : function popState ( ) {
var n = this . conditionStack . length - 1 ;
if ( n > 0 ) {
return this . conditionStack . pop ( ) ;
} else {
return this . conditionStack [ 0 ] ;
}
} ,
// produce the lexer rule set which is active for the currently active lexer condition state
_currentRules : function _currentRules ( ) {
if ( this . conditionStack . length && this . conditionStack [ this . conditionStack . length - 1 ] ) {
return this . conditions [ this . conditionStack [ this . conditionStack . length - 1 ] ] . rules ;
} else {
return this . conditions [ "INITIAL" ] . rules ;
}
} ,
// return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
topState : function topState ( n ) {
n = this . conditionStack . length - 1 - Math . abs ( n || 0 ) ;
if ( n >= 0 ) {
return this . conditionStack [ n ] ;
} else {
return "INITIAL" ;
}
} ,
// alias for begin(condition)
pushState : function pushState ( condition ) {
this . begin ( condition ) ;
} ,
// return the number of states currently on the stack
stateStackSize : function stateStackSize ( ) {
return this . conditionStack . length ;
} ,
options : { } ,
performAction : function anonymous ( yy , yy _ , $avoiding _name _collisions , YY _START ) {
var YYSTATE = YY _START ;
switch ( $avoiding _name _collisions ) {
case 0 : this . begin ( "script" ) ; return "SCRIPT_EVAL" ;
break ;
case 1 : this . begin ( "script" ) ; return "SCRIPT_EXEC" ;
break ;
case 2 : return "SCRIPT_TOKEN" ;
break ;
case 3 : this . popState ( )
break ;
case 4 : // Ignore comments
break ;
case 5 : // Ignore Whitespace
break ;
case 6 : return "ID"
break ;
case 7 : return "OPEN_PAREN"
break ;
case 8 : return "CLOSE_PAREN"
break ;
case 9 : return "COMMA"
break ;
case 10 : return "AT_ID"
break ;
2020-02-06 18:21:34 -05:00
case 11 : return "DOLLAR_ID"
2020-02-04 01:06:47 -05:00
break ;
2020-02-06 18:21:34 -05:00
case 12 : return "HASH_ID"
2020-02-04 01:06:47 -05:00
break ;
case 13 : return "OPEN_BRACE"
break ;
case 14 : return "CLOSE_BRACE"
break ;
case 15 : return "COLON"
break ;
case 16 : return "OPEN_BRACKET"
break ;
case 17 : return "CLOSE_BRACKET"
break ;
case 18 : return "HEX"
break ;
2020-02-10 15:51:58 -05:00
case 19 : return "BINARY"
break ;
case 20 : return "DECIMAL"
2020-02-04 01:06:47 -05:00
break ;
2020-02-10 15:51:58 -05:00
case 21 : return "DOLLAR_DOLLAR"
2020-02-06 18:21:34 -05:00
break ;
2020-02-10 15:51:58 -05:00
case 22 : return "DOLLAR_INDEX"
2020-02-06 18:21:34 -05:00
break ;
2020-02-10 15:51:58 -05:00
case 23 : return "EOF"
2020-02-04 01:06:47 -05:00
break ;
2020-02-10 15:51:58 -05:00
case 24 : return "INVALID"
2020-02-04 01:06:47 -05:00
break ;
}
} ,
2020-02-10 15:51:58 -05:00
rules : [ /^(?:\{\{=)/ , /^(?:\{\{!)/ , /^(?:([^\}]|\n|\}[^}]))/ , /^(?:\}\})/ , /^(?:([;][^\n]*\n))/ , /^(?:(\s+))/ , /^(?:([A-Za-z][A-Za-z0-9]*))/ , /^(?:\()/ , /^(?:\))/ , /^(?:,)/ , /^(?:([@][A-Za-z][A-Za-z0-9]*))/ , /^(?:([$](_|[A-Za-z][A-Za-z0-9]*)))/ , /^(?:([#](_|[A-Za-z][A-Za-z0-9]*)))/ , /^(?:\{)/ , /^(?:\})/ , /^(?::)/ , /^(?:\[)/ , /^(?:\])/ , /^(?:(0x([0-9a-fA-F][0-9a-fA-F])*))/ , /^(?:(0b(0|1)+))/ , /^(?:([1-9][0-9]*|0))/ , /^(?:\$\$)/ , /^(?:([$][1-9][0-9]*))/ , /^(?:$)/ , /^(?:)/ ] ,
conditions : { "script" : { "rules" : [ 2 , 3 ] , "inclusive" : false } , "INITIAL" : { "rules" : [ 0 , 1 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , 17 , 18 , 19 , 20 , 21 , 22 , 23 , 24 ] , "inclusive" : true } }
2020-02-04 01:06:47 -05:00
} ) ;
return lexer ;
} ) ( ) ;
parser . lexer = lexer ;
function Parser ( ) {
this . yy = { } ;
}
Parser . prototype = parser ; parser . Parser = Parser ;
return new Parser ;
} ) ( ) ;
if ( typeof require !== 'undefined' && typeof exports !== 'undefined' ) {
exports . parser = parser ;
exports . Parser = parser . Parser ;
exports . parse = function ( ) { return parser . parse . apply ( parser , arguments ) ; } ;
exports . main = function commonjsMain ( args ) {
if ( ! args [ 1 ] ) {
console . log ( 'Usage: ' + args [ 0 ] + ' FILE' ) ;
process . exit ( 1 ) ;
}
var source = require ( 'fs' ) . readFileSync ( require ( 'path' ) . normalize ( args [ 1 ] ) , "utf8" ) ;
return exports . parser . parse ( source ) ;
} ;
if ( typeof module !== 'undefined' && require . main === module ) {
exports . main ( process . argv . slice ( 1 ) ) ;
}
}
