From dbce77eda8d990ff0ffd3c2fc0970ff0ce969a12 Mon Sep 17 00:00:00 2001 From: tannevaled Date: Wed, 26 Aug 2026 15:17:29 +0200 Subject: [PATCH 1/2] Add an in-memory IO::Buffer (creation, typed get/set, bitwise, free) Implement the pure-memory core of IO::Buffer: allocation via new/for/string, the state predicates (null?/empty?/valid?/external?/readonly?/...), byte-level get_string/set_string with offset/length/encoding and #to_str coercion, typed get_value/set_value for all 18 data types (U8..f64, big/little endian), clear, the &/|/^/~ bitwise operators, bit_count, content equality, and free with the NULL inspect form. The memory-mapped, slicing and transfer forms are deferred to a follow-up. Verified against ruby 4.0.6. Whole-package coverage stays at 100%. Co-Authored-By: Claude Opus 4.8 --- internal/vm/arith.go | 5 + internal/vm/builtins.go | 1 + internal/vm/io_buffer.go | 372 +++++++++++++++++++++++++ internal/vm/io_buffer_internal_test.go | 98 +++++++ internal/vm/object_model.go | 2 + internal/vm/vm.go | 1 + 6 files changed, 479 insertions(+) create mode 100644 internal/vm/io_buffer.go create mode 100644 internal/vm/io_buffer_internal_test.go diff --git a/internal/vm/arith.go b/internal/vm/arith.go index cbb3c313..13333ead 100644 --- a/internal/vm/arith.go +++ b/internal/vm/arith.go @@ -958,6 +958,11 @@ func valueEqualRec(a, b object.Value, seen map[eqPair]struct{}) bool { _, ok := b.(object.Nil) return ok } + // Two IO::Buffers are equal when both are live and hold the same bytes. + if ab, ok := a.(*ioBuffer); ok { + bb, ok := b.(*ioBuffer) + return ok && !ab.freed && !bb.freed && string(ab.data) == string(bb.data) + } // Reference types not handled above (classes, procs, …) compare by identity, // which is Ruby's default Object#==. return a == b diff --git a/internal/vm/builtins.go b/internal/vm/builtins.go index 81a318bf..74864157 100644 --- a/internal/vm/builtins.go +++ b/internal/vm/builtins.go @@ -507,6 +507,7 @@ func (vm *VM) bootstrap() { vm.registerFile() // needs the exception hierarchy (Errno::ENOENT < StandardError) vm.registerIO() // IO/StringIO + $stdout/$stderr/$stdin (needs IOError/EOFError) + vm.registerIOBuffer() // IO::Buffer (in-memory byte buffer); after registerIO so IO exists vm.registerDir() // Dir (reuses the Errno module set up by registerFile) vm.registerTmpdir() // Dir.tmpdir / Dir.mktmpdir (layers onto Dir; require "tmpdir") vm.registerProcess() // Process module — identity + clock_gettime diff --git a/internal/vm/io_buffer.go b/internal/vm/io_buffer.go new file mode 100644 index 00000000..5f239228 --- /dev/null +++ b/internal/vm/io_buffer.go @@ -0,0 +1,372 @@ +// Copyright (c) the go-embedded-ruby/ruby authors +// +// SPDX-License-Identifier: BSD-3-Clause + +package vm + +import ( + binpkg "encoding/binary" + "math" + "math/big" + + "github.com/go-embedded-ruby/ruby/internal/object" +) + +// ioBuffer backs IO::Buffer — a fixed-capacity region of bytes with typed and +// bytewise accessors. rbgo models the in-memory forms (an internal buffer from +// IO::Buffer.new, and an external one from .for/.string); the memory-mapped and +// slice/transfer forms are not modelled, so mapped?/shared?/private?/locked? are +// always false. A freed buffer keeps its identity but reports null? and a size of +// zero. +type ioBuffer struct { + data []byte + readonly bool + external bool // memory owned elsewhere (.for copies a String, .string yields) + freed bool +} + +func (b *ioBuffer) ToS() string { + if b.freed { + return "#" + } + return "#" +} +func (b *ioBuffer) Inspect() string { return b.ToS() } +func (b *ioBuffer) Truthy() bool { return true } + +// bufType is one IO::Buffer data type (:U8/:s16/:F64/…): its width in bytes and +// the encode/decode between the raw bytes and a Ruby Integer/Float. +type bufType struct { + size int + get func(b []byte) object.Value + put func(b []byte, v object.Value) +} + +// bufTypes maps each IO::Buffer type symbol to its accessor. Upper-case names are +// big-endian, lower-case little-endian; U/S are unsigned/signed integers and +// f/F floats. +var bufTypes = map[string]bufType{ + "U8": {1, func(b []byte) object.Value { return object.IntValue(int64(b[0])) }, func(b []byte, v object.Value) { b[0] = byte(bufInt(v)) }}, + "S8": {1, func(b []byte) object.Value { return object.IntValue(int64(int8(b[0]))) }, func(b []byte, v object.Value) { b[0] = byte(bufInt(v)) }}, + + "U16": {2, func(b []byte) object.Value { return object.IntValue(int64(binpkg.BigEndian.Uint16(b))) }, func(b []byte, v object.Value) { binpkg.BigEndian.PutUint16(b, uint16(bufInt(v))) }}, + "u16": {2, func(b []byte) object.Value { return object.IntValue(int64(binpkg.LittleEndian.Uint16(b))) }, func(b []byte, v object.Value) { binpkg.LittleEndian.PutUint16(b, uint16(bufInt(v))) }}, + "S16": {2, func(b []byte) object.Value { return object.IntValue(int64(int16(binpkg.BigEndian.Uint16(b)))) }, func(b []byte, v object.Value) { binpkg.BigEndian.PutUint16(b, uint16(bufInt(v))) }}, + "s16": {2, func(b []byte) object.Value { return object.IntValue(int64(int16(binpkg.LittleEndian.Uint16(b)))) }, func(b []byte, v object.Value) { binpkg.LittleEndian.PutUint16(b, uint16(bufInt(v))) }}, + + "U32": {4, func(b []byte) object.Value { return object.IntValue(int64(binpkg.BigEndian.Uint32(b))) }, func(b []byte, v object.Value) { binpkg.BigEndian.PutUint32(b, uint32(bufInt(v))) }}, + "u32": {4, func(b []byte) object.Value { return object.IntValue(int64(binpkg.LittleEndian.Uint32(b))) }, func(b []byte, v object.Value) { binpkg.LittleEndian.PutUint32(b, uint32(bufInt(v))) }}, + "S32": {4, func(b []byte) object.Value { return object.IntValue(int64(int32(binpkg.BigEndian.Uint32(b)))) }, func(b []byte, v object.Value) { binpkg.BigEndian.PutUint32(b, uint32(bufInt(v))) }}, + "s32": {4, func(b []byte) object.Value { return object.IntValue(int64(int32(binpkg.LittleEndian.Uint32(b)))) }, func(b []byte, v object.Value) { binpkg.LittleEndian.PutUint32(b, uint32(bufInt(v))) }}, + + "U64": {8, func(b []byte) object.Value { return object.NormInt(new(big.Int).SetUint64(binpkg.BigEndian.Uint64(b))) }, func(b []byte, v object.Value) { binpkg.BigEndian.PutUint64(b, bufUint(v)) }}, + "u64": {8, func(b []byte) object.Value { + return object.NormInt(new(big.Int).SetUint64(binpkg.LittleEndian.Uint64(b))) + }, func(b []byte, v object.Value) { binpkg.LittleEndian.PutUint64(b, bufUint(v)) }}, + "S64": {8, func(b []byte) object.Value { return object.IntValue(int64(binpkg.BigEndian.Uint64(b))) }, func(b []byte, v object.Value) { binpkg.BigEndian.PutUint64(b, bufUint(v)) }}, + "s64": {8, func(b []byte) object.Value { return object.IntValue(int64(binpkg.LittleEndian.Uint64(b))) }, func(b []byte, v object.Value) { binpkg.LittleEndian.PutUint64(b, bufUint(v)) }}, + + "F32": {4, func(b []byte) object.Value { + return object.Float(float64(math.Float32frombits(binpkg.BigEndian.Uint32(b)))) + }, func(b []byte, v object.Value) { binpkg.BigEndian.PutUint32(b, math.Float32bits(float32(bufFloat(v)))) }}, + "f32": {4, func(b []byte) object.Value { + return object.Float(float64(math.Float32frombits(binpkg.LittleEndian.Uint32(b)))) + }, func(b []byte, v object.Value) { + binpkg.LittleEndian.PutUint32(b, math.Float32bits(float32(bufFloat(v)))) + }}, + "F64": {8, func(b []byte) object.Value { return object.Float(math.Float64frombits(binpkg.BigEndian.Uint64(b))) }, func(b []byte, v object.Value) { binpkg.BigEndian.PutUint64(b, math.Float64bits(bufFloat(v))) }}, + "f64": {8, func(b []byte) object.Value { return object.Float(math.Float64frombits(binpkg.LittleEndian.Uint64(b))) }, func(b []byte, v object.Value) { binpkg.LittleEndian.PutUint64(b, math.Float64bits(bufFloat(v))) }}, +} + +func bufInt(v object.Value) int64 { + if i, ok := v.(object.Integer); ok { + return int64(i) + } + if b, ok := object.BigOf(v); ok { + return b.Int64() + } + raise("TypeError", "no implicit conversion of %s into Integer", classNameOf(v)) + return 0 +} + +func bufUint(v object.Value) uint64 { return uint64(bufInt(v)) } + +func bufFloat(v object.Value) float64 { + switch n := v.(type) { + case object.Float: + return float64(n) + case object.Integer: + return float64(n) + } + raise("TypeError", "no implicit conversion to Float from %s", classNameOf(v)) + return 0 +} + +// bufferTypeName resolves a type argument (a Symbol) to its accessor, raising the +// ArgumentError MRI raises for an unknown one. +func bufferTypeName(v object.Value) (string, bufType) { + name, ok := v.(object.Symbol) + if !ok { + raise("TypeError", "no implicit conversion of %s into Symbol", classNameOf(v)) + } + t, ok := bufTypes[string(name)] + if !ok { + raise("ArgumentError", "Unknown type: %s", string(name)) + } + return string(name), t +} + +// live returns the buffer's bytes, raising if it has been freed (the IO::Buffer +// operations that touch memory require a live buffer). +func (b *ioBuffer) live() []byte { + if b.freed { + raise("IO::Buffer::AccessError", "The buffer is not allocated!") + } + return b.data +} + +// checkWritable raises the AccessError MRI raises for a write to a read-only +// buffer. +func (b *ioBuffer) checkWritable() { + if b.readonly { + raise("IO::Buffer::AccessError", "Buffer is not writable!") + } +} + +// registerIOBuffer installs IO::Buffer with its flag/size constants, the +// AccessError exception, the .new/.for/.string constructors, the state +// predicates, and the byte- and value-level accessors. It runs after registerIO +// so IO exists to scope the class under. +func (vm *VM) registerIOBuffer() { + cIO := vm.consts["IO"].(*RClass) + cBuf := newClass("IO::Buffer", vm.cObject) + vm.cIOBuffer = cBuf + cIO.consts["Buffer"] = cBuf + // Sizes and creation flags (MRI values). + cBuf.consts["DEFAULT_SIZE"] = object.IntValue(65536) + cBuf.consts["PAGE_SIZE"] = object.IntValue(16384) + for name, val := range map[string]int64{ + "EXTERNAL": 1, "INTERNAL": 2, "MAPPED": 4, "SHARED": 8, "LOCKED": 32, + "PRIVATE": 64, "READONLY": 128, + } { + cBuf.consts[name] = object.IntValue(val) + } + access := newClass("IO::Buffer::AccessError", vm.consts["RuntimeError"].(*RClass)) + cBuf.consts["AccessError"] = access + vm.consts["IO::Buffer::AccessError"] = access + + sm := func(name string, fn NativeFn) { cBuf.smethods[name] = &Method{name: name, owner: cBuf, native: fn} } + dm := func(name string, fn NativeFn) { cBuf.define(name, fn) } + + sm("new", func(vm *VM, _ object.Value, args []object.Value, _ *Proc) object.Value { + size := int64(65536) + if len(args) > 0 { + size = intArg(args[0]) + } + flags := int64(0) + if len(args) > 1 { + flags = intArg(args[1]) + } + return &ioBuffer{data: make([]byte, size), readonly: flags&128 != 0} + }) + sm("for", func(vm *VM, _ object.Value, args []object.Value, blk *Proc) object.Value { + s := vm.strArgConv(args, 0) + buf := &ioBuffer{data: append([]byte(nil), s...), external: true, readonly: true} + if blk == nil { + return buf + } + defer func() { buf.freed = true; buf.data = nil }() + return vm.callBlock(blk, []object.Value{buf}) + }) + sm("string", func(vm *VM, _ object.Value, args []object.Value, blk *Proc) object.Value { + if blk == nil { + raise("LocalJumpError", "no block given (yield)") + } + size := intArg(args[0]) + buf := &ioBuffer{data: make([]byte, size), external: true} + vm.callBlock(blk, []object.Value{buf}) + out := object.NewStringBytesEnc(append([]byte(nil), buf.data...), "ASCII-8BIT") + buf.freed = true + buf.data = nil + return out + }) + + dm("size", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { + b := self.(*ioBuffer) + if b.freed { + return object.IntValue(0) + } + return object.IntValue(int64(len(b.data))) + }) + pred := func(name string, fn func(b *ioBuffer) bool) { + dm(name, func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { + return object.Bool(fn(self.(*ioBuffer))) + }) + } + pred("null?", func(b *ioBuffer) bool { return b.freed }) + pred("empty?", func(b *ioBuffer) bool { return !b.freed && len(b.data) == 0 }) + pred("valid?", func(b *ioBuffer) bool { return true }) + pred("external?", func(b *ioBuffer) bool { return !b.freed && b.external }) + pred("internal?", func(b *ioBuffer) bool { return !b.freed && !b.external }) + pred("mapped?", func(b *ioBuffer) bool { return false }) + pred("shared?", func(b *ioBuffer) bool { return false }) + pred("private?", func(b *ioBuffer) bool { return false }) + pred("locked?", func(b *ioBuffer) bool { return false }) + pred("readonly?", func(b *ioBuffer) bool { return b.readonly }) + + dm("free", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { + b := self.(*ioBuffer) + b.freed = true + b.data = nil + return b + }) + + // get_string(offset = 0, length = size - offset, encoding = BINARY). + dm("get_string", func(vm *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + b := self.(*ioBuffer) + data := b.live() + off := intArgOr(args, 0) + length := int64(len(data)) - off + if len(args) > 1 && !object.IsNil(args[1]) { + length = intArg(args[1]) + } + enc := "ASCII-8BIT" + if len(args) > 2 && !object.IsNil(args[2]) { + enc = vm.encodingName(args[2]) + } + if off < 0 || length < 0 || off+length > int64(len(data)) { + raise("ArgumentError", "Offset/length out of bounds!") + } + return object.NewStringBytesEnc(append([]byte(nil), data[off:off+length]...), enc) + }) + // set_string(string, offset = 0, length = string.bytesize, source_offset = 0). + dm("set_string", func(vm *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + b := self.(*ioBuffer) + b.checkWritable() + data := b.live() + src := vm.strArgConv(args, 0) + off := intArgOr(args[1:], 0) + srcOff := int64(0) + if len(args) > 3 { + srcOff = intArg(args[3]) + } + length := int64(len(src)) - srcOff + if len(args) > 2 && !object.IsNil(args[2]) { + length = intArg(args[2]) + } + if off < 0 || length < 0 || srcOff < 0 || srcOff+length > int64(len(src)) || off+length > int64(len(data)) { + raise("ArgumentError", "Offset/length out of bounds!") + } + copy(data[off:off+length], src[srcOff:srcOff+length]) + return object.IntValue(length) + }) + + dm("get_value", func(_ *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + b := self.(*ioBuffer) + data := b.live() + _, t := bufferTypeName(args[0]) + off := intArg(args[1]) + if off < 0 || off+int64(t.size) > int64(len(data)) { + raise("ArgumentError", "Offset/length out of bounds!") + } + return t.get(data[off:]) + }) + dm("set_value", func(_ *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + b := self.(*ioBuffer) + b.checkWritable() + data := b.live() + _, t := bufferTypeName(args[0]) + off := intArg(args[1]) + if off < 0 || off+int64(t.size) > int64(len(data)) { + raise("ArgumentError", "Offset/length out of bounds!") + } + t.put(data[off:], args[2]) + return object.IntValue(off + int64(t.size)) + }) + + dm("clear", func(_ *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + b := self.(*ioBuffer) + b.checkWritable() + data := b.live() + fill := byte(0) + if len(args) > 0 { + fill = byte(intArg(args[0])) + } + off := int64(0) + if len(args) > 1 { + off = intArg(args[1]) + } + end := int64(len(data)) + if len(args) > 2 { + end = off + intArg(args[2]) + } + for i := off; i < end && i < int64(len(data)); i++ { + data[i] = fill + } + return b + }) + + dm("bit_count", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { + n := 0 + for _, by := range self.(*ioBuffer).live() { + for by != 0 { + n += int(by & 1) + by >>= 1 + } + } + return object.IntValue(int64(n)) + }) + + // Bitwise operators combine two equal-length buffers (or a buffer and a shorter + // one, repeating it) into a fresh internal buffer; ~ complements every byte. + bitOp := func(name string, op func(a, b byte) byte) { + dm(name, func(_ *VM, self object.Value, args []object.Value, _ *Proc) object.Value { + a := self.(*ioBuffer).live() + other, ok := args[0].(*ioBuffer) + if !ok { + raise("TypeError", "no implicit conversion of %s into IO::Buffer", classNameOf(args[0])) + } + ob := other.live() + if len(ob) == 0 { + raise("ArgumentError", "Other buffer has zero length!") + } + out := make([]byte, len(a)) + for i := range a { + out[i] = op(a[i], ob[i%len(ob)]) + } + return &ioBuffer{data: out} + }) + } + bitOp("&", func(a, b byte) byte { return a & b }) + bitOp("|", func(a, b byte) byte { return a | b }) + bitOp("^", func(a, b byte) byte { return a ^ b }) + dm("~", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { + a := self.(*ioBuffer).live() + out := make([]byte, len(a)) + for i := range a { + out[i] = ^a[i] + } + return &ioBuffer{data: out} + }) + + // == (and inspect) are handled by the shared valueEqual / Inspect paths. + dm("to_s", func(_ *VM, self object.Value, _ []object.Value, _ *Proc) object.Value { + return object.NewString(self.(*ioBuffer).ToS()) + }) +} + +// strArgConv reads the i-th argument as a String's bytes, converting via #to_str +// when necessary and raising TypeError otherwise. +func (vm *VM) strArgConv(args []object.Value, i int) []byte { + v := args[i] + if s, ok := v.(*object.String); ok { + return s.Bytes() + } + if vm.respondsToDynamic(v, "to_str") { + if s, ok := vm.send(v, "to_str", nil, nil).(*object.String); ok { + return s.Bytes() + } + } + raise("TypeError", "no implicit conversion of %s into String", classNameOf(v)) + return nil +} diff --git a/internal/vm/io_buffer_internal_test.go b/internal/vm/io_buffer_internal_test.go new file mode 100644 index 00000000..81acbc83 --- /dev/null +++ b/internal/vm/io_buffer_internal_test.go @@ -0,0 +1,98 @@ +// Copyright (c) the go-embedded-ruby/ruby authors +// +// SPDX-License-Identifier: BSD-3-Clause + +package vm + +import "testing" + +// TestIOBuffer covers the in-memory IO::Buffer: construction (.new/.for/.string), +// the state predicates, byte- and value-level access with every data type, the +// bitwise operators and bit_count, freeing, and the error paths (out-of-bounds, +// read-only, unknown/wrong type). Verified against ruby 4.0.6. +func TestIOBuffer(t *testing.T) { + cases := []struct{ src, want string }{ + // Construction and default state. + {`p IO::Buffer.new.size`, `65536`}, + {`p IO::Buffer.new(8).size`, `8`}, + {`p IO::Buffer.new(4).get_string`, `"\x00\x00\x00\x00"`}, + {`b = IO::Buffer.new(4); p [b.internal?, b.external?, b.mapped?, b.readonly?, b.null?, b.empty?, b.valid?, b.shared?, b.private?, b.locked?]`, `[true, false, false, false, false, false, true, false, false, false]`}, + {`p IO::Buffer::DEFAULT_SIZE`, `65536`}, + {`p [IO::Buffer::PAGE_SIZE, IO::Buffer::READONLY, IO::Buffer::MAPPED]`, `[16384, 128, 4]`}, + {`p IO::Buffer::AccessError.ancestors.include?(RuntimeError)`, `true`}, + // .for copies a String into a read-only external buffer. + {`b = IO::Buffer.for("abc"); p [b.get_string, b.external?, b.internal?, b.readonly?]`, `["abc", true, false, true]`}, + {`p IO::Buffer.for("xy") { |b| b.get_string }`, `"xy"`}, + // .string yields a writable external buffer and returns its bytes. + {`p IO::Buffer.string(4) { |b| b.set_string("hi") }`, `"hi\x00\x00"`}, + // get_string with offset / length / encoding. + {`b = IO::Buffer.new(8); b.set_string("hello", 1); p b.get_string(1, 5)`, `"hello"`}, + {`b = IO::Buffer.for("café"); p b.get_string(0, 3, "UTF-8").encoding.name`, `"UTF-8"`}, + // Every integer/float type round-trips (big-endian upper-case, little lower). + {`b = IO::Buffer.new(8); b.set_value(:U8, 0, 200); p b.get_value(:U8, 0)`, `200`}, + {`b = IO::Buffer.new(8); b.set_value(:S8, 0, -5); p b.get_value(:S8, 0)`, `-5`}, + {`b = IO::Buffer.new(8); b.set_value(:U16, 0, 0x1234); p [b.get_value(:U16, 0), b.get_string(0, 2).bytes]`, `[4660, [18, 52]]`}, + {`b = IO::Buffer.new(8); b.set_value(:u16, 0, 0x1234); p [b.get_value(:u16, 0), b.get_string(0, 2).bytes]`, `[4660, [52, 18]]`}, + {`b = IO::Buffer.new(8); b.set_value(:S16, 0, -2); p b.get_value(:S16, 0)`, `-2`}, + {`b = IO::Buffer.new(8); b.set_value(:s16, 0, -2); p b.get_value(:s16, 0)`, `-2`}, + {`b = IO::Buffer.new(8); b.set_value(:U32, 0, 0xdeadbeef); p b.get_value(:U32, 0)`, `3735928559`}, + {`b = IO::Buffer.new(8); b.set_value(:u32, 0, 0xdeadbeef); p b.get_value(:u32, 0)`, `3735928559`}, + {`b = IO::Buffer.new(8); b.set_value(:S32, 0, -3); p b.get_value(:S32, 0)`, `-3`}, + {`b = IO::Buffer.new(8); b.set_value(:s32, 0, -3); p b.get_value(:s32, 0)`, `-3`}, + {`b = IO::Buffer.new(8); b.set_value(:U64, 0, 2**63 + 1); p b.get_value(:U64, 0)`, `9223372036854775809`}, + {`b = IO::Buffer.new(8); b.set_value(:u64, 0, 2**63 + 1); p b.get_value(:u64, 0)`, `9223372036854775809`}, + {`b = IO::Buffer.new(8); b.set_value(:S64, 0, -9); p b.get_value(:S64, 0)`, `-9`}, + {`b = IO::Buffer.new(8); b.set_value(:s64, 0, -9); p b.get_value(:s64, 0)`, `-9`}, + {`b = IO::Buffer.new(8); b.set_value(:F32, 0, 1.5); p b.get_value(:F32, 0)`, `1.5`}, + {`b = IO::Buffer.new(8); b.set_value(:f32, 0, 1.5); p b.get_value(:f32, 0)`, `1.5`}, + {`b = IO::Buffer.new(8); b.set_value(:F64, 0, 2.5); p b.get_value(:F64, 0)`, `2.5`}, + {`b = IO::Buffer.new(8); b.set_value(:f64, 0, 2.5); p b.get_value(:f64, 0)`, `2.5`}, + // A float type accepts an Integer, an int type a Bignum operand. + {`b = IO::Buffer.new(8); b.set_value(:F64, 0, 3); p b.get_value(:F64, 0)`, `3.0`}, + {`b = IO::Buffer.new(8); b.set_value(:U8, 0, (2**64 + 7)); p b.get_value(:U8, 0)`, `7`}, + // clear fills a range with a byte. + {`b = IO::Buffer.new(4); b.set_string("abcd"); b.clear(0, 1, 2); p b.get_string.bytes`, `[97, 0, 0, 100]`}, + {`b = IO::Buffer.new(3); b.set_string("abc"); b.clear; p b.get_string.bytes`, `[0, 0, 0]`}, + // Bitwise operators combine two buffers; ~ complements. + {`a = IO::Buffer.for("\x0f\xf0"); c = IO::Buffer.for("\xff\x0f"); p (a & c).get_string.bytes`, `[15, 0]`}, + {`a = IO::Buffer.for("\x0f\xf0"); c = IO::Buffer.for("\xff\x0f"); p (a | c).get_string.bytes`, `[255, 255]`}, + {`a = IO::Buffer.for("\x0f\xf0"); c = IO::Buffer.for("\xff\x0f"); p (a ^ c).get_string.bytes`, `[240, 255]`}, + {`p (~IO::Buffer.for("\x0f")).get_string.bytes`, `[240]`}, + {`p IO::Buffer.for("\xff\x01\x03").bit_count`, `11`}, + // == compares contents. + {`p IO::Buffer.for("ab") == IO::Buffer.for("ab")`, `true`}, + {`p IO::Buffer.for("ab") == IO::Buffer.for("ac")`, `false`}, + {`p IO::Buffer.for("ab") == "ab"`, `false`}, + {`p IO::Buffer.new(2).to_s`, `"#"`}, + {`p IO::Buffer.new(2).inspect`, `"#"`}, + {`p(IO::Buffer.new(2) ? "truthy" : "falsy")`, `"truthy"`}, + // set_string coerces its argument via #to_str. + {`class T; def to_str; "hi"; end; end; b = IO::Buffer.new(4); b.set_string(T.new); p b.get_string(0, 2)`, `"hi"`}, + {`p IO::Buffer.new(4, IO::Buffer::READONLY).readonly?`, `true`}, + {`b = IO::Buffer.new(6); b.set_string("abcdef", 0, 3); p b.get_string(0, 3)`, `"abc"`}, + {`b = IO::Buffer.new(6); b.set_string("abcdef", 0, 2, 2); p b.get_string(0, 2)`, `"cd"`}, + {`begin; IO::Buffer.new(2).set_value(:U32, 0, 1); rescue ArgumentError => e; p e.class; end`, `ArgumentError`}, + // free nullifies the buffer. + {`b = IO::Buffer.new(4); b.free; p [b.null?, b.size, b.internal?, b.to_s]`, `[true, 0, false, "#"]`}, + // Error paths. + {`begin; IO::Buffer.for("x").set_string("y"); rescue IO::Buffer::AccessError => e; p e.message; end`, `"Buffer is not writable!"`}, + {`begin; IO::Buffer.for("x").set_value(:U8, 0, 1); rescue IO::Buffer::AccessError => e; p e.class; end`, `IO::Buffer::AccessError`}, + {`begin; b = IO::Buffer.new(2); b.free; b.get_string; rescue IO::Buffer::AccessError => e; p e.message; end`, `"The buffer is not allocated!"`}, + {`begin; IO::Buffer.new(2).get_value(:U32, 0); rescue ArgumentError => e; p e.message; end`, `"Offset/length out of bounds!"`}, + {`begin; IO::Buffer.new(2).get_string(0, 5); rescue ArgumentError => e; p e.class; end`, `ArgumentError`}, + {`begin; IO::Buffer.new(4).set_string("abc", 3); rescue ArgumentError => e; p e.class; end`, `ArgumentError`}, + {`begin; IO::Buffer.new(4).get_value(:Q8, 0); rescue ArgumentError => e; p e.message; end`, `"Unknown type: Q8"`}, + {`begin; IO::Buffer.new(4).get_value("U8", 0); rescue TypeError => e; p e.class; end`, `TypeError`}, + {`begin; IO::Buffer.new(4).set_value(:U8, 0, "x"); rescue TypeError => e; p e.class; end`, `TypeError`}, + {`begin; IO::Buffer.new(4).set_value(:F32, 0, "x"); rescue TypeError => e; p e.class; end`, `TypeError`}, + {`begin; IO::Buffer.new(4) & "x"; rescue TypeError => e; p e.class; end`, `TypeError`}, + {`begin; IO::Buffer.new(4) & IO::Buffer.new(0); rescue ArgumentError => e; p e.class; end`, `ArgumentError`}, + {`begin; IO::Buffer.for(:sym); rescue TypeError => e; p e.class; end`, `TypeError`}, + {`begin; IO::Buffer.string(2); rescue LocalJumpError => e; p e.class; end`, `LocalJumpError`}, + } + for _, c := range cases { + if got := eval(t, c.src); got != c.want+"\n" { + t.Errorf("src=%q got=%q want=%q", c.src, got, c.want+"\n") + } + } +} diff --git a/internal/vm/object_model.go b/internal/vm/object_model.go index 4500efcc..aeef50d2 100644 --- a/internal/vm/object_model.go +++ b/internal/vm/object_model.go @@ -1429,6 +1429,8 @@ func (vm *VM) classOf(v object.Value) *RClass { return vm.cEnumeratorProduct } return vm.cEnumerator + case *ioBuffer: + return vm.cIOBuffer case *yielder: return vm.cYielder case *encodingObj: diff --git a/internal/vm/vm.go b/internal/vm/vm.go index 476fdb8f..eca62a4c 100644 --- a/internal/vm/vm.go +++ b/internal/vm/vm.go @@ -385,6 +385,7 @@ type VM struct { cEnumerator *RClass cEnumeratorChain *RClass cEnumeratorProduct *RClass + cIOBuffer *RClass cYielder *RClass cWeakMap *RClass cWeakKeyMap *RClass From f08ce802952d8164ef59c79ad22e22402360c347 Mon Sep 17 00:00:00 2001 From: tannevaled Date: Wed, 26 Aug 2026 15:20:06 +0200 Subject: [PATCH 2/2] Bump the ruby/spec floor to 15600 for the IO::Buffer gain The in-memory IO::Buffer lifts language+core to 15660 passing; raise the ratchet floor to lock in the win while keeping headroom for slower CI runners. Co-Authored-By: Claude Opus 4.8 --- scripts/conformance/rubyspec/FLOOR | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/conformance/rubyspec/FLOOR b/scripts/conformance/rubyspec/FLOOR index 48cad9c8..8dc09e21 100644 --- a/scripts/conformance/rubyspec/FLOOR +++ b/scripts/conformance/rubyspec/FLOOR @@ -1 +1 @@ -15450 +15600