rubyduino 0.1.1

data/vendor/spinel/test/ensure_runs_on_return_nested.rb.expected

@@ -0,0 +1,3 @@
+inner=10
+outer=2
+log=io

data/vendor/spinel/test/enumerable.rb

@@ -0,0 +1,19 @@
+class NumberList
+  include Enumerable
+  def initialize
+    @data = (1..5).to_a
+  end
+  def each
+    @data.each do |x|
+      yield x
+    end
+  end
+end
+
+list = NumberList.new
+total = 0
+list.each do |x|
+  total += x
+end
+puts total  # 15
+puts "done"

data/vendor/spinel/test/enumerable.rb.expected

@@ -0,0 +1,2 @@
+15
+done

data/vendor/spinel/test/env_string_inference.rb

@@ -0,0 +1,37 @@
+# Issue #129: ENV["X"] was inferred as int at every call site even though
+# the dispatch correctly emits sp_str_dup_external(getenv(...)) returning
+# const char *. Fix is in `infer_operator_type`'s `[]` branch (early
+# ENV check) plus `compile_eq` for the `string == string` case (NULL-safe
+# via the new sp_str_eq runtime helper, since strcmp(NULL, ...) is UB and
+# segfaults on `"1" == ENV["UNSET"]`).
+#
+# Tests pin the four shapes from the issue body, plus the reverse-order
+# segfault case Sam called out.
+
+# Use a variable that's vanishingly unlikely to be set in any environment.
+UNSET = "SPINEL_TEST_VAR_THAT_DOES_NOT_EXIST_129"
+
+# 1. nil? on unset → true. Was: constant-folded to false at codegen.
+puts ENV[UNSET].nil?                      # true
+
+# 2. local capture + nil? roundtrip on unset → true.
+s = ENV[UNSET]
+puts s.nil?                                # true
+
+# 3. inline puts on unset → blank line. Was: printed pointer-as-int.
+puts ENV[UNSET]                            # (blank)
+
+# 4. equality on unset → false. Was: pointer-int compare, also always false
+#    but for the wrong reason (and would crash if the integer happened to
+#    be a valid pointer prefix).
+puts ENV[UNSET] == "1"                     # false
+
+# 5. Reverse-order equality on unset → false. Was: segfault. lt=string,
+#    at=int → fell through to strcmp("1", <int>), dereferencing the int
+#    as a pointer.
+puts "1" == ENV[UNSET]                     # false
+
+# 6. nil? on a likely-set var (PATH is universal on POSIX). The bootstrap
+#    needs PATH to find cc; if this test runs at all PATH is set. Pins the
+#    "set var" branch of the same fix.
+puts ENV["PATH"].nil?                      # false

data/vendor/spinel/test/env_string_inference.rb.expected

@@ -0,0 +1,6 @@
+true
+true
+
+false
+false
+false

data/vendor/spinel/test/exception_object_methods.rb

