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

    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 '

   236

   237

        decl = mod_var_name_decl(raw_module_name)

   238

        if decl:

   240

   241

        if self.debug:

   242

            haltException = self.module_prefix + "HaltException"

   257

   258

            isHaltFunction = self.module_prefix + "IsHaltException"

   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

    }

   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

   329

        # for className in self.top_level_classes:

   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)

   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

   385

   386

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

   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

   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]

   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)"]

   419

            if node.varargs:

   420

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

   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) + ")"

   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):

   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

   477

   478

    def _break(self, node, current_klass):

   480

   481

    def _continue(self, node, current_klass):

   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 = []

   515