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

    17

from __future__ import print_function

    18

import sys

    19

from types import StringType

    20

import compiler

    21

from compiler import ast

    22

import os

    23

import copy

    24

import cStringIO

    25

    26

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

    27

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

    28

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

    29

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

    30

#

    31

# over-rides can be done by either explicitly modifying

    32

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

    33

    34

prefix = sys.prefix

    35

    36

if 'PYJSPREFIX' in os.environ:

    37

    prefix = os.environ['PYJSPREFIX']

    38

    39

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

    40

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

    41

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

    42

# in compiling standard python modules into javascript!

    43

    44

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

    45

    46

if 'PYJSPATH' in os.environ:

    47

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

    48

        p = os.path.abspath(p)

    49

        if os.path.isdir(p):

    50

            path.append(p)

    51

    52

# this is the python function used to wrap native javascript

    53

NATIVE_JS_FUNC_NAME = "JS"

    54

    55

UU = ""

    56

    57

PYJSLIB_BUILTIN_FUNCTIONS = ("cmp",

    58

                             "map",

    59

                             "filter",

    60

                             "dir",

    61

                             "getattr",

    62

                             "setattr",

    63

                             "hasattr",

    64

                             "int",

    65

                             "float",

    66

                             "str",

    67

                             "repr",

    68

                             "range",

    69

                             "len",

    70

                             "hash",

    71

                             "abs",

    72

                             "ord",

    73

                             "chr",

    74

                             "enumerate",

    75

                             "min",

    76

                             "max",

    77

                             "bool",

    78

                             "type",

    79

                             "isinstance")

    80

    81

PYJSLIB_BUILTIN_CLASSES = ("BaseException",

    82

                           "Exception",

    83

                           "StandardError",

    84

                           "StopIteration",

    85

                           "AttributeError",

    86

                           "TypeError",

    87

                           "KeyError",

    88

                           "LookupError",

    89

                           "list",

    90

                           "dict",

    91

                           "object",

    92

                           "tuple")

    93

    94

    95

def pyjs_builtin_remap(name):

    96

    # XXX HACK!

    97

    if name == 'list':

    98

        name = 'List'

    99

    if name == 'object':

   100

        name = '__Object'

   101

    if name == 'dict':

   102

        name = 'Dict'

   103

    if name == 'tuple':

   104

        name = 'Tuple'

   105

    return name

   106

   107

   108

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

   109

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

   110

# problems.

   111

PYJS_GLOBAL_VARS = ("console")

   112

   113

# This is taken from the django project.

   114

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

   115