@@ -0,0 +1,99 @@
+# Exception variable methods bound by `rescue => e`:
+# .message returns the message string
+# .class returns the class name string
+# .to_s returns the message
+# .inspect returns "#<ClassName: message>"
+# Bare raise re-raises the original class+message rather than
+# fabricating a fresh RuntimeError.
+
+# .message
+begin
+  raise "boom"
+rescue => e
+  puts "msg: #{e.message}"
+end
+
+# .class on default raise (RuntimeError)
+begin
+  raise "boom2"
+rescue => e
+  puts "cls: #{e.class}"
+end
+
+# .class with explicit class
+begin
+  raise ArgumentError, "bad"
+rescue => e
+  puts "cls2: #{e.class}"
+  puts "msg2: #{e.message}"
+end
+
+# .to_s and .inspect
+begin
+  raise TypeError, "wrong"
+rescue => e
+  puts "tos: #{e.to_s}"
+  puts "ins: #{e.inspect}"
+end
+
+# Bare `raise` inside a rescue body re-raises with original class+msg.
+begin
+  begin
+    raise ArgumentError, "inner"
+  rescue => e
+    raise
+  end
+rescue => e
+  puts "re-raised cls: #{e.class}"
+  puts "re-raised msg: #{e.message}"
+end
+
+# Backward-compat: `puts e` still prints the message string,
+# preserving the existing test/rescue.rb shape.
+begin
+  raise "compat-msg"
+rescue => e
+  puts e
+end
+
+# Propagation when no rescue type matches (fix #3): a typed clause
+# whose sp_exc_is_a check returns false must re-raise so an enclosing
+# handler can catch it.
+begin
+  begin
+    raise ArgumentError, "propagate"
+  rescue TypeError => e
+    puts "should not be caught here"
+  end
+rescue ArgumentError => e
+  puts "caught propagated: #{e.class}"
+  puts "msg: #{e.message}"
+end
+
+# .backtrace returns nil (spinel does not track per-exception backtraces).
+begin
+  raise "trace"
+rescue => e
+  puts "backtrace is nil: #{e.backtrace == nil}"
+end
+
+# .full_message returns "ClassName: message".
+begin
+  raise ArgumentError, "fm"
+rescue => e
+  puts "full: #{e.full_message}"
+end
+
+# Multi-clause rescue chain: first clause misses, second clause catches.
+# Exercises the recursive sub-chain path in compile_rescue_chain.
+begin
+  raise TypeError, "multi"
+rescue ArgumentError => e
+  puts "should not match"
+rescue TypeError => e
+  puts "second clause: #{e.class} #{e.message}"
+rescue StandardError => e
+  puts "should not reach"
+end
+
+puts "done"

data/vendor/spinel/test/exception_object_methods.rb.expected

@@ -0,0 +1,15 @@
+msg: boom
+cls: RuntimeError
+cls2: ArgumentError
+msg2: bad
+tos: wrong
+ins: #<TypeError: wrong>
+re-raised cls: ArgumentError
+re-raised msg: inner
+compat-msg
+caught propagated: ArgumentError
+msg: propagate
+backtrace is nil: true
+full: ArgumentError: fm
+second clause: TypeError multi
+done

data/vendor/spinel/test/exceptions.rb

@@ -0,0 +1,34 @@
+# Test exception classes
+
+class AppError < RuntimeError
+end
+
+class NotFoundError < AppError
+end
+
+# Raise custom exception
+begin
+  raise NotFoundError, "item not found"
+rescue NotFoundError => e
+  puts e  # item not found
+rescue AppError => e
+  puts "app error"
+end
+
+# Raise with class name
+begin
+  raise AppError, "something went wrong"
+rescue NotFoundError => e
+  puts "not found"
+rescue AppError => e
+  puts e  # something went wrong
+end
+
+# Bare rescue catches all
+begin
+  raise "generic error"
+rescue => e
+  puts e  # generic error
+end
+
+puts "done"

data/vendor/spinel/test/exceptions.rb.expected

@@ -0,0 +1,4 @@
+item not found
+something went wrong
+generic error
+done

data/vendor/spinel/test/features.rb

@@ -0,0 +1,32 @@
+# Test various Ruby features
+
+# each_with_index
+[10, 20, 30].each_with_index { |v, i|
+  puts i.to_s + ":" + v.to_s
+}
+
+# for..in array
+sum = 0
+for x in [1, 2, 3, 4, 5]
+  sum = sum + x
+end
+puts sum
+
+# for..in range
+s = ""
+for i in 1..5
+  s = s + i.to_s
+end
+puts s
+
+# String#tr
+puts "hello".tr("el", "ip")
+
+# String#ljust / rjust
+puts "hi".ljust(6) + "|"
+puts "hi".rjust(6) + "|"
+
+# global variable type check (same type OK)
+$g = 10
+$g = 20
+puts $g

data/vendor/spinel/test/features.rb.expected

@@ -0,0 +1,9 @@
+0:10
+1:20
+2:30
+15
+12345
+hippo
+hi    |
+    hi|
+20

