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

import sys

    18

from types import StringType

    19

import compiler

    20

from compiler import ast

    21

import os

    22

import copy

    23

import cStringIO

    24

    25

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

    26

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

    27

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

    28

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

    29

#

    30

# over-rides can be done by either explicitly modifying

    31

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

    32

    33

prefix = sys.prefix

    34

    35

if 'PYJSPREFIX' in os.environ:

    36

    prefix = os.environ['PYJSPREFIX']

    37

    38

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

    39

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

    40

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

    41

# in compiling standard python modules into javascript!

    42

    43

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

    44

    45

if 'PYJSPATH' in os.environ:

    46

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

    47

        p = os.path.abspath(p)

    48

        if os.path.isdir(p):

    49

            path.append(p)

    50

    51

# this is the python function used to wrap native javascript

    52

NATIVE_JS_FUNC_NAME = "JS"

    53

    54

UU = ""

    55

    56

PYJSLIB_BUILTIN_FUNCTIONS = ("cmp",

    57

                             "map",

    58

                             "filter",

    59

                             "dir",

    60

                             "getattr",

    61

                             "setattr",

    62

                             "hasattr",

    63

                             "int",

    64

                             "float",

    65

                             "str",

    66

                             "repr",

    67

                             "range",

    68

                             "len",

    69

                             "hash",

    70

                             "abs",

    71

                             "ord",

    72

                             "chr",

    73

                             "enumerate",

    74

                             "min",

    75

                             "max",

    76

                             "bool",

    77

                             "type",

    78

                             "isinstance")

    79

    80

PYJSLIB_BUILTIN_CLASSES = ("BaseException",

    81

                           "Exception",

    82

                           "StandardError",

    83

                           "StopIteration",

    84

                           "AttributeError",

    85

                           "TypeError",

    86

                           "KeyError",

    87

                           "LookupError",

    88

                           "list",

    89

                           "dict",

    90

                           "object",

    91

                           "tuple")

    92

    93

    94

def pyjs_builtin_remap(name):

    95

    # XXX HACK!

    96

    if name == 'list':

    97

        name = 'List'

    98

    if name == 'object':

    99

        name = '__Object'

   100

    if name == 'dict':

   101

        name = 'Dict'

   102

    if name == 'tuple':

   103

        name = 'Tuple'

   104

    return name

   105

   106

   107

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

   108

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

   109

# problems.

   110

PYJS_GLOBAL_VARS = ("console")

   111

   112

# This is taken from the django project.

   113

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

   114

