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

    24

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

    25

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

    26

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

    27

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

    28

#

    29

# over-rides can be done by either explicitly modifying

    30

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

    31

    32

prefix = sys.prefix

    33

    34

if os.environ.has_key('PYJSPREFIX'):

    35

    prefix = os.environ['PYJSPREFIX']

    36

    37

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

    38

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

    39

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

    40

# in compiling standard python modules into javascript!

    41

    42

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

    43

    44

if os.environ.has_key('PYJSPATH'):

    45

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

    46

        p = os.path.abspath(p)

    47

        if os.path.isdir(p):

    48

            path.append(p)

    49

    50

# this is the python function used to wrap native javascript

    51

NATIVE_JS_FUNC_NAME = "JS"

    52

    53

UU = ""

    54

    55

PYJSLIB_BUILTIN_FUNCTIONS=("cmp",

    56

                           "map",

    57

                           "filter",

    58

                           "dir",

    59

                           "getattr",

    60

                           "setattr",

    61

                           "hasattr",

    62

                           "int",

    63

                           "float",

    64

                           "str",

    65

                           "repr",

    66

                           "range",

    67

                           "len",

    68

                           "hash",

    69

                           "abs",

    70

                           "ord",

    71

                           "chr",

    72

                           "enumerate",

    73

                           "min",

    74

                           "max",

    75

                           "bool",

    76

                           "type",

    77

                           "isinstance")

    78

    79

PYJSLIB_BUILTIN_CLASSES=("BaseException",

    80

                         "Exception",

    81

                         "StandardError",

    82

                         "StopIteration",

    83

                         "AttributeError",

    84

                         "TypeError",

    85

                         "KeyError",

    86

                         "LookupError",

    87

                         "list",

    88

                         "dict",

    89

                         "object",

    90

                         "tuple",

    91

                        )

    92

    93

def pyjs_builtin_remap(name):

    94

    # XXX HACK!

    95

    if name == 'list':

    96

        name = 'List'

    97

    if name == 'object':

    98

        name = '__Object'

    99

    if name == 'dict':

   100

        name = 'Dict'

   101

    if name == 'tuple':

   102

        name = 'Tuple'

   103

    return name

   104

   105

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

   106

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

   107

# problems.

   108

PYJS_GLOBAL_VARS=("console")

   109

   110

# This is taken from the django project.

   111

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

   112

