def wrapped(interp, argument_count_m1):
argument_count = argument_count_m1 + 1 # to account for the rcvr
frame = interp.w_active_context
assert argument_count == len_unwrap_spec
if len(frame.stack) < len_unwrap_spec:
raise PrimitiveFailedError()
args = ()
for i, spec in unrolling_unwrap_spec:
index = -len_unwrap_spec + i
w_arg = frame.stack[index]
if spec is int:
args += (utility.unwrap_int(w_arg), )
elif spec is index1_0:
args += (utility.unwrap_int(w_arg)-1, )
elif spec is float:
args += (utility.unwrap_float(w_arg), )
elif spec is object:
args += (w_arg, )
elif spec is str:
args += (w_arg.as_string(), )
elif spec is char:
args += (unwrap_char(w_arg), )
else:
raise NotImplementedError(
"unknown unwrap_spec %s" % (spec, ))
w_result = func(interp, *args)
frame.pop_n(len_unwrap_spec) # only if no exception occurs!
if not no_result:
assert w_result is not None
interp.w_active_context.push(w_result)
def wrapped(interp, argument_count_m1):
argument_count = argument_count_m1 + 1 # to account for the rcvr
frame = interp.w_active_context
assert argument_count == len_unwrap_spec
if len(frame.stack) < len_unwrap_spec:
raise PrimitiveFailedError()
args = ()
for i, spec in unrolling_unwrap_spec:
index = -len_unwrap_spec + i
w_arg = frame.stack[index]
if spec is int:
args += (utility.unwrap_int(w_arg), )
elif spec is index1_0:
args += (utility.unwrap_int(w_arg) - 1, )
elif spec is float:
args += (utility.unwrap_float(w_arg), )
elif spec is object:
args += (w_arg, )
elif spec is str:
args += (w_arg.as_string(), )
elif spec is char:
args += (unwrap_char(w_arg), )
else:
raise NotImplementedError("unknown unwrap_spec %s" %
(spec, ))
w_result = func(interp, *args)
frame.pop_n(len_unwrap_spec) # only if no exception occurs!
if not no_result:
assert w_result is not None
interp.w_active_context.push(w_result)
def entry_point(argv):
if len(argv) > 1:
n = int(argv[1])
else:
n = 8
interp.w_active_context.push(w_object)
interp.w_active_context.push(wrap_int(n))
result = interp.interpret()
print unwrap_int(result)
return 0
def literalatput0(self, index0, w_value):
if index0 == 0:
from pypy.lang.smalltalk import utility
header = utility.unwrap_int(w_value)
self.setheader(header)
else:
self.literals[index0 - 1] = w_value
def store(self, index, value):
# THIS IS ALL UNTESTED CODE and we're a bit unhappy about it
# because it crashd the translation N+4 times :-(
from pypy.lang.smalltalk import utility
if index == constants.BLKCTX_BLOCK_ARGUMENT_COUNT_INDEX:
self.argcnt = utility.unwrap_int(value)
elif index == constants.BLKCTX_INITIAL_IP_INDEX:
self.pc = utility.unwrap_int(value)
elif index == constants.BLKCTX_HOME_INDEX:
assert isinstance(value, W_MethodContext)
self.w_home = value
elif index >= constants.BLKCTX_TEMP_FRAME_START:
stack_index = len(self.stack) - index - 1
self.stack[stack_index] = value
else:
W_ContextPart.store(self, index, value)
def literalatput0(self, index0, w_value):
if index0 == 0:
from pypy.lang.smalltalk import utility
header = utility.unwrap_int(w_value)
self.setheader(header)
else:
self.literals[index0-1] = w_value
def check_me():
interp, w_object = build()
interp.w_active_context.push(w_object)
interp.w_active_context.push(wrap_int(8))
result = interp.interpret()
assert unwrap_int(result) == 34
print "check_me() ok"
def store(self, index, value):
# THIS IS ALL UNTESTED CODE and we're a bit unhappy about it
# because it crashd the translation N+4 times :-(
from pypy.lang.smalltalk import utility
if index == constants.BLKCTX_BLOCK_ARGUMENT_COUNT_INDEX:
self.argcnt = utility.unwrap_int(value)
elif index == constants.BLKCTX_INITIAL_IP_INDEX:
self.pc = utility.unwrap_int(value)
elif index == constants.BLKCTX_HOME_INDEX:
assert isinstance(value, W_MethodContext)
self.w_home = value
elif index >= constants.BLKCTX_TEMP_FRAME_START:
stack_index = len(self.stack) - index - 1
self.stack[stack_index] = value
else:
W_ContextPart.store(self, index, value)
def atput0(self, index0, w_value):
from pypy.lang.smalltalk import utility
if index0 < self.getliteralsize():
self.literalatput0(index0, w_value)
else:
# XXX use to-be-written unwrap_char
index0 = index0 - self.getliteralsize()
self.setchar(index0, chr(utility.unwrap_int(w_value)))
def atput0(self, index0, w_value):
from pypy.lang.smalltalk import utility
if index0 < self.getliteralsize():
self.literalatput0(index0, w_value)
else:
# XXX use to-be-written unwrap_char
index0 = index0 - self.getliteralsize()
self.setchar(index0, chr(utility.unwrap_int(w_value)))
def test():
interp = new_interpreter(sendLiteralSelectorBytecode(1 + 16))
interp.w_active_context.w_method().literals = fakeliterals("foo", "sub")
interp.w_active_context.push(wrap_int(50))
interp.w_active_context.push(wrap_int(8))
callerContext = interp.w_active_context
interp.step()
assert interp.w_active_context is callerContext
assert len(interp.w_active_context.stack) == 1
w_result = interp.w_active_context.pop()
assert unwrap_int(w_result) == 42
def test():
interp = new_interpreter(sendLiteralSelectorBytecode(1 + 16))
interp.w_active_context.w_method().literals = fakeliterals(
"foo", "sub")
interp.w_active_context.push(wrap_int(50))
interp.w_active_context.push(wrap_int(8))
callerContext = interp.w_active_context
interp.step()
assert interp.w_active_context is callerContext
assert len(interp.w_active_context.stack) == 1
w_result = interp.w_active_context.pop()
assert unwrap_int(w_result) == 42
def test_fibWithArgument():
bytecode = ''.join(map(chr, [ 16, 119, 178, 154, 118, 164, 11, 112, 16, 118, 177, 224, 112, 16, 119, 177, 224, 176, 124 ]))
shadow = mockclass(0).as_class_get_shadow()
method = model.W_CompiledMethod(len(bytecode))
method.literalsize = 1
method.bytes = bytecode
method.argsize = 1
method.literals = fakeliterals("fib:")
shadow.installmethod("fib:", method)
w_object = shadow.new()
interp = new_interpreter(sendLiteralSelectorBytecode(16) + returnTopFromMethod)
interp.w_active_context.w_method().literals = fakeliterals("fib:")
interp.w_active_context.push(w_object)
interp.w_active_context.push(wrap_int(8))
result = interp.interpret()
assert unwrap_int(result) == 34
def test_fibWithArgument():
bytecode = ''.join(
map(chr, [
16, 119, 178, 154, 118, 164, 11, 112, 16, 118, 177, 224, 112, 16,
119, 177, 224, 176, 124
]))
shadow = mockclass(0).as_class_get_shadow()
method = model.W_CompiledMethod(len(bytecode))
method.literalsize = 1
method.bytes = bytecode
method.argsize = 1
method.literals = fakeliterals("fib:")
shadow.installmethod("fib:", method)
w_object = shadow.new()
interp = new_interpreter(
sendLiteralSelectorBytecode(16) + returnTopFromMethod)
interp.w_active_context.w_method().literals = fakeliterals("fib:")
interp.w_active_context.push(w_object)
interp.w_active_context.push(wrap_int(8))
result = interp.interpret()
assert unwrap_int(result) == 34
def update_shadow(self):
"Update the ClassShadow with data from the w_self class."
from pypy.lang.smalltalk import objtable
w_self = self.w_self
# read and painfully decode the format
classformat = utility.unwrap_int(
w_self.fetch(constants.CLASS_FORMAT_INDEX))
# The classformat in Squeak, as an integer value, is:
# <2 bits=instSize//64><5 bits=cClass><4 bits=instSpec>
# <6 bits=instSize\\64><1 bit=0>
# In Slang the value is read directly as a boxed integer, so that
# the code gets a "pointer" whose bits are set as above, but
# shifted one bit to the left and with the lowest bit set to 1.
# compute the instance size (really the size, not the number of bytes)
instsize_lo = (classformat >> 1) & 0x3F
instsize_hi = (classformat >> (9 + 1)) & 0xC0
self.instance_size = (instsize_lo | instsize_hi) - 1 # subtract hdr
# decode the instSpec
format = (classformat >> 7) & 15
self.instance_varsized = format >= 2
if format < 4:
self.instance_kind = POINTERS
elif format == 4:
self.instance_kind = WEAK_POINTERS
elif format == 6:
self.instance_kind = WORDS
if self.instance_size != 0:
raise ClassShadowError("can't have both words and a non-zero "
"base instance size")
elif 8 <= format <= 11:
self.instance_kind = BYTES
if self.instance_size != 0:
raise ClassShadowError("can't have both bytes and a non-zero "
"base instance size")
elif 12 <= format <= 15:
self.instance_kind = COMPILED_METHOD
else:
raise ClassShadowError("unknown format %d" % (format,))
# read the name
if w_self.size() > constants.CLASS_NAME_INDEX:
w_name = w_self.fetch(constants.CLASS_NAME_INDEX)
if isinstance(w_name, model.W_BytesObject):
self.name = w_name.as_string()
# read the methoddict
w_methoddict = w_self.fetch(constants.CLASS_METHODDICT_INDEX)
w_values = w_methoddict.fetch(constants.METHODDICT_VALUES_INDEX)
size = w_methoddict.size() - constants.METHODDICT_NAMES_INDEX
for i in range(size):
w_selector = w_methoddict.fetch(constants.METHODDICT_NAMES_INDEX+i)
if w_selector is not objtable.w_nil:
if not isinstance(w_selector, model.W_BytesObject):
raise ClassShadowError("bogus selector in method dict")
selector = w_selector.as_string()
w_compiledmethod = w_values.fetch(i)
if not isinstance(w_compiledmethod, model.W_CompiledMethod):
raise ClassShadowError("the methoddict must contain "
"CompiledMethods only for now")
self.methoddict[selector] = w_compiledmethod
# for the rest, we need to reset invalid to False already so
# that cycles in the superclass and/or metaclass chains don't
# cause infinite recursion
self.invalid = False
# read s_superclass
w_superclass = w_self.fetch(constants.CLASS_SUPERCLASS_INDEX)
if w_superclass is objtable.w_nil:
self.s_superclass = None
else:
self.s_superclass = w_superclass.as_class_get_shadow()
def update_shadow(self):
"Update the ClassShadow with data from the w_self class."
from pypy.lang.smalltalk import objtable
w_self = self.w_self
# read and painfully decode the format
classformat = utility.unwrap_int(
w_self.fetch(constants.CLASS_FORMAT_INDEX))
# The classformat in Squeak, as an integer value, is:
# <2 bits=instSize//64><5 bits=cClass><4 bits=instSpec>
# <6 bits=instSize\\64><1 bit=0>
# In Slang the value is read directly as a boxed integer, so that
# the code gets a "pointer" whose bits are set as above, but
# shifted one bit to the left and with the lowest bit set to 1.
# compute the instance size (really the size, not the number of bytes)
instsize_lo = (classformat >> 1) & 0x3F
instsize_hi = (classformat >> (9 + 1)) & 0xC0
self.instance_size = (instsize_lo | instsize_hi) - 1 # subtract hdr
# decode the instSpec
format = (classformat >> 7) & 15
self.instance_varsized = format >= 2
if format < 4:
self.instance_kind = POINTERS
elif format == 4:
self.instance_kind = WEAK_POINTERS
elif format == 6:
self.instance_kind = WORDS
if self.instance_size != 0:
raise ClassShadowError("can't have both words and a non-zero "
"base instance size")
elif 8 <= format <= 11:
self.instance_kind = BYTES
if self.instance_size != 0:
raise ClassShadowError("can't have both bytes and a non-zero "
"base instance size")
elif 12 <= format <= 15:
self.instance_kind = COMPILED_METHOD
else:
raise ClassShadowError("unknown format %d" % (format, ))
# read the name
if w_self.size() > constants.CLASS_NAME_INDEX:
w_name = w_self.fetch(constants.CLASS_NAME_INDEX)
if isinstance(w_name, model.W_BytesObject):
self.name = w_name.as_string()
# read the methoddict
w_methoddict = w_self.fetch(constants.CLASS_METHODDICT_INDEX)
w_values = w_methoddict.fetch(constants.METHODDICT_VALUES_INDEX)
size = w_methoddict.size() - constants.METHODDICT_NAMES_INDEX
for i in range(size):
w_selector = w_methoddict.fetch(constants.METHODDICT_NAMES_INDEX +
i)
if w_selector is not objtable.w_nil:
if not isinstance(w_selector, model.W_BytesObject):
raise ClassShadowError("bogus selector in method dict")
selector = w_selector.as_string()
w_compiledmethod = w_values.fetch(i)
if not isinstance(w_compiledmethod, model.W_CompiledMethod):
raise ClassShadowError("the methoddict must contain "
"CompiledMethods only for now")
self.methoddict[selector] = w_compiledmethod
# for the rest, we need to reset invalid to False already so
# that cycles in the superclass and/or metaclass chains don't
# cause infinite recursion
self.invalid = False
# read s_superclass
w_superclass = w_self.fetch(constants.CLASS_SUPERCLASS_INDEX)
if w_superclass is objtable.w_nil:
self.s_superclass = None
else:
self.s_superclass = w_superclass.as_class_get_shadow()
def atput0(self, index0, w_value):
from pypy.lang.smalltalk import utility
self.setword(index0, utility.unwrap_int(w_value))
def atput0(self, index0, w_value):
from pypy.lang.smalltalk import utility
self.setword(index0, utility.unwrap_int(w_value))