JS_ESCAPES = (

   115

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

   116

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

   117

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

   118

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

   119

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

   120

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

   121

    (';', r'\x3B')

   122

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

   123

   124

   125

def escapejs(value):

   126

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

   127

    for bad, good in JS_ESCAPES:

   128

        value = value.replace(bad, good)

   129

    return value

   130

   131

   132

def uuprefix(name, leave_alone=0):

   133

    name = name.split(".")

   134

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

   135

    return '.'.join(name)

   136

   137

   138

class Klass:

   139

   140

    klasses = {}

   141

   142

    def __init__(self, name, name_):

   143

        self.name = name

   144

        self.name_ = name_

   145

        self.klasses[name] = self

   146

        self.functions = set()

   147

   148

    def set_base(self, base_name):

   149

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

   150

   151

    def add_function(self, function_name):

   152

        self.functions.add(function_name)

   153

   154

   155

class TranslationError(Exception):

   156

    def __init__(self, message, node):

   157

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

   158

   159

    def __str__(self):

   160

        return self.message

   161

   162

   163

def strip_py(name):

   164

    return name

   165

   166

   167

def mod_var_name_decl(raw_module_name):

   168

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

   169

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

   170

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

   171

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

   172

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

   173

   174

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

   175

        to see: gen_mod_import and mod_var_name_decl might have

   176

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

   177

    """

   178

    name = raw_module_name.split(".")

   179

    if len(name) == 1:

   180

        return ''

   181

    child_name = name[-1]

   182

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

   183

   184

   185

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

   186

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

   187

    return """

   188

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

   189

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

   190

        mod_var_name_decl(importName)

   191

   192

   193

class Translator:

   194

   195

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

   196

                 dynamic=0, optimize=False,

   197

                 findFile=None):

   198

   199

        if module_name:

   200

            self.module_prefix = module_name + "."

   201

        else:

   202

            self.module_prefix = ""

   203

        self.raw_module_name = raw_module_name

   204

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

   205

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

   206

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

   207

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

   208

        self.debug = debug

   209

        self.imported_modules = []

   210

        self.imported_modules_as = []

   211

        self.imported_js = set()

   212

        self.top_level_functions = set()

   213

        self.top_level_classes = set()

   214

        self.top_level_vars = set()

   215

        self.local_arg_stack = [[]]

   216

        self.output = output

   217

        self.imported_classes = {}

   218

        self.method_imported_globals = set()

   219

        self.method_self = None

   220

        self.nextTupleAssignID = 1

   221

        self.dynamic = dynamic

   222

        self.optimize = optimize

   223

        self.findFile = findFile

   224

   225

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

   226

            vdec = ''

   227

        else:

   228

            vdec = 'var '

   229

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

   230

   231

        print >>self.output, "    if("+module_name+".__was_initialized__) return;"

   232

        print >>self.output, "    "+UU+module_name+".__was_initialized__ = true;"

   233

        print >>self.output, UU+"if (__mod_name__ == null) __mod_name__ = '%s';" % (mn)

   234

        print >>self.output, UU+"%s.__name__ = __mod_name__;" % (raw_module_name)

   235

   236

        decl = mod_var_name_decl(raw_module_name)

   237

        if decl:

   238

            print >>self.output, decl

   239

   240

        if self.debug:

   241

            haltException = self.module_prefix + "HaltException"

   242

            print >>self.output, haltException + ' = function () {'

   243

            print >>self.output, '  this.message = "Program Halted";'

   244

            print >>self.output, '  this.name = "' + haltException + '";'

   245

            print >>self.output, '}'

   246

            print >>self.output, ''

   247

            print >>self.output, haltException + ".prototype.__str__ = function()"

   248

            print >>self.output, '{'

   249

            print >>self.output, 'return this.message ;'

   250

            print >>self.output, '}'

   251

   252

            print >>self.output, haltException + ".prototype.toString = function()"

   253

            print >>self.output, '{'

   254

            print >>self.output, 'return this.name + ": \\"" + this.message + "\\"";'

   255

            print >>self.output, '}'

   256

   257

            isHaltFunction = self.module_prefix + "IsHaltException"

   258

            print >>self.output, """

   259

    %s = function (s) {

   260

      var suffix="HaltException";

   261

      if (s.length < suffix.length) {

   262

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

   263

        return false;

   264

      } else {

   265

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

   266

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

   267

        return ss == suffix;

   268

      }

   269

    }

   270

                """ % isHaltFunction

   271

        for child in mod.node:

   272

            if isinstance(child, ast.Function):

   273

                self.top_level_functions.add(child.name)

   274

            elif isinstance(child, ast.Class):

   275

                self.top_level_classes.add(child.name)

   276

   277

        for child in mod.node:

   278

            if isinstance(child, ast.Function):

   279

                self._function(child, False)

   280

            elif isinstance(child, ast.Class):

   281

                self._class(child)

   282

            elif isinstance(child, ast.Import):

   283

                importName = child.names[0][0]

   284

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

   285

                    pass

   286

                elif importName.endswith('.js'):

   287

                    self.imported_js.add(importName)

   288

                else:

   289

                    self.add_imported_module(strip_py(importName))

   290

            elif isinstance(child, ast.From):

   291

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

   292

                    pass

   293

                else:

   294

                    self.add_imported_module(child.modname)

   295

                    self._from(child)

   296

            elif isinstance(child, ast.Discard):

   297

                self._discard(child, None)

   298

            elif isinstance(child, ast.Assign):

   299

                self._assign(child, None, True)

   300

            elif isinstance(child, ast.AugAssign):

   301

                self._augassign(child, None)

   302

            elif isinstance(child, ast.If):

   303

                self._if(child, None)

   304

            elif isinstance(child, ast.For):

   305

                self._for(child, None)

   306

            elif isinstance(child, ast.While):

   307

                self._while(child, None)

   308

            elif isinstance(child, ast.Subscript):

   309

                self._subscript_stmt(child, None)

   310

            elif isinstance(child, ast.Global):

   311

                self._global(child, None)

   312

            elif isinstance(child, ast.Printnl):

   313

                self._print(child, None)

   314

            elif isinstance(child, ast.Print):

   315

                self._print(child, None)

   316

            elif isinstance(child, ast.TryExcept):

   317

                self._tryExcept(child, None)

   318

            elif isinstance(child, ast.Raise):

   319

                self._raise(child, None)

   320

            elif isinstance(child, ast.Stmt):

   321

                self._stmt(child, None)

   322

            else:

   323

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

   324

   325

        # Initialize all classes for this module

   326

        # print >> self.output, "__"+self.modpfx()+\

   327

        #          "classes_initialize = function() {\n"

   328

        # for className in self.top_level_classes:

   329

        #    print >> self.output, "\t"+UU+self.modpfx()+"__"+className+"_initialize();"

   330

        # print >> self.output, "};\n"

   331

   332

        print >> self.output, "return this;\n"

   333

        print >> self.output, "}; /* end %s */ \n" % module_name

   334

   335

    def module_imports(self):

   336

        return self.imported_modules + self.imported_modules_as

   337

   338

    def add_local_arg(self, varname):

   339

        local_vars = self.local_arg_stack[-1]

   340

        if varname not in local_vars:

   341

            local_vars.append(varname)

   342

   343

    def add_imported_module(self, importName):

   344

   345

        if importName in self.imported_modules:

   346

            return

   347

        self.imported_modules.append(importName)

   348

        name = importName.split(".")

   349

        if len(name) != 1:

   350

            # add the name of the module to the namespace,

   351

            # but don't add the short name to imported_modules

   352

            # because then the short name would be attempted to be

   353

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

   354

            # module import directory structure!

   355

            child_name = name[-1]

   356

            self.imported_modules_as.append(child_name)

   357

        print >> self.output, gen_mod_import(self.raw_module_name,

   358

                                             strip_py(importName),

   359

                                             self.dynamic)

   360

   361

    def _default_args_handler(self, node, arg_names, current_klass,

   362

                              output=None):

   363

        if len(node.defaults):

   364

            output = output or self.output

   365

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

   366

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

   367

                default_pos -= 1

   368

            for default_node in node.defaults:

   369

                if isinstance(default_node, ast.Const):

   370

                    default_value = self._const(default_node)

   371

                elif isinstance(default_node, ast.Name):

   372

                    default_value = self._name(default_node, current_klass)

   373

                elif isinstance(default_node, ast.UnarySub):

   374

                    default_value = self._unarysub(default_node, current_klass)

   375

                else:

   376

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

   377

   378

                default_name = arg_names[default_pos]

   379

                default_pos += 1

   380

                print >> output, "    if (typeof %s == 'undefined') %s=%s;" % (default_name, default_name, default_value)

   381

   382

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

   383

        print >>self.output, "    var", varargname, '= new pyjslib.Tuple();'

   384

        print >>self.output, "    for(var __va_arg="+str(len(arg_names))+"; __va_arg < arguments.length; __va_arg++) {"

   385

        print >>self.output, "        var __arg = arguments[__va_arg];"

   386

        print >>self.output, "        "+varargname+".append(__arg);"

   387

        print >>self.output, "    }"

   388

   389

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

   390

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

   391

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

   392

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

   393

                default_pos -= 1

   394

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

   395

            for default_node in node.defaults:

   396

                default_value = self.expr(default_node, current_klass)

   397

