Lichen (annotate translator.py in 9f7b491d750c)

Lichen

Annotated translator.py

289:9f7b491d750c

2016-12-01

Paul Boddie

Tidied up the string class.

paul@113	1	#!/usr/bin/env python
paul@113	2
paul@113	3	"""
paul@113	4	Translate programs.
paul@113	5
paul@113	6	Copyright (C) 2015, 2016 Paul Boddie <paul@boddie.org.uk>
paul@113	7
paul@113	8	This program is free software; you can redistribute it and/or modify it under
paul@113	9	the terms of the GNU General Public License as published by the Free Software
paul@113	10	Foundation; either version 3 of the License, or (at your option) any later
paul@113	11	version.
paul@113	12
paul@113	13	This program is distributed in the hope that it will be useful, but WITHOUT
paul@113	14	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
paul@113	15	FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
paul@113	16	details.
paul@113	17
paul@113	18	You should have received a copy of the GNU General Public License along with
paul@113	19	this program. If not, see <http://www.gnu.org/licenses/>.
paul@113	20	"""
paul@113	21
paul@113	22	from common import *
paul@113	23	from encoders import *
paul@113	24	from os.path import exists, join
paul@113	25	from os import makedirs
paul@113	26	import compiler
paul@113	27	import results
paul@113	28
paul@113	29	class Translator(CommonOutput):
paul@113	30
paul@113	31	"A program translator."
paul@113	32
paul@113	33	def __init__(self, importer, deducer, optimiser, output):
paul@113	34	self.importer = importer
paul@113	35	self.deducer = deducer
paul@113	36	self.optimiser = optimiser
paul@113	37	self.output = output
paul@113	38
paul@113	39	def to_output(self):
paul@113	40	output = join(self.output, "src")
paul@113	41
paul@113	42	if not exists(output):
paul@113	43	makedirs(output)
paul@113	44
paul@113	45	self.check_output()
paul@113	46
paul@113	47	for module in self.importer.modules.values():
paul@161	48	if module.name != "native":
paul@161	49	tm = TranslatedModule(module.name, self.importer, self.deducer, self.optimiser)
paul@161	50	tm.translate(module.filename, join(output, "%s.c" % module.name))
paul@113	51
paul@113	52	# Classes representing intermediate translation results.
paul@113	53
paul@113	54	class TranslationResult:
paul@113	55
paul@113	56	"An abstract translation result mix-in."
paul@113	57
paul@234	58	def get_accessor_kinds(self):
paul@234	59	return None
paul@113	60
paul@144	61	class ReturnRef(TranslationResult):
paul@144	62
paul@144	63	"Indicates usage of a return statement."
paul@144	64
paul@144	65	pass
paul@144	66
paul@113	67	class Expression(results.Result, TranslationResult):
paul@113	68
paul@113	69	"A general expression."
paul@113	70
paul@113	71	def __init__(self, s):
paul@113	72	self.s = s
paul@113	73	def __str__(self):
paul@113	74	return self.s
paul@113	75	def __repr__(self):
paul@113	76	return "Expression(%r)" % self.s
paul@113	77
paul@113	78	class TrResolvedNameRef(results.ResolvedNameRef, TranslationResult):
paul@113	79
paul@113	80	"A reference to a name in the translation."
paul@113	81
paul@208	82	def __init__(self, name, ref, expr=None, parameter=None):
paul@208	83	results.ResolvedNameRef.__init__(self, name, ref, expr)
paul@208	84	self.parameter = parameter
paul@208	85
paul@113	86	def __str__(self):
paul@113	87
paul@113	88	"Return an output representation of the referenced name."
paul@113	89
paul@113	90	# For sources, any identified static origin will be constant and thus
paul@113	91	# usable directly. For targets, no constant should be assigned and thus
paul@113	92	# the alias (or any plain name) will be used.
paul@113	93
paul@137	94	ref = self.static()
paul@137	95	origin = ref and self.get_origin()
paul@137	96	static_name = origin and encode_path(origin)
paul@149	97
paul@149	98	# Determine whether a qualified name is involved.
paul@149	99
paul@152	100	t = (self.get_name() or self.name).rsplit(".", 1)
paul@149	101	parent = len(t) > 1 and t[0] or None
paul@149	102	attrname = encode_path(t[-1])
paul@113	103
paul@113	104	# Assignments.
paul@113	105
paul@113	106	if self.expr:
paul@113	107
paul@113	108	# Eliminate assignments between constants.
paul@113	109
paul@196	110	if ref and isinstance(self.expr, results.ResolvedNameRef) and self.expr.static():
paul@113	111	return ""
paul@149	112
paul@149	113	# Qualified names must be converted into parent-relative assignments.
paul@149	114
paul@149	115	elif parent:
paul@149	116	return "__store_via_object(&%s, %s, %s)" % (
paul@149	117	encode_path(parent), encode_symbol("pos", attrname), self.expr)
paul@149	118
paul@149	119	# All other assignments involve the names as they were given.
paul@149	120
paul@113	121	else:
paul@208	122	return "(%s%s) = %s" % (self.parameter and "*" or "", attrname, self.expr)
paul@113	123
paul@113	124	# Expressions.
paul@113	125
paul@137	126	elif static_name:
paul@137	127	parent = ref.parent()
paul@141	128	context = ref.has_kind("<function>") and encode_path(parent) or None
paul@144	129	return "((__attr) {%s, &%s})" % (context and "&%s" % context or "0", static_name)
paul@137	130
paul@152	131	# Qualified names must be converted into parent-relative accesses.
paul@152	132
paul@152	133	elif parent:
paul@152	134	return "__load_via_object(&%s, %s)" % (
paul@152	135	encode_path(parent), encode_symbol("pos", attrname))
paul@152	136
paul@152	137	# All other accesses involve the names as they were given.
paul@152	138
paul@113	139	else:
paul@208	140	return "(%s%s)" % (self.parameter and "*" or "", attrname)
paul@113	141
paul@113	142	class TrConstantValueRef(results.ConstantValueRef, TranslationResult):
paul@113	143
paul@113	144	"A constant value reference in the translation."
paul@113	145
paul@113	146	def __str__(self):
paul@136	147	return encode_literal_constant(self.number)
paul@113	148
paul@113	149	class TrLiteralSequenceRef(results.LiteralSequenceRef, TranslationResult):
paul@113	150
paul@113	151	"A reference representing a sequence of values."
paul@113	152
paul@113	153	def __str__(self):
paul@113	154	return str(self.node)
paul@113	155
paul@113	156	class AttrResult(Expression, TranslationResult):
paul@113	157
paul@113	158	"A translation result for an attribute access."
paul@113	159
paul@234	160	def __init__(self, s, refs, accessor_kinds):
paul@113	161	Expression.__init__(self, s)
paul@113	162	self.refs = refs
paul@234	163	self.accessor_kinds = accessor_kinds
paul@113	164
paul@113	165	def get_origin(self):
paul@113	166	return self.refs and len(self.refs) == 1 and first(self.refs).get_origin()
paul@113	167
paul@118	168	def has_kind(self, kinds):
paul@118	169	if not self.refs:
paul@118	170	return False
paul@118	171	for ref in self.refs:
paul@118	172	if ref.has_kind(kinds):
paul@118	173	return True
paul@118	174	return False
paul@118	175
paul@234	176	def get_accessor_kinds(self):
paul@234	177	return self.accessor_kinds
paul@234	178
paul@113	179	def __repr__(self):
paul@136	180	return "AttrResult(%r, %r)" % (self.s, self.get_origin())
paul@113	181
paul@113	182	class PredefinedConstantRef(AttrResult):
paul@113	183
paul@113	184	"A predefined constant reference."
paul@113	185
paul@113	186	def __init__(self, value):
paul@113	187	self.value = value
paul@113	188
paul@113	189	def __str__(self):
paul@136	190	if self.value in ("False", "True"):
paul@158	191	return encode_path("__builtins__.boolean.%s" % self.value)
paul@136	192	elif self.value == "None":
paul@136	193	return encode_path("__builtins__.none.%s" % self.value)
paul@136	194	elif self.value == "NotImplemented":
paul@136	195	return encode_path("__builtins__.notimplemented.%s" % self.value)
paul@136	196	else:
paul@136	197	return self.value
paul@113	198
paul@113	199	def __repr__(self):
paul@113	200	return "PredefinedConstantRef(%r)" % self.value
paul@113	201
paul@141	202	class BooleanResult(Expression, TranslationResult):
paul@141	203
paul@141	204	"A expression producing a boolean result."
paul@141	205
paul@141	206	def __str__(self):
paul@141	207	return "__builtins___bool_bool(%s)" % self.s
paul@141	208
paul@141	209	def __repr__(self):
paul@141	210	return "BooleanResult(%r)" % self.s
paul@141	211
paul@113	212	def make_expression(expr):
paul@113	213
paul@113	214	"Make a new expression from the existing 'expr'."
paul@113	215
paul@113	216	if isinstance(expr, results.Result):
paul@113	217	return expr
paul@113	218	else:
paul@113	219	return Expression(str(expr))
paul@113	220
paul@113	221	# The actual translation process itself.
paul@113	222
paul@113	223	class TranslatedModule(CommonModule):
paul@113	224
paul@113	225	"A module translator."
paul@113	226
paul@113	227	def __init__(self, name, importer, deducer, optimiser):
paul@113	228	CommonModule.__init__(self, name, importer)
paul@113	229	self.deducer = deducer
paul@113	230	self.optimiser = optimiser
paul@113	231
paul@113	232	# Output stream.
paul@113	233
paul@113	234	self.out = None
paul@113	235	self.indent = 0
paul@113	236	self.tabstop = " "
paul@113	237
paul@113	238	# Recorded namespaces.
paul@113	239
paul@113	240	self.namespaces = []
paul@113	241	self.in_conditional = False
paul@113	242
paul@144	243	# Exception raising adjustments.
paul@144	244
paul@144	245	self.in_try_finally = False
paul@189	246	self.in_try_except = False
paul@144	247
paul@237	248	# Attribute access and accessor counting.
paul@113	249
paul@113	250	self.attr_accesses = {}
paul@237	251	self.attr_accessors = {}
paul@113	252
paul@113	253	def __repr__(self):
paul@113	254	return "TranslatedModule(%r, %r)" % (self.name, self.importer)
paul@113	255
paul@113	256	def translate(self, filename, output_filename):
paul@113	257
paul@113	258	"""
paul@113	259	Parse the file having the given 'filename', writing the translation to
paul@113	260	the given 'output_filename'.
paul@113	261	"""
paul@113	262
paul@113	263	self.parse_file(filename)
paul@113	264
paul@113	265	# Collect function namespaces for separate processing.
paul@113	266
paul@113	267	self.record_namespaces(self.astnode)
paul@113	268
paul@113	269	# Reset the lambda naming (in order to obtain the same names again) and
paul@113	270	# translate the program.
paul@113	271
paul@113	272	self.reset_lambdas()
paul@113	273
paul@113	274	self.out = open(output_filename, "w")
paul@113	275	try:
paul@128	276	self.start_output()
paul@128	277
paul@113	278	# Process namespaces, writing the translation.
paul@113	279
paul@113	280	for path, node in self.namespaces:
paul@113	281	self.process_namespace(path, node)
paul@113	282
paul@113	283	# Process the module namespace including class namespaces.
paul@113	284
paul@113	285	self.process_namespace([], self.astnode)
paul@113	286
paul@113	287	finally:
paul@113	288	self.out.close()
paul@113	289
paul@113	290	def have_object(self):
paul@113	291
paul@113	292	"Return whether a namespace is a recorded object."
paul@113	293
paul@113	294	return self.importer.objects.get(self.get_namespace_path())
paul@113	295
paul@156	296	def get_builtin_class(self, name):
paul@156	297
paul@156	298	"Return a reference to the actual object providing 'name'."
paul@156	299
paul@156	300	# NOTE: This makes assumptions about the __builtins__ structure.
paul@113	301
paul@158	302	return self.importer.get_object("__builtins__.%s.%s" % (name, name))
paul@156	303
paul@156	304	def is_method(self, path):
paul@156	305
paul@156	306	"Return whether 'path' is a method."
paul@156	307
paul@113	308	class_name, method_name = path.rsplit(".", 1)
paul@267	309	return self.importer.classes.has_key(class_name) and class_name or None
paul@113	310
paul@208	311	def in_method(self):
paul@208	312
paul@208	313	"Return whether the current namespace provides a method."
paul@208	314
paul@208	315	return self.in_function and self.is_method(self.get_namespace_path())
paul@208	316
paul@113	317	# Namespace recording.
paul@113	318
paul@113	319	def record_namespaces(self, node):
paul@113	320
paul@113	321	"Process the program structure 'node', recording namespaces."
paul@113	322
paul@113	323	for n in node.getChildNodes():
paul@113	324	self.record_namespaces_in_node(n)
paul@113	325
paul@113	326	def record_namespaces_in_node(self, node):
paul@113	327
paul@113	328	"Process the program structure 'node', recording namespaces."
paul@113	329
paul@113	330	# Function namespaces within modules, classes and other functions.
paul@113	331	# Functions appearing within conditional statements are given arbitrary
paul@113	332	# names.
paul@113	333
paul@113	334	if isinstance(node, compiler.ast.Function):
paul@113	335	self.record_function_node(node, (self.in_conditional or self.in_function) and self.get_lambda_name() or node.name)
paul@113	336
paul@113	337	elif isinstance(node, compiler.ast.Lambda):
paul@113	338	self.record_function_node(node, self.get_lambda_name())
paul@113	339
paul@113	340	# Classes are visited, but may be ignored if inside functions.
paul@113	341
paul@113	342	elif isinstance(node, compiler.ast.Class):
paul@113	343	self.enter_namespace(node.name)
paul@113	344	if self.have_object():
paul@113	345	self.record_namespaces(node)
paul@113	346	self.exit_namespace()
paul@113	347
paul@113	348	# Conditional nodes are tracked so that function definitions may be
paul@113	349	# handled. Since "for" loops are converted to "while" loops, they are
paul@113	350	# included here.
paul@113	351
paul@113	352	elif isinstance(node, (compiler.ast.For, compiler.ast.If, compiler.ast.While)):
paul@113	353	in_conditional = self.in_conditional
paul@113	354	self.in_conditional = True
paul@113	355	self.record_namespaces(node)
paul@113	356	self.in_conditional = in_conditional
paul@113	357
paul@113	358	# All other nodes are processed depth-first.
paul@113	359
paul@113	360	else:
paul@113	361	self.record_namespaces(node)
paul@113	362
paul@113	363	def record_function_node(self, n, name):
paul@113	364
paul@113	365	"""
paul@113	366	Record the given function, lambda, if expression or list comprehension
paul@113	367	node 'n' with the given 'name'.
paul@113	368	"""
paul@113	369
paul@113	370	self.in_function = True
paul@113	371	self.enter_namespace(name)
paul@113	372
paul@113	373	if self.have_object():
paul@113	374
paul@113	375	# Record the namespace path and the node itself.
paul@113	376
paul@113	377	self.namespaces.append((self.namespace_path[:], n))
paul@113	378	self.record_namespaces_in_node(n.code)
paul@113	379
paul@113	380	self.exit_namespace()
paul@113	381	self.in_function = False
paul@113	382
paul@113	383	# Constant referencing.
paul@113	384
paul@113	385	def get_literal_instance(self, n, name):
paul@113	386
paul@113	387	"""
paul@113	388	For node 'n', return a reference for the type of the given 'name'.
paul@113	389	"""
paul@113	390
paul@156	391	ref = self.get_builtin_class(name)
paul@113	392
paul@113	393	if name in ("dict", "list", "tuple"):
paul@113	394	return self.process_literal_sequence_node(n, name, ref, TrLiteralSequenceRef)
paul@113	395	else:
paul@113	396	path = self.get_namespace_path()
paul@113	397	local_number = self.importer.all_constants[path][n.value]
paul@113	398	constant_name = "$c%d" % local_number
paul@113	399	objpath = self.get_object_path(constant_name)
paul@113	400	number = self.optimiser.constant_numbers[objpath]
paul@113	401	return TrConstantValueRef(constant_name, ref.instance_of(), n.value, number)
paul@113	402
paul@113	403	# Namespace translation.
paul@113	404
paul@113	405	def process_namespace(self, path, node):
paul@113	406
paul@113	407	"""
paul@113	408	Process the namespace for the given 'path' defined by the given 'node'.
paul@113	409	"""
paul@113	410
paul@113	411	self.namespace_path = path
paul@113	412
paul@113	413	if isinstance(node, (compiler.ast.Function, compiler.ast.Lambda)):
paul@113	414	self.in_function = True
paul@113	415	self.process_function_body_node(node)
paul@113	416	else:
paul@113	417	self.in_function = False
paul@192	418	self.function_target = 0
paul@113	419	self.start_module()
paul@113	420	self.process_structure(node)
paul@113	421	self.end_module()
paul@113	422
paul@113	423	def process_structure(self, node):
paul@113	424
paul@113	425	"Process the given 'node' or result."
paul@113	426
paul@144	427	# Handle processing requests on results.
paul@144	428
paul@113	429	if isinstance(node, results.Result):
paul@113	430	return node
paul@144	431
paul@144	432	# Handle processing requests on nodes.
paul@144	433
paul@113	434	else:
paul@144	435	l = CommonModule.process_structure(self, node)
paul@144	436
paul@144	437	# Return indications of return statement usage.
paul@144	438
paul@144	439	if l and isinstance(l[-1], ReturnRef):
paul@144	440	return l[-1]
paul@144	441	else:
paul@144	442	return None
paul@113	443
paul@113	444	def process_structure_node(self, n):
paul@113	445
paul@113	446	"Process the individual node 'n'."
paul@113	447
paul@113	448	# Plain statements emit their expressions.
paul@113	449
paul@113	450	if isinstance(n, compiler.ast.Discard):
paul@113	451	expr = self.process_structure_node(n.expr)
paul@113	452	self.statement(expr)
paul@113	453
paul@113	454	# Nodes using operator module functions.
paul@113	455
paul@113	456	elif isinstance(n, compiler.ast.Operator):
paul@113	457	return self.process_operator_node(n)
paul@113	458
paul@113	459	elif isinstance(n, compiler.ast.AugAssign):
paul@113	460	self.process_augassign_node(n)
paul@113	461
paul@113	462	elif isinstance(n, compiler.ast.Compare):
paul@113	463	return self.process_compare_node(n)
paul@113	464
paul@113	465	elif isinstance(n, compiler.ast.Slice):
paul@113	466	return self.process_slice_node(n)
paul@113	467
paul@113	468	elif isinstance(n, compiler.ast.Sliceobj):
paul@113	469	return self.process_sliceobj_node(n)
paul@113	470
paul@113	471	elif isinstance(n, compiler.ast.Subscript):
paul@113	472	return self.process_subscript_node(n)
paul@113	473
paul@113	474	# Classes are visited, but may be ignored if inside functions.
paul@113	475
paul@113	476	elif isinstance(n, compiler.ast.Class):
paul@113	477	self.process_class_node(n)
paul@113	478
paul@113	479	# Functions within namespaces have any dynamic defaults initialised.
paul@113	480
paul@113	481	elif isinstance(n, compiler.ast.Function):
paul@113	482	self.process_function_node(n)
paul@113	483
paul@113	484	# Lambdas are replaced with references to separately-generated
paul@113	485	# functions.
paul@113	486
paul@113	487	elif isinstance(n, compiler.ast.Lambda):
paul@113	488	return self.process_lambda_node(n)
paul@113	489
paul@113	490	# Assignments.
paul@113	491
paul@113	492	elif isinstance(n, compiler.ast.Assign):
paul@113	493
paul@113	494	# Handle each assignment node.
paul@113	495
paul@113	496	for node in n.nodes:
paul@113	497	self.process_assignment_node(node, n.expr)
paul@113	498
paul@113	499	# Accesses.
paul@113	500
paul@113	501	elif isinstance(n, compiler.ast.Getattr):
paul@113	502	return self.process_attribute_access(n)
paul@113	503
paul@113	504	# Names.
paul@113	505
paul@113	506	elif isinstance(n, compiler.ast.Name):
paul@113	507	return self.process_name_node(n)
paul@113	508
paul@113	509	# Loops and conditionals.
paul@113	510
paul@113	511	elif isinstance(n, compiler.ast.For):
paul@113	512	self.process_for_node(n)
paul@113	513
paul@113	514	elif isinstance(n, compiler.ast.While):
paul@113	515	self.process_while_node(n)
paul@113	516
paul@113	517	elif isinstance(n, compiler.ast.If):
paul@113	518	self.process_if_node(n)
paul@113	519
paul@113	520	elif isinstance(n, (compiler.ast.And, compiler.ast.Or)):
paul@113	521	return self.process_logical_node(n)
paul@113	522
paul@113	523	elif isinstance(n, compiler.ast.Not):
paul@113	524	return self.process_not_node(n)
paul@113	525
paul@113	526	# Exception control-flow tracking.
paul@113	527
paul@113	528	elif isinstance(n, compiler.ast.TryExcept):
paul@113	529	self.process_try_node(n)
paul@113	530
paul@113	531	elif isinstance(n, compiler.ast.TryFinally):
paul@113	532	self.process_try_finally_node(n)
paul@113	533
paul@113	534	# Control-flow modification statements.
paul@113	535
paul@113	536	elif isinstance(n, compiler.ast.Break):
paul@128	537	self.writestmt("break;")
paul@113	538
paul@113	539	elif isinstance(n, compiler.ast.Continue):
paul@128	540	self.writestmt("continue;")
paul@113	541
paul@144	542	elif isinstance(n, compiler.ast.Raise):
paul@144	543	self.process_raise_node(n)
paul@144	544
paul@113	545	elif isinstance(n, compiler.ast.Return):
paul@144	546	return self.process_return_node(n)
paul@113	547
paul@173	548	# Print statements.
paul@173	549
paul@173	550	elif isinstance(n, (compiler.ast.Print, compiler.ast.Printnl)):
paul@173	551	self.statement(self.process_print_node(n))
paul@173	552
paul@113	553	# Invocations.
paul@113	554
paul@113	555	elif isinstance(n, compiler.ast.CallFunc):
paul@113	556	return self.process_invocation_node(n)
paul@113	557
paul@113	558	elif isinstance(n, compiler.ast.Keyword):
paul@113	559	return self.process_structure_node(n.expr)
paul@113	560
paul@113	561	# Constant usage.
paul@113	562
paul@113	563	elif isinstance(n, compiler.ast.Const):
paul@113	564	return self.get_literal_instance(n, n.value.__class__.__name__)
paul@113	565
paul@113	566	elif isinstance(n, compiler.ast.Dict):
paul@113	567	return self.get_literal_instance(n, "dict")
paul@113	568
paul@113	569	elif isinstance(n, compiler.ast.List):
paul@113	570	return self.get_literal_instance(n, "list")
paul@113	571
paul@113	572	elif isinstance(n, compiler.ast.Tuple):
paul@113	573	return self.get_literal_instance(n, "tuple")
paul@113	574
paul@113	575	# All other nodes are processed depth-first.
paul@113	576
paul@113	577	else:
paul@144	578	return self.process_structure(n)
paul@113	579
paul@113	580	def process_assignment_node(self, n, expr):
paul@113	581
paul@113	582	"Process the individual node 'n' to be assigned the contents of 'expr'."
paul@113	583
paul@113	584	# Names and attributes are assigned the entire expression.
paul@113	585
paul@113	586	if isinstance(n, compiler.ast.AssName):
paul@113	587	name_ref = self.process_name_node(n, self.process_structure_node(expr))
paul@113	588	self.statement(name_ref)
paul@113	589
paul@238	590	# Employ guards after assignments if required.
paul@238	591
paul@238	592	if expr and name_ref.is_name():
paul@238	593	self.generate_guard(name_ref.name)
paul@238	594
paul@113	595	elif isinstance(n, compiler.ast.AssAttr):
paul@124	596	in_assignment = self.in_assignment
paul@124	597	self.in_assignment = self.process_structure_node(expr)
paul@124	598	self.statement(self.process_attribute_access(n))
paul@124	599	self.in_assignment = in_assignment
paul@113	600
paul@113	601	# Lists and tuples are matched against the expression and their
paul@113	602	# items assigned to expression items.
paul@113	603
paul@113	604	elif isinstance(n, (compiler.ast.AssList, compiler.ast.AssTuple)):
paul@113	605	self.process_assignment_node_items(n, expr)
paul@113	606
paul@113	607	# Slices and subscripts are permitted within assignment nodes.
paul@113	608
paul@113	609	elif isinstance(n, compiler.ast.Slice):
paul@113	610	self.statement(self.process_slice_node(n, expr))
paul@113	611
paul@113	612	elif isinstance(n, compiler.ast.Subscript):
paul@113	613	self.statement(self.process_subscript_node(n, expr))
paul@113	614
paul@124	615	def process_attribute_access(self, n):
paul@113	616
paul@113	617	"""
paul@113	618	Process the given attribute access node 'n'.
paul@113	619
paul@113	620	Where a name is provided, a single access should be recorded
paul@113	621	involving potentially many attributes, thus providing a path to an
paul@113	622	object. The remaining attributes are then accessed dynamically.
paul@113	623	The remaining accesses could be deduced and computed, but they would
paul@113	624	also need to be tested.
paul@113	625
paul@113	626	Where no name is provided, potentially many accesses should be
paul@113	627	recorded, one per attribute name. These could be used to provide
paul@113	628	computed accesses, but the accessors would need to be tested in each
paul@113	629	case.
paul@113	630	"""
paul@113	631
paul@113	632	# Obtain any completed chain and return the reference to it.
paul@113	633
paul@113	634	attr_expr = self.process_attribute_chain(n)
paul@113	635	if self.have_access_expression(n):
paul@113	636	return attr_expr
paul@113	637
paul@113	638	# Where the start of the chain of attributes has been reached, process
paul@113	639	# the complete access.
paul@113	640
paul@113	641	name_ref = attr_expr and attr_expr.is_name() and attr_expr
paul@152	642	name = name_ref and self.get_name_for_tracking(name_ref.name, name_ref and name_ref.final()) or None
paul@113	643
paul@113	644	location = self.get_access_location(name)
paul@113	645	refs = self.get_referenced_attributes(location)
paul@113	646
paul@113	647	# Generate access instructions.
paul@113	648
paul@113	649	subs = {
paul@113	650	"<expr>" : str(attr_expr),
paul@124	651	"<assexpr>" : str(self.in_assignment),
paul@113	652	"<context>" : "__tmp_context",
paul@113	653	"<accessor>" : "__tmp_value",
paul@113	654	}
paul@113	655
paul@113	656	output = []
paul@113	657
paul@113	658	for instruction in self.optimiser.access_instructions[location]:
paul@113	659	output.append(encode_access_instruction(instruction, subs))
paul@113	660
paul@128	661	if len(output) == 1:
paul@128	662	out = output[0]
paul@128	663	else:
paul@128	664	out = "(\n%s\n)" % ",\n".join(output)
paul@113	665
paul@113	666	del self.attrs[0]
paul@234	667	return AttrResult(out, refs, self.get_accessor_kinds(location))
paul@113	668
paul@113	669	def get_referenced_attributes(self, location):
paul@113	670
paul@113	671	"""
paul@113	672	Convert 'location' to the form used by the deducer and retrieve any
paul@113	673	identified attribute.
paul@113	674	"""
paul@113	675
paul@113	676	access_location = self.deducer.const_accesses.get(location)
paul@113	677	refs = []
paul@113	678	for attrtype, objpath, attr in self.deducer.referenced_attrs[access_location or location]:
paul@113	679	refs.append(attr)
paul@113	680	return refs
paul@113	681
paul@234	682	def get_accessor_kinds(self, location):
paul@234	683
paul@234	684	"Return the accessor kinds for 'location'."
paul@234	685
paul@234	686	return self.optimiser.accessor_kinds[location]
paul@234	687
paul@113	688	def get_access_location(self, name):
paul@113	689
paul@113	690	"""
paul@113	691	Using the current namespace and the given 'name', return the access
paul@113	692	location.
paul@113	693	"""
paul@113	694
paul@113	695	path = self.get_path_for_access()
paul@113	696
paul@113	697	# Get the location used by the deducer and optimiser and find any
paul@113	698	# recorded access.
paul@113	699
paul@113	700	attrnames = ".".join(self.attrs)
paul@113	701	access_number = self.get_access_number(path, name, attrnames)
paul@113	702	self.update_access_number(path, name, attrnames)
paul@113	703	return (path, name, attrnames, access_number)
paul@113	704
paul@113	705	def get_access_number(self, path, name, attrnames):
paul@113	706	access = name, attrnames
paul@113	707	if self.attr_accesses.has_key(path) and self.attr_accesses[path].has_key(access):
paul@113	708	return self.attr_accesses[path][access]
paul@113	709	else:
paul@113	710	return 0
paul@113	711
paul@113	712	def update_access_number(self, path, name, attrnames):
paul@113	713	access = name, attrnames
paul@113	714	if name:
paul@113	715	init_item(self.attr_accesses, path, dict)
paul@144	716	init_item(self.attr_accesses[path], access, lambda: 0)
paul@144	717	self.attr_accesses[path][access] += 1
paul@113	718
paul@237	719	def get_accessor_location(self, name):
paul@237	720
paul@237	721	"""
paul@237	722	Using the current namespace and the given 'name', return the accessor
paul@237	723	location.
paul@237	724	"""
paul@237	725
paul@237	726	path = self.get_path_for_access()
paul@237	727
paul@237	728	# Get the location used by the deducer and optimiser and find any
paul@237	729	# recorded accessor.
paul@237	730
paul@237	731	access_number = self.get_accessor_number(path, name)
paul@237	732	self.update_accessor_number(path, name)
paul@237	733	return (path, name, None, access_number)
paul@237	734
paul@237	735	def get_accessor_number(self, path, name):
paul@237	736	if self.attr_accessors.has_key(path) and self.attr_accessors[path].has_key(name):
paul@237	737	return self.attr_accessors[path][name]
paul@237	738	else:
paul@237	739	return 0
paul@237	740
paul@237	741	def update_accessor_number(self, path, name):
paul@237	742	if name:
paul@237	743	init_item(self.attr_accessors, path, dict)
paul@237	744	init_item(self.attr_accessors[path], name, lambda: 0)
paul@237	745	self.attr_accessors[path][name] += 1
paul@237	746
paul@113	747	def process_class_node(self, n):
paul@113	748
paul@113	749	"Process the given class node 'n'."
paul@113	750
paul@113	751	self.enter_namespace(n.name)
paul@113	752
paul@113	753	if self.have_object():
paul@113	754	class_name = self.get_namespace_path()
paul@113	755	self.write_comment("Class: %s" % class_name)
paul@113	756
paul@257	757	self.initialise_inherited_members(class_name)
paul@257	758
paul@113	759	self.process_structure(n)
paul@257	760	self.write_comment("End class: %s" % class_name)
paul@113	761
paul@113	762	self.exit_namespace()
paul@113	763
paul@257	764	def initialise_inherited_members(self, class_name):
paul@257	765
paul@257	766	"Initialise members of 'class_name' inherited from its ancestors."
paul@257	767
paul@257	768	for name, path in self.importer.all_class_attrs[class_name].items():
paul@257	769	target = "%s.%s" % (class_name, name)
paul@257	770
paul@257	771	# Ignore attributes with definitions.
paul@257	772
paul@257	773	ref = self.importer.identify(target)
paul@257	774	if ref:
paul@257	775	continue
paul@257	776
paul@257	777	# Reference inherited attributes.
paul@257	778
paul@257	779	ref = self.importer.identify(path)
paul@257	780	if ref and not ref.static():
paul@257	781	parent, attrname = path.rsplit(".", 1)
paul@257	782
paul@257	783	self.writestmt("__store_via_object(&%s, %s, __load_via_object(&%s, %s));" % (
paul@257	784	encode_path(class_name), encode_symbol("pos", name),
paul@257	785	encode_path(parent), encode_symbol("pos", attrname)
paul@257	786	))
paul@257	787
paul@113	788	def process_function_body_node(self, n):
paul@113	789
paul@113	790	"""
paul@113	791	Process the given function, lambda, if expression or list comprehension
paul@113	792	node 'n', generating the body.
paul@113	793	"""
paul@113	794
paul@113	795	function_name = self.get_namespace_path()
paul@113	796	self.start_function(function_name)
paul@113	797
paul@113	798	# Process the function body.
paul@113	799
paul@113	800	in_conditional = self.in_conditional
paul@113	801	self.in_conditional = False
paul@192	802	self.function_target = 0
paul@113	803
paul@237	804	# Process any guards defined for the parameters.
paul@237	805
paul@237	806	for name in self.importer.function_parameters.get(function_name):
paul@238	807	self.generate_guard(name)
paul@237	808
paul@237	809	# Produce the body and any additional return statement.
paul@237	810
paul@144	811	expr = self.process_structure_node(n.code) or PredefinedConstantRef("None")
paul@144	812	if not isinstance(expr, ReturnRef):
paul@128	813	self.writestmt("return %s;" % expr)
paul@113	814
paul@113	815	self.in_conditional = in_conditional
paul@113	816
paul@144	817	self.end_function(function_name)
paul@113	818
paul@238	819	def generate_guard(self, name):
paul@238	820
paul@238	821	"""
paul@238	822	Get the accessor details for 'name', found in the current namespace, and
paul@238	823	generate any guards defined for it.
paul@238	824	"""
paul@238	825
paul@238	826	# Obtain the location, keeping track of assignment versions.
paul@238	827
paul@238	828	location = self.get_accessor_location(name)
paul@238	829	test = self.deducer.accessor_guard_tests.get(location)
paul@238	830
paul@238	831	# Generate any guard from the deduced information.
paul@238	832
paul@238	833	if test:
paul@238	834	guard, guard_type = test
paul@238	835
paul@238	836	if guard == "specific":
paul@238	837	ref = first(self.deducer.accessor_all_types[location])
paul@238	838	argstr = "&%s" % encode_path(ref.get_origin())
paul@238	839	elif guard == "common":
paul@238	840	ref = first(self.deducer.accessor_all_general_types[location])
paul@238	841	typeattr = encode_type_attribute(ref.get_origin())
paul@238	842	argstr = "%s, %s" % (encode_symbol("pos", typeattr), encode_symbol("code", typeattr))
paul@238	843	else:
paul@238	844	return
paul@238	845
paul@257	846	# Produce an appropriate access to an attribute's value.
paul@257	847
paul@257	848	parameters = self.importer.function_parameters.get(self.get_namespace_path())
paul@257	849	if parameters and name in parameters:
paul@257	850	name_to_value = "%s->value" % name
paul@257	851	else:
paul@257	852	name_to_value = "%s.value" % name
paul@257	853
paul@238	854	# Write a test that raises a TypeError upon failure.
paul@238	855
paul@257	856	self.writestmt("if (!__test_%s_%s(%s, %s)) __raise_type_error();" % (
paul@257	857	guard, guard_type, name_to_value, argstr))
paul@238	858
paul@113	859	def process_function_node(self, n):
paul@113	860
paul@113	861	"""
paul@113	862	Process the given function, lambda, if expression or list comprehension
paul@113	863	node 'n', generating any initialisation statements.
paul@113	864	"""
paul@113	865
paul@113	866	# Where a function is declared conditionally, use a separate name for
paul@113	867	# the definition, and assign the definition to the stated name.
paul@113	868
paul@196	869	original_name = n.name
paul@196	870
paul@113	871	if self.in_conditional or self.in_function:
paul@113	872	name = self.get_lambda_name()
paul@113	873	else:
paul@113	874	name = n.name
paul@113	875
paul@196	876	objpath = self.get_object_path(name)
paul@196	877
paul@113	878	# Obtain details of the defaults.
paul@113	879
paul@285	880	defaults = self.process_function_defaults(n, name, objpath)
paul@113	881	if defaults:
paul@113	882	for default in defaults:
paul@113	883	self.writeline("%s;" % default)
paul@113	884
paul@196	885	# Where a function is set conditionally or where the name may refer to
paul@196	886	# different values, assign the name.
paul@196	887
paul@196	888	ref = self.importer.identify(objpath)
paul@113	889
paul@196	890	if self.in_conditional or self.in_function:
paul@196	891	self.process_assignment_for_function(original_name, compiler.ast.Name(name))
paul@196	892	elif not ref.static():
paul@267	893	context = self.is_method(objpath)
paul@267	894
paul@196	895	self.process_assignment_for_function(original_name,
paul@267	896	make_expression("((__attr) {%s, &%s})" % (
paul@267	897	context and "&%s" % encode_path(context) or "0",
paul@267	898	encode_path(objpath))))
paul@113	899
paul@285	900	def process_function_defaults(self, n, name, objpath, instance_name=None):
paul@113	901
paul@113	902	"""
paul@113	903	Process the given function or lambda node 'n', initialising defaults
paul@113	904	that are dynamically set. The given 'name' indicates the name of the
paul@285	905	function. The given 'objpath' indicates the origin of the function.
paul@285	906	The given 'instance_name' indicates the name of any separate instance
paul@285	907	of the function created to hold the defaults.
paul@113	908
paul@113	909	Return a list of operations setting defaults on a function instance.
paul@113	910	"""
paul@113	911
paul@113	912	function_name = self.get_object_path(name)
paul@113	913	function_defaults = self.importer.function_defaults.get(function_name)
paul@113	914	if not function_defaults:
paul@113	915	return None
paul@113	916
paul@113	917	# Determine whether any unidentified defaults are involved.
paul@113	918
paul@285	919	for argname, default in function_defaults:
paul@285	920	if not default.static():
paul@285	921	break
paul@285	922	else:
paul@113	923	return None
paul@113	924
paul@285	925	# Handle bound methods.
paul@285	926
paul@285	927	if not instance_name:
paul@285	928	if self.is_method(objpath):
paul@285	929	instance_name = "&%s" % encode_bound_reference(objpath)
paul@285	930	else:
paul@285	931	instance_name = "&%s" % encode_path(objpath)
paul@285	932
paul@113	933	# Where defaults are involved but cannot be identified, obtain a new
paul@113	934	# instance of the lambda and populate the defaults.
paul@113	935
paul@113	936	defaults = []
paul@113	937
paul@113	938	# Join the original defaults with the inspected defaults.
paul@113	939
paul@113	940	original_defaults = [(argname, default) for (argname, default) in compiler.ast.get_defaults(n) if default]
paul@113	941
paul@113	942	for i, (original, inspected) in enumerate(map(None, original_defaults, function_defaults)):
paul@113	943
paul@113	944	# Obtain any reference for the default.
paul@113	945
paul@113	946	if original:
paul@113	947	argname, default = original
paul@113	948	name_ref = self.process_structure_node(default)
paul@113	949	elif inspected:
paul@113	950	argname, default = inspected
paul@113	951	name_ref = TrResolvedNameRef(argname, default)
paul@113	952	else:
paul@113	953	continue
paul@113	954
paul@113	955	if name_ref:
paul@285	956	defaults.append("__SETDEFAULT(%s, %s, %s)" % (instance_name, i, name_ref))
paul@113	957
paul@113	958	return defaults
paul@113	959
paul@113	960	def process_if_node(self, n):
paul@113	961
paul@113	962	"""
paul@113	963	Process the given "if" node 'n'.
paul@113	964	"""
paul@113	965
paul@113	966	first = True
paul@113	967	for test, body in n.tests:
paul@113	968	test_ref = self.process_structure_node(test)
paul@113	969	self.start_if(first, test_ref)
paul@113	970
paul@113	971	in_conditional = self.in_conditional
paul@113	972	self.in_conditional = True
paul@113	973	self.process_structure_node(body)
paul@113	974	self.in_conditional = in_conditional
paul@113	975
paul@113	976	self.end_if()
paul@113	977	first = False
paul@113	978
paul@113	979	if n.else_:
paul@113	980	self.start_else()
paul@113	981	self.process_structure_node(n.else_)
paul@113	982	self.end_else()
paul@113	983
paul@113	984	def process_invocation_node(self, n):
paul@113	985
paul@113	986	"Process the given invocation node 'n'."
paul@113	987
paul@113	988	expr = self.process_structure_node(n.node)
paul@113	989	objpath = expr.get_origin()
paul@118	990	target = None
paul@242	991	function = None
paul@159	992	literal_instantiation = False
paul@113	993
paul@113	994	# Obtain details of the callable.
paul@113	995
paul@159	996	# Literals may be instantiated specially.
paul@159	997
paul@159	998	if expr.is_name() and expr.name.startswith("$L") and objpath:
paul@159	999	literal_instantiation = True
paul@159	1000	parameters = None
paul@159	1001	target = encode_literal_instantiator(objpath)
paul@159	1002
paul@159	1003	# Identified targets employ function pointers directly.
paul@159	1004
paul@159	1005	elif objpath:
paul@113	1006	parameters = self.importer.function_parameters.get(objpath)
paul@234	1007
paul@234	1008	# Class invocation involves instantiators.
paul@234	1009
paul@118	1010	if expr.has_kind("<class>"):
paul@118	1011	target = encode_instantiator_pointer(objpath)
paul@285	1012	target_structure = "&%s" % encode_bound_reference("%s.__init__" % objpath)
paul@234	1013
paul@234	1014	# Only plain functions and bound methods employ function pointers.
paul@234	1015
paul@118	1016	elif expr.has_kind("<function>"):
paul@242	1017	function = objpath
paul@234	1018
paul@234	1019	# Test for functions and methods.
paul@234	1020
paul@234	1021	accessor_kinds = expr.get_accessor_kinds()
paul@234	1022
paul@234	1023	if not self.is_method(objpath) or accessor_kinds and len(accessor_kinds) == 1 and first(accessor_kinds) == "<instance>":
paul@234	1024	target = encode_function_pointer(objpath)
paul@285	1025	target_structure = self.is_method(objpath) and \
paul@285	1026	encode_bound_reference(objpath) or \
paul@285	1027	"&%s" % encode_path(objpath)
paul@159	1028
paul@159	1029	# Other targets are retrieved at run-time.
paul@159	1030
paul@113	1031	else:
paul@113	1032	parameters = None
paul@113	1033
paul@122	1034	# Arguments are presented in a temporary frame array with any context
paul@122	1035	# always being the first argument (although it may be set to null for
paul@122	1036	# invocations where it would be unused).
paul@122	1037
paul@192	1038	args = ["__CONTEXT_AS_VALUE(__tmp_targets[%d])" % self.function_target]
paul@122	1039	args += [None] * (not parameters and len(n.args) or parameters and len(parameters) or 0)
paul@122	1040	kwcodes = []
paul@122	1041	kwargs = []
paul@122	1042
paul@192	1043	# Any invocations in the arguments will store target details in a
paul@192	1044	# different location.
paul@192	1045
paul@192	1046	self.function_target += 1
paul@192	1047
paul@122	1048	for i, arg in enumerate(n.args):
paul@122	1049	argexpr = self.process_structure_node(arg)
paul@122	1050
paul@122	1051	# Store a keyword argument, either in the argument list or
paul@122	1052	# in a separate keyword argument list for subsequent lookup.
paul@122	1053
paul@122	1054	if isinstance(arg, compiler.ast.Keyword):
paul@113	1055
paul@122	1056	# With knowledge of the target, store the keyword
paul@122	1057	# argument directly.
paul@122	1058
paul@122	1059	if parameters:
paul@122	1060	argnum = parameters.index(arg.name)
paul@122	1061	args[argnum+1] = str(argexpr)
paul@122	1062
paul@122	1063	# Otherwise, store the details in a separate collection.
paul@122	1064
paul@122	1065	else:
paul@122	1066	kwargs.append(str(argexpr))
paul@122	1067	kwcodes.append("{%s, %s}" % (
paul@122	1068	encode_symbol("ppos", arg.name),
paul@122	1069	encode_symbol("pcode", arg.name)))
paul@122	1070
paul@122	1071	else:
paul@225	1072	try:
paul@225	1073	args[i+1] = str(argexpr)
paul@225	1074	except IndexError:
paul@225	1075	raise TranslateError("Too many arguments specified.",
paul@225	1076	self.get_namespace_path(), n)
paul@113	1077
paul@192	1078	# Reference the current target again.
paul@192	1079
paul@192	1080	self.function_target -= 1
paul@192	1081
paul@113	1082	# Defaults are added to the frame where arguments are missing.
paul@113	1083
paul@122	1084	if parameters:
paul@122	1085	function_defaults = self.importer.function_defaults.get(objpath)
paul@122	1086	if function_defaults:
paul@122	1087
paul@122	1088	# Visit each default and set any missing arguments.
paul@149	1089	# Use the target structure to obtain defaults, as opposed to the
paul@149	1090	# actual function involved.
paul@122	1091
paul@122	1092	for i, (argname, default) in enumerate(function_defaults):
paul@122	1093	argnum = parameters.index(argname)
paul@122	1094	if not args[argnum+1]:
paul@285	1095	args[argnum+1] = "__GETDEFAULT(%s, %d)" % (target_structure, i)
paul@149	1096
paul@173	1097	# Test for missing arguments.
paul@173	1098
paul@173	1099	if None in args:
paul@173	1100	raise TranslateError("Not all arguments supplied.",
paul@173	1101	self.get_namespace_path(), n)
paul@173	1102
paul@149	1103	# Encode the arguments.
paul@122	1104
paul@122	1105	argstr = "__ARGS(%s)" % ", ".join(args)
paul@122	1106	kwargstr = kwargs and ("__ARGS(%s)" % ", ".join(kwargs)) or "0"
paul@122	1107	kwcodestr = kwcodes and ("__KWARGS(%s)" % ", ".join(kwcodes)) or "0"
paul@122	1108
paul@159	1109	# Where literal instantiation is occurring, add an argument indicating
paul@159	1110	# the number of values.
paul@159	1111
paul@159	1112	if literal_instantiation:
paul@159	1113	argstr += ", %d" % (len(args) - 1)
paul@159	1114
paul@156	1115	# First, the invocation expression is presented.
paul@113	1116
paul@156	1117	stages = []
paul@156	1118
paul@156	1119	# Without a known specific callable, the expression provides the target.
paul@118	1120
paul@192	1121	stages.append("__tmp_targets[%d] = %s" % (self.function_target, expr))
paul@156	1122
paul@156	1123	# Any specific callable is then obtained.
paul@156	1124
paul@163	1125	if target:
paul@156	1126	stages.append(target)
paul@242	1127	elif function:
paul@244	1128	stages.append("__load_via_object(__tmp_targets[%d].value, %s).fn" % (
paul@244	1129	self.function_target, encode_symbol("pos", "__fn__")))
paul@122	1130
paul@122	1131	# With a known target, the function is obtained directly and called.
paul@122	1132
paul@242	1133	if target or function:
paul@136	1134	output = "(\n%s\n)(%s)" % (",\n".join(stages), argstr)
paul@113	1135
paul@122	1136	# With unknown targets, the generic invocation function is applied to
paul@122	1137	# the callable and argument collections.
paul@113	1138
paul@122	1139	else:
paul@192	1140	output = "(%s, __invoke(\n__tmp_targets[%d],\n%d, %d, %s, %s,\n%d, %s\n))" % (
paul@122	1141	",\n".join(stages),
paul@192	1142	self.function_target,
paul@156	1143	self.always_callable and 1 or 0,
paul@122	1144	len(kwargs), kwcodestr, kwargstr,
paul@122	1145	len(args), argstr)
paul@122	1146
paul@122	1147	return make_expression(output)
paul@113	1148
paul@113	1149	def always_callable(self, refs):
paul@113	1150
paul@113	1151	"Determine whether all 'refs' are callable."
paul@113	1152
paul@113	1153	for ref in refs:
paul@113	1154	if not ref.static():
paul@113	1155	return False
paul@113	1156	else:
paul@113	1157	origin = ref.final()
paul@113	1158	if not self.importer.get_attribute(origin, "__fn__"):
paul@113	1159	return False
paul@113	1160	return True
paul@113	1161
paul@113	1162	def need_default_arguments(self, objpath, nargs):
paul@113	1163
paul@113	1164	"""
paul@113	1165	Return whether any default arguments are needed when invoking the object
paul@113	1166	given by 'objpath'.
paul@113	1167	"""
paul@113	1168
paul@113	1169	parameters = self.importer.function_parameters.get(objpath)
paul@113	1170	return nargs < len(parameters)
paul@113	1171
paul@113	1172	def process_lambda_node(self, n):
paul@113	1173
paul@113	1174	"Process the given lambda node 'n'."
paul@113	1175
paul@113	1176	name = self.get_lambda_name()
paul@113	1177	function_name = self.get_object_path(name)
paul@113	1178
paul@285	1179	defaults = self.process_function_defaults(n, name, function_name, "__tmp_value")
paul@149	1180
paul@149	1181	# Without defaults, produce an attribute referring to the function.
paul@149	1182
paul@113	1183	if not defaults:
paul@149	1184	return make_expression("((__attr) {0, &%s})" % encode_path(function_name))
paul@149	1185
paul@149	1186	# With defaults, copy the function structure and set the defaults on the
paul@149	1187	# copy.
paul@149	1188
paul@113	1189	else:
paul@155	1190	return make_expression("(__tmp_value = __COPY(&%s, sizeof(%s)), %s, (__attr) {0, __tmp_value})" % (
paul@151	1191	encode_path(function_name),
paul@151	1192	encode_symbol("obj", function_name),
paul@151	1193	", ".join(defaults)))
paul@113	1194
paul@113	1195	def process_logical_node(self, n):
paul@113	1196
paul@141	1197	"""
paul@141	1198	Process the given operator node 'n'.
paul@141	1199
paul@141	1200	Convert ... to ...
paul@141	1201
paul@141	1202	<a> and <b>
paul@141	1203	(__tmp_result = <a>, !__BOOL(__tmp_result)) ? __tmp_result : <b>
paul@141	1204
paul@141	1205	<a> or <b>
paul@141	1206	(__tmp_result = <a>, __BOOL(__tmp_result)) ? __tmp_result : <b>
paul@141	1207	"""
paul@113	1208
paul@113	1209	if isinstance(n, compiler.ast.And):
paul@141	1210	op = "!"
paul@113	1211	else:
paul@141	1212	op = ""
paul@141	1213
paul@141	1214	results = []
paul@113	1215
paul@141	1216	for node in n.nodes[:-1]:
paul@141	1217	expr = self.process_structure_node(node)
paul@141	1218	results.append("(__tmp_result = %s, %s__BOOL(__tmp_result)) ? __tmp_result : " % (expr, op))
paul@113	1219
paul@141	1220	expr = self.process_structure_node(n.nodes[-1])
paul@141	1221	results.append(str(expr))
paul@141	1222
paul@141	1223	return make_expression("(%s)" % "".join(results))
paul@113	1224
paul@113	1225	def process_name_node(self, n, expr=None):
paul@113	1226
paul@113	1227	"Process the given name node 'n' with the optional assignment 'expr'."
paul@113	1228
paul@113	1229	# Determine whether the name refers to a static external entity.
paul@113	1230
paul@113	1231	if n.name in predefined_constants:
paul@113	1232	return PredefinedConstantRef(n.name)
paul@113	1233
paul@173	1234	# Convert literal references, operator function names, and print
paul@173	1235	# function names to references.
paul@113	1236
paul@173	1237	elif n.name.startswith("$L") or n.name.startswith("$op") or \
paul@173	1238	n.name.startswith("$print"):
paul@136	1239	ref = self.importer.get_module(self.name).special.get(n.name)
paul@113	1240	return TrResolvedNameRef(n.name, ref)
paul@113	1241
paul@113	1242	# Get the appropriate name for the name reference, using the same method
paul@113	1243	# as in the inspector.
paul@113	1244
paul@250	1245	path = self.get_namespace_path()
paul@250	1246	objpath = self.get_object_path(n.name)
paul@250	1247
paul@250	1248	# Determine any assigned globals.
paul@250	1249
paul@250	1250	globals = self.importer.get_module(self.name).scope_globals.get(path)
paul@250	1251	if globals and n.name in globals:
paul@250	1252	objpath = self.get_global_path(n.name)
paul@113	1253
paul@113	1254	# Get the static identity of the name.
paul@113	1255
paul@250	1256	ref = self.importer.identify(objpath)
paul@152	1257	if ref and not ref.get_name():
paul@250	1258	ref = ref.alias(objpath)
paul@113	1259
paul@113	1260	# Obtain any resolved names for non-assignment names.
paul@113	1261
paul@113	1262	if not expr and not ref and self.in_function:
paul@250	1263	locals = self.importer.function_locals.get(path)
paul@113	1264	ref = locals and locals.get(n.name)
paul@113	1265
paul@208	1266	# Determine whether the name refers to a parameter. The generation of
paul@208	1267	# parameter references is different from other names.
paul@208	1268
paul@250	1269	parameters = self.importer.function_parameters.get(path)
paul@208	1270	parameter = n.name == "self" and self.in_method() or \
paul@208	1271	parameters and n.name in parameters
paul@208	1272
paul@113	1273	# Qualified names are used for resolved static references or for
paul@113	1274	# static namespace members. The reference should be configured to return
paul@113	1275	# such names.
paul@113	1276
paul@208	1277	return TrResolvedNameRef(n.name, ref, expr=expr, parameter=parameter)
paul@113	1278
paul@113	1279	def process_not_node(self, n):
paul@113	1280
paul@113	1281	"Process the given operator node 'n'."
paul@113	1282
paul@144	1283	return make_expression("(__BOOL(%s) ? %s : %s)" %
paul@149	1284	(self.process_structure_node(n.expr), PredefinedConstantRef("False"),
paul@149	1285	PredefinedConstantRef("True")))
paul@144	1286
paul@144	1287	def process_raise_node(self, n):
paul@144	1288
paul@144	1289	"Process the given raise node 'n'."
paul@144	1290
paul@144	1291	# NOTE: Determine which raise statement variants should be permitted.
paul@144	1292
paul@176	1293	if n.expr1:
paul@176	1294	self.writestmt("__Raise(%s);" % self.process_structure_node(n.expr1))
paul@176	1295	else:
paul@176	1296	self.writestmt("__Complete;")
paul@144	1297
paul@144	1298	def process_return_node(self, n):
paul@144	1299
paul@144	1300	"Process the given return node 'n'."
paul@144	1301
paul@144	1302	expr = self.process_structure_node(n.value) or PredefinedConstantRef("None")
paul@189	1303	if self.in_try_finally or self.in_try_except:
paul@144	1304	self.writestmt("__Return(%s);" % expr)
paul@144	1305	else:
paul@144	1306	self.writestmt("return %s;" % expr)
paul@144	1307
paul@144	1308	return ReturnRef()
paul@113	1309
paul@113	1310	def process_try_node(self, n):
paul@113	1311
paul@113	1312	"""
paul@113	1313	Process the given "try...except" node 'n'.
paul@113	1314	"""
paul@113	1315
paul@189	1316	in_try_except = self.in_try_except
paul@189	1317	self.in_try_except = True
paul@189	1318
paul@144	1319	# Use macros to implement exception handling.
paul@113	1320
paul@144	1321	self.writestmt("__Try")
paul@113	1322	self.writeline("{")
paul@113	1323	self.indent += 1
paul@113	1324	self.process_structure_node(n.body)
paul@144	1325
paul@144	1326	# Put the else statement in another try block that handles any raised
paul@144	1327	# exceptions and converts them to exceptions that will not be handled by
paul@144	1328	# the main handling block.
paul@144	1329
paul@144	1330	if n.else_:
paul@144	1331	self.writestmt("__Try")
paul@144	1332	self.writeline("{")
paul@144	1333	self.indent += 1
paul@144	1334	self.process_structure_node(n.else_)
paul@144	1335	self.indent -= 1
paul@144	1336	self.writeline("}")
paul@144	1337	self.writeline("__Catch (__tmp_exc)")
paul@144	1338	self.writeline("{")
paul@144	1339	self.indent += 1
paul@144	1340	self.writeline("if (__tmp_exc.raising) __RaiseElse(__tmp_exc.arg);")
paul@191	1341	self.writeline("else if (__tmp_exc.completing) __Throw(__tmp_exc);")
paul@144	1342	self.indent -= 1
paul@144	1343	self.writeline("}")
paul@144	1344
paul@144	1345	# Complete the try block and enter the finally block, if appropriate.
paul@144	1346
paul@144	1347	if self.in_try_finally:
paul@144	1348	self.writestmt("__Complete;")
paul@144	1349
paul@113	1350	self.indent -= 1
paul@113	1351	self.writeline("}")
paul@113	1352
paul@189	1353	self.in_try_except = in_try_except
paul@189	1354
paul@144	1355	# Handlers are tests within a common handler block.
paul@144	1356
paul@144	1357	self.writeline("__Catch (__tmp_exc)")
paul@144	1358	self.writeline("{")
paul@144	1359	self.indent += 1
paul@144	1360
paul@189	1361	# Introduce an if statement to handle the completion of a try block.
paul@189	1362
paul@189	1363	self.process_try_completion()
paul@189	1364
paul@144	1365	# Handle exceptions in else blocks converted to __RaiseElse, converting
paul@144	1366	# them back to normal exceptions.
paul@144	1367
paul@144	1368	if n.else_:
paul@189	1369	self.writeline("else if (__tmp_exc.raising_else) __Raise(__tmp_exc.arg);")
paul@144	1370
paul@144	1371	# Exception handling.
paul@144	1372
paul@113	1373	for name, var, handler in n.handlers:
paul@144	1374
paul@144	1375	# Test for specific exceptions.
paul@144	1376
paul@113	1377	if name is not None:
paul@113	1378	name_ref = self.process_structure_node(name)
paul@191	1379	self.writeline("else if (__BOOL(__fn_native__isinstance((__attr[]) {{0, 0}, __tmp_exc.arg, %s})))" % name_ref)
paul@144	1380	else:
paul@189	1381	self.writeline("else if (1)")
paul@113	1382
paul@113	1383	self.writeline("{")
paul@113	1384	self.indent += 1
paul@113	1385
paul@113	1386	# Establish the local for the handler.
paul@113	1387
paul@113	1388	if var is not None:
paul@261	1389	self.writestmt("%s;" % self.process_name_node(var, make_expression("__tmp_exc.arg")))
paul@113	1390
paul@113	1391	if handler is not None:
paul@113	1392	self.process_structure_node(handler)
paul@113	1393
paul@113	1394	self.indent -= 1
paul@113	1395	self.writeline("}")
paul@113	1396
paul@144	1397	# Re-raise unhandled exceptions.
paul@144	1398
paul@189	1399	self.writeline("else __Throw(__tmp_exc);")
paul@144	1400
paul@144	1401	# End the handler block.
paul@144	1402
paul@144	1403	self.indent -= 1
paul@144	1404	self.writeline("}")
paul@113	1405
paul@113	1406	def process_try_finally_node(self, n):
paul@113	1407
paul@113	1408	"""
paul@113	1409	Process the given "try...finally" node 'n'.
paul@113	1410	"""
paul@113	1411
paul@144	1412	in_try_finally = self.in_try_finally
paul@144	1413	self.in_try_finally = True
paul@113	1414
paul@144	1415	# Use macros to implement exception handling.
paul@144	1416
paul@144	1417	self.writestmt("__Try")
paul@113	1418	self.writeline("{")
paul@113	1419	self.indent += 1
paul@113	1420	self.process_structure_node(n.body)
paul@113	1421	self.indent -= 1
paul@113	1422	self.writeline("}")
paul@144	1423
paul@144	1424	self.in_try_finally = in_try_finally
paul@144	1425
paul@144	1426	# Finally clauses handle special exceptions.
paul@144	1427
paul@144	1428	self.writeline("__Catch (__tmp_exc)")
paul@113	1429	self.writeline("{")
paul@113	1430	self.indent += 1
paul@113	1431	self.process_structure_node(n.final)
paul@144	1432
paul@189	1433	# Introduce an if statement to handle the completion of a try block.
paul@189	1434
paul@189	1435	self.process_try_completion()
paul@189	1436	self.writeline("else __Throw(__tmp_exc);")
paul@189	1437
paul@189	1438	self.indent -= 1
paul@189	1439	self.writeline("}")
paul@189	1440
paul@189	1441	def process_try_completion(self):
paul@189	1442
paul@189	1443	"Generate a test for the completion of a try block."
paul@144	1444
paul@144	1445	self.writestmt("if (__tmp_exc.completing)")
paul@144	1446	self.writeline("{")
paul@144	1447	self.indent += 1
paul@189	1448
paul@189	1449	# Only use the normal return statement if no surrounding try blocks
paul@189	1450	# apply.
paul@189	1451
paul@189	1452	if not self.in_try_finally and not self.in_try_except:
paul@189	1453	self.writeline("if (!__ISNULL(__tmp_exc.arg)) return __tmp_exc.arg;")
paul@189	1454	else:
paul@189	1455	self.writeline("if (!__ISNULL(__tmp_exc.arg)) __Throw(__tmp_exc);")
paul@144	1456
paul@113	1457	self.indent -= 1
paul@113	1458	self.writeline("}")
paul@113	1459
paul@113	1460	def process_while_node(self, n):
paul@113	1461
paul@113	1462	"Process the given while node 'n'."
paul@113	1463
paul@113	1464	self.writeline("while (1)")
paul@113	1465	self.writeline("{")
paul@113	1466	self.indent += 1
paul@113	1467	test = self.process_structure_node(n.test)
paul@113	1468
paul@113	1469	# Emit the loop termination condition unless "while <true value>" is
paul@113	1470	# indicated.
paul@113	1471
paul@113	1472	if not (isinstance(test, PredefinedConstantRef) and test.value):
paul@113	1473
paul@113	1474	# NOTE: This needs to evaluate whether the operand is true or false
paul@113	1475	# NOTE: according to Python rules.
paul@113	1476
paul@144	1477	self.writeline("if (!__BOOL(%s))" % test)
paul@113	1478	self.writeline("{")
paul@113	1479	self.indent += 1
paul@113	1480	if n.else_:
paul@113	1481	self.process_structure_node(n.else_)
paul@128	1482	self.writestmt("break;")
paul@113	1483	self.indent -= 1
paul@113	1484	self.writeline("}")
paul@113	1485
paul@113	1486	in_conditional = self.in_conditional
paul@113	1487	self.in_conditional = True
paul@113	1488	self.process_structure_node(n.body)
paul@113	1489	self.in_conditional = in_conditional
paul@113	1490
paul@113	1491	self.indent -= 1
paul@113	1492	self.writeline("}")
paul@113	1493
paul@113	1494	# Output generation.
paul@113	1495
paul@128	1496	def start_output(self):
paul@159	1497
paul@159	1498	"Write the declarations at the top of each source file."
paul@159	1499
paul@128	1500	print >>self.out, """\
paul@128	1501	#include "types.h"
paul@144	1502	#include "exceptions.h"
paul@128	1503	#include "ops.h"
paul@128	1504	#include "progconsts.h"
paul@128	1505	#include "progops.h"
paul@128	1506	#include "progtypes.h"
paul@137	1507	#include "main.h"
paul@128	1508	"""
paul@128	1509
paul@113	1510	def start_module(self):
paul@159	1511
paul@159	1512	"Write the start of each module's main function."
paul@159	1513
paul@113	1514	print >>self.out, "void __main_%s()" % encode_path(self.name)
paul@113	1515	print >>self.out, "{"
paul@113	1516	self.indent += 1
paul@192	1517	self.write_temporaries(self.importer.function_targets.get(self.name))
paul@113	1518
paul@113	1519	def end_module(self):
paul@159	1520
paul@159	1521	"End each module by closing its main function."
paul@159	1522
paul@113	1523	self.indent -= 1
paul@144	1524	print >>self.out, "}"
paul@113	1525
paul@113	1526	def start_function(self, name):
paul@159	1527
paul@159	1528	"Start the function having the given 'name'."
paul@159	1529
paul@113	1530	print >>self.out, "__attr %s(__attr __args[])" % encode_function_pointer(name)
paul@113	1531	print >>self.out, "{"
paul@113	1532	self.indent += 1
paul@192	1533	self.write_temporaries(self.importer.function_targets.get(name))
paul@113	1534
paul@113	1535	# Obtain local names from parameters.
paul@113	1536
paul@113	1537	parameters = self.importer.function_parameters[name]
paul@144	1538	locals = self.importer.function_locals[name].keys()
paul@113	1539	names = []
paul@113	1540
paul@113	1541	for n in locals:
paul@113	1542
paul@113	1543	# Filter out special names and parameters. Note that self is a local
paul@113	1544	# regardless of whether it originally appeared in the parameters or
paul@113	1545	# not.
paul@113	1546
paul@113	1547	if n.startswith("$l") or n in parameters or n == "self":
paul@113	1548	continue
paul@113	1549	names.append(encode_path(n))
paul@113	1550
paul@113	1551	# Emit required local names.
paul@113	1552
paul@113	1553	if names:
paul@113	1554	names.sort()
paul@113	1555	self.writeline("__attr %s;" % ", ".join(names))
paul@113	1556
paul@208	1557	self.write_parameters(name)
paul@144	1558
paul@144	1559	def end_function(self, name):
paul@159	1560
paul@159	1561	"End the function having the given 'name'."
paul@159	1562
paul@144	1563	self.indent -= 1
paul@144	1564	print >>self.out, "}"
paul@144	1565	print >>self.out
paul@144	1566
paul@192	1567	def write_temporaries(self, targets):
paul@159	1568
paul@192	1569	"""
paul@192	1570	Write temporary storage employed by functions, providing space for the
paul@192	1571	given number of 'targets'.
paul@192	1572	"""
paul@192	1573
paul@192	1574	targets = targets is not None and "__tmp_targets[%d], " % targets or ""
paul@159	1575
paul@149	1576	self.writeline("__ref __tmp_context, __tmp_value;")
paul@192	1577	self.writeline("__attr %s__tmp_result;" % targets)
paul@149	1578	self.writeline("__exc __tmp_exc;")
paul@149	1579
paul@208	1580	def write_parameters(self, name):
paul@159	1581
paul@159	1582	"""
paul@159	1583	For the function having the given 'name', write definitions of
paul@208	1584	parameters found in the arguments array.
paul@159	1585	"""
paul@159	1586
paul@144	1587	parameters = self.importer.function_parameters[name]
paul@144	1588
paul@113	1589	# Generate any self reference.
paul@113	1590
paul@156	1591	if self.is_method(name):
paul@208	1592	self.writeline("__attr * const self = &__args[0];")
paul@113	1593
paul@113	1594	# Generate aliases for the parameters.
paul@113	1595
paul@113	1596	for i, parameter in enumerate(parameters):
paul@208	1597	self.writeline("__attr * const %s = &__args[%d];" % (encode_path(parameter), i+1))
paul@113	1598
paul@113	1599	def start_if(self, first, test_ref):
paul@144	1600	self.writestmt("%sif (__BOOL(%s))" % (not first and "else " or "", test_ref))
paul@113	1601	self.writeline("{")
paul@113	1602	self.indent += 1
paul@113	1603
paul@113	1604	def end_if(self):
paul@113	1605	self.indent -= 1
paul@113	1606	self.writeline("}")
paul@113	1607
paul@113	1608	def start_else(self):
paul@113	1609	self.writeline("else")
paul@113	1610	self.writeline("{")
paul@113	1611	self.indent += 1
paul@113	1612
paul@113	1613	def end_else(self):
paul@113	1614	self.indent -= 1
paul@113	1615	self.writeline("}")
paul@113	1616
paul@113	1617	def statement(self, expr):
paul@113	1618	# NOTE: Should never be None.
paul@113	1619	if not expr:
paul@128	1620	self.writestmt("...;")
paul@113	1621	s = str(expr)
paul@113	1622	if s:
paul@128	1623	self.writestmt("%s;" % s)
paul@113	1624
paul@113	1625	def statements(self, results):
paul@113	1626	for result in results:
paul@113	1627	self.statement(result)
paul@113	1628
paul@159	1629	def writeline(self, s):
paul@159	1630	print >>self.out, "%s%s" % (self.pad(), self.indenttext(s, self.indent + 1))
paul@159	1631
paul@159	1632	def writestmt(self, s):
paul@159	1633	print >>self.out
paul@159	1634	self.writeline(s)
paul@159	1635
paul@159	1636	def write_comment(self, s):
paul@159	1637	self.writestmt("/* %s */" % s)
paul@159	1638
paul@113	1639	def pad(self, extra=0):
paul@113	1640	return (self.indent + extra) * self.tabstop
paul@113	1641
paul@113	1642	def indenttext(self, s, levels):
paul@116	1643	lines = s.split("\n")
paul@116	1644	out = [lines[0]]
paul@116	1645	for line in lines[1:]:
paul@116	1646	out.append(levels * self.tabstop + line)
paul@116	1647	if line.endswith("("):
paul@116	1648	levels += 1
paul@122	1649	elif line.startswith(")"):
paul@116	1650	levels -= 1
paul@116	1651	return "\n".join(out)
paul@113	1652
paul@113	1653	# vim: tabstop=4 expandtab shiftwidth=4