data/vendor/spinel/test/ffi_buffer_reader.rb

@@ -0,0 +1,23 @@
+module Buf
+  ffi_buffer :scratch, 16
+  ffi_read_u32 :u32_at_0, 0
+  ffi_read_u32 :u32_at_4, 4
+  ffi_read_u32 :u32_at_8, 8
+  ffi_read_i32 :i32_at_0, 0
+end
+
+# `ffi_buffer` lives in BSS so it's zero-initialised at load. Reading
+# the buffer back through every reader kind at every offset proves the
+# storage + read-pointer arithmetic line up.
+puts Buf.u32_at_0(Buf.scratch)
+puts Buf.u32_at_4(Buf.scratch)
+puts Buf.u32_at_8(Buf.scratch)
+puts Buf.i32_at_0(Buf.scratch)
+
+# A second buffer is laid out next to the first; each gets its own
+# slot, so reading from one doesn't accidentally see the other's bytes.
+module Other
+  ffi_buffer :scratch, 16
+  ffi_read_u32 :u32, 0
+end
+puts Other.u32(Other.scratch)

data/vendor/spinel/test/ffi_buffer_reader.rb.expected

@@ -0,0 +1,5 @@
+0
+0
+0
+0
+0

data/vendor/spinel/test/ffi_const.rb

@@ -0,0 +1,12 @@
+module Flags
+  ffi_const :READ,  1
+  ffi_const :WRITE, 2
+  ffi_const :EXEC,  4
+  ffi_const :MASK,  0xff
+end
+
+puts Flags::READ
+puts Flags::WRITE
+puts Flags::EXEC
+puts Flags::MASK
+puts(Flags::READ | Flags::WRITE | Flags::EXEC)

data/vendor/spinel/test/ffi_const.rb.expected

@@ -0,0 +1,5 @@
+1
+2
+4
+255
+7

data/vendor/spinel/test/ffi_libc_libm_basic.rb

@@ -0,0 +1,16 @@
+module LibM
+  ffi_func :cos,  [:double], :double
+  ffi_func :sqrt, [:double], :double
+  ffi_func :pow,  [:double, :double], :double
+end
+
+module LibC
+  ffi_func :strlen, [:str], :size_t
+  ffi_func :getpid, [],     :int
+end
+
+puts LibM.cos(0.0).to_i
+puts LibM.sqrt(16.0).to_i
+puts LibM.pow(2.0, 10.0).to_i
+puts LibC.strlen("hello, world")
+puts(LibC.getpid > 0 ? "pid_ok" : "pid_bad")

data/vendor/spinel/test/ffi_libc_libm_basic.rb.expected

@@ -0,0 +1,5 @@
+1
+4
+1024
+12
+pid_ok

data/vendor/spinel/test/ffi_ptr_nil.rb

@@ -0,0 +1,27 @@
+module LibC
+  ffi_func :malloc, [:size_t], :ptr
+  ffi_func :free,   [:ptr],    :void
+end
+
+module Buf
+  ffi_buffer :scratch, 16
+  # The buffer is zero-init in BSS, so reading 8 bytes at offset 0 as a
+  # pointer gives a deterministic NULL — handy for verifying that
+  # `ptr == nil` actually compares to NULL.
+  ffi_read_ptr :first_ptr, 0
+end
+
+p = LibC.malloc(64)
+if p == nil
+  puts "got_nil"
+else
+  puts "non_nil"
+end
+LibC.free(p)
+
+zero_ptr = Buf.first_ptr(Buf.scratch)
+if zero_ptr == nil
+  puts "zero_is_nil"
+else
+  puts "zero_non_nil"
+end

data/vendor/spinel/test/ffi_ptr_nil.rb.expected

@@ -0,0 +1,2 @@
+non_nil
+zero_is_nil

data/vendor/spinel/test/ffi_void_return.rb

