KoD 0.7

- nuovo metodo di override DNS - aggiunta opzione nascondi server, se usi l'autoplay - migliorie al codice e fix vari
2020-01-08 19:19:59 +01:00
parent d1cc659707
commit b4376525de
139 changed files with 6078 additions and 8909 deletions
--- a/lib/js2py/base.py
+++ b/lib/js2py/base.py
@@ -5,6 +5,7 @@ import re
 from .translators.friendly_nodes import REGEXP_CONVERTER
 from .utils.injector import fix_js_args
 from types import FunctionType, ModuleType, GeneratorType, BuiltinFunctionType, MethodType, BuiltinMethodType
+from math import floor, log10
 import traceback
 try:
    import numpy
@@ -603,15 +604,7 @@ class PyJs(object):
        elif typ == 'Boolean':
            return Js('true') if self.value else Js('false')
        elif typ == 'Number':  #or self.Class=='Number':
-            if self.is_nan():
-                return Js('NaN')
-            elif self.is_infinity():
-                sign = '-' if self.value < 0 else ''
-                return Js(sign + 'Infinity')
-            elif isinstance(self.value,
-                            long) or self.value.is_integer():  # dont print .0
-                return Js(unicode(int(self.value)))
-            return Js(unicode(self.value))  # accurate enough
+            return Js(unicode(js_dtoa(self.value)))
        elif typ == 'String':
            return self
        else:  #object
@@ -1046,7 +1039,7 @@ def PyJsComma(a, b):
    return b


-from .internals.simplex import JsException as PyJsException
+from .internals.simplex import JsException as PyJsException, js_dtoa
 import pyjsparser
 pyjsparser.parser.ENABLE_JS2PY_ERRORS = lambda msg: MakeError('SyntaxError', msg)

--- a/lib/js2py/evaljs.py
+++ b/lib/js2py/evaljs.py
@@ -116,36 +116,52 @@ def eval_js(js):


 def eval_js6(js):
+    """Just like eval_js but with experimental support for js6 via babel."""
    return eval_js(js6_to_js5(js))


 def translate_js6(js):
+    """Just like translate_js but with experimental support for js6 via babel."""
    return translate_js(js6_to_js5(js))


 class EvalJs(object):
    """This class supports continuous execution of javascript under same context.

-        >>> js = EvalJs()
-        >>> js.execute('var a = 10;function f(x) {return x*x};')
-        >>> js.f(9)
+        >>> ctx = EvalJs()
+        >>> ctx.execute('var a = 10;function f(x) {return x*x};')
+        >>> ctx.f(9)
        81
-        >>> js.a
+        >>> ctx.a
        10

        context is a python dict or object that contains python variables that should be available to JavaScript
        For example:
-        >>> js = EvalJs({'a': 30})
-        >>> js.execute('var x = a')
-        >>> js.x
+        >>> ctx = EvalJs({'a': 30})
+        >>> ctx.execute('var x = a')
+        >>> ctx.x
        30

+        You can enable JS require function via enable_require. With this feature enabled you can use js modules
+        from npm, for example:
+        >>> ctx = EvalJs(enable_require=True)
+        >>> ctx.execute("var esprima = require('esprima');")
+        >>> ctx.execute("esprima.parse('var a = 1')")
+
       You can run interactive javascript console with console method!"""

-    def __init__(self, context={}):
+    def __init__(self, context={}, enable_require=False):
        self.__dict__['_context'] = {}
        exec (DEFAULT_HEADER, self._context)
        self.__dict__['_var'] = self._context['var'].to_python()
+
+        if enable_require:
+            def _js_require_impl(npm_module_name):
+                from .node_import import require
+                from .base import to_python
+                return require(to_python(npm_module_name), context=self._context)
+            setattr(self._var, 'require', _js_require_impl)
+
        if not isinstance(context, dict):
            try:
                context = context.__dict__
--- a/lib/js2py/internals/constructors/jsfunction.py
+++ b/lib/js2py/internals/constructors/jsfunction.py
@@ -7,7 +7,7 @@ from ..byte_trans import ByteCodeGenerator, Code

 def Function(this, args):
    # convert arguments to python list of strings
