Author: Anton Gulenko <[email protected]>
Branch: storage
Changeset: r694:20c045fd46e5
Date: 2014-03-24 18:31 +0100
http://bitbucket.org/pypy/lang-smalltalk/changeset/20c045fd46e5/
Log: Working on refactoring.
diff --git a/spyvm/model.py b/spyvm/model.py
--- a/spyvm/model.py
+++ b/spyvm/model.py
@@ -497,14 +497,23 @@
if not self.shadow:
self.store_shadow(self.default_storage(space, size))
else:
+ from spyvm.shadow import ClassShadow
+ if isinstance(self.shadow, ClassShadow) and self.shadow.name ==
"BlockClosure":
+ import pdb; pdb.set_trace()
+
self.shadow.initialize_storage(space, size)
def fillin(self, space, g_self):
+ g_self.g_class.fillin(space)
self.s_class = g_self.get_class().as_class_get_penumbra(space)
+
+ if self.s_class.name == "BlockClosure":
+ import pdb; pdb.set_trace()
+
self.hash = g_self.get_hash()
self.space = space
for g_obj in g_self.get_g_pointers():
- g_obj.fillin(space)
+ g_obj.fillin_nonpointers(space)
pointers = g_self.get_pointers()
self.initialize_storage(space, len(pointers))
self.store_all(space, pointers)
@@ -550,6 +559,8 @@
return self.varsize(space)
def size(self):
+ if not self.shadow:
+ return 0
return self._get_shadow().size()
def store_shadow(self, shadow):
diff --git a/spyvm/objspace.py b/spyvm/objspace.py
--- a/spyvm/objspace.py
+++ b/spyvm/objspace.py
@@ -36,6 +36,58 @@
return self._executable_path[0]
def make_bootstrap_classes(self):
+ def define_cls(cls_nm, supercls_nm, instvarsize=0,
format=shadow.POINTERS,
+ varsized=False):
+ assert cls_nm.startswith("w_")
+ self.classtable[cls_nm] = bootstrap_class(self, instvarsize, \
+ None,
+ None,
+ format=format,
+ varsized=varsized,
+ name=cls_nm[2:])
+
+#define_cls("w_Magnitude", "w_Object")
+ define_cls("w_Character", "w_Magnitude", instvarsize=1)
+#define_cls("w_Number", "w_Magnitude")
+#define_cls("w_Integer", "w_Number")
+ define_cls("w_SmallInteger", "w_Integer")
+ define_cls("w_LargePositiveInteger", "w_Integer", format=shadow.BYTES)
+ define_cls("w_Float", "w_Number", format=shadow.BYTES)
+ define_cls("w_Message", "w_Object")
+#define_cls("w_Collection", "w_Object")
+#define_cls("w_SequenceableCollection", "w_Collection")
+#define_cls("w_ArrayedCollection", "w_SequenceableCollection")
+ define_cls("w_Array", "w_ArrayedCollection", varsized=True)
+ define_cls("w_String", "w_ArrayedCollection", format=shadow.BYTES)
+ define_cls("w_Bitmap", "w_ArrayedCollection", varsized=True,
format=shadow.WORDS)
+#define_cls("w_UndefinedObject", "w_Object")
+#define_cls("w_Boolean", "w_Object")
+#define_cls("w_True", "w_Boolean")
+#define_cls("w_False", "w_Boolean")
+ define_cls("w_ByteArray", "w_ArrayedCollection", format=shadow.BYTES)
+ define_cls("w_CompiledMethod", "w_ByteArray",
format=shadow.COMPILED_METHOD)
+#define_cls("w_ContextPart", "w_Object")
+ define_cls("w_MethodContext", "w_ContextPart")
+#define_cls("w_Link", "w_Object")
+ #define_cls("w_Process", "w_Link")
+ #define_cls("w_Point", "w_Object")
+#define_cls("w_LinkedList", "w_SequenceableCollection")
+ define_cls("w_Semaphore", "w_LinkedList")
+ #define_cls("w_BlockContext", "w_ContextPart",
instvarsize=constants.BLKCTX_STACK_START)
+ define_cls("w_BlockClosure", "w_Object",
instvarsize=constants.BLKCLSR_SIZE, varsized=True)
+
+ # make better accessors for classes that can be found in special object
+ # table
+ for name in constants.classes_in_special_object_table.keys():
+ name = 'w_' + name
+ if name in self.classtable:
+ cls = self.classtable.get(name)
+ setattr(self, name, self.classtable.get(name))
+ else:
+ # assert False, "Missing bootstrapped class from special
objects array: %s" % (name,)
+ pass
+
+ def _make_bootstrap_classes(self):
def define_core_cls(name, w_superclass, w_metaclass):
assert name.startswith('w_')
w_class = bootstrap_class(self, instsize=0, # XXX
@@ -106,42 +158,45 @@
varsized=varsized,
name=cls_nm[2:])
- define_cls("w_Magnitude", "w_Object")
+ #define_cls("w_Magnitude", "w_Object")
define_cls("w_Character", "w_Magnitude", instvarsize=1)
- define_cls("w_Number", "w_Magnitude")
- define_cls("w_Integer", "w_Number")
+ #define_cls("w_Number", "w_Magnitude")
+ #define_cls("w_Integer", "w_Number")
define_cls("w_SmallInteger", "w_Integer")
define_cls("w_LargePositiveInteger", "w_Integer",
format=shadow.BYTES)
define_cls("w_Float", "w_Number", format=shadow.BYTES)
define_cls("w_Message", "w_Object")
- define_cls("w_Collection", "w_Object")
- define_cls("w_SequenceableCollection", "w_Collection")
- define_cls("w_ArrayedCollection", "w_SequenceableCollection")
+ #define_cls("w_Collection", "w_Object")
+ #define_cls("w_SequenceableCollection", "w_Collection")
+ #define_cls("w_ArrayedCollection", "w_SequenceableCollection")
define_cls("w_Array", "w_ArrayedCollection", varsized=True)
define_cls("w_String", "w_ArrayedCollection", format=shadow.BYTES)
define_cls("w_Bitmap", "w_ArrayedCollection", varsized=True,
format=shadow.WORDS)
- define_cls("w_UndefinedObject", "w_Object")
- define_cls("w_Boolean", "w_Object")
- define_cls("w_True", "w_Boolean")
- define_cls("w_False", "w_Boolean")
+ #define_cls("w_UndefinedObject", "w_Object")
+ #define_cls("w_Boolean", "w_Object")
+ #define_cls("w_True", "w_Boolean")
+ #define_cls("w_False", "w_Boolean")
define_cls("w_ByteArray", "w_ArrayedCollection",
format=shadow.BYTES)
- define_cls("w_MethodDict", "w_Object", instvarsize=2, varsized=True)
define_cls("w_CompiledMethod", "w_ByteArray",
format=shadow.COMPILED_METHOD)
- define_cls("w_ContextPart", "w_Object")
+ #define_cls("w_ContextPart", "w_Object")
define_cls("w_MethodContext", "w_ContextPart")
- define_cls("w_Link", "w_Object")
+ #define_cls("w_Link", "w_Object")
define_cls("w_Process", "w_Link")
define_cls("w_Point", "w_Object")
- define_cls("w_LinkedList", "w_SequenceableCollection")
+ #define_cls("w_LinkedList", "w_SequenceableCollection")
define_cls("w_Semaphore", "w_LinkedList")
define_cls("w_BlockContext", "w_ContextPart",
instvarsize=constants.BLKCTX_STACK_START)
define_cls("w_BlockClosure", "w_Object",
instvarsize=constants.BLKCLSR_SIZE, varsized=True)
+
+ # TODO - this class is not needed for the special objects array, so
maybe not create it synthetically.
+ #define_cls("w_MethodDict", "w_Object", instvarsize=2, varsized=True)
+
# make better accessors for classes that can be found in special object
# table
for name in constants.classes_in_special_object_table.keys():
name = 'w_' + name
setattr(self, name, self.classtable.get(name))
-
+
def make_bootstrap_objects(self):
def bld_char(i):
w_cinst = self.w_Character.as_class_get_shadow(self).new()
@@ -163,18 +218,22 @@
w_nil.initialize_storage(self, 0)
w_nil.s_class =
self.classtable['w_UndefinedObject'].as_class_get_penumbra(self)
return w_nil
- w_nil = self.w_nil = patch_nil(model.w_nil)
+ w_nil = self.w_nil = model.w_nil
+ # patch_nil(model.w_nil)
- w_true = self.classtable['w_True'].as_class_get_shadow(self).new()
+ w_true = instantiate(model.W_PointersObject)
+ #self.classtable['w_True'].as_class_get_shadow(self).new()
self.w_true = w_true
- w_false = self.classtable['w_False'].as_class_get_shadow(self).new()
+ w_false = instantiate(model.W_PointersObject)
+ #self.classtable['w_False'].as_class_get_shadow(self).new()
self.w_false = w_false
self.w_minus_one = model.W_SmallInteger(-1)
self.w_zero = model.W_SmallInteger(0)
self.w_one = model.W_SmallInteger(1)
self.w_two = model.W_SmallInteger(2)
- w_special_selectors = model.W_PointersObject(self,
- self.classtable['w_Array'], len(constants.SPECIAL_SELECTORS) * 2)
+ w_special_selectors = instantiate(model.W_PointersObject)
+ #model.W_PointersObject(self,
+ #self.classtable['w_Array'], len(constants.SPECIAL_SELECTORS) * 2)
self.w_special_selectors = w_special_selectors
self.objtable = {}
@@ -252,6 +311,7 @@
return intmask(w_value.value)
else:
raise UnwrappingError("The value is negative when interpreted
as 32bit value.")
+ import pdb; pdb.set_trace()
raise UnwrappingError("expected a W_SmallInteger or
W_LargePositiveInteger1Word, got %s" % (w_value,))
def unwrap_uint(self, w_value):
diff --git a/spyvm/shadow.py b/spyvm/shadow.py
--- a/spyvm/shadow.py
+++ b/spyvm/shadow.py
@@ -16,13 +16,10 @@
self.space = space
self._w_self = w_self
def fetch(self, n0):
- import pdb; pdb.set_trace()
raise NotImplementedError("Abstract class")
def store(self, n0, w_value):
- import pdb; pdb.set_trace()
raise NotImplementedError("Abstract class")
def size(self):
- import pdb; pdb.set_trace()
raise NotImplementedError("Abstract class")
def w_self(self):
return self._w_self
@@ -118,13 +115,8 @@
def copy_from(self, other_storage):
AbstractCachingShadow.copy_from(self, other_storage)
- if not self._s_methoddict:
- import pdb; pdb.set_trace()
def store(self, n0, w_val):
- if self.name == "String":
- import pdb; pdb.set_trace()
-
AbstractCachingShadow.store(self, n0, w_val)
if n0 == constants.CLASS_SUPERCLASS_INDEX:
self.store_w_superclass(w_val)
@@ -176,20 +168,6 @@
raise ClassShadowError("unknown format %d" % (format,))
elif n0 == constants.CLASS_NAME_INDEX:
self.store_w_name(w_val)
- elif n0 == (self.size() - 1):
- # Some heuristic to find the classname
- # Only used for debugging
- # XXX This is highly experimental XXX
- # if the name-pos of class is not bytesobject,
- # we are probably holding a metaclass instead of a class.
- # metaclasses hold a pointer to the real class in the last
- # slot. This is pos 6 in mini.image and higher in squeak3.9
- if (isinstance(w_val, model.W_PointersObject)
- and w_val.size() > constants.CLASS_NAME_INDEX):
- # TODO ADD TEST WHICH GOES OVER THIS PART
-
self.store_w_name(w_realclass.fetch(constants.CLASS_NAME_INDEX))
- else:
- return
else:
return
# Some of the special info has changed -> Switch version.
@@ -219,6 +197,8 @@
self.name = w_name.as_string()
else:
self.name = None
+ if self.name == "BlockClosure":
+ import pdb; pdb.set_trace()
@jit.unroll_safe
def flush_method_caches(self):
@@ -256,8 +236,6 @@
return self._s_methoddict.w_self()
def s_methoddict(self):
- if not hasattr(self, "_s_methoddict"):
- import pdb; pdb.set_trace()
return self._s_methoddict
def s_superclass(self):
diff --git a/spyvm/squeakimage.py b/spyvm/squeakimage.py
--- a/spyvm/squeakimage.py
+++ b/spyvm/squeakimage.py
@@ -278,26 +278,29 @@
chunk.g_object.init_w_object()
def assign_prebuilt_constants(self):
- # assign w_objects for objects that are already in objtable
- for name, so_index in
constants.objects_in_special_object_table.items():
- w_object = self.space.objtable["w_" + name]
+ # Assign classes and objects that in special objects array that are
already created.
+
self._assign_prebuilt_constants(constants.objects_in_special_object_table,
self.space.objtable, False)
+
self._assign_prebuilt_constants(constants.classes_in_special_object_table,
self.space.classtable, False)
+
+ # Make sure that all prebuilt classes are actually used in the special
classes array
+ for prebuilt_classname in self.space.classtable.keys():
+ prebuilt_classname = prebuilt_classname[2:]
+ assert prebuilt_classname in
constants.classes_in_special_object_table.keys(), \
+ "Prebuilt class is not used in the special objects
array: %s" % (prebuilt_classname,)
+
+ def _assign_prebuilt_constants(self, names_and_indices, prebuilt_objects,
force_existance=False):
+ for name, so_index in names_and_indices.items():
+ name = "w_" + name
+ if name not in prebuilt_objects and not force_existance:
+ continue
+ w_object = prebuilt_objects[name]
+ assert not force_existance or w_object
if self.special_object(so_index).w_object is None:
self.special_object(so_index).w_object = w_object
else:
if self.special_object(0).w_object is not self.space.w_nil:
raise Warning('Object found in multiple places in the
special objects array')
- # assign w_objects for objects that are already in classtable
- import pdb; pdb.set_trace()
- for name, so_index in
constants.classes_in_special_object_table.items():
- w_object = self.space.classtable["w_" + name]
- if not w_object:
- import pdb; pdb.set_trace()
- if self.special_object(so_index).w_object is None:
- self.special_object(so_index).w_object = w_object
- else:
- if self.special_object(0).w_object is not self.space.w_nil:
- raise Warning('Object found in multiple places in the
special objects array')
-
+
def special_object(self, index):
special = self.chunks[self.specialobjectspointer].g_object.pointers
return special[index]
@@ -439,6 +442,7 @@
w_int = self.space.wrap_int(value)
reader.intcache[value] = w_int
self.w_object = w_int
+ self.filled_in = True
def initialize(self, chunk, reader):
self.reader = reader
@@ -565,10 +569,11 @@
raise CorruptImageError("Expected %d words, got %d" %
(required_len, len(words)))
return words
+ def fillin_nonpointers(self, space):
+ if not self.filled_in and (self.isbytes() or self.iswords()):
+ self.fillin(space)
+
def fillin(self, space):
- if self == self.reader.special_object(6):
- import pdb; pdb.set_trace()
-
if not self.filled_in:
self.filled_in = True
self.w_object.fillin(space, self)
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