@@ -0,0 +1,14 @@
+module LibC
+  ffi_func :malloc, [:size_t], :ptr
+  ffi_func :free,   [:ptr],    :void
+end
+
+# void-returning functions can be used in any expression position;
+# the call evaluates and the value is dropped.
+p = LibC.malloc(8)
+LibC.free(p)
+puts "freed"
+
+# As an expression: void-returning calls produce 0.
+x = (LibC.free(LibC.malloc(8)); 42)
+puts x

data/vendor/spinel/test/ffi_void_return.rb.expected

@@ -0,0 +1,2 @@
+freed
+42

data/vendor/spinel/test/fiber_ivar_persists_across_yield.rb

@@ -0,0 +1,22 @@
+class Counter
+  def initialize
+    @n = 0
+    @fiber = Fiber.new do
+      @n += 10
+      Fiber.yield
+      @n += 100
+      Fiber.yield
+      @n += 1000
+    end
+  end
+
+  def step
+    @fiber.resume
+    @n
+  end
+end
+
+c = Counter.new
+puts c.step
+puts c.step
+puts c.step

data/vendor/spinel/test/fiber_ivar_persists_across_yield.rb.expected

@@ -0,0 +1,3 @@
+10
+110
+1110

data/vendor/spinel/test/fiber_yield_across_method_call.rb

@@ -0,0 +1,28 @@
+class Stepper
+  def initialize
+    @count = 0
+    @fiber = Fiber.new { main_loop }
+  end
+
+  def step
+    @fiber.resume
+    @count
+  end
+
+  def main_loop
+    while @count < 5
+      tick
+      tick
+      Fiber.yield
+    end
+  end
+
+  def tick
+    @count += 1
+  end
+end
+
+s = Stepper.new
+puts s.step
+puts s.step
+puts s.step

data/vendor/spinel/test/fiber_yield_across_method_call.rb.expected

@@ -0,0 +1,3 @@
+2
+4
+6

data/vendor/spinel/test/file_basename_gc.rb

@@ -0,0 +1,59 @@
+# sp_file_basename used to return `path + offset` — a pointer into
+# the input path. Without keeping the underlying buffer rooted, the
+# GC could free the path string, leaving the held basename dangling.
+#
+# Triggering the bug requires:
+#  - A path constructed dynamically (heap string, not literal).
+#  - A basename returned from a helper, so the path goes out of scope.
+#  - GC pressure that actually fires `sp_gc_collect` so `sp_str_sweep`
+#    walks the string heap and reaps the unreferenced path. String
+#    allocations alone don't accrue to `sp_gc_bytes` (per the comment
+#    in `sp_str_alloc`); we need object allocations to push past the
+#    threshold.
+#
+# The fix returns a fresh sp_str_alloc'd copy whose own `\xfe` tag
+# byte makes mark_string take the right path, and which survives
+# independently of the original path.
+
+class Trash
+  def initialize(n)
+    @n = n
+    @s = "padding payload " * 64    # ~1 KB heap string per Trash
+  end
+  attr_reader :n
+end
+
+def name_of(i)
+  path = "/very/deep/parent/directory/with/many/segments/file" + i.to_s + ".rb"
+  File.basename(path)
+end
+
+names = []
+i = 0
+while i < 50
+  names << name_of(i)
+  i = i + 1
+end
+
+# Allocate ~5000 Trash instances (~5 MB) — far past the 256 KB GC
+# threshold — to force multiple sp_gc_collect cycles and reap the
+# unreferenced path strings via sp_str_sweep.
+junk = []
+j = 0
+while j < 5000
+  junk << Trash.new(j)
+  j = j + 1
+end
+puts junk.length     # 5000
+
+# Each names[i] should still resolve to "fileN.rb".
+ok = 1
+i = 0
+while i < 50
+  expected = "file" + i.to_s + ".rb"
+  if names[i] != expected
+    ok = 0
+  end
+  i = i + 1
+end
+puts(ok == 1 ? "ok" : "corrupt")    # ok

data/vendor/spinel/test/file_basename_gc.rb.expected

@@ -0,0 +1,2 @@
+5000
+ok

data/vendor/spinel/test/forward_call_class_method_inherited_init.rb