#                if isinstance(default_node, ast.Const):

   398

#                    default_value = self._const(default_node)

   399

#                elif isinstance(default_node, ast.Name):

   400

#                    default_value = self._name(default_node)

   401

#                elif isinstance(default_node, ast.UnarySub):

   402

#                    default_value = self._unarysub(default_node, current_klass)

   403

#                else:

   404

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

   405

   406

                default_name = arg_names[default_pos]

   407

                print >>self.output, "    if (typeof %s == 'undefined')" % (default_name)

   408

                print >>self.output, "        %s=__kwargs.%s;" % (default_name, default_name)

   409

                default_pos += 1

   410

   411

            # self._default_args_handler(node, arg_names, current_klass)

   412

            if node.kwargs:

   413

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

   414

            print >>self.output, "    var __r = "+"".join(["[", ", ".join(arg_names), "]"])+";"

   415

            if node.varargs:

   416

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

   417

                print >>self.output, "    __r.push.apply(__r, __args.getArray())"

   418

            print >>self.output, "    return __r;"

   419

            print >>self.output, "};"

   420

   421

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

   422

        if local:

   423

            function_name = node.name

   424

            self.add_local_arg(function_name)

   425

        else:

   426

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

   427

   428

        arg_names = list(node.argnames)

   429

        normal_arg_names = list(arg_names)

   430

        if node.kwargs:

   431

            kwargname = normal_arg_names.pop()

   432

        if node.varargs:

   433

            varargname = normal_arg_names.pop()

   434

        declared_arg_names = list(normal_arg_names)

   435

        if node.kwargs:

   436

            declared_arg_names.append(kwargname)

   437

   438

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

   439

        print >>self.output, "%s = function%s {" % (function_name, function_args)

   440

        self._default_args_handler(node, normal_arg_names, None)

   441

   442

        local_arg_names = normal_arg_names + declared_arg_names

   443

   444

        if node.varargs:

   445

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

   446

            local_arg_names.append(varargname)

   447

   448

        # stack of local variable names for this function call

   449

        self.local_arg_stack.append(local_arg_names)

   450

   451

        for child in node.code:

   452

            self._stmt(child, None)

   453

   454

        # remove the top local arg names

   455

        self.local_arg_stack.pop()

   456

   457

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

   458

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

   459

        if not isinstance(lastStmt, ast.Return):

   460

            if not self._isNativeFunc(lastStmt):

   461

                print >>self.output, "    return null;"

   462

   463

        print >>self.output, "};"

   464

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

   465

   466

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

   467

   468

    def _return(self, node, current_klass):

   469

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

   470

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

   471

        # here too

   472

        print >>self.output, "    return " + expr + ";"

   473

   474

    def _break(self, node, current_klass):

   475

        print >>self.output, "    break;"

   476

   477

    def _continue(self, node, current_klass):

   478

        print >>self.output, "    continue;"

   479

   480

    def _callfunc(self, v, current_klass):

   481

   482

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

   483

            if v.node.name in self.top_level_functions:

   484

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

   485

            elif v.node.name in self.top_level_classes:

   486

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

   487

            elif v.node.name in self.imported_classes:

   488

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

   489

            elif v.node.name in PYJSLIB_BUILTIN_FUNCTIONS:

   490

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

   491

            elif v.node.name in PYJSLIB_BUILTIN_CLASSES:

   492

                name = pyjs_builtin_remap(v.node.name)

   493

                call_name = 'pyjslib.' + name

   494

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

   495

                call_name = "pyjslib.isFunction"

   496

            else:

   497

                call_name = v.node.name

   498

            call_args = []

   499

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

   500

            attr_name = v.node.attrname

   501

   502

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

   503

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

   504

                call_args = []

   505

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

   506

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

   507

                call_args = []

   508

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

   509

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

   510

                call_args = []

   511

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

   512

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

   513

                call_args = []

   514

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

   515

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

   516

                call_args = []

   517

            else:

   518

                raise TranslationError("unsupported type (in _callfunc)", v.node.expr)

   519

        else:

   520

            raise TranslationError("unsupported type (in _callfunc)", v.node)