-    a = map(to_string, tuple(args))
+    a = list(map(to_string, tuple(args)))
    _body = u';'
    _args = ()
    if len(a):
@@ -42,6 +42,7 @@ def executable_code(code_str, space, global_context=True):
    space.byte_generator.emit('LABEL', skip)
    space.byte_generator.emit('NOP')
    space.byte_generator.restore_state()
+
    space.byte_generator.exe.compile(
        start_loc=old_tape_len
    )  # dont read the code from the beginning, dont be stupid!
@@ -71,5 +72,5 @@ def _eval(this, args):


 def log(this, args):
-    print ' '.join(map(to_string, args))
+    print(' '.join(map(to_string, args)))
    return undefined
--- a/lib/js2py/internals/prototypes/jsstring.py
+++ b/lib/js2py/internals/prototypes/jsstring.py
@@ -4,7 +4,7 @@ from __future__ import unicode_literals
 import re
 from ..conversions import *
 from ..func_utils import *
-from jsregexp import RegExpExec
+from .jsregexp import RegExpExec

 DIGS = set(u'0123456789')
 WHITE = u"\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF"
--- a/lib/js2py/node_import.py
+++ b/lib/js2py/node_import.py
@@ -1,6 +1,6 @@
 __all__ = ['require']
 import subprocess, os, codecs, glob
-from .evaljs import translate_js
+from .evaljs import translate_js, DEFAULT_HEADER
 import six
 DID_INIT = False
 DIRNAME = os.path.dirname(os.path.abspath(__file__))
@@ -15,7 +15,7 @@ def _init():
        'node -v', shell=True, cwd=DIRNAME
    ) == 0, 'You must have node installed! run: brew install node'
    assert subprocess.call(
-        'cd %s;npm install babel-core babel-cli babel-preset-es2015 babel-polyfill babelify browserify'
+        'cd %s;npm install babel-core babel-cli babel-preset-es2015 babel-polyfill babelify browserify browserify-shim'
        % repr(DIRNAME),
        shell=True,
        cwd=DIRNAME) == 0, 'Could not link required node_modules'
@@ -46,12 +46,18 @@ GET_FROM_GLOBALS_FUNC = '''

 '''

+def _get_module_py_name(module_name):
+    return module_name.replace('-', '_')

-def require(module_name, include_polyfill=False, update=False):
+def _get_module_var_name(module_name):
+    return _get_module_py_name(module_name).rpartition('/')[-1]
+
+
+def _get_and_translate_npm_module(module_name, include_polyfill=False, update=False):
    assert isinstance(module_name, str), 'module_name must be a string!'
-    py_name = module_name.replace('-', '_')
+    py_name = _get_module_py_name(module_name)
    module_filename = '%s.py' % py_name
-    var_name = py_name.rpartition('/')[-1]
+    var_name = _get_module_var_name(module_name)
    if not os.path.exists(os.path.join(PY_NODE_MODULES_PATH,
                                       module_filename)) or update:
        _init()
@@ -77,7 +83,7 @@ def require(module_name, include_polyfill=False, update=False):

        # convert the module
        assert subprocess.call(
-            '''node -e "(require('browserify')('./%s').bundle(function (err,data) {fs.writeFile('%s', require('babel-core').transform(data, {'presets': require('babel-preset-es2015')}).code, ()=>{});}))"'''
+            '''node -e "(require('browserify')('./%s').bundle(function (err,data) {if (err) {console.log(err);throw new Error(err);};fs.writeFile('%s', require('babel-core').transform(data, {'presets': require('babel-preset-es2015')}).code, ()=>{});}))"'''
            % (in_file_name, out_file_name),
            shell=True,
            cwd=DIRNAME,
@@ -88,7 +94,8 @@ def require(module_name, include_polyfill=False, update=False):
                         "utf-8") as f:
            js_code = f.read()
        os.remove(os.path.join(DIRNAME, out_file_name))
-
+        if len(js_code) < 50:
+            raise RuntimeError("Candidate JS bundle too short - likely browserify issue.")
        js_code += GET_FROM_GLOBALS_FUNC
        js_code += ';var %s = getFromGlobals(%s);%s' % (
            var_name, repr(module_name), var_name)