JS_ESCAPES = (

   113

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

   114

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

   115

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

   116

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

   117

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

   118

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

   119

    (';', r'\x3B')

   120

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

   121

   122

def escapejs(value):

   123

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

   124

    for bad, good in JS_ESCAPES:

   125

        value = value.replace(bad, good)

   126

    return value

   127

   128

def uuprefix(name, leave_alone=0):

   129

    name = name.split(".")

   130

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

   131

    return '.'.join(name)

   132

   133

class Klass:

   134

   135

    klasses = {}

   136

   137

    def __init__(self, name, name_):

   138

        self.name = name

   139

        self.name_ = name_

   140

        self.klasses[name] = self

   141

        self.functions = set()

   142

   143

    def set_base(self, base_name):

   144

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

   145

   146

    def add_function(self, function_name):

   147

        self.functions.add(function_name)

   148

   149

   150

class TranslationError(Exception):

   151

    def __init__(self, message, node):

   152

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

   153

   154

    def __str__(self):

   155

        return self.message

   156

   157

def strip_py(name):

   158

    return name

   159

   160

def mod_var_name_decl(raw_module_name):

   161

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

   162

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

   163

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

   164

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

   165

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

   166

   167

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

   168

        to see: gen_mod_import and mod_var_name_decl might have

   169

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

   170

    """

   171

    name = raw_module_name.split(".")

   172

    if len(name) == 1:

   173

        return ''

   174

    child_name = name[-1]

   175

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

   176

   177

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

   178

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

   179

    return """

   180

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

   181

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

   182

    mod_var_name_decl(importName)

   183

   184

class Translator:

   185

   186

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

   187

                 dynamic=0, optimize=False,

   188

                 findFile=None):

   189

   190

        if module_name:

   191

            self.module_prefix = module_name + "."

   192

        else:

   193

            self.module_prefix = ""

   194

        self.raw_module_name = raw_module_name

   195

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

   196

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

   197

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

   198

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

   199

        self.debug = debug

   200

        self.imported_modules = []

   201

        self.imported_modules_as = []

   202

        self.imported_js = set()

   203

        self.top_level_functions = set()

   204

        self.top_level_classes = set()

   205

        self.top_level_vars = set()

   206

        self.local_arg_stack = [[]]

   207

        self.output = output

   208

        self.imported_classes = {}

   209

        self.method_imported_globals = set()

   210

        self.method_self = None

   211

        self.nextTupleAssignID = 1

   212

        self.dynamic = dynamic

   213

        self.optimize = optimize

   214

        self.findFile = findFile

   215

   216

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

   217

            vdec = ''

   218

        else:

   219

            vdec = 'var '

   220

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

   221

   222

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

   223

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

   224

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

   225

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

   226

   227

        decl = mod_var_name_decl(raw_module_name)

   228

        if decl:

   229

            print >>self.output, decl

   230

   231

   232

        if self.debug:

   233

            haltException = self.module_prefix + "HaltException"

   234

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

   235

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

   236

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

   237

            print >>self.output, '}'

   238

            print >>self.output, ''

   239

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

   240

            print >>self.output, '{'

   241

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

   242

            print >>self.output, '}'

   243

   244

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

   245

            print >>self.output, '{'

   246

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

   247

            print >>self.output, '}'

   248

   249

            isHaltFunction = self.module_prefix + "IsHaltException"

   250

            print >>self.output, """

   251

    %s = function (s) {

   252

      var suffix="HaltException";

   253

      if (s.length < suffix.length) {

   254

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

   255

        return false;

   256

      } else {

   257

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

   258

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

   259

        return ss == suffix;

   260

      }

   261

    }

   262

                """ % isHaltFunction

   263

        for child in mod.node:

   264

            if isinstance(child, ast.Function):

   265

                self.top_level_functions.add(child.name)

   266

            elif isinstance(child, ast.Class):

   267

                self.top_level_classes.add(child.name)

   268

   269

        for child in mod.node:

   270

            if isinstance(child, ast.Function):

   271

                self._function(child, False)

   272

            elif isinstance(child, ast.Class):

   273

                self._class(child)

   274

            elif isinstance(child, ast.Import):

   275

                importName = child.names[0][0]

   276

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

   277

                    pass

   278

                elif importName.endswith('.js'):

   279

                   self.imported_js.add(importName)

   280

                else:

   281

                   self.add_imported_module(strip_py(importName))

   282

            elif isinstance(child, ast.From):

   283

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

   284

                    pass

   285

                else:

   286

                    self.add_imported_module(child.modname)

   287

                    self._from(child)

   288

            elif isinstance(child, ast.Discard):

   289

                self._discard(child, None)

   290

            elif isinstance(child, ast.Assign):

   291

                self._assign(child, None, True)

   292

            elif isinstance(child, ast.AugAssign):

   293

                self._augassign(child, None)

   294

            elif isinstance(child, ast.If):

   295

                self._if(child, None)

   296

            elif isinstance(child, ast.For):

   297

                self._for(child, None)

   298

            elif isinstance(child, ast.While):

   299

                self._while(child, None)

   300

            elif isinstance(child, ast.Subscript):

   301

                self._subscript_stmt(child, None)

   302

            elif isinstance(child, ast.Global):

   303

                self._global(child, None)

   304

            elif isinstance(child, ast.Printnl):

   305

               self._print(child, None)

   306

            elif isinstance(child, ast.Print):

   307

               self._print(child, None)

   308

            elif isinstance(child, ast.TryExcept):

   309

                self._tryExcept(child, None)

   310

            elif isinstance(child, ast.Raise):

   311

                self._raise(child, None)

   312

            elif isinstance(child, ast.Stmt):

   313

                self._stmt(child, None)

   314

            else:

   315

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

   316

   317

        # Initialize all classes for this module

   318

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

   319

        #          "classes_initialize = function() {\n"

   320

        #for className in self.top_level_classes:

   321

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

   322

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

   323

   324

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

   325

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

   326

   327

    def module_imports(self):

   328

        return self.imported_modules + self.imported_modules_as

   329

   330

    def add_local_arg(self, varname):

   331

        local_vars = self.local_arg_stack[-1]

   332

        if varname not in local_vars:

   333

            local_vars.append(varname)

   334

   335

    def add_imported_module(self, importName):

   336

   337

        if importName in self.imported_modules:

   338

            return

   339

        self.imported_modules.append(importName)

   340

        name = importName.split(".")

   341

        if len(name) != 1:

   342

            # add the name of the module to the namespace,

   343

            # but don't add the short name to imported_modules

   344

            # because then the short name would be attempted to be

   345

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

   346

            # module import directory structure!

   347

            child_name = name[-1]

   348

            self.imported_modules_as.append(child_name)

   349

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

   350

                                             strip_py(importName),

   351

                                             self.dynamic)

   352

   353

    def _default_args_handler(self, node, arg_names, current_klass,

   354

                              output=None):

   355

        if len(node.defaults):

   356

            output = output or self.output

   357

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

   358

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

   359

                default_pos -= 1

   360

            for default_node in node.defaults:

   361

                if isinstance(default_node, ast.Const):

   362

                    default_value = self._const(default_node)

   363

                elif isinstance(default_node, ast.Name):

   364

                    default_value = self._name(default_node, current_klass)

   365

                elif isinstance(default_node, ast.UnarySub):

   366

                    default_value = self._unarysub(default_node, current_klass)

   367

                else:

   368

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

   369

   370

                default_name = arg_names[default_pos]

   371

                default_pos += 1

   372

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

   373

   374

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

   375

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

   376

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

   377

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

   378

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

   379

        print >>self.output, "    }"

   380

   381

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

   382

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

   383

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

   384

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

   385

                default_pos -= 1

   386

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

   387

            for default_node in node.defaults:

   388

                default_value = self.expr(default_node, current_klass)

   389

