diff -r 3edd2f19bce2 -r e0424e96e3fd svgui/pyjs/pyjs.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/svgui/pyjs/pyjs.py	Sat May 12 11:21:10 2012 +0200
@@ -0,0 +1,1777 @@
+#!/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()
+