v0 = argv[0] v1 = argv[1] v2 = space.null else: assert len(argv) == 3 v0 = argv[0] v1 = argv[1] v2 = argv[2] assert isinstance(v0, Dict) try: return v0.data[v1] except KeyError as error: return v2 @Dict.method(u"pop", signature(Dict, Object)) def Dict_pop(self, key): try: return self.data.pop(key) except KeyError as error: raise space.unwind(space.LKeyError(self, key)) @Dict.builtin_method @signature(Dict) def keys(self): return KeyIterator(self.data.iterkeys()) @Dict.builtin_method @signature(Dict)
def _impl_(fn): self.multimethod(*spec)(signature(*spec)(fn)) return fn
self.uint8data[index.value] = rffi.r_uchar(value.value) return value def to_str(self): return rffi.charpsize2str(rffi.cast(rffi.CCHARP, self.uint8data), int(self.length)) def iter(self): return Uint8Iterator(self.uint8data, self.length) def subslice(self, length): return Uint8Slice(self.uint8data, length, self) @Uint8Data.method(u'memcpy', signature(Uint8Data, Uint8Data, numbers.Integer, optional=1)) def Uint8Data_memcpy(self, src, size): size = src.length if size is None else size.value if size > self.length or size > src.length: raise space.unwind(space.LError(u"memcpy range error")) rffi.c_memcpy(rffi.cast(rffi.VOIDP, self.uint8data), rffi.cast(rffi.VOIDP, src.uint8data), size) return space.null class Uint8Array(Uint8Data): _immutable_fields_ = ['uint8data', 'length'] __slots__ = ['uint8data', 'length'] def repr(self): # Add hexadecimal formatting later.. return u"<uint8array>"
self.number = number def repr(self): return float_to_string(self.number) def hash(self): return compute_hash(self.number) def eq(self, other): if isinstance(other, Float): return self.number == other.number return False # There is potentially a lot more to consider on generic case of # stringifying floats, but we get ahead with this for a while. @Float.method(u"to_string", signature(Float)) def Float_to_string(self): return space.String(float_to_string(self.number)) def float_to_string(x, code='g', precision=DTSF_STR_PRECISION): if isfinite(x): s = formatd(x, code, precision, DTSF_ADD_DOT_0) elif isinf(x): if x > 0.0: s = "inf" else: s = "-inf" else: # isnan(x): s = "nan" return s.decode('utf-8')
def repr(self): cellnames = u"" for cellname in self.map.attribute_indexes: if len(cellnames) > 0: cellnames += u", " cellnames += cellname return u"<object %s>" % cellnames # Exnihilo doesn't exist for the user. He only sees an object. Exnihilo.interface = Object.interface @Object.instantiator2(signature(Object, optional=1)) def instantiate(obj): res = Exnihilo() if obj is not None: obj = space.cast(obj, space.Dict, u"object instantiation") for key, value in obj.data.items(): key = space.cast(key, space.String, u"setattr") res.setattr(key.string, value) return res # Attribute optimization for exnihilo objects. class Map(object): def __init__(self): self.attribute_indexes = {} self.other_maps = {}
return String(u"".join(result)) index = space.cast(index, Integer, u"index not an integer") if not 0 <= index.value < len(self.string): raise space.unwind(space.LKeyError(self, index)) return String(self.string[index.value]) def contains(self, item): if isinstance(item, String): return item.string in self.string return False def iter(self): return StringIterator(iter(self.string)) String.interface.name = u"str" @String.instantiator2(signature(Object)) def String_init_is_cast(obj): return space.cast(obj, String, u"str()") @String.method(u"count", signature(String, String)) def String_count(self, ch): if len(ch.string) != 1: raise space.unwind(space.LError(u"str.count expected char")) count = 0 x = ch.string[0] for ch in self.string: if ch == x: count += 1 return Integer(count) @String.method(u"join", signature(String, Object))
if not 0 <= index.value < len(self.contents): raise space.unwind(space.LKeyError(self, index)) self.contents[index.value] = value return value def iter(self): return ListIterator(iter(self.contents)) def repr(self): out = [] for item in self.contents: out.append(item.repr()) return u'[' + u', '.join(out) + u']' @List.method(u"append", signature(List, Object)) def List_append(self, other): self.contents.append(other) return null @List.method(u"extend", signature(List, Object)) def List_extend(self, iterable): it = iterable.iter() try: while True: self.contents.append(it.callattr(u"next", [])) except StopIteration as stop: return space.null return space.null
pass # TODO: pass only LAttributeError class DocRef(Object): def __init__(self, doc, name, parent): self.doc = doc self.name = name self.parent = parent def getattr(self, name): if name == u"link": return self.doc if name == u"name": return self.name if name == u"parent": return self.parent return Object.getattr(self, name) def listattr(self): listing = Object.listattr(self) listing.append(space.String(u"link")) listing.append(space.String(u"name")) listing.append(space.String(u"parent")) return listing @DocRef.instantiator2(signature(Object, Object, Object, optional=1)) def DocRef_init(doc, name, parent): parent = null if parent is None else parent return DocRef(doc, name, parent)
if name == u"get": return self.getter if name == u"set": return self.setter return Object.getattr(self, name) def setattr(self, name, value): if name == u"get": self.getter = value return value if name == u"set": self.setter = value return value return Object.setattr(self, name, value) @Property.instantiator2(signature()) def Property_instantiate(): return Property() # Id is for situations when you'd want to compare or # hash things by identity. Or when you want to access # a custom object directly. class Id(Object): def __init__(self, ref): self.ref = ref def getattr(self, name): if name == u"ref": return self.ref return Object.getattr(self, name)
pass else: method.call([obj] + argv) return obj CustomObject.interface.instantiate = instantiate class Property(Object): def __init__(self): self.getter = null self.setter = null def getattr(self, name): if name == u"get": return self.getter if name == u"set": return self.setter return Object.getattr(self, name) def setattr(self, name, value): if name == u"get": self.getter = value return value if name == u"set": self.setter = value return value return Object.setattr(self, name, value) @Property.instantiator2(signature()) def Property_instantiate(): return Property()
def hate_them(argv): raise space.unwind(space.LError(u"no")) #expose_internal_methods(Interface) #expose_internal_methods(Object) # if I do this, # every method will have internal_methods # Besides, Object methods are placeholders. # I doubt we miss these. #expose_internal_methods(BoundMethod) #expose_internal_methods(builtin.Builtin) # When your good names are your best. @Interface.instantiator2(builtin.signature(Object)) def Interface_init_is_cast(obj): return space.get_interface(obj) # Id is for situations when you'd want to compare or # hash things by identity. class Id(Object): def __init__(self, ref): self.ref = ref def getattr(self, name): if name == u"ref": return self.ref
else: a = start else: a = space.to_int(self.start) a = max(start, min(stop-1, a)) if self.stop is null: if step < 0: b = start - 1 else: b = stop else: b = space.to_int(self.stop) b = max(start-1, min(stop, b)) return (a, b, step) @Slice.instantiator2(signature(Object, Object, Object, optional=1)) def Slice_inst(start, stop, step): if step is None: step = space.Integer(1) return Slice(start, stop, step) class SliceRange(Object): def __init__(self, start, stop, step): self.current = start self.stop = stop self.step = step self.sign = +1 if step >= 0 else -1 def iter(self): return self
def hash(self): multi = r_uint(1822399083) + r_uint(1822399083) + 1 hash = r_uint(1927868237) hash *= r_uint(len(self._set) + 1) for w_item in self._set.iterkeys(): h = w_item.hash() value = (r_uint(h ^ (h << 16) ^ 89869747) * multi) hash = hash ^ value hash = hash * 69069 + 907133923 if hash == 0: hash = 590923713 return intmask(hash) @Set.method(u"copy", signature(Set)) def Set_copy(self): copy = Set() copy._set.update(self._set) return copy @Set.method(u"clear", signature(Set)) def Set_clear(self): self._set = r_dict(eq_fn, hash_fn, force_non_null=True) return null @Set.method(u"add", signature(Set, Object)) def Set_add(self, obj): self._set[obj] = None
CustomObject.interface.instantiate = instantiate class Property(Object): def __init__(self): self.getter = null self.setter = null def getattr(self, name): if name == u"get": return self.getter if name == u"set": return self.setter return Object.getattr(self, name) def setattr(self, name, value): if name == u"get": self.getter = value return value if name == u"set": self.setter = value return value return Object.setattr(self, name, value) @Property.instantiator2(signature()) def Property_instantiate(): return Property()
return _impl_ def setitem(self, index, value): vec = [] assert isinstance(index, space.List) for item in index.contents: assert isinstance(item, space.Interface) vec.append(item) self.methods[vec] = value return value def getattr(self, index): if index == u"default": return self.default return Object.getattr(self, index) def setattr(self, index, value): if index == u"default": self.default = value return value return Object.setattr(self, index, value) @Multimethod.instantiator @signature(Integer) def _(arity): return Multimethod(arity.value) @Multimethod.method(u"call_suppressed", signature(Multimethod, variadic=True)) def Multimethod_call_suppressed(mm, args): return mm.call_suppressed(args)
self._set = r_dict(eq_fn, hash_fn, force_non_null=True) def contains(self, index): if index in self._set: return True return False def getattr(self, name): if name == u'length': return Integer(len(self._set)) return Object.getattr(self, name) def iter(self): return SetIterator(self._set.iterkeys()) @Set.method(u"copy", signature(Set)) def Set_copy(self): copy = Set() copy._set.update(self._set) return copy @Set.method(u"clear", signature(Set)) def Set_clear(self): self._set = r_dict(eq_fn, hash_fn, force_non_null=True) return null @Set.method(u"add", signature(Set, Object)) def Set_add(self, obj): self._set[obj] = None return null
if len(argv) == 2: v0 = argv[0] v1 = argv[1] v2 = space.null else: assert len(argv) == 3 v0 = argv[0] v1 = argv[1] v2 = argv[2] assert isinstance(v0, Dict) try: return v0.data[v1] except KeyError as error: return v2 @Dict.method(u"pop", signature(Dict, Object)) def Dict_pop(self, key): try: return self.data.pop(key) except KeyError as error: raise space.unwind(space.LKeyError(self, key)) @Dict.builtin_method @signature(Dict) def keys(self): return KeyIterator(self.data.iterkeys()) @Dict.builtin_method @signature(Dict) def items(self): return ItemIterator(self.data.iteritems())
a = low else: a = space.to_int(self.start) a = max(low, min(high, a)) if self.stop is null: if step < 0: b = low - 1 else: b = high + 1 else: b = space.to_int(self.stop) b = max(low - 1, min(high + 1, b)) return (a, b, step) @Slice.instantiator2(signature(Object, Object, Object, optional=1)) def Slice_inst(start, stop, step): if step is None: step = space.Integer(1) return Slice(start, stop, step) class SliceRange(Object): def __init__(self, start, stop, step): self.current = start self.stop = stop self.step = step self.sign = +1 if step >= 0 else -1 def iter(self): return self
source_location=builtin.get_source_location(fn)) # Internal methods help at documenting the system. # TODO: rethink about lifting this eventually? def hate_them(argv): raise space.unwind(space.LError(u"hate them")) #expose_internal_methods(Interface) #expose_internal_methods(Object) # if I do this, # every method will have internal_methods # Besides, Object methods are placeholders. # I doubt we miss these. #expose_internal_methods(BoundMethod) #expose_internal_methods(builtin.Builtin) # When your good names are your best. @Interface.instantiator2(builtin.signature(Object)) def Interface_init_is_cast(obj): return space.get_interface(obj) # Only active with the user-defined interfaces that may be 'lost'. @Interface.method(u"+finalize", builtin.signature(Interface)) def Interface_finalize(self): for record in self.multimethods: record.multimethod.unregister_record(record)
for item in index.contents] self.multimethod_table[vec] = value return value def getattr(self, index): if index == u"default": return self.default return Object.getattr(self, index) def setattr(self, index, value): if index == u"default": self.default = value return value return Object.setattr(self, index, value) @Multimethod.instantiator @signature(Integer) def _(arity): return Multimethod(arity.value) @Multimethod.method(u"call_suppressed", signature(Multimethod, variadic=True)) def Multimethod_call_suppressed(mm, args): return mm.call_suppressed(args) @Multimethod.method(u"keys", signature(Multimethod)) def Multimethod_keys(self): return space.List([ space.List(list(vec)) for vec in self.multimethod_table ])
return index - ord('0') if ord('A') <= index <= ord('Z'): return index - ord('A') + 10 if ord('a') <= index <= ord('z'): return index - ord('a') + 10 return -1 @String.builtin_method @signature(String) def is_space(string): for ch in string.string: if not unicodedb.isspace(ord(ch)): return space.false return space.true @String.method(u"startswith", signature(String, String)) def String_startswith(self, prefix): return space.boolean( self.string.startswith(prefix.string)) @String.method(u"endswith", signature(String, String)) def String_endswith(self, postfix): return space.boolean( self.string.endswith(postfix.string)) class StringIterator(Object): _immutable_fields_ = ['iterator'] def __init__(self, iterator): self.iterator = iterator def iter(self):
index = space.cast(index, Integer, u"index not an integer") if not 0 <= index.value < len(self.contents): raise space.unwind(space.LKeyError(self, index)) self.contents[index.value] = value return value def iter(self): return ListIterator(iter(self.contents)) def repr(self): out = [] for item in self.contents: out.append(item.repr()) return u'[' + u', '.join(out) + u']' @List.method(u"append", signature(List, Object)) def List_append(self, other): self.contents.append(other) return null @List.method(u"extend", signature(List, Object)) def List_extend(self, iterable): it = iterable.iter() try: while True: self.contents.append(it.callattr(u"next", [])) except StopIteration as stop: return space.null return space.null @List.method(u"insert", signature(List, Integer, Object))
def repr(self): return float_to_string(self.number) def hash(self): return compute_hash(self.number) def eq(self, other): if isinstance(other, Float): return self.number == other.number return False # There is potentially a lot more to consider on generic case of # stringifying floats, but we get ahead with this for a while. @Float.method(u"to_string", signature(Float)) def Float_to_string(self): return space.String(float_to_string(self.number)) def float_to_string(x, code='g', precision=DTSF_STR_PRECISION): if isfinite(x): s = formatd(x, code, precision, DTSF_ADD_DOT_0) elif isinf(x): if x > 0.0: s = "inf" else: s = "-inf" else: # isnan(x): s = "nan" return s.decode('utf-8')
return space.true def as_alphadigit_i(index): if ord('0') <= index <= ord('9'): return index - ord('0') if ord('A') <= index <= ord('Z'): return index - ord('A') + 10 if ord('a') <= index <= ord('z'): return index - ord('a') + 10 return -1 @String.builtin_method @signature(String) def is_space(string): for ch in string.string: if not unicodedb.isspace(ord(ch)): return space.false return space.true class StringIterator(Object): _immutable_fields_ = ['iterator'] def __init__(self, iterator): self.iterator = iterator def iter(self): return self @StringIterator.method(u"next", signature(StringIterator)) def StringIterator_next(self): return String(self.iterator.next())