def check_hashfn(annotator, graph):
s = annotator.binding(graph.getreturnvar())
assert SomeInteger().contains(s), (
"the custom hash function of an r_dict must return an integer"
" (got %r)" % (s, ))
def and_((int1, int2)):
knowntype = rarithmetic.compute_restype(int1.knowntype, int2.knowntype)
return SomeInteger(nonneg=int1.nonneg or int2.nonneg,
knowntype=knowntype)
def rshift((int1, int2)):
if isinstance(int1, SomeBool):
return SomeInteger(nonneg=True)
else:
return SomeInteger(nonneg=int1.nonneg, knowntype=int1.knowntype)
def len(self):
return SomeInteger(nonneg=True)
def cmp((obj1, obj2)):
if obj1.is_immutable_constant() and obj2.is_immutable_constant():
return immutablevalue(cmp(obj1.const, obj2.const))
else:
return SomeInteger()
def method_index(self, s_value):
self.listdef.generalize(s_value)
return SomeInteger(nonneg=True)
def method_count(self, frag, start=None, end=None):
check_negative_slice(start, end, "count")
return SomeInteger(nonneg=True)
def immutablevalue(self, x):
"""The most precise SomeValue instance that contains the
immutable value x."""
# convert unbound methods to the underlying function
if hasattr(x, 'im_self') and x.im_self is None:
x = x.im_func
assert not hasattr(x, 'im_self')
tp = type(x)
if issubclass(tp, Symbolic): # symbolic constants support
result = x.annotation()
result.const_box = Constant(x)
return result
if tp is bool:
result = SomeBool()
elif tp is int:
result = SomeInteger(nonneg=x >= 0)
elif tp is long:
if -sys.maxint - 1 <= x <= sys.maxint:
x = int(x)
result = SomeInteger(nonneg=x >= 0)
else:
# XXX: better error reporting?
raise ValueError("seeing a prebuilt long (value %s)" % hex(x))
elif issubclass(tp, str): # py.lib uses annotated str subclasses
no_nul = not '\x00' in x
if len(x) == 1:
result = SomeChar(no_nul=no_nul)
else:
result = SomeString(no_nul=no_nul)
elif tp is unicode:
no_nul = not u'\x00' in x
if len(x) == 1:
result = SomeUnicodeCodePoint(no_nul=no_nul)
else:
result = SomeUnicodeString(no_nul=no_nul)
elif tp is bytearray:
result = SomeByteArray()
elif tp is tuple:
result = SomeTuple(items=[self.immutablevalue(e) for e in x])
elif tp is float:
result = SomeFloat()
elif tp is list:
key = Constant(x)
try:
return self.immutable_cache[key]
except KeyError:
result = SomeList(ListDef(self, s_ImpossibleValue))
self.immutable_cache[key] = result
for e in x:
result.listdef.generalize(self.immutablevalue(e))
result.const_box = key
return result
elif (tp is dict or tp is r_dict or tp is OrderedDict
or tp is r_ordereddict):
key = Constant(x)
try:
return self.immutable_cache[key]
except KeyError:
if tp is OrderedDict or tp is r_ordereddict:
cls = SomeOrderedDict
else:
cls = SomeDict
is_r_dict = issubclass(tp, r_dict)
result = cls(
DictDef(self,
s_ImpossibleValue,
s_ImpossibleValue,
is_r_dict=is_r_dict))
self.immutable_cache[key] = result
if is_r_dict:
s_eqfn = self.immutablevalue(x.key_eq)
s_hashfn = self.immutablevalue(x.key_hash)
result.dictdef.dictkey.update_rdict_annotations(
s_eqfn, s_hashfn)
seen_elements = 0
while seen_elements != len(x):
items = x.items()
for ek, ev in items:
result.dictdef.generalize_key(self.immutablevalue(ek))
result.dictdef.generalize_value(
self.immutablevalue(ev))
#dictdef.seen_prebuilt_key(ek)---not needed any more
seen_elements = len(items)
# if the dictionary grew during the iteration,
# start over again
result.const_box = key
return result
elif tp is weakref.ReferenceType:
x1 = x()
if x1 is None:
result = SomeWeakRef(None) # dead weakref
else:
s1 = self.immutablevalue(x1)
assert isinstance(s1, SomeInstance)
result = SomeWeakRef(s1.classdef)
elif tp is property:
return SomeProperty(x)
elif ishashable(x) and x in BUILTIN_ANALYZERS:
_module = getattr(x, "__module__", "unknown")
result = SomeBuiltin(BUILTIN_ANALYZERS[x],
methodname="%s.%s" % (_module, x.__name__))
elif extregistry.is_registered(x):
entry = extregistry.lookup(x)
result = entry.compute_annotation_bk(self)
elif tp is type:
result = SomeConstantType(x, self)
elif callable(x):
if hasattr(x, 'im_self') and hasattr(x, 'im_func'):
# on top of PyPy, for cases like 'l.append' where 'l' is a
# global constant list, the find_method() returns non-None
s_self = self.immutablevalue(x.im_self)
result = s_self.find_method(x.im_func.__name__)
elif hasattr(x, '__self__') and x.__self__ is not None:
# for cases like 'l.append' where 'l' is a global constant list
s_self = self.immutablevalue(x.__self__)
result = s_self.find_method(x.__name__)
assert result is not None
else:
result = None
if result is None:
result = SomePBC([self.getdesc(x)])
elif hasattr(x, '_freeze_'):
assert x._freeze_() is True
# user-defined classes can define a method _freeze_(), which
# is called when a prebuilt instance is found. If the method
# returns True, the instance is considered immutable and becomes
# a SomePBC(). Otherwise it's just SomeInstance().
result = SomePBC([self.getdesc(x)])
elif hasattr(x, '__class__') \
and x.__class__.__module__ != '__builtin__':
if hasattr(x, '_cleanup_'):
x._cleanup_()
classdef = self.getuniqueclassdef(x.__class__)
classdef.see_instance(x)
result = SomeInstance(classdef)
elif x is None:
return s_None
else:
raise Exception("Don't know how to represent %r" % (x, ))
result.const = x
return result
# ____________________________________________________________
class Sample(object):
__slots__ = 'x'
MemberDescriptorTypes = [type(Sample.x)]
del Sample
try:
MemberDescriptorTypes.append(type(OSError.errno))
except AttributeError: # on CPython <= 2.4
pass
# ____________________________________________________________
FORCE_ATTRIBUTES_INTO_CLASSES = {
EnvironmentError: {
'errno': SomeInteger(),
'strerror': SomeString(can_be_None=True),
'filename': SomeString(can_be_None=True)
},
}
try:
WindowsError
except NameError:
pass
else:
FORCE_ATTRIBUTES_INTO_CLASSES[WindowsError] = {'winerror': SomeInteger()}
def ann_offsetof(TYPE, fldname):
return SomeInteger()
def ann_cast_adr_to_int(s, s_mode=None):
return SomeInteger() # xxx
def ann_raw_malloc_usage(s_size):
assert isinstance(s_size, SomeInteger) # XXX add noneg...?
return SomeInteger(nonneg=True)
def compute_result_annotation(self):
from rpython.annotator.model import SomeInteger
return SomeInteger(nonneg=True)
import time
from rpython.rlib.rarithmetic import r_longlong, r_uint
from rpython.rlib.rarithmetic import intmask, longlongmask
from rpython.rtyper.extregistry import ExtRegistryEntry
from rpython.rtyper.lltypesystem import lltype, rffi
_is_64_bit = r_uint.BITS > 32
from rpython.annotator.model import SomeInteger
if _is_64_bit:
s_TIMESTAMP = SomeInteger()
TIMESTAMP_type = lltype.Signed
else:
s_TIMESTAMP = SomeInteger(knowntype=r_longlong)
TIMESTAMP_type = rffi.LONGLONG
# unit of values returned by read_timestamp. Should be in sync with the ones
# defined in translator/c/debug_print.h
UNIT_TSC = 0
UNIT_NS = 1 # nanoseconds
UNIT_QUERY_PERFORMANCE_COUNTER = 2
def read_timestamp():
# Returns a longlong on 32-bit, and a regular int on 64-bit.
# When running on top of python, build the result a bit arbitrarily.
x = long(time.time() * 500000000)
if _is_64_bit:
return intmask(x)
else:
def neg(self):
return SomeInteger()
def sub((s_addr1, s_addr2)):
from rpython.annotator.bookkeeper import getbookkeeper
if s_addr1.is_null_address() and s_addr2.is_null_address():
return getbookkeeper().immutablevalue(0)
return SomeInteger()
def pos(self):
return SomeInteger(nonneg=True)
def compute_result_annotation(self, s_arg):
from rpython.annotator.model import SomeInteger
if not SomeInteger().contains(s_arg):
raise ExpectedRegularInt(s_arg)
return s_arg
def method_rfind(self, frag, start=None, end=None):
check_negative_slice(start, end, "rfind")
return SomeInteger()
def compute_result_annotation(self, s_model): # pragma: no cover
from rpython.annotator.model import SomeInteger
return SomeInteger(nonneg=True, knowntype=int)
def ord(self):
return SomeInteger(nonneg=True)
def execute(self, space):
getattr(space, self.method)(*self.args)
def __repr__(self):
return "space.%s(%s)" % (self.method, ', '.join(map(repr, self.args)))
class PseudoRTyper:
cache_dummy_values = {}
# XXX: None keys crash the test, but translation sort-of allows it
keytypes_s = [
SomeString(),
SomeInteger(),
SomeChar(),
SomeUnicodeString(),
SomeUnicodeCodePoint()
]
st_keys = sampled_from(keytypes_s)
st_values = sampled_from(keytypes_s + [SomeString(can_be_None=True)])
class MappingSpace(object):
def __init__(self, s_key, s_value):
from rpython.rtyper.rtuple import TupleRepr
self.s_key = s_key
self.s_value = s_value
rtyper = PseudoRTyper()
def int(self):
return SomeInteger()
def invert(self):
return SomeInteger(knowntype=self.knowntype)
def sub((int1, int2)):
knowntype = rarithmetic.compute_restype(int1.knowntype, int2.knowntype)
return SomeInteger(knowntype=knowntype)
def neg(self):
return SomeInteger(knowntype=self.knowntype)
def lshift((int1, int2)):
if isinstance(int1, SomeBool):
return SomeInteger()
else:
return SomeInteger(knowntype=int1.knowntype)
def abs(self):
return SomeInteger(nonneg=True, knowntype=self.knowntype)
def getitem((s_b, s_i)):
return SomeInteger()
def method_getlength(self):
return SomeInteger(nonneg=True)