#                if isinstance(default_node, ast.Const):

   390

#                    default_value = self._const(default_node)

   391

#                elif isinstance(default_node, ast.Name):

   392

#                    default_value = self._name(default_node)

   393

#                elif isinstance(default_node, ast.UnarySub):

   394

#                    default_value = self._unarysub(default_node, current_klass)

   395

#                else:

   396

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

   397

   398

                default_name = arg_names[default_pos]

   399

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

   400

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

   401

                default_pos += 1

   402

   403

            #self._default_args_handler(node, arg_names, current_klass)

   404

            if node.kwargs: arg_names += ["pyjslib.Dict(__kwargs)"]

   405

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

   406

            if node.varargs:

   407

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

   408

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

   409

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

   410

            print >>self.output, "};"

   411

   412

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

   413

        if local:

   414

            function_name = node.name

   415

            self.add_local_arg(function_name)

   416

        else:

   417

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

   418

   419

        arg_names = list(node.argnames)

   420

        normal_arg_names = list(arg_names)

   421

        if node.kwargs: kwargname = normal_arg_names.pop()

   422

        if node.varargs: varargname = normal_arg_names.pop()

   423

        declared_arg_names = list(normal_arg_names)

   424

        if node.kwargs: declared_arg_names.append(kwargname)

   425

   426

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

   427

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

   428

        self._default_args_handler(node, normal_arg_names, None)

   429

   430

        local_arg_names = normal_arg_names + declared_arg_names

   431

   432

        if node.varargs:

   433

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

   434

            local_arg_names.append(varargname)

   435

   436

        # stack of local variable names for this function call

   437

        self.local_arg_stack.append(local_arg_names)

   438

   439

        for child in node.code:

   440

            self._stmt(child, None)

   441

   442

        # remove the top local arg names

   443

        self.local_arg_stack.pop()

   444

   445

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

   446

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

   447

        if not isinstance(lastStmt, ast.Return):

   448

            if not self._isNativeFunc(lastStmt):

   449

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

   450

   451

        print >>self.output, "};"

   452

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

   453

   454

   455

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

   456

   457

   458

    def _return(self, node, current_klass):

   459

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

   460

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

   461

        # here too

   462

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

   463

   464

   465

    def _break(self, node, current_klass):

   466

        print >>self.output, "    break;"

   467

   468

   469

    def _continue(self, node, current_klass):

   470

        print >>self.output, "    continue;"

   471

   472

   473

    def _callfunc(self, v, current_klass):

   474

   475

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

   476

            if v.node.name in self.top_level_functions:

   477

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

   478

            elif v.node.name in self.top_level_classes:

   479

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

   480

            elif self.imported_classes.has_key(v.node.name):

   481

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

   482

            elif v.node.name in PYJSLIB_BUILTIN_FUNCTIONS:

   483

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

   484

            elif v.node.name in PYJSLIB_BUILTIN_CLASSES:

   485

                name = pyjs_builtin_remap(v.node.name)

   486

                call_name = 'pyjslib.' + name

   487

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

   488

                call_name = "pyjslib.isFunction"

   489

            else:

   490

                call_name = v.node.name

   491

            call_args = []

   492

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

   493

            attr_name = v.node.attrname

   494

   495

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

   496

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

   497

                call_args = []

   498

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

   499

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

   500

                call_args = []

   501

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

   502

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

   503

                call_args = []

   504

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

   505

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

   506

                call_args = []

   507

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

   508

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

   509

                call_args = []

   510

            else:

   511

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

   512

        else:

   513

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

   514

   515

        call_name = strip_py(call_name)

   516

   517

        kwargs = []

   518

        star_arg_name = None

   519

        if v.star_args:

   520

            star_arg_name = self.expr(v.star_args, current_klass)

   521

   522

        for ch4 in v.args:

   523

            if isinstance(ch4, ast.Keyword):

   524

                kwarg = ch4.name + ":" + self.expr(ch4.expr, current_klass)

   525

                kwargs.append(kwarg)

   526

            else:

   527

                arg = self.expr(ch4, current_klass)

   528

                call_args.append(arg)

   529