1

#!/usr/bin/env python

     2

# Copyright 2006 James Tauber and contributors

     3

#

     4

# Licensed under the Apache License, Version 2.0 (the "License");

     5

# you may not use this file except in compliance with the License.

     6

# You may obtain a copy of the License at

     7

#

     8

#     http://www.apache.org/licenses/LICENSE-2.0

     9

#

    10

# Unless required by applicable law or agreed to in writing, software

    11

# distributed under the License is distributed on an "AS IS" BASIS,

    12

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    13

# See the License for the specific language governing permissions and

    14

# limitations under the License.

    15

#

    16

# pylint: disable=no-absolute-import,bad-python3-import

    17

    18

from __future__ import print_function

    19

import sys

    20

import compiler

    21

from compiler import ast

    22

import os

    23

import copy

    24

from builtins import str as text

    25

from past.builtins import basestring

    26

from six.moves import cStringIO

    27

    28

# the standard location for builtins (e.g. pyjslib) can be

    29

# over-ridden by changing this.  it defaults to sys.prefix

    30

# so that on a system-wide install of pyjamas the builtins

    31

# can be found in e.g. {sys.prefix}/share/pyjamas

    32

#

    33

# over-rides can be done by either explicitly modifying

    34

# pyjs.prefix or by setting an environment variable, PYJSPREFIX.

    35

    36

prefix = sys.prefix

    37

    38

if 'PYJSPREFIX' in os.environ:

    39

    prefix = os.environ['PYJSPREFIX']

    40

    41

# pyjs.path is the list of paths, just like sys.path, from which

    42

# library modules will be searched for, for compile purposes.

    43

# obviously we don't want to use sys.path because that would result

    44

# in compiling standard python modules into javascript!

    45

    46

path = [os.path.abspath('')]

    47

    48

if 'PYJSPATH' in os.environ:

    49

    for p in os.environ['PYJSPATH'].split(os.pathsep):

    50

        p = os.path.abspath(p)

    51

        if os.path.isdir(p):

    52

            path.append(p)

    53

    54

# this is the python function used to wrap native javascript

    55

NATIVE_JS_FUNC_NAME = "JS"

    56

    57

UU = ""

    58

    59

PYJSLIB_BUILTIN_FUNCTIONS = ("cmp",

    60

                             "map",

    61

                             "filter",

    62

                             "dir",

    63

                             "getattr",

    64

                             "setattr",

    65

                             "hasattr",

    66

                             "int",

    67

                             "float",

    68

                             "str",

    69

                             "repr",

    70

                             "range",

    71

                             "len",

    72

                             "hash",

    73

                             "abs",

    74

                             "ord",

    75

                             "chr",

    76

                             "enumerate",

    77

                             "min",

    78

                             "max",

    79

                             "bool",

    80

                             "type",

    81

                             "isinstance")

    82

    83

PYJSLIB_BUILTIN_CLASSES = ("BaseException",

    84

                           "Exception",

    85

                           "StandardError",

    86

                           "StopIteration",

    87

                           "AttributeError",

    88

                           "TypeError",

    89

                           "KeyError",

    90

                           "LookupError",

    91

                           "list",

    92

                           "dict",

    93

                           "object",

    94

                           "tuple")

    95

    96

    97

def pyjs_builtin_remap(name):

    98

    # XXX HACK!

    99

    if name == 'list':

   100

        name = 'List'

   101

    if name == 'object':

   102

        name = '__Object'

   103

    if name == 'dict':

   104

        name = 'Dict'

   105

    if name == 'tuple':

   106

        name = 'Tuple'

   107

    return name

   108

   109

   110

# XXX: this is a hack: these should be dealt with another way

   111

# however, console is currently the only global name which is causing

   112

# problems.

   113

PYJS_GLOBAL_VARS = ("console")

   114

   115

# This is taken from the django project.

   116

# Escape every ASCII character with a value less than 32.

   117

JS_ESCAPES = (

   118

    ('\\', r'\x5C'),

   119

    ('\'', r'\x27'),

   120

    ('"', r'\x22'),

   121

    ('>', r'\x3E'),

   122

    ('<', r'\x3C'),

   123

    ('&', r'\x26'),

   124

    (';', r'\x3B')

   125

    ) + tuple([('%c' % z, '\\x%02X' % z) for z in range(32)])

   126

   127

   128