@@ -107,7 +114,32 @@ def require(module_name, include_polyfill=False, update=False):
                os.path.join(PY_NODE_MODULES_PATH, module_filename), "r",
                "utf-8") as f:
            py_code = f.read()
+    return py_code

-    context = {}
+
+def require(module_name, include_polyfill=False, update=False, context=None):
+    """
+    Installs the provided npm module, exports a js bundle via browserify, converts to ECMA 5.1 via babel and
+    finally translates the generated JS bundle to Python via Js2Py.
+    Returns a pure python object that behaves like the installed module. Nice!
+
+    :param module_name: Name of the npm module to require. For example 'esprima'.
+    :param include_polyfill: Whether the babel-polyfill should be included as part of the translation. May be needed
+    for some modules that use unsupported features.
+    :param update: Whether to force update the translation. Otherwise uses a cached version if exists.
+    :param context: Optional context in which the translated module should be executed in. If provided, the
+        header (js2py imports) will be skipped as it is assumed that the context already has all the necessary imports.
+    :return: The JsObjectWrapper containing the translated module object. Can be used like a standard python object.
+    """
+    py_code = _get_and_translate_npm_module(module_name, include_polyfill=include_polyfill, update=update)
+    # this is a bit hacky but we need to strip the default header from the generated code...
+    if context is not None:
+        if not py_code.startswith(DEFAULT_HEADER):
+            # new header version? retranslate...
+            assert not update, "Unexpected header."
+            py_code = _get_and_translate_npm_module(module_name, include_polyfill=include_polyfill, update=True)
+            assert py_code.startswith(DEFAULT_HEADER), "Unexpected header."
+        py_code = py_code[len(DEFAULT_HEADER):]
+    context = {} if context is None else context
    exec (py_code, context)
-    return context['var'][var_name].to_py()
+    return context['var'][_get_module_var_name(module_name)].to_py()
--- a/lib/js2py/prototypes/jsfunction.py
+++ b/lib/js2py/prototypes/jsfunction.py
@@ -6,8 +6,6 @@ if six.PY3:
    xrange = range
    unicode = str

-# todo fix apply and bind
-

 class FunctionPrototype:
    def toString():
@@ -41,6 +39,7 @@ class FunctionPrototype:
        return this.call(obj, args)

    def bind(thisArg):
