beremiz: comparison svgui/pyjs/pyjs.py

equal deleted inserted replaced

-:b789b695b5c6
+:dd94b9a68c61
 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, "    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:
 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,
 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.
 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):
 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:
 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:
 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:
 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)
 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 \
 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"
 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 + ")) {"
 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]
 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 = "==="
 elif op == "is not":
 op = "!=="
 return "(" + lhs + " " + op + " " + rhs + ")"
 def _not(self, node, current_klass):
 expr = self.expr(node.expr, current_klass)
 return "!(" + expr + ")"
 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 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")
 #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()

changeset 1741	dd94b9a68c61
parent 1740	b789b695b5c6
child 1742	92932cd370a4