JS_ESCAPES = (

   116

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

   117

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

   118

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

   119

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

   120

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

   121

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

   122

    (';', r'\x3B')

   123

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

   124

   125

   126

def escapejs(value):

   127

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

   128

    for bad, good in JS_ESCAPES:

   129

        value = value.replace(bad, good)

   130

    return value

   131

   132

   133

def uuprefix(name, leave_alone=0):

   134

    name = name.split(".")

   135

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

   136

    return '.'.join(name)

   137

   138

   139

class Klass:

   140

   141

    klasses = {}

   142

   143

    def __init__(self, name, name_):

   144

        self.name = name

   145

        self.name_ = name_

   146

        self.klasses[name] = self

   147

        self.functions = set()

   148

   149

    def set_base(self, base_name):

   150

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

   151

   152

    def add_function(self, function_name):

   153

        self.functions.add(function_name)

   154

   155

   156

class TranslationError(Exception):

   157

    def __init__(self, message, node):

   158

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

   159

   160

    def __str__(self):

   161

        return self.message

   162

   163

   164

def strip_py(name):

   165

    return name

   166

   167

   168

def mod_var_name_decl(raw_module_name):

   169

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

   170

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

   171

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

   172

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

   173

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

   174

   175

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

   176

        to see: gen_mod_import and mod_var_name_decl might have

   177

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

   178

    """

   179

    name = raw_module_name.split(".")

   180

    if len(name) == 1:

   181

        return ''

   182

    child_name = name[-1]

   183

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

   184

   185

   186

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

   187

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

   188

    return """

   189

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

   190

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

   191

        mod_var_name_decl(importName)

   192

   193

   194

class Translator:

   195

   196

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

   197

                 dynamic=0, optimize=False,

   198

                 findFile=None):

   199

   200

        if module_name:

   201

            self.module_prefix = module_name + "."

   202

        else:

   203

            self.module_prefix = ""

   204

        self.raw_module_name = raw_module_name

   205

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

   206

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

   207

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

   208

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

   209

        self.debug = debug

   210

        self.imported_modules = []

   211

        self.imported_modules_as = []

   212

        self.imported_js = set()

   213

        self.top_level_functions = set()

   214

        self.top_level_classes = set()

   215

        self.top_level_vars = set()

   216

        self.local_arg_stack = [[]]

   217

        self.output = output

   218

        self.imported_classes = {}

   219

        self.method_imported_globals = set()

   220

        self.method_self = None

   221

        self.nextTupleAssignID = 1

   222

        self.dynamic = dynamic

   223

        self.optimize = optimize

   224

        self.findFile = findFile

   225

   226

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

   227

            vdec = ''

   228

        else:

   229

            vdec = 'var '

   230

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

   231

   232

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

   233

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

   234

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

   235

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

   236

   237

        decl = mod_var_name_decl(raw_module_name)

   238

        if decl:

   239

            self.printo(decl)

   240

   241

        if self.debug:

   242

            haltException = self.module_prefix + "HaltException"

   243

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

   244

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

   245

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

   246

            self.printo('}')

   247

            self.printo('')

   248

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

   249

            self.printo('{')

   250

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

   251

            self.printo('}')

   252

   253

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

   254

            self.printo('{')

   255

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

   256

            self.printo('}')

   257

   258

            isHaltFunction = self.module_prefix + "IsHaltException"

   259

            self.printo(""")

   260

    %s = function (s) {

   261

      var suffix="HaltException";

   262

      if (s.length < suffix.length) {

   263

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

   264

        return false;

   265

      } else {

   266

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

   267

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

   268

        return ss == suffix;

   269

      }

   270

    }

   271

                """ % isHaltFunction)

   272

        for child in mod.node:

   273

            if isinstance(child, ast.Function):

   274

                self.top_level_functions.add(child.name)

   275

            elif isinstance(child, ast.Class):

   276

                self.top_level_classes.add(child.name)

   277

   278

        for child in mod.node:

   279

            if isinstance(child, ast.Function):

   280

                self._function(child, False)

   281

            elif isinstance(child, ast.Class):

   282

                self._class(child)

   283

            elif isinstance(child, ast.Import):

   284

                importName = child.names[0][0]

   285

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

   286

                    pass

   287

                elif importName.endswith('.js'):

   288

                    self.imported_js.add(importName)

   289

                else:

   290

                    self.add_imported_module(strip_py(importName))

   291

            elif isinstance(child, ast.From):

   292

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

   293

                    pass

   294

                else:

   295

                    self.add_imported_module(child.modname)

   296

                    self._from(child)

   297

            elif isinstance(child, ast.Discard):

   298

                self._discard(child, None)

   299

            elif isinstance(child, ast.Assign):

   300

                self._assign(child, None, True)

   301

            elif isinstance(child, ast.AugAssign):

   302

                self._augassign(child, None)

   303

            elif isinstance(child, ast.If):

   304

                self._if(child, None)

   305

            elif isinstance(child, ast.For):

   306

                self._for(child, None)

   307

            elif isinstance(child, ast.While):

   308

                self._while(child, None)

   309

            elif isinstance(child, ast.Subscript):

   310

                self._subscript_stmt(child, None)

   311

            elif isinstance(child, ast.Global):

   312

                self._global(child, None)

   313

            elif isinstance(child, ast.Printnl):

   314

                self._print(child, None)

   315

            elif isinstance(child, ast.Print):

   316

                self._print(child, None)

   317

            elif isinstance(child, ast.TryExcept):

   318

                self._tryExcept(child, None)

   319

            elif isinstance(child, ast.Raise):

   320

                self._raise(child, None)

   321

            elif isinstance(child, ast.Stmt):

   322

                self._stmt(child, None)

   323

            else:

   324

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

   325

   326

        # Initialize all classes for this module

   327

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

   328

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

   329

        # for className in self.top_level_classes:

   330

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

   331

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

   332

   333

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

   334

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

   335

   336

    def printo(self, *args):

   337

        print(*args, file=self.output)

   338

   339

    def module_imports(self):

   340

        return self.imported_modules + self.imported_modules_as

   341

   342

    def add_local_arg(self, varname):

   343

        local_vars = self.local_arg_stack[-1]

   344

        if varname not in local_vars:

   345

            local_vars.append(varname)

   346

   347

    def add_imported_module(self, importName):

   348

   349

        if importName in self.imported_modules:

   350

            return

   351

        self.imported_modules.append(importName)

   352

        name = importName.split(".")

   353

        if len(name) != 1:

   354

            # add the name of the module to the namespace,

   355

            # but don't add the short name to imported_modules

   356

            # because then the short name would be attempted to be

   357

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

   358

            # module import directory structure!

   359

            child_name = name[-1]

   360

            self.imported_modules_as.append(child_name)

   361

        self.printo(gen_mod_import(self.raw_module_name,

   362

                                   strip_py(importName),

   363

                                   self.dynamic))

   364

   365

    def _default_args_handler(self, node, arg_names, current_klass,

   366

                              output=None):

   367

        if len(node.defaults):

   368

            output = output or self.output

   369

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

   370

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

   371

                default_pos -= 1

   372

            for default_node in node.defaults:

   373

                if isinstance(default_node, ast.Const):

   374

                    default_value = self._const(default_node)

   375

                elif isinstance(default_node, ast.Name):

   376

                    default_value = self._name(default_node, current_klass)

   377

                elif isinstance(default_node, ast.UnarySub):

   378

                    default_value = self._unarysub(default_node, current_klass)

   379

                else:

   380

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

   381

   382

                default_name = arg_names[default_pos]

   383

                default_pos += 1

   384

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

   385

   386

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

   387

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

   388

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

   389

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

   390

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

   391

        self.printo("    }")

   392

   393

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

   394

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

   395

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

   396

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

   397

                default_pos -= 1

   398

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

   399

            for default_node in node.defaults:

   400

                default_value = self.expr(default_node, current_klass)

   401

