rudy4 0.2.0

data/bin/rudy4

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/rudy4"
+
+exit Rudy4::CLI.new(ARGV).run

data/examples/hello_gem/README.md

@@ -0,0 +1,91 @@
+# hello_gem — a shippable D-backed Ruby extension
+
+The rest of the rudy4 repo is *acceptance-test shaped*: `src/dextest.d` and
+everything under `experiments/` exists to exercise the library, not to be
+installed. This directory is the counter-example — a real gem layout you can
+`gem build` / `gem install`, whose native half is written in **D** and
+compiled with **GDC**.
+
+```
+hello_gem/
+  hello_gem.gemspec        gem metadata; declares the extconf.rb extension
+  lib/hello_gem.rb         pure-Ruby half: loads the .so, adds conveniences
+  lib/hello_gem/version.rb
+  ext/hello_gem/hello_gem.d    the native extension (def! + wrapped struct)
+  ext/hello_gem/extconf.rb     writes a Makefile that drives gdc
+  test/smoke.sh                one-shot build + assert script
+```
+
+## What the native half shows
+
+`ext/hello_gem/hello_gem.d` uses the whole rudy4 surface in one file:
+
+| Ruby-side        | D-side                                     |
+|------------------|--------------------------------------------|
+| `greet(name)`    | `def!(greet)` with automatic string conversion |
+| `add(a, b)`      | `def!(add)` with `long` conversion         |
+| `is_even(n)`     | `def!(is_even)` → D `bool` → Ruby `true/false` |
+| `HelloGem.module_greet` | `def!("HelloGem", greet, ...)` namespaced |
+| `HelloVec2#[]`, `#[]=`, `#norm2` | `RudyTypedData!(Vec2)` + raw `extern(C)` |
+| `HelloVec2#dup/#clone/#==/#hash/#inspect` | `RudyObjectProtocol!(Vec2)` |
+| `vec.freeze` guards `vec[0] = …` | `rb_check_frozen(self)` in the mutator |
+
+## Building and running
+
+From this directory:
+
+```sh
+# 1. compile the extension in place (leaves hello_gem_ext.so in lib/)
+cd ext/hello_gem
+ruby extconf.rb
+make
+make install RUBYARCHDIR=../../lib      # or let it default
+
+# 2. try it
+cd ../..
+ruby -Ilib -e 'require "hello_gem"; p greet("world"); v = HelloVec2.new(3, 4); p v.norm2; p v == v.dup'
+```
+
+Then the gem itself:
+
+```sh
+gem build hello_gem.gemspec
+gem install hello_gem-0.1.0.gem
+ruby -e 'require "hello_gem"; p add(2, 3)'
+```
+
+`test/smoke.sh` does the build-and-assert loop in one shot (17 assertions).
+
+### Installing outside the repo
+
+`gem build` / `gem install` compiles the extension in a temporary copy of
+the gem, so the `../../../src/rudy` auto-detection no longer applies. When
+installing from an unpacked gem (not from this checkout), point `RUDY4_ROOT`
+at a rudy4 checkout:
+
+```sh
+RUDY4_ROOT=/path/to/rudy4 GDC=gdc-14 gem install ./hello_gem-0.1.0.gem
+```
+
+A published gem would instead vendor `src/rudy` inside the gem (or depend on
+a `rudy4` gem that ships it), removing the need for `RUDY4_ROOT` entirely.
+
+## Requirements
+
+- Ruby 4.0 (the suite targets the 4.0 C API),
+- GDC 14 (`gdc-14`),
+- the rudy4 library sources, found at `../../../src/rudy` (this checkout) or
+  wherever `$RUDY4_ROOT` points.
+
+## How the extconf.rb trick works
+
+RubyGems' native-extension protocol is language-agnostic: it runs your
+`extconf.rb`, expects it to emit a `Makefile` with `all` and `install`
+targets, then runs them. `extconf.rb` here interrogates `RbConfig` for the
+Ruby header dirs and `libruby` exactly like `mkmf` would, then emits a
+Makefile whose `CC` is `gdc-14` and that compiles the `.d` sources alongside
+`hello_gem.d`. Ruby never learns the language was D.
+
+A gem published like this would vendor the rudy4 `src/rudy` tree into the
+gem (or depend on a `rudy4` gem that ships it); the in-repo default just
+walks four directories up to this checkout.

