def convert_to_func_wrapper(pyf):
import inspect
if obj.compare_type(pyf, PY_FUNCTION_TYPE) or \
obj.compare_type(pyf, FUNCTION_TYPE):
return pyf
if inspect.isfunction(pyf) or inspect.isbuiltin(pyf):
return obj.ObjectCreater.new_object(PY_FUNCTION_TYPE, pyf)
return obj.convert_to_ail_object(pyf)
def func_show_struct(sobj):
if not (objs.compare_type(sobj, struct.STRUCT_OBJ_TYPE) or
objs.compare_type(sobj, struct.STRUCT_TYPE)):
return AILRuntimeError('show_struct needs a struct type or object', 'TypeError')
ln1 = str(sobj) + '\n'
memb = sobj.members.items()
meml = '\n'.join(['\t%s : %s' % (k, v) for k, v in memb
if k[:2] != '__'])
block = '{\n%s\n}' % meml
return ln1 + block
def func_range(a, b, step=1):
if not (compare_type(a, INTEGER_TYPE) and compare_type(b, INTEGER_TYPE)) \
and compare_type(step, INTEGER_TYPE):
return AILRuntimeError('a and b must be an integer!')
va = unpack_ailobj(a)
vb = unpack_ailobj(b)
vs = unpack_ailobj(step)
if va > vb:
return convert_to_array([])
return convert_to_array(list(range(va, vb, vs)))
def float_init(self :obj.AILObject, value :obj.AILObject):
if type(value) in (float, int):
self['__value__'] = value
elif obj.compare_type(value, FLOAT_TYPE):
self['__value__'] = value['__value__']
else:
return AILRuntimeError('invalid number type \'%s\'' % type(value), 'TypeError')
def _sys_exit(_, code):
if not compare_type(code, INTEGER_TYPE):
return AILRuntimeError('exit() needs an integer.')
c = unpack_ailobj(code)
import sys
try:
sys.exit(c)
except Exception as e:
return AILRuntimeError(str(e), 'PythonError')
def int_init(self: obj.AILObject, value: obj.AILObject):
if isinstance(value, int):
self['__value__'] = value
elif isinstance(value, float):
o = obj.ObjectCreater.new_object(afloat.FLOAT_TYPE, value)
self.reference = o.reference
self.properties = o.properties
elif obj.compare_type(value, INTEGER_TYPE):
self['__value__'] = value['__value__']
else:
return AILRuntimeError('invalid number type \'%s\'' % type(value),
'TypeError')
def obj_setattr(aobj, name, value):
from objects import string
if obj.compare_type(name, string.STRING_TYPE):
name = string.convert_to_string(name)
if not _is_reserved_attr_name(name):
return AILRuntimeError(
'\'%s\' object has no attribute \'%s\'' %
(aobj['__class__'].name, name), 'AttributeError')
aobj.properties[name] = value
def new_struct(struct_type, default_list=None):
# return a struct object
if default_list is not None and \
not objs.compare_type(default_list, array.ARRAY_TYPE):
return AILRuntimeError('member initialize need an array')
elif default_list is not None:
default_list = default_list['__value__']
if objs.compare_type(struct_type, struct.STRUCT_OBJ_TYPE):
return AILRuntimeError('new() needs a struct type, not a struct object',
'TypeError')
if not objs.compare_type(struct_type, struct.STRUCT_TYPE):
return AILRuntimeError('new() need a struct type')
m = struct_type.members.keys()
if default_list is not None:
if len(default_list) < len(m):
return AILRuntimeError(
'struct \'%s\' initialize missing %d required argument(s) : %s' %
(struct_type['__name__'], len(m), '(%s)' % (', '.join(m))),
'TypeError')
elif len(default_list) > len(m):
return AILRuntimeError(
'struct \'%s\' initialize takes %d argument(s) but %d were given' %
(struct_type['__name__'], len(m), len(default_list)),
'TypeError')
if default_list is not None:
md = {k:v for k, v in zip(m, default_list)}
else:
md = {k:null.null for k in m}
n = struct_type['__name__']
pl = struct_type.protected
return objs.ObjectCreater.new_object(
struct.STRUCT_OBJ_TYPE, n, md, struct_type, pl)
def func_make_type(name, default_attrs :objs.AILObject=None):
if default_attrs is not None and \
not objs.compare_type(default_attrs, array.ARRAY_TYPE):
return AILRuntimeError('type() needs an array to set default attribute.')
return objs.ObjectCreater.new_object(atype.TYPE_TYPE, name, default_attrs)
def func_isinstance(o, stype):
if objs.compare_type(o, struct.STRUCT_OBJ_TYPE) and \
objs.compare_type(stype, struct.STRUCT_TYPE):
return o['__type__'] == stype
return False
def func_array(size):
if objs.compare_type(size, aint.INTEGER_TYPE):
l = [null.null for _ in range(size['__value__'])]
o = objs.ObjectCreater.new_object(array.ARRAY_TYPE, l)
return o
return AILRuntimeError('array() needs an integer.', 'TypeError')
def convert_to_pyobj(struct_obj) -> _StructObjectWrapper:
if not obj.compare_type(struct_obj, STRUCT_OBJ_TYPE):
return None
st = _StructObjectWrapper(struct_obj)
return st
