mirror of
https://github.com/SickGear/SickGear.git
synced 2024-12-30 14:43:39 +00:00
3210 lines
105 KiB
Python
3210 lines
105 KiB
Python
|
# JUST FOR NOW, later I will write my own - much faster and better.
|
||
|
|
||
|
# Copyright (C) 2013 Ariya Hidayat <ariya.hidayat@gmail.com>
|
||
|
# Copyright (C) 2013 Thaddee Tyl <thaddee.tyl@gmail.com>
|
||
|
# Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
|
||
|
# Copyright (C) 2012 Mathias Bynens <mathias@qiwi.be>
|
||
|
# Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
|
||
|
# Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>
|
||
|
# Copyright (C) 2012 Yusuke Suzuki <utatane.tea@gmail.com>
|
||
|
# Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>
|
||
|
# Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
|
||
|
#
|
||
|
# Redistribution and use in source and binary forms, with or without
|
||
|
# modification, are permitted provided that the following conditions are met:
|
||
|
#
|
||
|
# * Redistributions of source code must retain the above copyright
|
||
|
# notice, this list of conditions and the following disclaimer.
|
||
|
# * 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.
|
||
|
#
|
||
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 <COPYRIGHT HOLDER> 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.
|
||
|
|
||
|
# -*- coding: latin-1 -*-
|
||
|
from __future__ import print_function
|
||
|
import re
|
||
|
|
||
|
|
||
|
def typeof(t):
|
||
|
if t is None: return 'undefined'
|
||
|
elif isinstance(t, bool): return 'boolean'
|
||
|
elif isinstance(t, str): return 'string'
|
||
|
elif isinstance(t, int) or isinstance(t, float): return 'number'
|
||
|
elif hasattr(t, '__call__'): return 'function'
|
||
|
else: return 'object'
|
||
|
|
||
|
|
||
|
def list_indexOf(l, v):
|
||
|
try:
|
||
|
return l.index(v)
|
||
|
except:
|
||
|
return -1
|
||
|
|
||
|
|
||
|
parseFloat = float
|
||
|
parseInt = int
|
||
|
|
||
|
|
||
|
class jsdict(object):
|
||
|
def __init__(self, d):
|
||
|
self.__dict__.update(d)
|
||
|
|
||
|
def __getitem__(self, name):
|
||
|
if name in self.__dict__:
|
||
|
return self.__dict__[name]
|
||
|
else:
|
||
|
return None
|
||
|
|
||
|
def __setitem__(self, name, value):
|
||
|
self.__dict__[name] = value
|
||
|
return value
|
||
|
|
||
|
def __getattr__(self, name):
|
||
|
try:
|
||
|
return getattr(self, name)
|
||
|
except:
|
||
|
return None
|
||
|
|
||
|
def __setattr__(self, name, value):
|
||
|
self[name] = value
|
||
|
return value
|
||
|
|
||
|
def __contains__(self, name):
|
||
|
return name in self.__dict__
|
||
|
|
||
|
def __repr__(self):
|
||
|
return str(self.__dict__)
|
||
|
|
||
|
|
||
|
class RegExp(object):
|
||
|
def __init__(self, pattern, flags=''):
|
||
|
self.flags = flags
|
||
|
pyflags = 0 | re.M if 'm' in flags else 0 | re.I if 'i' in flags else 0
|
||
|
self.source = pattern
|
||
|
self.pattern = re.compile(pattern, pyflags)
|
||
|
|
||
|
def test(self, s):
|
||
|
return self.pattern.search(s) is not None
|
||
|
|
||
|
|
||
|
console = jsdict({"log": print})
|
||
|
|
||
|
|
||
|
def __temp__42(object=None, body=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.WithStatement,
|
||
|
"object": object,
|
||
|
"body": body,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__41(test=None, body=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.WhileStatement,
|
||
|
"test": test,
|
||
|
"body": body,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__40(id=None, init=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.VariableDeclarator,
|
||
|
"id": id,
|
||
|
"init": init,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__39(declarations=None, kind=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.VariableDeclaration,
|
||
|
"declarations": declarations,
|
||
|
"kind": kind,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__38(operator=None, argument=None):
|
||
|
if (operator == "++") or (operator == "--"):
|
||
|
return jsdict({
|
||
|
"type": Syntax.UpdateExpression,
|
||
|
"operator": operator,
|
||
|
"argument": argument,
|
||
|
"prefix": True,
|
||
|
})
|
||
|
return jsdict({
|
||
|
"type": Syntax.UnaryExpression,
|
||
|
"operator": operator,
|
||
|
"argument": argument,
|
||
|
"prefix": True,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__37(block=None, guardedHandlers=None, handlers=None,
|
||
|
finalizer=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.TryStatement,
|
||
|
"block": block,
|
||
|
"guardedHandlers": guardedHandlers,
|
||
|
"handlers": handlers,
|
||
|
"finalizer": finalizer,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__36(argument=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.ThrowStatement,
|
||
|
"argument": argument,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__35():
|
||
|
return jsdict({
|
||
|
"type": Syntax.ThisExpression,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__34(discriminant=None, cases=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.SwitchStatement,
|
||
|
"discriminant": discriminant,
|
||
|
"cases": cases,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__33(test=None, consequent=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.SwitchCase,
|
||
|
"test": test,
|
||
|
"consequent": consequent,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__32(expressions=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.SequenceExpression,
|
||
|
"expressions": expressions,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__31(argument=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.ReturnStatement,
|
||
|
"argument": argument,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__30(kind=None, key=None, value=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.Property,
|
||
|
"key": key,
|
||
|
"value": value,
|
||
|
"kind": kind,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__29(body=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.Program,
|
||
|
"body": body,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__28(operator=None, argument=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.UpdateExpression,
|
||
|
"operator": operator,
|
||
|
"argument": argument,
|
||
|
"prefix": False,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__27(properties=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.ObjectExpression,
|
||
|
"properties": properties,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__26(callee=None, args=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.NewExpression,
|
||
|
"callee": callee,
|
||
|
"arguments": args,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__25(accessor=None, object=None, property=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.MemberExpression,
|
||
|
"computed": accessor == "[",
|
||
|
"object": object,
|
||
|
"property": property,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__24(token=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.Literal,
|
||
|
"value": token.value,
|
||
|
"raw": source[token.range[0]:token.range[1]],
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__23(label=None, body=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.LabeledStatement,
|
||
|
"label": label,
|
||
|
"body": body,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__22(test=None, consequent=None, alternate=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.IfStatement,
|
||
|
"test": test,
|
||
|
"consequent": consequent,
|
||
|
"alternate": alternate,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__21(name=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.Identifier,
|
||
|
"name": name,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__20(id=None, params=None, defaults=None, body=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.FunctionExpression,
|
||
|
"id": id,
|
||
|
"params": params,
|
||
|
"defaults": defaults,
|
||
|
"body": body,
|
||
|
"rest": None,
|
||
|
"generator": False,
|
||
|
"expression": False,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__19(id=None, params=None, defaults=None, body=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.FunctionDeclaration,
|
||
|
"id": id,
|
||
|
"params": params,
|
||
|
"defaults": defaults,
|
||
|
"body": body,
|
||
|
"rest": None,
|
||
|
"generator": False,
|
||
|
"expression": False,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__18(left=None, right=None, body=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.ForInStatement,
|
||
|
"left": left,
|
||
|
"right": right,
|
||
|
"body": body,
|
||
|
"each": False,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__17(init=None, test=None, update=None, body=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.ForStatement,
|
||
|
"init": init,
|
||
|
"test": test,
|
||
|
"update": update,
|
||
|
"body": body,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__16(expression=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.ExpressionStatement,
|
||
|
"expression": expression,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__15():
|
||
|
return jsdict({
|
||
|
"type": Syntax.EmptyStatement,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__14(body=None, test=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.DoWhileStatement,
|
||
|
"body": body,
|
||
|
"test": test,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__13():
|
||
|
return jsdict({
|
||
|
"type": Syntax.DebuggerStatement,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__12(label=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.ContinueStatement,
|
||
|
"label": label,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__11(test=None, consequent=None, alternate=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.ConditionalExpression,
|
||
|
"test": test,
|
||
|
"consequent": consequent,
|
||
|
"alternate": alternate,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__10(param=None, body=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.CatchClause,
|
||
|
"param": param,
|
||
|
"body": body,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__9(callee=None, args=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.CallExpression,
|
||
|
"callee": callee,
|
||
|
"arguments": args,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__8(label=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.BreakStatement,
|
||
|
"label": label,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__7(body=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.BlockStatement,
|
||
|
"body": body,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__6(operator=None, left=None, right=None):
|
||
|
type = (Syntax.LogicalExpression if (operator == "||") or
|
||
|
(operator == "&&") else Syntax.BinaryExpression)
|
||
|
return jsdict({
|
||
|
"type": type,
|
||
|
"operator": operator,
|
||
|
"left": left,
|
||
|
"right": right,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__5(operator=None, left=None, right=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.AssignmentExpression,
|
||
|
"operator": operator,
|
||
|
"left": left,
|
||
|
"right": right,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__4(elements=None):
|
||
|
return jsdict({
|
||
|
"type": Syntax.ArrayExpression,
|
||
|
"elements": elements,
|
||
|
})
|
||
|
|
||
|
|
||
|
def __temp__3(node=None):
|
||
|
if extra.source:
|
||
|
node.loc.source = extra.source
|
||
|
return node
|
||
|
|
||
|
|
||
|
def __temp__2(node=None):
|
||
|
if node.range or node.loc:
|
||
|
if extra.loc:
|
||
|
state.markerStack.pop()
|
||
|
state.markerStack.pop()
|
||
|
if extra.range:
|
||
|
state.markerStack.pop()
|
||
|
else:
|
||
|
SyntaxTreeDelegate.markEnd(node)
|
||
|
return node
|
||
|
|
||
|
|
||
|
def __temp__1(node=None):
|
||
|
if extra.range:
|
||
|
node.range = [state.markerStack.pop(), index]
|
||
|
if extra.loc:
|
||
|
node.loc = jsdict({
|
||
|
"start":
|
||
|
jsdict({
|
||
|
"line": state.markerStack.pop(),
|
||
|
"column": state.markerStack.pop(),
|
||
|
}),
|
||
|
"end":
|
||
|
jsdict({
|
||
|
"line": lineNumber,
|
||
|
"column": index - lineStart,
|
||
|
}),
|
||
|
})
|
||
|
SyntaxTreeDelegate.postProcess(node)
|
||
|
return node
|
||
|
|
||
|
|
||
|
def __temp__0():
|
||
|
if extra.loc:
|
||
|
state.markerStack.append(index - lineStart)
|
||
|
state.markerStack.append(lineNumber)
|
||
|
if extra.range:
|
||
|
state.markerStack.append(index)
|
||
|
|
||
|
|
||
|
Token = None
|
||
|
TokenName = None
|
||
|
FnExprTokens = None
|
||
|
Syntax = None
|
||
|
PropertyKind = None
|
||
|
Messages = None
|
||
|
Regex = None
|
||
|
SyntaxTreeDelegate = None
|
||
|
source = None
|
||
|
strict = None
|
||
|
index = None
|
||
|
lineNumber = None
|
||
|
lineStart = None
|
||
|
length = None
|
||
|
delegate = None
|
||
|
lookahead = None
|
||
|
state = None
|
||
|
extra = None
|
||
|
Token = jsdict({
|
||
|
"BooleanLiteral": 1,
|
||
|
"EOF": 2,
|
||
|
"Identifier": 3,
|
||
|
"Keyword": 4,
|
||
|
"NullLiteral": 5,
|
||
|
"NumericLiteral": 6,
|
||
|
"Punctuator": 7,
|
||
|
"StringLiteral": 8,
|
||
|
"RegularExpression": 9,
|
||
|
})
|
||
|
TokenName = jsdict({})
|
||
|
TokenName[Token.BooleanLiteral] = "Boolean"
|
||
|
TokenName[Token.EOF] = "<end>"
|
||
|
TokenName[Token.Identifier] = "Identifier"
|
||
|
TokenName[Token.Keyword] = "Keyword"
|
||
|
TokenName[Token.NullLiteral] = "Null"
|
||
|
TokenName[Token.NumericLiteral] = "Numeric"
|
||
|
TokenName[Token.Punctuator] = "Punctuator"
|
||
|
TokenName[Token.StringLiteral] = "String"
|
||
|
TokenName[Token.RegularExpression] = "RegularExpression"
|
||
|
FnExprTokens = [
|
||
|
"(", "{", "[", "in", "typeof", "instanceof", "new", "return", "case",
|
||
|
"delete", "throw", "void", "=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=",
|
||
|
">>>=", "&=", "|=", "^=", ",", "+", "-", "*", "/", "%", "++", "--", "<<",
|
||
|
">>", ">>>", "&", "|", "^", "!", "~", "&&", "||", "?", ":", "===", "==",
|
||
|
">=", "<=", "<", ">", "!=", "!=="
|
||
|
]
|
||
|
Syntax = jsdict({
|
||
|
"AssignmentExpression": "AssignmentExpression",
|
||
|
"ArrayExpression": "ArrayExpression",
|
||
|
"BlockStatement": "BlockStatement",
|
||
|
"BinaryExpression": "BinaryExpression",
|
||
|
"BreakStatement": "BreakStatement",
|
||
|
"CallExpression": "CallExpression",
|
||
|
"CatchClause": "CatchClause",
|
||
|
"ConditionalExpression": "ConditionalExpression",
|
||
|
"ContinueStatement": "ContinueStatement",
|
||
|
"DoWhileStatement": "DoWhileStatement",
|
||
|
"DebuggerStatement": "DebuggerStatement",
|
||
|
"EmptyStatement": "EmptyStatement",
|
||
|
"ExpressionStatement": "ExpressionStatement",
|
||
|
"ForStatement": "ForStatement",
|
||
|
"ForInStatement": "ForInStatement",
|
||
|
"FunctionDeclaration": "FunctionDeclaration",
|
||
|
"FunctionExpression": "FunctionExpression",
|
||
|
"Identifier": "Identifier",
|
||
|
"IfStatement": "IfStatement",
|
||
|
"Literal": "Literal",
|
||
|
"LabeledStatement": "LabeledStatement",
|
||
|
"LogicalExpression": "LogicalExpression",
|
||
|
"MemberExpression": "MemberExpression",
|
||
|
"NewExpression": "NewExpression",
|
||
|
"ObjectExpression": "ObjectExpression",
|
||
|
"Program": "Program",
|
||
|
"Property": "Property",
|
||
|
"ReturnStatement": "ReturnStatement",
|
||
|
"SequenceExpression": "SequenceExpression",
|
||
|
"SwitchStatement": "SwitchStatement",
|
||
|
"SwitchCase": "SwitchCase",
|
||
|
"ThisExpression": "ThisExpression",
|
||
|
"ThrowStatement": "ThrowStatement",
|
||
|
"TryStatement": "TryStatement",
|
||
|
"UnaryExpression": "UnaryExpression",
|
||
|
"UpdateExpression": "UpdateExpression",
|
||
|
"VariableDeclaration": "VariableDeclaration",
|
||
|
"VariableDeclarator": "VariableDeclarator",
|
||
|
"WhileStatement": "WhileStatement",
|
||
|
"WithStatement": "WithStatement",
|
||
|
})
|
||
|
PropertyKind = jsdict({
|
||
|
"Data": 1,
|
||
|
"Get": 2,
|
||
|
"Set": 4,
|
||
|
})
|
||
|
Messages = jsdict({
|
||
|
"UnexpectedToken":
|
||
|
"Unexpected token %0",
|
||
|
"UnexpectedNumber":
|
||
|
"Unexpected number",
|
||
|
"UnexpectedString":
|
||
|
"Unexpected string",
|
||
|
"UnexpectedIdentifier":
|
||
|
"Unexpected identifier",
|
||
|
"UnexpectedReserved":
|
||
|
"Unexpected reserved word",
|
||
|
"UnexpectedEOS":
|
||
|
"Unexpected end of input",
|
||
|
"NewlineAfterThrow":
|
||
|
"Illegal newline after throw",
|
||
|
"InvalidRegExp":
|
||
|
"Invalid regular expression",
|
||
|
"UnterminatedRegExp":
|
||
|
"Invalid regular expression: missing /",
|
||
|
"InvalidLHSInAssignment":
|
||
|
"Invalid left-hand side in assignment",
|
||
|
"InvalidLHSInForIn":
|
||
|
"Invalid left-hand side in for-in",
|
||
|
"MultipleDefaultsInSwitch":
|
||
|
"More than one default clause in switch statement",
|
||
|
"NoCatchOrFinally":
|
||
|
"Missing catch or finally after try",
|
||
|
"UnknownLabel":
|
||
|
"Undefined label '%0'",
|
||
|
"Redeclaration":
|
||
|
"%0 '%1' has already been declared",
|
||
|
"IllegalContinue":
|
||
|
"Illegal continue statement",
|
||
|
"IllegalBreak":
|
||
|
"Illegal break statement",
|
||
|
"IllegalReturn":
|
||
|
"Illegal return statement",
|
||
|
"StrictModeWith":
|
||
|
"Strict mode code may not include a with statement",
|
||
|
"StrictCatchVariable":
|
||
|
"Catch variable may not be eval or arguments in strict mode",
|
||
|
"StrictVarName":
|
||
|
"Variable name may not be eval or arguments in strict mode",
|
||
|
"StrictParamName":
|
||
|
"Parameter name eval or arguments is not allowed in strict mode",
|
||
|
"StrictParamDupe":
|
||
|
"Strict mode function may not have duplicate parameter names",
|
||
|
"StrictFunctionName":
|
||
|
"Function name may not be eval or arguments in strict mode",
|
||
|
"StrictOctalLiteral":
|
||
|
"Octal literals are not allowed in strict mode.",
|
||
|
"StrictDelete":
|
||
|
"Delete of an unqualified identifier in strict mode.",
|
||
|
"StrictDuplicateProperty":
|
||
|
"Duplicate data property in object literal not allowed in strict mode",
|
||
|
"AccessorDataProperty":
|
||
|
"Object literal may not have data and accessor property with the same name",
|
||
|
"AccessorGetSet":
|
||
|
"Object literal may not have multiple get/set accessors with the same name",
|
||
|
"StrictLHSAssignment":
|
||
|
"Assignment to eval or arguments is not allowed in strict mode",
|
||
|
"StrictLHSPostfix":
|
||
|
"Postfix increment/decrement may not have eval or arguments operand in strict mode",
|
||
|
"StrictLHSPrefix":
|
||
|
"Prefix increment/decrement may not have eval or arguments operand in strict mode",
|
||
|
"StrictReservedWord":
|
||
|
"Use of future reserved word in strict mode",
|
||
|
})
|
||
|
Regex = jsdict({
|
||
|
"NonAsciiIdentifierStart":
|
||
|
RegExp(
|
||
|
u"[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe7
|
||
|
),
|
||
|
"NonAsciiIdentifierPart":
|
||
|
RegExp(
|
||
|
u"[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u05d0-\u05ea\u05f0-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u0800-\u082d\u0840-\u085b\u08a0\u08a2-\u08ac\u08e4-\u08fe\u0900-\u0963\u0966-\u096f\u0971-\u0977\u0979-\u097f\u0981-\u0983\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7\u09c8\u09cb-\u09ce\u09d7\u09dc\u09dd\u09df-\u09e3\u09e6-\u09f1\u0a01-\u0a03\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5c\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c58\u0c59\u0c60-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1\u0cf2\u0d02\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d57\u0d60-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d82\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772\u1773\u1780-\u17d3\u17d7\u17dc\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1820-\u1877\u1880-\u18aa\u18b0-\u18f5\u1900-\u191c\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1b00-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1cd0-\u1cd2\u1cd4-\u1cf6\u1d00-\u1de6\u1dfc-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u200c\u200d\u203f\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4
|
||
|
),
|
||
|
})
|
||
|
|
||
|
|
||
|
def assert__py__(condition=None, message=None):
|
||
|
if not condition:
|
||
|
raise RuntimeError("ASSERT: " + message)
|
||
|
|
||
|
|
||
|
def isDecimalDigit(ch=None):
|
||
|
return (ch >= 48) and (ch <= 57)
|
||
|
|
||
|
|
||
|
def isHexDigit(ch=None):
|
||
|
return "0123456789abcdefABCDEF".find(ch) >= 0
|
||
|
|
||
|
|
||
|
def isOctalDigit(ch=None):
|
||
|
return "01234567".find(ch) >= 0
|
||
|
|
||
|
|
||
|
def isWhiteSpace(ch=None):
|
||
|
return (
|
||
|
((((ch == 32) or (ch == 9)) or (ch == 11)) or
|
||
|
(ch == 12)) or (ch == 160)
|
||
|
) or ((ch >= 5760) and (
|
||
|
u"\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\ufeff"
|
||
|
.find(unichr(ch)) > 0))
|
||
|
|
||
|
|
||
|
def isLineTerminator(ch=None):
|
||
|
return (((ch == 10) or (ch == 13)) or (ch == 8232)) or (ch == 8233)
|
||
|
|
||
|
|
||
|
def isIdentifierStart(ch=None):
|
||
|
return (((((ch == 36) or (ch == 95)) or ((ch >= 65) and (ch <= 90))) or
|
||
|
((ch >= 97) and (ch <= 122))) or
|
||
|
(ch == 92)) or ((ch >= 128)
|
||
|
and Regex.NonAsciiIdentifierStart.test(unichr(ch)))
|
||
|
|
||
|
|
||
|
def isIdentifierPart(ch=None):
|
||
|
return ((((((ch == 36) or (ch == 95)) or ((ch >= 65) and (ch <= 90))) or
|
||
|
((ch >= 97) and (ch <= 122))) or ((ch >= 48) and (ch <= 57))) or
|
||
|
(ch == 92)) or ((ch >= 128)
|
||
|
and Regex.NonAsciiIdentifierPart.test(unichr(ch)))
|
||
|
|
||
|
|
||
|
def isFutureReservedWord(id=None):
|
||
|
while 1:
|
||
|
if (id == "super") or ((id == "import") or ((id == "extends") or
|
||
|
((id == "export") or
|
||
|
((id == "enum") or
|
||
|
(id == "class"))))):
|
||
|
return True
|
||
|
else:
|
||
|
return False
|
||
|
break
|
||
|
|
||
|
|
||
|
def isStrictModeReservedWord(id=None):
|
||
|
while 1:
|
||
|
if (id == "let") or ((id == "yield") or
|
||
|
((id == "static") or
|
||
|
((id == "public") or
|
||
|
((id == "protected") or
|
||
|
((id == "private") or
|
||
|
((id == "package") or
|
||
|
((id == "interface") or
|
||
|
(id == "implements")))))))):
|
||
|
return True
|
||
|
else:
|
||
|
return False
|
||
|
break
|
||
|
|
||
|
|
||
|
def isRestrictedWord(id=None):
|
||
|
return (id == "eval") or (id == "arguments")
|
||
|
|
||
|
|
||
|
def isKeyword(id=None):
|
||
|
if strict and isStrictModeReservedWord(id):
|
||
|
return True
|
||
|
while 1:
|
||
|
if len(id) == 2:
|
||
|
return ((id == "if") or (id == "in")) or (id == "do")
|
||
|
elif len(id) == 3:
|
||
|
return ((((id == "var") or (id == "for")) or (id == "new")) or
|
||
|
(id == "try")) or (id == "let")
|
||
|
elif len(id) == 4:
|
||
|
return (((((id == "this") or (id == "else")) or (id == "case")) or
|
||
|
(id == "void")) or (id == "with")) or (id == "enum")
|
||
|
elif len(id) == 5:
|
||
|
return (((((((id == "while") or (id == "break")) or
|
||
|
(id == "catch")) or (id == "throw")) or
|
||
|
(id == "const")) or (id == "yield")) or
|
||
|
(id == "class")) or (id == "super")
|
||
|
elif len(id) == 6:
|
||
|
return (((((id == "return") or (id == "typeof")) or
|
||
|
(id == "delete")) or (id == "switch")) or
|
||
|
(id == "export")) or (id == "import")
|
||
|
elif len(id) == 7:
|
||
|
return ((id == "default") or
|
||
|
(id == "finally")) or (id == "extends")
|
||
|
elif len(id) == 8:
|
||
|
return ((id == "function") or
|
||
|
(id == "continue")) or (id == "debugger")
|
||
|
elif len(id) == 10:
|
||
|
return id == "instanceof"
|
||
|
else:
|
||
|
return False
|
||
|
break
|
||
|
|
||
|
|
||
|
def addComment(type=None, value=None, start=None, end=None, loc=None):
|
||
|
comment = None
|
||
|
assert__py__(('undefined'
|
||
|
if not 'start' in locals() else typeof(start)) == "number",
|
||
|
"Comment must have valid position")
|
||
|
if state.lastCommentStart >= start:
|
||
|
return
|
||
|
state.lastCommentStart = start
|
||
|
comment = jsdict({
|
||
|
"type": type,
|
||
|
"value": value,
|
||
|
})
|
||
|
if extra.range:
|
||
|
comment.range = [start, end]
|
||
|
if extra.loc:
|
||
|
comment.loc = loc
|
||
|
extra.comments.append(comment)
|
||
|
|
||
|
|
||
|
def skipSingleLineComment():
|
||
|
global index, lineNumber, lineStart
|
||
|
start = None
|
||
|
loc = None
|
||
|
ch = None
|
||
|
comment = None
|
||
|
start = index - 2
|
||
|
loc = jsdict({
|
||
|
"start":
|
||
|
jsdict({
|
||
|
"line": lineNumber,
|
||
|
"column": (index - lineStart) - 2,
|
||
|
}),
|
||
|
})
|
||
|
while index < length:
|
||
|
ch = (ord(source[index]) if index < len(source) else None)
|
||
|
index += 1
|
||
|
index
|
||
|
if isLineTerminator(ch):
|
||
|
if extra.comments:
|
||
|
comment = source[(start + 2):(index - 1)]
|
||
|
loc.end = jsdict({
|
||
|
"line": lineNumber,
|
||
|
"column": (index - lineStart) - 1,
|
||
|
})
|
||
|
addComment("Line", comment, start, index - 1, loc)
|
||
|
if (ch == 13) and (
|
||
|
(ord(source[index]) if index < len(source) else None) == 10):
|
||
|
index += 1
|
||
|
index
|
||
|
lineNumber += 1
|
||
|
lineNumber
|
||
|
lineStart = index
|
||
|
return
|
||
|
if extra.comments:
|
||
|
comment = source[(start + 2):index]
|
||
|
loc.end = jsdict({
|
||
|
"line": lineNumber,
|
||
|
"column": index - lineStart,
|
||
|
})
|
||
|
addComment("Line", comment, start, index, loc)
|
||
|
|
||
|
|
||
|
def skipMultiLineComment():
|
||
|
global index, lineNumber, lineStart
|
||
|
start = None
|
||
|
loc = None
|
||
|
ch = None
|
||
|
comment = None
|
||
|
if extra.comments:
|
||
|
start = index - 2
|
||
|
loc = jsdict({
|
||
|
"start":
|
||
|
jsdict({
|
||
|
"line": lineNumber,
|
||
|
"column": (index - lineStart) - 2,
|
||
|
}),
|
||
|
})
|
||
|
while index < length:
|
||
|
ch = (ord(source[index]) if index < len(source) else None)
|
||
|
if isLineTerminator(ch):
|
||
|
if (ch == 13) and ((ord(source[index + 1]) if
|
||
|
(index + 1) < len(source) else None) == 10):
|
||
|
index += 1
|
||
|
index
|
||
|
lineNumber += 1
|
||
|
lineNumber
|
||
|
index += 1
|
||
|
index
|
||
|
lineStart = index
|
||
|
if index >= length:
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
elif ch == 42:
|
||
|
if (ord(source[index + 1]) if
|
||
|
(index + 1) < len(source) else None) == 47:
|
||
|
index += 1
|
||
|
index
|
||
|
index += 1
|
||
|
index
|
||
|
if extra.comments:
|
||
|
comment = source[(start + 2):(index - 2)]
|
||
|
loc.end = jsdict({
|
||
|
"line": lineNumber,
|
||
|
"column": index - lineStart,
|
||
|
})
|
||
|
addComment("Block", comment, start, index, loc)
|
||
|
return
|
||
|
index += 1
|
||
|
index
|
||
|
else:
|
||
|
index += 1
|
||
|
index
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
|
||
|
|
||
|
def skipComment():
|
||
|
global index, lineNumber, lineStart
|
||
|
ch = None
|
||
|
while index < length:
|
||
|
ch = (ord(source[index]) if index < len(source) else None)
|
||
|
if isWhiteSpace(ch):
|
||
|
index += 1
|
||
|
index
|
||
|
elif isLineTerminator(ch):
|
||
|
index += 1
|
||
|
index
|
||
|
if (ch == 13) and (
|
||
|
(ord(source[index]) if index < len(source) else None) == 10):
|
||
|
index += 1
|
||
|
index
|
||
|
lineNumber += 1
|
||
|
lineNumber
|
||
|
lineStart = index
|
||
|
elif ch == 47:
|
||
|
ch = (ord(source[index + 1]) if
|
||
|
(index + 1) < len(source) else None)
|
||
|
if ch == 47:
|
||
|
index += 1
|
||
|
index
|
||
|
index += 1
|
||
|
index
|
||
|
skipSingleLineComment()
|
||
|
elif ch == 42:
|
||
|
index += 1
|
||
|
index
|
||
|
index += 1
|
||
|
index
|
||
|
skipMultiLineComment()
|
||
|
else:
|
||
|
break
|
||
|
else:
|
||
|
break
|
||
|
|
||
|
|
||
|
def scanHexEscape(prefix=None):
|
||
|
global len__py__, index
|
||
|
i = None
|
||
|
len__py__ = None
|
||
|
ch = None
|
||
|
code = 0
|
||
|
len__py__ = (4 if prefix == "u" else 2)
|
||
|
i = 0
|
||
|
while 1:
|
||
|
if not (i < len__py__):
|
||
|
break
|
||
|
if (index < length) and isHexDigit(source[index]):
|
||
|
index += 1
|
||
|
ch = source[index - 1]
|
||
|
code = (code * 16) + "0123456789abcdef".find(ch.lower())
|
||
|
else:
|
||
|
return ""
|
||
|
i += 1
|
||
|
return unichr(code)
|
||
|
|
||
|
|
||
|
def getEscapedIdentifier():
|
||
|
global index
|
||
|
ch = None
|
||
|
id = None
|
||
|
index += 1
|
||
|
index += 1
|
||
|
ch = (ord(source[index - 1]) if index - 1 < len(source) else None)
|
||
|
id = unichr(ch)
|
||
|
if ch == 92:
|
||
|
if (ord(source[index]) if index < len(source) else None) != 117:
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
index += 1
|
||
|
index
|
||
|
ch = scanHexEscape("u")
|
||
|
if ((not ch) or (ch == "\\")) or (not isIdentifierStart(
|
||
|
(ord(ch[0]) if 0 < len(ch) else None))):
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
id = ch
|
||
|
while index < length:
|
||
|
ch = (ord(source[index]) if index < len(source) else None)
|
||
|
if not isIdentifierPart(ch):
|
||
|
break
|
||
|
index += 1
|
||
|
index
|
||
|
id += unichr(ch)
|
||
|
if ch == 92:
|
||
|
id = id[0:(0 + (len(id) - 1))]
|
||
|
if (ord(source[index]) if index < len(source) else None) != 117:
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
index += 1
|
||
|
index
|
||
|
ch = scanHexEscape("u")
|
||
|
if ((not ch) or (ch == "\\")) or (not isIdentifierPart(
|
||
|
(ord(ch[0]) if 0 < len(ch) else None))):
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
id += ch
|
||
|
return id
|
||
|
|
||
|
|
||
|
def getIdentifier():
|
||
|
global index
|
||
|
start = None
|
||
|
ch = None
|
||
|
index += 1
|
||
|
start = index - 1
|
||
|
while index < length:
|
||
|
ch = (ord(source[index]) if index < len(source) else None)
|
||
|
if ch == 92:
|
||
|
index = start
|
||
|
return getEscapedIdentifier()
|
||
|
if isIdentifierPart(ch):
|
||
|
index += 1
|
||
|
index
|
||
|
else:
|
||
|
break
|
||
|
return source[start:index]
|
||
|
|
||
|
|
||
|
def scanIdentifier():
|
||
|
start = None
|
||
|
id = None
|
||
|
type = None
|
||
|
start = index
|
||
|
id = (getEscapedIdentifier() if
|
||
|
(ord(source[index]) if index < len(source) else None) == 92 else
|
||
|
getIdentifier())
|
||
|
if len(id) == 1:
|
||
|
type = Token.Identifier
|
||
|
elif isKeyword(id):
|
||
|
type = Token.Keyword
|
||
|
elif id == "null":
|
||
|
type = Token.NullLiteral
|
||
|
elif (id == "true") or (id == "false"):
|
||
|
type = Token.BooleanLiteral
|
||
|
else:
|
||
|
type = Token.Identifier
|
||
|
return jsdict({
|
||
|
"type": type,
|
||
|
"value": id,
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
|
||
|
|
||
|
def scanPunctuator():
|
||
|
global index
|
||
|
start = index
|
||
|
code = (ord(source[index]) if index < len(source) else None)
|
||
|
code2 = None
|
||
|
ch1 = source[index]
|
||
|
ch2 = None
|
||
|
ch3 = None
|
||
|
ch4 = None
|
||
|
while 1:
|
||
|
if (code == 126) or ((code == 63) or ((code == 58) or
|
||
|
((code == 93) or
|
||
|
((code == 91) or
|
||
|
((code == 125) or
|
||
|
((code == 123) or
|
||
|
((code == 44) or
|
||
|
((code == 59) or
|
||
|
((code == 41) or
|
||
|
((code == 40) or
|
||
|
(code == 46))))))))))):
|
||
|
index += 1
|
||
|
index
|
||
|
if extra.tokenize:
|
||
|
if code == 40:
|
||
|
extra.openParenToken = len(extra.tokens)
|
||
|
elif code == 123:
|
||
|
extra.openCurlyToken = len(extra.tokens)
|
||
|
return jsdict({
|
||
|
"type": Token.Punctuator,
|
||
|
"value": unichr(code),
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
else:
|
||
|
code2 = (ord(source[index + 1]) if
|
||
|
(index + 1) < len(source) else None)
|
||
|
if code2 == 61:
|
||
|
while 1:
|
||
|
if (code == 124) or ((code == 94) or
|
||
|
((code == 62) or
|
||
|
((code == 60) or
|
||
|
((code == 47) or
|
||
|
((code == 45) or
|
||
|
((code == 43) or
|
||
|
((code == 42) or
|
||
|
((code == 38) or
|
||
|
(code == 37))))))))):
|
||
|
index += 2
|
||
|
return jsdict({
|
||
|
"type": Token.Punctuator,
|
||
|
"value": unichr(code) + unichr(code2),
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
elif (code == 61) or (code == 33):
|
||
|
index += 2
|
||
|
if (ord(source[index])
|
||
|
if index < len(source) else None) == 61:
|
||
|
index += 1
|
||
|
index
|
||
|
return jsdict({
|
||
|
"type": Token.Punctuator,
|
||
|
"value": source[start:index],
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
else:
|
||
|
break
|
||
|
break
|
||
|
break
|
||
|
break
|
||
|
ch2 = source[index + 1] if index + 1 < len(source) else None
|
||
|
ch3 = source[index + 2] if index + 2 < len(source) else None
|
||
|
ch4 = source[index + 3] if index + 3 < len(source) else None
|
||
|
if ((ch1 == ">") and (ch2 == ">")) and (ch3 == ">"):
|
||
|
if ch4 == "=":
|
||
|
index += 4
|
||
|
return jsdict({
|
||
|
"type": Token.Punctuator,
|
||
|
"value": ">>>=",
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
if ((ch1 == ">") and (ch2 == ">")) and (ch3 == ">"):
|
||
|
index += 3
|
||
|
return jsdict({
|
||
|
"type": Token.Punctuator,
|
||
|
"value": ">>>",
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
if ((ch1 == "<") and (ch2 == "<")) and (ch3 == "="):
|
||
|
index += 3
|
||
|
return jsdict({
|
||
|
"type": Token.Punctuator,
|
||
|
"value": "<<=",
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
if ((ch1 == ">") and (ch2 == ">")) and (ch3 == "="):
|
||
|
index += 3
|
||
|
return jsdict({
|
||
|
"type": Token.Punctuator,
|
||
|
"value": ">>=",
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
if (ch1 == ch2) and ("+-<>&|".find(ch1) >= 0):
|
||
|
index += 2
|
||
|
return jsdict({
|
||
|
"type": Token.Punctuator,
|
||
|
"value": ch1 + ch2,
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
if "<>=!+-*%&|^/".find(ch1) >= 0:
|
||
|
index += 1
|
||
|
index
|
||
|
return jsdict({
|
||
|
"type": Token.Punctuator,
|
||
|
"value": ch1,
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
|
||
|
|
||
|
def scanHexLiteral(start=None):
|
||
|
global index
|
||
|
number = ""
|
||
|
while index < length:
|
||
|
if not isHexDigit(source[index]):
|
||
|
break
|
||
|
index += 1
|
||
|
number += source[index - 1]
|
||
|
if len(number) == 0:
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
if isIdentifierStart(
|
||
|
(ord(source[index]) if index < len(source) else None)):
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
return jsdict({
|
||
|
"type": Token.NumericLiteral,
|
||
|
"value": parseInt("0x" + number, 16),
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
|
||
|
|
||
|
def scanOctalLiteral(start=None):
|
||
|
global index
|
||
|
index += 1
|
||
|
number = "0" + source[index - 1]
|
||
|
while index < length:
|
||
|
if not isOctalDigit(source[index]):
|
||
|
break
|
||
|
index += 1
|
||
|
number += source[index - 1]
|
||
|
if isIdentifierStart(
|
||
|
(ord(source[index])
|
||
|
if index < len(source) else None)) or isDecimalDigit(
|
||
|
(ord(source[index]) if index < len(source) else None)):
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
return jsdict({
|
||
|
"type": Token.NumericLiteral,
|
||
|
"value": parseInt(number, 8),
|
||
|
"octal": True,
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
|
||
|
|
||
|
def scanNumericLiteral():
|
||
|
global index
|
||
|
number = None
|
||
|
start = None
|
||
|
ch = None
|
||
|
ch = source[index]
|
||
|
assert__py__(
|
||
|
isDecimalDigit((ord(ch[0]) if 0 < len(ch) else None)) or (ch == "."),
|
||
|
"Numeric literal must start with a decimal digit or a decimal point")
|
||
|
start = index
|
||
|
number = ""
|
||
|
if ch != ".":
|
||
|
index += 1
|
||
|
number = source[index - 1]
|
||
|
ch = source[index] if index < len(source) else None
|
||
|
if number == "0":
|
||
|
if (ch == "x") or (ch == "X"):
|
||
|
index += 1
|
||
|
index
|
||
|
return scanHexLiteral(start)
|
||
|
if isOctalDigit(ch):
|
||
|
return scanOctalLiteral(start)
|
||
|
if ch and isDecimalDigit((ord(ch[0]) if 0 < len(ch) else None)):
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
while isDecimalDigit(
|
||
|
(ord(source[index]) if index < len(source) else None)):
|
||
|
index += 1
|
||
|
number += source[index - 1]
|
||
|
ch = source[index] if index < len(source) else None
|
||
|
if ch == ".":
|
||
|
index += 1
|
||
|
number += source[index - 1]
|
||
|
while isDecimalDigit(
|
||
|
(ord(source[index]) if index < len(source) else None)):
|
||
|
index += 1
|
||
|
number += source[index - 1]
|
||
|
ch = source[index]
|
||
|
if (ch == "e") or (ch == "E"):
|
||
|
index += 1
|
||
|
number += source[index - 1]
|
||
|
ch = source[index]
|
||
|
if (ch == "+") or (ch == "-"):
|
||
|
index += 1
|
||
|
number += source[index - 1]
|
||
|
if isDecimalDigit(
|
||
|
(ord(source[index]) if index < len(source) else None)):
|
||
|
while isDecimalDigit(
|
||
|
(ord(source[index]) if index < len(source) else None)):
|
||
|
index += 1
|
||
|
number += source[index - 1]
|
||
|
else:
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
if isIdentifierStart(
|
||
|
(ord(source[index]) if index < len(source) else None)):
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
return jsdict({
|
||
|
"type": Token.NumericLiteral,
|
||
|
"value": parseFloat(number),
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
|
||
|
|
||
|
def scanStringLiteral():
|
||
|
global index, lineNumber
|
||
|
str = ""
|
||
|
quote = None
|
||
|
start = None
|
||
|
ch = None
|
||
|
code = None
|
||
|
unescaped = None
|
||
|
restore = None
|
||
|
octal = False
|
||
|
quote = source[index]
|
||
|
assert__py__((quote == "'") or (quote == "\""),
|
||
|
"String literal must starts with a quote")
|
||
|
start = index
|
||
|
index += 1
|
||
|
index
|
||
|
while index < length:
|
||
|
index += 1
|
||
|
ch = source[index - 1]
|
||
|
if ch == quote:
|
||
|
quote = ""
|
||
|
break
|
||
|
elif ch == "\\":
|
||
|
index += 1
|
||
|
ch = source[index - 1]
|
||
|
if (not ch) or (not isLineTerminator(
|
||
|
(ord(ch[0]) if 0 < len(ch) else None))):
|
||
|
while 1:
|
||
|
if ch == "n":
|
||
|
str += u"\x0a"
|
||
|
break
|
||
|
elif ch == "r":
|
||
|
str += u"\x0d"
|
||
|
break
|
||
|
elif ch == "t":
|
||
|
str += u"\x09"
|
||
|
break
|
||
|
elif (ch == "x") or (ch == "u"):
|
||
|
restore = index
|
||
|
unescaped = scanHexEscape(ch)
|
||
|
if unescaped:
|
||
|
str += unescaped
|
||
|
else:
|
||
|
index = restore
|
||
|
str += ch
|
||
|
break
|
||
|
elif ch == "b":
|
||
|
str += u"\x08"
|
||
|
break
|
||
|
elif ch == "f":
|
||
|
str += u"\x0c"
|
||
|
break
|
||
|
elif ch == "v":
|
||
|
str += u"\x0b"
|
||
|
break
|
||
|
else:
|
||
|
if isOctalDigit(ch):
|
||
|
code = "01234567".find(ch)
|
||
|
if code != 0:
|
||
|
octal = True
|
||
|
if (index < length) and isOctalDigit(
|
||
|
source[index]):
|
||
|
octal = True
|
||
|
index += 1
|
||
|
code = (code * 8) + "01234567".find(
|
||
|
source[index - 1])
|
||
|
if (("0123".find(ch) >= 0) and
|
||
|
(index < length)) and isOctalDigit(
|
||
|
source[index]):
|
||
|
index += 1
|
||
|
code = (code * 8) + "01234567".find(
|
||
|
source[index - 1])
|
||
|
str += unichr(code)
|
||
|
else:
|
||
|
str += ch
|
||
|
break
|
||
|
break
|
||
|
else:
|
||
|
lineNumber += 1
|
||
|
lineNumber
|
||
|
if (ch == u"\x0d") and (source[index] == u"\x0a"):
|
||
|
index += 1
|
||
|
index
|
||
|
elif isLineTerminator((ord(ch[0]) if 0 < len(ch) else None)):
|
||
|
break
|
||
|
else:
|
||
|
str += ch
|
||
|
if quote != "":
|
||
|
throwError(jsdict({}), Messages.UnexpectedToken, "ILLEGAL")
|
||
|
return jsdict({
|
||
|
"type": Token.StringLiteral,
|
||
|
"value": str,
|
||
|
"octal": octal,
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
|
||
|
|
||
|
def scanRegExp():
|
||
|
global lookahead, index
|
||
|
str = None
|
||
|
ch = None
|
||
|
start = None
|
||
|
pattern = None
|
||
|
flags = None
|
||
|
value = None
|
||
|
classMarker = False
|
||
|
restore = None
|
||
|
terminated = False
|
||
|
lookahead = None
|
||
|
skipComment()
|
||
|
start = index
|
||
|
ch = source[index]
|
||
|
assert__py__(ch == "/",
|
||
|
"Regular expression literal must start with a slash")
|
||
|
index += 1
|
||
|
str = source[index - 1]
|
||
|
while index < length:
|
||
|
index += 1
|
||
|
ch = source[index - 1]
|
||
|
str += ch
|
||
|
if classMarker:
|
||
|
if ch == "]":
|
||
|
classMarker = False
|
||
|
else:
|
||
|
if ch == "\\":
|
||
|
index += 1
|
||
|
ch = source[index - 1]
|
||
|
if isLineTerminator((ord(ch[0]) if 0 < len(ch) else None)):
|
||
|
throwError(jsdict({}), Messages.UnterminatedRegExp)
|
||
|
str += ch
|
||
|
elif ch == "/":
|
||
|
terminated = True
|
||
|
break
|
||
|
elif ch == "[":
|
||
|
classMarker = True
|
||
|
elif isLineTerminator((ord(ch[0]) if 0 < len(ch) else None)):
|
||
|
throwError(jsdict({}), Messages.UnterminatedRegExp)
|
||
|
if not terminated:
|
||
|
throwError(jsdict({}), Messages.UnterminatedRegExp)
|
||
|
pattern = str[1:(1 + (len(str) - 2))]
|
||
|
flags = ""
|
||
|
while index < length:
|
||
|
ch = source[index]
|
||
|
if not isIdentifierPart((ord(ch[0]) if 0 < len(ch) else None)):
|
||
|
break
|
||
|
index += 1
|
||
|
index
|
||
|
if (ch == "\\") and (index < length):
|
||
|
ch = source[index]
|
||
|
if ch == "u":
|
||
|
index += 1
|
||
|
index
|
||
|
restore = index
|
||
|
ch = scanHexEscape("u")
|
||
|
if ch:
|
||
|
flags += ch
|
||
|
str += "\\u"
|
||
|
while 1:
|
||
|
if not (restore < index):
|
||
|
break
|
||
|
str += source[restore]
|
||
|
restore += 1
|
||
|
else:
|
||
|
index = restore
|
||
|
flags += "u"
|
||
|
str += "\\u"
|
||
|
else:
|
||
|
str += "\\"
|
||
|
else:
|
||
|
flags += ch
|
||
|
str += ch
|
||
|
try:
|
||
|
value = RegExp(pattern, flags)
|
||
|
except Exception as e:
|
||
|
throwError(jsdict({}), Messages.InvalidRegExp)
|
||
|
peek()
|
||
|
if extra.tokenize:
|
||
|
return jsdict({
|
||
|
"type": Token.RegularExpression,
|
||
|
"value": value,
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
return jsdict({
|
||
|
"literal": str,
|
||
|
"value": value,
|
||
|
"range": [start, index],
|
||
|
})
|
||
|
|
||
|
|
||
|
def isIdentifierName(token=None):
|
||
|
return (((token.type == Token.Identifier) or
|
||
|
(token.type == Token.Keyword)) or
|
||
|
(token.type == Token.BooleanLiteral)) or (
|
||
|
token.type == Token.NullLiteral)
|
||
|
|
||
|
|
||
|
def advanceSlash():
|
||
|
prevToken = None
|
||
|
checkToken = None
|
||
|
prevToken = extra.tokens[len(extra.tokens) - 1]
|
||
|
if not prevToken:
|
||
|
return scanRegExp()
|
||
|
if prevToken.type == "Punctuator":
|
||
|
if prevToken.value == ")":
|
||
|
checkToken = extra.tokens[extra.openParenToken - 1]
|
||
|
if (checkToken and (checkToken.type == "Keyword")) and (
|
||
|
(((checkToken.value == "if") or
|
||
|
(checkToken.value == "while")) or
|
||
|
(checkToken.value == "for")) or (checkToken.value == "with")):
|
||
|
return scanRegExp()
|
||
|
return scanPunctuator()
|
||
|
if prevToken.value == "}":
|
||
|
if extra.tokens[extra.openCurlyToken - 3] and (
|
||
|
extra.tokens[extra.openCurlyToken - 3].type == "Keyword"):
|
||
|
checkToken = extra.tokens[extra.openCurlyToken - 4]
|
||
|
if not checkToken:
|
||
|
return scanPunctuator()
|
||
|
elif extra.tokens[extra.openCurlyToken - 4] and (
|
||
|
extra.tokens[extra.openCurlyToken - 4].type == "Keyword"):
|
||
|
checkToken = extra.tokens[extra.openCurlyToken - 5]
|
||
|
if not checkToken:
|
||
|
return scanRegExp()
|
||
|
else:
|
||
|
return scanPunctuator()
|
||
|
if FnExprTokens.indexOf(checkToken.value) >= 0:
|
||
|
return scanPunctuator()
|
||
|
return scanRegExp()
|
||
|
return scanRegExp()
|
||
|
if prevToken.type == "Keyword":
|
||
|
return scanRegExp()
|
||
|
return scanPunctuator()
|
||
|
|
||
|
|
||
|
def advance():
|
||
|
ch = None
|
||
|
skipComment()
|
||
|
if index >= length:
|
||
|
return jsdict({
|
||
|
"type": Token.EOF,
|
||
|
"lineNumber": lineNumber,
|
||
|
"lineStart": lineStart,
|
||
|
"range": [index, index],
|
||
|
})
|
||
|
ch = (ord(source[index]) if index < len(source) else None)
|
||
|
if ((ch == 40) or (ch == 41)) or (ch == 58):
|
||
|
return scanPunctuator()
|
||
|
if (ch == 39) or (ch == 34):
|
||
|
return scanStringLiteral()
|
||
|
if isIdentifierStart(ch):
|
||
|
return scanIdentifier()
|
||
|
if ch == 46:
|
||
|
if isDecimalDigit((ord(source[index + 1]) if
|
||
|
(index + 1) < len(source) else None)):
|
||
|
return scanNumericLiteral()
|
||
|
return scanPunctuator()
|
||
|
if isDecimalDigit(ch):
|
||
|
return scanNumericLiteral()
|
||
|
if extra.tokenize and (ch == 47):
|
||
|
return advanceSlash()
|
||
|
return scanPunctuator()
|
||
|
|
||
|
|
||
|
def lex():
|
||
|
global index, lineNumber, lineStart, lookahead
|
||
|
token = None
|
||
|
token = lookahead
|
||
|
index = token.range[1]
|
||
|
lineNumber = token.lineNumber
|
||
|
lineStart = token.lineStart
|
||
|
lookahead = advance()
|
||
|
index = token.range[1]
|
||
|
lineNumber = token.lineNumber
|
||
|
lineStart = token.lineStart
|
||
|
return token
|
||
|
|
||
|
|
||
|
def peek():
|
||
|
global lookahead, index, lineNumber, lineStart
|
||
|
pos = None
|
||
|
line = None
|
||
|
start = None
|
||
|
pos = index
|
||
|
line = lineNumber
|
||
|
start = lineStart
|
||
|
lookahead = advance()
|
||
|
index = pos
|
||
|
lineNumber = line
|
||
|
lineStart = start
|
||
|
|
||
|
|
||
|
SyntaxTreeDelegate = jsdict({
|
||
|
"name": "SyntaxTree",
|
||
|
"markStart": __temp__0,
|
||
|
"markEnd": __temp__1,
|
||
|
"markEndIf": __temp__2,
|
||
|
"postProcess": __temp__3,
|
||
|
"createArrayExpression": __temp__4,
|
||
|
"createAssignmentExpression": __temp__5,
|
||
|
"createBinaryExpression": __temp__6,
|
||
|
"createBlockStatement": __temp__7,
|
||
|
"createBreakStatement": __temp__8,
|
||
|
"createCallExpression": __temp__9,
|
||
|
"createCatchClause": __temp__10,
|
||
|
"createConditionalExpression": __temp__11,
|
||
|
"createContinueStatement": __temp__12,
|
||
|
"createDebuggerStatement": __temp__13,
|
||
|
"createDoWhileStatement": __temp__14,
|
||
|
"createEmptyStatement": __temp__15,
|
||
|
"createExpressionStatement": __temp__16,
|
||
|
"createForStatement": __temp__17,
|
||
|
"createForInStatement": __temp__18,
|
||
|
"createFunctionDeclaration": __temp__19,
|
||
|
"createFunctionExpression": __temp__20,
|
||
|
"createIdentifier": __temp__21,
|
||
|
"createIfStatement": __temp__22,
|
||
|
"createLabeledStatement": __temp__23,
|
||
|
"createLiteral": __temp__24,
|
||
|
"createMemberExpression": __temp__25,
|
||
|
"createNewExpression": __temp__26,
|
||
|
"createObjectExpression": __temp__27,
|
||
|
"createPostfixExpression": __temp__28,
|
||
|
"createProgram": __temp__29,
|
||
|
"createProperty": __temp__30,
|
||
|
"createReturnStatement": __temp__31,
|
||
|
"createSequenceExpression": __temp__32,
|
||
|
"createSwitchCase": __temp__33,
|
||
|
"createSwitchStatement": __temp__34,
|
||
|
"createThisExpression": __temp__35,
|
||
|
"createThrowStatement": __temp__36,
|
||
|
"createTryStatement": __temp__37,
|
||
|
"createUnaryExpression": __temp__38,
|
||
|
"createVariableDeclaration": __temp__39,
|
||
|
"createVariableDeclarator": __temp__40,
|
||
|
"createWhileStatement": __temp__41,
|
||
|
"createWithStatement": __temp__42,
|
||
|
})
|
||
|
|
||
|
|
||
|
def peekLineTerminator():
|
||
|
global index, lineNumber, lineStart
|
||
|
pos = None
|
||
|
line = None
|
||
|
start = None
|
||
|
found = None
|
||
|
pos = index
|
||
|
line = lineNumber
|
||
|
start = lineStart
|
||
|
skipComment()
|
||
|
found = lineNumber != line
|
||
|
index = pos
|
||
|
lineNumber = line
|
||
|
lineStart = start
|
||
|
return found
|
||
|
|
||
|
|
||
|
def throwError(token=None, messageFormat=None, a=None):
|
||
|
def __temp__43(whole=None, index=None):
|
||
|
assert__py__(index < len(args), "Message reference must be in range")
|
||
|
return args[index]
|
||
|
|
||
|
error = None
|
||
|
args = Array.prototype.slice.call(arguments, 2)
|
||
|
msg = messageFormat.replace(RegExp(r'%(\d)'), __temp__43)
|
||
|
if ('undefined' if not ('lineNumber' in token) else typeof(
|
||
|
token.lineNumber)) == "number":
|
||
|
error = RuntimeError((("Line " + token.lineNumber) + ": ") + msg)
|
||
|
error.index = token.range[0]
|
||
|
error.lineNumber = token.lineNumber
|
||
|
error.column = (token.range[0] - lineStart) + 1
|
||
|
else:
|
||
|
error = RuntimeError((("Line " + lineNumber) + ": ") + msg)
|
||
|
error.index = index
|
||
|
error.lineNumber = lineNumber
|
||
|
error.column = (index - lineStart) + 1
|
||
|
error.description = msg
|
||
|
raise error
|
||
|
|
||
|
|
||
|
def throwErrorTolerant():
|
||
|
try:
|
||
|
throwError.apply(None, arguments)
|
||
|
except Exception as e:
|
||
|
if extra.errors:
|
||
|
extra.errors.append(e)
|
||
|
else:
|
||
|
raise
|
||
|
|
||
|
|
||
|
def throwUnexpected(token=None):
|
||
|
if token.type == Token.EOF:
|
||
|
throwError(token, Messages.UnexpectedEOS)
|
||
|
if token.type == Token.NumericLiteral:
|
||
|
throwError(token, Messages.UnexpectedNumber)
|
||
|
if token.type == Token.StringLiteral:
|
||
|
throwError(token, Messages.UnexpectedString)
|
||
|
if token.type == Token.Identifier:
|
||
|
throwError(token, Messages.UnexpectedIdentifier)
|
||
|
if token.type == Token.Keyword:
|
||
|
if isFutureReservedWord(token.value):
|
||
|
throwError(token, Messages.UnexpectedReserved)
|
||
|
elif strict and isStrictModeReservedWord(token.value):
|
||
|
throwErrorTolerant(token, Messages.StrictReservedWord)
|
||
|
return
|
||
|
throwError(token, Messages.UnexpectedToken, token.value)
|
||
|
throwError(token, Messages.UnexpectedToken, token.value)
|
||
|
|
||
|
|
||
|
def expect(value=None):
|
||
|
token = lex()
|
||
|
if (token.type != Token.Punctuator) or (token.value != value):
|
||
|
throwUnexpected(token)
|
||
|
|
||
|
|
||
|
def expectKeyword(keyword=None):
|
||
|
token = lex()
|
||
|
if (token.type != Token.Keyword) or (token.value != keyword):
|
||
|
throwUnexpected(token)
|
||
|
|
||
|
|
||
|
def match(value=None):
|
||
|
return (lookahead.type == Token.Punctuator) and (lookahead.value == value)
|
||
|
|
||
|
|
||
|
def matchKeyword(keyword=None):
|
||
|
return (lookahead.type == Token.Keyword) and (lookahead.value == keyword)
|
||
|
|
||
|
|
||
|
def matchAssign():
|
||
|
op = None
|
||
|
if lookahead.type != Token.Punctuator:
|
||
|
return False
|
||
|
op = lookahead.value
|
||
|
return (((((((((((op == "=") or (op == "*=")) or (op == "/=")) or
|
||
|
(op == "%=")) or (op == "+=")) or (op == "-=")) or
|
||
|
(op == "<<=")) or (op == ">>=")) or (op == ">>>=")) or
|
||
|
(op == "&=")) or (op == "^=")) or (op == "|=")
|
||
|
|
||
|
|
||
|
def consumeSemicolon():
|
||
|
line = None
|
||
|
if (ord(source[index]) if index < len(source) else None) == 59:
|
||
|
lex()
|
||
|
return
|
||
|
line = lineNumber
|
||
|
skipComment()
|
||
|
if lineNumber != line:
|
||
|
return
|
||
|
if match(";"):
|
||
|
lex()
|
||
|
return
|
||
|
if (lookahead.type != Token.EOF) and (not match("}")):
|
||
|
throwUnexpected(lookahead)
|
||
|
|
||
|
|
||
|
def isLeftHandSide(expr=None):
|
||
|
return (expr.type == Syntax.Identifier) or (
|
||
|
expr.type == Syntax.MemberExpression)
|
||
|
|
||
|
|
||
|
def parseArrayInitialiser():
|
||
|
elements = []
|
||
|
expect("[")
|
||
|
while not match("]"):
|
||
|
if match(","):
|
||
|
lex()
|
||
|
elements.append(None)
|
||
|
else:
|
||
|
elements.append(parseAssignmentExpression())
|
||
|
if not match("]"):
|
||
|
expect(",")
|
||
|
expect("]")
|
||
|
return delegate.createArrayExpression(elements)
|
||
|
|
||
|
|
||
|
def parsePropertyFunction(param=None, first=None):
|
||
|
global strict
|
||
|
previousStrict = None
|
||
|
body = None
|
||
|
previousStrict = strict
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
body = parseFunctionSourceElements()
|
||
|
if (first and strict) and isRestrictedWord(param[0].name):
|
||
|
throwErrorTolerant(first, Messages.StrictParamName)
|
||
|
strict = previousStrict
|
||
|
return delegate.markEnd(
|
||
|
delegate.createFunctionExpression(None, param, [], body))
|
||
|
|
||
|
|
||
|
def parseObjectPropertyKey():
|
||
|
token = None
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
token = lex()
|
||
|
if (token.type == Token.StringLiteral) or (
|
||
|
token.type == Token.NumericLiteral):
|
||
|
if strict and token.octal:
|
||
|
throwErrorTolerant(token, Messages.StrictOctalLiteral)
|
||
|
return delegate.markEnd(delegate.createLiteral(token))
|
||
|
return delegate.markEnd(delegate.createIdentifier(token.value))
|
||
|
|
||
|
|
||
|
def parseObjectProperty():
|
||
|
token = None
|
||
|
key = None
|
||
|
id = None
|
||
|
value = None
|
||
|
param = None
|
||
|
token = lookahead
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
if token.type == Token.Identifier:
|
||
|
id = parseObjectPropertyKey()
|
||
|
if (token.value == "get") and (not match(":")):
|
||
|
key = parseObjectPropertyKey()
|
||
|
expect("(")
|
||
|
expect(")")
|
||
|
value = parsePropertyFunction([])
|
||
|
return delegate.markEnd(delegate.createProperty("get", key, value))
|
||
|
if (token.value == "set") and (not match(":")):
|
||
|
key = parseObjectPropertyKey()
|
||
|
expect("(")
|
||
|
token = lookahead
|
||
|
if token.type != Token.Identifier:
|
||
|
expect(")")
|
||
|
throwErrorTolerant(token, Messages.UnexpectedToken,
|
||
|
token.value)
|
||
|
value = parsePropertyFunction([])
|
||
|
else:
|
||
|
param = [parseVariableIdentifier()]
|
||
|
expect(")")
|
||
|
value = parsePropertyFunction(param, token)
|
||
|
return delegate.markEnd(delegate.createProperty("set", key, value))
|
||
|
expect(":")
|
||
|
value = parseAssignmentExpression()
|
||
|
return delegate.markEnd(delegate.createProperty("init", id, value))
|
||
|
if (token.type == Token.EOF) or (token.type == Token.Punctuator):
|
||
|
throwUnexpected(token)
|
||
|
else:
|
||
|
key = parseObjectPropertyKey()
|
||
|
expect(":")
|
||
|
value = parseAssignmentExpression()
|
||
|
return delegate.markEnd(delegate.createProperty("init", key, value))
|
||
|
|
||
|
|
||
|
def parseObjectInitialiser():
|
||
|
properties = []
|
||
|
property = None
|
||
|
name = None
|
||
|
key = None
|
||
|
kind = None
|
||
|
map = jsdict({})
|
||
|
toString = str
|
||
|
expect("{")
|
||
|
while not match("}"):
|
||
|
property = parseObjectProperty()
|
||
|
if property.key.type == Syntax.Identifier:
|
||
|
name = property.key.name
|
||
|
else:
|
||
|
name = toString(property.key.value)
|
||
|
kind = (PropertyKind.Data if property.kind == "init" else (
|
||
|
PropertyKind.Get if property.kind == "get" else PropertyKind.Set))
|
||
|
key = "$" + name
|
||
|
if key in map:
|
||
|
if map[key] == PropertyKind.Data:
|
||
|
if strict and (kind == PropertyKind.Data):
|
||
|
throwErrorTolerant(
|
||
|
jsdict({}), Messages.StrictDuplicateProperty)
|
||
|
elif kind != PropertyKind.Data:
|
||
|
throwErrorTolerant(
|
||
|
jsdict({}), Messages.AccessorDataProperty)
|
||
|
else:
|
||
|
if kind == PropertyKind.Data:
|
||
|
throwErrorTolerant(
|
||
|
jsdict({}), Messages.AccessorDataProperty)
|
||
|
elif map[key] & kind:
|
||
|
throwErrorTolerant(jsdict({}), Messages.AccessorGetSet)
|
||
|
map[key] |= kind
|
||
|
else:
|
||
|
map[key] = kind
|
||
|
properties.append(property)
|
||
|
if not match("}"):
|
||
|
expect(",")
|
||
|
expect("}")
|
||
|
return delegate.createObjectExpression(properties)
|
||
|
|
||
|
|
||
|
def parseGroupExpression():
|
||
|
expr = None
|
||
|
expect("(")
|
||
|
expr = parseExpression()
|
||
|
expect(")")
|
||
|
return expr
|
||
|
|
||
|
|
||
|
def parsePrimaryExpression():
|
||
|
type = None
|
||
|
token = None
|
||
|
expr = None
|
||
|
if match("("):
|
||
|
return parseGroupExpression()
|
||
|
type = lookahead.type
|
||
|
delegate.markStart()
|
||
|
if type == Token.Identifier:
|
||
|
expr = delegate.createIdentifier(lex().value)
|
||
|
elif (type == Token.StringLiteral) or (type == Token.NumericLiteral):
|
||
|
if strict and lookahead.octal:
|
||
|
throwErrorTolerant(lookahead, Messages.StrictOctalLiteral)
|
||
|
expr = delegate.createLiteral(lex())
|
||
|
elif type == Token.Keyword:
|
||
|
if matchKeyword("this"):
|
||
|
lex()
|
||
|
expr = delegate.createThisExpression()
|
||
|
elif matchKeyword("function"):
|
||
|
expr = parseFunctionExpression()
|
||
|
elif type == Token.BooleanLiteral:
|
||
|
token = lex()
|
||
|
token.value = token.value == "true"
|
||
|
expr = delegate.createLiteral(token)
|
||
|
elif type == Token.NullLiteral:
|
||
|
token = lex()
|
||
|
token.value = None
|
||
|
expr = delegate.createLiteral(token)
|
||
|
elif match("["):
|
||
|
expr = parseArrayInitialiser()
|
||
|
elif match("{"):
|
||
|
expr = parseObjectInitialiser()
|
||
|
elif match("/") or match("/="):
|
||
|
expr = delegate.createLiteral(scanRegExp())
|
||
|
if expr:
|
||
|
return delegate.markEnd(expr)
|
||
|
throwUnexpected(lex())
|
||
|
|
||
|
|
||
|
def parseArguments():
|
||
|
args = []
|
||
|
expect("(")
|
||
|
if not match(")"):
|
||
|
while index < length:
|
||
|
args.append(parseAssignmentExpression())
|
||
|
if match(")"):
|
||
|
break
|
||
|
expect(",")
|
||
|
expect(")")
|
||
|
return args
|
||
|
|
||
|
|
||
|
def parseNonComputedProperty():
|
||
|
token = None
|
||
|
delegate.markStart()
|
||
|
token = lex()
|
||
|
if not isIdentifierName(token):
|
||
|
throwUnexpected(token)
|
||
|
return delegate.markEnd(delegate.createIdentifier(token.value))
|
||
|
|
||
|
|
||
|
def parseNonComputedMember():
|
||
|
expect(".")
|
||
|
return parseNonComputedProperty()
|
||
|
|
||
|
|
||
|
def parseComputedMember():
|
||
|
expr = None
|
||
|
expect("[")
|
||
|
expr = parseExpression()
|
||
|
expect("]")
|
||
|
return expr
|
||
|
|
||
|
|
||
|
def parseNewExpression():
|
||
|
callee = None
|
||
|
args = None
|
||
|
delegate.markStart()
|
||
|
expectKeyword("new")
|
||
|
callee = parseLeftHandSideExpression()
|
||
|
args = (parseArguments() if match("(") else [])
|
||
|
return delegate.markEnd(delegate.createNewExpression(callee, args))
|
||
|
|
||
|
|
||
|
def parseLeftHandSideExpressionAllowCall():
|
||
|
marker = None
|
||
|
expr = None
|
||
|
args = None
|
||
|
property = None
|
||
|
marker = createLocationMarker()
|
||
|
expr = (parseNewExpression()
|
||
|
if matchKeyword("new") else parsePrimaryExpression())
|
||
|
while (match(".") or match("[")) or match("("):
|
||
|
if match("("):
|
||
|
args = parseArguments()
|
||
|
expr = delegate.createCallExpression(expr, args)
|
||
|
elif match("["):
|
||
|
property = parseComputedMember()
|
||
|
expr = delegate.createMemberExpression("[", expr, property)
|
||
|
else:
|
||
|
property = parseNonComputedMember()
|
||
|
expr = delegate.createMemberExpression(".", expr, property)
|
||
|
if marker:
|
||
|
marker.end()
|
||
|
marker.apply(expr)
|
||
|
return expr
|
||
|
|
||
|
|
||
|
def parseLeftHandSideExpression():
|
||
|
marker = None
|
||
|
expr = None
|
||
|
property = None
|
||
|
marker = createLocationMarker()
|
||
|
expr = (parseNewExpression()
|
||
|
if matchKeyword("new") else parsePrimaryExpression())
|
||
|
while match(".") or match("["):
|
||
|
if match("["):
|
||
|
property = parseComputedMember()
|
||
|
expr = delegate.createMemberExpression("[", expr, property)
|
||
|
else:
|
||
|
property = parseNonComputedMember()
|
||
|
expr = delegate.createMemberExpression(".", expr, property)
|
||
|
if marker:
|
||
|
marker.end()
|
||
|
marker.apply(expr)
|
||
|
return expr
|
||
|
|
||
|
|
||
|
def parsePostfixExpression():
|
||
|
expr = None
|
||
|
token = None
|
||
|
delegate.markStart()
|
||
|
expr = parseLeftHandSideExpressionAllowCall()
|
||
|
if lookahead.type == Token.Punctuator:
|
||
|
if (match("++") or match("--")) and (not peekLineTerminator()):
|
||
|
if (strict and
|
||
|
(expr.type == Syntax.Identifier)) and isRestrictedWord(
|
||
|
expr.name):
|
||
|
throwErrorTolerant(jsdict({}), Messages.StrictLHSPostfix)
|
||
|
if not isLeftHandSide(expr):
|
||
|
throwError(jsdict({}), Messages.InvalidLHSInAssignment)
|
||
|
token = lex()
|
||
|
expr = delegate.createPostfixExpression(token.value, expr)
|
||
|
return delegate.markEndIf(expr)
|
||
|
|
||
|
|
||
|
def parseUnaryExpression():
|
||
|
token = None
|
||
|
expr = None
|
||
|
delegate.markStart()
|
||
|
if (lookahead.type != Token.Punctuator) and (lookahead.type !=
|
||
|
Token.Keyword):
|
||
|
expr = parsePostfixExpression()
|
||
|
elif match("++") or match("--"):
|
||
|
token = lex()
|
||
|
expr = parseUnaryExpression()
|
||
|
if (strict and
|
||
|
(expr.type == Syntax.Identifier)) and isRestrictedWord(expr.name):
|
||
|
throwErrorTolerant(jsdict({}), Messages.StrictLHSPrefix)
|
||
|
if not isLeftHandSide(expr):
|
||
|
throwError(jsdict({}), Messages.InvalidLHSInAssignment)
|
||
|
expr = delegate.createUnaryExpression(token.value, expr)
|
||
|
elif ((match("+") or match("-")) or match("~")) or match("!"):
|
||
|
token = lex()
|
||
|
expr = parseUnaryExpression()
|
||
|
expr = delegate.createUnaryExpression(token.value, expr)
|
||
|
elif (matchKeyword("delete")
|
||
|
or matchKeyword("void")) or matchKeyword("typeof"):
|
||
|
token = lex()
|
||
|
expr = parseUnaryExpression()
|
||
|
expr = delegate.createUnaryExpression(token.value, expr)
|
||
|
if (strict and (expr.operator == "delete")) and (
|
||
|
expr.argument.type == Syntax.Identifier):
|
||
|
throwErrorTolerant(jsdict({}), Messages.StrictDelete)
|
||
|
else:
|
||
|
expr = parsePostfixExpression()
|
||
|
return delegate.markEndIf(expr)
|
||
|
|
||
|
|
||
|
def binaryPrecedence(token=None, allowIn=None):
|
||
|
prec = 0
|
||
|
if (token.type != Token.Punctuator) and (token.type != Token.Keyword):
|
||
|
return 0
|
||
|
while 1:
|
||
|
if token.value == "||":
|
||
|
prec = 1
|
||
|
break
|
||
|
elif token.value == "&&":
|
||
|
prec = 2
|
||
|
break
|
||
|
elif token.value == "|":
|
||
|
prec = 3
|
||
|
break
|
||
|
elif token.value == "^":
|
||
|
prec = 4
|
||
|
break
|
||
|
elif token.value == "&":
|
||
|
prec = 5
|
||
|
break
|
||
|
elif (token.value == "!==") or ((token.value == "===") or
|
||
|
((token.value == "!=") or
|
||
|
(token.value == "=="))):
|
||
|
prec = 6
|
||
|
break
|
||
|
elif (token.value == "instanceof") or ((token.value == ">=") or
|
||
|
((token.value == "<=") or
|
||
|
((token.value == ">") or
|
||
|
(token.value == "<")))):
|
||
|
prec = 7
|
||
|
break
|
||
|
elif token.value == "in":
|
||
|
prec = (7 if allowIn else 0)
|
||
|
break
|
||
|
elif (token.value == ">>>") or ((token.value == ">>") or
|
||
|
(token.value == "<<")):
|
||
|
prec = 8
|
||
|
break
|
||
|
elif (token.value == "-") or (token.value == "+"):
|
||
|
prec = 9
|
||
|
break
|
||
|
elif (token.value == "%") or ((token.value == "/") or
|
||
|
(token.value == "*")):
|
||
|
prec = 11
|
||
|
break
|
||
|
else:
|
||
|
break
|
||
|
break
|
||
|
return prec
|
||
|
|
||
|
|
||
|
def parseBinaryExpression():
|
||
|
marker = None
|
||
|
markers = None
|
||
|
expr = None
|
||
|
token = None
|
||
|
prec = None
|
||
|
previousAllowIn = None
|
||
|
stack = None
|
||
|
right = None
|
||
|
operator = None
|
||
|
left = None
|
||
|
i = None
|
||
|
previousAllowIn = state.allowIn
|
||
|
state.allowIn = True
|
||
|
marker = createLocationMarker()
|
||
|
left = parseUnaryExpression()
|
||
|
token = lookahead
|
||
|
prec = binaryPrecedence(token, previousAllowIn)
|
||
|
if prec == 0:
|
||
|
return left
|
||
|
token.prec = prec
|
||
|
lex()
|
||
|
markers = [marker, createLocationMarker()]
|
||
|
right = parseUnaryExpression()
|
||
|
stack = [left, token, right]
|
||
|
prec = binaryPrecedence(lookahead, previousAllowIn)
|
||
|
while prec > 0:
|
||
|
while (len(stack) > 2) and (prec <= stack[len(stack) - 2].prec):
|
||
|
right = stack.pop()
|
||
|
operator = stack.pop().value
|
||
|
left = stack.pop()
|
||
|
expr = delegate.createBinaryExpression(operator, left, right)
|
||
|
markers.pop()
|
||
|
marker = markers.pop()
|
||
|
if marker:
|
||
|
marker.end()
|
||
|
marker.apply(expr)
|
||
|
stack.append(expr)
|
||
|
markers.append(marker)
|
||
|
token = lex()
|
||
|
token.prec = prec
|
||
|
stack.append(token)
|
||
|
markers.append(createLocationMarker())
|
||
|
expr = parseUnaryExpression()
|
||
|
stack.append(expr)
|
||
|
prec = binaryPrecedence(lookahead, previousAllowIn)
|
||
|
state.allowIn = previousAllowIn
|
||
|
i = len(stack) - 1
|
||
|
expr = stack[i]
|
||
|
markers.pop()
|
||
|
while i > 1:
|
||
|
expr = delegate.createBinaryExpression(stack[i - 1].value,
|
||
|
stack[i - 2], expr)
|
||
|
i -= 2
|
||
|
marker = markers.pop()
|
||
|
if marker:
|
||
|
marker.end()
|
||
|
marker.apply(expr)
|
||
|
return expr
|
||
|
|
||
|
|
||
|
def parseConditionalExpression():
|
||
|
expr = None
|
||
|
previousAllowIn = None
|
||
|
consequent = None
|
||
|
alternate = None
|
||
|
delegate.markStart()
|
||
|
expr = parseBinaryExpression()
|
||
|
if match("?"):
|
||
|
lex()
|
||
|
previousAllowIn = state.allowIn
|
||
|
state.allowIn = True
|
||
|
consequent = parseAssignmentExpression()
|
||
|
state.allowIn = previousAllowIn
|
||
|
expect(":")
|
||
|
alternate = parseAssignmentExpression()
|
||
|
expr = delegate.markEnd(
|
||
|
delegate.createConditionalExpression(expr, consequent, alternate))
|
||
|
else:
|
||
|
delegate.markEnd(jsdict({}))
|
||
|
return expr
|
||
|
|
||
|
|
||
|
def parseAssignmentExpression():
|
||
|
token = None
|
||
|
left = None
|
||
|
right = None
|
||
|
node = None
|
||
|
token = lookahead
|
||
|
delegate.markStart()
|
||
|
left = parseConditionalExpression()
|
||
|
node = left
|
||
|
if matchAssign():
|
||
|
if not isLeftHandSide(left):
|
||
|
throwError(jsdict({}), Messages.InvalidLHSInAssignment)
|
||
|
if (strict and
|
||
|
(left.type == Syntax.Identifier)) and isRestrictedWord(left.name):
|
||
|
throwErrorTolerant(token, Messages.StrictLHSAssignment)
|
||
|
token = lex()
|
||
|
right = parseAssignmentExpression()
|
||
|
node = delegate.createAssignmentExpression(token.value, left, right)
|
||
|
return delegate.markEndIf(node)
|
||
|
|
||
|
|
||
|
def parseExpression():
|
||
|
expr = None
|
||
|
delegate.markStart()
|
||
|
expr = parseAssignmentExpression()
|
||
|
if match(","):
|
||
|
expr = delegate.createSequenceExpression([expr])
|
||
|
while index < length:
|
||
|
if not match(","):
|
||
|
break
|
||
|
lex()
|
||
|
expr.expressions.append(parseAssignmentExpression())
|
||
|
return delegate.markEndIf(expr)
|
||
|
|
||
|
|
||
|
def parseStatementList():
|
||
|
list__py__ = []
|
||
|
statement = None
|
||
|
while index < length:
|
||
|
if match("}"):
|
||
|
break
|
||
|
statement = parseSourceElement()
|
||
|
if ('undefined' if not 'statement' in locals() else
|
||
|
typeof(statement)) == "undefined":
|
||
|
break
|
||
|
list__py__.append(statement)
|
||
|
return list__py__
|
||
|
|
||
|
|
||
|
def parseBlock():
|
||
|
block = None
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
expect("{")
|
||
|
block = parseStatementList()
|
||
|
expect("}")
|
||
|
return delegate.markEnd(delegate.createBlockStatement(block))
|
||
|
|
||
|
|
||
|
def parseVariableIdentifier():
|
||
|
token = None
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
token = lex()
|
||
|
if token.type != Token.Identifier:
|
||
|
throwUnexpected(token)
|
||
|
return delegate.markEnd(delegate.createIdentifier(token.value))
|
||
|
|
||
|
|
||
|
def parseVariableDeclaration(kind=None):
|
||
|
init = None
|
||
|
id = None
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
id = parseVariableIdentifier()
|
||
|
if strict and isRestrictedWord(id.name):
|
||
|
throwErrorTolerant(jsdict({}), Messages.StrictVarName)
|
||
|
if kind == "const":
|
||
|
expect("=")
|
||
|
init = parseAssignmentExpression()
|
||
|
elif match("="):
|
||
|
lex()
|
||
|
init = parseAssignmentExpression()
|
||
|
return delegate.markEnd(delegate.createVariableDeclarator(id, init))
|
||
|
|
||
|
|
||
|
def parseVariableDeclarationList(kind=None):
|
||
|
list__py__ = []
|
||
|
while 1:
|
||
|
list__py__.append(parseVariableDeclaration(kind))
|
||
|
if not match(","):
|
||
|
break
|
||
|
lex()
|
||
|
if not (index < length):
|
||
|
break
|
||
|
return list__py__
|
||
|
|
||
|
|
||
|
def parseVariableStatement():
|
||
|
declarations = None
|
||
|
expectKeyword("var")
|
||
|
declarations = parseVariableDeclarationList()
|
||
|
consumeSemicolon()
|
||
|
return delegate.createVariableDeclaration(declarations, "var")
|
||
|
|
||
|
|
||
|
def parseConstLetDeclaration(kind=None):
|
||
|
declarations = None
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
expectKeyword(kind)
|
||
|
declarations = parseVariableDeclarationList(kind)
|
||
|
consumeSemicolon()
|
||
|
return delegate.markEnd(
|
||
|
delegate.createVariableDeclaration(declarations, kind))
|
||
|
|
||
|
|
||
|
def parseEmptyStatement():
|
||
|
expect(";")
|
||
|
return delegate.createEmptyStatement()
|
||
|
|
||
|
|
||
|
def parseExpressionStatement():
|
||
|
expr = parseExpression()
|
||
|
consumeSemicolon()
|
||
|
return delegate.createExpressionStatement(expr)
|
||
|
|
||
|
|
||
|
def parseIfStatement():
|
||
|
test = None
|
||
|
consequent = None
|
||
|
alternate = None
|
||
|
expectKeyword("if")
|
||
|
expect("(")
|
||
|
test = parseExpression()
|
||
|
expect(")")
|
||
|
consequent = parseStatement()
|
||
|
if matchKeyword("else"):
|
||
|
lex()
|
||
|
alternate = parseStatement()
|
||
|
else:
|
||
|
alternate = None
|
||
|
return delegate.createIfStatement(test, consequent, alternate)
|
||
|
|
||
|
|
||
|
def parseDoWhileStatement():
|
||
|
body = None
|
||
|
test = None
|
||
|
oldInIteration = None
|
||
|
expectKeyword("do")
|
||
|
oldInIteration = state.inIteration
|
||
|
state.inIteration = True
|
||
|
body = parseStatement()
|
||
|
state.inIteration = oldInIteration
|
||
|
expectKeyword("while")
|
||
|
expect("(")
|
||
|
test = parseExpression()
|
||
|
expect(")")
|
||
|
if match(";"):
|
||
|
lex()
|
||
|
return delegate.createDoWhileStatement(body, test)
|
||
|
|
||
|
|
||
|
def parseWhileStatement():
|
||
|
test = None
|
||
|
body = None
|
||
|
oldInIteration = None
|
||
|
expectKeyword("while")
|
||
|
expect("(")
|
||
|
test = parseExpression()
|
||
|
expect(")")
|
||
|
oldInIteration = state.inIteration
|
||
|
state.inIteration = True
|
||
|
body = parseStatement()
|
||
|
state.inIteration = oldInIteration
|
||
|
return delegate.createWhileStatement(test, body)
|
||
|
|
||
|
|
||
|
def parseForVariableDeclaration():
|
||
|
token = None
|
||
|
declarations = None
|
||
|
delegate.markStart()
|
||
|
token = lex()
|
||
|
declarations = parseVariableDeclarationList()
|
||
|
return delegate.markEnd(
|
||
|
delegate.createVariableDeclaration(declarations, token.value))
|
||
|
|
||
|
|
||
|
def parseForStatement():
|
||
|
init = None
|
||
|
test = None
|
||
|
update = None
|
||
|
left = None
|
||
|
right = None
|
||
|
body = None
|
||
|
oldInIteration = None
|
||
|
update = None
|
||
|
test = update
|
||
|
init = test
|
||
|
expectKeyword("for")
|
||
|
expect("(")
|
||
|
if match(";"):
|
||
|
lex()
|
||
|
else:
|
||
|
if matchKeyword("var") or matchKeyword("let"):
|
||
|
state.allowIn = False
|
||
|
init = parseForVariableDeclaration()
|
||
|
state.allowIn = True
|
||
|
if (len(init.declarations) == 1) and matchKeyword("in"):
|
||
|
lex()
|
||
|
left = init
|
||
|
right = parseExpression()
|
||
|
init = None
|
||
|
else:
|
||
|
state.allowIn = False
|
||
|
init = parseExpression()
|
||
|
state.allowIn = True
|
||
|
if matchKeyword("in"):
|
||
|
if not isLeftHandSide(init):
|
||
|
throwError(jsdict({}), Messages.InvalidLHSInForIn)
|
||
|
lex()
|
||
|
left = init
|
||
|
right = parseExpression()
|
||
|
init = None
|
||
|
if ('undefined'
|
||
|
if not 'left' in locals() else typeof(left)) == "undefined":
|
||
|
expect(";")
|
||
|
if ('undefined'
|
||
|
if not 'left' in locals() else typeof(left)) == "undefined":
|
||
|
if not match(";"):
|
||
|
test = parseExpression()
|
||
|
expect(";")
|
||
|
if not match(")"):
|
||
|
update = parseExpression()
|
||
|
expect(")")
|
||
|
oldInIteration = state.inIteration
|
||
|
state.inIteration = True
|
||
|
body = parseStatement()
|
||
|
state.inIteration = oldInIteration
|
||
|
return (delegate.createForStatement(init, test, update, body) if (
|
||
|
'undefined' if not 'left' in locals() else typeof(left)) == "undefined"
|
||
|
else delegate.createForInStatement(left, right, body))
|
||
|
|
||
|
|
||
|
def parseContinueStatement():
|
||
|
label = None
|
||
|
key = None
|
||
|
expectKeyword("continue")
|
||
|
if (ord(source[index]) if index < len(source) else None) == 59:
|
||
|
lex()
|
||
|
if not state.inIteration:
|
||
|
throwError(jsdict({}), Messages.IllegalContinue)
|
||
|
return delegate.createContinueStatement(None)
|
||
|
if peekLineTerminator():
|
||
|
if not state.inIteration:
|
||
|
throwError(jsdict({}), Messages.IllegalContinue)
|
||
|
return delegate.createContinueStatement(None)
|
||
|
if lookahead.type == Token.Identifier:
|
||
|
label = parseVariableIdentifier()
|
||
|
key = "$" + label.name
|
||
|
if not (key in state.labelSet):
|
||
|
throwError(jsdict({}), Messages.UnknownLabel, label.name)
|
||
|
consumeSemicolon()
|
||
|
if (label == None) and (not state.inIteration):
|
||
|
throwError(jsdict({}), Messages.IllegalContinue)
|
||
|
return delegate.createContinueStatement(label)
|
||
|
|
||
|
|
||
|
def parseBreakStatement():
|
||
|
label = None
|
||
|
key = None
|
||
|
expectKeyword("break")
|
||
|
if (ord(source[index]) if index < len(source) else None) == 59:
|
||
|
lex()
|
||
|
if not (state.inIteration or state.inSwitch):
|
||
|
throwError(jsdict({}), Messages.IllegalBreak)
|
||
|
return delegate.createBreakStatement(None)
|
||
|
if peekLineTerminator():
|
||
|
if not (state.inIteration or state.inSwitch):
|
||
|
throwError(jsdict({}), Messages.IllegalBreak)
|
||
|
return delegate.createBreakStatement(None)
|
||
|
if lookahead.type == Token.Identifier:
|
||
|
label = parseVariableIdentifier()
|
||
|
key = "$" + label.name
|
||
|
if not (key in state.labelSet):
|
||
|
throwError(jsdict({}), Messages.UnknownLabel, label.name)
|
||
|
consumeSemicolon()
|
||
|
if (label == None) and (not (state.inIteration or state.inSwitch)):
|
||
|
throwError(jsdict({}), Messages.IllegalBreak)
|
||
|
return delegate.createBreakStatement(label)
|
||
|
|
||
|
|
||
|
def parseReturnStatement():
|
||
|
argument = None
|
||
|
expectKeyword("return")
|
||
|
if not state.inFunctionBody:
|
||
|
throwErrorTolerant(jsdict({}), Messages.IllegalReturn)
|
||
|
if (ord(source[index]) if index < len(source) else None) == 32:
|
||
|
if isIdentifierStart((ord(source[index + 1]) if
|
||
|
(index + 1) < len(source) else None)):
|
||
|
argument = parseExpression()
|
||
|
consumeSemicolon()
|
||
|
return delegate.createReturnStatement(argument)
|
||
|
if peekLineTerminator():
|
||
|
return delegate.createReturnStatement(None)
|
||
|
if not match(";"):
|
||
|
if (not match("}")) and (lookahead.type != Token.EOF):
|
||
|
argument = parseExpression()
|
||
|
consumeSemicolon()
|
||
|
return delegate.createReturnStatement(argument)
|
||
|
|
||
|
|
||
|
def parseWithStatement():
|
||
|
object = None
|
||
|
body = None
|
||
|
if strict:
|
||
|
throwErrorTolerant(jsdict({}), Messages.StrictModeWith)
|
||
|
expectKeyword("with")
|
||
|
expect("(")
|
||
|
object = parseExpression()
|
||
|
expect(")")
|
||
|
body = parseStatement()
|
||
|
return delegate.createWithStatement(object, body)
|
||
|
|
||
|
|
||
|
def parseSwitchCase():
|
||
|
test = None
|
||
|
consequent = []
|
||
|
statement = None
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
if matchKeyword("default"):
|
||
|
lex()
|
||
|
test = None
|
||
|
else:
|
||
|
expectKeyword("case")
|
||
|
test = parseExpression()
|
||
|
expect(":")
|
||
|
while index < length:
|
||
|
if (match("}") or matchKeyword("default")) or matchKeyword("case"):
|
||
|
break
|
||
|
statement = parseStatement()
|
||
|
consequent.append(statement)
|
||
|
return delegate.markEnd(delegate.createSwitchCase(test, consequent))
|
||
|
|
||
|
|
||
|
def parseSwitchStatement():
|
||
|
discriminant = None
|
||
|
cases = None
|
||
|
clause = None
|
||
|
oldInSwitch = None
|
||
|
defaultFound = None
|
||
|
expectKeyword("switch")
|
||
|
expect("(")
|
||
|
discriminant = parseExpression()
|
||
|
expect(")")
|
||
|
expect("{")
|
||
|
if match("}"):
|
||
|
lex()
|
||
|
return delegate.createSwitchStatement(discriminant)
|
||
|
cases = []
|
||
|
oldInSwitch = state.inSwitch
|
||
|
state.inSwitch = True
|
||
|
defaultFound = False
|
||
|
while index < length:
|
||
|
if match("}"):
|
||
|
break
|
||
|
clause = parseSwitchCase()
|
||
|
if clause.test == None:
|
||
|
if defaultFound:
|
||
|
throwError(jsdict({}), Messages.MultipleDefaultsInSwitch)
|
||
|
defaultFound = True
|
||
|
cases.append(clause)
|
||
|
state.inSwitch = oldInSwitch
|
||
|
expect("}")
|
||
|
return delegate.createSwitchStatement(discriminant, cases)
|
||
|
|
||
|
|
||
|
def parseThrowStatement():
|
||
|
argument = None
|
||
|
expectKeyword("throw")
|
||
|
if peekLineTerminator():
|
||
|
throwError(jsdict({}), Messages.NewlineAfterThrow)
|
||
|
argument = parseExpression()
|
||
|
consumeSemicolon()
|
||
|
return delegate.createThrowStatement(argument)
|
||
|
|
||
|
|
||
|
def parseCatchClause():
|
||
|
param = None
|
||
|
body = None
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
expectKeyword("catch")
|
||
|
expect("(")
|
||
|
if match(")"):
|
||
|
throwUnexpected(lookahead)
|
||
|
param = parseVariableIdentifier()
|
||
|
if strict and isRestrictedWord(param.name):
|
||
|
throwErrorTolerant(jsdict({}), Messages.StrictCatchVariable)
|
||
|
expect(")")
|
||
|
body = parseBlock()
|
||
|
return delegate.markEnd(delegate.createCatchClause(param, body))
|
||
|
|
||
|
|
||
|
def parseTryStatement():
|
||
|
block = None
|
||
|
handlers = []
|
||
|
finalizer = None
|
||
|
expectKeyword("try")
|
||
|
block = parseBlock()
|
||
|
if matchKeyword("catch"):
|
||
|
handlers.append(parseCatchClause())
|
||
|
if matchKeyword("finally"):
|
||
|
lex()
|
||
|
finalizer = parseBlock()
|
||
|
if (len(handlers) == 0) and (not finalizer):
|
||
|
throwError(jsdict({}), Messages.NoCatchOrFinally)
|
||
|
return delegate.createTryStatement(block, [], handlers, finalizer)
|
||
|
|
||
|
|
||
|
def parseDebuggerStatement():
|
||
|
expectKeyword("debugger")
|
||
|
consumeSemicolon()
|
||
|
return delegate.createDebuggerStatement()
|
||
|
|
||
|
|
||
|
def parseStatement():
|
||
|
type = lookahead.type
|
||
|
expr = None
|
||
|
labeledBody = None
|
||
|
key = None
|
||
|
if type == Token.EOF:
|
||
|
throwUnexpected(lookahead)
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
if type == Token.Punctuator:
|
||
|
while 1:
|
||
|
if lookahead.value == ";":
|
||
|
return delegate.markEnd(parseEmptyStatement())
|
||
|
elif lookahead.value == "{":
|
||
|
return delegate.markEnd(parseBlock())
|
||
|
elif lookahead.value == "(":
|
||
|
return delegate.markEnd(parseExpressionStatement())
|
||
|
else:
|
||
|
break
|
||
|
break
|
||
|
if type == Token.Keyword:
|
||
|
while 1:
|
||
|
if lookahead.value == "break":
|
||
|
return delegate.markEnd(parseBreakStatement())
|
||
|
elif lookahead.value == "continue":
|
||
|
return delegate.markEnd(parseContinueStatement())
|
||
|
elif lookahead.value == "debugger":
|
||
|
return delegate.markEnd(parseDebuggerStatement())
|
||
|
elif lookahead.value == "do":
|
||
|
return delegate.markEnd(parseDoWhileStatement())
|
||
|
elif lookahead.value == "for":
|
||
|
return delegate.markEnd(parseForStatement())
|
||
|
elif lookahead.value == "function":
|
||
|
return delegate.markEnd(parseFunctionDeclaration())
|
||
|
elif lookahead.value == "if":
|
||
|
return delegate.markEnd(parseIfStatement())
|
||
|
elif lookahead.value == "return":
|
||
|
return delegate.markEnd(parseReturnStatement())
|
||
|
elif lookahead.value == "switch":
|
||
|
return delegate.markEnd(parseSwitchStatement())
|
||
|
elif lookahead.value == "throw":
|
||
|
return delegate.markEnd(parseThrowStatement())
|
||
|
elif lookahead.value == "try":
|
||
|
return delegate.markEnd(parseTryStatement())
|
||
|
elif lookahead.value == "var":
|
||
|
return delegate.markEnd(parseVariableStatement())
|
||
|
elif lookahead.value == "while":
|
||
|
return delegate.markEnd(parseWhileStatement())
|
||
|
elif lookahead.value == "with":
|
||
|
return delegate.markEnd(parseWithStatement())
|
||
|
else:
|
||
|
break
|
||
|
break
|
||
|
expr = parseExpression()
|
||
|
if (expr.type == Syntax.Identifier) and match(":"):
|
||
|
lex()
|
||
|
key = "$" + expr.name
|
||
|
if key in state.labelSet:
|
||
|
throwError(jsdict({}), Messages.Redeclaration, "Label", expr.name)
|
||
|
state.labelSet[key] = True
|
||
|
labeledBody = parseStatement()
|
||
|
del state.labelSet[key]
|
||
|
return delegate.markEnd(
|
||
|
delegate.createLabeledStatement(expr, labeledBody))
|
||
|
consumeSemicolon()
|
||
|
return delegate.markEnd(delegate.createExpressionStatement(expr))
|
||
|
|
||
|
|
||
|
def parseFunctionSourceElements():
|
||
|
global strict
|
||
|
sourceElement = None
|
||
|
sourceElements = []
|
||
|
token = None
|
||
|
directive = None
|
||
|
firstRestricted = None
|
||
|
oldLabelSet = None
|
||
|
oldInIteration = None
|
||
|
oldInSwitch = None
|
||
|
oldInFunctionBody = None
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
expect("{")
|
||
|
while index < length:
|
||
|
if lookahead.type != Token.StringLiteral:
|
||
|
break
|
||
|
token = lookahead
|
||
|
sourceElement = parseSourceElement()
|
||
|
sourceElements.append(sourceElement)
|
||
|
if sourceElement.expression.type != Syntax.Literal:
|
||
|
break
|
||
|
directive = source[(token.range[0] + 1):(token.range[1] - 1)]
|
||
|
if directive == "use strict":
|
||
|
strict = True
|
||
|
if firstRestricted:
|
||
|
throwErrorTolerant(firstRestricted,
|
||
|
Messages.StrictOctalLiteral)
|
||
|
else:
|
||
|
if (not firstRestricted) and token.octal:
|
||
|
firstRestricted = token
|
||
|
oldLabelSet = state.labelSet
|
||
|
oldInIteration = state.inIteration
|
||
|
oldInSwitch = state.inSwitch
|
||
|
oldInFunctionBody = state.inFunctionBody
|
||
|
state.labelSet = jsdict({})
|
||
|
state.inIteration = False
|
||
|
state.inSwitch = False
|
||
|
state.inFunctionBody = True
|
||
|
while index < length:
|
||
|
if match("}"):
|
||
|
break
|
||
|
sourceElement = parseSourceElement()
|
||
|
if ('undefined' if not 'sourceElement' in locals() else
|
||
|
typeof(sourceElement)) == "undefined":
|
||
|
break
|
||
|
sourceElements.append(sourceElement)
|
||
|
expect("}")
|
||
|
state.labelSet = oldLabelSet
|
||
|
state.inIteration = oldInIteration
|
||
|
state.inSwitch = oldInSwitch
|
||
|
state.inFunctionBody = oldInFunctionBody
|
||
|
return delegate.markEnd(delegate.createBlockStatement(sourceElements))
|
||
|
|
||
|
|
||
|
def parseParams(firstRestricted=None):
|
||
|
param = None
|
||
|
params = []
|
||
|
token = None
|
||
|
stricted = None
|
||
|
paramSet = None
|
||
|
key = None
|
||
|
message = None
|
||
|
expect("(")
|
||
|
if not match(")"):
|
||
|
paramSet = jsdict({})
|
||
|
while index < length:
|
||
|
token = lookahead
|
||
|
param = parseVariableIdentifier()
|
||
|
key = "$" + token.value
|
||
|
if strict:
|
||
|
if isRestrictedWord(token.value):
|
||
|
stricted = token
|
||
|
message = Messages.StrictParamName
|
||
|
if key in paramSet:
|
||
|
stricted = token
|
||
|
message = Messages.StrictParamDupe
|
||
|
elif not firstRestricted:
|
||
|
if isRestrictedWord(token.value):
|
||
|
firstRestricted = token
|
||
|
message = Messages.StrictParamName
|
||
|
elif isStrictModeReservedWord(token.value):
|
||
|
firstRestricted = token
|
||
|
message = Messages.StrictReservedWord
|
||
|
elif key in paramSet:
|
||
|
firstRestricted = token
|
||
|
message = Messages.StrictParamDupe
|
||
|
params.append(param)
|
||
|
paramSet[key] = True
|
||
|
if match(")"):
|
||
|
break
|
||
|
expect(",")
|
||
|
expect(")")
|
||
|
return jsdict({
|
||
|
"params": params,
|
||
|
"stricted": stricted,
|
||
|
"firstRestricted": firstRestricted,
|
||
|
"message": message,
|
||
|
})
|
||
|
|
||
|
|
||
|
def parseFunctionDeclaration():
|
||
|
global strict
|
||
|
id = None
|
||
|
params = []
|
||
|
body = None
|
||
|
token = None
|
||
|
stricted = None
|
||
|
tmp = None
|
||
|
firstRestricted = None
|
||
|
message = None
|
||
|
previousStrict = None
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
expectKeyword("function")
|
||
|
token = lookahead
|
||
|
id = parseVariableIdentifier()
|
||
|
if strict:
|
||
|
if isRestrictedWord(token.value):
|
||
|
throwErrorTolerant(token, Messages.StrictFunctionName)
|
||
|
else:
|
||
|
if isRestrictedWord(token.value):
|
||
|
firstRestricted = token
|
||
|
message = Messages.StrictFunctionName
|
||
|
elif isStrictModeReservedWord(token.value):
|
||
|
firstRestricted = token
|
||
|
message = Messages.StrictReservedWord
|
||
|
tmp = parseParams(firstRestricted)
|
||
|
params = tmp.params
|
||
|
stricted = tmp.stricted
|
||
|
firstRestricted = tmp.firstRestricted
|
||
|
if tmp.message:
|
||
|
message = tmp.message
|
||
|
previousStrict = strict
|
||
|
body = parseFunctionSourceElements()
|
||
|
if strict and firstRestricted:
|
||
|
throwError(firstRestricted, message)
|
||
|
if strict and stricted:
|
||
|
throwErrorTolerant(stricted, message)
|
||
|
strict = previousStrict
|
||
|
return delegate.markEnd(
|
||
|
delegate.createFunctionDeclaration(id, params, [], body))
|
||
|
|
||
|
|
||
|
def parseFunctionExpression():
|
||
|
global strict
|
||
|
token = None
|
||
|
id = None
|
||
|
stricted = None
|
||
|
firstRestricted = None
|
||
|
message = None
|
||
|
tmp = None
|
||
|
params = []
|
||
|
body = None
|
||
|
previousStrict = None
|
||
|
delegate.markStart()
|
||
|
expectKeyword("function")
|
||
|
if not match("("):
|
||
|
token = lookahead
|
||
|
id = parseVariableIdentifier()
|
||
|
if strict:
|
||
|
if isRestrictedWord(token.value):
|
||
|
throwErrorTolerant(token, Messages.StrictFunctionName)
|
||
|
else:
|
||
|
if isRestrictedWord(token.value):
|
||
|
firstRestricted = token
|
||
|
message = Messages.StrictFunctionName
|
||
|
elif isStrictModeReservedWord(token.value):
|
||
|
firstRestricted = token
|
||
|
message = Messages.StrictReservedWord
|
||
|
tmp = parseParams(firstRestricted)
|
||
|
params = tmp.params
|
||
|
stricted = tmp.stricted
|
||
|
firstRestricted = tmp.firstRestricted
|
||
|
if tmp.message:
|
||
|
message = tmp.message
|
||
|
previousStrict = strict
|
||
|
body = parseFunctionSourceElements()
|
||
|
if strict and firstRestricted:
|
||
|
throwError(firstRestricted, message)
|
||
|
if strict and stricted:
|
||
|
throwErrorTolerant(stricted, message)
|
||
|
strict = previousStrict
|
||
|
return delegate.markEnd(
|
||
|
delegate.createFunctionExpression(id, params, [], body))
|
||
|
|
||
|
|
||
|
def parseSourceElement():
|
||
|
if lookahead.type == Token.Keyword:
|
||
|
while 1:
|
||
|
if (lookahead.value == "let") or (lookahead.value == "const"):
|
||
|
return parseConstLetDeclaration(lookahead.value)
|
||
|
elif lookahead.value == "function":
|
||
|
return parseFunctionDeclaration()
|
||
|
else:
|
||
|
return parseStatement()
|
||
|
break
|
||
|
if lookahead.type != Token.EOF:
|
||
|
return parseStatement()
|
||
|
|
||
|
|
||
|
def parseSourceElements():
|
||
|
global strict
|
||
|
sourceElement = None
|
||
|
sourceElements = []
|
||
|
token = None
|
||
|
directive = None
|
||
|
firstRestricted = None
|
||
|
while index < length:
|
||
|
token = lookahead
|
||
|
if token.type != Token.StringLiteral:
|
||
|
break
|
||
|
sourceElement = parseSourceElement()
|
||
|
sourceElements.append(sourceElement)
|
||
|
if sourceElement.expression.type != Syntax.Literal:
|
||
|
break
|
||
|
directive = source[(token.range[0] + 1):(token.range[1] - 1)]
|
||
|
if directive == "use strict":
|
||
|
strict = True
|
||
|
if firstRestricted:
|
||
|
throwErrorTolerant(firstRestricted,
|
||
|
Messages.StrictOctalLiteral)
|
||
|
else:
|
||
|
if (not firstRestricted) and token.octal:
|
||
|
firstRestricted = token
|
||
|
while index < length:
|
||
|
sourceElement = parseSourceElement()
|
||
|
if ('undefined' if not 'sourceElement' in locals() else
|
||
|
typeof(sourceElement)) == "undefined":
|
||
|
break
|
||
|
sourceElements.append(sourceElement)
|
||
|
return sourceElements
|
||
|
|
||
|
|
||
|
def parseProgram():
|
||
|
global strict
|
||
|
body = None
|
||
|
skipComment()
|
||
|
delegate.markStart()
|
||
|
strict = False
|
||
|
peek()
|
||
|
body = parseSourceElements()
|
||
|
return delegate.markEnd(delegate.createProgram(body))
|
||
|
|
||
|
|
||
|
def collectToken():
|
||
|
start = None
|
||
|
loc = None
|
||
|
token = None
|
||
|
range = None
|
||
|
value = None
|
||
|
skipComment()
|
||
|
start = index
|
||
|
loc = jsdict({
|
||
|
"start":
|
||
|
jsdict({
|
||
|
"line": lineNumber,
|
||
|
"column": index - lineStart,
|
||
|
}),
|
||
|
})
|
||
|
token = extra.advance()
|
||
|
loc.end = jsdict({
|
||
|
"line": lineNumber,
|
||
|
"column": index - lineStart,
|
||
|
})
|
||
|
if token.type != Token.EOF:
|
||
|
range = [token.range[0], token.range[1]]
|
||
|
value = source[token.range[0]:token.range[1]]
|
||
|
extra.tokens.append(
|
||
|
jsdict({
|
||
|
"type": TokenName[token.type],
|
||
|
"value": value,
|
||
|
"range": range,
|
||
|
"loc": loc,
|
||
|
}))
|
||
|
return token
|
||
|
|
||
|
|
||
|
def collectRegex():
|
||
|
pos = None
|
||
|
loc = None
|
||
|
regex = None
|
||
|
token = None
|
||
|
skipComment()
|
||
|
pos = index
|
||
|
loc = jsdict({
|
||
|
"start":
|
||
|
jsdict({
|
||
|
"line": lineNumber,
|
||
|
"column": index - lineStart,
|
||
|
}),
|
||
|
})
|
||
|
regex = extra.scanRegExp()
|
||
|
loc.end = jsdict({
|
||
|
"line": lineNumber,
|
||
|
"column": index - lineStart,
|
||
|
})
|
||
|
if not extra.tokenize:
|
||
|
if len(extra.tokens) > 0:
|
||
|
token = extra.tokens[len(extra.tokens) - 1]
|
||
|
if (token.range[0] == pos) and (token.type == "Punctuator"):
|
||
|
if (token.value == "/") or (token.value == "/="):
|
||
|
extra.tokens.pop()
|
||
|
extra.tokens.append(
|
||
|
jsdict({
|
||
|
"type": "RegularExpression",
|
||
|
"value": regex.literal,
|
||
|
"range": [pos, index],
|
||
|
"loc": loc,
|
||
|
}))
|
||
|
return regex
|
||
|
|
||
|
|
||
|
def filterTokenLocation():
|
||
|
i = None
|
||
|
entry = None
|
||
|
token = None
|
||
|
tokens = []
|
||
|
i = 0
|
||
|
while 1:
|
||
|
if not (i < len(extra.tokens)):
|
||
|
break
|
||
|
entry = extra.tokens[i]
|
||
|
token = jsdict({
|
||
|
"type": entry.type,
|
||
|
"value": entry.value,
|
||
|
})
|
||
|
if extra.range:
|
||
|
token.range = entry.range
|
||
|
if extra.loc:
|
||
|
token.loc = entry.loc
|
||
|
tokens.append(token)
|
||
|
i += 1
|
||
|
extra.tokens = tokens
|
||
|
|
||
|
|
||
|
class LocationMarker(object):
|
||
|
def __init__(self=None):
|
||
|
self.marker = [index, lineNumber, index - lineStart, 0, 0, 0]
|
||
|
|
||
|
def end(self=None):
|
||
|
self.marker[3] = index
|
||
|
self.marker[4] = lineNumber
|
||
|
self.marker[5] = index - lineStart
|
||
|
|
||
|
def apply(self=None, node=None):
|
||
|
if extra.range:
|
||
|
node.range = [self.marker[0], self.marker[3]]
|
||
|
if extra.loc:
|
||
|
node.loc = jsdict({
|
||
|
"start":
|
||
|
jsdict({
|
||
|
"line": self.marker[1],
|
||
|
"column": self.marker[2],
|
||
|
}),
|
||
|
"end":
|
||
|
jsdict({
|
||
|
"line": self.marker[4],
|
||
|
"column": self.marker[5],
|
||
|
}),
|
||
|
})
|
||
|
node = delegate.postProcess(node)
|
||
|
|
||
|
|
||
|
def createLocationMarker():
|
||
|
if (not extra.loc) and (not extra.range):
|
||
|
return None
|
||
|
skipComment()
|
||
|
return LocationMarker()
|
||
|
|
||
|
|
||
|
def patch():
|
||
|
global advance, scanRegExp
|
||
|
if ('undefined' if not ('tokens' in extra) else typeof(
|
||
|
extra.tokens)) != "undefined":
|
||
|
extra.advance = advance
|
||
|
extra.scanRegExp = scanRegExp
|
||
|
advance = collectToken
|
||
|
scanRegExp = collectRegex
|
||
|
|
||
|
|
||
|
def unpatch():
|
||
|
global advance, scanRegExp
|
||
|
if ('undefined' if not ('scanRegExp' in extra) else typeof(
|
||
|
extra.scanRegExp)) == "function":
|
||
|
advance = extra.advance
|
||
|
scanRegExp = extra.scanRegExp
|
||
|
|
||
|
|
||
|
def tokenize(code, **options):
|
||
|
global delegate, source, index, lineNumber, lineStart, length, lookahead, state, extra
|
||
|
options = jsdict(options)
|
||
|
toString = None
|
||
|
token = None
|
||
|
tokens = None
|
||
|
toString = str
|
||
|
if (('undefined' if not 'code' in locals() else typeof(code)) !=
|
||
|
"string") and (not isinstance(code, str)):
|
||
|
code = toString(code)
|
||
|
delegate = SyntaxTreeDelegate
|
||
|
source = code
|
||
|
index = 0
|
||
|
lineNumber = (1 if len(source) > 0 else 0)
|
||
|
lineStart = 0
|
||
|
length = len(source)
|
||
|
lookahead = None
|
||
|
state = jsdict({
|
||
|
"allowIn": True,
|
||
|
"labelSet": jsdict({}),
|
||
|
"inFunctionBody": False,
|
||
|
"inIteration": False,
|
||
|
"inSwitch": False,
|
||
|
"lastCommentStart": -1,
|
||
|
})
|
||
|
extra = jsdict({})
|
||
|
options = options or jsdict({})
|
||
|
options.tokens = True
|
||
|
extra.tokens = []
|
||
|
extra.tokenize = True
|
||
|
extra.openParenToken = -1
|
||
|
extra.openCurlyToken = -1
|
||
|
extra.range = (('undefined' if not ('range' in options) else typeof(
|
||
|
options.range)) == "boolean") and options.range
|
||
|
extra.loc = (('undefined' if not ('loc' in options) else typeof(
|
||
|
options.loc)) == "boolean") and options.loc
|
||
|
if (('undefined' if not ('comment' in options) else typeof(
|
||
|
options.comment)) == "boolean") and options.comment:
|
||
|
extra.comments = []
|
||
|
if (('undefined' if not ('tolerant' in options) else typeof(
|
||
|
options.tolerant)) == "boolean") and options.tolerant:
|
||
|
extra.errors = []
|
||
|
if length > 0:
|
||
|
if (typeof(source[0])) == "undefined":
|
||
|
if isinstance(code, str):
|
||
|
source = code.valueOf()
|
||
|
patch()
|
||
|
try:
|
||
|
peek()
|
||
|
if lookahead.type == Token.EOF:
|
||
|
return extra.tokens
|
||
|
token = lex()
|
||
|
while lookahead.type != Token.EOF:
|
||
|
try:
|
||
|
token = lex()
|
||
|
except Exception as lexError:
|
||
|
token = lookahead
|
||
|
if extra.errors:
|
||
|
extra.errors.append(lexError)
|
||
|
break
|
||
|
else:
|
||
|
raise
|
||
|
filterTokenLocation()
|
||
|
tokens = extra.tokens
|
||
|
if ('undefined' if not ('comments' in extra) else typeof(
|
||
|
extra.comments)) != "undefined":
|
||
|
tokens.comments = extra.comments
|
||
|
if ('undefined' if not ('errors' in extra) else typeof(
|
||
|
extra.errors)) != "undefined":
|
||
|
tokens.errors = extra.errors
|
||
|
except Exception as e:
|
||
|
raise
|
||
|
finally:
|
||
|
unpatch()
|
||
|
extra = jsdict({})
|
||
|
return tokens
|
||
|
|
||
|
|
||
|
def parse(code, **options):
|
||
|
global delegate, source, index, lineNumber, lineStart, length, lookahead, state, extra
|
||
|
options = jsdict(options)
|
||
|
program = None
|
||
|
toString = None
|
||
|
toString = str
|
||
|
if (('undefined' if not 'code' in locals() else typeof(code)) !=
|
||
|
"string") and (not isinstance(code, str)):
|
||
|
code = toString(code)
|
||
|
delegate = SyntaxTreeDelegate
|
||
|
source = code
|
||
|
index = 0
|
||
|
lineNumber = (1 if len(source) > 0 else 0)
|
||
|
lineStart = 0
|
||
|
length = len(source)
|
||
|
lookahead = None
|
||
|
state = jsdict({
|
||
|
"allowIn": True,
|
||
|
"labelSet": jsdict({}),
|
||
|
"inFunctionBody": False,
|
||
|
"inIteration": False,
|
||
|
"inSwitch": False,
|
||
|
"lastCommentStart": -1,
|
||
|
"markerStack": [],
|
||
|
})
|
||
|
extra = jsdict({})
|
||
|
if ('undefined'
|
||
|
if not 'options' in locals() else typeof(options)) != "undefined":
|
||
|
extra.range = (('undefined' if not ('range' in options) else typeof(
|
||
|
options.range)) == "boolean") and options.range
|
||
|
extra.loc = (('undefined' if not ('loc' in options) else typeof(
|
||
|
options.loc)) == "boolean") and options.loc
|
||
|
if (extra.loc and
|
||
|
(options.source != None)) and (options.source != undefined):
|
||
|
extra.source = toString(options.source)
|
||
|
if (('undefined' if not ('tokens' in options) else typeof(
|
||
|
options.tokens)) == "boolean") and options.tokens:
|
||
|
extra.tokens = []
|
||
|
if (('undefined' if not ('comment' in options) else typeof(
|
||
|
options.comment)) == "boolean") and options.comment:
|
||
|
extra.comments = []
|
||
|
if (('undefined' if not ('tolerant' in options) else typeof(
|
||
|
options.tolerant)) == "boolean") and options.tolerant:
|
||
|
extra.errors = []
|
||
|
if length > 0:
|
||
|
if (typeof(source[0])) == "undefined":
|
||
|
if isinstance(code, str):
|
||
|
source = code.valueOf()
|
||
|
patch()
|
||
|
try:
|
||
|
program = parseProgram()
|
||
|
if ('undefined' if not ('comments' in extra) else typeof(
|
||
|
extra.comments)) != "undefined":
|
||
|
program.comments = extra.comments
|
||
|
if ('undefined' if not ('tokens' in extra) else typeof(
|
||
|
extra.tokens)) != "undefined":
|
||
|
filterTokenLocation()
|
||
|
program.tokens = extra.tokens
|
||
|
if ('undefined' if not ('errors' in extra) else typeof(
|
||
|
extra.errors)) != "undefined":
|
||
|
program.errors = extra.errors
|
||
|
except Exception as e:
|
||
|
raise
|
||
|
finally:
|
||
|
unpatch()
|
||
|
extra = jsdict({})
|
||
|
return program
|
||
|
|
||
|
|
||
|
parse('var = 490 \n a=4;')
|