data/examples/hello_gem/ext/hello_gem/extconf.rb

@@ -0,0 +1,75 @@
+# extconf.rb — stand-in for mkmf, for an extension whose "C compiler" is GDC.
+#
+# RubyGems knows how to run an extconf.rb + make + make install cycle for an
+# extension; it does not care that the language is D. This file writes a
+# Makefile that compiles `hello_gem.d` together with the rudy4 library into
+# `hello_gem.so`, then exposes an `install` target that RubyGems will call.
+#
+# The rudy4 D library sources are found, in order, from:
+#   1. $RUDY4_ROOT/src/rudy            (explicit override)
+#   2. ../../../src/rudy               (in-repo development, this checkout)
+# A published, standalone gem would instead vendor these sources into the
+# gem (or declare a dependency on a `rudy4` gem that ships them).
+
+require "rbconfig"
+require "pathname"
+
+RUDY4_ROOT =
+  if ENV["RUDY4_ROOT"] && !ENV["RUDY4_ROOT"].empty?
+    Pathname.new(ENV["RUDY4_ROOT"])
+  else
+    # ext/hello_gem/extconf.rb -> repo root is four levels up
+    Pathname.new(__dir__).join("..", "..", "..", "..").expand_path
+  end
+
+RUDY_SRC = RUDY4_ROOT.join("src", "rudy").expand_path
+unless RUDY_SRC.join("defs.d").file?
+  abort <<~MSG
+    rudy4 library sources not found at #{RUDY_SRC}.
+    Set RUDY4_ROOT to a rudy4 checkout, or run extconf.rb from inside one.
+  MSG
+end
+
+RUDY_D_SOURCES = Dir.glob(RUDY_SRC.join("**", "*.d")).sort
+
+# Where RubyGems wants the built extension installed. `make install` below
+# honours it; a plain `ruby extconf.rb && make` leaves the .so next to the
+# sources (lib/) so it can be required in place.
+RUBYARCHDIR = ENV["RUBYARCHDIR"] || File.expand_path("../../lib", __dir__)
+
+hdr      = RbConfig::CONFIG["rubyhdrdir"]
+archhdr  = RbConfig::CONFIG["rubyarchhdrdir"]
+libarg   = RbConfig::CONFIG["LIBRUBYARG_SHARED"]
+libdir   = RbConfig::CONFIG["libdir"]
+dllib    = RbConfig::CONFIG["DLEXT"] # "so"
+
+gdc = ENV["GDC"] || "gdc-14"
+
+File.write("Makefile", <<~MAKE)
+  # Generated by extconf.rb — do not edit.
+  GDC         = #{gdc}
+  RUBYHDR     = #{hdr}
+  RUBYARCHHDR = #{archhdr}
+  LIBRUBYARG  = #{libarg}
+  LIBRUBY_DIR = #{libdir}
+  RUBYARCHDIR = #{RUBYARCHDIR}
+
+  DFLAGS = -fPIC -I#{RUDY4_ROOT.join("src")} -I$(RUBYHDR) -I$(RUBYARCHHDR) -fpreview=dip1008 -Wno-deprecated
+
+  RUDY_SOURCES = #{RUDY_D_SOURCES.join(" ")}
+
+  TARGET = hello_gem_ext.#{dllib}
+
+  all: $(TARGET)
+
+  $(TARGET): hello_gem.d $(RUDY_SOURCES)
+  \t$(GDC) -shared -o $@ $(DFLAGS) $(RUDY_SOURCES) hello_gem.d \\
+  \t  -L$(LIBRUBY_DIR) $(LIBRUBYARG) -lm
+
+  install: $(TARGET)
+  \tmkdir -p $(RUBYARCHDIR)
+  \tcp $(TARGET) $(RUBYARCHDIR)/
+
+  clean:
+  \trm -f $(TARGET)
+MAKE

data/examples/hello_gem/ext/hello_gem/hello_gem.d