def escapejs(value):

   129

    """Hex encodes characters for use in JavaScript strings."""

   130

    for bad, good in JS_ESCAPES:

   131

        value = value.replace(bad, good)

   132

    return value

   133

   134

   135

def uuprefix(name, leave_alone=0):

   136

    name = name.split(".")

   137

    name = name[:leave_alone] + map(lambda x: "__%s" % x, name[leave_alone:])

   138

    return '.'.join(name)

   139

   140

   141

class Klass(object):

   142

   143

    klasses = {}

   144

   145

    def __init__(self, name, name_):

   146

        self.name = name

   147

        self.name_ = name_

   148

        self.klasses[name] = self

   149

        self.functions = set()

   150

   151

    def set_base(self, base_name):

   152

        self.base = self.klasses.get(base_name)

   153

   154

    def add_function(self, function_name):

   155

        self.functions.add(function_name)

   156

   157

   158

class TranslationError(Exception):

   159

    def __init__(self, message, node):

   160

        Exception.__init__(self)

   161

        self.message = "line %s:\n%s\n%s" % (node.lineno, message, node)

   162

   163

    def __str__(self):

   164

        return self.message

   165

   166

   167

def strip_py(name):

   168

    return name

   169

   170

   171

def mod_var_name_decl(raw_module_name):

   172

    """ function to get the last component of the module e.g.

   173

        pyjamas.ui.DOM into the "namespace".  i.e. doing

   174

        "import pyjamas.ui.DOM" actually ends up with _two_

   175

        variables - one pyjamas.ui.DOM, the other just "DOM".

   176

        but "DOM" is actually local, hence the "var" prefix.

   177

   178

        for PyV8, this might end up causing problems - we'll have

   179

        to see: gen_mod_import and mod_var_name_decl might have

   180

        to end up in a library-specific module, somewhere.

   181

    """

   182

    name = raw_module_name.split(".")

   183

    if len(name) == 1:

   184

        return ''

   185

    child_name = name[-1]

   186

    return "var %s = %s;\n" % (child_name, raw_module_name)

   187

   188

   189

def gen_mod_import(parentName, importName, dynamic=1):

   190

    # pyjs_ajax_eval("%(n)s.cache.js", null, true);

   191

    return """

   192

    pyjslib.import_module(sys.loadpath, '%(p)s', '%(n)s', %(d)d, false);

   193

    """ % ({'p': parentName, 'd': dynamic, 'n': importName}) + \

   194

        mod_var_name_decl(importName)

   195

   196

   197

