jsi = JSInterpreter('function f(){return 1 << 5;}')
self.assertEqual(jsi.call_function('f'), 32)
+ jsi = JSInterpreter('function f(){return 2 ** 5}')
+ self.assertEqual(jsi.call_function('f'), 32)
+
jsi = JSInterpreter('function f(){return 19 & 21;}')
self.assertEqual(jsi.call_function('f'), 17)
jsi = JSInterpreter('function f(){return []? 2+3: 4;}')
self.assertEqual(jsi.call_function('f'), 5)
+ jsi = JSInterpreter('function f(){return 1 == 2}')
+ self.assertEqual(jsi.call_function('f'), False)
+
+ jsi = JSInterpreter('function f(){return 0 && 1 || 2;}')
+ self.assertEqual(jsi.call_function('f'), 2)
+
def test_array_access(self):
jsi = JSInterpreter('function f(){var x = [1,2,3]; x[0] = 4; x[0] = 5; x[2.0] = 7; return x;}')
self.assertEqual(jsi.call_function('f'), [5, 2, 7])
}''')
self.assertEqual(jsi.call_function('x'), [20, 20, 30, 40, 50])
+ def test_builtins(self):
+ jsi = JSInterpreter('''
+ function x() { return new Date('Wednesday 31 December 1969 18:01:26 MDT') - 0; }
+ ''')
+ self.assertEqual(jsi.call_function('x'), 86000)
+ jsi = JSInterpreter('''
+ function x(dt) { return new Date(dt) - 0; }
+ ''')
+ self.assertEqual(jsi.call_function('x', 'Wednesday 31 December 1969 18:01:26 MDT'), 86000)
+
def test_call(self):
jsi = JSInterpreter('''
function x() { return 2; }
''')
self.assertEqual(jsi.call_function('x'), 7)
+ jsi = JSInterpreter('''
+ function x() { a=5; return (a -= 1, a+=3, a); }
+ ''')
+ self.assertEqual(jsi.call_function('x'), 7)
+
+ def test_void(self):
+ jsi = JSInterpreter('''
+ function x() { return void 42; }
+ ''')
+ self.assertEqual(jsi.call_function('x'), None)
+
def test_return_function(self):
jsi = JSInterpreter('''
function x() { return [1, function(){return 1}][1] }
)
_NAME_RE = r'[a-zA-Z_$][\w$]*'
+
+# Ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence
_OPERATORS = { # None => Defined in JSInterpreter._operator
'?': None,
'|': operator.or_,
'^': operator.xor,
- # FIXME: This should actually be below comparision
- '>>': operator.rshift,
- '<<': operator.lshift,
+ '===': operator.is_,
+ '!==': operator.is_not,
+ '==': operator.eq,
+ '!=': operator.ne,
'<=': operator.le,
'>=': operator.ge,
'<': operator.lt,
'>': operator.gt,
+ '>>': operator.rshift,
+ '<<': operator.lshift,
+
'+': operator.add,
'-': operator.sub,
'*': operator.mul,
'/': operator.truediv,
'%': operator.mod,
+
+ '**': operator.pow,
}
+_COMP_OPERATORS = {'===', '!==', '==', '!=', '<=', '>=', '<', '>'}
+
_MATCHING_PARENS = dict(zip('({[', ')}]'))
_QUOTES = '\'"'
class Debugger:
import sys
- ENABLED = 'pytest' in sys.modules
+ ENABLED = False and 'pytest' in sys.modules
@staticmethod
def write(*args, level=100):
if should_return:
return ret, should_return
- m = re.match(r'(?P<var>var\s)|return(?:\s+|$)', stmt)
+ m = re.match(r'(?P<var>(?:var|const|let)\s)|return(?:\s+|$)', stmt)
if m:
expr = stmt[len(m.group(0)):].strip()
should_return = not m.group('var')
obj = expr[4:]
if obj.startswith('Date('):
left, right = self._separate_at_paren(obj[4:], ')')
- expr = unified_timestamp(left[1:-1], False)
+ expr = unified_timestamp(
+ self.interpret_expression(left, local_vars, allow_recursion), False)
if not expr:
raise self.Exception(f'Failed to parse date {left!r}', expr)
expr = self._dump(int(expr * 1000), local_vars) + right
else:
raise self.Exception(f'Unsupported object {obj}', expr)
+ if expr.startswith('void '):
+ left = self.interpret_expression(expr[5:], local_vars, allow_recursion)
+ return None, should_return
+
if expr.startswith('{'):
inner, outer = self._separate_at_paren(expr, '}')
inner, should_abort = self.interpret_statement(inner, local_vars, allow_recursion)
if default:
matched = matched or case == 'default'
elif not matched:
- matched = case != 'default' and switch_val == self.interpret_expression(case, local_vars, allow_recursion)
+ matched = (case != 'default'
+ and switch_val == self.interpret_expression(case, local_vars, allow_recursion))
if not matched:
continue
try:
m = re.match(fr'''(?x)
(?P<assign>
(?P<out>{_NAME_RE})(?:\[(?P<index>[^\]]+?)\])?\s*
- (?P<op>{"|".join(map(re.escape, _OPERATORS))})?
+ (?P<op>{"|".join(map(re.escape, set(_OPERATORS) - _COMP_OPERATORS))})?
=(?P<expr>.*)$
)|(?P<return>
(?!if|return|true|false|null|undefined)(?P<name>{_NAME_RE})$
for op in _OPERATORS:
separated = list(self._separate(expr, op))
- if len(separated) < 2:
- continue
right_expr = separated.pop()
- while op == '-' and len(separated) > 1 and not separated[-1].strip():
- right_expr = f'-{right_expr}'
+ while op in '<>*-' and len(separated) > 1 and not separated[-1].strip():
separated.pop()
+ right_expr = f'{op}{right_expr}'
+ if op != '-':
+ right_expr = f'{separated.pop()}{op}{right_expr}'
+ if not separated:
+ continue
left_val = self.interpret_expression(op.join(separated), local_vars, allow_recursion)
return self._operator(op, 0 if left_val is None else left_val,
right_expr, expr, local_vars, allow_recursion), should_return
# Currently, it only supports function definitions
fields_m = re.finditer(
r'''(?x)
- (?P<key>%s)\s*:\s*function\s*\((?P<args>[a-z,]+)\){(?P<code>[^}]+)}
- ''' % _FUNC_NAME_RE,
+ (?P<key>%s)\s*:\s*function\s*\((?P<args>(?:%s|,)*)\){(?P<code>[^}]+)}
+ ''' % (_FUNC_NAME_RE, _NAME_RE),
fields)
for f in fields_m:
argnames = f.group('args').split(',')
(?:
function\s+%(name)s|
[{;,]\s*%(name)s\s*=\s*function|
- var\s+%(name)s\s*=\s*function
+ (?:var|const|let)\s+%(name)s\s*=\s*function
)\s*
\((?P<args>[^)]*)\)\s*
(?P<code>{.+})''' % {'name': re.escape(funcname)},
argnames = tuple(argnames)
def resf(args, kwargs={}, allow_recursion=100):
- global_stack[0].update({
- **dict(itertools.zip_longest(argnames, args, fillvalue=None)),
- **kwargs
- })
+ global_stack[0].update(itertools.zip_longest(argnames, args, fillvalue=None))
+ global_stack[0].update(kwargs)
var_stack = LocalNameSpace(*global_stack)
ret, should_abort = self.interpret_statement(code.replace('\n', ''), var_stack, allow_recursion - 1)
if should_abort:
projects / yt-dlp.git / commitdiff