@@ -0,0 +1,122 @@
+/// hello_gem_ext — the native half of the `hello_gem` gem (a shippable
+/// D-backed Ruby extension).
+///
+/// Demonstrates the whole rudy4 surface in one installable gem:
+///   * `def!` for global functions and instance methods, with automatic
+///     D<->Ruby conversion,
+///   * `RudyTypedData` + `RudyObjectProtocol` to expose a real D struct
+///     (a `Vec2`) as a first-class Ruby object (allocate/dup/clone/==/hash/
+///     inspect/freeze),
+///   * raw `extern(C)` C-API bodies for the methods that need them.
+///
+/// Build with the gem's extconf.rb (see ../extconf.rb), which drives gdc.
+
+module hello_gem;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.typeddata;
+import rudy.objproto;
+import rudy.defs;
+
+import core.runtime : rt_init;
+import std.string : format;
+
+// ---------------------------------------------------------------------
+// def!'d plain functions — conversion is automatic.
+// ---------------------------------------------------------------------
+
+string greet(string name) { return "hello, " ~ name ~ "!"; }
+
+long add(long a, long b) { return a + b; }
+
+bool is_even(long n) { return (n % 2) == 0; }
+
+string describe(string what, int count)
+{
+    import std.conv : to;
+    return what ~ " x" ~ count.to!string;
+}
+
+// ---------------------------------------------------------------------
+// A wrapped D struct: Vec2 as a Ruby object.
+// ---------------------------------------------------------------------
+
+struct Vec2
+{
+    double x, y;
+}
+
+mixin RudyTypedData!(Vec2, "hello_vec2");
+
+private string vec2_inspect(ref const Vec2 v)
+{
+    return format("x=%g y=%g", v.x, v.y);
+}
+
+// Companion protocol: allocate / dup / clone / == / eql? / hash / inspect.
+mixin RudyObjectProtocol!(Vec2, "hello_vec2",
+                          null, null, null,
+                          vec2_inspect);
+
+extern (C) VALUE vec2_initialize(VALUE self, VALUE x, VALUE y)
+{
+    Vec2* p = hello_vec2_get(self);
+    p.x = d_type!double(x);
+    p.y = d_type!double(y);
+    return self;
+}
+
+extern (C) VALUE vec2_get_component(VALUE self, VALUE i)
+{
+    Vec2* p = hello_vec2_get(self);
+    final switch (d_type!long(i)) {
+        case 0: return to_ruby_value(p.x);
+        case 1: return to_ruby_value(p.y);
+    }
+}
+
+extern (C) VALUE vec2_set_component(VALUE self, VALUE i, VALUE v)
+{
+    rb_check_frozen(self);          // honour Ruby's freeze contract
+    Vec2* p = hello_vec2_get(self);
+    switch (d_type!long(i)) {
+        case 0: p.x = d_type!double(v); break;
+        default: p.y = d_type!double(v); break;
+    }
+    return v;
+}
+
+extern (C) VALUE vec2_norm2(VALUE self)
+{
+    Vec2* p = hello_vec2_get(self);
+    return to_ruby_value(p.x * p.x + p.y * p.y);
+}
+
+// ---------------------------------------------------------------------
+// Entry point — Ruby calls this once when the extension is required.
+// ---------------------------------------------------------------------
+
+pragma(mangle, "Init_hello_gem_ext")
+extern (C) void Init_hello_gem_ext()
+{
+    rt_init();
+
+    // global functions (on Object)
+    def!(greet);
+    def!(add);
+    def!(is_even);
+    def!(describe);
+
+    // a namespaced module function
+    VALUE HelloGem = rb_define_module("HelloGem");
+    def!("HelloGem", greet, "module_greet");
+
+    // the wrapped struct as a top-level class
+    VALUE c = rb_define_class("HelloVec2", rb_cObject);
+    hello_vec2_proto_install(c);
+    rb_define_method(c, "initialize", cast(AnyMethod) &vec2_initialize, 2);
+    rb_define_method(c, "[]", cast(AnyMethod) &vec2_get_component, 1);
+    rb_define_method(c, "[]=", cast(AnyMethod) &vec2_set_component, 2);
+    rb_define_method(c, "norm2", cast(AnyMethod) &vec2_norm2, 0);
+}

