def cli2py(space, b_obj):
# TODO: support other types and find the most efficient way to
# select the correct case
if b_obj is None:
return space.w_None
w_obj = unbox(b_obj, W_Root)
if w_obj is not None:
return w_obj # it's already a wrapped object!
b_type = b_obj.GetType()
if b_type == typeof(System.Int32):
intval = unbox(b_obj, ootype.Signed)
return space.wrap(intval)
elif b_type == typeof(System.Double):
floatval = unbox(b_obj, ootype.Float)
return space.wrap(floatval)
elif b_type == typeof(System.Boolean):
boolval = unbox(b_obj, ootype.Bool)
return space.wrap(boolval)
elif b_type == typeof(System.String):
strval = unbox(b_obj, ootype.String)
return space.wrap(strval)
else:
namespace, classname = split_fullname(b_type.ToString())
assemblyname = b_type.get_Assembly().get_FullName()
w_cls = load_cli_class(space, assemblyname, namespace, classname)
cliobj = W_CliObject(space, b_obj)
return wrapper_from_cliobj(space, w_cls, cliobj)
def fn(flag):
if flag:
clitype = typeof(System.Int32)
else:
clitype = typeof(System.String)
cls = type2class(clitype)
return cls is cInt32
def cli2py(space, b_obj):
# TODO: support other types and find the most efficient way to
# select the correct case
if b_obj is None:
return space.w_None
w_obj = unbox(b_obj, W_Root)
if w_obj is not None:
return w_obj # it's already a wrapped object!
b_type = b_obj.GetType()
if b_type == typeof(System.Int32):
intval = unbox(b_obj, ootype.Signed)
return space.wrap(intval)
elif b_type == typeof(System.Double):
floatval = unbox(b_obj, ootype.Float)
return space.wrap(floatval)
elif b_type == typeof(System.Boolean):
boolval = unbox(b_obj, ootype.Bool)
return space.wrap(boolval)
elif b_type == typeof(System.String):
strval = unbox(b_obj, ootype.String)
return space.wrap(strval)
else:
namespace, classname = split_fullname(b_type.ToString())
assemblyname = b_type.get_Assembly().get_FullName()
w_cls = load_cli_class(space, assemblyname, namespace, classname)
cliobj = W_CliObject(space, b_obj)
return wrapper_from_cliobj(space, w_cls, cliobj)
def fn(flag):
if flag:
clitype = typeof(System.Int32)
else:
clitype = typeof(System.String)
cls = type2class(clitype)
return cls is cInt32
def cli2py(space, b_obj):
# TODO: support other types and find the most efficient way to
# select the correct case
if b_obj is None:
return space.w_None
w_obj = unbox(b_obj, W_Root)
if w_obj is not None:
return w_obj # it's already a wrapped object!
b_type = b_obj.GetType()
if b_type == typeof(System.Int32):
intval = unbox(b_obj, ootype.Signed)
return space.wrap(intval)
elif b_type == typeof(System.Double):
floatval = unbox(b_obj, ootype.Float)
return space.wrap(floatval)
elif b_type == typeof(System.Boolean):
boolval = unbox(b_obj, ootype.Bool)
return space.wrap(boolval)
elif b_type == typeof(System.String):
strval = unbox(b_obj, ootype.String)
return space.wrap(strval)
else:
msg = "Can't convert object %s to Python" % str(b_obj.ToString())
raise OperationError(space.w_TypeError, space.wrap(msg))
def build_fn():
tInt = typeof(System.Int32)
args = init_array(System.Type, tInt, tInt)
meth = Utils.CreateDynamicMethod("add", tInt, args)
il = meth.GetILGenerator()
il.Emit(OpCodes.Ldarg_0)
il.Emit(OpCodes.Ldarg_1)
il.Emit(OpCodes.Add)
il.Emit(OpCodes.Ret)
myfunc = meth.CreateDelegate(typeof(FUNCTYPE))
return myfunc
def build_fn():
tInt = typeof(System.Int32)
args = init_array(System.Type, tInt, tInt)
meth = Utils.CreateDynamicMethod("add", tInt, args)
il = meth.GetILGenerator()
il.Emit(OpCodes.Ldarg_0)
il.Emit(OpCodes.Ldarg_1)
il.Emit(OpCodes.Add)
il.Emit(OpCodes.Ret)
myfunc = meth.CreateDelegate(typeof(FUNCTYPE))
return myfunc
def getCliType(self, meth):
if self in meth.box2type:
return meth.box2type[self]
if self.type == history.INT:
return dotnet.typeof(System.Int32)
elif self.type == history.FLOAT:
return dotnet.typeof(System.Double)
elif self.type == history.REF:
return dotnet.typeof(System.Object)
else:
assert False, 'Unknown type: %s' % self.type
def build_fn():
tObjArray = System.Type.GetType("System.Object[]")
tInt = typeof(System.Int32)
args = init_array(System.Type, tObjArray, tInt, tInt)
meth = Utils.CreateDynamicMethod("add", tInt, args)
il = meth.GetILGenerator()
il.Emit(OpCodes.Ldarg_1)
il.Emit(OpCodes.Ldarg_2)
il.Emit(OpCodes.Add)
il.Emit(OpCodes.Ret)
array = new_array(System.Object, 0)
myfunc = meth.CreateDelegate(typeof(FUNCTYPE), array)
return myfunc
def build_fn():
tObjArray = System.Type.GetType("System.Object[]")
tInt = typeof(System.Int32)
args = init_array(System.Type, tObjArray, tInt, tInt)
meth = Utils.CreateDynamicMethod("add", tInt, args)
il = meth.GetILGenerator()
il.Emit(OpCodes.Ldarg_1)
il.Emit(OpCodes.Ldarg_2)
il.Emit(OpCodes.Add)
il.Emit(OpCodes.Ret)
array = new_array(System.Object, 0)
myfunc = meth.CreateDelegate(typeof(FUNCTYPE), array)
return myfunc
def __init__(self, cpu, cliloop):
self.setoptions()
self.cpu = cpu
self.name = cliloop.get_fresh_cli_name()
self.cliloop = cliloop
self.boxes = {} # box --> local var
self.branches = []
self.branchlabels = []
self.consts = {} # object --> index
self.meth_wrapper = self._get_meth_wrapper()
self.il = self.meth_wrapper.get_il_generator()
self.av_consts = MethodArgument(0,
System.Type.GetType("System.Object[]"))
t_InputArgs = dotnet.typeof(InputArgs)
self.av_inputargs = MethodArgument(1, t_InputArgs)
self.av_ovf_flag = BoxInt()
self.exc_value_field = t_InputArgs.GetField('exc_value')
if cpu.rtyper:
self.av_OverflowError = ConstObj(
ootype.cast_to_object(cpu.ll_ovf_exc))
self.av_ZeroDivisionError = ConstObj(
ootype.cast_to_object(cpu.ll_zero_exc))
else:
self.av_OverflowError = None
self.av_ZeroDivisionError = None
self.box2type = {}
def emit_op_subclassof(self, op):
clitype_utils = dotnet.typeof(Utils)
methinfo = clitype_utils.GetMethod('SubclassOf')
op.args[0].load(self)
op.args[1].load(self)
self.il.Emit(OpCodes.Call, methinfo)
self.store_result(op)
def load(self, meth):
holdertype = self.holder.GetType()
funcfield = holdertype.GetField('func')
Const.load(self, meth)
meth.il.Emit(OpCodes.Castclass, holdertype)
meth.il.Emit(OpCodes.Ldfld, funcfield)
meth.il.Emit(OpCodes.Castclass, dotnet.typeof(LoopDelegate))
def emit_op_guard_class(self, op):
assert len(op.args) == 2
il_label = self.newbranch(op)
self.push_arg(op, 0)
meth = dotnet.typeof(System.Object).GetMethod("GetType")
self.il.Emit(OpCodes.Callvirt, meth)
self.push_arg(op, 1)
self.il.Emit(OpCodes.Bne_Un, il_label)
def finish_code(self):
delegatetype = dotnet.typeof(LoopDelegate)
# initialize the array of genconsts
consts = dotnet.new_array(System.Object, len(self.consts))
for av_const, i in self.consts.iteritems():
consts[i] = av_const.get_cliobj()
# build the delegate
func = self.meth_wrapper.create_delegate(delegatetype, consts)
return dotnet.clidowncast(func, LoopDelegate)
def emit_return_failed_op(self, op, args):
# store the index of the failed op
index_op = self.get_index_for_failing_op(op)
self.av_inputargs.load(self)
self.il.Emit(OpCodes.Ldc_I4, index_op)
field = dotnet.typeof(InputArgs).GetField('failed_op')
self.il.Emit(OpCodes.Stfld, field)
self.emit_store_opargs(args)
self.il.Emit(OpCodes.Ret)
def emit_new_arrayofvoids(self, op):
clitype = dotnet.typeof(ListOfVoid)
ctor = clitype.GetConstructor(dotnet.new_array(System.Type, 0))
_ll_resize = clitype.GetMethod('_ll_resize')
self.il.Emit(OpCodes.Newobj, ctor)
self.il.Emit(OpCodes.Dup)
op.args[0].load(self)
self.il.Emit(OpCodes.Callvirt, _ll_resize)
self.store_result(op)
def get_inputarg_field(self, type):
t = dotnet.typeof(InputArgs)
if type == history.INT:
fieldname = 'ints'
elif type == history.FLOAT:
fieldname = 'floats'
elif type == history.REF:
fieldname = 'objs'
else:
assert False, 'Unknown type %s' % type
return t.GetField(fieldname)
def emit_ovf_op_and_guard(self, op, opguard, emit_op):
# emit the checked operation
lbl = self.il.BeginExceptionBlock()
emit_op(self, op)
self.il.Emit(OpCodes.Leave, lbl)
self.il.BeginCatchBlock(dotnet.typeof(System.OverflowException))
# emit the guard
assert len(opguard.args) == 0
il_label = self.newbranch(opguard)
self.il.Emit(OpCodes.Leave, il_label)
self.il.EndExceptionBlock()
def rewrap_args(space, w_args, startfrom):
args = space.unpackiterable(w_args)
paramlen = len(args)-startfrom
b_args = new_array(System.Object, paramlen)
b_paramtypes = new_array(System.Type, paramlen)
for i in range(startfrom, len(args)):
j = i-startfrom
b_obj = py2cli(space, args[i])
b_args[j] = b_obj
if b_obj is None:
b_paramtypes[j] = typeof(System.Object) # we really can't be more precise
else:
b_paramtypes[j] = b_obj.GetType() # XXX: potentially inefficient
return b_args, b_paramtypes
def rewrap_args(space, w_args, startfrom):
args = space.unpackiterable(w_args)
paramlen = len(args)-startfrom
b_args = new_array(System.Object, paramlen)
b_paramtypes = new_array(System.Type, paramlen)
for i in range(startfrom, len(args)):
j = i-startfrom
b_obj = py2cli(space, args[i])
b_args[j] = b_obj
if b_obj is None:
b_paramtypes[j] = typeof(System.Object) # we really can't be more precise
else:
b_paramtypes[j] = b_obj.GetType() # XXX: potentially inefficient
return b_args, b_paramtypes
def emit_ovf_op(self, op, emit_op):
next_op = self.oplist[self.i+1]
if next_op.opnum == rop.GUARD_NO_OVERFLOW:
self.i += 1
self.emit_ovf_op_and_guard(op, next_op, emit_op)
return
# clear the overflow flag
self.il.Emit(OpCodes.Ldc_I4_0)
self.av_ovf_flag.store(self)
lbl = self.il.BeginExceptionBlock()
emit_op(self, op)
self.il.Emit(OpCodes.Leave, lbl)
self.il.BeginCatchBlock(dotnet.typeof(System.OverflowException))
self.il.Emit(OpCodes.Ldc_I4_1)
self.av_ovf_flag.store(self)
self.il.EndExceptionBlock()
def emit_raising_op(self, op, emit_op, exctypes):
self.emit_clear_exception()
lbl = self.il.BeginExceptionBlock()
emit_op(self, op)
self.il.Emit(OpCodes.Leave, lbl)
for exctype in exctypes:
v = self.il.DeclareLocal(exctype)
self.il.BeginCatchBlock(exctype)
if exctype == dotnet.typeof(System.OverflowException) and self.av_OverflowError:
self.il.Emit(OpCodes.Ldc_I4_1)
self.av_ovf_flag.store(self)
else:
self.il.Emit(OpCodes.Stloc, v)
self.av_inputargs.load(self)
self.il.Emit(OpCodes.Ldloc, v)
self.il.Emit(OpCodes.Stfld, self.exc_value_field)
self.il.EndExceptionBlock()
def emit_op_jump(self, op):
target_token = op.descr
assert isinstance(target_token, LoopToken)
if target_token.cliloop is self.cliloop:
# jump to the beginning of the loop
i = 0
for i in range(len(op.args)):
op.args[i].load(self)
self.cliloop.inputargs[i].store(self)
self.il.Emit(OpCodes.Br, self.il_loop_start)
else:
# it's a real bridge
cliloop = target_token.cliloop
assert len(op.args) == len(cliloop.inputargs)
self.emit_debug('jumping to ' + cliloop.name)
self.emit_store_opargs(op.args)
cliloop.funcbox.load(self)
self.av_inputargs.load(self)
methinfo = dotnet.typeof(LoopDelegate).GetMethod('Invoke')
if self.tailcall:
self.il.Emit(OpCodes.Tailcall)
self.il.Emit(OpCodes.Callvirt, methinfo)
self.il.Emit(OpCodes.Ret)
def __init__(self, cpu, cliloop):
self.setoptions()
self.cpu = cpu
self.name = cliloop.get_fresh_cli_name()
self.cliloop = cliloop
self.boxes = {} # box --> local var
self.branches = []
self.branchlabels = []
self.consts = {} # object --> index
self.meth_wrapper = self._get_meth_wrapper()
self.il = self.meth_wrapper.get_il_generator()
self.av_consts = MethodArgument(0, System.Type.GetType("System.Object[]"))
t_InputArgs = dotnet.typeof(InputArgs)
self.av_inputargs = MethodArgument(1,t_InputArgs )
self.av_ovf_flag = BoxInt()
self.exc_value_field = t_InputArgs.GetField('exc_value')
if cpu.rtyper:
self.av_OverflowError = ConstObj(ootype.cast_to_object(cpu.ll_ovf_exc))
self.av_ZeroDivisionError = ConstObj(ootype.cast_to_object(cpu.ll_zero_exc))
else:
self.av_OverflowError = None
self.av_ZeroDivisionError = None
self.box2type = {}
def restype_bool(self): return typeof(System.Boolean) def restype_int(self): return typeof(System.Int32)
def restype_bool(self):
return typeof(System.Boolean)
def restype_uint(self):
return typeof(System.Int32)
def restype_float(self):
return typeof(System.Double)
def restype_unichar(self): return typeof(System.Char) def restype_longlong(self): return typeof(System.Int64)
def restype_float(self): return typeof(System.Double) def restype_char(self): return typeof(System.Char)
def emit_op_call(self, op):
emit_op = Method.emit_op_call_impl.im_func
exctypes = [dotnet.typeof(System.Exception)]
self.emit_raising_op(op, emit_op, exctypes)
def fn():
return typeof(DelegateType) is not None
def emit_op_runtimenew(self, op):
clitype_utils = dotnet.typeof(Utils)
methinfo = clitype_utils.GetMethod('RuntimeNew')
op.args[0].load(self)
self.il.Emit(OpCodes.Call, methinfo)
self.store_result(op)
def fn():
t = typeof(FUNCTYPE)
return t.get_Name()
def fn():
t = typeof(FUNCTYPE)
return t.get_Name()
def restype_int(self): return typeof(System.Int32) def restype_uint(self): return typeof(System.Int32)
def fn():
x = box(42)
return x.GetType() == typeof(System.Int32)
def restype_uint(self): return typeof(System.Int32) def restype_float(self): return typeof(System.Double)
def restype_longlong(self):
return typeof(System.Int64)
def restype_char(self): return typeof(System.Char) def restype_unichar(self): return typeof(System.Char)
def restype_unichar(self):
return typeof(System.Char)
def restype_longlong(self): return typeof(System.Int64) def fillops(ops, baseclass):
def _get_meth_wrapper(self):
restype = dotnet.class2type(cVoid)
args = self._get_args_array([dotnet.typeof(InputArgs)])
return get_method_wrapper(self.name, restype, args)