--- a/py_ext/modules/svgui/pyjs/pyjs.py Wed May 09 00:39:54 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1777 +0,0 @@
-#!/usr/bin/env python
-# Copyright 2006 James Tauber and contributors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-import sys
-from types import StringType
-import compiler
-from compiler import ast
-import os
-import copy
-
-# the standard location for builtins (e.g. pyjslib) can be
-# over-ridden by changing this. it defaults to sys.prefix
-# so that on a system-wide install of pyjamas the builtins
-# can be found in e.g. {sys.prefix}/share/pyjamas
-#
-# over-rides can be done by either explicitly modifying
-# pyjs.prefix or by setting an environment variable, PYJSPREFIX.
-
-prefix = sys.prefix
-
-if os.environ.has_key('PYJSPREFIX'):
- prefix = os.environ['PYJSPREFIX']
-
-# pyjs.path is the list of paths, just like sys.path, from which
-# library modules will be searched for, for compile purposes.
-# obviously we don't want to use sys.path because that would result
-# in compiling standard python modules into javascript!
-
-path = [os.path.abspath('')]
-
-if os.environ.has_key('PYJSPATH'):
- for p in os.environ['PYJSPATH'].split(os.pathsep):
- p = os.path.abspath(p)
- if os.path.isdir(p):
- path.append(p)
-
-# this is the python function used to wrap native javascript
-NATIVE_JS_FUNC_NAME = "JS"
-
-UU = ""
-
-PYJSLIB_BUILTIN_FUNCTIONS=("cmp",
- "map",
- "filter",
- "dir",
- "getattr",
- "setattr",
- "hasattr",
- "int",
- "float",
- "str",
- "repr",
- "range",
- "len",
- "hash",
- "abs",
- "ord",
- "chr",
- "enumerate",
- "min",
- "max",
- "bool",
- "type",
- "isinstance")
-
-PYJSLIB_BUILTIN_CLASSES=("BaseException",
- "Exception",
- "StandardError",
- "StopIteration",
- "AttributeError",
- "TypeError",
- "KeyError",
- "LookupError",
- "list",
- "dict",
- "object",
- "tuple",
- )
-
-def pyjs_builtin_remap(name):
- # XXX HACK!
- if name == 'list':
- name = 'List'
- if name == 'object':
- name = '__Object'
- if name == 'dict':
- name = 'Dict'
- if name == 'tuple':
- name = 'Tuple'
- return name
-
-# XXX: this is a hack: these should be dealt with another way
-# however, console is currently the only global name which is causing
-# problems.
-PYJS_GLOBAL_VARS=("console")
-
-# This is taken from the django project.
-# Escape every ASCII character with a value less than 32.
-JS_ESCAPES = (
- ('\\', r'\x5C'),
- ('\'', r'\x27'),
- ('"', r'\x22'),
- ('>', r'\x3E'),
- ('<', r'\x3C'),
- ('&', r'\x26'),
- (';', r'\x3B')
- ) + tuple([('%c' % z, '\\x%02X' % z) for z in range(32)])
-
-def escapejs(value):
- """Hex encodes characters for use in JavaScript strings."""
- for bad, good in JS_ESCAPES:
- value = value.replace(bad, good)
- return value
-
-def uuprefix(name, leave_alone=0):
- name = name.split(".")
- name = name[:leave_alone] + map(lambda x: "__%s" % x, name[leave_alone:])
- return '.'.join(name)
-
-class Klass:
-
- klasses = {}
-
- def __init__(self, name, name_):
- self.name = name
- self.name_ = name_
- self.klasses[name] = self
- self.functions = set()
-
- def set_base(self, base_name):
- self.base = self.klasses.get(base_name)
-
- def add_function(self, function_name):
- self.functions.add(function_name)
-
-
-class TranslationError(Exception):
- def __init__(self, message, node):
- self.message = "line %s:\n%s\n%s" % (node.lineno, message, node)
-
- def __str__(self):
- return self.message
-
-def strip_py(name):
- return name
-
-def mod_var_name_decl(raw_module_name):
- """ function to get the last component of the module e.g.
- pyjamas.ui.DOM into the "namespace". i.e. doing
- "import pyjamas.ui.DOM" actually ends up with _two_
- variables - one pyjamas.ui.DOM, the other just "DOM".
- but "DOM" is actually local, hence the "var" prefix.
-
- for PyV8, this might end up causing problems - we'll have
- to see: gen_mod_import and mod_var_name_decl might have
- to end up in a library-specific module, somewhere.
- """
- name = raw_module_name.split(".")
- if len(name) == 1:
- return ''
- child_name = name[-1]
- return "var %s = %s;\n" % (child_name, raw_module_name)
-
-def gen_mod_import(parentName, importName, dynamic=1):
- #pyjs_ajax_eval("%(n)s.cache.js", null, true);
- return """
- pyjslib.import_module(sys.loadpath, '%(p)s', '%(n)s', %(d)d, false);
- """ % ({'p': parentName, 'd': dynamic, 'n': importName}) + \
- mod_var_name_decl(importName)
-
-class Translator:
-
- def __init__(self, mn, module_name, raw_module_name, src, debug, mod, output,
- dynamic=0, optimize=False,
- findFile=None):
-
- if module_name:
- self.module_prefix = module_name + "."
- else:
- self.module_prefix = ""
- self.raw_module_name = raw_module_name
- src = src.replace("\r\n", "\n")
- src = src.replace("\n\r", "\n")
- src = src.replace("\r", "\n")
- self.src = src.split("\n")
- self.debug = debug
- self.imported_modules = []
- self.imported_modules_as = []
- self.imported_js = set()
- self.top_level_functions = set()
- self.top_level_classes = set()
- self.top_level_vars = set()
- self.local_arg_stack = [[]]
- self.output = output
- self.imported_classes = {}
- self.method_imported_globals = set()
- self.method_self = None
- self.nextTupleAssignID = 1
- self.dynamic = dynamic
- self.optimize = optimize
- self.findFile = findFile
-
- if module_name.find(".") >= 0:
- vdec = ''
- else:
- vdec = 'var '
- print >>self.output, UU+"%s%s = function (__mod_name__) {" % (vdec, module_name)
-
- print >>self.output, " if("+module_name+".__was_initialized__) return;"
- print >>self.output, " "+UU+module_name+".__was_initialized__ = true;"
- print >>self.output, UU+"if (__mod_name__ == null) __mod_name__ = '%s';" % (mn)
- print >>self.output, UU+"%s.__name__ = __mod_name__;" % (raw_module_name)
-
- decl = mod_var_name_decl(raw_module_name)
- if decl:
- print >>self.output, decl
-
-
- if self.debug:
- haltException = self.module_prefix + "HaltException"
- print >>self.output, haltException + ' = function () {'
- print >>self.output, ' this.message = "Program Halted";'
- print >>self.output, ' this.name = "' + haltException + '";'
- print >>self.output, '}'
- print >>self.output, ''
- print >>self.output, haltException + ".prototype.__str__ = function()"
- print >>self.output, '{'
- print >>self.output, 'return this.message ;'
- print >>self.output, '}'
-
- print >>self.output, haltException + ".prototype.toString = function()"
- print >>self.output, '{'
- print >>self.output, 'return this.name + ": \\"" + this.message + "\\"";'
- print >>self.output, '}'
-
- isHaltFunction = self.module_prefix + "IsHaltException"
- print >>self.output, """
- %s = function (s) {
- var suffix="HaltException";
- if (s.length < suffix.length) {
- //alert(s + " " + suffix);
- return false;
- } else {
- var ss = s.substring(s.length, (s.length - suffix.length));
- //alert(s + " " + suffix + " " + ss);
- return ss == suffix;
- }
- }
- """ % isHaltFunction
- for child in mod.node:
- if isinstance(child, ast.Function):
- self.top_level_functions.add(child.name)
- elif isinstance(child, ast.Class):
- self.top_level_classes.add(child.name)
-
- for child in mod.node:
- if isinstance(child, ast.Function):
- self._function(child, False)
- elif isinstance(child, ast.Class):
- self._class(child)
- elif isinstance(child, ast.Import):
- importName = child.names[0][0]
- if importName == '__pyjamas__': # special module to help make pyjamas modules loadable in the python interpreter
- pass
- elif importName.endswith('.js'):
- self.imported_js.add(importName)
- else:
- self.add_imported_module(strip_py(importName))
- elif isinstance(child, ast.From):
- if child.modname == '__pyjamas__': # special module to help make pyjamas modules loadable in the python interpreter
- pass
- else:
- self.add_imported_module(child.modname)
- self._from(child)
- elif isinstance(child, ast.Discard):
- self._discard(child, None)
- elif isinstance(child, ast.Assign):
- self._assign(child, None, True)
- elif isinstance(child, ast.AugAssign):
- self._augassign(child, None)
- elif isinstance(child, ast.If):
- self._if(child, None)
- elif isinstance(child, ast.For):
- self._for(child, None)
- elif isinstance(child, ast.While):
- self._while(child, None)
- elif isinstance(child, ast.Subscript):
- self._subscript_stmt(child, None)
- elif isinstance(child, ast.Global):
- self._global(child, None)
- elif isinstance(child, ast.Printnl):
- self._print(child, None)
- elif isinstance(child, ast.Print):
- self._print(child, None)
- elif isinstance(child, ast.TryExcept):
- self._tryExcept(child, None)
- elif isinstance(child, ast.Raise):
- self._raise(child, None)
- elif isinstance(child, ast.Stmt):
- self._stmt(child, None)
- else:
- raise TranslationError("unsupported type (in __init__)", child)
-
- # Initialize all classes for this module
- #print >> self.output, "__"+self.modpfx()+\
- # "classes_initialize = function() {\n"
- #for className in self.top_level_classes:
- # print >> self.output, "\t"+UU+self.modpfx()+"__"+className+"_initialize();"
- #print >> self.output, "};\n"
-
- print >> self.output, "return this;\n"
- print >> self.output, "}; /* end %s */ \n" % module_name
-
- def module_imports(self):
- return self.imported_modules + self.imported_modules_as
-
- def add_local_arg(self, varname):
- local_vars = self.local_arg_stack[-1]
- if varname not in local_vars:
- local_vars.append(varname)
-
- def add_imported_module(self, importName):
-
- if importName in self.imported_modules:
- return
- self.imported_modules.append(importName)
- name = importName.split(".")
- if len(name) != 1:
- # add the name of the module to the namespace,
- # but don't add the short name to imported_modules
- # because then the short name would be attempted to be
- # added to the dependencies, and it's half way up the
- # module import directory structure!
- child_name = name[-1]
- self.imported_modules_as.append(child_name)
- print >> self.output, gen_mod_import(self.raw_module_name,
- strip_py(importName),
- self.dynamic)
-
- def _default_args_handler(self, node, arg_names, current_klass,
- output=None):
- if len(node.defaults):
- output = output or self.output
- default_pos = len(arg_names) - len(node.defaults)
- if arg_names and arg_names[0] == self.method_self:
- default_pos -= 1
- for default_node in node.defaults:
- if isinstance(default_node, ast.Const):
- default_value = self._const(default_node)
- elif isinstance(default_node, ast.Name):
- default_value = self._name(default_node, current_klass)
- elif isinstance(default_node, ast.UnarySub):
- default_value = self._unarysub(default_node, current_klass)
- else:
- raise TranslationError("unsupported type (in _method)", default_node)
-
- default_name = arg_names[default_pos]
- default_pos += 1
- print >> output, " if (typeof %s == 'undefined') %s=%s;" % (default_name, default_name, default_value)
-
- def _varargs_handler(self, node, varargname, arg_names, current_klass):
- print >>self.output, " var", varargname, '= new pyjslib.Tuple();'
- print >>self.output, " for(var __va_arg="+str(len(arg_names))+"; __va_arg < arguments.length; __va_arg++) {"
- print >>self.output, " var __arg = arguments[__va_arg];"
- print >>self.output, " "+varargname+".append(__arg);"
- print >>self.output, " }"
-
- def _kwargs_parser(self, node, function_name, arg_names, current_klass):
- if len(node.defaults) or node.kwargs:
- default_pos = len(arg_names) - len(node.defaults)
- if arg_names and arg_names[0] == self.method_self:
- default_pos -= 1
- print >>self.output, function_name+'.parse_kwargs = function (', ", ".join(["__kwargs"]+arg_names), ") {"
- for default_node in node.defaults:
- default_value = self.expr(default_node, current_klass)
-# if isinstance(default_node, ast.Const):
-# default_value = self._const(default_node)
-# elif isinstance(default_node, ast.Name):
-# default_value = self._name(default_node)
-# elif isinstance(default_node, ast.UnarySub):
-# default_value = self._unarysub(default_node, current_klass)
-# else:
-# raise TranslationError("unsupported type (in _method)", default_node)
-
- default_name = arg_names[default_pos]
- print >>self.output, " if (typeof %s == 'undefined')"%(default_name)
- print >>self.output, " %s=__kwargs.%s;"% (default_name, default_name)
- default_pos += 1
-
- #self._default_args_handler(node, arg_names, current_klass)
- if node.kwargs: arg_names += ["pyjslib.Dict(__kwargs)"]
- print >>self.output, " var __r = "+"".join(["[", ", ".join(arg_names), "]"])+";"
- if node.varargs:
- self._varargs_handler(node, "__args", arg_names, current_klass)
- print >>self.output, " __r.push.apply(__r, __args.getArray())"
- print >>self.output, " return __r;"
- print >>self.output, "};"
-
- def _function(self, node, local=False):
- if local:
- function_name = node.name
- self.add_local_arg(function_name)
- else:
- function_name = UU + self.modpfx() + node.name
-
- arg_names = list(node.argnames)
- normal_arg_names = list(arg_names)
- if node.kwargs: kwargname = normal_arg_names.pop()
- if node.varargs: varargname = normal_arg_names.pop()
- declared_arg_names = list(normal_arg_names)
- if node.kwargs: declared_arg_names.append(kwargname)
-
- function_args = "(" + ", ".join(declared_arg_names) + ")"
- print >>self.output, "%s = function%s {" % (function_name, function_args)
- self._default_args_handler(node, normal_arg_names, None)
-
- local_arg_names = normal_arg_names + declared_arg_names
-
- if node.varargs:
- self._varargs_handler(node, varargname, declared_arg_names, None)
- local_arg_names.append(varargname)
-
- # stack of local variable names for this function call
- self.local_arg_stack.append(local_arg_names)
-
- for child in node.code:
- self._stmt(child, None)
-
- # remove the top local arg names
- self.local_arg_stack.pop()
-
- # we need to return null always, so it is not undefined
- lastStmt = [p for p in node.code][-1]
- if not isinstance(lastStmt, ast.Return):
- if not self._isNativeFunc(lastStmt):
- print >>self.output, " return null;"
-
- print >>self.output, "};"
- print >>self.output, "%s.__name__ = '%s';\n" % (function_name, node.name)
-
-
- self._kwargs_parser(node, function_name, normal_arg_names, None)
-
-
- def _return(self, node, current_klass):
- expr = self.expr(node.value, current_klass)
- # in python a function call always returns None, so we do it
- # here too
- print >>self.output, " return " + expr + ";"
-
-
- def _break(self, node, current_klass):
- print >>self.output, " break;"
-
-
- def _continue(self, node, current_klass):
- print >>self.output, " continue;"
-
-
- def _callfunc(self, v, current_klass):
-
- if isinstance(v.node, ast.Name):
- if v.node.name in self.top_level_functions:
- call_name = self.modpfx() + v.node.name
- elif v.node.name in self.top_level_classes:
- call_name = self.modpfx() + v.node.name
- elif self.imported_classes.has_key(v.node.name):
- call_name = self.imported_classes[v.node.name] + '.' + v.node.name
- elif v.node.name in PYJSLIB_BUILTIN_FUNCTIONS:
- call_name = 'pyjslib.' + v.node.name
- elif v.node.name in PYJSLIB_BUILTIN_CLASSES:
- name = pyjs_builtin_remap(v.node.name)
- call_name = 'pyjslib.' + name
- elif v.node.name == "callable":
- call_name = "pyjslib.isFunction"
- else:
- call_name = v.node.name
- call_args = []
- elif isinstance(v.node, ast.Getattr):
- attr_name = v.node.attrname
-
- if isinstance(v.node.expr, ast.Name):
- call_name = self._name2(v.node.expr, current_klass, attr_name)
- call_args = []
- elif isinstance(v.node.expr, ast.Getattr):
- call_name = self._getattr2(v.node.expr, current_klass, attr_name)
- call_args = []
- elif isinstance(v.node.expr, ast.CallFunc):
- call_name = self._callfunc(v.node.expr, current_klass) + "." + v.node.attrname
- call_args = []
- elif isinstance(v.node.expr, ast.Subscript):
- call_name = self._subscript(v.node.expr, current_klass) + "." + v.node.attrname
- call_args = []
- elif isinstance(v.node.expr, ast.Const):
- call_name = self.expr(v.node.expr, current_klass) + "." + v.node.attrname
- call_args = []
- else:
- raise TranslationError("unsupported type (in _callfunc)", v.node.expr)
- else:
- raise TranslationError("unsupported type (in _callfunc)", v.node)
-
- call_name = strip_py(call_name)
-
- kwargs = []
- star_arg_name = None
- if v.star_args:
- star_arg_name = self.expr(v.star_args, current_klass)
-
- for ch4 in v.args:
- if isinstance(ch4, ast.Keyword):
- kwarg = ch4.name + ":" + self.expr(ch4.expr, current_klass)
- kwargs.append(kwarg)
- else:
- arg = self.expr(ch4, current_klass)
- call_args.append(arg)
-
- if kwargs:
- fn_args = ", ".join(['{' + ', '.join(kwargs) + '}']+call_args)
- else:
- fn_args = ", ".join(call_args)
-
- if kwargs or star_arg_name:
- if not star_arg_name:
- star_arg_name = 'null'
- try: call_this, method_name = call_name.rsplit(".", 1)
- except ValueError:
- # Must be a function call ...
- return ("pyjs_kwargs_function_call("+call_name+", "
- + star_arg_name
- + ", ["+fn_args+"]"
- + ")" )
- else:
- return ("pyjs_kwargs_method_call("+call_this+", '"+method_name+"', "
- + star_arg_name
- + ", ["+fn_args+"]"
- + ")")
- else:
- return call_name + "(" + ", ".join(call_args) + ")"
-
- def _print(self, node, current_klass):
- if self.optimize:
- return
- call_args = []
- for ch4 in node.nodes:
- arg = self.expr(ch4, current_klass)
- call_args.append(arg)
-
- print >>self.output, "pyjslib.printFunc([", ', '.join(call_args), "],", int(isinstance(node, ast.Printnl)), ");"
-
- def _tryExcept(self, node, current_klass):
- if len(node.handlers) != 1:
- raise TranslationError("except statements in this form are" +
- " not supported", node)
-
- expr = node.handlers[0][0]
- as_ = node.handlers[0][1]
- if as_:
- errName = as_.name
- else:
- errName = 'err'
-
- # XXX TODO: check that this should instead be added as a _separate_
- # local scope, temporary to the function. oh dearie me.
- self.add_local_arg(errName)
-
- print >>self.output, " try {"
- for stmt in node.body.nodes:
- self._stmt(stmt, current_klass)
- print >> self.output, " } catch(%s) {" % errName
- if expr:
- l = []
- if isinstance(expr, ast.Tuple):
- for x in expr.nodes:
- l.append("(%(err)s.__name__ == %(expr)s.__name__)" % dict (err=errName, expr=self.expr(x, current_klass)))
- else:
- l = [ " (%(err)s.__name__ == %(expr)s.__name__) " % dict (err=errName, expr=self.expr(expr, current_klass)) ]
- print >> self.output, " if(%s) {" % '||\n\t\t'.join(l)
- for stmt in node.handlers[0][2]:
- self._stmt(stmt, current_klass)
- if expr:
- #print >> self.output, "} else { throw(%s); } " % errName
- print >> self.output, "}"
- if node.else_ != None:
- print >>self.output, " } finally {"
- for stmt in node.else_:
- self._stmt(stmt, current_klass)
- print >>self.output, " }"
-
- # XXX: change use_getattr to True to enable "strict" compilation
- # but incurring a 100% performance penalty. oops.
- def _getattr(self, v, current_klass, use_getattr=False):
- attr_name = v.attrname
- if isinstance(v.expr, ast.Name):
- obj = self._name(v.expr, current_klass, return_none_for_module=True)
- if obj == None and v.expr.name in self.module_imports():
- # XXX TODO: distinguish between module import classes
- # and variables. right now, this is a hack to get
- # the sys module working.
- #if v.expr.name == 'sys':
- return v.expr.name+'.'+attr_name
- #return v.expr.name+'.__'+attr_name+'.prototype.__class__'
- if not use_getattr or attr_name == '__class__' or \
- attr_name == '__name__':
- return obj + "." + attr_name
- return "pyjslib.getattr(%s, '%s')" % (obj, attr_name)
- elif isinstance(v.expr, ast.Getattr):
- return self._getattr(v.expr, current_klass) + "." + attr_name
- elif isinstance(v.expr, ast.Subscript):
- return self._subscript(v.expr, self.modpfx()) + "." + attr_name
- elif isinstance(v.expr, ast.CallFunc):
- return self._callfunc(v.expr, self.modpfx()) + "." + attr_name
- else:
- raise TranslationError("unsupported type (in _getattr)", v.expr)
-
-
- def modpfx(self):
- return strip_py(self.module_prefix)
-
- def _name(self, v, current_klass, top_level=False,
- return_none_for_module=False):
-
- if v.name == 'ilikesillynamesfornicedebugcode':
- print top_level, current_klass, repr(v)
- print self.top_level_vars
- print self.top_level_functions
- print self.local_arg_stack
- print "error..."
-
- local_var_names = None
- las = len(self.local_arg_stack)
- if las > 0:
- local_var_names = self.local_arg_stack[-1]
-
- if v.name == "True":
- return "true"
- elif v.name == "False":
- return "false"
- elif v.name == "None":
- return "null"
- elif v.name == '__name__' and current_klass is None:
- return self.modpfx() + v.name
- elif v.name == self.method_self:
- return "this"
- elif v.name in self.top_level_functions:
- return UU+self.modpfx() + v.name
- elif v.name in self.method_imported_globals:
- return UU+self.modpfx() + v.name
- elif not current_klass and las == 1 and v.name in self.top_level_vars:
- return UU+self.modpfx() + v.name
- elif v.name in local_var_names:
- return v.name
- elif self.imported_classes.has_key(v.name):
- return UU+self.imported_classes[v.name] + '.__' + v.name + ".prototype.__class__"
- elif v.name in self.top_level_classes:
- return UU+self.modpfx() + "__" + v.name + ".prototype.__class__"
- elif v.name in self.module_imports() and return_none_for_module:
- return None
- elif v.name in PYJSLIB_BUILTIN_CLASSES:
- return "pyjslib." + pyjs_builtin_remap( v.name )
- elif current_klass:
- if v.name not in local_var_names and \
- v.name not in self.top_level_vars and \
- v.name not in PYJS_GLOBAL_VARS and \
- v.name not in self.top_level_functions:
-
- cls_name = current_klass
- if hasattr(cls_name, "name"):
- cls_name_ = cls_name.name_
- cls_name = cls_name.name
- else:
- cls_name_ = current_klass + "_" # XXX ???
- name = UU+cls_name_ + ".prototype.__class__." \
- + v.name
- if v.name == 'listener':
- name = 'listener+' + name
- return name
-
- return v.name
-
- def _name2(self, v, current_klass, attr_name):
- obj = v.name
-
- if obj in self.method_imported_globals:
- call_name = UU+self.modpfx() + obj + "." + attr_name
- elif self.imported_classes.has_key(obj):
- #attr_str = ""
- #if attr_name != "__init__":
- attr_str = ".prototype.__class__." + attr_name
- call_name = UU+self.imported_classes[obj] + '.__' + obj + attr_str
- elif obj in self.module_imports():
- call_name = obj + "." + attr_name
- elif obj[0] == obj[0].upper(): # XXX HACK ALERT
- call_name = UU + self.modpfx() + "__" + obj + ".prototype.__class__." + attr_name
- else:
- call_name = UU+self._name(v, current_klass) + "." + attr_name
-
- return call_name
-
-
- def _getattr2(self, v, current_klass, attr_name):
- if isinstance(v.expr, ast.Getattr):
- call_name = self._getattr2(v.expr, current_klass, v.attrname + "." + attr_name)
- elif isinstance(v.expr, ast.Name) and v.expr.name in self.module_imports():
- call_name = UU+v.expr.name + '.__' +v.attrname+".prototype.__class__."+attr_name
- else:
- obj = self.expr(v.expr, current_klass)
- call_name = obj + "." + v.attrname + "." + attr_name
-
- return call_name
-
-
- def _class(self, node):
- """
- Handle a class definition.
-
- In order to translate python semantics reasonably well, the following
- structure is used:
-
- A special object is created for the class, which inherits attributes
- from the superclass, or Object if there's no superclass. This is the
- class object; the object which you refer to when specifying the
- class by name. Static, class, and unbound methods are copied
- from the superclass object.
-
- A special constructor function is created with the same name as the
- class, which is used to create instances of that class.
-
- A javascript class (e.g. a function with a prototype attribute) is
- created which is the javascript class of created instances, and
- which inherits attributes from the class object. Bound methods are
- copied from the superclass into this class rather than inherited,
- because the class object contains unbound, class, and static methods
- that we don't necessarily want to inherit.
-
- The type of a method can now be determined by inspecting its
- static_method, unbound_method, class_method, or instance_method
- attribute; only one of these should be true.
-
- Much of this work is done in pyjs_extend, is pyjslib.py
- """
- class_name = self.modpfx() + uuprefix(node.name, 1)
- class_name_ = self.modpfx() + uuprefix(node.name)
- current_klass = Klass(class_name, class_name_)
- init_method = None
- for child in node.code:
- if isinstance(child, ast.Function):
- current_klass.add_function(child.name)
- if child.name == "__init__":
- init_method = child
-
-
- if len(node.bases) == 0:
- base_class = "pyjslib.__Object"
- elif len(node.bases) == 1:
- if isinstance(node.bases[0], ast.Name):
- if self.imported_classes.has_key(node.bases[0].name):
- base_class_ = self.imported_classes[node.bases[0].name] + '.__' + node.bases[0].name
- base_class = self.imported_classes[node.bases[0].name] + '.' + node.bases[0].name
- else:
- base_class_ = self.modpfx() + "__" + node.bases[0].name
- base_class = self.modpfx() + node.bases[0].name
- elif isinstance(node.bases[0], ast.Getattr):
- # the bases are not in scope of the class so do not
- # pass our class to self._name
- base_class_ = self._name(node.bases[0].expr, None) + \
- ".__" + node.bases[0].attrname
- base_class = self._name(node.bases[0].expr, None) + \
- "." + node.bases[0].attrname
- else:
- raise TranslationError("unsupported type (in _class)", node.bases[0])
-
- current_klass.set_base(base_class)
- else:
- raise TranslationError("more than one base (in _class)", node)
-
- print >>self.output, UU+class_name_ + " = function () {"
- # call superconstructor
- #if base_class:
- # print >>self.output, " __" + base_class + ".call(this);"
- print >>self.output, "}"
-
- if not init_method:
- init_method = ast.Function([], "__init__", ["self"], [], 0, None, [])
- #self._method(init_method, current_klass, class_name)
-
- # Generate a function which constructs the object
- clsfunc = ast.Function([],
- node.name,
- init_method.argnames[1:],
- init_method.defaults,
- init_method.flags,
- None,
- [ast.Discard(ast.CallFunc(ast.Name("JS"), [ast.Const(
-# I attempted lazy initialization, but then you can't access static class members
-# " if(!__"+base_class+".__was_initialized__)"+
-# " __" + class_name + "_initialize();\n" +
- " var instance = new " + UU + class_name_ + "();\n" +
- " if(instance.__init__) instance.__init__.apply(instance, arguments);\n" +
- " return instance;"
- )]))])
-
- self._function(clsfunc, False)
- print >>self.output, UU+class_name_ + ".__initialize__ = function () {"
- print >>self.output, " if("+UU+class_name_+".__was_initialized__) return;"
- print >>self.output, " "+UU+class_name_+".__was_initialized__ = true;"
- cls_obj = UU+class_name_ + '.prototype.__class__'
-
- if class_name == "pyjslib.__Object":
- print >>self.output, " "+cls_obj+" = {};"
- else:
- if base_class and base_class not in ("object", "pyjslib.__Object"):
- print >>self.output, " if(!"+UU+base_class_+".__was_initialized__)"
- print >>self.output, " "+UU+base_class_+".__initialize__();"
- print >>self.output, " pyjs_extend(" + UU+class_name_ + ", "+UU+base_class_+");"
- else:
- print >>self.output, " pyjs_extend(" + UU+class_name_ + ", "+UU+"pyjslib.__Object);"
-
- print >>self.output, " "+cls_obj+".__new__ = "+UU+class_name+";"
- print >>self.output, " "+cls_obj+".__name__ = '"+UU+node.name+"';"
-
- for child in node.code:
- if isinstance(child, ast.Pass):
- pass
- elif isinstance(child, ast.Function):
- self._method(child, current_klass, class_name, class_name_)
- elif isinstance(child, ast.Assign):
- self.classattr(child, current_klass)
- elif isinstance(child, ast.Discard) and isinstance(child.expr, ast.Const):
- # Probably a docstring, turf it
- pass
- else:
- raise TranslationError("unsupported type (in _class)", child)
- print >>self.output, "}"
-
- print >> self.output, class_name_+".__initialize__();"
-
-
- def classattr(self, node, current_klass):
- self._assign(node, current_klass, True)
-
- def _raise(self, node, current_klass):
- if node.expr2:
- raise TranslationError("More than one expression unsupported",
- node)
- print >> self.output, "throw (%s);" % self.expr(
- node.expr1, current_klass)
-
- def _method(self, node, current_klass, class_name, class_name_):
- # reset global var scope
- self.method_imported_globals = set()
-
- arg_names = list(node.argnames)
-
- classmethod = False
- staticmethod = False
- if node.decorators:
- for d in node.decorators:
- if d.name == "classmethod":
- classmethod = True
- elif d.name == "staticmethod":
- staticmethod = True
-
- if staticmethod:
- staticfunc = ast.Function([], class_name_+"."+node.name, node.argnames, node.defaults, node.flags, node.doc, node.code, node.lineno)
- self._function(staticfunc, True)
- print >>self.output, " " + UU+class_name_ + ".prototype.__class__." + node.name + " = " + class_name_+"."+node.name+";";
- print >>self.output, " " + UU+class_name_ + ".prototype.__class__." + node.name + ".static_method = true;";
- return
- else:
- if len(arg_names) == 0:
- raise TranslationError("methods must take an argument 'self' (in _method)", node)
- self.method_self = arg_names[0]
-
- #if not classmethod and arg_names[0] != "self":
- # raise TranslationError("first arg not 'self' (in _method)", node)
-
- normal_arg_names = arg_names[1:]
- if node.kwargs: kwargname = normal_arg_names.pop()
- if node.varargs: varargname = normal_arg_names.pop()
- declared_arg_names = list(normal_arg_names)
- if node.kwargs: declared_arg_names.append(kwargname)
-
- function_args = "(" + ", ".join(declared_arg_names) + ")"
-
- if classmethod:
- fexpr = UU + class_name_ + ".prototype.__class__." + node.name
- else:
- fexpr = UU + class_name_ + ".prototype." + node.name
- print >>self.output, " "+fexpr + " = function" + function_args + " {"
-
- # default arguments
- self._default_args_handler(node, normal_arg_names, current_klass)
-
- local_arg_names = normal_arg_names + declared_arg_names
-
- if node.varargs:
- self._varargs_handler(node, varargname, declared_arg_names, current_klass)
- local_arg_names.append(varargname)
-
-
- # stack of local variable names for this function call
- self.local_arg_stack.append(local_arg_names)
-
- for child in node.code:
- self._stmt(child, current_klass)
-
- # remove the top local arg names
- self.local_arg_stack.pop()
-
- print >>self.output, " };"
-
- self._kwargs_parser(node, fexpr, normal_arg_names, current_klass)
-
- if classmethod:
- # Have to create a version on the instances which automatically passes the
- # class as "self"
- altexpr = UU + class_name_ + ".prototype." + node.name
- print >>self.output, " "+altexpr + " = function() {"
- print >>self.output, " return " + fexpr + ".apply(this.__class__, arguments);"
- print >>self.output, " };"
- print >>self.output, " "+fexpr+".class_method = true;"
- print >>self.output, " "+altexpr+".instance_method = true;"
- else:
- # For instance methods, we need an unbound version in the class object
- altexpr = UU + class_name_ + ".prototype.__class__." + node.name
- print >>self.output, " "+altexpr + " = function() {"
- print >>self.output, " return " + fexpr + ".call.apply("+fexpr+", arguments);"
- print >>self.output, " };"
- print >>self.output, " "+altexpr+".unbound_method = true;"
- print >>self.output, " "+fexpr+".instance_method = true;"
- print >>self.output, " "+altexpr+".__name__ = '%s';" % node.name
-
- print >>self.output, UU + class_name_ + ".prototype.%s.__name__ = '%s';" % \
- (node.name, node.name)
-
- if node.kwargs or len(node.defaults):
- print >>self.output, " "+altexpr + ".parse_kwargs = " + fexpr + ".parse_kwargs;"
-
- self.method_self = None
- self.method_imported_globals = set()
-
- def _isNativeFunc(self, node):
- if isinstance(node, ast.Discard):
- if isinstance(node.expr, ast.CallFunc):
- if isinstance(node.expr.node, ast.Name) and \
- node.expr.node.name == NATIVE_JS_FUNC_NAME:
- return True
- return False
-
- def _stmt(self, node, current_klass):
- debugStmt = self.debug and not self._isNativeFunc(node)
- if debugStmt:
- print >>self.output, ' try {'
-
- if isinstance(node, ast.Return):
- self._return(node, current_klass)
- elif isinstance(node, ast.Break):
- self._break(node, current_klass)
- elif isinstance(node, ast.Continue):
- self._continue(node, current_klass)
- elif isinstance(node, ast.Assign):
- self._assign(node, current_klass)
- elif isinstance(node, ast.AugAssign):
- self._augassign(node, current_klass)
- elif isinstance(node, ast.Discard):
- self._discard(node, current_klass)
- elif isinstance(node, ast.If):
- self._if(node, current_klass)
- elif isinstance(node, ast.For):
- self._for(node, current_klass)
- elif isinstance(node, ast.While):
- self._while(node, current_klass)
- elif isinstance(node, ast.Subscript):
- self._subscript_stmt(node, current_klass)
- elif isinstance(node, ast.Global):
- self._global(node, current_klass)
- elif isinstance(node, ast.Pass):
- pass
- elif isinstance(node, ast.Function):
- self._function(node, True)
- elif isinstance(node, ast.Printnl):
- self._print(node, current_klass)
- elif isinstance(node, ast.Print):
- self._print(node, current_klass)
- elif isinstance(node, ast.TryExcept):
- self._tryExcept(node, current_klass)
- elif isinstance(node, ast.Raise):
- self._raise(node, current_klass)
- else:
- raise TranslationError("unsupported type (in _stmt)", node)
-
- if debugStmt:
-
- lt = self.get_line_trace(node)
-
- haltException = self.module_prefix + "HaltException"
- isHaltFunction = self.module_prefix + "IsHaltException"
-
- print >>self.output, ' } catch (__err) {'
- print >>self.output, ' if (' + isHaltFunction + '(__err.name)) {'
- print >>self.output, ' throw __err;'
- print >>self.output, ' } else {'
- print >>self.output, " st = sys.printstack() + "\
- + '"%s"' % lt + "+ '\\n' ;"
- print >>self.output, ' alert("' + "Error in " \
- + lt + '"' \
- + '+"\\n"+__err.name+": "+__err.message'\
- + '+"\\n\\nStack trace:\\n"' \
- + '+st' \
- + ');'
- print >>self.output, ' debugger;'
-
- print >>self.output, ' throw new ' + self.module_prefix + "HaltException();"
- print >>self.output, ' }'
- print >>self.output, ' }'
-
-
- def get_line_trace(self, node):
- lineNum = "Unknown"
- srcLine = ""
- if hasattr(node, "lineno"):
- if node.lineno != None:
- lineNum = node.lineno
- srcLine = self.src[min(lineNum, len(self.src))-1]
- srcLine = srcLine.replace('\\', '\\\\')
- srcLine = srcLine.replace('"', '\\"')
- srcLine = srcLine.replace("'", "\\'")
-
- return self.raw_module_name + ".py, line " \
- + str(lineNum) + ":"\
- + "\\n" \
- + " " + srcLine
-
- def _augassign(self, node, current_klass):
- v = node.node
- if isinstance(v, ast.Getattr):
- # XXX HACK! don't allow += on return result of getattr.
- # TODO: create a temporary variable or something.
- lhs = self._getattr(v, current_klass, False)
- else:
- lhs = self._name(node.node, current_klass)
- op = node.op
- rhs = self.expr(node.expr, current_klass)
- print >>self.output, " " + lhs + " " + op + " " + rhs + ";"
-
-
- def _assign(self, node, current_klass, top_level = False):
- if len(node.nodes) != 1:
- tempvar = '__temp'+str(node.lineno)
- tnode = ast.Assign([ast.AssName(tempvar, "OP_ASSIGN", node.lineno)], node.expr, node.lineno)
- self._assign(tnode, current_klass, top_level)
- for v in node.nodes:
- tnode2 = ast.Assign([v], ast.Name(tempvar, node.lineno), node.lineno)
- self._assign(tnode2, current_klass, top_level)
- return
-
- local_var_names = None
- if len(self.local_arg_stack) > 0:
- local_var_names = self.local_arg_stack[-1]
-
- def _lhsFromAttr(v, current_klass):
- attr_name = v.attrname
- if isinstance(v.expr, ast.Name):
- obj = v.expr.name
- lhs = self._name(v.expr, current_klass) + "." + attr_name
- elif isinstance(v.expr, ast.Getattr):
- lhs = self._getattr(v, current_klass)
- elif isinstance(v.expr, ast.Subscript):
- lhs = self._subscript(v.expr, current_klass) + "." + attr_name
- else:
- raise TranslationError("unsupported type (in _assign)", v.expr)
- return lhs
-
- def _lhsFromName(v, top_level, current_klass):
- if top_level:
- if current_klass:
- lhs = UU+current_klass.name_ + ".prototype.__class__." \
- + v.name
- else:
- self.top_level_vars.add(v.name)
- vname = self.modpfx() + v.name
- if not self.modpfx() and v.name not in\
- self.method_imported_globals:
- lhs = "var " + vname
- else:
- lhs = UU + vname
- self.add_local_arg(v.name)
- else:
- if v.name in local_var_names:
- lhs = v.name
- elif v.name in self.method_imported_globals:
- lhs = self.modpfx() + v.name
- else:
- lhs = "var " + v.name
- self.add_local_arg(v.name)
- return lhs
-
- dbg = 0
- v = node.nodes[0]
- if isinstance(v, ast.AssAttr):
- lhs = _lhsFromAttr(v, current_klass)
- if v.flags == "OP_ASSIGN":
- op = "="
- else:
- raise TranslationError("unsupported flag (in _assign)", v)
-
- elif isinstance(v, ast.AssName):
- lhs = _lhsFromName(v, top_level, current_klass)
- if v.flags == "OP_ASSIGN":
- op = "="
- else:
- raise TranslationError("unsupported flag (in _assign)", v)
- elif isinstance(v, ast.Subscript):
- if v.flags == "OP_ASSIGN":
- obj = self.expr(v.expr, current_klass)
- if len(v.subs) != 1:
- raise TranslationError("must have one sub (in _assign)", v)
- idx = self.expr(v.subs[0], current_klass)
- value = self.expr(node.expr, current_klass)
- print >>self.output, " " + obj + ".__setitem__(" + idx + ", " + value + ");"
- return
- else:
- raise TranslationError("unsupported flag (in _assign)", v)
- elif isinstance(v, (ast.AssList, ast.AssTuple)):
- uniqueID = self.nextTupleAssignID
- self.nextTupleAssignID += 1
- tempName = "__tupleassign" + str(uniqueID) + "__"
- print >>self.output, " var " + tempName + " = " + \
- self.expr(node.expr, current_klass) + ";"
- for index,child in enumerate(v.getChildNodes()):
- rhs = tempName + ".__getitem__(" + str(index) + ")"
-
- if isinstance(child, ast.AssAttr):
- lhs = _lhsFromAttr(child, current_klass)
- elif isinstance(child, ast.AssName):
- lhs = _lhsFromName(child, top_level, current_klass)
- elif isinstance(child, ast.Subscript):
- if child.flags == "OP_ASSIGN":
- obj = self.expr(child.expr, current_klass)
- if len(child.subs) != 1:
- raise TranslationError("must have one sub " +
- "(in _assign)", child)
- idx = self.expr(child.subs[0], current_klass)
- value = self.expr(node.expr, current_klass)
- print >>self.output, " " + obj + ".__setitem__(" \
- + idx + ", " + rhs + ");"
- continue
- print >>self.output, " " + lhs + " = " + rhs + ";"
- return
- else:
- raise TranslationError("unsupported type (in _assign)", v)
-
- rhs = self.expr(node.expr, current_klass)
- if dbg:
- print "b", repr(node.expr), rhs
- print >>self.output, " " + lhs + " " + op + " " + rhs + ";"
-
-
- def _discard(self, node, current_klass):
-
- if isinstance(node.expr, ast.CallFunc):
- debugStmt = self.debug and not self._isNativeFunc(node)
- if debugStmt and isinstance(node.expr.node, ast.Name) and \
- node.expr.node.name == 'import_wait':
- debugStmt = False
- if debugStmt:
- st = self.get_line_trace(node)
- print >>self.output, "sys.addstack('%s');\n" % st
- if isinstance(node.expr.node, ast.Name) and node.expr.node.name == NATIVE_JS_FUNC_NAME:
- if len(node.expr.args) != 1:
- raise TranslationError("native javascript function %s must have one arg" % NATIVE_JS_FUNC_NAME, node.expr)
- if not isinstance(node.expr.args[0], ast.Const):
- raise TranslationError("native javascript function %s must have constant arg" % NATIVE_JS_FUNC_NAME, node.expr)
- raw_js = node.expr.args[0].value
- print >>self.output, raw_js
- else:
- expr = self._callfunc(node.expr, current_klass)
- print >>self.output, " " + expr + ";"
-
- if debugStmt:
- print >>self.output, "sys.popstack();\n"
-
- elif isinstance(node.expr, ast.Const):
- if node.expr.value is not None: # Empty statements generate ignore None
- print >>self.output, self._const(node.expr)
- else:
- raise TranslationError("unsupported type (in _discard)", node.expr)
-
-
- def _if(self, node, current_klass):
- for i in range(len(node.tests)):
- test, consequence = node.tests[i]
- if i == 0:
- keyword = "if"
- else:
- keyword = "else if"
-
- self._if_test(keyword, test, consequence, current_klass)
-
- if node.else_:
- keyword = "else"
- test = None
- consequence = node.else_
-
- self._if_test(keyword, test, consequence, current_klass)
-
-
- def _if_test(self, keyword, test, consequence, current_klass):
- if test:
- expr = self.expr(test, current_klass)
-
- print >>self.output, " " + keyword + " (pyjslib.bool(" + expr + ")) {"
- else:
- print >>self.output, " " + keyword + " {"
-
- if isinstance(consequence, ast.Stmt):
- for child in consequence.nodes:
- self._stmt(child, current_klass)
- else:
- raise TranslationError("unsupported type (in _if_test)", consequence)
-
- print >>self.output, " }"
-
-
- def _from(self, node):
- for name in node.names:
- # look up "hack" in AppTranslator as to how findFile gets here
- module_name = node.modname + "." + name[0]
- try:
- ff = self.findFile(module_name + ".py")
- except Exception:
- ff = None
- if ff:
- self.add_imported_module(module_name)
- else:
- self.imported_classes[name[0]] = node.modname
-
-
- def _compare(self, node, current_klass):
- lhs = self.expr(node.expr, current_klass)
-
- if len(node.ops) != 1:
- raise TranslationError("only one ops supported (in _compare)", node)
-
- op = node.ops[0][0]
- rhs_node = node.ops[0][1]
- rhs = self.expr(rhs_node, current_klass)
-
- if op == "==":
- return "pyjslib.eq(%s, %s)" % (lhs, rhs)
- if op == "in":
- return rhs + ".__contains__(" + lhs + ")"
- elif op == "not in":
- return "!" + rhs + ".__contains__(" + lhs + ")"
- elif op == "is":
- op = "==="
- elif op == "is not":
- op = "!=="
-
- return "(" + lhs + " " + op + " " + rhs + ")"
-
-
- def _not(self, node, current_klass):
- expr = self.expr(node.expr, current_klass)
-
- return "!(" + expr + ")"
-
- def _or(self, node, current_klass):
- expr = "("+(") || (".join([self.expr(child, current_klass) for child in node.nodes]))+')'
- return expr
-
- def _and(self, node, current_klass):
- expr = "("+(") && (".join([self.expr(child, current_klass) for child in node.nodes]))+")"
- return expr
-
- def _for(self, node, current_klass):
- assign_name = ""
- assign_tuple = ""
-
- # based on Bob Ippolito's Iteration in Javascript code
- if isinstance(node.assign, ast.AssName):
- assign_name = node.assign.name
- self.add_local_arg(assign_name)
- if node.assign.flags == "OP_ASSIGN":
- op = "="
- elif isinstance(node.assign, ast.AssTuple):
- op = "="
- i = 0
- for child in node.assign:
- child_name = child.name
- if assign_name == "":
- assign_name = "temp_" + child_name
- self.add_local_arg(child_name)
- assign_tuple += """
- var %(child_name)s %(op)s %(assign_name)s.__getitem__(%(i)i);
- """ % locals()
- i += 1
- else:
- raise TranslationError("unsupported type (in _for)", node.assign)
-
- if isinstance(node.list, ast.Name):
- list_expr = self._name(node.list, current_klass)
- elif isinstance(node.list, ast.Getattr):
- list_expr = self._getattr(node.list, current_klass)
- elif isinstance(node.list, ast.CallFunc):
- list_expr = self._callfunc(node.list, current_klass)
- else:
- raise TranslationError("unsupported type (in _for)", node.list)
-
- lhs = "var " + assign_name
- iterator_name = "__" + assign_name
-
- print >>self.output, """
- var %(iterator_name)s = %(list_expr)s.__iter__();
- try {
- while (true) {
- %(lhs)s %(op)s %(iterator_name)s.next();
- %(assign_tuple)s
- """ % locals()
- for node in node.body.nodes:
- self._stmt(node, current_klass)
- print >>self.output, """
- }
- } catch (e) {
- if (e.__name__ != pyjslib.StopIteration.__name__) {
- throw e;
- }
- }
- """ % locals()
-
-
- def _while(self, node, current_klass):
- test = self.expr(node.test, current_klass)
- print >>self.output, " while (pyjslib.bool(" + test + ")) {"
- if isinstance(node.body, ast.Stmt):
- for child in node.body.nodes:
- self._stmt(child, current_klass)
- else:
- raise TranslationError("unsupported type (in _while)", node.body)
- print >>self.output, " }"
-
-
- def _const(self, node):
- if isinstance(node.value, int):
- return str(node.value)
- elif isinstance(node.value, float):
- return str(node.value)
- elif isinstance(node.value, basestring):
- v = node.value
- if isinstance(node.value, unicode):
- v = v.encode('utf-8')
- return "String('%s')" % escapejs(v)
- elif node.value is None:
- return "null"
- else:
- raise TranslationError("unsupported type (in _const)", node)
-
- def _unaryadd(self, node, current_klass):
- return self.expr(node.expr, current_klass)
-
- def _unarysub(self, node, current_klass):
- return "-" + self.expr(node.expr, current_klass)
-
- def _add(self, node, current_klass):
- return self.expr(node.left, current_klass) + " + " + self.expr(node.right, current_klass)
-
- def _sub(self, node, current_klass):
- return self.expr(node.left, current_klass) + " - " + self.expr(node.right, current_klass)
-
- def _div(self, node, current_klass):
- return self.expr(node.left, current_klass) + " / " + self.expr(node.right, current_klass)
-
- def _mul(self, node, current_klass):
- return self.expr(node.left, current_klass) + " * " + self.expr(node.right, current_klass)
-
- def _mod(self, node, current_klass):
- if isinstance(node.left, ast.Const) and isinstance(node.left.value, StringType):
- self.imported_js.add("sprintf.js") # Include the sprintf functionality if it is used
- return "sprintf("+self.expr(node.left, current_klass) + ", " + self.expr(node.right, current_klass)+")"
- return self.expr(node.left, current_klass) + " % " + self.expr(node.right, current_klass)
-
- def _invert(self, node, current_klass):
- return "~" + self.expr(node.expr, current_klass)
-
- def _bitand(self, node, current_klass):
- return " & ".join([self.expr(child, current_klass) for child in node.nodes])
-
- def _bitshiftleft(self, node, current_klass):
- return self.expr(node.left, current_klass) + " << " + self.expr(node.right, current_klass)
-
- def _bitshiftright(self, node, current_klass):
- return self.expr(node.left, current_klass) + " >>> " + self.expr(node.right, current_klass)
-
- def _bitxor(self,node, current_klass):
- return " ^ ".join([self.expr(child, current_klass) for child in node.nodes])
-
- def _bitor(self, node, current_klass):
- return " | ".join([self.expr(child, current_klass) for child in node.nodes])
-
- def _subscript(self, node, current_klass):
- if node.flags == "OP_APPLY":
- if len(node.subs) == 1:
- return self.expr(node.expr, current_klass) + ".__getitem__(" + self.expr(node.subs[0], current_klass) + ")"
- else:
- raise TranslationError("must have one sub (in _subscript)", node)
- else:
- raise TranslationError("unsupported flag (in _subscript)", node)
-
- def _subscript_stmt(self, node, current_klass):
- if node.flags == "OP_DELETE":
- print >>self.output, " " + self.expr(node.expr, current_klass) + ".__delitem__(" + self.expr(node.subs[0], current_klass) + ");"
- else:
- raise TranslationError("unsupported flag (in _subscript)", node)
-
- def _list(self, node, current_klass):
- return "new pyjslib.List([" + ", ".join([self.expr(x, current_klass) for x in node.nodes]) + "])"
-
- def _dict(self, node, current_klass):
- items = []
- for x in node.items:
- key = self.expr(x[0], current_klass)
- value = self.expr(x[1], current_klass)
- items.append("[" + key + ", " + value + "]")
- return "new pyjslib.Dict([" + ", ".join(items) + "])"
-
- def _tuple(self, node, current_klass):
- return "new pyjslib.Tuple([" + ", ".join([self.expr(x, current_klass) for x in node.nodes]) + "])"
-
- def _lambda(self, node, current_klass):
- if node.varargs:
- raise TranslationError("varargs are not supported in Lambdas", node)
- if node.kwargs:
- raise TranslationError("kwargs are not supported in Lambdas", node)
- res = cStringIO.StringIO()
- arg_names = list(node.argnames)
- function_args = ", ".join(arg_names)
- for child in node.getChildNodes():
- expr = self.expr(child, None)
- print >> res, "function (%s){" % function_args
- self._default_args_handler(node, arg_names, None,
- output=res)
- print >> res, 'return %s;}' % expr
- return res.getvalue()
-
- def _slice(self, node, current_klass):
- if node.flags == "OP_APPLY":
- lower = "null"
- upper = "null"
- if node.lower != None:
- lower = self.expr(node.lower, current_klass)
- if node.upper != None:
- upper = self.expr(node.upper, current_klass)
- return "pyjslib.slice(" + self.expr(node.expr, current_klass) + ", " + lower + ", " + upper + ")"
- else:
- raise TranslationError("unsupported flag (in _slice)", node)
-
- def _global(self, node, current_klass):
- for name in node.names:
- self.method_imported_globals.add(name)
-
- def expr(self, node, current_klass):
- if isinstance(node, ast.Const):
- return self._const(node)
- # @@@ not sure if the parentheses should be here or in individual operator functions - JKT
- elif isinstance(node, ast.Mul):
- return " ( " + self._mul(node, current_klass) + " ) "
- elif isinstance(node, ast.Add):
- return " ( " + self._add(node, current_klass) + " ) "
- elif isinstance(node, ast.Sub):
- return " ( " + self._sub(node, current_klass) + " ) "
- elif isinstance(node, ast.Div):
- return " ( " + self._div(node, current_klass) + " ) "
- elif isinstance(node, ast.Mod):
- return self._mod(node, current_klass)
- elif isinstance(node, ast.UnaryAdd):
- return self._unaryadd(node, current_klass)
- elif isinstance(node, ast.UnarySub):
- return self._unarysub(node, current_klass)
- elif isinstance(node, ast.Not):
- return self._not(node, current_klass)
- elif isinstance(node, ast.Or):
- return self._or(node, current_klass)
- elif isinstance(node, ast.And):
- return self._and(node, current_klass)
- elif isinstance(node, ast.Invert):
- return self._invert(node, current_klass)
- elif isinstance(node, ast.Bitand):
- return "("+self._bitand(node, current_klass)+")"
- elif isinstance(node,ast.LeftShift):
- return self._bitshiftleft(node, current_klass)
- elif isinstance(node, ast.RightShift):
- return self._bitshiftright(node, current_klass)
- elif isinstance(node, ast.Bitxor):
- return "("+self._bitxor(node, current_klass)+")"
- elif isinstance(node, ast.Bitor):
- return "("+self._bitor(node, current_klass)+")"
- elif isinstance(node, ast.Compare):
- return self._compare(node, current_klass)
- elif isinstance(node, ast.CallFunc):
- return self._callfunc(node, current_klass)
- elif isinstance(node, ast.Name):
- return self._name(node, current_klass)
- elif isinstance(node, ast.Subscript):
- return self._subscript(node, current_klass)
- elif isinstance(node, ast.Getattr):
- return self._getattr(node, current_klass)
- elif isinstance(node, ast.List):
- return self._list(node, current_klass)
- elif isinstance(node, ast.Dict):
- return self._dict(node, current_klass)
- elif isinstance(node, ast.Tuple):
- return self._tuple(node, current_klass)
- elif isinstance(node, ast.Slice):
- return self._slice(node, current_klass)
- elif isinstance(node, ast.Lambda):
- return self._lambda(node, current_klass)
- else:
- raise TranslationError("unsupported type (in expr)", node)
-
-
-
-import cStringIO
-
-def translate(file_name, module_name, debug=False):
- f = file(file_name, "r")
- src = f.read()
- f.close()
- output = cStringIO.StringIO()
- mod = compiler.parseFile(file_name)
- t = Translator(module_name, module_name, module_name, src, debug, mod, output)
- return output.getvalue()
-
-
-class PlatformParser:
- def __init__(self, platform_dir = "", verbose=True):
- self.platform_dir = platform_dir
- self.parse_cache = {}
- self.platform = ""
- self.verbose = verbose
-
- def setPlatform(self, platform):
- self.platform = platform
-
- def parseModule(self, module_name, file_name):
-
- importing = False
- if not self.parse_cache.has_key(file_name):
- importing = True
- mod = compiler.parseFile(file_name)
- self.parse_cache[file_name] = mod
- else:
- mod = self.parse_cache[file_name]
-
- override = False
- platform_file_name = self.generatePlatformFilename(file_name)
- if self.platform and os.path.isfile(platform_file_name):
- mod = copy.deepcopy(mod)
- mod_override = compiler.parseFile(platform_file_name)
- self.merge(mod, mod_override)
- override = True
-
- if self.verbose:
- if override:
- print "Importing %s (Platform %s)" % (module_name, self.platform)
- elif importing:
- print "Importing %s" % (module_name)
-
- return mod, override
-
- def generatePlatformFilename(self, file_name):
- (module_name, extension) = os.path.splitext(os.path.basename(file_name))
- platform_file_name = module_name + self.platform + extension
-
- return os.path.join(os.path.dirname(file_name), self.platform_dir, platform_file_name)
-
- def merge(self, tree1, tree2):
- for child in tree2.node:
- if isinstance(child, ast.Function):
- self.replaceFunction(tree1, child.name, child)
- elif isinstance(child, ast.Class):
- self.replaceClassMethods(tree1, child.name, child)
-
- return tree1
-
- def replaceFunction(self, tree, function_name, function_node):
- # find function to replace
- for child in tree.node:
- if isinstance(child, ast.Function) and child.name == function_name:
- self.copyFunction(child, function_node)
- return
- raise TranslationError("function not found: " + function_name, function_node)
-
- def replaceClassMethods(self, tree, class_name, class_node):
- # find class to replace
- old_class_node = None
- for child in tree.node:
- if isinstance(child, ast.Class) and child.name == class_name:
- old_class_node = child
- break
-
- if not old_class_node:
- raise TranslationError("class not found: " + class_name, class_node)
-
- # replace methods
- for function_node in class_node.code:
- if isinstance(function_node, ast.Function):
- found = False
- for child in old_class_node.code:
- if isinstance(child, ast.Function) and child.name == function_node.name:
- found = True
- self.copyFunction(child, function_node)
- break
-
- if not found:
- raise TranslationError("class method not found: " + class_name + "." + function_node.name, function_node)
-
- def copyFunction(self, target, source):
- target.code = source.code
- target.argnames = source.argnames
- target.defaults = source.defaults
- target.doc = source.doc # @@@ not sure we need to do this any more
-
-def dotreplace(fname):
- path, ext = os.path.splitext(fname)
- return path.replace(".", "/") + ext
-
-class AppTranslator:
-
- def __init__(self, library_dirs=[], parser=None, dynamic=False,
- optimize=False, verbose=True):
- self.extension = ".py"
- self.optimize = optimize
- self.library_modules = []
- self.overrides = {}
- self.library_dirs = path + library_dirs
- self.dynamic = dynamic
- self.verbose = verbose
-
- if not parser:
- self.parser = PlatformParser()
- else:
- self.parser = parser
-
- self.parser.dynamic = dynamic
-
- def findFile(self, file_name):
- if os.path.isfile(file_name):
- return file_name
-
- for library_dir in self.library_dirs:
- file_name = dotreplace(file_name)
- full_file_name = os.path.join(
- os.path.abspath(os.path.dirname(__file__)), library_dir, file_name)
- if os.path.isfile(full_file_name):
- return full_file_name
-
- fnameinit, ext = os.path.splitext(file_name)
- fnameinit = fnameinit + "/__init__.py"
-
- full_file_name = os.path.join(
- os.path.abspath(os.path.dirname(__file__)), library_dir, fnameinit)
- if os.path.isfile(full_file_name):
- return full_file_name
-
- raise Exception("file not found: " + file_name)
-
- def _translate(self, module_name, is_app=True, debug=False,
- imported_js=set()):
- if module_name not in self.library_modules:
- self.library_modules.append(module_name)
-
- file_name = self.findFile(module_name + self.extension)
-
- output = cStringIO.StringIO()
-
- f = file(file_name, "r")
- src = f.read()
- f.close()
-
- mod, override = self.parser.parseModule(module_name, file_name)
- if override:
- override_name = "%s.%s" % (self.parser.platform.lower(),
- module_name)
- self.overrides[override_name] = override_name
- if is_app:
- mn = '__main__'
- else:
- mn = module_name
- t = Translator(mn, module_name, module_name,
- src, debug, mod, output, self.dynamic, self.optimize,
- self.findFile)
-
- module_str = output.getvalue()
- imported_js.update(set(t.imported_js))
- imported_modules_str = ""
- for module in t.imported_modules:
- if module not in self.library_modules:
- self.library_modules.append(module)
- #imported_js.update(set(t.imported_js))
- #imported_modules_str += self._translate(
- # module, False, debug=debug, imported_js=imported_js)
-
- return imported_modules_str + module_str
-
-
- def translate(self, module_name, is_app=True, debug=False,
- library_modules=[]):
- app_code = cStringIO.StringIO()
- lib_code = cStringIO.StringIO()
- imported_js = set()
- self.library_modules = []
- self.overrides = {}
- for library in library_modules:
- if library.endswith(".js"):
- imported_js.add(library)
- continue
- self.library_modules.append(library)
- if self.verbose:
- print 'Including LIB', library
- print >> lib_code, '\n//\n// BEGIN LIB '+library+'\n//\n'
- print >> lib_code, self._translate(
- library, False, debug=debug, imported_js=imported_js)
-
- print >> lib_code, "/* initialize static library */"
- print >> lib_code, "%s%s();\n" % (UU, library)
-
- print >> lib_code, '\n//\n// END LIB '+library+'\n//\n'
- if module_name:
- print >> app_code, self._translate(
- module_name, is_app, debug=debug, imported_js=imported_js)
- for js in imported_js:
- path = self.findFile(js)
- if os.path.isfile(path):
- if self.verbose:
- print 'Including JS', js
- print >> lib_code, '\n//\n// BEGIN JS '+js+'\n//\n'
- print >> lib_code, file(path).read()
- print >> lib_code, '\n//\n// END JS '+js+'\n//\n'
- else:
- print >>sys.stderr, 'Warning: Unable to find imported javascript:', js
- return lib_code.getvalue(), app_code.getvalue()
-
-usage = """
- usage: %s file_name [module_name]
-"""
-
-def main():
- import sys
- if len(sys.argv)<2:
- print >> sys.stderr, usage % sys.argv[0]
- sys.exit(1)
- file_name = os.path.abspath(sys.argv[1])
- if not os.path.isfile(file_name):
- print >> sys.stderr, "File not found %s" % file_name
- sys.exit(1)
- if len(sys.argv) > 2:
- module_name = sys.argv[2]
- else:
- module_name = None
- print translate(file_name, module_name),
-
-if __name__ == "__main__":
- main()
-