RSqueak/VM’s documentation

Building from Source

Common to all systems

We have scripts for installing dependencies, building, running the unit tests, and running JIT tests in the .build subdirectory. You need the PyPy source tree, and the rsdl source tree. If you already have all these, run .build/build.py –32bit to build 32-bit VM. Run .build/build.py to compile a 64-bit VM. The script passes all other arguments on to the rpython translator, so you can pass other options.

It will generate a config file .build/buildconfig.ini where you can set your paths. You can also run .build/download_dependencies.py to download the dependencies automatically. You will also need a Python and a C compiler for 32-bit compilation, if you plan to do 32-bit development.

Windows

On Windows, you will have to use the C compiler that comes with Visual Studio 2008, because newer ones crash the JIT. It suffices to just install the Microsoft C compiler V90 plus Windows SDK 7. Also, install the Python 2.7 Visual Studio compiler package. The packages provided in the link install it to the default paths. If you already have the compiler and SDK, you can also just update the paths in .build/buildconfig.ini.

Linux

RSqueak/VM can currently be compiled in both 32-bit and 64-bit configurations. For 32-bit, you need to use 32-bit python and SDL2 using 32-bit libraries for everything. The easiest way to ensure that is to use a chroot, but you can also install the :i386 versions of the SDL2 dependencies for your distro.

macOS

To compile RSqueak/VM for 32-bit, run

export VERSIONER_PYTHON_PREFER_32_BIT=yes

before you run any of the python scripts in the .build directory. You also need to download SDL2 as a framework (homebrew version is not tested). Check the .travis/build-osx.sh if you get stuck anywhere.

Development

The .build directory includes several scripts that make development easier. Once you’ve setup your system for building, you can use these to work on the RSqueak/VM.

run.py

This script executes RSqueak/VM in hosted mode, that is, it runs on top of a Python interpreter. This is very slow (we recommend using PyPy), but it can be useful to debug specific aspects of the VM quickly. Ideally, you set up an image so that it executes the code that you are interested in early during startup (DisplayScreen class>>startUp is a good candidate) and then you add your breakpoints to the source. You can also pass commandline arguments to the script or tweak the default arguments in the script itself.

Running a “Smalltalk REPL”

When you want to work on primitives or plugins, it is useful to prepare an image a little (for example, make it so test runs print to the console), and then run the following:

pypy .build/run.py --shell <PATH_TO_IMAGE>

This will load the image and dump you in a simple REPL for Smalltalk, but with some commands to help you execute Python code and, in particular, to reload the Python code you write in any plugin or primitive file. Thus, you can run some Smalltalk code, check for errors, change the primitive code, reload it, and try again. This avoids having to reload the image in interpreted mode all the time (which can be slow).

There is an integrated help that you can get by typing !help, and there is limited autocomplete, too.

Note that the REPL only loads the image, but does not process startup. For many things, you might want to run FileStream startUp: true or Delay startUp to get basic I/O working or delays working.

unittests.py

The second script that is useful for working on issues regarding the interpreter is unittests.py. By default it runs all tests under the rsqueakvm/test directory (but not those in rsqueakvm/test/jittest/). This is a standalone pytest script, so you can pass arguments or select single test files as you would for pytest.

jittests.py

This script requires that you have already built an rsqueak binary and that you have the C Squeak VM installed. It executes the tests in rsqueakvm/test/jittest/ and checks for the JIT output. We use these tests to ensure that development on the VM does not break JIT optimizations.

jit.py

This script is useful to figure out what the JIT is doing. Like run.py, it executes the RSqueak/VM in hosted mode, but this time it also simulates the JIT. This is even slower, but allows us to test small code snippets without having to retranslate the entire VM. The code snippets are configured directly in the file. When you run it, it does part of the translation process (but only enough to execute your specific code) and then runs the code. When the JIT kicks in, the compiled loop is shown in a PyGame window. You can then inspect it at your leisure and when you quit the window, the code continues executing. In order for this to work, you need to have pygame and graphviz installed and in your PATH.

shell.py

This script sets all the environment variables as if for translating the VM, and the drops you into an interactive Python prompt. You can type terminal() to drop into a system shell (%COMSPEC% on Windows $SHELL or /bin/sh on Unices) which then has all the environment variables set up that you need to do manual partial translations or similar things.

rsqueakvm package

Subpackages

rsqueakvm.model package

Submodules

rsqueakvm.model.base module

class W_AbstractObjectWithClassReference(space, w_class)

Bases: rsqueakvm.model.base.W_AbstractObjectWithIdentityHash

Objects with arbitrary class (ie not CompiledMethod, SmallInteger or Float).

change_class(space, w_class)

fillin(space, g_self)

getclass(space)

Return Squeak class.

guess_classname()

Get the name of the class of the receiver without using a space. If the shadow of the class of the receiver is not yet initialized, this might not return a correct name.

invariant()

pointers_become_one_way(space, from_w, to_w)

repr_classname = 'W_AbstractObjectWithClassReference'

repr_content()

safe_getclass(space)

w_class = None

class W_AbstractObjectWithIdentityHash

Bases: rsqueakvm.model.base.W_Object

Object with explicit hash (ie all except small ints and floats).

UNASSIGNED_HASH = 0

become(w_other)

Become swaps two objects. False means swapping failed

can_become(w_other)

fillin(space, g_self)

gethash()

Return 31-bit hash value.

hash = 0

invariant()

post_become_one_way(w_to)

rehash()

repr_classname = 'W_AbstractObjectWithIdentityHash'

setchar(n0, character)

class W_Object

Bases: object

Root of Squeak model, abstract.

as_repr_string()

at0(space, index0)

Access variable-sized part, as by Object>>at:.

Return value depends on layout of instance. Byte objects return bytes, word objects return words, pointer objects return pointers. Compiled method are treated special, if index0 within the literalsize returns pointer to literal, otherwise returns byte (ie byte code indexing starts at literalsize).

atput0(space, index0, w_value)

Access variable-sized part, as by Object>>at:put:.

Semantics depend on layout of instance. Byte objects set bytes, word objects set words, pointer objects set pointers. Compiled method are treated special, if index0 within the literalsize sets pointer to literal, otherwise patches bytecode (ie byte code indexing starts at literalsize).

become(other)

Become swaps two objects. False means swapping failed

bytes_per_slot = 4

bytesize()

Return bytesize that conforms to Blue Book.

The reported size may differ from the actual size in Spy’s object space, as memory representation varies depending on PyPy translation.

change_class(space, w_class)

class_shadow(space)

Return internal representation of Squeak class.

classname(space)

Get the name of the class of the receiver

clone(space)

fetch(space, n0)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

fillin(space, g_self)

fillin_finalize(space, g_self)

fillin_weak(space, g_self)

getclass(space)

Return Squeak class.

gethash()

Return 31-bit hash value.

getword(n0)

guess_classname()

Get the name of the class of the receiver without using a space. If the shadow of the class of the receiver is not yet initialized, this might not return a correct name.

has_class()

All Smalltalk objects should have classes. Unfortuantely for bootstrapping the metaclass-cycle and during testing, that is not true for some W_PointersObjects

instsize()

Return the number of slots of the object reserved for instance variables (not number of bytes). Only returns something non-zero for W_PointersObjects, because all other classes in this model hierarchy represent varsized classes (except for SmallInteger).

invariant()

is_array_object()

is_class(space)

Return true, if the receiver seems to be a class. We can not be completely sure about this (non-class objects might be used as class).

is_nil(space)

Return True, if the receiver represents the nil object in the given Object Space.

is_positive(space)

is_same_object(other)

Compare object identity. This should be used instead of directly using is everywhere in the interpreter, in case we ever want to implement it differently (which is useful e.g. for proxies). Also, SmallIntegers and Floats need a different implementation.

pointers_become_one_way(space, from_w, to_w)

post_become_one_way(w_to)

repr_classname = 'W_Object'

repr_content()

safe_getclass(space)

selector_string()

setword(n0, r_uint_value)

size()

Return the number of “slots” or “items” in the receiver object. This means different things for different objects. For ByteObject, this means the number of bytes, for WordObject the number of words, for PointerObject the number of pointers (regardless if it’s varsized or not).

store(space, n0, w_value)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

str_content()

trace_pointers(space)

unwrap_array(space)

unwrap_char_as_byte(space)

unwrap_float(space)

unwrap_int(space)

unwrap_int64(space)

unwrap_rbigint(space)

unwrap_string(space)

unwrap_uint(space)

varsize()

Return number of slots in the of variable-sized part (not number of bytes). Not necessarily number of bytes. Variable sized objects are those created with #new:.

calculate_and_cache(w_object)

rsqueakvm.model.block_closure module

class W_BlockClosure(space, w_outerctxt, startpc, numArgs, size, stack=None)

Bases: rsqueakvm.model.base.W_AbstractObjectWithIdentityHash

at0(space, index0)

Access variable-sized part, as by Object>>at:.

Return value depends on layout of instance. Byte objects return bytes, word objects return words, pointer objects return pointers. Compiled method are treated special, if index0 within the literalsize returns pointer to literal, otherwise returns byte (ie byte code indexing starts at literalsize).

atput0(space, index0, w_value)

Access variable-sized part, as by Object>>at:put:.

Semantics depend on layout of instance. Byte objects set bytes, word objects set words, pointer objects set pointers. Compiled method are treated special, if index0 within the literalsize sets pointer to literal, otherwise patches bytecode (ie byte code indexing starts at literalsize).

bytes_per_slot = 1

changed()

clone(space)

create_frame(space, arguments=[])

empty_stack = []

fetch(space, index0)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

fetch_all(space)

fillin(space, g_self)

fillin_finalize(space, g_self)

get_stacksize()

getclass(space)

Return Squeak class.

instsize()

Return the number of slots of the object reserved for instance variables (not number of bytes). Only returns something non-zero for W_PointersObjects, because all other classes in this model hierarchy represent varsized classes (except for SmallInteger).

numArgs()

pointers_become_one_way(space, from_w, to_w)

repr_classname = 'W_BlockClosure'

set_numArgs(numArgs)

set_stack(lst)

set_startpc(pc)

size()

Return the number of “slots” or “items” in the receiver object. This means different things for different objects. For ByteObject, this means the number of bytes, for WordObject the number of words, for PointerObject the number of pointers (regardless if it’s varsized or not).

startpc()

store(space, index0, w_value)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

store_all(space, lst_w)

tempsize()

trace_pointers(space)

varsize()

Return number of slots in the of variable-sized part (not number of bytes). Not necessarily number of bytes. Variable sized objects are those created with #new:.

version = <rsqueakvm.util.version.Version object>

w_method()

w_outerContext()

w_receiver()

rsqueakvm.model.character module

class W_Character(value)

Bases: rsqueakvm.model.base.W_AbstractObjectWithIdentityHash

Boxed char value.

at0(space, index0)

Access variable-sized part, as by Object>>at:.

Return value depends on layout of instance. Byte objects return bytes, word objects return words, pointer objects return pointers. Compiled method are treated special, if index0 within the literalsize returns pointer to literal, otherwise returns byte (ie byte code indexing starts at literalsize).

atput0(space, index0, w_value)

Access variable-sized part, as by Object>>at:put:.

Semantics depend on layout of instance. Byte objects set bytes, word objects set words, pointer objects set pointers. Compiled method are treated special, if index0 within the literalsize sets pointer to literal, otherwise patches bytecode (ie byte code indexing starts at literalsize).

clone(space)

fetch(space, n0)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

fillin(space, g_self)

getclass(space)

Return Character from special objects array.

gethash()

Return 31-bit hash value.

guess_classname()

Get the name of the class of the receiver without using a space. If the shadow of the class of the receiver is not yet initialized, this might not return a correct name.

invariant()

is_same_object(other)

