test shows that Brython's tokenizer can be used to parse python code and transform it back into a PythonJS compatible AST.

hartsantler · hartsantler · commit b7d3d89db161 · 2013-11-18T20:50:10.000-08:00
diff --git a/tests/brython_AST.html b/tests/brython_AST.html
@@ -16,10 +16,31 @@
 
 <script type="text/python">
 
-class Name:
+def tokenize(src):
+	module = 'test'
+	return JS('$tokenize(src, module)')  ## Brython tokenizer
+
+
+class Assign:
+	def __init__(self, ctx):
+		self.targets = []
+		self.targets.append( to_ast_node(ctx.tree[0]) ) ## should be: expr.name==id
+		self.value = to_ast_node( ctx.tree[1] )  ## should be an: expr.name==operand
+
+class Num:
 	def __init__(self, ctx):
-		print 'Name:', ctx.name
-		self.id = ctx.name
+		self.n = ctx.value
+
+class Name:
+	def __init__(self, ctx=None, name=None):
+		if name:
+			self.id = name
+		elif ctx.type == 'id':
+			self.id = ctx.value
+		else:
+			raise TypeError
+
+		print 'Name:', self.id
 
 class _arguments:
 	def __init__(self, ctx):
@@ -32,59 +53,105 @@
 		if ctx.type != 'func_args':
 			raise TypeError
 		for c in ctx.tree:
-			if c.type != 'func_arg_id':
+			if c.type == 'func_arg_id':
+				self.args.append( Name(name=c.name) )
+			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
-			self.args.append( Name(c) )
 
 
 
-class FunctionDef:
+class BinOp:
 	def __init__(self, ctx):
+		self.left = to_ast_node( ctx.tree[0] )
+		self.right = to_ast_node( ctx.tree[1] )
+		self.op = ctx.op  ## should be: +,-,*, etc...
+
+class Return:
+	def __init__(self, ctx):
+		self.value = to_ast_node( ctx.tree[0] )
+
+class FunctionDef:
+	def __init__(self, ctx, node):
 		self.name = ctx.name
 		self.args = _arguments( ctx.tree[0] )
 		self.body = []
 		self.decorator_list = []
 		self.returns = None ## python3 returns annotation
+		for child in node.children:
+			anode = to_ast_node( child.get_ctx() )
+			self.body.append( anode )
+
+
+class Call:
+	def __init__(self, ctx, node):
+		self.func = None
+		self.args = []
+		self.keywords = []
+		self.starargs = None
+		self.kwargs = None
+
+		for c in ctx.tree:
+			if c.type == 'call_arg':
+				self.args.append( to_ast_node(c.tree[0]) )
 
-def tokenize(src):
-	module = 'test'
-	return JS('$tokenize(src, module)')
 
-def walk_tree( ctx ):
-	anode = None
-	print 'ctx.type:', ctx.type
+def to_ast_node( ctx, node=None ):
+	print 'to-ast-node', ctx
 	if ctx.type == 'def':
-		print '  def ', ctx.name
-		anode = FunctionDef( ctx )
+		return FunctionDef( ctx, node )
+	elif ctx.type == 'assign':
+		return Assign(ctx)
+	elif ctx.type == 'return':
+		return Return(ctx)
+	elif ctx.type == 'node':
+		return to_ast_node( ctx.tree[0], node=node )
+	elif ctx.type == 'expr' and ctx.name == 'id':
+		if ctx.tree[0].type == 'call':
+			return Call( ctx.tree[0], node)
+		else:
+			return Name( ctx.tree[0] )
+	elif ctx.type == 'expr' and ctx.name == 'operand':
+		return BinOp( ctx.tree[0] )
+
+	elif ctx.type == 'expr' and ctx.name == 'int':
+		return Num( ctx.tree[0] )
 
-	if anode:
-		return anode
 	else:
-		for c in ctx.tree:
-			walk_tree( c )
+		print ctx
+		raise TypeError
+
 
-def convert_to_ast( node ):
+def walk_nodes( node, module ):
 	print 'node.type:', node.type
-	ctx = node.get_ctx()
-	if ctx:
-		walk_tree( ctx )
 
-	for child in node.children:
-		convert_to_ast( child )
+	if node.type == 'expression':
+		anode = to_ast_node( node.get_ctx(), node=node )
+		module.append( anode )
 
-source = """
-def xxx(a,b):
-	return a+b
+	else:
+		for child in node.children:
+			walk_nodes( child, module )
 
-print( xxx(1, 2) )
 
+source = """
+def func(a,b):
+	c = a+b
+	return c
+
+func(100, 200)
 """
 
 def test():
-	global a
+	global a, module
 	a = tokenize( source )
 	print a
-	convert_to_ast( a )
+	module = list()
+	walk_nodes( a, module )
+
 
 </script>
 
