def visit_FuncCall(self, node):
type = self.type
opcode = node.name.name
args = self.visits(node.args.exprs) if node.args else []
if opcode == "list":
return args
elif not type and not ops.is_void(opcode):
error(
node, "Expected a type for sub-expression "
"(add a cast or assignment)")
elif not hasattr(self.builder, opcode):
if opcode in self.mod.functions:
func = self.mod.get_function(opcode)
return self.builder.call(type, func, args)
# error(node, "No opcode %s" % (opcode,))
op = Op(opcode, type or types.Opaque, args)
self.builder.emit(op)
return op
buildop = getattr(self.builder, opcode)
if ops.is_void(opcode):
return buildop(*args)
else:
return buildop(type or types.Opaque, *args)
def visit_FuncCall(self, node):
type = self.type
opcode = node.name.name
args = self.visits(node.args.exprs) if node.args else []
if opcode == "list":
return args
elif not type and not ops.is_void(opcode):
error(node, "Expected a type for sub-expression "
"(add a cast or assignment)")
elif not hasattr(self.builder, opcode):
if opcode in self.mod.functions:
func = self.mod.get_function(opcode)
return self.builder.call(type, func, args)
# error(node, "No opcode %s" % (opcode,))
op = Op(opcode, type or types.Opaque, args)
self.builder.emit(op)
return op
buildop = getattr(self.builder, opcode)
if ops.is_void(opcode):
return buildop(*args)
else:
return buildop(type or types.Opaque, *args)
def _op(op):
"""Helper to create Builder methods"""
def _process(self, ty, args=None, result=None, **metadata):
if args is None:
args = []
assert ty is not None
assert isinstance(args, list), args
assert not any(arg is None for arg in flatten(args)), args
result = Op(op, ty, args, result)
if metadata:
result.add_metadata(metadata)
self._insert_op(result)
return result
def _process_void(self, *args, **kwds):
result = kwds.pop('result', None)
op = _process(self, types.Void, list(args), result)
if kwds:
op.add_metadata(kwds)
return op
if ops.is_void(op):
build_op = _process_void
else:
build_op = _process
if config.op_verify:
build_op = op_verifier(build_op)
return build_op
def _op(op):
"""Helper to create Builder methods"""
def _process(self, ty, args=None, result=None, **metadata):
if args is None:
args = []
assert ty is not None
assert isinstance(args, list), args
assert not any(arg is None for arg in flatten(args)), args
result = Op(op, ty, args, result)
if metadata:
result.add_metadata(metadata)
self._insert_op(result)
return result
def _process_void(self, *args, **kwds):
result = kwds.pop('result', None)
op = _process(self, types.Void, list(args), result)
if kwds:
op.add_metadata(kwds)
return op
if ops.is_void(op):
build_op = _process_void
else:
build_op = _process
if config.op_verify:
build_op = op_verifier(build_op)
return build_op
def visit_FuncCall(self, node):
type = self.type
opcode = node.name.name
args = self.visits(node.args.exprs) if node.args else []
if opcode == "list":
return args
elif not type and not ops.is_void(opcode):
error(node, "Expected a type for sub-expression "
"(add a cast or assignment)")
elif not hasattr(self.builder, opcode):
error(node, "No opcode %s" % (opcode,))
buildop = getattr(self.builder, opcode)
if ops.is_void(opcode):
return buildop(*args)
else:
return buildop(type or "Unset", args)
def visit_FuncCall(self, node):
type = self.type
opcode = node.name.name
args = self.visits(node.args.exprs) if node.args else []
if opcode == "list":
return args
elif not type and not ops.is_void(opcode):
error(
node, "Expected a type for sub-expression "
"(add a cast or assignment)")
elif not hasattr(self.builder, opcode):
if opcode in self.mod.functions:
return self.builder.call(type,
[self.mod.get_function(opcode), args])
error(node, "No opcode %s" % (opcode, ))
buildop = getattr(self.builder, opcode)
if ops.is_void(opcode):
return buildop(*args)
else:
return buildop(type or "Unset", args)
def _op(op):
"""Helper to create Builder methods"""
def _process(self, ty, args, result=None):
assert ty is not None
# args = nestedmap(make_arg, args)
result = Op(op, ty, args, result)
self._insert_op(result)
return result
if ops.is_void(op):
def build_op(self, *args, **kwds):
return _process(self, types.Void, args, kwds.pop('result', None))
else:
build_op = _process
return build_op
def _op(op):
"""Helper to create Builder methods"""
def _process(self, ty, args, result=None):
assert ty is not None
# args = nestedmap(make_arg, args)
result = Op(op, ty, args, result)
self._insert_op(result)
return result
if ops.is_void(op):
def build_op(self, *args, **kwds):
return _process(self, types.Void, args,
kwds.pop('result', None))
else:
build_op = _process
return build_op
def resolve_context(func, env):
"""Reduce typesets in context to concrete types"""
context = env['flypy.typing.context']
for op, typeset in context.items():
if typeset:
typeset = context[op]
try:
ty = reduce(typejoin, typeset)
except TypeError as e:
raise TypeError(
"Cannot type-join types for op %s: %s" % (op, e))
context[op] = ty
elif isinstance(op, ir.Op) and not ops.is_void(op.opcode):
print(func)
raise TypeError("op %s has no type in function %s" % (op, func.name))
def resolve_context(func, env):
"""Reduce typesets in context to concrete types"""
context = env['flypy.typing.context']
for op, typeset in context.iteritems():
if typeset:
typeset = context[op]
try:
ty = reduce(typejoin, typeset)
except TypeError, e:
raise TypeError("Cannot type-join types for op %s: %s" %
(op, e))
context[op] = ty
elif isinstance(op, ir.Op) and not ops.is_void(op.opcode):
print(func)
raise TypeError("op %s has no type in function %s" %
(op, func.name))
def insert(self, opcode, *args):
type = types.Void if ops.is_void(opcode) else types.Opaque
op = Op(opcode, type, list(args))
op.add_metadata({'lineno': self.lineno})
self.builder.emit(op)
return op
def gen_builder_methods():
"""Generate code for pykit.ir.builder operations"""
print("""
#===------------------------------------------------------------------===
# Generated by pykit.utils._generate
#===------------------------------------------------------------------===
""")
names = {
ops.List: 'lst',
ops.Value: 'value',
ops.Const: 'const',
ops.Any: 'any',
ops.Obj: 'obj'
}
for lineno, op in order:
if op[0].isupper():
print(" %-20s = _const(ops.%s)" % (op, op))
else:
counts = defaultdict(int)
params = []
args = []
stmts = []
if not ops.is_void(op):
params.append("returnType")
for s in ops.op_syntax[op]:
if s == ops.Star:
params.append('*args')
args.append('list(args)')
else:
param = "%s%d" % (names[s], counts[s])
params.append(param)
args.append(param)
if s == ops.List:
ty = "list"
elif s == ops.Value:
ty = "Value"
elif s == ops.Const:
ty = "Const"
else:
continue
stmts.append("assert isinstance(%s, %s)" % (param, ty))
counts[s] += 1
params = ", ".join(params) + "," if params else ""
args = ", ".join(args)
if not ops.is_void(op):
stmts.append('assert returnType is not None')
else:
stmts.append('returnType = types.Void')
d = {
'op': op, 'params': params, 'args': args,
'stmts': '\n '.join(stmts),
}
print("""
def %(op)s(self, %(params)s **kwds):
%(stmts)s
register = kwds.pop('result', None)
op = Op('%(op)s', returnType, [%(args)s], register, metadata=kwds)
if config.op_verify:
verify_op_syntax(op)
self._insert_op(op)
return op""" % d)
def insert(self, opcode, *args):
type = types.Void if ops.is_void(opcode) else types.Opaque
op = Op(opcode, type, list(args))
op.add_metadata({'lineno': self.lineno})
self.builder.emit(op)
return op