Compare object identity. This should be used instead of directly using is everywhere in the interpreter, in case we ever want to implement it differently (which is useful e.g. for proxies). Also, SmallIntegers and Floats need a different implementation.

repr_classname = 'W_Character'

size()

Return the number of “slots” or “items” in the receiver object. This means different things for different objects. For ByteObject, this means the number of bytes, for WordObject the number of words, for PointerObject the number of pointers (regardless if it’s varsized or not).

store(space, n0, w_obj)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

str_content()

unwrap_char_as_byte(space)

rsqueakvm.model.compiled_methods module

class CompiledMethodHeader(header_word)

Bases: object

class SpurCompiledMethodHeader(header_word)

Bases: rsqueakvm.model.compiled_methods.CompiledMethodHeader

static has_primitive_bit_set(header_word)

class V3CompiledMethodHeader(header_word)

Bases: rsqueakvm.model.compiled_methods.CompiledMethodHeader

class W_CompiledMethod(space, bytecount=0, header=0)

Bases: rsqueakvm.model.base.W_AbstractObjectWithIdentityHash

My instances are methods suitable for interpretation by the virtual machine. This is the only class in the system whose instances intermix both indexable pointer fields and indexable integer fields.

The current format of a CompiledMethod is as follows:

header (4 bytes) literals (4 bytes each) bytecodes (variable)

An optional method trailer can be part of the bytecodes part.

as_string(markBytecode=0)

at0(space, index0)

atput0(space, index0, w_value)

Access variable-sized part, as by Object>>at:put:.

Semantics depend on layout of instance. Byte objects set bytes, word objects set words, pointer objects set pointers. Compiled method are treated special, if index0 within the literalsize sets pointer to literal, otherwise patches bytecode (ie byte code indexing starts at literalsize).

bytecode_string(markBytecode=0)

bytecodeoffset()

bytes_per_slot = 1

clone(space)

compiled_in()

compute_frame_size()

constant_compiledin_class()

constant_lookup_class()

create_frame(space, receiver, arguments=[], s_fallback=None)

end_pc()

fetch_bytecode(pc)

fillin(space, g_self)

get_identifier_string()

getbytes()

getclass(space)

Return Squeak class.

getheader()

getliteral(index)

getliteralsize()

guess_classname()

Get the name of the class of the receiver without using a space. If the shadow of the class of the receiver is not yet initialized, this might not return a correct name.

guess_containing_classname()

headersize()

initialize_literals(number_of_literals, space, initializing=False)

invariant()

is_array_object()

literalat0(space, index0)

literalatput0(space, index0, w_value, initializing=False)

lookup_class = None

lookup_selector = '<unknown>'

pointers_become_one_way(space, from_w, to_w)

post_init()

primitive()

repr_classname = 'W_CompiledMethod'

safe_compiled_in()

safe_identifier_string()

set_lookup_class_and_name(w_class, selector)

setbytes(bytes)

setchar(index0, character)

setheader(space, header, initializing=False)

setliteral(index, w_lit)

setliterals(literals)

size()

store(space, index0, w_v)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

str_content()

tempsize()

trace_pointers(space)

update_compiledin_class_from_literals()

class W_PreSpurCompiledMethod(space, bytecount=0, header=0)

Bases: rsqueakvm.model.compiled_methods.W_CompiledMethod

setheader(space, header, initializing=False)

class W_SpurCompiledMethod(space, bytecount=0, header=0)

Bases: rsqueakvm.model.compiled_methods.W_CompiledMethod

Handles the specialities of the method header in Spur

setbytes(bytes)

setchar(index0, character)

setheader(space, header, initializing=False)

update_primitive_index()

rsqueakvm.model.display module

class W_16BitDisplayBitmap(space, size, depth)

Bases: rsqueakvm.model.display.W_DirectDisplayBitmap

getword(n)

repr_classname = 'W_16BitDisplayBitmap'

setword(n, word)

swap_pixels(word)

class W_32BitDisplayBitmap(space, size, depth)

Bases: rsqueakvm.model.display.W_DirectDisplayBitmap

repr_classname = 'W_32BitDisplayBitmap'

class W_DirectDisplayBitmap(space, size, depth)

Bases: rsqueakvm.model.display.W_DisplayBitmap

force_rectange_to_screen(left, right, top, bottom)

repr_classname = 'W_DirectDisplayBitmap'

class W_DisplayBitmap(space, size, depth)

Bases: rsqueakvm.model.base.W_AbstractObjectWithIdentityHash

at0(space, index0)

Access variable-sized part, as by Object>>at:.

Return value depends on layout of instance. Byte objects return bytes, word objects return words, pointer objects return pointers. Compiled method are treated special, if index0 within the literalsize returns pointer to literal, otherwise returns byte (ie byte code indexing starts at literalsize).

atput0(space, index0, w_value)

Access variable-sized part, as by Object>>at:put:.

Semantics depend on layout of instance. Byte objects set bytes, word objects set words, pointer objects set pointers. Compiled method are treated special, if index0 within the literalsize sets pointer to literal, otherwise patches bytecode (ie byte code indexing starts at literalsize).

can_become(w_other)

TODO implement _become() for this class. Impossible due to _immutable_fields_?

clone(space)

display()

flush_to_screen()

getclass(space)

Return Squeak class.

getword(n)

guess_classname()

Get the name of the class of the receiver without using a space. If the shadow of the class of the receiver is not yet initialized, this might not return a correct name.

invariant()

is_array_object()

relinquish_display()

repr_classname = 'W_DisplayBitmap'

repr_content()

setword(n, word)

setwords(lst)

size()

Return the number of “slots” or “items” in the receiver object. This means different things for different objects. For ByteObject, this means the number of bytes, for WordObject the number of words, for PointerObject the number of pointers (regardless if it’s varsized or not).

take_over_display()

unwrap_string(space)

class W_MappingDisplayBitmap(space, size, depth)

Bases: rsqueakvm.model.display.W_DisplayBitmap

force_rectange_to_screen(left, right, top, bottom)

repr_classname = 'W_MappingDisplayBitmap'

set_pixelbuffer_word(n, word)

take_over_display()

word_from_pixel(x, y)

from_words_object(w_obj, form)

rsqueakvm.model.numeric module

class W_AbstractFloat(value)

Bases: rsqueakvm.model.base.W_AbstractObjectWithIdentityHash

at0(space, index0)

Access variable-sized part, as by Object>>at:.

Return value depends on layout of instance. Byte objects return bytes, word objects return words, pointer objects return pointers. Compiled method are treated special, if index0 within the literalsize returns pointer to literal, otherwise returns byte (ie byte code indexing starts at literalsize).

atput0(space, index0, w_value)

Access variable-sized part, as by Object>>at:put:.

Semantics depend on layout of instance. Byte objects set bytes, word objects set words, pointer objects set pointers. Compiled method are treated special, if index0 within the literalsize sets pointer to literal, otherwise patches bytecode (ie byte code indexing starts at literalsize).

clone(space)

fetch(space, n0)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

fillin(space, g_self)

fillin_fromwords(space, high, low)

getclass(space)

Return Float from special objects array.

gethash()

Return 31-bit hash value.

getvalue()

guess_classname()

Get the name of the class of the receiver without using a space. If the shadow of the class of the receiver is not yet initialized, this might not return a correct name.

is_same_object(other)

Compare object identity. This should be used instead of directly using is everywhere in the interpreter, in case we ever want to implement it differently (which is useful e.g. for proxies). Also, SmallIntegers and Floats need a different implementation.

setvalue(v)

size()

Return the number of “slots” or “items” in the receiver object. This means different things for different objects. For ByteObject, this means the number of bytes, for WordObject the number of words, for PointerObject the number of pointers (regardless if it’s varsized or not).

store(space, n0, w_obj)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

str_content()

unwrap_float(space)

unwrap_string(space)

class W_Float(value)

Bases: rsqueakvm.model.numeric.W_AbstractFloat

Boxed float value.

fillin_fromwords(space, high, low)

getvalue()

repr_classname = 'W_Float'

setvalue(v)

store(space, n0, w_obj)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

class W_LargeInteger(space, w_class)

Bases: rsqueakvm.model.base.W_AbstractObjectWithClassReference

bytes_per_slot = 1

is_array_object()

is_positive(space)

repr_classname = 'W_LargeInteger'

class W_LargeIntegerBig(space, w_class, value, size=0)

Bases: rsqueakvm.model.numeric.W_LargeInteger

Large integer using rbigints

at0(space, n0)

Access variable-sized part, as by Object>>at:.

Return value depends on layout of instance. Byte objects return bytes, word objects return words, pointer objects return pointers. Compiled method are treated special, if index0 within the literalsize returns pointer to literal, otherwise returns byte (ie byte code indexing starts at literalsize).

atput0(space, n0, w_value)

Access variable-sized part, as by Object>>at:put:.

Semantics depend on layout of instance. Byte objects set bytes, word objects set words, pointer objects set pointers. Compiled method are treated special, if index0 within the literalsize sets pointer to literal, otherwise patches bytecode (ie byte code indexing starts at literalsize).

clone(space)

fillin(space, g_self)

repr_classname = 'W_LargeIntegerBig'

size()

Return the number of “slots” or “items” in the receiver object. This means different things for different objects. For ByteObject, this means the number of bytes, for WordObject the number of words, for PointerObject the number of pointers (regardless if it’s varsized or not).

str_content()

unwrap_float(space)

unwrap_int(space)

unwrap_int64(space)

unwrap_long_untranslated(space)

unwrap_rbigint(space)

unwrap_string(space)

unwrap_uint(space)

class W_LargeIntegerWord(space, w_class, value, size)

Bases: rsqueakvm.model.numeric.W_LargeInteger

at0(space, n0)

Access variable-sized part, as by Object>>at:.

Return value depends on layout of instance. Byte objects return bytes, word objects return words, pointer objects return pointers. Compiled method are treated special, if index0 within the literalsize returns pointer to literal, otherwise returns byte (ie byte code indexing starts at literalsize).

atput0(space, n0, w_value)

Access variable-sized part, as by Object>>at:put:.

Semantics depend on layout of instance. Byte objects set bytes, word objects set words, pointer objects set pointers. Compiled method are treated special, if index0 within the literalsize sets pointer to literal, otherwise patches bytecode (ie byte code indexing starts at literalsize).

clone(space)

fillin(space, g_self)

repr_classname = 'W_LargeIntegerWord'

size()

Return the number of “slots” or “items” in the receiver object. This means different things for different objects. For ByteObject, this means the number of bytes, for WordObject the number of words, for PointerObject the number of pointers (regardless if it’s varsized or not).

str_content()

unwrap_float(space)

unwrap_int64(space)

unwrap_long_untranslated(space)

unwrap_rbigint(space)

unwrap_string(space)

unwrap_uint(space)

class W_MutableFloat(value)

Bases: rsqueakvm.model.numeric.W_AbstractFloat

