class Crystal::Repl::Constants

Overview

This class keeps track of all the constants 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.

Trivial constants such as A = 1 (int literals, bools, etc.) are not stored in memory. Instead, their value is inlined in the bytecode when they are used.

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

[,,,,,,,,_,......] ^-----^ ^-------^ A B

In this memory, for each constant there are 8 bytes that indicate whether the constant was initialized or not. After these 8 bytes comes the constant 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 ClassVars are very similar.

Defined in:

compiler/crystal/interpreter/constants.cr

Constant Summary

OFFSET_FROM_INITIALIZED = 8

The offset to use after the index of a constant 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 constants so far.


[View source]
def declare(const : Const, compiled_def : CompiledDef) : Int32 #

Declares a new constant. Returns the index in memory where it will be stored. compiled_def is the constant initializer compiled to bytecode. 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 fetch?(const : Const) : Value | Nil #

Fetches a constant, if it's there.


[View source]