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

from types import StringType

    21

import compiler

    22

from compiler import ast

    23

import os

    24

import copy

    25

from builtins import str as text

    27

from six.moves import cStringIO

    28

    29

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

    30

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

    31

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

    32

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

    33

#

    34

# over-rides can be done by either explicitly modifying

    35

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

    36

    37

prefix = sys.prefix

    38

    39

if 'PYJSPREFIX' in os.environ:

    40

    prefix = os.environ['PYJSPREFIX']

    41

    42

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

    43

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

    44

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

    45

# in compiling standard python modules into javascript!

    46

    47

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

    48

    49

if 'PYJSPATH' in os.environ:

    50

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

    51

        p = os.path.abspath(p)

    52

        if os.path.isdir(p):

    53

            path.append(p)

    54

    55

# this is the python function used to wrap native javascript

    56

NATIVE_JS_FUNC_NAME = "JS"

    57

    58

UU = ""

    59

    60

PYJSLIB_BUILTIN_FUNCTIONS = ("cmp",

    61

                             "map",

    62

                             "filter",

    63

                             "dir",

    64

                             "getattr",

    65

                             "setattr",

    66

                             "hasattr",

    67

                             "int",

    68

                             "float",

    69

                             "str",

    70

                             "repr",

    71

                             "range",

    72

                             "len",

    73

                             "hash",

    74

                             "abs",

    75

                             "ord",

    76

                             "chr",

    77

                             "enumerate",

    78

                             "min",

    79

                             "max",

    80

                             "bool",

    81

                             "type",

    82

                             "isinstance")

    83

    84

PYJSLIB_BUILTIN_CLASSES = ("BaseException",

    85

                           "Exception",

    86

                           "StandardError",

    87

                           "StopIteration",

    88

                           "AttributeError",

    89

                           "TypeError",

    90

                           "KeyError",

    91

                           "LookupError",

    92

                           "list",

    93

                           "dict",

    94

                           "object",

    95

                           "tuple")

    96

    97

    98

def pyjs_builtin_remap(name):

    99

    # XXX HACK!

   100

    if name == 'list':

   101

        name = 'List'

   102

    if name == 'object':

   103

        name = '__Object'

   104

    if name == 'dict':

   105

        name = 'Dict'

   106

    if name == 'tuple':

   107

        name = 'Tuple'

   108

    return name

   109

   110

   111

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

   112

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

   113

# problems.

   114

PYJS_GLOBAL_VARS = ("console")

   115

   116

# This is taken from the django project.

   117

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

   118