Balloon frequently converts 32-bit words into Floats from within the image. If we give a normal W_Float and let Balloon mutate the words to fill it in, we always have to abort any trace because we’re forcing a quasi-immutable. So just for those cases where someone in the image is creating floats using `new’ (in storage_classes.py), we use W_MutableFloat instances, which do not declare they’re value as quasi-immutable.

getvalue()

repr_classname = 'W_MutableFloat'

setvalue(v)

store(space, n0, w_obj)

Floats are stored in big-endian (PowerPC) order

class W_MutableSmallInteger(value)

Bases: rsqueakvm.model.numeric.W_SmallInteger

set_value(v)

value

class W_SmallInteger(value)

Bases: rsqueakvm.model.base.W_Object

Boxed integer value

clone(space)

fillin(space, g_self)

This is only called for Large Integers that for us fit in SmallIntegers

getclass(space)

Return Squeak class.

gethash()

Return 31-bit hash value.

guess_classname()

Get the name of the class of the receiver without using a space. If the shadow of the class of the receiver is not yet initialized, this might not return a correct name.

invariant()

is_positive(space)

is_same_object(other)

Compare object identity. This should be used instead of directly using is everywhere in the interpreter, in case we ever want to implement it differently (which is useful e.g. for proxies). Also, SmallIntegers and Floats need a different implementation.

repr_classname = 'W_SmallInteger'

str_content()

unwrap_char_as_byte(space)

unwrap_float(space)

unwrap_int(space)

unwrap_int64(space)

unwrap_long_untranslated(space)

unwrap_rbigint(space)

unwrap_uint(space)

value

calculate_exposed_size_for_big_int(value)

rsqueakvm.model.pointers module

class W_PointersObject(space, w_class, size, weak=False)

Bases: rsqueakvm.model.base.W_AbstractObjectWithIdentityHash

Common object.

as_cached_object_get_shadow(space)

as_class_get_shadow(space)

as_context_get_shadow(space)

as_methoddict_get_shadow(space)

as_observed_get_shadow(space)

as_special_get_shadow(space, TheClass)

assert_strategy()

at0(space, index0)

Access variable-sized part, as by Object>>at:.

Return value depends on layout of instance. Byte objects return bytes, word objects return words, pointer objects return pointers. Compiled method are treated special, if index0 within the literalsize returns pointer to literal, otherwise returns byte (ie byte code indexing starts at literalsize).

atput0(space, index0, w_value)

Access variable-sized part, as by Object>>at:put:.

Semantics depend on layout of instance. Byte objects set bytes, word objects set words, pointer objects set pointers. Compiled method are treated special, if index0 within the literalsize sets pointer to literal, otherwise patches bytecode (ie byte code indexing starts at literalsize).

change_class(space, w_class)

clone(space)

fetch(space, n0)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

fetch_all(space)

fillin(space, g_self)

fillin_weak(space, g_self)

getclass(space)

Return Squeak class.

guess_classname()

Get the name of the class of the receiver without using a space. If the shadow of the class of the receiver is not yet initialized, this might not return a correct name.

has_class()

All Smalltalk objects should have classes. Unfortuantely for bootstrapping the metaclass-cycle and during testing, that is not true for some W_PointersObjects

has_space()

has_strategy()

instsize()

Return the number of slots of the object reserved for instance variables (not number of bytes). Only returns something non-zero for W_PointersObjects, because all other classes in this model hierarchy represent varsized classes (except for SmallInteger).

invariant()

is_class(space)

Return true, if the receiver seems to be a class. We can not be completely sure about this (non-class objects might be used as class).

is_weak()

pointers_become_one_way(space, from_w, to_w)

repr_classname = 'W_PointersObject'

repr_content()

safe_getclass(space)

size()

Return the number of “slots” or “items” in the receiver object. This means different things for different objects. For ByteObject, this means the number of bytes, for WordObject the number of words, for PointerObject the number of pointers (regardless if it’s varsized or not).

space()

store(space, n0, w_value)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

store_all(space, collection)

store_strategy(strategy)

strategy = None

trace_pointers(space)

unwrap_array(space)

unwrap_char(space)

rsqueakvm.model.variable module

class W_BytesObject(space, w_class, size)

Bases: rsqueakvm.model.base.W_AbstractObjectWithClassReference

at0(space, index0)

Access variable-sized part, as by Object>>at:.

Return value depends on layout of instance. Byte objects return bytes, word objects return words, pointer objects return pointers. Compiled method are treated special, if index0 within the literalsize returns pointer to literal, otherwise returns byte (ie byte code indexing starts at literalsize).

atput0(space, index0, w_value)

Access variable-sized part, as by Object>>at:put:.

Semantics depend on layout of instance. Byte objects set bytes, word objects set words, pointer objects set pointers. Compiled method are treated special, if index0 within the literalsize sets pointer to literal, otherwise patches bytecode (ie byte code indexing starts at literalsize).

bytes_per_slot = 1

clone(space)

fillin(space, g_self)

getbytes()

getchar(n0)

getrbigint()

invariant()

is_array_object()

is_positive(space)

mutate()

repr_classname = 'W_BytesObject'

selector_string()

setbytes(lst)

setchar(n0, character)

short_at0(space, index0)

short_atput0(space, index0, w_value)

size()

Return the number of “slots” or “items” in the receiver object. This means different things for different objects. For ByteObject, this means the number of bytes, for WordObject the number of words, for PointerObject the number of pointers (regardless if it’s varsized or not).

str_content()

unwrap_int64(space)

unwrap_long_untranslated(space)

unwrap_rbigint(space)

unwrap_string(space)

unwrap_uint(space)

class W_WordsObject(space, w_class, size)

Bases: rsqueakvm.model.base.W_AbstractObjectWithClassReference

at0(space, index0)

Access variable-sized part, as by Object>>at:.

Return value depends on layout of instance. Byte objects return bytes, word objects return words, pointer objects return pointers. Compiled method are treated special, if index0 within the literalsize returns pointer to literal, otherwise returns byte (ie byte code indexing starts at literalsize).

atput0(space, index0, w_value)

Access variable-sized part, as by Object>>at:put:.

Semantics depend on layout of instance. Byte objects set bytes, word objects set words, pointer objects set pointers. Compiled method are treated special, if index0 within the literalsize sets pointer to literal, otherwise patches bytecode (ie byte code indexing starts at literalsize).

clone(space)

convert_to_bytes_layout(wordsize)

fillin(space, g_self)

getchar(n0)

getword(n)

getwords()

invariant()

is_array_object()

repr_classname = 'W_WordsObject'

setchar(n0, character)

setword(n, word)

setwords(lst)

short_at0(space, index0)

short_atput0(space, index0, w_value)

size()

Return the number of “slots” or “items” in the receiver object. This means different things for different objects. For ByteObject, this means the number of bytes, for WordObject the number of words, for PointerObject the number of pointers (regardless if it’s varsized or not).

unwrap_string(space)

Module contents

Squeak model.

W_Object

W_SmallInteger

W_MutableSmallInteger

W_AbstractObjectWithIdentityHash

W_AbstractFloat

W_Float W_MutableFloat

W_Character W_PointersObject W_AbstractObjectWithClassReference

W_LargeInteger

W_LargeIntegerWord W_LargeIntegerBig

W_BytesObject W_WordsObject

W_CompiledMethod

W_SpurCompiledMethod W_PreSpurCompiledMethod

rsqueakvm.plugins package

Subpackages

rsqueakvm.plugins.database package

Submodules

rsqueakvm.plugins.database.model module

class DBType

Bases: object

class W_DBObject(space, w_class, size, weak=False, w_id=None, cache=None)

Bases: rsqueakvm.model.pointers.W_PointersObject

class_name(space)

fetch(space, n0)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

is_same_object(other)

Compare object identity. This should be used instead of directly using is everywhere in the interpreter, in case we ever want to implement it differently (which is useful e.g. for proxies). Also, SmallIntegers and Floats need a different implementation.

static next_id()

repr_classname = 'W_DBObject'

state = <rsqueakvm.plugins.database.model.W_DBObject_State instance>

store(space, n0, w_value)

Access fixed-size part, maybe also variable-sized part (we have to consult the Blue Book).

class W_DBObject_State

create_table_if_neccessary(space, class_name, connection)

get_column_type(class_name, n0)

get_column_types(class_name)

init_column_types_if_neccessary(class_name, size)

set_column_type(class_name, position, value)

alter_sql(class_name, n0, dbtype)

create_sql(class_name)

insert_sql(class_name)

select_sql(class_name, n0)

update_sql(class_name, n0)

Module contents

class CConfig

SQLITE_BLOB = None

SQLITE_DONE = None

SQLITE_FLOAT = None

SQLITE_INTEGER = None

SQLITE_NULL = None

SQLITE_ROW = None

SQLITE_TEXT = None

class DBManager

Bases: object

close(db_pointer)

connect(db_class, filename)

connection()

cursor(cursor_handle)

execute(space, db, sql, args=None)

get_connection(db_handle)

class SQLConnection(db_class, filename)

Bases: object

close()

connect(db_class, filename)

cursor()

execute(space, sql, args=None)

class SQLCursor(connection)

Bases: object

bind_query_argument(space, w_value, query, i)

close()

execute(space, sql, args=None)

next(space)

raw_next(space)

class Statement(w_connection, sql)

Bases: object

close()

class StatementCache(w_connection)

Bases: object

all_statements()

get_holder(sql)

get_or_make(sql)

invalidate()

class StatementHolder

Bases: object

rsqueakvm.plugins.immutability package

Submodules

rsqueakvm.plugins.immutability.bytes module

Immutable W_BytesObject Implementation.

class W_Immutable_BytesObject(space, w_cls, bytes)

Bases: rsqueakvm.model.variable.W_BytesObject

W_BytesObject subclass with immutable bytes.

rsqueakvm.plugins.immutability.pointers module

Immutable W_PointersObject Implementation.

POINTERS_CLASSES

A list of all immutable W_PointersObject subclasses. The position of each class in the list correlates to its number of storage slots (0 no storage, 1 has one storage slot, …). The last class in the list is an immutable W_PointersObject subclass with variable storage size.

POINTERS_CLASS_ITER

Unrolling iterable of POINTERS_CLASSES.

STORAGE_ATTR_TEMPLATE

Storage attribute template.

MAX_FIXED_SLOTS

Number of immutable subclasses with fixed number of slots to generate.

class W_AbstractImmutable_PointersObject(space, w_cls)

Bases: rsqueakvm.model.pointers.W_PointersObject

Abstract W_PointersObject subclass for immutable pointers objects.

class_shadow(space)

Returns:Class shadow stored in self.strategy slot.

fetch(space, n0)

Raises:NotImplementedError

getclass(space)

Returns:Class from class shadow stored in self.strategy slot.

size()

Raises:NotImplementedError

class W_Immutable_PointersObject(space, w_cls, pointers_w)

Bases: rsqueakvm.plugins.immutability.pointers.W_AbstractImmutable_PointersObject

W_PointersObject subclass with immutable storage of variable size.

fetch(space, n0)

Raises:NotImplementedError

size()

Raises:NotImplementedError

generate_fixed_immutable_subclass(n_storage)

Generate W_PointersObject subclass with immutable storage of fixed size.

Parameters:n_storage – Number of storage slots. Returns:Immutable W_PointersObject subclass with fixed slots.

select_immutable_pointers_class(storage)

Select immutable W_PointersObject subclass for a given pointers storage. If there is no immutable W_PointersObject subclass with the right fixed storage size, it returns the immutable subclass with variable storage size.

Parameters:storage – Pointers to store. Returns:Immutable W_PointersObject subclass.

rsqueakvm.plugins.immutability.words module

Immutable W_WordsObject Implementation.

class W_Immutable_WordsObject(space, w_cls, words)

Bases: rsqueakvm.model.variable.W_WordsObject

W_WordsObject subclass with immutable words.

Module contents

Base functions for ImmutabilityPlugin.

WRITE_OPERATIONS

A list of all write operations to be stubbed out by immutable_class(cls) decorator.

immutable_class(cls)

This function decorates classes, so that is_immutable returns True and all WRITE_OPERATIONS are implemented as NoOps.

Parameters:cls – The target class. Returns:The decorated class.

patch_w_object()

Add W_Object.is_immutable which by default returns False.

rsqueakvm.plugins.vmdebugging package

Submodules

rsqueakvm.plugins.vmdebugging.hooks module

class JitIface

Bases: rpython.rlib.jit.JitHookInterface

after_compile(debug_info)

A hook called after a loop has compiled assembler, called with JitDebugInfo instance. Overwrite for custom behavior

after_compile_bridge(debug_info)

A hook called after a bridge is compiled, called with JitDebugInfo instance, overwrite for custom behavior

before_compile(debug_info)

A hook called after a loop is optimized, before compiling assembler, called with JitDebugInfo instance. Overwrite for custom behavior

before_compile_bridge(debug_info)

A hook called before a bridge is compiled, but after optimizations are performed. Called with instance of debug_info, overwrite for custom behavior

on_abort(reason, jitdriver, greenkey, greenkey_repr, logops, operations)

on_trace_too_long(jitdriver, greenkey, greenkey_repr)

prepare_abort(reason, jitdriver, greenkey, greenkey_repr, logops, operations)

prepare_compile_hook(jitdriver, debug_info, is_bridge)

prepare_trace_too_long(jitdriver, greenkey, greenkey_repr)

wrapped_compiled_hook(jitdriver, debug_info, is_bridge)

make_hook(args, func)

rsqueakvm.plugins.vmdebugging.model module

DebugMergePoint(space, name, repr_of_resop, jd_name, call_depth, call_id, w_greenkey)

GuardOp(space, name, offset, repr_of_resop, hash)

WrappedOp(space, name, offset, repr_of_resop)

method_from_greenkey(space, jitdriver, greenkey)

wrap_debug_info(space, debug_info, is_bridge=False)

wrap_greenkey(space, jitdriver, greenkey, greenkey_repr)

wrap_oplist(space, logops, operations, ops_offset=None)

Module contents

Submodules

rsqueakvm.plugins.database_plugin module

rsqueakvm.plugins.file_plugin module

class FilePlugin

Bases: rsqueakvm.plugins.plugin.Plugin

primitiveDirectoryCreate(interp, s_frame, w_rcvr, dir_path)

primitiveDirectoryDelete(interp, s_frame, w_rcvr, dir_path)

primitiveDirectoryDelimitor(interp, s_frame, w_rcvr)

primitiveDirectoryLookup(interp, s_frame, w_file_directory, full_path, index)

primitiveDirectorySetMacTypeAndCreator(interp, s_frame, w_rcvr, filename, type, creator)

primitiveFileAtEnd(interp, s_frame, w_rcvr, fd)

primitiveFileClose(interp, s_frame, w_rcvr, fd)

primitiveFileDelete(interp, s_frame, w_rcvr, file_path)

primitiveFileFlush(interp, s_frame, w_rcvr, fd)

primitiveFileGetPosition(interp, s_frame, w_rcvr, fd)

primitiveFileOpen(interp, s_frame, w_rcvr, file_path, w_writeable_flag)

primitiveFileRead(interp, s_frame, w_rcvr, fd, target, start, count)

primitiveFileSetPosition(interp, s_frame, w_rcvr, fd, position)

primitiveFileSize(interp, s_frame, w_rcvr, fd)

primitiveFileStdioHandles(interp, s_frame, w_rcvr)

primitiveFileTruncate(interp, s_frame, w_rcvr, fd, position)

primitiveFileWrite(interp, s_frame, w_rcvr, fd, content, start, count)

smalltalk_timestamp(space, sec_since_epoch)

rsqueakvm.plugins.immutability_plugin module

RSqueak/VM plugin which provides support for immutable objects.

Immutable objects can be created as copy of existing objects or from a list of arguments. The package ImmutableObjects, located in /repository, needs to be loaded in the image.

class ImmutabilityPlugin

Bases: rsqueakvm.plugins.plugin.Plugin

setup()

Called when enabled during instantiation.

primitiveImmutableFrom(interp, s_frame, w_cls, w_obj)

Creates an immutable copy of a given Smalltalk object.

Parameters:

• interp – The interpreter proxy.
• s_frame – The stack frame.
• w_cls – The imutable objects target class.
• w_obj – The Smalltalk object to produce an immutable copy from.

Returns:

An immutable copy of w_obj with class w_cls.

Raises:

PrimitiveFailedError

primitiveImmutableFromArgs(interp, s_frame, argcount)

Returns an immutable instance of the receiver (which is a class) with all fields initialized with the arguments given.

Parameters:

• interp – The interpreter proxy.
• s_frame – The stack frame.
• argcount – The number of arguments.

Returns:

An immutable object.

Raises:

PrimitiveFailedError

primitiveIsImmutable(interp, s_frame, w_recv)

Tests if w_recv is an immutable object.

Parameters:

• interp – The interpreter proxy.
• s_frame – The stack frame.
• w_recv – The receiver object.

Returns:

w_true if w_recv is immutable object, otherwise w_false.

rsqueakvm.plugins.large_integers module

class LargeIntegers

Bases: rsqueakvm.plugins.plugin.Plugin

make_func(name, primitive)

minimum_bytelen_for(val)

primDigitAdd(interp, s_frame, rcvr, arg)

primDigitCompare(interp, s_frame, rcvr, arg)

primDigitDivNegative(interp, s_frame, rcvr, arg, neg)

primDigitMultiplyNegative(interp, s_frame, rcvr, arg, neg)

primDigitSubtract(interp, s_frame, rcvr, arg)

primNormalizeNegative(interp, s_frame, w_rcvr)

primNormalizePositive(interp, s_frame, w_rcvr)

rsqueakvm.plugins.locale_plugin module

class LocalePlugin

Bases: rsqueakvm.plugins.plugin.Plugin

primitiveCountry(interp, s_frame, w_rcvr)

primitiveLanguage(interp, s_frame, w_rcvr)

rsqueakvm.plugins.misc_primitive_plugin module

class MiscPrimitivePlugin

Bases: rsqueakvm.plugins.plugin.Plugin

compare_ascii(string1, string2)

compare_collated(string1, string2, order)

is_ascii_order(w_order)

primitiveCompareString(interp, s_frame, w_rcvr, string1, string2, w_order)

primitiveIndexOfAsciiInString(interp, s_frame, w_rcvr, thechar, thebytes, start)

primitiveStringHash(interp, s_frame, w_rcvr, thebytes, initialHash)

rsqueakvm.plugins.plugin module

class Plugin

Bases: object

call(name, interp, s_frame, argcount, w_method)

expose_primitive(wrap_func=None, **kwargs)

is_enabled()

is_optional()

name()

patch()

Called once in the beginning of main.py to patch interpreter.

setup()

Called when enabled during instantiation.

static startup(space, argv)

Called after image has been loaded and space has been set up.

rsqueakvm.plugins.profiler_plugin module

class LogFile

Bases: object

close()

fileno()

isopen()

open(name)

class ProfilerPlugin

Bases: rsqueakvm.plugins.plugin.Plugin

is_optional()

patch()

Called once in the beginning of main.py to patch interpreter.

setup()

Called when enabled during instantiation.

disableJitlog(interp, s_frame, w_rcvr)

disableProfiler(interp, s_frame, w_rcvr)

enableJitlog(interp, s_frame, w_rcvr, fileno)

enableProfiler(interp, s_frame, w_rcvr, fileno, period)

func(interp, s_frame, w_rcvr)

patch_compiled_method()

patch_interpreter()

rsqueakvm.plugins.ruby_plugin module

rsqueakvm.plugins.simulation module

class SimulationPlugin

Bases: rsqueakvm.plugins.plugin.Plugin

simulate(w_name, signature, interp, s_frame, argcount, w_method)

simulateNumeric(code, interp, s_frame, argcount, w_method)

rsqueakvm.plugins.socket_plugin module

class SocketPlugin

Bases: rsqueakvm.plugins.plugin.Plugin

expose_primitive(wrap_func=None, **kwargs)

get_last_lookup()

is_socket(space, w_int)

set_last_lookup(v)

static startup(space, argv)

class W_SocketHandle(family, socketType)

Bases: rsqueakvm.model.base.W_AbstractObjectWithIdentityHash

can_read()

close()

connect(w_bytes, port)

destroy()

getclass(space)

Return Squeak class.

guess_classname()

Get the name of the class of the receiver without using a space. If the shadow of the class of the receiver is not yet initialized, this might not return a correct name.

isipv4()

isipv6()

make_socket()

recv(count)

repr_classname = 'W_SocketHandle'

send(data)

ensure_socket(w_socket)

non_blocking_recv(self, count)

primitiveHasSocketAccess(interp, s_frame, w_rcvr)

primitiveInitializeNetwork(interp, s_frame, w_rcvr, w_semaphore)

primitiveResolverAbortLookup(interp, s_frame, argcount)

primitiveResolverAddressLookupResult(interp, s_frame, argcount)

primitiveResolverError(interp, s_frame, argcount)

primitiveResolverGetAddressInfo(interp, s_frame, argcount)

primitiveResolverGetAddressInfoFamily(interp, s_frame, argcount)

primitiveResolverGetAddressInfoNext(interp, s_frame, argcount)

primitiveResolverGetAddressInfoProtocol(interp, s_frame, argcount)

primitiveResolverGetAddressInfoResult(interp, s_frame, argcount)

primitiveResolverGetAddressInfoSize(interp, s_frame, argcount)

primitiveResolverGetAddressInfoType(interp, s_frame, argcount)

primitiveResolverGetNameInfo(interp, s_frame, argcount)

primitiveResolverGetNameInfoHostResult(interp, s_frame, argcount)

primitiveResolverGetNameInfoHostSize(interp, s_frame, argcount)

primitiveResolverGetNameInfoServiceResult(interp, s_frame, argcount)

primitiveResolverGetNameInfoServiceSize(interp, s_frame, argcount)

primitiveResolverHostNameResult(interp, s_frame, argcount)

primitiveResolverHostNameSize(interp, s_frame, argcount)

primitiveResolverLocalAddress(interp, s_frame, argcount)

primitiveResolverNameLookupResult(interp, s_frame, w_rcvr)

primitiveResolverStartAddressLookup(interp, s_frame, argcount)

primitiveResolverStartNameLookup(interp, s_frame, w_rcvr, hostname)

primitiveResolverStatus(interp, s_frame, w_rcvr)

primitiveSocketAbortConnection(interp, s_frame, argcount)

primitiveSocketAccept3Semaphores(interp, s_frame, argcount)

primitiveSocketAddressGetPort(interp, s_frame, argcount)

primitiveSocketAddressSetPort(interp, s_frame, argcount)

primitiveSocketBindTo(interp, s_frame, argcount)

primitiveSocketCloseConnection(interp, s_frame, w_rcvr, w_handle)

primitiveSocketConnectTo(interp, s_frame, argcount)

primitiveSocketConnectToPort(interp, s_frame, w_rcvr, w_handle, w_hostaddr, port)

primitiveSocketConnectionStatus(interp, s_frame, w_rcvr, w_socket)

primitiveSocketCreate3Semaphores(interp, s_frame, w_rcvr, netType, socketType, rcvBufSize, sendBufSize, sema, readSema, writeSema)

primitiveSocketDestroy(interp, s_frame, w_rcvr, w_handle)

primitiveSocketError(interp, s_frame, argcount)

primitiveSocketGetOptions(interp, s_frame, argcount)

primitiveSocketListenOnPortBacklogInterface(interp, s_frame, argcount)

primitiveSocketListenWithBacklog(interp, s_frame, argcount)

primitiveSocketListenWithOrWithoutBacklog(interp, s_frame, argcount)

primitiveSocketLocalAddress(interp, s_frame, argcount)

primitiveSocketLocalAddressResult(interp, s_frame, argcount)

primitiveSocketLocalAddressSize(interp, s_frame, argcount)

primitiveSocketLocalPort(interp, s_frame, argcount)

primitiveSocketReceiveDataAvailable(interp, s_frame, w_rcvr, w_handle)

primitiveSocketReceiveDataBufCount(interp, s_frame, w_rcvr, w_handle, w_target, start, count)

primitiveSocketReceiveUDPDataBufCount(interp, s_frame, argcount)

primitiveSocketRemoteAddress(interp, s_frame, argcount)

primitiveSocketRemoteAddressResult(interp, s_frame, argcount)

primitiveSocketRemoteAddressSize(interp, s_frame, argcount)

primitiveSocketRemotePort(interp, s_frame, argcount)

primitiveSocketSendDataBufCount(interp, s_frame, w_rcvr, w_handle, data, start, count)

primitiveSocketSendDone(interp, s_frame, w_rcvr, fd)

primitiveSocketSendUDPDataBufCount(interp, s_frame, argcount)

primitiveSocketSetOptions(interp, s_frame, argcount)

rsqueakvm.plugins.squeak_s_s_l module

rsqueakvm.plugins.tailcall_plugin module

class TailcallPlugin

Bases: rsqueakvm.plugins.plugin.Plugin

is_optional()

patch()

Called once in the beginning of main.py to patch interpreter.

setup()

Called when enabled during instantiation.

primitiveIsTailcallContext(interp, s_frame, w_recv)

primitiveMarkTailcallContext(interp, s_frame, w_recv)

rsqueakvm.plugins.unix_o_s_process_plugin module

rsqueakvm.plugins.v_m_debugging module

rsqueakvm.plugins.win32_o_s_process_plugin module

Module contents

class PluginRegistry

Bases: object

static add(instance)

disabled_names = ['RubyPlugin']

enabled_names = ['SimulationPlugin', 'FilePlugin', 'ImmutabilityPlugin', 'LargeIntegers', 'LocalePlugin', 'MiscPrimitivePlugin', 'ProfilerPlugin', 'SocketPlugin', 'TailcallPlugin']

enabled_plugins = [<rsqueakvm.plugins.simulation.SimulationPlugin object>, <rsqueakvm.plugins.file_plugin.FilePlugin object>, <rsqueakvm.plugins.immutability_plugin.ImmutabilityPlugin object>, <rsqueakvm.plugins.large_integers.LargeIntegers object>, <rsqueakvm.plugins.locale_plugin.LocalePlugin object>, <rsqueakvm.plugins.misc_primitive_plugin.MiscPrimitivePlugin object>, <rsqueakvm.plugins.profiler_plugin.ProfilerPlugin object>, <rsqueakvm.plugins.socket_plugin.SocketPlugin object>, <rsqueakvm.plugins.tailcall_plugin.TailcallPlugin object>]

get_plugins()

print_plugin_overview()

should_load_plugin(localfile)

rsqueakvm.primitives package

Submodules

rsqueakvm.primitives.arithmetic module

rsqueakvm.primitives.array_stream module

func(interp, s_frame, w_receiver, n0, w_value)

rsqueakvm.primitives.block_closure module

activateClosure(interp, w_block, args_w)

func(interp, s_frame, w_rcvr)

rsqueakvm.primitives.constants module

rsqueakvm.primitives.control module

rsqueakvm.primitives.input_output module

func(interp, s_frame, w_rcvr)

rsqueakvm.primitives.mirror module

expose_mirror_primitive(code)

rsqueakvm.primitives.misc module

fake_bytes_left(interp)

func(interp, s_frame, w_receiver, attr_id)

next_object(space, list_of_objects, w_obj)

rsqueakvm.primitives.storage module

func(interp, s_frame, w_class, bytecount, header)

get_instances_array(interp, s_frame, w_class=None, store=True, some_instance=False)

get_instances_array_gc(interp, w_class=None)

get_instances_array_trace(interp, w_class, some_instance=False)

next_instance(space, list_of_objects, w_obj)

primitive_fetch(interp, s_frame, w_rcvr, n0)

primitive_store(interp, s_frame, w_rcvr, n0, w_value)

rsqueakvm.primitives.system module

current_gc_old_mem(*args)

current_gc_time(*args)

current_gc_total_mem(*args)

current_gc_young_mem(*args)

func(interp, s_frame, w_rcvr, index)

translated_or_default(default)

Module contents

class PrimitiveHolder

Bases: object

assert_class(interp, w_obj, w_class)

assert_pointers(w_obj)

assert_valid_index(space, n0, w_obj)

assert_valid_inst_index(space, n0, w_obj)

expose_also_as(*codes)

expose_alternative_primitive(code, **kwargs)

expose_primitive(code, wrap_func=None, **kwargs)

make_prim(i)

make_simulation(code)

primitive_name_from_code(code)

unwrap_alternatives(unwrap_specs=None)

wrap_primitive(unwrap_spec=None, no_result=False, result_is_new_frame=False, may_context_switch=True, clean_stack=True, compiled_method=False)

rsqueakvm.util package

Submodules

rsqueakvm.util.bitmanipulation module

class BitSplitter

Bases: dict

rsqueakvm.util.cells module

Cell(initial_value, type=<type 'object'>)

QuasiConstant(initial_value, cls=None)

class QuasiConstantCache

Bases: rpython.rlib.cache.Cache

class QuasiConstantMixin(initial_value)

Bases: object

Mixin for constant values that can be edited, but will be promoted to a constant when jitting.

activate()

changed()

deactivate()

get()

is_set()

set(value)

rsqueakvm.util.dialog module

ask_question(string)

get_file()

rsqueakvm.util.logparser module

class Trace(trace)

Bases: object

addbridge(trace)

keep_op(op)

parse(remove_debug, remove_main_labels, remove_all_labels)

parse_bridges()

parse_loop()

extract_traces(file, remove_debug=True, remove_main_labels=True, remove_all_labels=False)

rsqueakvm.util.platform_calls module

get_memory_usage()

rsqueakvm.util.progress module

class Progress(stages, silent=False)

Bases: object

next_stage(steps)

update(new_steps=-1)

rsqueakvm.util.shell module

class Shell(interp, space, code=None)

Bases: object

db(code)

!db to drop to pdb (untranslated) or gdb (translated)

help(code)

!help to print this help

load(code)

!load Filename to read and execute a file

method(code)

!method Class to define a method. End with !!

q(code)

!q for quitting

raw_input(delim)

reload(c)

reset_readline()

run()

set_interp(interp)

set_readline()

trace(code)

!trace on|off to enable/disable interp tracing

cmd(func)

completer(text, state, completions=None)

untranslated_cmd(func)

rsqueakvm.util.stream module

class Stream(filename=None, inputfile=None, data=None)

Bases: object

Simple input stream. Data is completely read into memory. Constructor can raise OSError.

be_32bit()

be_64bit()

bytes2dword_with_correct_endianness(bytes)

bytes2qword_with_correct_endianness(bytes)

close()

length()

next()

next_bytes(n)

next_qword()

next_short()

peek()

peek_bytes(n)

reset()

reset_count()

skipbytes(jump)

skipwords(jump)

chrs2int(b)

chrs2long(b)

runpack(fmt, arg)

swapped_chrs2int(b)

swapped_chrs2long(b)

rsqueakvm.util.system module

expose_options(config)

translation_options()

rsqueakvm.util.version module

class Version

Bases: object

class VersionMixin

Bases: object

changed()

version = <rsqueakvm.util.version.Version object>

elidable_for_version(numargs, promote='all')

elidable_for_version_iff(numargs, promote='all', cond=None)

Module contents

Submodules

rsqueakvm.constants module

decode_alternate_compiled_method_header(header)

Decode 30-bit method header and apply new format.

(index 0) 16 bits: number of literals (#numLiterals) (index 16) 1 bit: has primitive (index 17) 1 bit: whether a large frame size is needed (#frameSize) (index 18) 6 bits: number of temporary variables (#numTemps) (index 24) 4 bits: number of arguments to the method (#numArgs) (index 28) 2 bits: reserved for an access modifier (00-unused, 01-private, 10-protected, 11-public)

decode_compiled_method_header(header)

Decode 30-bit method header and apply new format.

(index 0) 9 bits: main part of primitive number (#primitive) (index 9) 8 bits: number of literals (#numLiterals) (index 17) 1 bit: whether a large frame size is needed (#frameSize) (index 18) 6 bits: number of temporary variables (#numTemps) (index 24) 4 bits: number of arguments to the method (#numArgs) (index 28) 1 bit: high-bit of primitive number (#primitive) (index 29) 1 bit: flag bit, ignored by the VM (#flag)

find_selectorindex(selector)

init_special_objects_mapping(constant_objects_in_special_object_table)

rsqueakvm.display module

class NullDisplay

Bases: object

defer_updates(flag)

flip(pixels, x, y, x2, y2)

get_dropped_filename()

get_next_event(time=0)

get_pixelbuffer()

get_plain_pixelbuffer()

has_clipboard_text()

has_interrupts_pending()

is_headless()

mouse_button()

mouse_point()

next_keycode()

peek_keycode()

render(force=False)

set_clipboard_text(text)

set_full_screen(flag)

set_interrupt_key(space, encoded_key)

set_title(title)

set_video_mode(w, h, d)

class SDLCursorClass

Bases: object

Cursor modification not yet implemented in RSDL2?

cursor_words_to_bytes(bytenum, words)

In Squeak, only the upper 16bits of the cursor form seem to count (I’m guessing because the code was ported over from 16-bit machines), so this ignores the lower 16-bits of each word.

instance = None

set(data_words, w, h, x, y, mask_words=None)

class SDLDisplay(title, highdpi, software_renderer, altf4quit)

Bases: rsqueakvm.display.NullDisplay

close()

copy_pixels(pixels, start, stop)

create_window_and_renderer(x, y, width, height)

defer_updates(flag)

dequeue_event()

fix_key_code_case()

flip(pixels, x, y, x2, y2)

full_damage()

get_clipboard_text()

get_dropevent(time, c_type, event)

get_dropped_filename()

get_modifier_mask(shift)

get_mouse_event_buttons_and_mods()

get_next_event(time=0)

get_next_key_event(key_event_type, time)

get_next_mouse_event(time)

get_next_mouse_wheel_event(time, event)

handle_keyboard_event(c_type, event)

handle_mouse_button(c_type, event)

handle_mouse_move(c_type, event)

handle_textinput_event(event)

handle_windowevent(c_type, event)

has_clipboard_text()

has_interrupts_pending()

has_queued_events()

insert_padding_event()

is_control_key(key_ord)

is_headless()

is_modifier_key(key_ord)

lock()

mouse_button()

mouse_point()

next_keycode()

peek_keycode()

pump_events()

queue_event(evt)

record_damage(x, y, w, h)

render(force=False)

reset_damage()

set_clipboard_text(text)

set_full_screen(flag)

set_interrupt_key(space, encoded_key)

set_title(title)

set_video_mode(w, h, d)

unlock()

exception SqueakInterrupt

Bases: exceptions.Exception

rsqueakvm.error module

exception BlockCannotReturnError(msg='<no message>')

Bases: rsqueakvm.error.SmalltalkException

exception_type = 'BlockCannotReturnError'

exception CleanExit(msg='')

Bases: rsqueakvm.error.Exit

exception CorruptImageError(msg)

Bases: rsqueakvm.error.Exit

exception Exit(msg)

Bases: exceptions.Exception

exception FatalError(msg='<no message>')

Bases: rsqueakvm.error.SmalltalkException

exception_type = 'FatalError'

exception MissingBytecode(bytecodename)

Bases: rsqueakvm.error.SmalltalkException

Bytecode not implemented yet.

exception_type = 'MissingBytecode'

exception PrimitiveFailedError(msg='', name=None)

Bases: rsqueakvm.error.SmalltalkException

exception_type = 'PrimitiveFailedError'

exception PrimitiveNotYetWrittenError(msg='', name=None)

Bases: rsqueakvm.error.PrimitiveFailedError

exception_type = 'PrimitiveNotYetWrittenError'

exception SimulatedPrimitiveFailedError(msg, w_name, s_class)

Bases: rsqueakvm.error.PrimitiveFailedError

exception_type = 'SimulatedPrimitiveFailedError'

exception SmalltalkException(msg='<no message>')

Bases: exceptions.Exception

Base class for Smalltalk exception hierarchy

exception_type = 'SmalltalkException'

exception UnwrappingError(msg='', name=None)

Bases: rsqueakvm.error.PrimitiveFailedError

exception_type = 'UnwrappingError'

exception WrapperException(msg='', name=None)

Bases: rsqueakvm.error.PrimitiveFailedError

exception_type = 'WrapperException'

exception WrappingError(msg='', name=None)

Bases: rsqueakvm.error.PrimitiveFailedError

exception_type = 'WrappingError'

rsqueakvm.interpreter module

exception ContextSwitchException(s_new_context)

Bases: exceptions.Exception

General Exception that causes the interpreter to leave the current context.

print_trace()

type = 'ContextSwitch'

exception FreshReturn(exception)

Bases: exceptions.Exception

exception IntLocalReturn(intresult)

Bases: rsqueakvm.interpreter.LocalReturn

value(space)

exception IntNonLocalReturn(s_home_context, intvalue)

Bases: rsqueakvm.interpreter.NonLocalReturn

value(space)

class Interpreter(space, image=None, trace_important=False, trace=False, evented=True, interrupts=True)

Bases: object

check_for_interrupts(s_frame)

check_sigusr(s_frame)

create_toplevel_context(w_receiver, selector='', w_selector=None, w_arguments=[])

event_time_now()

Answer the number of milliseconds since the millisecond clock was last reset or rolled over.

getblockmethod(s_context)

getreceiverclass(s_context)

interpret_toplevel(w_frame)

is_tracing()

jit_driver = <rpython.rlib.jit.JitDriver object>

jitted_check_for_interrupt(s_frame)

loop(w_active_context)

loop_bytecodes(s_context, may_context_switch)

perform(w_receiver, selector='', w_selector=None, w_arguments=[])

perform_headless(w_receiver, w_selector, w_arguments)

print_padded(str)

quick_check_for_interrupt(s_frame, dec=1)

resume_driver = <rpython.rlib.jit.JitDriver object>

signal_memory_error(s_frame)

stack_frame(s_frame, s_sender, may_context_switch)

step(context)

time_now()

Answer the UTC microseconds since the Smalltalk epoch. The value is derived from the Posix epoch with a constant offset corresponding to elapsed microseconds between the two epochs according to RFC 868

unwind_context_chain(start_context, target_context, return_value, s_current_context)

unwind_context_chain_local(target_context, return_value, s_current_context)

unwind_primitive_simulation(start_context, error_code)

exception LocalReturn

Bases: rsqueakvm.interpreter.Return

static make(space, w_value)

exception NonLocalReturn(s_home_context)

Bases: rsqueakvm.interpreter.Return

static make(space, s_home_context, w_value)

exception NonVirtualReturn(s_target_context, s_current_context, w_result)

Bases: exceptions.Exception

print_trace()

exception ProcessSwitch(s_new_context, forced=False)

Bases: rsqueakvm.interpreter.ContextSwitchException

This causes the interpreter to switch the executed context. Triggered when switching the process.

type = 'Process Switch'

exception Return

Bases: exceptions.Exception

value(space)

exception ReturnFromTopLevel(object, s_current_frame)

Bases: exceptions.Exception

exception StackOverflow(s_new_context)

Bases: rsqueakvm.interpreter.ContextSwitchException

This causes the current jit-loop to be left, dumping all virtualized objects to the heap. This breaks performance, so it should rarely happen. In case of severe performance problems, execute with -t and check if this occurrs.

type = 'Stack Overflow'

exception WrappedLocalReturn(w_result)

Bases: rsqueakvm.interpreter.LocalReturn

value(space)

exception WrappedNonLocalReturn(s_home_context, w_value)

Bases: rsqueakvm.interpreter.NonLocalReturn

value(space)

get_printable_location(pc, self, method, w_class, blockmethod)

resume_get_printable_location(pc, self, method, w_class)

rsqueakvm.interpreter_bytecodes module

bytecode_implementation(parameter_bytes=0)

initialize_bytecode_names()

initialize_bytecode_table()

initialize_return_bytecodes()

make_call_primitive_bytecode(primitive, selector, argcount, store_pc=False)

make_call_primitive_bytecode_classbased(a_class_name, a_primitive, alternative_class_name, alternative_primitive, selector, argcount)

make_quick_call_primitive_bytecode(primitive_index, argcount)

make_send_selector_bytecode(selector, argcount)

class unrolling_int

Bases: int, rpython.rlib.unroll.SpecTag

rsqueakvm.interpreter_debugging module

activate_debugging()

activating_init(original)

rsqueakvm.key_constants module

rsqueakvm.main module

class Config(space, argv)

Bases: object

ensure_path()

find_executable(executable)

get_exedir()

init_from_arguments()

init_from_ini()

parse_args(argv, skip_bad=False)

sanitize()

active_context(space)

compile_code(interp, w_receiver, code, isclass=False, make_selector=True)

create_context(interp, w_receiver, selector, stringarg)

create_process(interp, s_frame)

entry_point(argv)

execute_context(interp, s_frame)

get_int_parameter(argv, idx, arg)

get_parameter(argv, idx, arg)

make_initial_space()

print_error(str)

result_string(w_result)

safe_entry_point(argv)

rsqueakvm.objspace module

class ForceHeadless(space)

Bases: object

class ObjSpace

Bases: object

display()

executable_path()

get_image_name()

get_special_selector(selector)

get_system_attribute(idx)

init_system_attributes(argv)

make_special_objects()

newClosure(w_outer_ctxt, pc, numArgs, copiedValues)

runtime_setup(interp, exepath, argv, image_name, image_args_idx)

set_system_attribute(idx, value)

set_w_display(w_obj)

set_w_interrupt_semaphore(w_obj)

set_w_jit_hook_receiver(w_obj)

set_w_jit_hook_selector(w_obj)

set_w_low_space_semaphore(w_obj)

set_w_timerSemaphore(w_obj)

smalltalk_at(string)

A helper to find a class by name in modern Squeak images

unwrap_array(w_array)

unwrap_char_as_byte(w_char)

unwrap_float(w_v)

unwrap_int(w_value)

unwrap_int64(w_value)

unwrap_positive_uint(w_value)

unwrap_rbigint(w_value)

unwrap_string(w_object)

unwrap_uint(w_value)

w_display()

w_interrupt_semaphore()

w_jit_hook_receiver()

w_jit_hook_selector()

w_low_space_semaphore()

w_timerSemaphore()

window_title()

wrap_bool(b)

wrap_char(c)

wrap_float(i)

wrap_int(val)

wrap_list(lst_w)

Converts a Python list of wrapped objects into a wrapped smalltalk array

wrap_list_unroll_safe(lst_w)

wrap_rbigint(val)

wrap_rbigint_direct(val, w_class=None)

wrap_smallint_unsafe(val)

wrap_string(string)

wrap_symbol(string)

wrap_wordint_direct(val, w_class)

add_special_properties()

empty_object()

empty_symbol()

rsqueakvm.squeakimage module

class AncientReader(imageReader, version, stream, space)

Bases: rsqueakvm.squeakimage.NonSpurReader

Reader strategy for pre-4.0 images

class BaseReaderStrategy(imageReader, version, stream, space)

Bases: object

assign_prebuilt_constants()

continue_read_header()

fillin_finalize()

fillin_w_object(chunk)

fillin_w_objects()

fillin_weak_w_object(chunk)

fillin_weak_w_objects()

g_class_of(chunk)

get_bytes_of(chunk)

init_compactclassesarray()

init_g_object(chunk)

init_g_objects()

init_w_object(chunk)

init_w_objects()

isbiginteger(g_object)

isfloat(g_object)

islargeinteger(g_object)

issignedinteger(g_object)

isunsignedinteger(g_object)

len_bytes_of(chunk)

log(msg)

lookup_in_assocs_g(array_g, lookup_name)

read_and_initialize()

read_body()

skip_to_body()

smalltalk_g_at(lookup_name)

special_g_object(index)

special_g_object_safe(index)

class GenericObject

Bases: object

Intermediate representation of squeak objects. To establish all pointers as object references, ImageReader creates instances of GenericObject from the image chunks, and uses them as starting point for the actual create of rsqueakvm.model classes.

as_string()

classname()

fillin(space)

fillin_finalize(space)

fillin_weak(space)

format

get_bytes()

get_class()

get_hash()

get_pointers()

get_ruints(required_len=-1)

hash

init_g_class()

init_pointers()

init_w_object(space)

initialize(chunk, reader, space)

initialize_char(untagged_value, reader, space)

initialize_int(value, reader, space)

isinitialized()

isweak()

len_bytes()

size

class ImageChunk(size, format, classid, hash, data=None)

Bases: object

A chunk knows the information from the header, but the body of the object is not decoded yet.

as_g_object(reader, space)

iscompact()

class ImageReader(space, stream, logging_enabled=False)

Bases: object

choose_reader_strategy()

chunklist

chunks

compactclasses

create_image()

decode_pointers(g_object, space, end=-1)

g_class_of(chunk)

intcache

read_all()

read_header()

read_version()

try_read_version()

class ImageVersion(magic, is_big_endian, is_64bit, has_closures, has_floats_reversed, is_spur=False)

Bases: object

configure_stream(stream)

class NonSpurReader(imageReader, version, stream, space)

Bases: rsqueakvm.squeakimage.BaseReaderStrategy

decode_pointers(g_object, space, end=-1)

g_class_of(chunk)

init_compactclassesarray()

from the blue book (CompiledMethod Symbol Array PseudoContext LargePositiveInteger nil MethodDictionary Association Point Rectangle nil TranslatedMethod BlockContext MethodContext nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil )

init_g_objects()

instantiate(g_object)

0 no fields

1 fixed fields only (all containing pointers) 2 indexable fields only (all containing pointers) 3 both fixed and indexable fields (all containing pointers) 4 both fixed and indexable weak fields (all containing pointers).

5 unused 6 indexable word fields only (no pointers) 7 indexable long (64-bit) fields (only in 64-bit images)

8-11 indexable byte fields only (no pointers) (low 2 bits are low 2 bits of size)

12-15 compiled methods:

# of literal oops specified in method header, followed by indexable bytes (same interpretation of low 2 bits as above)

isblockclosure(g_object)

isbytes(g_object)

ischar(g_object)

iscompiledmethod(g_object)

ispointers(g_object)

isweak(g_object)

iswords(g_object)

literal_count_of_method_header(untagged_header)

read_1wordobjectheader()

read_2wordobjectheader()

read_3wordobjectheader()

read_body()

read_object()

class SpurImageWriter(interp, filename)

Bases: object

convert_instspec_to_spur(spec)

fixed_and_indexable_size_for(obj)

frame_size_for(obj)

headers_for_hash_numfields(Class, Hash, size)

image_header_size = 64

insert_class_into_classtable(obj)

len_and_header(obj)

old_to_spur_specs = [0, 1, 2, 3, 4, -1, 10, 9, 16, 16, 16, 16, 24, 24, 24, 24]

padding_for(length)

reserve(obj)

ruint64_tobytes(i)

trace_image(s_frame)

trace_until_finish()

word_size = 4

write_and_trace(obj)

write_bytes_object(obj)

write_compiled_method(obj)

write_file_header(w_special_objects)

write_header(hdrsize, sz, obj, oop)

write_last_bridge()

write_pointers_object(obj)

write_word(word)

write_words_object(obj)

class SpurReader(imageReader, version, stream, space)

Bases: rsqueakvm.squeakimage.BaseReaderStrategy

FREE_OBJECT_CLASS_INDEX_PUN = 0

SLOTS_MASK = -72057594037927936

continue_read_header()

decode_pointers(g_object, space, end=-1)

g_class_of(chunk)

instantiate(g_object)

0 no fields 1 fixed fields only (all containing pointers) 2 indexable fields only (all containing pointers) 3 both fixed and indexable fields (all containing pointers) 4 indexable weak fields (all containing pointers) 5 fixed weak fields (all containing pointers) 6-8 unused

9 indexable 64 bit fields (no pointers) 10-11 indexable 32 bit fields (no pointers) 12-15 indexable 16 bit fields (no pointers) 16-23 indexable byte fields (no pointers)

for the above, the lower bits are the lower bits of the size

24-31 compiled methods:

# of literal oops specified in method header, followed by indexable bytes (same interpretation of low bits as above)

isblockclosure(g_object)

isbytes(g_object)

ischar(g_object)

iscompiledmethod(g_object)

ispointers(g_object)

isweak(g_object)

iswords(g_object)

literal_count_of_method_header(untagged_header)

major_class_index_of(classid)

minor_class_index_of(classid)

read_body()

read_object()

words_for(size)

class SqueakImage(reader)

Bases: object

find_symbol(space, reader, symbol)

special(index)

rsqueakvm.storage module

class AbstractCachingShadow(space, w_self, size, w_class)

Bases: rsqueakvm.storage.AbstractGenericShadow

Abstract shadow maintaining an empty version object for the underlying Smalltalk object. The version object allows jit-related optimizations.

changed()

get_storage(w_self)

repr_classname = 'AbstractCachingShadow'

set_storage(w_self, storage)

version = None

class AbstractGenericShadow(space, w_self, size, w_class)

Bases: rsqueakvm.storage.ListStrategy

This class behaves just like a generic list storage strategy, but allows safe subclassing for more specific, non-singleton strategies.

become(w_other)

get_storage(w_self)

is_shadow()

onesided_become(w_other)

own_fetch(i)

own_size()

own_store(i, val)

promote_if_neccessary()

set_storage(w_self, storage)

w_self()

class AbstractStrategy(space, w_self, size, w_class)

Bases: object

Subclasses of this handle the information contained in Smalltalk objects. The common API allows to store and fetch elements from object slots. Every object has some kind of storage representation attached. Some subclasses (those with *Shadow in their name) contain additional information, required by the VM. These ‘shadows’ not only manage the memory of their Smalltalk objects, but are also the VM-internal representation of these objects.

append(w_self, list_w)

become(w_other)

delete(w_self, start, end)

fetch(w_self, index0)

fetch_all(w_self)

get_storage(w_self)

getclass()

getname()

handles_become()

Only shadows are non-singletons and actually handle become

insert(w_self, index0, list_w)

instantiate(w_self, w_class)

is_shadow()

onesided_become(w_other)

pop(w_self, index0)

promote_if_neccessary()

provides_getname = False

repr_classname = 'AbstractStrategy'

set_storage(w_self, storage)

size(w_self)

slice(w_self, start, end)

store(w_self, index0, value)

store_all(w_self, elements)

strategy_factory()

strategy_switched(w_self)

class AllNilStrategy(space, w_self, size, w_class)

Bases: rsqueakvm.storage.SimpleStorageStrategy

append(w_self, list_w)

delete(w_self, start, end)

fetch(w_self, index0)

fetch_all(w_self)

generalized_strategy_for(value)

get_storage(w_self)

insert(w_self, index0, list_w)

instantiate_type

alias of AllNilStrategy

pop(w_self, index0)

repr_classname = 'AllNilStrategy'

set_storage(w_self, storage)

size(w_self)

slice(w_self, start, end)

store(w_self, index0, value)

store_all(w_self, elements)

strategy_switched(w_self)

value()

class CachedObjectShadow(space, w_self, size, w_class)

Bases: rsqueakvm.storage.AbstractCachingShadow

A shadow which treats its contents as jit constants as long as the object is not modified.

fetch(arg0, arg1)

get_storage(w_self)

instantiate_type

alias of CachedObjectShadow

repr_classname = 'CachedObjectShadow'

set_storage(w_self, storage)

store(w_self, n0, w_value)

class CharacterOrNilStrategy(space, w_self, size, w_class)

Bases: rsqueakvm.storage.SimpleStorageStrategy

append(w_self, list_w)

contained_type

alias of rsqueakvm.model.character.W_Character

delete(w_self, start, end)

fetch(w_self, index0)

fetch_all(w_self)

generalized_strategy_for(value)

get_storage(w_self)

insert(w_self, start, list_w)

instantiate_type

alias of CharacterOrNilStrategy

pop(w_self, index0)

repr_classname = 'CharacterOrNilStrategy'

set_storage(w_self, storage)

size(w_self)

slice(w_self, start, end)

store(w_self, index0, wrapped_value)

store_all(w_self, elements)

strategy_switched(w_self)

unwrap(w_val)

unwrapped_tagged_value()

wrap(val)

wrapped_tagged_value()

class ExtendableStrategyMetaclass

Bases: rpython.tool.pairtype.extendabletype, rpython.rlib.rstrategies.rstrategies.StrategyMetaclass

class FloatOrNilStrategy(space, w_self, size, w_class)

Bases: rsqueakvm.storage.SimpleStorageStrategy

append(w_self, list_w)

contained_type

alias of rsqueakvm.model.numeric.W_Float

delete(w_self, start, end)

fetch(w_self, index0)

fetch_all(w_self)

generalized_strategy_for(value)

get_storage(w_self)

insert(w_self, start, list_w)

instantiate_type

alias of FloatOrNilStrategy

pop(w_self, index0)

repr_classname = 'FloatOrNilStrategy'

set_storage(w_self, storage)

size(w_self)

slice(w_self, start, end)

store(w_self, index0, wrapped_value)

store_all(w_self, elements)

strategy_switched(w_self)

tag_float = 1.7976931348623157e+308

unwrap(w_val)

unwrapped_tagged_value()

wrap(val)

wrapped_tagged_value()

class ListEntry

Bases: object

static build(value, is_instvar)

static is_strong_anyway(value, is_instvar)

class ListStrategy(space, w_self, size, w_class)

Bases: rsqueakvm.storage.SimpleStorageStrategy

append(w_self, list_w)

delete(w_self, start, end)

fetch(w_self, index0)

fetch_all(w_self)

get_storage(w_self)

insert(w_self, start, list_w)

instantiate_type

alias of ListStrategy

pop(w_self, index0)

repr_classname = 'ListStrategy'

set_storage(w_self, storage)

size(w_self)

slice(w_self, start, end)

store(w_self, index0, w_value)

store_all(w_self, elements)

strategy_switched(w_self)

class ObserveeShadow(space, w_self, size, w_class)

Bases: rsqueakvm.storage.AbstractGenericShadow

A generic shadow that notifies a single observer object whenever changes are made.

get_storage(w_self)

instantiate_type

alias of ObserveeShadow

repr_classname = 'ObserveeShadow'

set_observer(observer)

set_storage(w_self, storage)

store(w_self, n0, w_value)

class OptimizedConvertFromAllNilMixin

Bases: object

class ShadowMixin

Bases: object

Shadows are non-singleton strategies. They maintain a backpointer to their shadowed W_PointersObject instance. This is a mixin, because it is used at several places in the class tree.

become(w_other)

is_shadow()

onesided_become(w_other)

own_fetch(i)

own_size()

own_store(i, val)

promote_if_neccessary()

w_self()

class SimpleStorageStrategy(space, w_self, size, w_class)

Bases: rsqueakvm.storage.AbstractStrategy

Singleton strategies handle ‘simple’ object storage in normal objects, without additional VM-internal information. Depending on the data inside an object, different optimizing strategies are used.

check_index_fetch(w_self, index0)

check_index_range(w_self, start, end)

check_index_store(w_self, index0)

default_value()

get_storage(w_self)

repr_classname = 'SimpleStorageStrategy'

set_storage(w_self, storage)

class SmallIntegerOrNilStrategy(space, w_self, size, w_class)

Bases: rsqueakvm.storage.SimpleStorageStrategy

append(w_self, list_w)

contained_type

alias of rsqueakvm.model.numeric.W_SmallInteger

delete(w_self, start, end)

fetch(w_self, index0)

fetch_all(w_self)

generalized_strategy_for(value)

get_storage(w_self)

insert(w_self, start, list_w)

instantiate_type

alias of SmallIntegerOrNilStrategy

pop(w_self, index0)

repr_classname = 'SmallIntegerOrNilStrategy'

set_storage(w_self, storage)

size(w_self)

slice(w_self, start, end)

store(w_self, index0, wrapped_value)

store_all(w_self, elements)

strategy_switched(w_self)

unwrap(w_val)

unwrapped_tagged_value()

wrap(val)

wrapped_tagged_value()

class StrategyFactory(space)

Bases: rpython.rlib.rstrategies.rstrategies.StrategyFactory

empty_storage_type(w_self, size, weak=False)

instantiate_strategy(strategy_type, w_class, w_self=None, initial_size=0)

Return a functional instance of strategy_type. Overwrite this if you need a non-default constructor. The two additional parameters should be ignored for singleton-strategies.

log(w_self, new_strategy, old_strategy=None, new_element=None)

This can be overwritten into a more appropriate call to self.logger.log

set_initial_strategy(w_self, strategy_type, w_class, size, elements=None)

Initialize the strategy and storage fields of w_self. This must be called before switch_strategy or any strategy method can be used. elements is an optional list of values initially stored in w_self. If given, then len(elements) == size must hold.

strategy_singleton_instance(strategy_class, w_class=None)

strategy_singleton_instance_from_cache(strategy_class, w_class)

strategy_type_for(objects, weak=False)

Return the best-fitting strategy to hold all given objects.

switch_strategy(w_self, new_strategy_type, new_element=None)

Switch the strategy of w_self to the new type. new_element can be given as as hint, purely for logging purposes. It should be the object that was added to w_self, causing the strategy switch.

class StrongListEntry(value)

Bases: rsqueakvm.storage.ListEntry

get()

class WeakListEntry(value)

Bases: rsqueakvm.storage.ListEntry

get()

class WeakListStrategy(space, w_self, size, w_class)

Bases: rsqueakvm.storage.SimpleStorageStrategy

append(w_self, list_w)

delete(w_self, start, end)

fetch(w_self, index0)

fetch_all(w_self)

get_storage(w_self)

insert(w_self, start, list_w)

instantiate_type

alias of WeakListStrategy

pop(w_self, index0)

repr_classname = 'WeakListStrategy'

set_storage(w_self, storage)

size(w_self)

slice(w_self, start, end)

store(w_self, index0, wrapped_value)

store_all(w_self, elements)

strategy_switched(w_self)

rsqueakvm.storage_classes module

class ClassShadow(space, w_self, size, w_class)

Bases: rsqueakvm.storage.AbstractCachingShadow

A shadow for Smalltalk objects that are classes (i.e. used as the class of another Smalltalk object).

attach_s_class(s_other)

changed()

detach_s_class(s_other)

flush_method_caches()

get_instance_kind()

get_storage(w_self)

getname()

inherits_from(s_superclass)

initialize_methoddict()

installmethod(w_selector, w_method)

instantiate_type

alias of ClassShadow

instsize()

isvariable()

lookup(arg0)

make_pointers_object(w_cls, size)

name = '??? (incomplete class info)'

new(extrasize=0)

provides_getname = True

repr_classname = 'ClassShadow'

s_methoddict()

s_superclass()

set_storage(w_self, storage)

store(w_self, n0, w_val)

store_pre_spur_classformat(w_self, n0, w_val)

store_s_methoddict(s_methoddict)

store_spur_classformat(w_self, n0, w_val)

store_w_methoddict(w_methoddict)

store_w_name(w_name)

store_w_superclass(w_class)

superclass_changed(version)

w_methoddict()

exception ClassShadowError(msg='<no message>')

Bases: rsqueakvm.error.SmalltalkException

exception_type = 'ClassShadowError'

class MethodDictionaryShadow(space, w_self, size, w_class)

Bases: rsqueakvm.storage.AbstractGenericShadow

become(w_other)

find_selector(w_selector)

flush_method_cache()

get_storage(w_self)

instantiate_type

alias of MethodDictionaryShadow

notify()

repr_classname = 'MethodDictionaryShadow'

set_storage(w_self, storage)

setup_notification()

store(w_self, n0, w_value)

sync_method_cache()

w_values()

rsqueakvm.storage_contexts module

class ContextPartShadow(space, w_self, size, w_class)

Bases: rsqueakvm.storage.AbstractStrategy

This Shadow handles the entire object storage on its own, ignoring the _storage field in W_PointersObject. The w_self parameter in fetch/store/size etc. is ignored, and the own_fetch/own_store/own_size methods from ShadowMixin should be used instead. This shadow can exist without a W_PointersObject. In order to integrate well with the RPython toolchain (virtualizables and jit), this class actually represents one of two classes, determined by the is_block_context switch.

argument_strings()

become(w_other)

static build_block_context(space, s_home, argcnt, pc)

static build_method_context(space, w_method, w_receiver, arguments=[], closure=None, s_fallback=None)

bytecodePrimAdd(interp, current_bytecode)

bytecodePrimAt(interp, current_bytecode)

bytecodePrimAtEnd(interp, current_bytecode)

bytecodePrimAtPut(interp, current_bytecode)

bytecodePrimBitAnd(interp, current_bytecode)

bytecodePrimBitOr(interp, current_bytecode)

bytecodePrimBitShift(interp, current_bytecode)

bytecodePrimBlockCopy(interp, current_bytecode)

bytecodePrimClass(interp, current_bytecode)

bytecodePrimDiv(interp, current_bytecode)

bytecodePrimDivide(interp, current_bytecode)

bytecodePrimDo(interp, current_bytecode)

bytecodePrimEqual(interp, current_bytecode)

bytecodePrimEquivalent(interp, current_bytecode)

bytecodePrimGreaterOrEqual(interp, current_bytecode)

bytecodePrimGreaterThan(interp, current_bytecode)

bytecodePrimLessOrEqual(interp, current_bytecode)

bytecodePrimLessThan(interp, current_bytecode)

bytecodePrimMakePoint(interp, current_bytecode)

bytecodePrimMod(interp, current_bytecode)

bytecodePrimMultiply(interp, current_bytecode)

bytecodePrimNew(interp, current_bytecode)

bytecodePrimNewWithArg(interp, current_bytecode)

bytecodePrimNext(interp, current_bytecode)

bytecodePrimNextPut(interp, current_bytecode)

bytecodePrimNotEqual(interp, current_bytecode)

bytecodePrimPointX(interp, current_bytecode)

bytecodePrimPointY(interp, current_bytecode)

bytecodePrimSize(interp, current_bytecode)

bytecodePrimSubtract(interp, current_bytecode)

bytecodePrimValue(interp, current_bytecode)

bytecodePrimValueWithArg(interp, current_bytecode)

callPrimitiveBytecode(interp, current_bytecode)

debug_bytecode(interp)

doubleExtendedDoAnythingBytecode(interp, current_bytecode)

duplicateTopBytecode(interp, current_bytecode)

enter_virtual_frame(s_sender)

exitFromHeadlessExecution(selector='', w_message=None)

expected_argument_count()

extendedPushBytecode(interp, current_bytecode)

extendedStoreAndPopBytecode(interp, current_bytecode)

extendedStoreBytecode(interp, current_bytecode)

external_stackpointer()

fetch(ignored_w_self, n0)

fetch_block_context(n0)

fetch_bytecode(pc)

fetch_context_part(n0)

fetch_method_context(n0)

fetch_next_bytecode()

full_stacksize()

get_extra_data()

get_fallback()

get_state()

get_storage(w_self)

gettemp(index)

gettemp_block_context(index)

gettemp_method_context(index0)

has_s_sender()

home_is_self()

home_is_self_block_context()

home_is_self_method_context()

init_temps_and_stack()

initialip()

initialize_temps(space, arguments)

instances_array(w_class)

instantiate_type

alias of ContextPartShadow

is_BlockClosure_ensure()

is_closure_context()

is_closure_context_block_context()

is_closure_context_method_context()

is_privileged_index(n0)

is_returned()

is_shadow()

leave_virtual_frame(vref, ref)

longJumpIfFalseBytecode(interp, current_bytecode)

longJumpIfTrueBytecode(interp, current_bytecode)

longUnconditionalJumpBytecode(interp, current_bytecode)

mark_returned()

method_str()

method_str_block_context()

method_str_method_context()

onesided_become(w_other)

own_fetch(i)

own_size()

own_store(i, val)

pc()

peek(idx)

peek_n(n)

pop()

popStackBytecode(interp, current_bytecode)

pop_and_return_n(n)

pop_n(n)

print_padded_stack(method)

print_stack(method=True)

privileged_block_fields = (5,)

privileged_method_fields = (3, 4)

promote_if_neccessary()

pure_is_block_context()

push(w_v)

pushActiveContextBytecode(interp, current_bytecode)

pushClosureCopyCopiedValuesBytecode(interp, current_bytecode)

pushConstantFalseBytecode(interp, current_bytecode)

pushConstantMinusOneBytecode(interp, current_bytecode)

pushConstantNilBytecode(interp, current_bytecode)

pushConstantOneBytecode(interp, current_bytecode)

pushConstantTrueBytecode(interp, current_bytecode)

pushConstantTwoBytecode(interp, current_bytecode)

pushConstantZeroBytecode(interp, current_bytecode)

pushLiteralConstantBytecode(interp, current_bytecode)

pushLiteralVariableBytecode(interp, current_bytecode)

pushNewArrayBytecode(interp, current_bytecode)

pushReceiverBytecode(interp, current_bytecode)

pushReceiverVariableBytecode(interp, current_bytecode)

pushRemoteTempLongBytecode(interp, current_bytecode)

pushTemporaryVariableBytecode(interp, current_bytecode)

push_all(lst)

remove_s_sender()

repr_classname = 'ContextPartShadow'

reset_pc()

reset_stack()

returnFalseBytecode(interp, current_bytecode)

returnNilBytecode(interp, current_bytecode)

returnReceiverBytecode(interp, current_bytecode)

returnTopFromBlockBytecode(interp, current_bytecode)

returnTopFromMethodBytecode(interp, current_bytecode)

returnTrueBytecode(interp, current_bytecode)

s_home()

s_home_block_context()

s_home_method_context()

s_sender()

secondExtendedSendBytecode(interp, current_bytecode)

sendLiteralSelectorBytecode(interp, current_bytecode)

set_state(t)

set_storage(w_self, storage)

set_top(value, position=0)

settemp(index, w_value)

settemp_block_context(index, w_value)

settemp_method_context(index0, w_value)

shortConditionalJumpBytecode(interp, current_bytecode)

shortUnconditionalJumpBytecode(interp, current_bytecode)

short_str()

singleExtendedSendBytecode(interp, current_bytecode)

singleExtendedSuperBytecode(interp, current_bytecode)

size(ignored_w_self)

stack()

stack_get(index0)

stack_ptr()

stack_put(index0, w_val)

stackdepth()

stackend()

stacksize()

stackstart()

stackstart_block_context()

stackstart_method_context()

store(ignored_w_self, n0, w_value)

storeAndPopReceiverVariableBytecode(interp, current_bytecode)

storeAndPopRemoteTempLongBytecode(interp, current_bytecode)

storeAndPopTemporaryVariableBytecode(interp, current_bytecode)

storeRemoteTempLongBytecode(interp, current_bytecode)

store_block_context(n0, w_value)

store_context_part(n0, w_value)

store_expected_argument_count(argc)

store_initialip(initialip)

store_instances_array(w_class, match_w)

store_method_context(n0, w_value)

store_pc(newpc)

store_s_sender(s_sender)

store_stack_ptr(ptr)

store_stackpointer(size)

store_unwrap_pc(w_pc)

store_w_home(w_home)

store_w_method(w_method)

store_w_receiver(w_receiver)

tempsize()

tempsize_block_context()

tempsize_method_context()

top()

unknownBytecode(interp, current_bytecode)

unwrap_store_eargc(w_value)

unwrap_store_initialip(w_value)

unwrap_store_stackpointer(w_sp1)

w_arguments()

w_arguments_block_context()

w_arguments_method_context()

w_method()

w_method_block_context()

w_method_method_context()

w_receiver()

w_receiver_block_context()

w_receiver_method_context()

w_self()

w_sender()

wrap_eargc()

wrap_initialip()

wrap_pc()

wrap_stackpointer()

class ContextState(name)

Bases: object

num()

states = [InactiveContext, ActiveContext, DirtyContext]

class ExtraContextAttributes

Bases: object

fresh_virtualizable(x)

rsqueakvm.wrapper module

class AssociationWrapper(space, w_self)

Bases: rsqueakvm.wrapper.Wrapper

static build(space, w_assoc)

key()

static make_w_assoc(space, w_key, w_value)

store_value(w_new)

value()

class CriticalSectionWrapper(space, w_self)

Bases: rsqueakvm.wrapper.LinkedListWrapper

enter(s_frame)

exit(s_current_frame)

owner()

store_owner(w_new)

test_and_set_owner(s_current_frame)

class FormWrapper(space, w_self)

Bases: rsqueakvm.wrapper.Wrapper

bits()

create_display_bitmap()

depth()

get_display_bitmap()

height()

store_bits(w_new)

store_depth(new)

store_height(new)

store_width(new)

take_over_display()

width()

class LinkWrapper(space, w_self)

Bases: rsqueakvm.wrapper.Wrapper

next_link()

store_next_link(w_new)

class LinkedListWrapper(space, w_self)

Bases: rsqueakvm.wrapper.Wrapper

add_last_link(w_process)

first_link()

is_empty_list()

last_link()

remove(w_link)

remove_first_link_of_list()

store_first_link(w_new)

store_last_link(w_new)

class PointWrapper(space, w_self)

Bases: rsqueakvm.wrapper.Wrapper

store_x(new)

store_y(new)

x()

y()

class ProcessWrapper(space, w_self)

Bases: rsqueakvm.wrapper.LinkWrapper

is_active_process()

my_list()

priority()

put_to_sleep()

resume(s_current_frame, forced=False)

store_my_list(w_new)

store_suspended_context(w_new)

suspend(s_current_frame)

suspended_context()

transfer_to_self_from(s_old_frame, forced=False)

yield_(s_current_frame)

class PromotingAssociationWrapper(space, w_self)

Bases: rsqueakvm.wrapper.AssociationWrapper

value()

class SchedulerWrapper(space, w_self)

Bases: rsqueakvm.wrapper.Wrapper

active_process()

get_process_list(priority)

priority_list()

process_list(priority)

store_active_process(w_new)

wake_highest_priority_process()

class SemaphoreWrapper(space, w_self)

Bases: rsqueakvm.wrapper.LinkedListWrapper

excess_signals()

signal(s_current_frame, forced=False)

store_excess_signals(new)

wait(s_current_frame)

class VarsizedWrapper(space, w_self)

Bases: rsqueakvm.wrapper.Wrapper

at0(i0)

atput0(i0, w_value)

class Wrapper(space, w_self)

Bases: object

read(index0)

write(index0, w_new)

make_getter(index0)

make_getter_setter(index0)

make_int_getter(index0)

make_int_getter_setter(index0)

make_int_setter(index0)

make_setter(index0)

scheduler(space)

unwrapped_wake_highest_priority_process(space, w_lists)

Module contents

Indices and tables

• Index
• Module Index
• Search Page