#                if isinstance(default_node, ast.Const):

   402

#                    default_value = self._const(default_node)

   403

#                elif isinstance(default_node, ast.Name):

   404

#                    default_value = self._name(default_node)

   405

#                elif isinstance(default_node, ast.UnarySub):

   406

#                    default_value = self._unarysub(default_node, current_klass)

   407

#                else:

   408

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

   409

   410

                default_name = arg_names[default_pos]

   411

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

   412

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

   413

                default_pos += 1

   414

   415

            # self._default_args_handler(node, arg_names, current_klass)

   416

            if node.kwargs:

   417

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

   418

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

   419

            if node.varargs:

   420

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

   421

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

   422

            self.printo("    return __r;")

   423

            self.printo("};")

   424

   425

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

   426

        if local:

   427

            function_name = node.name

   428

            self.add_local_arg(function_name)

   429

        else:

   430

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

   431

   432

        arg_names = list(node.argnames)

   433

        normal_arg_names = list(arg_names)

   434

        if node.kwargs:

   435

            kwargname = normal_arg_names.pop()

   436

        if node.varargs:

   437

            varargname = normal_arg_names.pop()

   438

        declared_arg_names = list(normal_arg_names)

   439

        if node.kwargs:

   440

            declared_arg_names.append(kwargname)

   441

   442

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

   443

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

   444

        self._default_args_handler(node, normal_arg_names, None)

   445

   446

        local_arg_names = normal_arg_names + declared_arg_names

   447

   448

        if node.varargs:

   449

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

   450

            local_arg_names.append(varargname)

   451

   452

        # stack of local variable names for this function call

   453

        self.local_arg_stack.append(local_arg_names)

   454

   455

        for child in node.code:

   456

            self._stmt(child, None)

   457

   458

        # remove the top local arg names

   459

        self.local_arg_stack.pop()

   460

   461

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

   462

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

   463

        if not isinstance(lastStmt, ast.Return):

   464

            if not self._isNativeFunc(lastStmt):

   465

                self.printo("    return null;")

   466

   467

        self.printo("};")

   468

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

   469

   470

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

   471

   472

    def _return(self, node, current_klass):

   473

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

   474

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

   475

        # here too

   476

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

   477

   478

    def _break(self, node, current_klass):

   479

        self.printo("    break;")

   480

   481

    def _continue(self, node, current_klass):

   482

        self.printo("    continue;")

   483

   484

    def _callfunc(self, v, current_klass):

   485

   486

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

   487

            if v.node.name in self.top_level_functions:

   488

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

   489

            elif v.node.name in self.top_level_classes:

   490

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

   491

            elif v.node.name in self.imported_classes:

   492

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

   493

            elif v.node.name in PYJSLIB_BUILTIN_FUNCTIONS:

   494

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

   495

            elif v.node.name in PYJSLIB_BUILTIN_CLASSES:

   496

                name = pyjs_builtin_remap(v.node.name)

   497

                call_name = 'pyjslib.' + name

   498

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

   499

                call_name = "pyjslib.isFunction"

   500

            else:

   501

                call_name = v.node.name

   502

            call_args = []

   503

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

   504

            attr_name = v.node.attrname

   505

   506

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

   507

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

   508

                call_args = []

   509

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

   510

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

   511

                call_args = []

   512

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

   513

                call_name = self._callfunc(v.node.expr, current_klass) + "." + v.node.attrname

   514

                call_args = []