JS_ESCAPES = (

   119

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

   120

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

   121

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

   122

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

   123

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

   124

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

   125

    (';', r'\x3B')

   126

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

   127

   128

   129

def escapejs(value):

   130

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

   131

    for bad, good in JS_ESCAPES:

   132

        value = value.replace(bad, good)

   133

    return value

   134

   135

   136

def uuprefix(name, leave_alone=0):

   137

    name = name.split(".")

   138

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

   139

    return '.'.join(name)

   140

   141

   142

class Klass(object):

   143

   144

    klasses = {}

   145

   146

    def __init__(self, name, name_):

   147

        self.name = name

   148

        self.name_ = name_

   149

        self.klasses[name] = self

   150

        self.functions = set()

   151

   152

    def set_base(self, base_name):

   153

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

   154

   155

    def add_function(self, function_name):

   156

        self.functions.add(function_name)

   157

   158

   159

class TranslationError(Exception):

   160

    def __init__(self, message, node):

   161

        Exception.__init__(self)

   162

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

   163

   164

    def __str__(self):

   165

        return self.message

   166

   167

   168

def strip_py(name):

   169

    return name

   170

   171

   172

def mod_var_name_decl(raw_module_name):

   173

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

   174

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

   175

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

   176

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

   177

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

   178

   179

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

   180

        to see: gen_mod_import and mod_var_name_decl might have

   181

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

   182

    """

   183

    name = raw_module_name.split(".")

   184

    if len(name) == 1:

   185

        return ''

   186

    child_name = name[-1]

   187

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

   188

   189

   190

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

   191

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

   192

    return """

   193

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

   194

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

   195

        mod_var_name_decl(importName)

   196

   197

   198

class Translator(object):

   199

   200

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

   201

                 dynamic=0, optimize=False,

   202

                 findFile=None):

   203

   204

        if module_name:

   205

            self.module_prefix = module_name + "."

   206

        else:

   207

            self.module_prefix = ""

   208

        self.raw_module_name = raw_module_name

   209

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

   210

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

   211

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

   212

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

   213

        self.debug = debug

   214

        self.imported_modules = []

   215

        self.imported_modules_as = []

   216

        self.imported_js = set()

   217

        self.top_level_functions = set()

   218

        self.top_level_classes = set()

   219

        self.top_level_vars = set()

   220

        self.local_arg_stack = [[]]

   221

        self.output = output

   222

        self.imported_classes = {}

   223

        self.method_imported_globals = set()

   224

        self.method_self = None

   225

        self.nextTupleAssignID = 1

   226

        self.dynamic = dynamic

   227

        self.optimize = optimize

   228

        self.findFile = findFile

   229

   230

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

   231

            vdec = ''

   232

        else:

   233

            vdec = 'var '

   234

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

   235

   236

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

   237

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

   238

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

   239

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

   240

   241

        decl = mod_var_name_decl(raw_module_name)

   242

        if decl:

   243

            self.printo(decl)

   244

   245

        if self.debug:

   246

            haltException = self.module_prefix + "HaltException"

   247

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

   248

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

   249

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

   250

            self.printo('}')

   251

            self.printo('')

   252

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

   253

            self.printo('{')

   254

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

   255

            self.printo('}')

   256

   257

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

   258

            self.printo('{')

   259

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

   260

            self.printo('}')

   261

   262

            isHaltFunction = self.module_prefix + "IsHaltException"

   263

            self.printo(""")

   264

    %s = function (s) {

   265

      var suffix="HaltException";

   266

      if (s.length < suffix.length) {

   267

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

   268

        return false;

   269

      } else {

   270

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

   271

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

   272

        return ss == suffix;

   273

      }

   274

    }

   275

                """ % isHaltFunction)

   276

        for child in mod.node:

   277

            if isinstance(child, ast.Function):

   278

                self.top_level_functions.add(child.name)

   279

            elif isinstance(child, ast.Class):

   280

                self.top_level_classes.add(child.name)

   281

   282

        for child in mod.node:

   283

            if isinstance(child, ast.Function):

   284

                self._function(child, False)

   285

            elif isinstance(child, ast.Class):

   286

                self._class(child)

   287

            elif isinstance(child, ast.Import):

   288

                importName = child.names[0][0]

   289

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

   290

                    pass

   291

                elif importName.endswith('.js'):

   292

                    self.imported_js.add(importName)

   293

                else:

   294

                    self.add_imported_module(strip_py(importName))

   295

            elif isinstance(child, ast.From):

   296

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

   297

                    pass

   298

                else:

   299

                    self.add_imported_module(child.modname)

   300

                    self._from(child)

   301

            elif isinstance(child, ast.Discard):

   302

                self._discard(child, None)

   303

            elif isinstance(child, ast.Assign):

   304

                self._assign(child, None, True)

   305

            elif isinstance(child, ast.AugAssign):

   306

                self._augassign(child, None)

   307

            elif isinstance(child, ast.If):

   308

                self._if(child, None)

   309

            elif isinstance(child, ast.For):

   310

                self._for(child, None)

   311

            elif isinstance(child, ast.While):

   312

                self._while(child, None)

   313

            elif isinstance(child, ast.Subscript):

   314

                self._subscript_stmt(child, None)

   315

            elif isinstance(child, ast.Global):

   316

                self._global(child, None)

   317

            elif isinstance(child, ast.Printnl):

   318

                self._print(child, None)

   319

            elif isinstance(child, ast.Print):

   320

                self._print(child, None)

   321

            elif isinstance(child, ast.TryExcept):

   322

                self._tryExcept(child, None)

   323

            elif isinstance(child, ast.Raise):

   324

                self._raise(child, None)

   325

            elif isinstance(child, ast.Stmt):

   326

                self._stmt(child, None)

   327

            else:

   328

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

   329

   330

        # Initialize all classes for this module

   331

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

   332

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

   333

        # for className in self.top_level_classes:

   334

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

   335

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

   336

   337

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

   338

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

   339

   340

    def printo(self, *args):

   341

        print(*args, file=self.output)

   342

   343

    def module_imports(self):

   344

        return self.imported_modules + self.imported_modules_as

   345

   346

    def add_local_arg(self, varname):

   347

        local_vars = self.local_arg_stack[-1]

   348

        if varname not in local_vars:

   349

            local_vars.append(varname)

   350

   351

    def add_imported_module(self, importName):

   352

   353

        if importName in self.imported_modules:

   354

            return

   355

        self.imported_modules.append(importName)

   356

        name = importName.split(".")

   357

        if len(name) != 1:

   358

            # add the name of the module to the namespace,

   359

            # but don't add the short name to imported_modules

   360

            # because then the short name would be attempted to be

   361

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

   362

            # module import directory structure!

   363

            child_name = name[-1]

   364

            self.imported_modules_as.append(child_name)

   365

        self.printo(gen_mod_import(self.raw_module_name,

   366

                                   strip_py(importName),

   367

                                   self.dynamic))

   368

   369

    def _default_args_handler(self, node, arg_names, current_klass,

   370

                              output=None):

   371

        if len(node.defaults):

   372

            output = output or self.output

   373

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

   374

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

   375

                default_pos -= 1

   376

            for default_node in node.defaults:

   377

                if isinstance(default_node, ast.Const):

   378

                    default_value = self._const(default_node)

   379

                elif isinstance(default_node, ast.Name):

   380

                    default_value = self._name(default_node, current_klass)

   381

                elif isinstance(default_node, ast.UnarySub):

   382

                    default_value = self._unarysub(default_node, current_klass)

   383

                else:

   384

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

   385

   386

                default_name = arg_names[default_pos]

   387

                default_pos += 1

   388

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

   389

   390

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

   391

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

   392

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

   393

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

   394

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

   395

        self.printo("    }")

   396

   397

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

   398

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

   399

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

   400

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

   401

                default_pos -= 1

   402

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

   403

            for _default_node in node.defaults:

   404

                # default_value = self.expr(default_node, current_klass)

   405

                # if isinstance(default_node, ast.Const):

   406

                #     default_value = self._const(default_node)

   407

                # elif isinstance(default_node, ast.Name):

   408

                #     default_value = self._name(default_node)

   409

                # elif isinstance(default_node, ast.UnarySub):

   410

                #     default_value = self._unarysub(default_node, current_klass)

   411

                # else:

   412

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

   413

   414

                default_name = arg_names[default_pos]

   415

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

   416

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

   417

                default_pos += 1

   418

   419

            # self._default_args_handler(node, arg_names, current_klass)

   420

            if node.kwargs:

   421

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

   422

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

   423

            if node.varargs:

   424

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

   425

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

   426

            self.printo("    return __r;")

   427

            self.printo("};")

   428

   429

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

   430

        if local:

   431

            function_name = node.name

   432

            self.add_local_arg(function_name)

   433

        else:

   434

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

   435

   436

        arg_names = list(node.argnames)

   437

        normal_arg_names = list(arg_names)

   438

        if node.kwargs:

   439

            kwargname = normal_arg_names.pop()

   440

        if node.varargs:

   441

            varargname = normal_arg_names.pop()

   442

        declared_arg_names = list(normal_arg_names)

   443

        if node.kwargs:

   444

            declared_arg_names.append(kwargname)

   445

   446

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

   447

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

   448

        self._default_args_handler(node, normal_arg_names, None)

   449

   450

        local_arg_names = normal_arg_names + declared_arg_names

   451

   452

        if node.varargs:

   453

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

   454

            local_arg_names.append(varargname)

   455

   456

        # stack of local variable names for this function call

   457

        self.local_arg_stack.append(local_arg_names)

   458

   459

        for child in node.code:

   460

            self._stmt(child, None)

   461

   462

        # remove the top local arg names

   463

        self.local_arg_stack.pop()

   464

   465

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

   466

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

   467

        if not isinstance(lastStmt, ast.Return):

   468

            if not self._isNativeFunc(lastStmt):

   469

                self.printo("    return null;")

   470

   471

        self.printo("};")

   472

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

   473

   474

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

   475

   476

    def _return(self, node, current_klass):

   477

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

   478

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

   479

        # here too

   480

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

   481

   482

    def _break(self, node, current_klass):

   483

        self.printo("    break;")

   484

   485

    def _continue(self, node, current_klass):

   486

        self.printo("    continue;")

   487

   488

    def _callfunc(self, v, current_klass):

   489

   490

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

   491

            if v.node.name in self.top_level_functions:

   492

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

   493

            elif v.node.name in self.top_level_classes:

   494

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

   495

            elif v.node.name in self.imported_classes:

   496

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

   497

            elif v.node.name in PYJSLIB_BUILTIN_FUNCTIONS:

   498

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

   499

            elif v.node.name in PYJSLIB_BUILTIN_CLASSES:

   500

                name = pyjs_builtin_remap(v.node.name)

   501

                call_name = 'pyjslib.' + name

   502

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

   503

                call_name = "pyjslib.isFunction"

   504

            else:

   505

                call_name = v.node.name

   506

            call_args = []

   507

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

   508

            attr_name = v.node.attrname

   509

   510

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

   511

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

   512

                call_args = []

   513

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