+        arguments_ = arguments
        target = this
        if not target.is_callable():
            raise this.MakeError(
@@ -48,5 +47,5 @@ class FunctionPrototype:
        if len(arguments) <= 1:
            args = ()
        else:
-            args = tuple([arguments[e] for e in xrange(1, len(arguments))])
+            args = tuple([arguments_[e] for e in xrange(1, len(arguments_))])
        return this.PyJsBoundFunction(target, thisArg, args)
--- a/lib/js2py/test_internals.py
+++ b/lib/js2py/test_internals.py
@@ -1,9 +0,0 @@
-from internals import byte_trans
-from internals import seval
-import pyjsparser
-
-x = r'''
-function g() {var h123 = 11; return [function g1() {return h123}, new Function('return h123')]}
-g()[1]()
-'''
-print seval.eval_js_vm(x)
--- a/lib/js2py/translators/translating_nodes.py
+++ b/lib/js2py/translators/translating_nodes.py
@@ -155,7 +155,7 @@ def limited(func):
 inf = float('inf')


-def Literal(type, value, raw, regex=None, comments=None):
+def Literal(type, value, raw, regex=None):
    if regex:  # regex
        return 'JsRegExp(%s)' % repr(compose_regex(value))
    elif value is None:  # null
@@ -165,12 +165,12 @@ def Literal(type, value, raw, regex=None, comments=None):
    return 'Js(%s)' % repr(value) if value != inf else 'Js(float("inf"))'


-def Identifier(type, name, comments=None):
+def Identifier(type, name):
    return 'var.get(%s)' % repr(name)


@limited
-def MemberExpression(type, computed, object, property, comments=None):
+def MemberExpression(type, computed, object, property):
    far_left = trans(object)
    if computed:  # obj[prop] type accessor
        # may be literal which is the same in every case so we can save some time on conversion
@@ -183,12 +183,12 @@ def MemberExpression(type, computed, object, property, comments=None):
    return far_left + '.get(%s)' % prop


-def ThisExpression(type, comments=None):
+def ThisExpression(type):
    return 'var.get(u"this")'


@limited
-def CallExpression(type, callee, arguments, comments=None):
+def CallExpression(type, callee, arguments):
    arguments = [trans(e) for e in arguments]
    if callee['type'] == 'MemberExpression':
        far_left = trans(callee['object'])
@@ -210,38 +210,47 @@ def CallExpression(type, callee, arguments, comments=None):
 # ========== ARRAYS ============


-def ArrayExpression(type, elements, comments=None):  # todo fix null inside problem
+def ArrayExpression(type, elements):  # todo fix null inside problem
    return 'Js([%s])' % ', '.join(trans(e) if e else 'None' for e in elements)


 # ========== OBJECTS =============


-def ObjectExpression(type, properties, comments=None):
-    name = inline_stack.require('Object')
+def ObjectExpression(type, properties):
+    name = None
    elems = []
    after = ''
    for p in properties:
        if p['kind'] == 'init':
            elems.append('%s:%s' % Property(**p))
-        elif p['kind'] == 'set':
-            k, setter = Property(
-                **p
-            )  # setter is just a lval referring to that function, it will be defined in InlineStack automatically
-            after += '%s.define_own_property(%s, {"set":%s, "configurable":True, "enumerable":True})\n' % (
-                name, k, setter)
-        elif p['kind'] == 'get':
-            k, getter = Property(**p)
-            after += '%s.define_own_property(%s, {"get":%s, "configurable":True, "enumerable":True})\n' % (
-                name, k, getter)
        else:
-            raise RuntimeError('Unexpected object propery kind')
-    obj = '%s = Js({%s})\n' % (name, ','.join(elems))
-    inline_stack.define(name, obj + after)
-    return name
+            if name is None:
+                name = inline_stack.require('Object')
+            if p['kind'] == 'set':
+                k, setter = Property(
+                    **p
+                )  # setter is just a lval referring to that function, it will be defined in InlineStack automatically
+                after += '%s.define_own_property(%s, {"set":%s, "configurable":True, "enumerable":True})\n' % (
+                    name, k, setter)
+            elif p['kind'] == 'get':
+                k, getter = Property(**p)
+                after += '%s.define_own_property(%s, {"get":%s, "configurable":True, "enumerable":True})\n' % (
+                    name, k, getter)
+            else:
+                raise RuntimeError('Unexpected object propery kind')
+    definition = 'Js({%s})' % ','.join(elems)
+    if name is None:
+        return definition
+    body = '%s = %s\n' % (name, definition)
+    body += after
+    body += 'return %s\n' % name
+    code = 'def %s():\n%s' % (name, indent(body))
+    inline_stack.define(name, code)
+    return name + '()'


-def Property(type, kind, key, computed, value, method, shorthand, comments=None):
+def Property(type, kind, key, computed, value, method, shorthand):
    if shorthand or computed:
        raise NotImplementedError(
            'Shorthand and Computed properties not implemented!')
@@ -256,7 +265,7 @@ def Property(type, kind, key, computed, value, method, shorthand, comments=None)


@limited
-def UnaryExpression(type, operator, argument, prefix, comments=None):
+def UnaryExpression(type, operator, argument, prefix):
    a = trans(
        argument, standard=True
    )  # unary involve some complex operations so we cant use line shorteners here
@@ -271,7 +280,7 @@ def UnaryExpression(type, operator, argument, prefix, comments=None):


@limited
-def BinaryExpression(type, operator, left, right, comments=None):
+def BinaryExpression(type, operator, left, right):
    a = trans(left)
    b = trans(right)
    # delegate to our friends
@@ -279,7 +288,7 @@ def BinaryExpression(type, operator, left, right, comments=None):


@limited
-def UpdateExpression(type, operator, argument, prefix, comments=None):
+def UpdateExpression(type, operator, argument, prefix):
    a = trans(
        argument, standard=True
    )  # also complex operation involving parsing of the result so no line length reducing here
@@ -287,7 +296,7 @@ def UpdateExpression(type, operator, argument, prefix, comments=None):


@limited
-def AssignmentExpression(type, operator, left, right, comments=None):
+def AssignmentExpression(type, operator, left, right):
    operator = operator[:-1]
    if left['type'] == 'Identifier':
        if operator:
@@ -319,12 +328,12 @@ six


@limited
-def SequenceExpression(type, expressions, comments=None):
+def SequenceExpression(type, expressions):
    return reduce(js_comma, (trans(e) for e in expressions))


@limited
-def NewExpression(type, callee, arguments, comments=None):
+def NewExpression(type, callee, arguments):
    return trans(callee) + '.create(%s)' % ', '.join(
        trans(e) for e in arguments)

@@ -332,7 +341,7 @@ def NewExpression(type, callee, arguments, comments=None):
@limited
 def ConditionalExpression(
        type, test, consequent,
-        alternate, comments=None):  # caused plenty of problems in my home-made translator :)
+        alternate):  # caused plenty of problems in my home-made translator :)
    return '(%s if %s else %s)' % (trans(consequent), trans(test),
                                   trans(alternate))

