Python code coverage for Lib/compiler/pycodegen.py

#	count	content
1	2	import imp
2	2	import os
3	2	import marshal
4	2	import struct
5	2	import sys
6	2	from cStringIO import StringIO
7	n/a
8	2	from compiler import ast, parse, walk, syntax
9	2	from compiler import pyassem, misc, future, symbols
10	2	from compiler.consts import SC_LOCAL, SC_GLOBAL_IMPLICIT, SC_GLOBAL_EXPLICT, \
11	n/a	SC_FREE, SC_CELL
12	2	from compiler.consts import (CO_VARARGS, CO_VARKEYWORDS, CO_NEWLOCALS,
13	n/a	CO_NESTED, CO_GENERATOR, CO_FUTURE_DIVISION,
14	n/a	CO_FUTURE_ABSIMPORT, CO_FUTURE_WITH_STATEMENT, CO_FUTURE_PRINT_FUNCTION)
15	2	from compiler.pyassem import TupleArg
16	n/a
17	n/a	# XXX The version-specific code can go, since this code only works with 2.x.
18	n/a	# Do we have Python 1.x or Python 2.x?
19	2	try:
20	2	VERSION = sys.version_info[0]
21	0	except AttributeError:
22	0	VERSION = 1
23	n/a
24	2	callfunc_opcode_info = {
25	n/a	# (Have args, Have *args) : opcode
26	2	(0,0) : "CALL_FUNCTION",
27	2	(1,0) : "CALL_FUNCTION_VAR",
28	2	(0,1) : "CALL_FUNCTION_KW",
29	2	(1,1) : "CALL_FUNCTION_VAR_KW",
30	n/a	}
31	n/a
32	2	LOOP = 1
33	2	EXCEPT = 2
34	2	TRY_FINALLY = 3
35	2	END_FINALLY = 4
36	n/a
37	2	def compileFile(filename, display=0):
38	0	f = open(filename, 'U')
39	0	buf = f.read()
40	0	f.close()
41	0	mod = Module(buf, filename)
42	0	try:
43	0	mod.compile(display)
44	0	except SyntaxError:
45	0	raise
46	n/a	else:
47	0	f = open(filename + "c", "wb")
48	0	mod.dump(f)
49	0	f.close()
50	n/a
51	2	def compile(source, filename, mode, flags=None, dont_inherit=None):
52	n/a	"""Replacement for builtin compile() function"""
53	31	if flags is not None or dont_inherit is not None:
54	0	raise RuntimeError, "not implemented yet"
55	n/a
56	31	if mode == "single":
57	3	gen = Interactive(source, filename)
58	28	elif mode == "exec":
59	19	gen = Module(source, filename)
60	9	elif mode == "eval":
61	9	gen = Expression(source, filename)
62	n/a	else:
63	0	raise ValueError("compile() 3rd arg must be 'exec' or "
64	n/a	"'eval' or 'single'")
65	31	gen.compile()
66	31	return gen.code
67	n/a
68	4	class AbstractCompileMode:
69	n/a
70	2	mode = None # defined by subclass
71	n/a
72	2	def __init__(self, source, filename):
73	31	self.source = source
74	31	self.filename = filename
75	31	self.code = None
76	n/a
77	2	def _get_tree(self):
78	31	tree = parse(self.source, self.mode)
79	31	misc.set_filename(self.filename, tree)
80	31	syntax.check(tree)
81	31	return tree
82	n/a
83	2	def compile(self):
84	0	pass # implemented by subclass
85	n/a
86	2	def getCode(self):
87	0	return self.code
88	n/a
89	4	class Expression(AbstractCompileMode):
90	n/a
91	2	mode = "eval"
92	n/a
93	2	def compile(self):
94	9	tree = self._get_tree()
95	9	gen = ExpressionCodeGenerator(tree)
96	9	self.code = gen.getCode()
97	n/a
98	4	class Interactive(AbstractCompileMode):
99	n/a
100	2	mode = "single"
101	n/a
102	2	def compile(self):
103	3	tree = self._get_tree()
104	3	gen = InteractiveCodeGenerator(tree)
105	3	self.code = gen.getCode()
106	n/a
107	4	class Module(AbstractCompileMode):
108	n/a
109	2	mode = "exec"
110	n/a
111	2	def compile(self, display=0):
112	19	tree = self._get_tree()
113	19	gen = ModuleCodeGenerator(tree)
114	19	if display:
115	0	import pprint
116	0	print pprint.pprint(tree)
117	19	self.code = gen.getCode()
118	n/a
119	2	def dump(self, f):
120	0	f.write(self.getPycHeader())
121	0	marshal.dump(self.code, f)
122	n/a
123	2	MAGIC = imp.get_magic()
124	n/a
125	2	def getPycHeader(self):
126	n/a	# compile.c uses marshal to write a long directly, with
127	n/a	# calling the interface that would also generate a 1-byte code
128	n/a	# to indicate the type of the value. simplest way to get the
129	n/a	# same effect is to call marshal and then skip the code.
130	0	mtime = os.path.getmtime(self.filename)
131	0	mtime = struct.pack('<i', mtime)
132	0	return self.MAGIC + mtime
133	n/a
134	4	class LocalNameFinder:
135	2	"""Find local names in scope"""
136	2	def __init__(self, names=()):
137	1050	self.names = misc.Set()
138	1050	self.globals = misc.Set()
139	1995	for name in names:
140	945	self.names.add(name)
141	n/a
142	n/a	# XXX list comprehensions and for loops
143	n/a
144	2	def getLocals(self):
145	1061	for elt in self.globals.elements():
146	11	if self.names.has_elt(elt):
147	11	self.names.remove(elt)
148	1050	return self.names
149	n/a
150	2	def visitDict(self, node):
151	96	pass
152	n/a
153	2	def visitGlobal(self, node):
154	18	for name in node.names:
155	11	self.globals.add(name)
156	n/a
157	2	def visitFunction(self, node):
158	617	self.names.add(node.name)
159	n/a
160	2	def visitLambda(self, node):
161	18	pass
162	n/a
163	2	def visitImport(self, node):
164	101	for name, alias in node.names:
165	53	self.names.add(alias or name)
166	n/a
167	2	def visitFrom(self, node):
168	32	for name, alias in node.names:
169	17	self.names.add(alias or name)
170	n/a
171	2	def visitClass(self, node):
172	391	self.names.add(node.name)
173	n/a
174	2	def visitAssName(self, node):
175	824	self.names.add(node.name)
176	n/a
177	2	def is_constant_false(node):
178	118	if isinstance(node, ast.Const):
179	0	if not node.value:
180	0	return 1
181	118	return 0
182	n/a
183	4	class CodeGenerator:
184	n/a	"""Defines basic code generator for Python bytecode
185	n/a
186	n/a	This class is an abstract base class. Concrete subclasses must
187	n/a	define an __init__() that defines self.graph and then calls the
188	n/a	__init__() defined in this class.
189	n/a
190	n/a	The concrete class must also define the class attributes
191	n/a	NameFinder, FunctionGen, and ClassGen. These attributes can be
192	n/a	defined in the initClass() method, which is a hook for
193	n/a	initializing these methods after all the classes have been
194	n/a	defined.
195	2	"""
196	n/a
197	2	optimized = 0 # is namespace access optimized?
198	2	__initialized = None
199	2	class_name = None # provide default for instance variable
200	n/a
201	2	def __init__(self):
202	1059	if self.__initialized is None:
203	6	self.initClass()
204	6	self.__class__.__initialized = 1
205	1059	self.checkClass()
206	1059	self.locals = misc.Stack()
207	1059	self.setups = misc.Stack()
208	1059	self.last_lineno = None
209	1059	self._setupGraphDelegation()
210	1059	self._div_op = "BINARY_DIVIDE"
211	n/a
212	n/a	# XXX set flags based on future features
213	1059	futures = self.get_module().futures
214	1066	for feature in futures:
215	7	if feature == "division":
216	0	self.graph.setFlag(CO_FUTURE_DIVISION)
217	0	self._div_op = "BINARY_TRUE_DIVIDE"
218	7	elif feature == "absolute_import":
219	0	self.graph.setFlag(CO_FUTURE_ABSIMPORT)
220	7	elif feature == "with_statement":
221	6	self.graph.setFlag(CO_FUTURE_WITH_STATEMENT)
222	1	elif feature == "print_function":
223	1	self.graph.setFlag(CO_FUTURE_PRINT_FUNCTION)
224	n/a
225	2	def initClass(self):
226	n/a	"""This method is called once for each class"""
227	n/a
228	2	def checkClass(self):
229	n/a	"""Verify that class is constructed correctly"""
230	1059	try:
231	1059	assert hasattr(self, 'graph')
232	1059	assert getattr(self, 'NameFinder')
233	1059	assert getattr(self, 'FunctionGen')
234	1059	assert getattr(self, 'ClassGen')
235	0	except AssertionError, msg:
236	0	intro = "Bad class construction for %s" % self.__class__.__name__
237	0	raise AssertionError, intro
238	n/a
239	2	def _setupGraphDelegation(self):
240	1059	self.emit = self.graph.emit
241	1059	self.newBlock = self.graph.newBlock
242	1059	self.startBlock = self.graph.startBlock
243	1059	self.nextBlock = self.graph.nextBlock
244	1059	self.setDocstring = self.graph.setDocstring
245	n/a
246	2	def getCode(self):
247	n/a	"""Return a code object"""
248	1059	return self.graph.getCode()
249	n/a
250	2	def mangle(self, name):
251	12013	if self.class_name is not None:
252	11233	return misc.mangle(name, self.class_name)
253	n/a	else:
254	780	return name
255	n/a
256	2	def parseSymbols(self, tree):
257	31	s = symbols.SymbolVisitor()
258	31	walk(tree, s)
259	31	return s.scopes
260	n/a
261	2	def get_module(self):
262	0	raise RuntimeError, "should be implemented by subclasses"
263	n/a
264	n/a	# Next five methods handle name access
265	n/a
266	2	def isLocalName(self, name):
267	0	return self.locals.top().has_elt(name)
268	n/a
269	2	def storeName(self, name):
270	2302	self._nameOp('STORE', name)
271	n/a
272	2	def loadName(self, name):
273	6817	self._nameOp('LOAD', name)
274	n/a
275	2	def delName(self, name):
276	19	self._nameOp('DELETE', name)
277	n/a
278	2	def _nameOp(self, prefix, name):
279	9138	name = self.mangle(name)
280	9138	scope = self.scope.check_name(name)
281	9138	if scope == SC_LOCAL:
282	6958	if not self.optimized:
283	1342	self.emit(prefix + '_NAME', name)
284	n/a	else:
285	5616	self.emit(prefix + '_FAST', name)
286	2180	elif scope == SC_GLOBAL_EXPLICT:
287	298	self.emit(prefix + '_GLOBAL', name)
288	1882	elif scope == SC_GLOBAL_IMPLICIT:
289	1385	if not self.optimized:
290	56	self.emit(prefix + '_NAME', name)
291	n/a	else:
292	1329	self.emit(prefix + '_GLOBAL', name)
293	497	elif scope == SC_FREE or scope == SC_CELL:
294	497	self.emit(prefix + '_DEREF', name)
295	n/a	else:
296	0	raise RuntimeError, "unsupported scope for var %s: %d" % \
297	0	(name, scope)
298	n/a
299	2	def _implicitNameOp(self, prefix, name):
300	n/a	"""Emit name ops for names generated implicitly by for loops
301	n/a
302	n/a	The interpreter generates names that start with a period or
303	n/a	dollar sign. The symbol table ignores these names because
304	n/a	they aren't present in the program text.
305	n/a	"""
306	12	if self.optimized:
307	12	self.emit(prefix + '_FAST', name)
308	n/a	else:
309	0	self.emit(prefix + '_NAME', name)
310	n/a
311	n/a	# The set_lineno() function and the explicit emit() calls for
312	n/a	# SET_LINENO below are only used to generate the line number table.
313	n/a	# As of Python 2.3, the interpreter does not have a SET_LINENO
314	n/a	# instruction. pyassem treats SET_LINENO opcodes as a special case.
315	n/a
316	2	def set_lineno(self, node, force=False):
317	n/a	"""Emit SET_LINENO if necessary.
318	n/a
319	n/a	The instruction is considered necessary if the node has a
320	n/a	lineno attribute and it is different than the last lineno
321	n/a	emitted.
322	n/a
323	n/a	Returns true if SET_LINENO was emitted.
324	n/a
325	n/a	There are no rules for when an AST node should have a lineno
326	n/a	attribute. The transformer and AST code need to be reviewed
327	n/a	and a consistent policy implemented and documented. Until
328	n/a	then, this method works around missing line numbers.
329	n/a	"""
330	16581	lineno = getattr(node, 'lineno', None)
331	16581	if lineno is not None and (lineno != self.last_lineno
332	10619	or force):
333	6071	self.emit('SET_LINENO', lineno)
334	6071	self.last_lineno = lineno
335	6071	return True
336	10510	return False
337	n/a
338	n/a	# The first few visitor methods handle nodes that generator new
339	n/a	# code objects. They use class attributes to determine what
340	n/a	# specialized code generators to use.
341	n/a
342	2	NameFinder = LocalNameFinder
343	2	FunctionGen = None
344	2	ClassGen = None
345	n/a
346	2	def visitModule(self, node):
347	22	self.scopes = self.parseSymbols(node)
348	22	self.scope = self.scopes[node]
349	22	self.emit('SET_LINENO', 0)
350	22	if node.doc:
351	5	self.emit('LOAD_CONST', node.doc)
352	5	self.storeName('__doc__')
353	22	lnf = walk(node.node, self.NameFinder(), verbose=0)
354	22	self.locals.push(lnf.getLocals())
355	22	self.visit(node.node)
356	22	self.emit('LOAD_CONST', None)
357	22	self.emit('RETURN_VALUE')
358	n/a
359	2	def visitExpression(self, node):
360	9	self.set_lineno(node)
361	9	self.scopes = self.parseSymbols(node)
362	9	self.scope = self.scopes[node]
363	9	self.visit(node.node)
364	9	self.emit('RETURN_VALUE')
365	n/a
366	2	def visitFunction(self, node):
367	617	self._visitFuncOrLambda(node, isLambda=0)
368	617	if node.doc:
369	21	self.setDocstring(node.doc)
370	617	self.storeName(node.name)
371	n/a
372	2	def visitLambda(self, node):
373	18	self._visitFuncOrLambda(node, isLambda=1)
374	n/a
375	2	def _visitFuncOrLambda(self, node, isLambda=0):
376	635	if not isLambda and node.decorators:
377	38	for decorator in node.decorators.nodes:
378	19	self.visit(decorator)
379	19	ndecorators = len(node.decorators.nodes)
380	n/a	else:
381	616	ndecorators = 0
382	n/a
383	635	gen = self.FunctionGen(node, self.scopes, isLambda,
384	635	self.class_name, self.get_module())
385	635	walk(node.code, gen)
386	635	gen.finish()
387	635	self.set_lineno(node)
388	678	for default in node.defaults:
389	43	self.visit(default)
390	635	self._makeClosure(gen, len(node.defaults))
391	654	for i in range(ndecorators):
392	19	self.emit('CALL_FUNCTION', 1)
393	n/a
394	2	def visitClass(self, node):
395	391	gen = self.ClassGen(node, self.scopes,
396	391	self.get_module())
397	391	walk(node.code, gen)
398	391	gen.finish()
399	391	self.set_lineno(node)
400	391	self.emit('LOAD_CONST', node.name)
401	805	for base in node.bases:
402	414	self.visit(base)
403	391	self.emit('BUILD_TUPLE', len(node.bases))
404	391	self._makeClosure(gen, 0)
405	391	self.emit('CALL_FUNCTION', 0)
406	391	self.emit('BUILD_CLASS')
407	391	self.storeName(node.name)
408	n/a
409	n/a	# The rest are standard visitor methods
410	n/a
411	n/a	# The next few implement control-flow statements
412	n/a
413	2	def visitIf(self, node):
414	116	end = self.newBlock()
415	116	numtests = len(node.tests)
416	234	for i in range(numtests):
417	118	test, suite = node.tests[i]
418	118	if is_constant_false(test):
419	n/a	# XXX will need to check generator stuff here
420	0	continue
421	118	self.set_lineno(test)
422	118	self.visit(test)
423	118	nextTest = self.newBlock()
424	118	self.emit('POP_JUMP_IF_FALSE', nextTest)
425	118	self.nextBlock()
426	118	self.visit(suite)
427	118	self.emit('JUMP_FORWARD', end)
428	118	self.startBlock(nextTest)
429	116	if node.else_:
430	26	self.visit(node.else_)
431	116	self.nextBlock(end)
432	n/a
433	2	def visitWhile(self, node):
434	12	self.set_lineno(node)
435	n/a
436	12	loop = self.newBlock()
437	12	else_ = self.newBlock()
438	n/a
439	12	after = self.newBlock()
440	12	self.emit('SETUP_LOOP', after)
441	n/a
442	12	self.nextBlock(loop)
443	12	self.setups.push((LOOP, loop))
444	n/a
445	12	self.set_lineno(node, force=True)
446	12	self.visit(node.test)
447	12	self.emit('POP_JUMP_IF_FALSE', else_ or after)
448	n/a
449	12	self.nextBlock()
450	12	self.visit(node.body)
451	12	self.emit('JUMP_ABSOLUTE', loop)
452	n/a
453	12	self.startBlock(else_) # or just the POPs if not else clause
454	12	self.emit('POP_BLOCK')
455	12	self.setups.pop()
456	12	if node.else_:
457	0	self.visit(node.else_)
458	12	self.nextBlock(after)
459	n/a
460	2	def visitFor(self, node):
461	90	start = self.newBlock()
462	90	anchor = self.newBlock()
463	90	after = self.newBlock()
464	90	self.setups.push((LOOP, start))
465	n/a
466	90	self.set_lineno(node)
467	90	self.emit('SETUP_LOOP', after)
468	90	self.visit(node.list)
469	90	self.emit('GET_ITER')
470	n/a
471	90	self.nextBlock(start)
472	90	self.set_lineno(node, force=1)
473	90	self.emit('FOR_ITER', anchor)
474	90	self.visit(node.assign)
475	90	self.visit(node.body)
476	90	self.emit('JUMP_ABSOLUTE', start)
477	90	self.nextBlock(anchor)
478	90	self.emit('POP_BLOCK')
479	90	self.setups.pop()
480	90	if node.else_:
481	0	self.visit(node.else_)
482	90	self.nextBlock(after)
483	n/a
484	2	def visitBreak(self, node):
485	0	if not self.setups:
486	0	raise SyntaxError, "'break' outside loop (%s, %d)" % \
487	0	(node.filename, node.lineno)
488	0	self.set_lineno(node)
489	0	self.emit('BREAK_LOOP')
490	n/a
491	2	def visitContinue(self, node):
492	3	if not self.setups:
493	0	raise SyntaxError, "'continue' outside loop (%s, %d)" % \
494	0	(node.filename, node.lineno)
495	3	kind, block = self.setups.top()
496	3	if kind == LOOP:
497	3	self.set_lineno(node)
498	3	self.emit('JUMP_ABSOLUTE', block)
499	3	self.nextBlock()
500	0	elif kind == EXCEPT or kind == TRY_FINALLY:
501	0	self.set_lineno(node)
502	n/a	# find the block that starts the loop
503	0	top = len(self.setups)
504	0	while top > 0:
505	0	top = top - 1
506	0	kind, loop_block = self.setups[top]
507	0	if kind == LOOP:
508	0	break
509	0	if kind != LOOP:
510	0	raise SyntaxError, "'continue' outside loop (%s, %d)" % \
511	0	(node.filename, node.lineno)
512	0	self.emit('CONTINUE_LOOP', loop_block)
513	0	self.nextBlock()
514	0	elif kind == END_FINALLY:
515	0	msg = "'continue' not allowed inside 'finally' clause (%s, %d)"
516	0	raise SyntaxError, msg % (node.filename, node.lineno)
517	n/a
518	2	def visitTest(self, node, jump):
519	17	end = self.newBlock()
520	34	for child in node.nodes[:-1]:
521	17	self.visit(child)
522	17	self.emit(jump, end)
523	17	self.nextBlock()
524	17	self.visit(node.nodes[-1])
525	17	self.nextBlock(end)
526	n/a
527	2	def visitAnd(self, node):
528	9	self.visitTest(node, 'JUMP_IF_FALSE_OR_POP')
529	n/a
530	2	def visitOr(self, node):
531	8	self.visitTest(node, 'JUMP_IF_TRUE_OR_POP')
532	n/a
533	2	def visitIfExp(self, node):
534	0	endblock = self.newBlock()
535	0	elseblock = self.newBlock()
536	0	self.visit(node.test)
537	0	self.emit('POP_JUMP_IF_FALSE', elseblock)
538	0	self.visit(node.then)
539	0	self.emit('JUMP_FORWARD', endblock)
540	0	self.nextBlock(elseblock)
541	0	self.visit(node.else_)
542	0	self.nextBlock(endblock)
543	n/a
544	2	def visitCompare(self, node):
545	232	self.visit(node.expr)
546	232	cleanup = self.newBlock()
547	235	for op, code in node.ops[:-1]:
548	3	self.visit(code)
549	3	self.emit('DUP_TOP')
550	3	self.emit('ROT_THREE')
551	3	self.emit('COMPARE_OP', op)
552	3	self.emit('JUMP_IF_FALSE_OR_POP', cleanup)
553	3	self.nextBlock()
554	n/a	# now do the last comparison
555	232	if node.ops:
556	232	op, code = node.ops[-1]
557	232	self.visit(code)
558	232	self.emit('COMPARE_OP', op)
559	232	if len(node.ops) > 1:
560	3	end = self.newBlock()
561	3	self.emit('JUMP_FORWARD', end)
562	3	self.startBlock(cleanup)
563	3	self.emit('ROT_TWO')
564	3	self.emit('POP_TOP')
565	3	self.nextBlock(end)
566	n/a
567	n/a	# list comprehensions
568	2	def visitListComp(self, node):
569	13	self.set_lineno(node)
570	n/a	# setup list
571	13	self.emit('BUILD_LIST', 0)
572	n/a
573	13	stack = []
574	26	for i, for_ in zip(range(len(node.quals)), node.quals):
575	13	start, anchor = self.visit(for_)
576	13	cont = None
577	17	for if_ in for_.ifs:
578	4	if cont is None:
579	4	cont = self.newBlock()
580	4	self.visit(if_, cont)
581	13	stack.insert(0, (start, cont, anchor))
582	n/a
583	13	self.visit(node.expr)
584	13	self.emit('LIST_APPEND', len(node.quals) + 1)
585	n/a
586	26	for start, cont, anchor in stack:
587	13	if cont:
588	4	self.nextBlock(cont)
589	13	self.emit('JUMP_ABSOLUTE', start)
590	13	self.startBlock(anchor)
591	n/a
592	2	def visitSetComp(self, node):
593	2	self.set_lineno(node)
594	n/a	# setup list
595	2	self.emit('BUILD_SET', 0)
596	n/a
597	2	stack = []
598	5	for i, for_ in zip(range(len(node.quals)), node.quals):
599	3	start, anchor = self.visit(for_)
600	3	cont = None
601	5	for if_ in for_.ifs:
602	2	if cont is None:
603	2	cont = self.newBlock()
604	2	self.visit(if_, cont)
605	3	stack.insert(0, (start, cont, anchor))
606	n/a
607	2	self.visit(node.expr)
608	2	self.emit('SET_ADD', len(node.quals) + 1)
609	n/a
610	5	for start, cont, anchor in stack:
611	3	if cont:
612	2	self.nextBlock(cont)
613	3	self.emit('JUMP_ABSOLUTE', start)
614	3	self.startBlock(anchor)
615	n/a
616	2	def visitDictComp(self, node):
617	2	self.set_lineno(node)
618	n/a	# setup list
619	2	self.emit('BUILD_MAP', 0)
620	n/a
621	2	stack = []
622	5	for i, for_ in zip(range(len(node.quals)), node.quals):
623	3	start, anchor = self.visit(for_)
624	3	cont = None
625	5	for if_ in for_.ifs:
626	2	if cont is None:
627	2	cont = self.newBlock()
628	2	self.visit(if_, cont)
629	3	stack.insert(0, (start, cont, anchor))
630	n/a
631	2	self.visit(node.value)
632	2	self.visit(node.key)
633	2	self.emit('MAP_ADD', len(node.quals) + 1)
634	n/a
635	5	for start, cont, anchor in stack:
636	3	if cont:
637	2	self.nextBlock(cont)
638	3	self.emit('JUMP_ABSOLUTE', start)
639	3	self.startBlock(anchor)
640	n/a
641	2	def visitListCompFor(self, node):
642	19	start = self.newBlock()
643	19	anchor = self.newBlock()
644	n/a
645	19	self.visit(node.list)
646	19	self.emit('GET_ITER')
647	19	self.nextBlock(start)
648	19	self.set_lineno(node, force=True)
649	19	self.emit('FOR_ITER', anchor)
650	19	self.nextBlock()
651	19	self.visit(node.assign)
652	19	return start, anchor
653	n/a
654	2	def visitListCompIf(self, node, branch):
655	8	self.set_lineno(node, force=True)
656	8	self.visit(node.test)
657	8	self.emit('POP_JUMP_IF_FALSE', branch)
658	8	self.newBlock()
659	n/a
660	2	def _makeClosure(self, gen, args):
661	1028	frees = gen.scope.get_free_vars()
662	1028	if frees:
663	297	for name in frees:
664	157	self.emit('LOAD_CLOSURE', name)
665	140	self.emit('BUILD_TUPLE', len(frees))
666	140	self.emit('LOAD_CONST', gen)
667	140	self.emit('MAKE_CLOSURE', args)
668	n/a	else:
669	888	self.emit('LOAD_CONST', gen)
670	888	self.emit('MAKE_FUNCTION', args)
671	n/a
672	2	def visitGenExpr(self, node):
673	2	gen = GenExprCodeGenerator(node, self.scopes, self.class_name,
674	2	self.get_module())
675	2	walk(node.code, gen)
676	2	gen.finish()
677	2	self.set_lineno(node)
678	2	self._makeClosure(gen, 0)
679	n/a	# precomputation of outmost iterable
680	2	self.visit(node.code.quals[0].iter)
681	2	self.emit('GET_ITER')
682	2	self.emit('CALL_FUNCTION', 1)
683	n/a
684	2	def visitGenExprInner(self, node):
685	2	self.set_lineno(node)
686	n/a	# setup list
687	n/a
688	2	stack = []
689	5	for i, for_ in zip(range(len(node.quals)), node.quals):
690	3	start, anchor, end = self.visit(for_)
691	3	cont = None
692	5	for if_ in for_.ifs:
693	2	if cont is None:
694	2	cont = self.newBlock()
695	2	self.visit(if_, cont)
696	3	stack.insert(0, (start, cont, anchor, end))
697	n/a
698	2	self.visit(node.expr)
699	2	self.emit('YIELD_VALUE')
700	2	self.emit('POP_TOP')
701	n/a
702	5	for start, cont, anchor, end in stack:
703	3	if cont:
704	2	self.nextBlock(cont)
705	3	self.emit('JUMP_ABSOLUTE', start)
706	3	self.startBlock(anchor)
707	3	self.emit('POP_BLOCK')
708	3	self.setups.pop()
709	3	self.nextBlock(end)
710	n/a
711	2	self.emit('LOAD_CONST', None)
712	n/a
713	2	def visitGenExprFor(self, node):
714	3	start = self.newBlock()
715	3	anchor = self.newBlock()
716	3	end = self.newBlock()
717	n/a
718	3	self.setups.push((LOOP, start))
719	3	self.emit('SETUP_LOOP', end)
720	n/a
721	3	if node.is_outmost:
722	2	self.loadName('.0')
723	n/a	else:
724	1	self.visit(node.iter)
725	1	self.emit('GET_ITER')
726	n/a
727	3	self.nextBlock(start)
728	3	self.set_lineno(node, force=True)
729	3	self.emit('FOR_ITER', anchor)
730	3	self.nextBlock()
731	3	self.visit(node.assign)
732	3	return start, anchor, end
733	n/a
734	2	def visitGenExprIf(self, node, branch):
735	2	self.set_lineno(node, force=True)
736	2	self.visit(node.test)
737	2	self.emit('POP_JUMP_IF_FALSE', branch)
738	2	self.newBlock()
739	n/a
740	n/a	# exception related
741	n/a
742	2	def visitAssert(self, node):
743	n/a	# XXX would be interesting to implement this via a
744	n/a	# transformation of the AST before this stage
745	n/a	if __debug__:
746	3	end = self.newBlock()
747	3	self.set_lineno(node)
748	n/a	# XXX AssertionError appears to be special case -- it is always
749	n/a	# loaded as a global even if there is a local name. I guess this
750	n/a	# is a sort of renaming op.
751	3	self.nextBlock()
752	3	self.visit(node.test)
753	3	self.emit('POP_JUMP_IF_TRUE', end)
754	3	self.nextBlock()
755	3	self.emit('LOAD_GLOBAL', 'AssertionError')
756	3	if node.fail:
757	1	self.visit(node.fail)
758	1	self.emit('RAISE_VARARGS', 2)
759	n/a	else:
760	2	self.emit('RAISE_VARARGS', 1)
761	3	self.nextBlock(end)
762	n/a
763	2	def visitRaise(self, node):
764	28	self.set_lineno(node)
765	28	n = 0
766	28	if node.expr1:
767	27	self.visit(node.expr1)
768	27	n = n + 1
769	28	if node.expr2:
770	12	self.visit(node.expr2)
771	12	n = n + 1
772	28	if node.expr3:
773	0	self.visit(node.expr3)
774	0	n = n + 1
775	28	self.emit('RAISE_VARARGS', n)
776	n/a
777	2	def visitTryExcept(self, node):
778	132	body = self.newBlock()
779	132	handlers = self.newBlock()
780	132	end = self.newBlock()
781	132	if node.else_:
782	98	lElse = self.newBlock()
783	n/a	else:
784	34	lElse = end
785	132	self.set_lineno(node)
786	132	self.emit('SETUP_EXCEPT', handlers)
787	132	self.nextBlock(body)
788	132	self.setups.push((EXCEPT, body))
789	132	self.visit(node.body)
790	132	self.emit('POP_BLOCK')
791	132	self.setups.pop()
792	132	self.emit('JUMP_FORWARD', lElse)
793	132	self.startBlock(handlers)
794	n/a
795	132	last = len(node.handlers) - 1
796	266	for i in range(len(node.handlers)):
797	134	expr, target, body = node.handlers[i]
798	134	self.set_lineno(expr)
799	134	if expr:
800	127	self.emit('DUP_TOP')
801	127	self.visit(expr)
802	127	self.emit('COMPARE_OP', 'exception match')
803	127	next = self.newBlock()
804	127	self.emit('POP_JUMP_IF_FALSE', next)
805	127	self.nextBlock()
806	134	self.emit('POP_TOP')
807	134	if target:
808	19	self.visit(target)
809	n/a	else:
810	115	self.emit('POP_TOP')
811	134	self.emit('POP_TOP')
812	134	self.visit(body)
813	134	self.emit('JUMP_FORWARD', end)
814	134	if expr:
815	127	self.nextBlock(next)
816	n/a	else:
817	7	self.nextBlock()
818	132	self.emit('END_FINALLY')
819	132	if node.else_:
820	98	self.nextBlock(lElse)
821	98	self.visit(node.else_)
822	132	self.nextBlock(end)
823	n/a
824	2	def visitTryFinally(self, node):
825	12	body = self.newBlock()
826	12	final = self.newBlock()
827	12	self.set_lineno(node)
828	12	self.emit('SETUP_FINALLY', final)
829	12	self.nextBlock(body)
830	12	self.setups.push((TRY_FINALLY, body))
831	12	self.visit(node.body)
832	12	self.emit('POP_BLOCK')
833	12	self.setups.pop()
834	12	self.emit('LOAD_CONST', None)
835	12	self.nextBlock(final)
836	12	self.setups.push((END_FINALLY, final))
837	12	self.visit(node.final)
838	12	self.emit('END_FINALLY')
839	12	self.setups.pop()
840	n/a
841	2	__with_count = 0
842	n/a
843	2	def visitWith(self, node):
844	8	body = self.newBlock()
845	8	final = self.newBlock()
846	8	self.__with_count += 1
847	8	valuevar = "_[%d]" % self.__with_count
848	8	self.set_lineno(node)
849	8	self.visit(node.expr)
850	8	self.emit('DUP_TOP')
851	8	self.emit('LOAD_ATTR', '__exit__')
852	8	self.emit('ROT_TWO')
853	8	self.emit('LOAD_ATTR', '__enter__')
854	8	self.emit('CALL_FUNCTION', 0)
855	8	if node.vars is None:
856	4	self.emit('POP_TOP')
857	n/a	else:
858	4	self._implicitNameOp('STORE', valuevar)
859	8	self.emit('SETUP_FINALLY', final)
860	8	self.nextBlock(body)
861	8	self.setups.push((TRY_FINALLY, body))
862	8	if node.vars is not None:
863	4	self._implicitNameOp('LOAD', valuevar)
864	4	self._implicitNameOp('DELETE', valuevar)
865	4	self.visit(node.vars)
866	8	self.visit(node.body)
867	8	self.emit('POP_BLOCK')
868	8	self.setups.pop()
869	8	self.emit('LOAD_CONST', None)
870	8	self.nextBlock(final)
871	8	self.setups.push((END_FINALLY, final))
872	8	self.emit('WITH_CLEANUP')
873	8	self.emit('END_FINALLY')
874	8	self.setups.pop()
875	8	self.__with_count -= 1
876	n/a
877	n/a	# misc
878	n/a
879	2	def visitDiscard(self, node):
880	1515	self.set_lineno(node)
881	1515	self.visit(node.expr)
882	1515	self.emit('POP_TOP')
883	n/a
884	2	def visitConst(self, node):
885	3259	self.emit('LOAD_CONST', node.value)
886	n/a
887	2	def visitKeyword(self, node):
888	39	self.emit('LOAD_CONST', node.name)
889	39	self.visit(node.expr)
890	n/a
891	2	def visitGlobal(self, node):
892	n/a	# no code to generate
893	7	pass
894	n/a
895	2	def visitName(self, node):
896	6804	self.set_lineno(node)
897	6804	self.loadName(node.name)
898	n/a
899	2	def visitPass(self, node):
900	262	self.set_lineno(node)
901	n/a
902	2	def visitImport(self, node):
903	48	self.set_lineno(node)
904	48	level = 0 if self.graph.checkFlag(CO_FUTURE_ABSIMPORT) else -1
905	101	for name, alias in node.names:
906	53	if VERSION > 1:
907	53	self.emit('LOAD_CONST', level)
908	53	self.emit('LOAD_CONST', None)
909	53	self.emit('IMPORT_NAME', name)
910	53	mod = name.split(".")[0]
911	53	if alias:
912	6	self._resolveDots(name)
913	6	self.storeName(alias)
914	n/a	else:
915	47	self.storeName(mod)
916	n/a
917	2	def visitFrom(self, node):
918	15	self.set_lineno(node)
919	15	level = node.level
920	15	if level == 0 and not self.graph.checkFlag(CO_FUTURE_ABSIMPORT):
921	15	level = -1
922	47	fromlist = tuple(name for (name, alias) in node.names)
923	15	if VERSION > 1:
924	15	self.emit('LOAD_CONST', level)
925	15	self.emit('LOAD_CONST', fromlist)
926	15	self.emit('IMPORT_NAME', node.modname)
927	32	for name, alias in node.names:
928	17	if VERSION > 1:
929	17	if name == '*':
930	0	self.namespace = 0
931	0	self.emit('IMPORT_STAR')
932	n/a	# There can only be one name w/ from ... import *
933	0	assert len(node.names) == 1
934	0	return
935	n/a	else:
936	17	self.emit('IMPORT_FROM', name)
937	17	self._resolveDots(name)
938	17	self.storeName(alias or name)
939	n/a	else:
940	0	self.emit('IMPORT_FROM', name)
941	15	self.emit('POP_TOP')
942	n/a
943	2	def _resolveDots(self, name):
944	23	elts = name.split(".")
945	23	if len(elts) == 1:
946	23	return
947	0	for elt in elts[1:]:
948	0	self.emit('LOAD_ATTR', elt)
949	n/a
950	2	def visitGetattr(self, node):
951	2526	self.visit(node.expr)
952	2526	self.emit('LOAD_ATTR', self.mangle(node.attrname))
953	n/a
954	n/a	# next five implement assignments
955	n/a
956	2	def visitAssign(self, node):
957	971	self.set_lineno(node)
958	971	self.visit(node.expr)
959	971	dups = len(node.nodes) - 1
960	1946	for i in range(len(node.nodes)):
961	975	elt = node.nodes[i]
962	975	if i < dups:
963	4	self.emit('DUP_TOP')
964	975	if isinstance(elt, ast.Node):
965	975	self.visit(elt)
966	n/a
967	2	def visitAssName(self, node):
968	829	if node.flags == 'OP_ASSIGN':
969	810	self.storeName(node.name)
970	19	elif node.flags == 'OP_DELETE':
971	19	self.set_lineno(node)
972	19	self.delName(node.name)
973	n/a	else:
974	0	print "oops", node.flags
975	n/a
976	2	def visitAssAttr(self, node):
977	337	self.visit(node.expr)
978	337	if node.flags == 'OP_ASSIGN':
979	306	self.emit('STORE_ATTR', self.mangle(node.attrname))
980	31	elif node.flags == 'OP_DELETE':
981	31	self.emit('DELETE_ATTR', self.mangle(node.attrname))
982	n/a	else:
983	0	print "warning: unexpected flags:", node.flags
984	0	print node
985	n/a
986	2	def _visitAssSequence(self, node, op='UNPACK_SEQUENCE'):
987	35	if findOp(node) != 'OP_DELETE':
988	35	self.emit(op, len(node.nodes))
989	114	for child in node.nodes:
990	79	self.visit(child)
991	n/a
992	2	if VERSION > 1:
993	2	visitAssTuple = _visitAssSequence
994	2	visitAssList = _visitAssSequence
995	n/a	else:
996	0	def visitAssTuple(self, node):
997	0	self._visitAssSequence(node, 'UNPACK_TUPLE')
998	n/a
999	0	def visitAssList(self, node):
1000	0	self._visitAssSequence(node, 'UNPACK_LIST')
1001	n/a
1002	n/a	# augmented assignment
1003	n/a
1004	2	def visitAugAssign(self, node):
1005	17	self.set_lineno(node)
1006	17	aug_node = wrap_aug(node.node)
1007	17	self.visit(aug_node, "load")
1008	17	self.visit(node.expr)
1009	17	self.emit(self._augmented_opcode[node.op])
1010	17	self.visit(aug_node, "store")
1011	n/a
1012	2	_augmented_opcode = {
1013	2	'+=' : 'INPLACE_ADD',
1014	2	'-=' : 'INPLACE_SUBTRACT',
1015	2	'*=' : 'INPLACE_MULTIPLY',
1016	2	'/=' : 'INPLACE_DIVIDE',
1017	2	'//=': 'INPLACE_FLOOR_DIVIDE',
1018	2	'%=' : 'INPLACE_MODULO',
1019	2	'**=': 'INPLACE_POWER',
1020	2	'>>=': 'INPLACE_RSHIFT',
1021	2	'<<=': 'INPLACE_LSHIFT',
1022	2	'&=' : 'INPLACE_AND',
1023	2	'^=' : 'INPLACE_XOR',
1024	2	'\|=' : 'INPLACE_OR',
1025	n/a	}
1026	n/a
1027	2	def visitAugName(self, node, mode):
1028	22	if mode == "load":
1029	11	self.loadName(node.name)
1030	11	elif mode == "store":
1031	11	self.storeName(node.name)
1032	n/a
1033	2	def visitAugGetattr(self, node, mode):
1034	12	if mode == "load":
1035	6	self.visit(node.expr)
1036	6	self.emit('DUP_TOP')
1037	6	self.emit('LOAD_ATTR', self.mangle(node.attrname))
1038	6	elif mode == "store":
1039	6	self.emit('ROT_TWO')
1040	6	self.emit('STORE_ATTR', self.mangle(node.attrname))
1041	n/a
1042	2	def visitAugSlice(self, node, mode):
1043	0	if mode == "load":
1044	0	self.visitSlice(node, 1)
1045	0	elif mode == "store":
1046	0	slice = 0
1047	0	if node.lower:
1048	0	slice = slice \| 1
1049	0	if node.upper:
1050	0	slice = slice \| 2
1051	0	if slice == 0:
1052	0	self.emit('ROT_TWO')
1053	0	elif slice == 3:
1054	0	self.emit('ROT_FOUR')
1055	n/a	else:
1056	0	self.emit('ROT_THREE')
1057	0	self.emit('STORE_SLICE+%d' % slice)
1058	n/a
1059	2	def visitAugSubscript(self, node, mode):
1060	0	if mode == "load":
1061	0	self.visitSubscript(node, 1)
1062	0	elif mode == "store":
1063	0	self.emit('ROT_THREE')
1064	0	self.emit('STORE_SUBSCR')
1065	n/a
1066	2	def visitExec(self, node):
1067	9	self.visit(node.expr)
1068	9	if node.locals is None:
1069	3	self.emit('LOAD_CONST', None)
1070	n/a	else:
1071	6	self.visit(node.locals)
1072	9	if node.globals is None:
1073	9	self.emit('DUP_TOP')
1074	n/a	else:
1075	0	self.visit(node.globals)
1076	9	self.emit('EXEC_STMT')
1077	n/a
1078	2	def visitCallFunc(self, node):
1079	2955	pos = 0
1080	2955	kw = 0
1081	2955	self.set_lineno(node)
1082	2955	self.visit(node.node)
1083	6897	for arg in node.args:
1084	3942	self.visit(arg)
1085	3942	if isinstance(arg, ast.Keyword):
1086	39	kw = kw + 1
1087	n/a	else:
1088	3903	pos = pos + 1
1089	2955	if node.star_args is not None:
1090	12	self.visit(node.star_args)
1091	2955	if node.dstar_args is not None:
1092	10	self.visit(node.dstar_args)
1093	2955	have_star = node.star_args is not None
1094	2955	have_dstar = node.dstar_args is not None
1095	2955	opcode = callfunc_opcode_info[have_star, have_dstar]
1096	2955	self.emit(opcode, kw << 8 \| pos)
1097	n/a
1098	2	def visitPrint(self, node, newline=0):
1099	8	self.set_lineno(node)
1100	8	if node.dest:
1101	4	self.visit(node.dest)
1102	17	for child in node.nodes:
1103	9	if node.dest:
1104	5	self.emit('DUP_TOP')
1105	9	self.visit(child)
1106	9	if node.dest:
1107	5	self.emit('ROT_TWO')
1108	5	self.emit('PRINT_ITEM_TO')
1109	n/a	else:
1110	4	self.emit('PRINT_ITEM')
1111	8	if node.dest and not newline:
1112	0	self.emit('POP_TOP')
1113	n/a
1114	2	def visitPrintnl(self, node):
1115	8	self.visitPrint(node, newline=1)
1116	8	if node.dest:
1117	4	self.emit('PRINT_NEWLINE_TO')
1118	n/a	else:
1119	4	self.emit('PRINT_NEWLINE')
1120	n/a
1121	2	def visitReturn(self, node):
1122	280	self.set_lineno(node)
1123	280	self.visit(node.value)
1124	280	self.emit('RETURN_VALUE')
1125	n/a
1126	2	def visitYield(self, node):
1127	2	self.set_lineno(node)
1128	2	self.visit(node.value)
1129	2	self.emit('YIELD_VALUE')
1130	n/a
1131	n/a	# slice and subscript stuff
1132	n/a
1133	2	def visitSlice(self, node, aug_flag=None):
1134	n/a	# aug_flag is used by visitAugSlice
1135	34	self.visit(node.expr)
1136	34	slice = 0
1137	34	if node.lower:
1138	18	self.visit(node.lower)
1139	18	slice = slice \| 1
1140	34	if node.upper:
1141	20	self.visit(node.upper)
1142	20	slice = slice \| 2
1143	34	if aug_flag:
1144	0	if slice == 0:
1145	0	self.emit('DUP_TOP')
1146	0	elif slice == 3:
1147	0	self.emit('DUP_TOPX', 3)
1148	n/a	else:
1149	0	self.emit('DUP_TOPX', 2)
1150	34	if node.flags == 'OP_APPLY':
1151	29	self.emit('SLICE+%d' % slice)
1152	5	elif node.flags == 'OP_ASSIGN':
1153	3	self.emit('STORE_SLICE+%d' % slice)
1154	2	elif node.flags == 'OP_DELETE':
1155	2	self.emit('DELETE_SLICE+%d' % slice)
1156	n/a	else:
1157	0	print "weird slice", node.flags
1158	0	raise
1159	n/a
1160	2	def visitSubscript(self, node, aug_flag=None):
1161	148	self.visit(node.expr)
1162	296	for sub in node.subs:
1163	148	self.visit(sub)
1164	148	if len(node.subs) > 1:
1165	0	self.emit('BUILD_TUPLE', len(node.subs))
1166	148	if aug_flag:
1167	0	self.emit('DUP_TOPX', 2)
1168	148	if node.flags == 'OP_APPLY':
1169	110	self.emit('BINARY_SUBSCR')
1170	38	elif node.flags == 'OP_ASSIGN':
1171	35	self.emit('STORE_SUBSCR')
1172	3	elif node.flags == 'OP_DELETE':
1173	3	self.emit('DELETE_SUBSCR')
1174	n/a
1175	n/a	# binary ops
1176	n/a
1177	2	def binaryOp(self, node, op):
1178	253	self.visit(node.left)
1179	253	self.visit(node.right)
1180	253	self.emit(op)
1181	n/a
1182	2	def visitAdd(self, node):
1183	93	return self.binaryOp(node, 'BINARY_ADD')
1184	n/a
1185	2	def visitSub(self, node):
1186	5	return self.binaryOp(node, 'BINARY_SUBTRACT')
1187	n/a
1188	2	def visitMul(self, node):
1189	46	return self.binaryOp(node, 'BINARY_MULTIPLY')
1190	n/a
1191	2	def visitDiv(self, node):
1192	4	return self.binaryOp(node, self._div_op)
1193	n/a
1194	2	def visitFloorDiv(self, node):
1195	13	return self.binaryOp(node, 'BINARY_FLOOR_DIVIDE')
1196	n/a
1197	2	def visitMod(self, node):
1198	78	return self.binaryOp(node, 'BINARY_MODULO')
1199	n/a
1200	2	def visitPower(self, node):
1201	4	return self.binaryOp(node, 'BINARY_POWER')
1202	n/a
1203	2	def visitLeftShift(self, node):
1204	6	return self.binaryOp(node, 'BINARY_LSHIFT')
1205	n/a
1206	2	def visitRightShift(self, node):
1207	4	return self.binaryOp(node, 'BINARY_RSHIFT')
1208	n/a
1209	n/a	# unary ops
1210	n/a
1211	2	def unaryOp(self, node, op):
1212	91	self.visit(node.expr)
1213	91	self.emit(op)
1214	n/a
1215	2	def visitInvert(self, node):
1216	0	return self.unaryOp(node, 'UNARY_INVERT')
1217	n/a
1218	2	def visitUnarySub(self, node):
1219	56	return self.unaryOp(node, 'UNARY_NEGATIVE')
1220	n/a
1221	2	def visitUnaryAdd(self, node):
1222	4	return self.unaryOp(node, 'UNARY_POSITIVE')
1223	n/a
1224	2	def visitUnaryInvert(self, node):
1225	0	return self.unaryOp(node, 'UNARY_INVERT')
1226	n/a
1227	2	def visitNot(self, node):
1228	31	return self.unaryOp(node, 'UNARY_NOT')
1229	n/a
1230	2	def visitBackquote(self, node):
1231	0	return self.unaryOp(node, 'UNARY_CONVERT')
1232	n/a
1233	n/a	# bit ops
1234	n/a
1235	2	def bitOp(self, nodes, op):
1236	3	self.visit(nodes[0])
1237	6	for node in nodes[1:]:
1238	3	self.visit(node)
1239	3	self.emit(op)
1240	n/a
1241	2	def visitBitand(self, node):
1242	1	return self.bitOp(node.nodes, 'BINARY_AND')
1243	n/a
1244	2	def visitBitor(self, node):
1245	1	return self.bitOp(node.nodes, 'BINARY_OR')
1246	n/a
1247	2	def visitBitxor(self, node):
1248	1	return self.bitOp(node.nodes, 'BINARY_XOR')
1249	n/a
1250	n/a	# object constructors
1251	n/a
1252	2	def visitEllipsis(self, node):
1253	0	self.emit('LOAD_CONST', Ellipsis)
1254	n/a
1255	2	def visitTuple(self, node):
1256	508	self.set_lineno(node)
1257	1781	for elt in node.nodes:
1258	1273	self.visit(elt)
1259	508	self.emit('BUILD_TUPLE', len(node.nodes))
1260	n/a
1261	2	def visitList(self, node):
1262	313	self.set_lineno(node)
1263	979	for elt in node.nodes:
1264	666	self.visit(elt)
1265	313	self.emit('BUILD_LIST', len(node.nodes))
1266	n/a
1267	2	def visitSet(self, node):
1268	2	self.set_lineno(node)
1269	8	for elt in node.nodes:
1270	6	self.visit(elt)
1271	2	self.emit('BUILD_SET', len(node.nodes))
1272	n/a
1273	2	def visitSliceobj(self, node):
1274	0	for child in node.nodes:
1275	0	self.visit(child)
1276	0	self.emit('BUILD_SLICE', len(node.nodes))
1277	n/a
1278	2	def visitDict(self, node):
1279	101	self.set_lineno(node)
1280	101	self.emit('BUILD_MAP', 0)
1281	236	for k, v in node.items:
1282	135	self.emit('DUP_TOP')
1283	135	self.visit(k)
1284	135	self.visit(v)
1285	135	self.emit('ROT_THREE')
1286	135	self.emit('STORE_SUBSCR')
1287	n/a
1288	4	class NestedScopeMixin:
1289	2	"""Defines initClass() for nested scoping (Python 2.2-compatible)"""
1290	2	def initClass(self):
1291	6	self.__class__.NameFinder = LocalNameFinder
1292	6	self.__class__.FunctionGen = FunctionCodeGenerator
1293	6	self.__class__.ClassGen = ClassCodeGenerator
1294	n/a
1295	4	class ModuleCodeGenerator(NestedScopeMixin, CodeGenerator):
1296	2	__super_init = CodeGenerator.__init__
1297	n/a
1298	2	scopes = None
1299	n/a
1300	2	def __init__(self, tree):
1301	19	self.graph = pyassem.PyFlowGraph("<module>", tree.filename)
1302	19	self.futures = future.find_futures(tree)
1303	19	self.__super_init()
1304	19	walk(tree, self)
1305	n/a
1306	2	def get_module(self):
1307	92	return self
1308	n/a
1309	4	class ExpressionCodeGenerator(NestedScopeMixin, CodeGenerator):
1310	2	__super_init = CodeGenerator.__init__
1311	n/a
1312	2	scopes = None
1313	2	futures = ()
1314	n/a
1315	2	def __init__(self, tree):
1316	9	self.graph = pyassem.PyFlowGraph("<expression>", tree.filename)
1317	9	self.__super_init()
1318	9	walk(tree, self)
1319	n/a
1320	2	def get_module(self):
1321	10	return self
1322	n/a
1323	4	class InteractiveCodeGenerator(NestedScopeMixin, CodeGenerator):
1324	n/a
1325	2	__super_init = CodeGenerator.__init__
1326	n/a
1327	2	scopes = None
1328	2	futures = ()
1329	n/a
1330	2	def __init__(self, tree):
1331	3	self.graph = pyassem.PyFlowGraph("<interactive>", tree.filename)
1332	3	self.__super_init()
1333	3	self.set_lineno(tree)
1334	3	walk(tree, self)
1335	3	self.emit('RETURN_VALUE')
1336	n/a
1337	2	def get_module(self):
1338	3	return self
1339	n/a
1340	2	def visitDiscard(self, node):
1341	n/a	# XXX Discard means it's an expression. Perhaps this is a bad
1342	n/a	# name.
1343	0	self.visit(node.expr)
1344	0	self.emit('PRINT_EXPR')
1345	n/a
1346	4	class AbstractFunctionCode:
1347	2	optimized = 1
1348	2	lambdaCount = 0
1349	n/a
1350	2	def __init__(self, func, scopes, isLambda, class_name, mod):
1351	637	self.class_name = class_name
1352	637	self.module = mod
1353	637	if isLambda:
1354	20	klass = FunctionCodeGenerator
1355	20	name = "<lambda.%d>" % klass.lambdaCount
1356	20	klass.lambdaCount = klass.lambdaCount + 1
1357	n/a	else:
1358	617	name = func.name
1359	n/a
1360	637	args, hasTupleArg = generateArgList(func.argnames)
1361	637	self.graph = pyassem.PyFlowGraph(name, func.filename, args,
1362	637	optimized=1)
1363	637	self.isLambda = isLambda
1364	637	self.super_init()
1365	n/a
1366	637	if not isLambda and func.doc:
1367	21	self.setDocstring(func.doc)
1368	n/a
1369	637	lnf = walk(func.code, self.NameFinder(args), verbose=0)
1370	637	self.locals.push(lnf.getLocals())
1371	637	if func.varargs:
1372	24	self.graph.setFlag(CO_VARARGS)
1373	637	if func.kwargs:
1374	4	self.graph.setFlag(CO_VARKEYWORDS)
1375	637	self.set_lineno(func)
1376	637	if hasTupleArg:
1377	0	self.generateArgUnpack(func.argnames)
1378	n/a
1379	2	def get_module(self):
1380	1059	return self.module
1381	n/a
1382	2	def finish(self):
1383	637	self.graph.startExitBlock()
1384	637	if not self.isLambda:
1385	617	self.emit('LOAD_CONST', None)
1386	637	self.emit('RETURN_VALUE')
1387	n/a
1388	2	def generateArgUnpack(self, args):
1389	0	for i in range(len(args)):
1390	0	arg = args[i]
1391	0	if isinstance(arg, tuple):
1392	0	self.emit('LOAD_FAST', '.%d' % (i * 2))
1393	0	self.unpackSequence(arg)
1394	n/a
1395	2	def unpackSequence(self, tup):
1396	0	if VERSION > 1:
1397	0	self.emit('UNPACK_SEQUENCE', len(tup))
1398	n/a	else:
1399	0	self.emit('UNPACK_TUPLE', len(tup))
1400	0	for elt in tup:
1401	0	if isinstance(elt, tuple):
1402	0	self.unpackSequence(elt)
1403	n/a	else:
1404	0	self._nameOp('STORE', elt)
1405	n/a
1406	2	unpackTuple = unpackSequence
1407	n/a
1408	4	class FunctionCodeGenerator(NestedScopeMixin, AbstractFunctionCode,
1409	2	CodeGenerator):
1410	2	super_init = CodeGenerator.__init__ # call be other init
1411	2	scopes = None
1412	n/a
1413	2	__super_init = AbstractFunctionCode.__init__
1414	n/a
1415	2	def __init__(self, func, scopes, isLambda, class_name, mod):
1416	635	self.scopes = scopes
1417	635	self.scope = scopes[func]
1418	635	self.__super_init(func, scopes, isLambda, class_name, mod)
1419	635	self.graph.setFreeVars(self.scope.get_free_vars())
1420	635	self.graph.setCellVars(self.scope.get_cell_vars())
1421	635	if self.scope.generator is not None:
1422	2	self.graph.setFlag(CO_GENERATOR)
1423	n/a
1424	4	class GenExprCodeGenerator(NestedScopeMixin, AbstractFunctionCode,
1425	2	CodeGenerator):
1426	2	super_init = CodeGenerator.__init__ # call be other init
1427	2	scopes = None
1428	n/a
1429	2	__super_init = AbstractFunctionCode.__init__
1430	n/a
1431	2	def __init__(self, gexp, scopes, class_name, mod):
1432	2	self.scopes = scopes
1433	2	self.scope = scopes[gexp]
1434	2	self.__super_init(gexp, scopes, 1, class_name, mod)
1435	2	self.graph.setFreeVars(self.scope.get_free_vars())
1436	2	self.graph.setCellVars(self.scope.get_cell_vars())
1437	2	self.graph.setFlag(CO_GENERATOR)
1438	n/a
1439	4	class AbstractClassCode:
1440	n/a
1441	2	def __init__(self, klass, scopes, module):
1442	391	self.class_name = klass.name
1443	391	self.module = module
1444	391	self.graph = pyassem.PyFlowGraph(klass.name, klass.filename,
1445	391	optimized=0, klass=1)
1446	391	self.super_init()
1447	391	lnf = walk(klass.code, self.NameFinder(), verbose=0)
1448	391	self.locals.push(lnf.getLocals())
1449	391	self.graph.setFlag(CO_NEWLOCALS)
1450	391	if klass.doc:
1451	7	self.setDocstring(klass.doc)
1452	n/a
1453	2	def get_module(self):
1454	923	return self.module
1455	n/a
1456	2	def finish(self):
1457	391	self.graph.startExitBlock()
1458	391	self.emit('LOAD_LOCALS')
1459	391	self.emit('RETURN_VALUE')
1460	n/a
1461	4	class ClassCodeGenerator(NestedScopeMixin, AbstractClassCode, CodeGenerator):
1462	2	super_init = CodeGenerator.__init__
1463	2	scopes = None
1464	n/a
1465	2	__super_init = AbstractClassCode.__init__
1466	n/a
1467	2	def __init__(self, klass, scopes, module):
1468	391	self.scopes = scopes
1469	391	self.scope = scopes[klass]
1470	391	self.__super_init(klass, scopes, module)
1471	391	self.graph.setFreeVars(self.scope.get_free_vars())
1472	391	self.graph.setCellVars(self.scope.get_cell_vars())
1473	391	self.set_lineno(klass)
1474	391	self.emit("LOAD_GLOBAL", "__name__")
1475	391	self.storeName("__module__")
1476	391	if klass.doc:
1477	7	self.emit("LOAD_CONST", klass.doc)
1478	7	self.storeName('__doc__')
1479	n/a
1480	2	def generateArgList(arglist):
1481	n/a	"""Generate an arg list marking TupleArgs"""
1482	637	args = []
1483	637	extra = []
1484	637	count = 0
1485	1582	for i in range(len(arglist)):
1486	945	elt = arglist[i]
1487	945	if isinstance(elt, str):
1488	945	args.append(elt)
1489	0	elif isinstance(elt, tuple):
1490	0	args.append(TupleArg(i * 2, elt))
1491	0	extra.extend(misc.flatten(elt))
1492	0	count = count + 1
1493	n/a	else:
1494	0	raise ValueError, "unexpect argument type:", elt
1495	637	return args + extra, count
1496	n/a
1497	2	def findOp(node):
1498	n/a	"""Find the op (DELETE, LOAD, STORE) in an AssTuple tree"""
1499	35	v = OpFinder()
1500	35	walk(node, v, verbose=0)
1501	35	return v.op
1502	n/a
1503	4	class OpFinder:
1504	2	def __init__(self):
1505	35	self.op = None
1506	2	def visitAssName(self, node):
1507	81	if self.op is None:
1508	35	self.op = node.flags
1509	46	elif self.op != node.flags:
1510	0	raise ValueError, "mixed ops in stmt"
1511	2	visitAssAttr = visitAssName
1512	2	visitSubscript = visitAssName
1513	n/a
1514	4	class Delegator:
1515	n/a	"""Base class to support delegation for augmented assignment nodes
1516	n/a
1517	n/a	To generator code for augmented assignments, we use the following
1518	n/a	wrapper classes. In visitAugAssign, the left-hand expression node
1519	n/a	is visited twice. The first time the visit uses the normal method
1520	n/a	for that node . The second time the visit uses a different method
1521	n/a	that generates the appropriate code to perform the assignment.
1522	n/a	These delegator classes wrap the original AST nodes in order to
1523	n/a	support the variant visit methods.
1524	2	"""
1525	2	def __init__(self, obj):
1526	17	self.obj = obj
1527	n/a
1528	2	def __getattr__(self, attr):
1529	40	return getattr(self.obj, attr)
1530	n/a
1531	4	class AugGetattr(Delegator):
1532	2	pass
1533	n/a
1534	4	class AugName(Delegator):
1535	2	pass
1536	n/a
1537	4	class AugSlice(Delegator):
1538	2	pass
1539	n/a
1540	4	class AugSubscript(Delegator):
1541	2	pass
1542	n/a
1543	2	wrapper = {
1544	2	ast.Getattr: AugGetattr,
1545	2	ast.Name: AugName,
1546	2	ast.Slice: AugSlice,
1547	2	ast.Subscript: AugSubscript,
1548	n/a	}
1549	n/a
1550	2	def wrap_aug(node):
1551	17	return wrapper[node.__class__](node)
1552	n/a
1553	2	if __name__ == "__main__":
1554	0	for file in sys.argv[1:]:
1555	0	compileFile(file)