data/examples/hello_gem/hello_gem.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "lib/hello_gem/version"
+
+Gem::Specification.new do |spec|
+  spec.name    = "hello_gem"
+  spec.version = HelloGem::VERSION
+  spec.authors = ["Tomasz Stachewicz"]
+  spec.email   = ["tomasz.stachewicz@gmail.com"]
+
+  spec.summary     = "A D-backed Ruby extension, packaged as a gem"
+  spec.description = <<~DESC
+    Reference example for rudy4: the native half of this gem is written in D
+    (compiled by GDC) and exposes global functions plus a wrapped D struct to
+    Ruby. Shows the gem-shaped layout (gemspec + ext/ + lib/) that a real
+    rudy4-based extension would ship with.
+  DESC
+  spec.homepage = "https://github.com/tomash/rudy4"
+  spec.license  = "MIT"
+
+  spec.required_ruby_version = ">= 4.0"
+
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "ext/**/*.d",
+    "ext/**/*.rb",
+    "README.md",
+  ]
+  spec.require_paths = ["lib"]
+
+  # Builds hello_gem.so from D sources via GDC.
+  spec.extensions = ["ext/hello_gem/extconf.rb"]
+
+  spec.metadata["rubygems_mfa_required"] = "true"
+end

data/examples/hello_gem/lib/hello_gem/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HelloGem
+  VERSION = "0.1.0"
+end

data/examples/hello_gem/lib/hello_gem.rb