class Translator(object):

   198

   199

    def __init__(self, mn, module_name, raw_module_name, src, debug, mod, output,

   200

                 dynamic=0, optimize=False,

   201

                 findFile=None):

   202

   203

        if module_name:

   204

            self.module_prefix = module_name + "."

   205

        else:

   206

            self.module_prefix = ""

   207

        self.raw_module_name = raw_module_name

   208

        src = src.replace("\r\n", "\n")

   209

        src = src.replace("\n\r", "\n")

   210

        src = src.replace("\r",   "\n")

   211

        self.src = src.split("\n")

   212

        self.debug = debug

   213

        self.imported_modules = []

   214

        self.imported_modules_as = []

   215

        self.imported_js = set()

   216

        self.top_level_functions = set()

   217

        self.top_level_classes = set()

   218

        self.top_level_vars = set()

   219

        self.local_arg_stack = [[]]

   220

        self.output = output

   221

        self.imported_classes = {}

   222

        self.method_imported_globals = set()

   223

        self.method_self = None

   224

        self.nextTupleAssignID = 1

   225

        self.dynamic = dynamic

   226

        self.optimize = optimize

   227

        self.findFile = findFile

   228

   229

        if module_name.find(".") >= 0:

   230

            vdec = ''

   231

        else:

   232

            vdec = 'var '

   233

        self.printo(UU+"%s%s = function (__mod_name__) {" % (vdec, module_name))

   234

   235

        self.printo("    if("+module_name+".__was_initialized__) return;")

   236

        self.printo("    "+UU+module_name+".__was_initialized__ = true;")

   237

        self.printo(UU+"if (__mod_name__ == null) __mod_name__ = '%s';" % (mn))

   238

        self.printo(UU+"%s.__name__ = __mod_name__;" % (raw_module_name))

   239

   240

        decl = mod_var_name_decl(raw_module_name)

   241

        if decl:

   242

            self.printo(decl)

   243

   244

        if self.debug:

   245

            haltException = self.module_prefix + "HaltException"

   246

            self.printo(haltException + ' = function () {')

   247

            self.printo('  this.message = "Program Halted";')

   248

            self.printo('  this.name = "' + haltException + '";')

   249

            self.printo('}')

   250

            self.printo('')

   251

            self.printo(haltException + ".prototype.__str__ = function()")

   252

            self.printo('{')

   253

            self.printo('return this.message ;')

   254

            self.printo('}')

   255

   256

            self.printo(haltException + ".prototype.toString = function()")

   257

            self.printo('{')

   258

            self.printo('return this.name + ": \\"" + this.message + "\\"";')

   259

            self.printo('}')

   260

   261

            isHaltFunction = self.module_prefix + "IsHaltException"

   262

            self.printo(""")

   263

    %s = function (s) {

   264

      var suffix="HaltException";

   265

      if (s.length < suffix.length) {

   266

        //alert(s + " " + suffix);

   267

        return false;

   268

      } else {

   269

        var ss = s.substring(s.length, (s.length - suffix.length));

   270

        //alert(s + " " + suffix + " " + ss);

   271

        return ss == suffix;

   272

      }

   273

    }

   274

                """ % isHaltFunction)

   275

        for child in mod.node:

   276

            if isinstance(child, ast.Function):

   277

                self.top_level_functions.add(child.name)

   278

            elif isinstance(child, ast.Class):

   279

                self.top_level_classes.add(child.name)

   280

   281

        for child in mod.node:

   282

            if isinstance(child, ast.Function):

   283

                self._function(child, False)

   284

            elif isinstance(child, ast.Class):

   285

                self._class(child)

   286

            elif isinstance(child, ast.Import):

   287

                importName = child.names[0][0]

   288

                if importName == '__pyjamas__':  # special module to help make pyjamas modules loadable in the python interpreter

   289

                    pass

   290

                elif importName.endswith('.js'):

   291

                    self.imported_js.add(importName)

   292

                else:

   293

                    self.add_imported_module(strip_py(importName))

   294

            elif isinstance(child, ast.From):

   295

                if child.modname == '__pyjamas__':  # special module to help make pyjamas modules loadable in the python interpreter

   296

                    pass

   297

                else:

   298

                    self.add_imported_module(child.modname)

   299

                    self._from(child)

   300

            elif isinstance(child, ast.Discard):

   301

                self._discard(child, None)

   302

            elif isinstance(child, ast.Assign):

   303

                self._assign(child, None, True)

   304

            elif isinstance(child, ast.AugAssign):

   305

                self._augassign(child, None)

   306

            elif isinstance(child, ast.If):

   307

                self._if(child, None)

   308

            elif isinstance(child, ast.For):

   309

                self._for(child, None)

   310

            elif isinstance(child, ast.While):

   311

                self._while(child, None)

   312

            elif isinstance(child, ast.Subscript):

   313

                self._subscript_stmt(child, None)

   314

            elif isinstance(child, ast.Global):

   315

                self._global(child, None)

   316

            elif isinstance(child, ast.Printnl):

   317

                self._print(child, None)

   318

            elif isinstance(child, ast.Print):

   319

                self._print(child, None)

   320

            elif isinstance(child, ast.TryExcept):

   321

                self._tryExcept(child, None)

   322

            elif isinstance(child, ast.Raise):

   323

                self._raise(child, None)

   324

            elif isinstance(child, ast.Stmt):

   325

                self._stmt(child, None)

   326

            else:

   327

                raise TranslationError("unsupported type (in __init__)", child)

   328

   329

        # Initialize all classes for this module

   330

        # self.printo("__"+self.modpfx()+\

   331

        #          "classes_initialize = function() {\n")

   332

        # for className in self.top_level_classes:

   333

        #    self.printo("\t"+UU+self.modpfx()+"__"+className+"_initialize();")

   334

        # self.printo("};\n")

   335

   336

        self.printo("return this;\n")

   337

        self.printo("}; /* end %s */ \n" % module_name)

   338

   339

    def printo(self, *args):

   340

        print(*args, file=self.output)

   341

   342

    def module_imports(self):

   343

        return self.imported_modules + self.imported_modules_as

   344

   345

    def add_local_arg(self, varname):

   346

        local_vars = self.local_arg_stack[-1]

   347

        if varname not in local_vars:

   348

            local_vars.append(varname)

   349

   350

    def add_imported_module(self, importName):

   351

   352

        if importName in self.imported_modules:

   353

            return

   354

        self.imported_modules.append(importName)

   355

        name = importName.split(".")

   356

        if len(name) != 1:

   357

            # add the name of the module to the namespace,

   358

            # but don't add the short name to imported_modules

   359

            # because then the short name would be attempted to be

   360

            # added to the dependencies, and it's half way up the

   361

            # module import directory structure!

   362

            child_name = name[-1]

   363

            self.imported_modules_as.append(child_name)

   364

        self.printo(gen_mod_import(self.raw_module_name,

   365

                                   strip_py(importName),

   366

                                   self.dynamic))

   367

   368

    def _default_args_handler(self, node, arg_names, current_klass,

   369

                              output=None):

   370

        if len(node.defaults):

   371

            output = output or self.output

   372

            default_pos = len(arg_names) - len(node.defaults)

   373

            if arg_names and arg_names[0] == self.method_self:

   374

                default_pos -= 1

   375

            for default_node in node.defaults:

   376

                if isinstance(default_node, ast.Const):

   377

                    default_value = self._const(default_node)

   378

                elif isinstance(default_node, ast.Name):

   379

                    default_value = self._name(default_node, current_klass)

   380

                elif isinstance(default_node, ast.UnarySub):

   381

                    default_value = self._unarysub(default_node, current_klass)

   382

                else:

   383

                    raise TranslationError("unsupported type (in _method)", default_node)

   384

   385

                default_name = arg_names[default_pos]

   386

                default_pos += 1

   387

                self.printo("    if (typeof %s == 'undefined') %s=%s;" % (default_name, default_name, default_value))

   388

   389

    def _varargs_handler(self, node, varargname, arg_names, current_klass):

   390

        self.printo("    var", varargname, '= new pyjslib.Tuple();')

   391

        self.printo("    for(var __va_arg="+str(len(arg_names))+"; __va_arg < arguments.length; __va_arg++) {")

   392

        self.printo("        var __arg = arguments[__va_arg];")

   393

        self.printo("        "+varargname+".append(__arg);")

   394

        self.printo("    }")

   395

   396

    def _kwargs_parser(self, node, function_name, arg_names, current_klass):

   397

        if len(node.defaults) or node.kwargs:

   398

            default_pos = len(arg_names) - len(node.defaults)

   399

            if arg_names and arg_names[0] == self.method_self:

   400

                default_pos -= 1

   401

            self.printo(function_name+'.parse_kwargs = function (', ", ".join(["__kwargs"]+arg_names), ") {")

   402

            for _default_node in node.defaults:

   403

                # default_value = self.expr(default_node, current_klass)

   404

                # if isinstance(default_node, ast.Const):

   405

                #     default_value = self._const(default_node)

   406

                # elif isinstance(default_node, ast.Name):

   407

                #     default_value = self._name(default_node)

   408

                # elif isinstance(default_node, ast.UnarySub):

   409

                #     default_value = self._unarysub(default_node, current_klass)

   410

                # else:

   411

                #     raise TranslationError("unsupported type (in _method)", default_node)

   412

   413

                default_name = arg_names[default_pos]

   414

                self.printo("    if (typeof %s == 'undefined')" % (default_name))

   415

                self.printo("        %s=__kwargs.%s;" % (default_name, default_name))

   416

                default_pos += 1

   417

   418

            # self._default_args_handler(node, arg_names, current_klass)

   419

            if node.kwargs:

   420

                arg_names += ["pyjslib.Dict(__kwargs)"]

   421

            self.printo("    var __r = "+"".join(["[", ", ".join(arg_names), "]"])+";")

   422

            if node.varargs:

   423

                self._varargs_handler(node, "__args", arg_names, current_klass)

   424

                self.printo("    __r.push.apply(__r, __args.getArray())")

   425

            self.printo("    return __r;")

   426

            self.printo("};")

   427

   428

    def _function(self, node, local=False):

   429

        if local:

   430

            function_name = node.name

   431

            self.add_local_arg(function_name)

   432

        else:

   433

            function_name = UU + self.modpfx() + node.name

   434

   435

        arg_names = list(node.argnames)

   436

        normal_arg_names = list(arg_names)

   437

        if node.kwargs:

   438

            kwargname = normal_arg_names.pop()

   439

        if node.varargs:

   440

            varargname = normal_arg_names.pop()

   441

        declared_arg_names = list(normal_arg_names)

   442

        if node.kwargs:

   443

            declared_arg_names.append(kwargname)

   444

   445

        function_args = "(" + ", ".join(declared_arg_names) + ")"

   446

        self.printo("%s = function%s {" % (function_name, function_args))

   447

        self._default_args_handler(node, normal_arg_names, None)

   448

   449

        local_arg_names = normal_arg_names + declared_arg_names

   450

   451

        if node.varargs:

   452

            self._varargs_handler(node, varargname, declared_arg_names, None)

   453

            local_arg_names.append(varargname)

   454

   455

        # stack of local variable names for this function call

   456

        self.local_arg_stack.append(local_arg_names)

   457

   458

        for child in node.code:

   459

            self._stmt(child, None)

   460

   461

        # remove the top local arg names

   462

        self.local_arg_stack.pop()

   463

   464

        # we need to return null always, so it is not undefined

   465

        lastStmt = [p for p in node.code][-1]

   466

        if not isinstance(lastStmt, ast.Return):

   467

            if not self._isNativeFunc(lastStmt):

   468

                self.printo("    return null;")

   469

   470

        self.printo("};")

   471

        self.printo("%s.__name__ = '%s';\n" % (function_name, node.name))

   472

   473

        self._kwargs_parser(node, function_name, normal_arg_names, None)

   474

   475

    def _return(self, node, current_klass):

   476

        expr = self.expr(node.value, current_klass)

   477

        # in python a function call always returns None, so we do it

   478

        # here too

   479

        self.printo("    return " + expr + ";")

   480

   481

    def _break(self, node, current_klass):

   482

        self.printo("    break;")

   483

   484

    def _continue(self, node, current_klass):

   485

        self.printo("    continue;")

   486

   487

    def _callfunc(self, v, current_klass):

   488

   489

        if isinstance(v.node, ast.Name):

   490

            if v.node.name in self.top_level_functions:

   491

                call_name = self.modpfx() + v.node.name

   492

            elif v.node.name in self.top_level_classes:

   493

                call_name = self.modpfx() + v.node.name

   494

            elif v.node.name in self.imported_classes:

   495

                call_name = self.imported_classes[v.node.name] + '.' + v.node.name

   496

            elif v.node.name in PYJSLIB_BUILTIN_FUNCTIONS:

   497

                call_name = 'pyjslib.' + v.node.name

   498

            elif v.node.name in PYJSLIB_BUILTIN_CLASSES:

   499

                name = pyjs_builtin_remap(v.node.name)

   500

                call_name = 'pyjslib.' + name

   501

            elif v.node.name == "callable":

   502

                call_name = "pyjslib.isFunction"

   503

            else:

   504

                call_name = v.node.name

   505

            call_args = []

   506

        elif isinstance(v.node, ast.Getattr):

   507

            attr_name = v.node.attrname

   508

   509

            if isinstance(v.node.expr, ast.Name):

   510

                call_name = self._name2(v.node.expr, current_klass, attr_name)

   511

                call_args = []

   512

            elif isinstance(v.node.expr, ast.Getattr):

   513

                call_name = self._getattr2(v.node.expr, current_klass, attr_name)