class Crystal::Repl::ClassVars

Overview

This class keeps track of all the class variables the interpreter will need access to, and allows you to declare and access their position in memory, and whether they have an initializer or not.

The interpreter holds a memory region for class variables, for example like this:

[,,,,,,,,_,......] ^-----^ ^-------^ A.@@a B.@@b

In this memory, for each class variables there are 8 bytes that indicate whether the class variable was initialized or not. If a class variable has no initializer it's considered to be initialized when the program starts (see #each_initialized_index). After these 8 bytes comes the class variable data, aligned to 8 bytes boundaries so that the GC can properly track pointers (that's why we also use 8 bytes for the initialized bit.)

This class and Constants are very similar.

Defined in:

compiler/crystal/interpreter/class_vars.cr

Constant Summary

OFFSET_FROM_INITIALIZED = 8

The offset to use after the index of a class variable to get access to its data.

Constructors

Instance Method Summary

Instance methods inherited from class Reference

==(other : self)
==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==, dup dup, hash(hasher) hash, initialize initialize, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, pretty_print(pp) : Nil pretty_print, same?(other : Reference) : Bool
same?(other : Nil) same?, to_s(io : IO) : Nil to_s

Constructor methods inherited from class Reference

new new, unsafe_construct(address : Pointer, *args, **opts) : self unsafe_construct

Class methods inherited from class Reference

pre_initialize(address : Pointer) pre_initialize

Instance methods inherited from class Object

! : Bool !, !=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as

Class methods inherited from class Object

from_json(string_or_io : String | IO, root : String)
from_json(string_or_io : String | IO) from_json, from_yaml(string_or_io : String | IO) from_yaml

Macros inherited from class Object

class_getter(*names, &block) class_getter, class_getter!(*names) class_getter!, class_getter?(*names, &block) class_getter?, class_property(*names, &block) class_property, class_property!(*names) class_property!, class_property?(*names, &block) class_property?, class_setter(*names) class_setter, def_clone def_clone, def_equals(*fields) def_equals, def_equals_and_hash(*fields) def_equals_and_hash, def_hash(*fields) def_hash, delegate(*methods, to object) delegate, forward_missing_to(delegate) forward_missing_to, getter(*names, &block) getter, getter!(*names) getter!, getter?(*names, &block) getter?, property(*names, &block) property, property!(*names) property!, property?(*names, &block) property?, setter(*names) setter

Constructor Detail

def self.new(context : Context) #

[View source]

Instance Method Detail

def bytesize : Int32 #

Returns the total amount of bytes needed to store all known class variables so far.


[View source]
def declare(owner : Type, name : String, type : Type, compiled_def : CompiledDef | Nil) : Int32 #

Declares a new class variable. Returns the index in memory where it will be stored. compiled_def is the class var's initializer compiled to bytecode, if there was an initializer. Note that at that index the initializer "bit" (8 bytes) should be stored, and only after OFFSET_FROM_INITIALIZER the data should be stored.


[View source]
def each_initialized_index(&) #

Yields each index of every class variable that is trivially "initialized" when the program starts: those that don't have initializers.


[View source]
def fetch?(owner : Type, name : String) : Value | Nil #

Fetches a class variable, if it's there.


[View source]