@@ -0,0 +1,36 @@
+# Forward-ref `Class.new(arg)` whose Class is a subclass with its
+# own `def initialize(_arg); super; end`. Pre-fix codegen widened
+# the child's #initialize ptype from the call site but never
+# propagated the type through the bare `super` to the parent's
+# #initialize, leaving the parent's `owner` param at the default
+# `mrb_int`. The parent's body `@owner = owner` then stored the
+# int payload; subsequent `@owner.<method>` dispatches on a child
+# instance landed on the wrong class via the int→class fallback.
+
+class Outer
+  def initialize
+    @child = Sub.new(self)
+  end
+  def report
+    @child.read_owner_name
+  end
+  def name; "outer"; end
+end
+
+class Base
+  def initialize(owner)
+    @owner = owner
+  end
+  def read_owner_name
+    @owner.name
+  end
+end
+
+class Sub < Base
+  def initialize(_owner)
+    super
+  end
+end
+
+o = Outer.new
+puts o.report

data/vendor/spinel/test/forward_call_class_method_inherited_init.rb.expected

@@ -0,0 +1 @@
+outer

data/vendor/spinel/test/forward_call_class_method_inherited_init_int_array.rb

@@ -0,0 +1,32 @@
+# Inherited-init forward-ref with an IntArray param flowing through
+# the super call. The parent's `arr` param must end up
+# `sp_IntArray *` (not the default `mrb_int`) so the body's
+# `@arr = arr` stores the right pointer type and a parent-defined
+# accessor reads the typed value.
+
+class Driver
+  def initialize
+    @child = Subscriber.new([10, 20, 30, 40])
+  end
+  def report
+    @child.length
+  end
+end
+
+class Listener
+  def initialize(arr)
+    @arr = arr
+  end
+  def length
+    @arr.length
+  end
+end
+
+class Subscriber < Listener
+  def initialize(_arr)
+    super
+  end
+end
+
+d = Driver.new
+puts d.report

data/vendor/spinel/test/forward_call_class_method_inherited_init_int_array.rb.expected

@@ -0,0 +1 @@
+4

data/vendor/spinel/test/forward_call_class_method_inherited_init_obj.rb

@@ -0,0 +1,41 @@
+# Inherited-init forward-ref where the param type is itself an
+# obj_X user class. Verifies the type flows through both the
+# `Class.new(@h)` constructor branch and the bare `super` of the
+# child's initialize.
+
+class Holder
+  def initialize(name)
+    @name = name
+  end
+  def label
+    "h:#{@name}"
+  end
+end
+
+class Outer
+  def initialize
+    @h = Holder.new("alpha")
+    @child = Sub.new(@h)
+  end
+  def report
+    @child.held_label
+  end
+end
+
+class Base
+  def initialize(holder)
+    @holder = holder
+  end
+  def held_label
+    @holder.label
+  end
+end
+
+class Sub < Base
+  def initialize(_holder)
+    super
+  end
+end
+
+o = Outer.new
+puts o.report

data/vendor/spinel/test/forward_call_class_method_inherited_init_obj.rb.expected

@@ -0,0 +1 @@
+h:alpha

data/vendor/spinel/test/forward_call_class_method_int_array.rb

@@ -0,0 +1,26 @@
+# `Class.new(int_array_arg)` where the callee class is defined later
+# than the call site. Pre-fix codegen left Target's `arr` param at
+# the default `mrb_int`; the int→class fallback then emitted the
+# call with a Wint-conversion error. Source order kept caller-first.
+
+class Caller
+  def make_target
+    @t = Target.new([10, 20, 30])
+  end
+  def length
+    @t.show
+  end
+end
+
+class Target
+  def initialize(arr)
+    @arr = arr
+  end
+  def show
+    @arr.length
+  end
+end
+
+c = Caller.new
+c.make_target
+puts c.length

data/vendor/spinel/test/forward_call_class_method_int_array.rb.expected

@@ -0,0 +1 @@
+3