@@ -0,0 +1,32 @@
+# lib/hello_gem.rb
+#
+# Pure-Ruby half of the gem. Its job: load the compiled native extension and
+# provide the conventional `HelloGem` namespace. Native code is written in D
+# (see ext/hello_gem/hello_gem.d) and compiled by extconf.rb via GDC.
+
+require "hello_gem/version"
+
+# `hello_gem_ext.so` is installed into this directory by the gem's install
+# step. (The native artifact is suffixed `_ext` so it does not collide with
+# this file, `hello_gem.rb`.)
+begin
+  require "hello_gem_ext"
+rescue LoadError => e
+  raise LoadError, <<~MSG
+    Could not load the native hello_gem extension (#{e.message}).
+    Build it first:
+      cd ext/hello_gem && ruby extconf.rb && make && make install
+  MSG
+end
+
+module HelloGem
+  # A small pure-Ruby convenience on top of the native Vec2: a unit vector.
+  # `HelloVec2` itself comes from D land.
+  def self.unit(x, y)
+    v = HelloVec2.new(x, y)
+    n = Math.sqrt(v.norm2)
+    return v if n.zero?
+
+    HelloVec2.new(x / n, y / n)
+  end
+end

data/examples/hello_gem/test/smoke.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+# smoke.sh — build the hello_gem extension from D sources and assert it works.
+#
+# One-shot end-to-end check for the packaging example:
+#   extconf.rb -> make -> require -> exercise def! functions + the wrapped
+#   struct's object protocol. Exits non-zero on the first failed assertion.
+#
+# Usage: bash test/smoke.sh [ruby-binary]      (default: the rudy4 asdf ruby)
+
+set -euo pipefail
+
+HERE="$(cd "$(dirname "$0")/.." && pwd)"
+RUBY="${1:-$HOME/.asdf/installs/ruby/4.0.7/bin/ruby}"
+GDC="${GDC:-gdc-14}"
+
+echo "== ruby: $($RUBY -v)"
+echo "== gdc:  $($GDC --version | head -1)"
+
+cd "$HERE/ext/hello_gem"
+rm -f hello_gem_ext.so
+GDC="$GDC" "$RUBY" extconf.rb
+make
+make install RUBYARCHDIR="$HERE/lib"
+
+echo "== running smoke assertions"
+cd "$HERE"
+"$RUBY" -Ilib - <<'RUBY'
+require "hello_gem"
+
+checks = 0
+assert = lambda do |cond, msg|
+  checks += 1
+  raise "FAIL: #{msg}" unless cond
+end
+
+# def! global functions + automatic conversion
+assert.(greet("world") == "hello, world!", "greet/string conversion")
+assert.(add(2, 3) == 5, "add/long conversion")
+assert.(is_even(4) == true, "is_even true")
+assert.(is_even(5) == false, "is_even false")
+assert.(describe("cat", 3) == "cat x3", "multi-arg conversion")
+
+# namespaced module function
+assert.(HelloGem.module_greet("D") == "hello, D!", "module function")
+
+# wrapped D struct: allocate + initialize
+v = HelloVec2.new(3.0, 4.0)
+assert.(v[0] == 3.0 && v[1] == 4.0, "component get")
+assert.(v.norm2 == 25.0, "norm2")
+
+# object protocol
+assert.(v == HelloVec2.new(3.0, 4.0), "value equality")
+assert.(v.eql?(HelloVec2.new(3.0, 4.0)), "eql?")
+assert.(v.hash == HelloVec2.new(3.0, 4.0).hash, "hash contract")
+assert.(v.dup[0] == 3.0, "dup copies struct")
+assert.(v.inspect.include?("x=3"), "inspect via hook")
+h = { HelloVec2.new(1.0, 1.0) => :found }
+assert.(h[HelloVec2.new(1.0, 1.0)] == :found, "hash keying")
+
+# freeze enforcement (rb_check_frozen in the mutator)
+f = HelloVec2.new(1.0, 2.0)
+f.freeze
+begin
+  f[0] = 9.0
+  raise "FAIL: frozen mutator did not raise"
+rescue FrozenError
+  checks += 1
+end
+
+# mutating a copy does not touch the original
+a = HelloVec2.new(1.0, 1.0)
+b = a.dup
+b[0] = 7.0
+assert.(a[0] == 1.0 && b[0] == 7.0, "dup independence")
+
+# pure-Ruby convenience on top of the native struct
+u = HelloGem.unit(0.0, 5.0)
+assert.((u.norm2 - 1.0).abs < 1e-9, "HelloGem.unit")
+
+puts "hello_gem smoke: #{checks} assertions OK"
+RUBY

data/experiments/exp_compact.d

@@ -0,0 +1,178 @@
+/// EXPERIMENT 7 — GC compaction vs wrapped structs and registered globals.
+///
+/// Torture elements:
+/// - BoxCell is a wrapped D struct that HOLDS live Ruby VALUEs (a String
+///   and an Array). The RudyTypedData mixin currently has NO dmark slot
+///   exposed — so if Ruby's GC can't see the referents through the box,
+///   they can be collected while the box survives => dangling VALUE inside
+///   a live Ruby object. Then GC.compact moves survivors; stale VALUEs in
+///   registered globals (and inside boxes without dcompact) point into
+///   unmoved memory.
+/// - globals: raw VALUEs registered via rb_gc_register_address. After
+///   GC.compact, Ruby says "update your references" (rb_gc_location).
+///   A D extension that ignores that keeps pre-compaction VALUEs.
+///
+///   Ruby API:
+///     DExpCompact.make_box(str, arr)   -> DBox instance (TypedData wrap)
+///     DExpCompact.read_box(obj)        -> [str, arr] back out of the box
+///     DExpCompact.stash(str)           -> store in registered global, returns id
+///     DExpCompact.peek_stashed(id)     -> read back (may be stale VALUE)
+///     DExpCompact.refresh(id)          -> rb_gc_location refresh, returns new id
+///
+/// What can go wrong (the point):
+/// - box holds VALUEs, nothing marks them -> collected while box alive
+///   (RUBY_T_NONE garbage / segfault on read_box)
+/// - GC.compact moves referents -> box's stored VALUEs / registered
+///   globals go stale; rb_gc_location is required to fix them
+
+module exp_compact;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.typeddata;
+
+import core.runtime : rt_init;
+import core.stdc.stdlib : malloc, free;
+
+private:
+
+// A wrapped struct that holds LIVE Ruby VALUEs — the dangerous case.
+struct BoxCell
+{
+    VALUE str;     // a live Ruby String
+    VALUE arr;     // a live Ruby Array
+    ulong serial;
+}
+
+// Two descriptors for the same struct: one WITHOUT mark/compact (the old
+// library behavior — kept deliberately as the negative control) and one
+// WITH (finding #11 fix). The Ruby test creates both and shows that the
+// unguarded box corrupts while the guarded one survives.
+mixin RudyTypedData!(BoxCell, "boxcell");                       // no mark (control)
+
+extern (C) void boxcell_mark(void* p)
+{
+    auto c = cast(BoxCell*) p;
+    rb_gc_mark_movable(c.str);
+    rb_gc_mark_movable(c.arr);
+}
+
+extern (C) void boxcell_compact(void* p)
+{
+    auto c = cast(BoxCell*) p;
+    c.str = rb_gc_location(c.str);
+    c.arr = rb_gc_location(c.arr);
+}
+
+mixin RudyTypedData!(BoxCell, "gboxcell", &rudy_typed_free,
+                    &boxcell_mark, &boxcell_compact);           // guarded
+
+__gshared VALUE boxcell_klass;
+__gshared VALUE gboxcell_klass;
+
+// ------------------------------------------------- registered globals
+
+// stash slots for the rb_gc_register_address part of the torture.
+// We keep a fixed pool so ids are stable and Ruby side can request refresh.
+enum STASH_SIZE = 16;
+__gshared VALUE[STASH_SIZE] stash;
+__gshared bool[STASH_SIZE] stash_used;
+
+extern (C) void stash_mark_all() {}   // placeholder (unused)
+
+// ---------------------------------------------------------- Ruby API
+
+extern (C) VALUE make_box(VALUE self, VALUE str, VALUE arr)
+{
+    auto cell = cast(BoxCell*) malloc(BoxCell.sizeof);
+    cell.str = str;
+    cell.arr = arr;
+    cell.serial = 0;
+    return boxcell_wrap(boxcell_klass, cell);
+}
+
+extern (C) VALUE make_gbox(VALUE self, VALUE str, VALUE arr)
+{
+    auto cell = cast(BoxCell*) malloc(BoxCell.sizeof);
+    cell.str = str;
+    cell.arr = arr;
+    cell.serial = 0;
+    return gboxcell_wrap(gboxcell_klass, cell);
+}
+
+extern (C) VALUE read_box(VALUE self, VALUE obj)
+{
+    // both classes share the struct layout and the same wrap_struct_name
+    // would collide — gboxcell has its own name so rb_check_typeddata
+    // distinguishes. We branch on the class of obj.
+    BoxCell* c;
+    if (obj_class_matches(obj, gboxcell_klass))
+        c = gboxcell_get(obj);
+    else
+        c = boxcell_get(obj);
+    VALUE[2] pair;
+    pair[0] = c.str;
+    pair[1] = c.arr;
+    return rb_ary_new_from_values(2, pair.ptr);
+}
+
+private bool obj_class_matches(VALUE obj, VALUE klass)
+{
+    return rb_obj_class(obj) == klass;
+}
+
+extern (C) VALUE stash_value(VALUE self, VALUE str)
+{
+    int id = -1;
+    foreach (i; 0 .. STASH_SIZE)
+        if (!stash_used[i]) { id = cast(int) i; break; }
+    if (id < 0) rb_raise(rb_eRuntimeError, "no free stash slot\0".ptr);
+    stash[id] = str;
+    stash_used[id] = true;
+    return to_ruby_value!int(id);
+}
+
+extern (C) VALUE peek_stashed(VALUE self, VALUE id_v)
+{
+    int id = d_type!int(id_v);
+    if (id < 0 || id >= STASH_SIZE || !stash_used[id])
+        return Qnil_;
+    return stash[id];
+}
+
+extern (C) VALUE refresh(VALUE self, VALUE id_v)
+{
+    int id = d_type!int(id_v);
+    if (id < 0 || id >= STASH_SIZE || !stash_used[id])
+        return Qnil_;
+    VALUE refreshed = rb_gc_location(stash[id]);
+    stash[id] = refreshed;
+    return refreshed;
+}
+
+// ---------------------------------------------------------- init
+
+pragma(mangle, "Init_exp_compact")
+extern (C) void Init_exp_compact()
+{
+    rt_init();   // torture finding #5 (exp_gcstorm): dlopened D .so needs it
+
+    // register the stash array with Ruby's GC — Ruby now knows these
+    // slots hold VALUEs (it roots and updates-eligibles them at compaction
+    // time via rb_gc_location — which WE must call to fetch new values).
+    foreach (i; 0 .. STASH_SIZE)
+        rb_gc_register_address(&stash[i]);
+
+    VALUE c = rb_define_class("DBox", rb_cObject);
+    boxcell_klass = c;
+    VALUE gc_ = rb_define_class("DGuardedBox", rb_cObject);
+    gboxcell_klass = gc_;
+
+    VALUE m = rb_define_module("DExpCompact");
+    rb_define_module_function(m, "make_box", cast(AnyMethod) &make_box, 2);
+    rb_define_module_function(m, "make_gbox", cast(AnyMethod) &make_gbox, 2);
+    rb_define_module_function(m, "read_box", cast(AnyMethod) &read_box, 1);
+    rb_define_module_function(m, "stash", cast(AnyMethod) &stash_value, 1);
+    rb_define_module_function(m, "peek_stashed", cast(AnyMethod) &peek_stashed, 1);
+    rb_define_module_function(m, "refresh", cast(AnyMethod) &refresh, 1);
+}