@@ -340,49 +349,49 @@ def ConditionalExpression(
 # ===========  STATEMENTS =============


-def BlockStatement(type, body, comments=None):
+def BlockStatement(type, body):
    return StatementList(
        body)  # never returns empty string! In the worst case returns pass\n


-def ExpressionStatement(type, expression, comments=None):
+def ExpressionStatement(type, expression):
    return trans(expression) + '\n'  # end expression space with new line


-def BreakStatement(type, label, comments=None):
+def BreakStatement(type, label):
    if label:
        return 'raise %s("Breaked")\n' % (get_break_label(label['name']))
    else:
        return 'break\n'


-def ContinueStatement(type, label, comments=None):
+def ContinueStatement(type, label):
    if label:
        return 'raise %s("Continued")\n' % (get_continue_label(label['name']))
    else:
        return 'continue\n'


-def ReturnStatement(type, argument, comments=None):
+def ReturnStatement(type, argument):
    return 'return %s\n' % (trans(argument)
                            if argument else "var.get('undefined')")


-def EmptyStatement(type, comments=None):
+def EmptyStatement(type):
    return 'pass\n'


-def DebuggerStatement(type, comments=None):
+def DebuggerStatement(type):
    return 'pass\n'


-def DoWhileStatement(type, body, test, comments=None):
+def DoWhileStatement(type, body, test):
    inside = trans(body) + 'if not %s:\n' % trans(test) + indent('break\n')
    result = 'while 1:\n' + indent(inside)
    return result


-def ForStatement(type, init, test, update, body, comments=None):
+def ForStatement(type, init, test, update, body):
    update = indent(trans(update)) if update else ''
    init = trans(init) if init else ''
    if not init.endswith('\n'):
@@ -398,7 +407,7 @@ def ForStatement(type, init, test, update, body, comments=None):
    return result


-def ForInStatement(type, left, right, body, each, comments=None):
+def ForInStatement(type, left, right, body, each):
    res = 'for PyJsTemp in %s:\n' % trans(right)
    if left['type'] == "VariableDeclaration":
        addon = trans(left)  # make sure variable is registered
@@ -417,7 +426,7 @@ def ForInStatement(type, left, right, body, each, comments=None):
    return res


-def IfStatement(type, test, consequent, alternate, comments=None):
+def IfStatement(type, test, consequent, alternate):
    # NOTE we cannot do elif because function definition inside elif statement would not be possible!
    IF = 'if %s:\n' % trans(test)
    IF += indent(trans(consequent))
@@ -427,7 +436,7 @@ def IfStatement(type, test, consequent, alternate, comments=None):
    return IF + ELSE


-def LabeledStatement(type, label, body, comments=None):
+def LabeledStatement(type, label, body):
    # todo consider using smarter approach!
    inside = trans(body)
    defs = ''
@@ -448,7 +457,7 @@ def LabeledStatement(type, label, body, comments=None):
    return defs + inside


-def StatementList(lis, comments=None):
+def StatementList(lis):
    if lis:  # ensure we don't return empty string because it may ruin indentation!
        code = ''.join(trans(e) for e in lis)
        return code if code else 'pass\n'
@@ -456,7 +465,7 @@ def StatementList(lis, comments=None):
        return 'pass\n'


-def PyimportStatement(type, imp, comments=None):
+def PyimportStatement(type, imp):
    lib = imp['name']
    jlib = 'PyImport_%s' % lib
    code = 'import %s as %s\n' % (lib, jlib)
@@ -471,7 +480,7 @@ def PyimportStatement(type, imp, comments=None):
    return code


-def SwitchStatement(type, discriminant, cases, comments=None):
+def SwitchStatement(type, discriminant, cases):
    #TODO there will be a problem with continue in a switch statement.... FIX IT
    code = 'while 1:\n' + indent('SWITCHED = False\nCONDITION = (%s)\n')
    code = code % trans(discriminant)
@@ -491,12 +500,12 @@ def SwitchStatement(type, discriminant, cases, comments=None):
    return code


-def ThrowStatement(type, argument, comments=None):
+def ThrowStatement(type, argument):
    return 'PyJsTempException = JsToPyException(%s)\nraise PyJsTempException\n' % trans(
        argument)


-def TryStatement(type, block, handler, handlers, guardedHandlers, finalizer, comments=None):
+def TryStatement(type, block, handler, handlers, guardedHandlers, finalizer):
    result = 'try:\n%s' % indent(trans(block))
    # complicated catch statement...
    if handler:
@@ -516,13 +525,13 @@ def TryStatement(type, block, handler, handlers, guardedHandlers, finalizer, com
    return result


-def LexicalDeclaration(type, declarations, kind, comments=None):
+def LexicalDeclaration(type, declarations, kind):
    raise NotImplementedError(
        'let and const not implemented yet but they will be soon! Check github for updates.'
    )


-def VariableDeclarator(type, id, init, comments=None):
+def VariableDeclarator(type, id, init):
    name = id['name']
    # register the name if not already registered
    Context.register(name)
@@ -531,21 +540,21 @@ def VariableDeclarator(type, id, init, comments=None):
    return ''


-def VariableDeclaration(type, declarations, kind, comments=None):
+def VariableDeclaration(type, declarations, kind):
    code = ''.join(trans(d) for d in declarations)
    return code if code else 'pass\n'


-def WhileStatement(type, test, body, comments=None):
+def WhileStatement(type, test, body):
    result = 'while %s:\n' % trans(test) + indent(trans(body))
    return result


-def WithStatement(type, object, body, comments=None):
+def WithStatement(type, object, body):
    raise NotImplementedError('With statement not implemented!')


-def Program(type, body, comments=None):
+def Program(type, body):
    inline_stack.reset()
    code = ''.join(trans(e) for e in body)
    # here add hoisted elements (register variables and define functions)
@@ -559,7 +568,7 @@ def Program(type, body, comments=None):


 def FunctionDeclaration(type, id, params, defaults, body, generator,
-                        expression, comments=None):
+                        expression):
    if generator:
        raise NotImplementedError('Generators not supported')
    if defaults:
@@ -610,7 +619,7 @@ def FunctionDeclaration(type, id, params, defaults, body, generator,


 def FunctionExpression(type, id, params, defaults, body, generator,
-                       expression, comments=None):
+                       expression):
    if generator:
        raise NotImplementedError('Generators not supported')
    if defaults:
--- a/lib/js2py/utils/injector.py
+++ b/lib/js2py/utils/injector.py
@@ -115,7 +115,16 @@ def append_arguments(code_obj, new_locals):
                code_obj.co_freevars, code_obj.co_cellvars)

    # Done modifying codestring - make the code object
-    return types.CodeType(*args)
+    if hasattr(code_obj, "replace"):
+        # Python 3.8+
+        return code_obj.replace(
+            co_argcount=co_argcount + new_locals_len,
+            co_nlocals=code_obj.co_nlocals + new_locals_len,
+            co_code=code,
+            co_names=names,
+            co_varnames=varnames)
+    else:
+        return types.CodeType(*args)


 def instructions(code_obj):