diff --git a/README.md b/README.md
index 43939fa..db3e43f 100644
--- a/README.md
+++ b/README.md
@@ -1,751 +1,284 @@
-##PythonJS 0.8.9
-
-
-
-Community
----------
-
-[https://groups.google.com/forum/#!forum/pythonjs](https://groups.google.com/forum/#!forum/pythonjs)
-
-irc freenode::
-
- #pythonjs
-
Introduction
-======
-
-PythonJS is a Python to Javascript translator written in
-Python, created by Amirouche Boubekki and Brett Hartshorn,
-currently maintained and developed by Brett. It features:
-list comprehensions, classes, multiple inheritance, operator
-overloading, function and class decorators, generator functions,
-HTML DOM, and easily integrates with JavaScript and external JavaScript
-libraries. The generated code works in the Browser and in NodeJS.
-Note: the Dart, CoffeeScript and Lua backends are still very experimental.
-
-Speed
----------------
-PythonJS allows you to select which features you need for
-each section of your code, where you need performance you
-can disable operator overloading, and other slow operations.
-Features can be switched off and on for blocks of code using
-`pythonjs.configure()` or the special `with` statements and
-decorators described below. When PythonJS is run in fastest
-mode (javascript mode) it beats PyPy in the Richards, and N-Body benchmarks.
-
-
-
-N-Body benchmark, PythonJS in javascript mode has similar performance to Dart.
-
-##pypubjs - integrated develop environment
-
-[](http://www.youtube.com/watch?v=WjIGAUbcN9Q)
-
-PythonJS includes an IDE called __pypubjs__ that is built using Node-Webkit, Ace.js, and Empythoned. It runs on Linux, OSX, and Windows.
-
-
-Directly Calling JavaScript Functions
----------------
-
-####HTML DOM Example
-
-
-
-
-
-
-
-
-
-
-
-
-
-PythonJS allows you to call any JavaScript function directly
-by wrapping it at runtime. Attributes of JavaScript objects
-are also returned directly, like document.body. This allows
-you to use the HTML DOM API just as you would in normal
-JavaScript.
-
-If the JavaScript function you are calling takes a JavaScript
-Object as the last argument you can call the function using
-keyword arguments and they will be automatically converted
-to a JavaScript Object. Any dictionaries or lists you pass
-to a JavaScript function will be converted to: Array or Object.
-
-####Example
-
-
-
-
-
-
-translator.py
------------
-To convert your python script into javascript use translator.py located in the "pythonjs" directory. You can give it a list of python files to translate at once. It will output the translation to stdout. The default output type is JavaScript.
-
-Usage::
-
- translator.py [--dart|--coffee] file.py
-
-Example::
-
- cd PythonJS
- pythonjs/translator.py --coffee myscript.py > myscript.coffee
+PythonJS is a transpiler written in Python that converts a python like language into fast
+JavaScript. It also includes experimental backends that translate to: Dart, Lua, CoffeeScript, and Go.
+[Syntax Documentation](https://github.com/PythonJS/PythonJS/blob/master/doc/syntax.md)
-How does translation work?
-----------------
-Translation to JavaScript is done in two steps::
-
- +------------+ +-----------------+ +------------+
- ¦ .py source ¦--->¦ pythonjs subset ¦--->¦ .js source ¦
- +------------+ +-----------------+ +------------+
-
-First, the script walks the AST tree of Python source and
-translates it into the subset of Python called `pythonjs`.
-This reduced subset is still valid Python code, and its
-AST gets parsed again in the second translation phase
-that converts it into final JavaScript form.
-
-
-Python vs JavaScript Modes
--------------------------
-
-PythonJS has two primary modes you can write code in: `python` and `javascript`. The default mode is `python`, you can mark sections of your code to use either mode with `pythonjs.configure(javascript=True/False)` or nesting blocks inside `with python:` or `with javascript:`. The `javascript` mode can be used for sections of code where performance is a major concern. When in `javascript` mode Python dictionaries become JavaScript Objects. In both modes you can directly call external JavaScript functions, its only faster in `javascript` mode because function calls are direct without any wrapping.
-
-
-Function Types
----------------
-
-PythonJS has three main types of functions: `normal`, `fastdef`, and `javascript`.
+Go backend
+----------
+The Go backend uses a fully typed subset of Python, mixed with extra syntax inspired by Golang to output Go programs that can be compiled to native executeables, or translated to JavaScript using GopherJS.
-By default a function is "normal" and fully emulates the Python standard, it allows for: arguments, keyword args with defaults, variable length arguments (*args) and variable length keyword args (**kwargs). Functions that are "normal" also have special logic that allows them to be called from external JavaScript like normal JavaScript functions (keyword args become normal positional arguments when called from JavaScript). Calling "normal" functions is slow because of this overhead, when you need faster function calls you can use "fastdef" or "javascript".
+[Syntax Documentation](https://github.com/PythonJS/PythonJS/blob/master/doc/go_syntax.md)
-Functions decorated with `@fastdef`, or inside a `with fastdef:` block become "fastdef" type functions. This makes calling them faster, but they do not support variable length arguments (*args) or variable length keyword args (**kwargs).
-Another limitation is that when called from external JavaScript you must pack args into an Array as the first argument, and pack keyword arguments into an Object as the second argument.
-Functions decorated with @javascript, or inside a `with javascript:` block, or following the call: `pythonjs.configure(javascript=True)` become `javascript` type functions, these offer the highest calling speed. They do not support *args or **kwargs. When called from external JavaScript, keyword arguments are not given by name, they become positional arguments that default to the default value if undefined. When called from within PythonJS code, they need to be called from inside a `with javascript:` block, or following the call `pythonjs.configure(javascript=True)` that sets all following code to be in `javascript` mode.
+Getting Started
+===============
+PythonJS can be run with regular Python, or fully self-hosted within
+NodeJS using Empythoned.
-####Example
+To get started, you have two options:
+1. install NodeJS, python-js package, and write a build script.
+2. or install Python2 and use translator.py from this repo directly.
- pythonjs.configure( javascript=True )
- def myfunc(x,y,z, a=1,b=2,c=3):
- print x,y,z,a,b,c
+1. Installing NodeJS Package
+-------------
+You can quickly get started with the stable version of PythonJS by installing the NodeJS package,
+and writing a build script in javascript to compile your python scripts to javascript.
+(Python2.7 is not required)
-####Example JavaScript Translation
+```
+npm install python-js
+```
- myfunc = function(x, y, z, a, b, c) {
- if (a === undefined) a = 1;
- if (b === undefined) b = 2;
- if (c === undefined) c = 3;
- console.log(x, y, z, a, b, c);
- }
+NodeJS Quick Example
+--------------
-Class Types
------------
+```
+var pythonjs = require('python-js');
+var pycode = "a = []; a.append('hello'); a.append('world'); print(a)";
+var jscode = pythonjs.translator.to_javascript( pycode );
+eval( pythonjs.runtime.javascript + jscode );
-PythonJS has two types of classes: `normal` and `javascript`. By default classes are `normal` and support operator overloading and properties. Calling methods on a `javascript` class is much faster than method calls on a `normal` class, but follow the same rules as described above for `javascript` type functions. Both class types can be used from external JavaScript, the only difference is that instances of a "normal" class can pass their methods directly as arguments to a function that will use the method as a callback - even if that external function depends on the context of `this`. Whereas instances of a `javascript` class can not directly pass their methods as arguments, because they depend on the calling context of `this` - if you are familiar with JavaScript this comes as no surprise.
+```
-Example::
- pythonjs.configure( javascript=True )
- class A:
- def __init__(self, x,y,z):
- self.x = x
- self.y = y
- self.z = z
-
- def foo(self, w):
- return self.x + w
-
-Example JavaScript Translation::
-
- A = function(x, y, z) {
- A.__init__(this, x,y,z);
- }
-
- A.prototype.__init__ = function(x, y, z) {
- this.x=x;
- this.y=y;
- this.z=z;
- }
- A.__init__ = function () { return A.prototype.__init__.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };
-
- A.prototype.foo = function(w) {
- return (this.x + w);
- }
- A.foo = function () { return A.prototype.foo.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };
-
-
-Method Overrides
+Example Projects
----------------
-In the example above, you might be wondering why in the JavaScript translation, is the class A constructor calling `A.__init__(this, x,y,z)`, and why is the `__init__` method assigned `A.prototype` and then wrapped and assigned to `A.__init__`. This is done so that subclasses are able to override their parent's methods, but still have a way of calling them, an example that subclasses A will make this more clear.
-
-####Example
-
- class B( A ):
- def __init__(self, w):
- A.__init__(self, 10, 20, 30)
- self.w = w
-
-####Example JavaScript Translation
-
- B = function(w) {
- B.__init__(this, w);
- }
-
- B.prototype.__init__ = function(w) {
- A.__init__(this,10,20,30);
- this.w=w;
- }
- B.__init__ = function () { return B.prototype.__init__.apply(arguments[0], Array.prototype.slice.call(arguments,1)) };
-
- for (var n in A.prototype) { if (!(n in B.prototype)) { B.prototype[n] = A.prototype[n] }};
-
-
-The above output Javascript shows how the constructor for `B` calls `B.__init__` which then calls `B.prototype.__init__`.
-`B.prototype.__init__` calls `A.__init__` passing `this` as the first argument. This emulates in JavaScript how unbound methods work in Python. When using the Dart backend, the output is different but the concept is the same - static "class methods" are created that implement the method body, the instance methods are just short stubs that call the static "class methods".
-
-####Example Dart Translation
-
- class B implements A {
- var y;
- var x;
- var z;
- var w;
- B(w) {B.__init__(this,w);}
- static void __init__(self, w) {
- A.__init__(self,10,20,30);
- self.w=w;
- }
-
- foo(w) { return A.__foo(this,w); }
- }
-
-Above the method `foo` calls the static class method `A.__foo`. Note that the static class methods are automatically prefixed with `__`.
-
+The example projects below, require the NodeJS python-js package.
-Multiple Inheritance
---------------------
+[https://github.com/PythonJS/pythonjs-demo-server-nodejs](https://github.com/PythonJS/pythonjs-demo-server-nodejs)
-Multiple inheritance is fully supported for both JavaScript and Dart backends. When using the Dart backend it will generate stub-methods that call static class methods that are prefixed with `__`.
-Methods that the subclass extends can call: ParentClassName.some_method(self) and this will be translated into: ParentClassName.__some_method(this)
+[https://github.com/PythonJS/pypubjs](https://github.com/PythonJS/pypubjs)
-#### Example
- class A:
- def foo(self):
- print 'foo'
- class B:
- def bar(self):
- print 'bar'
-
- class C( A, B ):
- def call_foo_bar(self):
- print 'call_foo_bar in subclass C'
- self.foo()
- self.bar()
-
- ## extend foo ##
- def foo(self):
- A.foo(self)
- print 'foo extended'
-
-#### Example Dart Translation
-
- class A {
- foo() { return A.__foo(this); }
- static __foo(self) {
- print("foo");
- }
-
- }
- class B {
- bar() { return B.__bar(this); }
- static __bar(self) {
- print("bar");
- }
-
- }
- class C implements A, B {
- call_foo_bar() { return C.__call_foo_bar(this); }
- static __call_foo_bar(self) {
- print("call_foo_bar in subclass C");
- self.foo();
- self.bar();
- }
-
- foo() { return C.__foo(this); }
- static __foo(self) {
- A.__foo(self);
- print("foo extended");
- }
-
- bar() { return B.__bar(this); }
- }
-
-
-Generator Functions
--------------------
-
-Functions that use the `yield` keyword are generator functions. They allow you to quickly write complex iterables.
-PythonJS supports simple generator functions that have a single for loop, and up to three `yield` statements.
-The first `yield` comes before the for loop, and the final `yield` comes after the for loop.
-The compiler will translate your generator function into a simple class with state-machine. This implementation
-bypasses using the native JavaScript `yield` keyword, and ensures that your generator function can work in all web browsers.
-
-Instances of the generator function will have a next method. Using a for loop to iterate over a generator function will automatically call its next method.
-
-####Example
-
- def fib(n):
- yield 'hello'
- a, b = 0, 1
- for x in range(n):
- yield a
- a,b = b, a+b
- yield 'world'
-
- def test():
- for n in fib(20):
- print n
-
-####Example Output
-
- fib = function(n) {
- this.n = n;
- this.__head_yield = "hello";
- this.__head_returned = 0;
- var __r_0;
- __r_0 = [0, 1];
- this.a = __r_0[0];
- this.b = __r_0[1];
- this.__iter_start = 0;
- this.__iter_index = 0;
- this.__iter_end = this.n;
- this.__done__ = 0;
- }
-
- fib.prototype.next = function() {
- if (( this.__head_returned ) == 0) {
- this.__head_returned = 1;
- return this.__head_yield;
- } else {
- if (( this.__iter_index ) < this.__iter_end) {
- __yield_return__ = this.a;
- var __r_1;
- __r_1 = [this.b, (this.a + this.b)];
- this.a = __r_1[0];
- this.b = __r_1[1];
- this.__iter_index += 1
- return __yield_return__;
- } else {
- this.__done__ = 1;
- __yield_return__ = "world";
- return __yield_return__;
- }
- }
- }
-
- test = function(args, kwargs) {
- var __iterator__, n;
- var n, __generator__;
- __generator__ = new fib(20);
- while(( __generator__.__done__ ) != 1) {
- n = __generator__.next();
- console.log(n);
- }
- }
-
-
----------------
-
-Inline JavaScript
----------------
-
-There are times that JavaScript needs to be directly inlined
-into PythonJS code, this is done with the special
-`JS([str])` function that takes a string literal as its only
-argument. The compiler will insert the string directly into
-the final output JavaScript.
-
-####JS Example
-
- JS("var arr = new Array()")
- JS("var ob = new Object()")
- JS("ob['key'] = 'value'")
- if JS("Object.prototype.toString.call( arr ) === '[object Array]'"):
- JS("arr.push('hello world')")
- JS("arr.push( ob )")
-
-In the example above we create a new JavaScript Array.
-Notice that the if-statement above has a condition that is
-inlined JavaScript. Lets take a look at two alternative
-ways this can be rewritten.
-
-1. JSArray, JSObject, and instanceof::
-
- arr = JSArray()
- ob = JSObject()
- if instanceof(arr, Array):
- arr.push('hello world')
- arr.push( ob )
-
-The special function JSArray will create a new JavaScript
-Array object, and JSObject creates a new JavaScript Object.
-The `instanceof` function will be translated into using the
-'instanceof' JavaScript operator. At the end, arr.push is
-called without wrapping it in `JS()`, this is allowed because
-from PythonJS, we can directly call JavaScript functions by
-dynamically wrapping it at runtime.
-
-This code is more clear than before, but the downside is
-that the calls to arr.push will be slower because it gets
-wrapped at runtime. To have fast and clear code we need to
-use the final method below, `with javascript`
-
-2. with javascript::
-
- with javascript:
- arr = []
- ob = {}
- if instanceof(arr, Array):
- arr.push('hello world')
- arr.push( ob )
-
-The `with javascript:` statement can be used to mark a block
-of code as being direct JavaScript. The compiler will
-basically wrap each line it can in JS() calls. The calls to
-arr.push will be fast because there is no longer any runtime
-wrapping. Instead of using JSArray and JSObject you just
-use the literal notation to create them.
-
----------------
-
-Calling PythonJS Functions from JavaScript
-------------------------------
-
-PythonJS functions can be used as callbacks in Javascript
-code, there are no special calling conventions that you need
-to worry about. Simply define a function in PythonJS and
-call it from JavaScript. Note that if your PythonJS
-function uses keyword arguments, you can use them as a
-normal positional arguments.
-
-####Example
-
- # PythonJS
- def my_pyfunction( a,b,c, optional='some default'):
- print a,b,c, optional
-
- // javascript
- my_pyfunction( 1,2,3, 'my kwarg' );
-
-
----------------
-
-Calling PythonJS Methods from JavaScript
-------------------------------
-
-Calling PythonJS methods is also simple, you just need to
-create an instance of the class in PythonJS and then pass
-the method to a JavaScript function, or assign it to a new
-variable that the JavaScript code will use. PythonJS takes
-care of wrapping the method for you so that `self` is bound
-to the method, and is callable from JavaScript.
-
-####Example
-
- // javascript
- function js_call_method( method_callback ) {
- method_callback( 1,2,3 )
- }
-
- # PythonJS
- class A:
- def my_method(self, a,b,c):
- print self, a,b,c
- self.a = a
- self.b = b
- self.c = c
-
- a = A()
- js_call_method( a.my_method )
-
-
----------------
-
-Passing PythonJS Instances to JavaScript
-------------------------------
-
-If you are doing something complex like deep integration
-with an external JavaScript library, the above technique of
-passing each method callback to JavaScript might become
-inefficient. If you want to pass the PythonJS instance
-itself and have its methods callable from JavaScript, you
-can do this now simply by passing the instance.
-
-####Example
-
- // javascript
- function js_function( pyob ) {
- pyob.foo( 1,2,3 )
- pyob.bar( 4,5,6 )
- }
-
- # PythonJS
- class A:
- def foo(self, a,b,c):
- print a+b+c
- def bar(self, a,b,c):
- print a*b*c
-
- a = A()
- js_function( a )
-
-
----------------
-
-Define JavaScript Prototypes from PythonJS
-------------------------------
-
-If you are going beyond simple integration with an external
-JavaScript library, and perhaps want to change the way it
-works on a deeper level, you can modify JavaScript
-prototypes from PythonJS using some special syntax.
+2. translator.py
+--------------------------------------
+If you want to run the latest version of the translator, you will need to install
+Python2.7 and git clone this repo. (the NodeJS package above is not required)
+Then, to translate your python script, directly run the `translator.py` script in the "pythonjs" directory. You can give it a list of python files to translate at once.
+It will output the translation to stdout. The default output type is JavaScript.
+An html file can also be used as input, python code inside a script tag: `
-
+1. The calling context of `this` must be taken into account when using fast javascript mode, code that comes after: `pythonjs.configure(javascript=True)` or is inside a `with javascript:` block. When in javascript mode, passing a method as a callback, or setting it as an attribute on another object, requires you call `f.bind(self)` to ensure that `self` within the method points to the class instance. This is not required when using classes defined normal mode, because the `this` calling context is automatically managed.
+Note: you can use the special `->` syntax in place of the attribute operator `.` to call `bind` automatically.
-The server knows that above is an embedded Python script
-because the script tag has its type attribute set to
-"text/python". The server will compile and replace the
-Python code with JavaScript, change the type attribute to be
-"text/javascript", and serve the page to the client.
+```
+class A:
+ def method(self):
+ print(self)
+a = A()
-
+with javascript:
+ class B:
+ def method(self):
+ print(self)
+
+ b = B()
+ a.b_method1 = b.method
+ a.b_method2 = b.method.bind(b)
+ a.b_method3 = b->method
+
+ a.method() ## OK: prints a
+ a.b_method1() ## FAILS: prints a, should have printed b
+ a.b_method2() ## OK: prints b
+ a.b_method3() ## OK: prints b
+
+ b.a_method = a.method
+ b.a_method() ## OK: prints a
+
+```
+
+2. When using direct operators, builtins are also affected. List + list will no longer return a new array of items from both lists. String * N will no longer return the string multipled by the number.
+
+```
+a = [1,2] + [3,4] ## OK: a is [1,2,3,4]
+pythonjs.configure(direct_operator="+")
+b = [1,2] + [3,4] ## FAILS
+
+c = "HI" * 2 ## OK: c is "HIHI"
+pythonjs.configure(direct_operator="*")
+d = "HI" * 2 ## FAILS
+
+```
+
+3. The syntax `from mymodule import *` allows you to import another python script from the same folder,
+but both mymodule and the parent will share the same namespace, mymodule can use global variables defined in the parent.
+
+4. Using tuples as keys in a dict is allowed, the tuple may contain other tuples, objects, and a mix of numbers or strings.
+Note that tuples in PythonJS are actually JavaScript arrays, so if you modify the contents of the tuple, it would no
+longer be the same key in a dict.
+```
+a = (1,2,3)
+b = ("1","2","3")
+D = { a: 'hello', b: 'world' }
+D[ a ] == 'hello' ## OK
+D[ b ] == 'world' ## OK
+```
+
+5. AttributeError and KeyError are only raised in javascript mode when inside a block that catches those errors.
+In the default python mode these errors will always be thrown, and halt the program.
+```
+pythonjs.configure(javascript=True)
+a = {}
+# this will not throw any error
+b = a['xxx']
+# this works as expected, "b" will be set to "my-default"
+b = a['xxx'] except KeyError: 'my-default'
+```
diff --git a/bindings/ace.py b/bindings/ace.py
deleted file mode 100644
index 5ac9bb8..0000000
--- a/bindings/ace.py
+++ /dev/null
@@ -1,31 +0,0 @@
-# PythonJS binding for Ace Editor http://ace.c9.io/
-# by Brett Hartshorn - copyright 2013
-# License: "New BSD"
-
-class AceEditor:
- def __init__(self, div_id='editor', mode='python', theme=None):
- with javascript: self[...] = ace.edit( div_id )
- if mode: self.setMode( mode )
- if theme: self.setTheme( theme )
-
- def setMode(self, mode):
- with javascript:
- self[...].getSession().setMode( 'ace/mode/'+mode )
-
- def setTheme(self, name='monokai'):
- with javascript:
- self[...].setTheme( 'ace/theme/'+name)
-
- def setValue(self, txt):
- with javascript:
- self[...].setValue( txt )
-
- def getValue(self):
- with javascript:
- return self[...].getValue()
-
- def setFontSize(self, size):
- with javascript:
- self[...].setFontSize( size )
-
-
diff --git a/bindings/ast.py b/bindings/ast.py
deleted file mode 100644
index 6bff943..0000000
--- a/bindings/ast.py
+++ /dev/null
@@ -1,841 +0,0 @@
-# Brython AST to Python AST Bridge
-# by Brett Hartshorn - copyright 2013
-# License: "New BSD"
-
-def brython_tokenize(src):
- module = 'test'
- return JS('__BRYTHON__.$tokenize(src, module)')
-
-_decorators = []
-def push_decorator(ctx):
- _decorators.append( ctx )
-def pop_decorators():
- arr = list( _decorators )
- _decorators.length = 0 ## javascript style
- return arr
-
-class Pass:
- def __init__(self, ctx, node):
- pass
-
-class Not:
- def __init__(self, ctx=None, node=None):
- if ctx:
- self.value = to_ast_node(ctx.tree[0]) ## not standard python
- else:
- self.value = None
-
-class List:
- def __init__(self, ctx, node):
- self.elts = []
- #self.ctx = 'Load' # 'Store' is (x,y,z) = w
- for a in ctx.tree:
- self.elts.append( to_ast_node(a) )
-
-class comprehension:
- def __init__(self, ctx):
- if ctx.type != 'comp_for': raise TypeError
- target = ctx.tree[0]
- iter = ctx.tree[1]
- if target.type != 'target_list': raise TypeError
- if iter.type != 'comp_iterable': raise TypeError
-
- self.target = to_ast_node( target.tree[0] ) ## TODO support mutiple targets
- self.iter = to_ast_node( iter.tree[0] )
- self.ifs = []
-
-class ListComp:
- def __init__(self, ctx, node):
- self.elt = to_ast_node(ctx.expression[0]) ## TODO support mutiple
- self.generators = []
- self._vars = ctx.vars ## brython catches all names
- for c in ctx.tree:
- if c.type == 'comprehension':
- if len(c.tree) == 1:
- self.generators.append( comprehension(c.tree[0]) )
- else:
- raise TypeError
- else:
- raise TypeError
-
-class Tuple:
- def __init__(self, ctx, node):
- self.elts = []
- #self.ctx = 'Load' # 'Store' is (x,y,z) = w
- for a in ctx.tree:
- self.elts.append( to_ast_node(a) )
-
-class Dict:
- def __init__(self, ctx, node):
- self.keys = []
- self.values = []
- #for i in range(0, len(ctx.items), 2): ## TODO fix me
- i = 0
- while i < len(ctx.items):
- key = ctx.items[i]
- val = ctx.items[i+1]
- self.keys.append( to_ast_node(key) )
- self.values.append( to_ast_node(val) )
- i += 2
-
-class Subscript:
- def __init__(self, ctx, node):
- self.value = to_ast_node(ctx.value)
- if len(ctx.tree) == 1:
- self.slice = Index(value=to_ast_node(ctx.tree[0]))
- elif len(ctx.tree) == 2:
- self.slice = Slice(
- lower=to_ast_node(ctx.tree[0]),
- upper=to_ast_node(ctx.tree[1])
- )
- elif len(ctx.tree) == 3:
- self.slice = Slice(
- lower=to_ast_node(ctx.tree[0]),
- upper=to_ast_node(ctx.tree[1]),
- step=to_ast_node(ctx.tree[2])
- )
- else:
- raise TypeError
- #self.ctx = 'Load', 'Store', 'Del'
-
-class Index:
- def __init__(self, value=None):
- self.value = value
-
-class Slice:
- def __init__(self, lower=None, upper=None, step=None):
- self.lower = lower
- self.upper = upper
- self.step = step
-
-class Assign:
- def _collect_targets(self, ctx):
- if ctx.type == 'expr' and ctx.name == 'id':
- a = ctx.tree[0]
- if a.type == 'id':
- self.targets.append( Name(ctx.tree[0]) )
- elif a.type == 'attribute' and a.func == 'getattr': #and a.value.type == 'id':
- self.targets.append( Attribute(a,None) )
- elif a.type == 'sub' and a.func == 'getitem':
- self.targets.append( to_ast_node(a) )
- else:
- print('_collect_targets ERROR!')
- print(ctx)
- raise TypeError
-
- elif ctx.type == 'assign':
- self._collect_targets( ctx.tree[0] )
- self._collect_targets( ctx.tree[1] )
-
- elif ctx.type == 'list_or_tuple':
- self.targets.append( to_ast_node(ctx) )
- else:
- print('_collect_targets ERROR')
- print( ctx )
- raise TypeError
-
- def __init__(self, ctx, node):
- self.targets = []
- self._collect_targets( ctx.tree[0] )
- self.value = to_ast_node( ctx.tree[1] ) ## should be an: expr.name==operand
-
-class AugAssign:
- #_previous = None ## DEPRECATED
- def __init__(self, ctx, node):
- #AugAssign._previous = self
- ctx.name = '' ## need to set name to nothing so that to_ast_node will not recurse back here
- self.target = to_ast_node(ctx)
- self.op = ctx.augm_assign['op']
- self.value = to_ast_node( ctx.tree[1] )
-
-class Num:
- def __init__(self, ctx, node):
- if ctx.value is None:
- raise TypeError
- self.n = ctx.value
-
-class Str:
- def __init__(self, ctx, node):
- #self.s = ctx.value ## old brython
- if len(ctx.tree) == 1:
- self.s = ctx.tree[0]
- else:
- raise TypeError
-
-class Name:
- def __init__(self, ctx=None, name=None):
- if name:
- self.id = name
- elif ctx.type == 'id':
- self.id = ctx.value
- else:
- print ctx
- raise TypeError
-
-class Add:
- pass
-class Sub:
- pass
-class Div:
- pass
-class FloorDiv:
- pass
-class Mult:
- pass
-class Mod:
- pass
-class Pow:
- pass
-class LShift:
- pass
-class RShift:
- pass
-class BitOr:
- pass
-class BitXor:
- pass
-class BitAnd:
- pass
-
-class Eq:
- pass
-class NotEq:
- pass
-class Lt:
- pass
-class LtE:
- pass
-class Gt:
- pass
-class GtE:
- pass
-class In:
- pass
-class NotIn:
- pass
-class Is:
- pass
-class IsNot:
- pass
-class And:
- pass
-class Or:
- pass
-
-_operators = {
- '+' : Add,
- '-' : Sub,
- '/' : Div,
- '//': FloorDiv,
- '*' : Mult,
- '%' : Mod,
- '**': Pow,
- '<<': LShift,
- '>>': RShift,
- '|' : BitOr,
- '^' : BitXor,
- '&' : BitAnd,
- '==': Eq,
- '!=': NotEq,
- '<' : Lt,
- '<=': LtE,
- '>' : Gt,
- '>=': GtE,
- 'in': In,
- 'not_in' : NotIn,
- 'is': Is,
- 'is_not': IsNot,
- 'and' : And,
- 'or' : Or,
-}
-
-class USub:
- pass
-class UAdd:
- pass
-class Invert:
- pass
-
-class UnaryOp:
- '''
- note: this is constructed directly from an abstract_expr
- '''
- def __init__(self, op=None, operand=None):
- self.operand = operand
- if op == '-':
- self.op = USub()
- elif op == '+':
- self.op = UAdd()
- elif op == '~':
- self.op = Invert()
- elif op == 'not':
- self.op = Not()
-
-class BinOp:
- def __init__(self, ctx, node):
- print 'BinOp', ctx
- if len(ctx.tree) != 2:
- raise TypeError
- self.left = to_ast_node( ctx.tree[0] )
- self.right = to_ast_node( ctx.tree[1] )
- if ctx.op in _operators:
- klass = _operators[ctx.op]
- self.op = klass()
- else:
- print('ERROR: unknown operator type')
- print(ctx)
- raise TypeError
-
-
-
-class _arguments:
- def __init__(self, ctx):
- self.args = [] ## in Python2 these are Name nodes, in Py3 they are "arg" objects with: `arg`=raw-string and `annotation`=astnode
- self.vararg = None # string
- self.kwarg = None # string
- self.defaults = []
- self.kw_defaults = []
-
- if ctx.type != 'func_args':
- print('_arguments class expects ctx.type of func_args')
- raise TypeError
- for c in ctx.tree:
- if c.type == 'func_arg_id':
- self.args.append( Name(name=c.name) )
- if len(c.tree):
- self.defaults.append( to_ast_node(c.tree[0]) )
-
- elif c.type == 'func_star_arg' and c.op=='*':
- self.vararg = c.name
- elif c.type == 'func_star_arg' and c.op=='**':
- self.kwarg = c.name
- else:
- raise TypeError
-
-class FunctionDef:
- def __init__(self, ctx, node):
- self.name = ctx.name ## raw string
- self.args = _arguments( ctx.tree[0] )
- self.body = []
- self.decorator_list = pop_decorators()
- self.returns = None ## python3 returns annotation
- print 'FunctionDef::', ctx
- for child in node.children:
- child_ctx = child.get_ctx()
- if child_ctx:
- anode = to_ast_node( child_ctx, node=child )
- if anode: ## ctx of type: 'single_kw' and token elif/else do not return an ast node
- self.body.append( anode )
-
-class _lambda_arguments:
- def __init__(self, ctx):
- self.args = []
- self.vararg = None # string
- self.kwarg = None # string
- self.defaults = []
- self.kw_defaults = []
- for c in ctx.tree:
- if c.type != 'call_arg': raise TypeError
- name = c.vars[0]
- self.args.append( Name(name=name) )
-
-class Lambda:
- def __init__(self, ctx, node):
- self.args = _lambda_arguments( ctx.args[0] )
- self.body = to_ast_node( ctx.tree[0] )
- self._locals = ctx.locals
- self._vars = ctx.vars
-
-class Return:
- def __init__(self, ctx, node):
- if ctx.tree[0].type == 'abstract_expr' and len(ctx.tree[0].tree)==0:
- self.value = None
- else:
- self.value = to_ast_node( ctx.tree[0] )
-
-
-class _keyword:
- def __init__(self, arg, value):
- self.arg = arg ## raw string
- self.value = value ## astnode
-
-class Call:
- def __init__(self, ctx, node):
- self.func = to_ast_node( ctx.func )
- self.args = []
- self.keywords = []
- self.starargs = None
- self.kwargs = None
-
- for c in ctx.tree:
- if c.type == 'call_arg':
- sub = c.tree[0]
- if sub.type == 'kwarg':
- k = _keyword(
- sub.tree[0].value,
- to_ast_node(sub.tree[1])
- )
- self.keywords.append( k )
- else:
- self.args.append( to_ast_node(c.tree[0]) )
-
- else:
- raise TypeError
-
-class Expr:
- def __init__(self, ctx, node):
- self.value = to_ast_node(ctx.tree[0])
-
-class ClassDef:
- def __init__(self, ctx, node):
- self.name = ctx.name
- self.bases = []
- self.body = []
- self.decorator_list = pop_decorators()
-
- if len(ctx.tree) == 1:
- e = ctx.tree[0]
- if e.type == 'expr' and e.name == 'tuple':
- t = e.tree[0]
- for b in t.tree:
- self.bases.append( Name(b.tree[0]) )
- else:
- raise TypeError
-
- for child in node.children:
- if child.get_ctx():
- anode = to_ast_node( child.get_ctx() )
- if anode:
- self.body.append( anode )
-
-
-class Attribute:
- def __init__(self, ctx, node):
- self.value = to_ast_node(ctx.value)
- self.attr = ctx.name
- self._func = ctx.func ## brython-extra: getattr/setattr
-
-
-class IfExp:
- '''
- if/elif/else could be translated to javascript switch/case more easily if we track elif statements,
- but the python standard simply treats elif statements as nested if statements in .orelse.
- In the future we can bend this rule when PythonJS becomes fully self-hosted.
- '''
- _previous = None
- def __init__(self, ctx, node):
- if ctx.token == 'if': ## can also be "elif" and "else"
- IfExp._previous = self
- self.test = to_ast_node( ctx.tree[0] )
- self.body = []
- self.orelse = []
- for child in node.children:
- anode = to_ast_node(child.get_ctx())
- if anode:
- self.body.append( anode )
-
-class For:
- def __init__(self, ctx, node):
- targets = ctx.tree[0]
- if targets.type != 'target_list':
- raise TypeError
- if len(targets.tree) == 1:
- self.target = to_ast_node( targets.tree[0] )
- else: ## pack into a ast.Tuple
- #print('TODO pack for-loop targets into ast.Tuple')
- #raise TypeError
- self.target = Tuple( targets )
-
- self.iter = to_ast_node( ctx.tree[1] )
- self.body = []
- for child in node.children:
- anode = to_ast_node(child.get_ctx())
- if anode:
- self.body.append( anode )
-
-class While:
- def __init__(self, ctx, node):
- self.test = to_ast_node( ctx.tree[0] )
- self.body = []
- for child in node.children:
- anode = to_ast_node(child.get_ctx())
- if anode:
- self.body.append( anode )
-
-class alias:
- def __init__(self, name=None, asname=None):
- self.name = name
- self.asname = asname
-
-class Import:
- def __init__(self, ctx, node):
- self.names = []
- for c in ctx.tree:
- self.names.append( alias(name=c.name,asname=c.alias) )
-
-class ImportFrom:
- def __init__(self, ctx, node):
- self.module = ctx.module
- self.names = []
- self.level = 0
- for name in ctx.names:
- self.names.append( alias(name=name) )
-
-class TryExcept:
- _stack = []
- def __init__(self, ctx, node):
- TryExcept._stack.append( self )
- self.body = []
- self.handlers = []
- self.orelse = []
- for child in node.children:
- self.body.append( to_ast_node(child.get_ctx()) )
-
-class ExceptHandler:
- def __init__(self, ctx, node):
- TryExcept._stack[-1].handlers.append(self)
- self.type = None
- self.name = None
- self.body = []
- if len(ctx.tree):
- self.type = to_ast_node(ctx.tree[0])
- for child in node.children:
- self.body.append( to_ast_node(child.get_ctx()) )
- #TryExcept._stack.pop()
-
-class Assert:
- def __init__(self, ctx, node):
- self.test = to_ast_node(ctx.tree[0])
- self.msg = None
-
-class Raise:
- '''
- Python2 and Python3 style
- '''
- def __init__(self, ctx, node):
- # Py3 style
- self.exc = to_ast_node(ctx.tree[0])
- if len(ctx.tree) > 1:
- self.cause = to_ast_node(ctx.tree[1])
- else:
- self.cause = None
- # Py2 style
- self.type = self.exc
- self.inst = self.cause
- self.tback = None
-
-
-__MAP = {
- 'def' : FunctionDef,
- 'lambda' : Lambda,
- 'assign' : Assign,
- 'return' : Return,
- 'expr' : Expr,
- 'call' : Call,
- 'int' : Num,
- 'str' : Str,
- 'id' : Name,
- 'class' : ClassDef,
- 'op' : BinOp,
- 'attribute' : Attribute,
- 'pass' : Pass,
- 'for' : For,
- 'not' : Not,
- 'sub' : Subscript,
- 'import' : Import,
- 'from' : ImportFrom,
- 'try' : TryExcept, ## note: there is also TryFinally
- 'assert' : Assert,
- 'raise' : Raise,
-}
-
-def to_ast_node( ctx, node=None ):
- print 'to-ast-node', ctx
-
- if ctx.type == 'node':
- print 'NODE::', ctx.node
- return to_ast_node( ctx.tree[0], node=ctx.node )
-
- elif ctx.type == 'assign' and ctx.tree[0].type == 'id' and ctx.tree[0].value == '$temp':
- print('DEPRECATED')
- raise TypeError
- return AugAssign(ctx, node)
- elif ctx.type == 'expr' and ctx.name == 'augm_assign':
- return AugAssign(ctx, node)
-
- elif ctx.type == 'except':
- ExceptHandler(ctx, node) ## do not return, inserts self into TryExcept node
-
- elif ctx.type in __MAP:
- return __MAP[ ctx.type ]( ctx, node )
-
- elif ctx.type == 'list_or_tuple':
- if ctx.real == 'list':
- return List(ctx, node)
- elif ctx.real == 'tuple':
- return Tuple(ctx, node)
- elif ctx.real == 'list_comp':
- return ListComp(ctx, node)
- else:
- raise TypeError
-
- elif ctx.type == 'dict_or_set':
- if ctx.real == 'dict':
- return Dict(ctx, node)
-
- elif ctx.type == 'decorator':
- push_decorator( to_ast_node(ctx.tree[0]) )
-
- elif ctx.type == 'condition' and ctx.token == 'while':
- return While( ctx, node )
-
- elif ctx.type == 'condition' and ctx.token == 'if':
- return IfExp( ctx, node )
- elif ctx.type == 'condition' and ctx.token == 'elif':
- a = IfExp( ctx, node )
- IfExp._previous.orelse.append( a )
- IfExp._previous = a
-
- elif ctx.type == 'single_kw':
- if ctx.token == 'else' or ctx.token == 'elif':
- #if ctx.token == 'else': ## TODO fix: "if/elif: if"
- orelse = IfExp._previous.orelse
- for child in node.children:
- walk_nodes( child, orelse )
-
- else:
- print 'unknown token for single_kw'
- print ctx
- raise TypeError
-
- elif ctx.type == 'node_js':
- print(ctx.tree[0])
- ## special brython inline javascript ##
- #if len(ctx.tree) == 1 and '__iadd__' in ctx.tree[0]:
- # AugAssign._previous.op = '+'
- #elif len(ctx.tree) == 1 and '__isub__' in ctx.tree[0]:
- # AugAssign._previous.op = '-'
- #elif len(ctx.tree) == 1 and ctx.tree[0].startswith("if($temp.$fast_augm"):
- # print(ctx.tree[0])
- # c = ctx.tree[0].split('"')
- # if len(c) == 3:
- # AugAssign._previous.target = Name( name=c[1] )
- # else:
- # print(c)
- # raise TypeError
-
- if len(ctx.tree) == 1 and ctx.tree[0] == 'else': ## DEPRECATED
- raise TypeError
- else:
- print '--------special node_js error-------'
- print(ctx)
- raise TypeError
-
- elif ctx.type == 'abstract_expr':
- if len(ctx.tree)==1 and ctx.tree[0].type=='expr' and ctx.tree[0].name=='call' and len(ctx.tree[0].tree)==1:
- call = ctx.tree[0].tree[0]
- assert call.type=='call'
- func = call.func
- if func.type=='attribute' and func.func=='getattr':
- if func.name=='__neg__':
- return UnaryOp(op='-', operand=to_ast_node(func.value))
- else:
- raise TypeError
- else:
- print '---------abstract_expr error----------'
- print ctx
- raise TypeError
- elif ctx.parent.type=='sub' and len(ctx.tree)==0:
- ## this is a null part of the slice: "a[1:]"
- return None
- else:
- print '---------abstract_expr error----------'
- print ctx
- raise TypeError
-
- else:
- print '---------error----------'
- print node
- print ctx
- raise TypeError
-
-
-def walk_nodes( node, module ):
- print 'node.type:', node.type
-
- if node.type == 'expression':
- if node.get_ctx():
- anode = to_ast_node( node.get_ctx(), node=node )
- if anode: ## decorators do not return
- module.append( anode )
- elif node.get_ctx():
- anode = to_ast_node( node.get_ctx(), node=node )
- if anode:
- module.append( anode )
- #else:
- # for child in node.children:
- # walk_nodes( child, module )
-
- else:
- for child in node.children:
- walk_nodes( child, module )
-
-
-def parse(source):
- a = brython_tokenize( source )
- module = list()
- walk_nodes( a, module )
- return module
-
-
-class NodeVisitor:
- def __init__(self, module):
- #print('module:')
- #print(module)
- for node in module:
- self.visit( node )
-
- def visit(self, node):
- if node is None:
- print('ERROR: trying to visit None')
- raise TypeError
- #print('visit.name', node)
- f = getattr(
- self,
- 'visit_'+type(node).__name__,
- )
- return f( node )
-
- def visit_Lambda(self, node):
- args = []
- for a in node.args.args:
- args.append( self.visit(a) )
- if node.args.vararg:
- args.append( '*'+node.args.vararg )
- if node.args.kwarg:
- args.append( '**'+node.args.kwarg )
- args = ','.join( args )
- body = self.visit(node.body)
- return 'lambda %s: %s' %(args, body)
-
- def visit_ListComp(self, node):
- gen = node.generators[0]
- return '[' + self.visit(node.elt) + ' for ' + self.visit(gen.target) + ' in ' + self.visit(gen.iter) + ']'
-
- def visit_Import(self, node):
- a = [ alias.name for alias in node.names ]
- print 'import', ','.join(a)
-
- def visit_ImportFrom(self, node):
- a = [ alias.name for alias in node.names ]
- print 'from', node.module, 'import', ','.join(a)
-
- def visit_TryExcept(self, node):
- print 'try:'
- for n in node.body:
- a = self.visit(n)
- if a: print ' ', a
- for h in node.handlers:
- if h.type:
- print 'except ', self.visit(h.type), ':'
- else:
- print 'except:'
- for n in h.body:
- a = self.visit(n)
- if a: print ' ', a
-
- def visit_Assert(self, node):
- print 'assert', self.visit(node.test)
-
- def visit_Raise(self, node):
- print 'raise', self.visit(node.type)
-
- def visit_Expr(self, node):
- return self.visit(node.value)
-
- def visit_Str(self, node):
- return node.s
-
- def visit_Num(self, node):
- return node.n
-
- def visit_Name(self, node):
- return node.id
-
- def visit_Pass(self, node):
- return 'pass'
-
- def visit_Not(self, node):
- ## note: node.value is non-standard for the `Not` node
- if node.value:
- return ' not ' + self.visit(node.value)
- else:
- return ' not '
-
- def visit_IsNot(self, node):
- return ' is not '
-
- def visit_Eq(self, node):
- return '=='
-
- def visit_NotEq(self, node):
- return '!='
-
- def visit_In(self, node):
- return ' in '
-
- def visit_Is(self, node):
- return ' is '
-
- def visit_Pow(self, node):
- return '**'
-
- def visit_Mult(self, node):
- return '*'
-
- def visit_UAdd(self, node):
- return '+'
- def visit_USub(self, node):
- return '-'
- def visit_Add(self, node):
- return '+'
- def visit_Sub(self, node):
- return '-'
-
- def visit_FloorDiv(self, node):
- return '//'
- def visit_Div(self, node):
- return '/'
- def visit_Mod(self, node):
- return '%'
- def visit_LShift(self, node):
- return '<<'
- def visit_RShift(self, node):
- return '>>'
- def visit_BitXor(self, node):
- return '^'
- def visit_BitOr(self, node):
- return '|'
- def visit_BitAnd(self, node):
- return '&'
-
- def visit_Lt(self, node):
- return '<'
-
- def visit_Gt(self, node):
- return '>'
-
- def visit_GtE(self, node):
- return '>='
-
- def visit_LtE(self, node):
- return '<='
-
- def visit_And(self, node):
- return ' and '
-
- def visit_Or(self, node):
- return ' or '
-
- def visit_NotIn(self, node):
- return ' not in '
\ No newline at end of file
diff --git a/bindings/blockly.py b/bindings/blockly.py
deleted file mode 100644
index 789fcb0..0000000
--- a/bindings/blockly.py
+++ /dev/null
@@ -1,998 +0,0 @@
-# Google Blockly wrapper for PythonJS
-# by Brett Hartshorn - copyright 2013
-# License: "New BSD"
-
-Blockly.SCALE = 1.0
-BlocklyImageHack = None
-BlocklyBlockGenerators = dict() ## Blocks share a single namespace in Blockly
-BlocklyClasses = dict()
-
-with javascript: BlocklyBlockInstances = {} ## block-uid : block instance
-_blockly_instances_uid = 0
-
-with javascript:
- NEW_LINE = String.fromCharCode(10)
-
-def bind_blockly_event( element, name, callback ):
- Blockly.bindEvent_( element, name, None, callback )
-
-
-def __blockinstance( result, block_uid ):
- with javascript:
- BlocklyBlockInstances[ block_uid ].pythonjs_object = result
- return result
-
-with javascript:
- def on_mouse_wheel(e):
- delta = 0
- if e.wheelDelta: ## WebKit, Opera, IE9
- delta = e.wheelDelta
- elif e.detail: ## firefox
- delta = -e.detail
-
- e.preventDefault()
- e.stopPropagation()
- if Blockly.SCALE >= 0.25 and Blockly.SCALE <= 1.0:
- Blockly.SCALE += delta * 0.001
-
- if Blockly.SCALE < 0.25:
- Blockly.SCALE = 0.25
- elif Blockly.SCALE > 1.0:
- Blockly.SCALE = 1.0
-
- #Blockly.fireUiEvent(window, 'resize') ## this will not fire if blockly is inside a div with absolute height and width
- Blockly.mainWorkspace.setMetrics() ## forces a direct redraw
-
-def init_node_blockly( blockly_id ):
- document.getElementById( blockly_id ).addEventListener( 'mousewheel', on_mouse_wheel, False );
- document.getElementById( blockly_id ).addEventListener( 'DOMMouseScroll', on_mouse_wheel, False ); ## firefox
-
- ## special node block ##
- _node_block = StatementBlock('node_input', color=0, title='