rubyduino 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aebef08a8012ff1994cfef5f943278222b9cc76c0147398d467d2a815121c37c
-  data.tar.gz: d48692b143f9248dcae3cddc6db3b823ce9386e0a28e693133c88d28a4fea72d
+  metadata.gz: 06e43dd1d4e9f5f4d9dbfda78f6954733999175a658f50b5d76186e6c51fc544
+  data.tar.gz: 62a7ba189c79f9741001a6724af58026c7870aaa9da5775dcf54c824afcf53d3
 SHA512:
-  metadata.gz: 3bbdc16bf822d3bc4ed389a64fbaa3fbc61d9dfa97604baf0c19d35a9ab0918040e1e2de5d1ccae958b2972338e18be6725eeefdd40291ab0b06fbeab067302b
-  data.tar.gz: 54625b52317c6de6607655e81cbb1e9b19f493c9b1eb669f50edfe080c06b6a863ed07ab72d29e55af1a626a23d760103aa7142843f81499cd6aa7fb9879e989
+  metadata.gz: 9a83433f8069a0e13757f47666c6913307185d66f388eb014fa68bc54a9afd0117e4c7155bf2f8199ffa5a73c4e7de415096f8cdce2a0965f4679cd567cbf7a1
+  data.tar.gz: deb4d7cc643e4d93c172a525677fb7944fbc6fb2bab93fe2b48f7893ca2e0886153879fedd42ee7bf06605e4dc0ac5413cb16c767bd59a0ede37cde188dbf0c4

data/CHANGELOG.md

@@ -7,3 +7,7 @@
 ## [0.1.1] - 2026-05-08
 
 - Fix avrdude discovery for installed command
+
+## [0.1.2] - 2026-05-08
+
+- Update vendored Spinel revision

data/lib/rubyduino/spinel.rb

@@ -2,7 +2,7 @@
 
 module Rubyduino
   module Spinel
-    COMMIT = "a70208094343b9d4cd306218c909d99781661c2f"
+    COMMIT = "e7f714f213ca572912f7214f358a927f8e2152e5"
     ROOT = File.expand_path("../../vendor/spinel", __dir__)
   end
 end

data/lib/rubyduino/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubyduino
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/vendor/spinel/Makefile

@@ -122,7 +122,7 @@ PRISM_LIB    = build/libprism.a
 CODEGEN_STAMP := build/stamps/spinel_codegen.rb.stamp
 PARSE_STAMP   := build/stamps/spinel_parse.c.stamp
 
-.PHONY: all parse bootstrap codegen test retest clean-test-results regen-expected bench clean install uninstall deps
+.PHONY: all parse bootstrap codegen test retest clean-test-results regen-expected bench optcarrot clean install uninstall deps
 
 all: parse regexp spinel_codegen$(EXE)
 
@@ -378,6 +378,34 @@ bench: spinel_parse$(EXE) $(SP_RT_LIB) spinel_codegen$(EXE)
 	echo "Benchmarks: $$pass pass, $$fail fail, $$err error, $$skip skip"; \
 	if [ $$fail -ne 0 ] || [ $$err -ne 0 ]; then exit 1; fi
 
+# ---- Optcarrot integration test ----
+#
+# End-to-end pipeline: clone optcarrot's `experiment/spinel` branch,
+# pack `lib/optcarrot/*.rb` into a single Ruby file via the upstream
+# `tools/pack-for-spinel.rb`, compile through spinel, run the
+# resulting binary against `examples/Lan_Master.nes`, and verify the
+# output contains `fps: <num>` and `checksum: 59662` (the canonical
+# 180-frame checksum for `--benchmark`).
+
+OPTCARROT_DIR  := build/optcarrot
+OPTCARROT_REPO := https://github.com/mame/optcarrot.git
+OPTCARROT_BRANCH := experiment/spinel
+
+optcarrot: spinel_parse$(EXE) $(SP_RT_LIB) spinel_codegen$(EXE)
+	@if [ ! -d $(OPTCARROT_DIR) ]; then \
+	  git clone --depth=1 --branch=$(OPTCARROT_BRANCH) $(OPTCARROT_REPO) $(OPTCARROT_DIR); \
+	fi
+	@ruby $(OPTCARROT_DIR)/tools/pack-for-spinel.rb > build/optcarrot-single.rb
+	@./spinel build/optcarrot-single.rb -o build/optcarrot-single
+	@out=$$($(TIMEOUT60) ./build/optcarrot-single 2>&1); \
+	echo "$$out"; \
+	if echo "$$out" | grep -qE "^fps: [0-9.]+$$" && echo "$$out" | grep -q "^checksum: 59662$$"; then \
+	  echo "Optcarrot: OK"; \
+	else \
+	  echo "Optcarrot: FAIL — expected 'fps: <num>' and 'checksum: 59662'"; \
+	  exit 1; \
+	fi
+
 # ---- Install ----
 
 PREFIX   ?= /usr/local

data/vendor/spinel/spinel_codegen.rb

@@ -2934,6 +2934,18 @@ class Compiler
       end
     end
 
+    # `<obj>.class` returns the class name as a string (Spinel
+    # collapses Class/Module objects to their textual name; the
+    # only consumers in practice are interpolation
+    # `"#<#{self.class}>"` and `.to_s.split` chains, both of
+    # which work fine on a plain string).
+    if recv >= 0 && mname == "class"
+      rt = infer_type(recv)
+      if is_obj_type(rt) == 1
+        return "string"
+      end
+    end
+
     # `recv.__sp_ieval_<N>(...)`: the rewritten form of an
     # `recv.instance_eval { ... }` call. v1 only fired on top-level call
     # sites, where the call's value was always discarded — so its return
@@ -3994,6 +4006,16 @@ class Compiler
       end
       return "int_array"
     end
+    # `replace(other)` returns the receiver, not a fresh array;
+    # the inferred result must therefore preserve the receiver's
+    # array type so that an expression-form `c = a.replace(b)`
+    # still tags `c` as `int_array` (or whatever `a` is) rather
+    # than falling through to `int`.
+    if mname == "replace"
+      if recv >= 0
+        return infer_type(recv)
+      end
+    end
     if mname == "pop"
       if recv >= 0
         rt = infer_type(recv)
@@ -4643,7 +4665,7 @@ class Compiler
           if mname == "read" || mname == "binread"
             return "string"
           end
-          if mname == "exist?"
+          if mname == "exist?" || mname == "readable?"
             return "bool"
           end
           if mname == "join"
@@ -17819,6 +17841,14 @@ class Compiler
 
   # ---- Forward declarations ----
   def emit_forward_decls
+    # ARGV (sp_argv) is referenced from any function that uses
+    # `ARGV.length` / `ARGV[i]`, so the declaration has to precede
+    # all function bodies — not just main()'s.  emit_main keeps the
+    # runtime initialization (`sp_argv.len = argc - 1; ...`) where
+    # main() can fill it in from `argc` / `argv`.
+    emit_raw("typedef struct{const char**data;mrb_int len;}sp_Argv;")
+    emit_raw("static sp_Argv sp_argv;")
+    emit_raw("")
     # Emit block helper functions accumulated during collection
     if @block_funcs != ""
       emit_raw(@block_funcs)
@@ -20806,9 +20836,6 @@ class Compiler
 
   def emit_main
     stmts = get_body_stmts(@root_id)
-    emit_raw("typedef struct{const char**data;mrb_int len;}sp_Argv;")
-    emit_raw("static sp_Argv sp_argv;")
-    emit_raw("")
     emit_raw("int main(int argc,char**argv){")
     emit_raw("  sp_argv.len=argc-1;sp_argv.data=(const char**)malloc(sizeof(const char*)*(argc>1?argc-1:1));{int _i;for(_i=0;_i<sp_argv.len;_i++)sp_argv.data[_i]=sp_str_dup_external(argv[_i+1]);}")
     if @needs_rand == 1
@@ -21303,7 +21330,16 @@ class Compiler
       exit(1)
     end
     if t == "IntegerNode"
-      return @nd_value[nid].to_s
+      # Suffix with `LL` so the literal is `long long` rather than
+      # `int` in the emitted C. Without it, an expression of int
+      # literals whose product exceeds int32 (e.g. APU mixer
+      # constant `24329 * 256 * 500 = 3,114,112,000`) overflows
+      # at constant-folding time and the C compiler emits a wrong
+      # value. Plain literals at runtime sites get implicitly
+      # promoted to mrb_int (= long long) on assignment, but
+      # constant-init expressions are evaluated by the C compiler
+      # using the literals' declared type.
+      return @nd_value[nid].to_s + "LL"
     end
     if t == "FloatNode"
       return @nd_content[nid]
@@ -26285,6 +26321,37 @@ class Compiler
         end
         return "sp_IntArray_sort(" + rc + ")"
       end
+      # `pack("C*")` — the only format Spinel implements: each
+      # int element is written as a byte into a freshly allocated
+      # NUL-terminated string. Sufficient for the optcarrot save-
+      # RAM `@wrk.pack("C*")` shape and the symmetric inverse of
+      # `String#bytes` we already support. Other format strings
+      # fall through to the unresolved-call warning.
+      if mname == "pack" && recv_type == "int_array"
+        args_id = @nd_arguments[nid]
+        if args_id >= 0
+          a_pk = get_args(args_id)
+          if a_pk.length == 1 && @nd_type[a_pk[0]] == "StringNode" && @nd_content[a_pk[0]] == "C*"
+            tmp = new_temp
+            ntmp = new_temp
+            itmp = new_temp
+            emit("  mrb_int " + ntmp + " = sp_IntArray_length(" + rc + ");")
+            emit("  char *" + tmp + " = sp_str_alloc(" + ntmp + ");")
+            emit("  for (mrb_int " + itmp + " = 0; " + itmp + " < " + ntmp + "; " + itmp + "++) " + tmp + "[" + itmp + "] = (char)sp_IntArray_get(" + rc + ", " + itmp + ");")
+            emit("  " + tmp + "[" + ntmp + "] = 0;")
+            return tmp
+          end
+        end
+      end
+      # `replace(other)` in expression position: the stmt-form
+      # arm in compile_*_stmt only fires when the call's value is
+      # discarded; in expression position (e.g. last stmt of a
+      # method body, or rvalue of an assignment) we still need to
+      # emit the side effect *and* yield the receiver as the
+      # value. Use the comma operator so the result is `rc`.
+      if mname == "replace" && recv_type == "int_array"
+        return "(sp_IntArray_replace(" + rc + ", " + compile_arg0(nid) + "), " + rc + ")"
+      end
       # take_while / drop_while: block-driven prefix scan. take_while
       # collects elements from the front while the block stays truthy;
       # drop_while skips them and returns the rest. Mirrors the
@@ -26539,6 +26606,14 @@ class Compiler
       if mname == "difference"
         return "sp_FloatArray_difference(" + rc + ", " + compile_arg0(nid) + ")"
       end
+      if mname == "sort"
+        # Non-bang: yield a fresh sorted copy. Mirror the
+        # `sp_FloatArray_shuffle` pattern (new + replace) so the
+        # source array is left untouched.
+        tmp = new_temp
+        emit("  sp_FloatArray *" + tmp + " = sp_FloatArray_new(); sp_FloatArray_replace(" + tmp + ", " + rc + "); sp_FloatArray_sort_bang(" + tmp + ");")
+        return tmp
+      end
     end
     if is_ptr_array_type(recv_type) == 1
       elem_type = ptr_array_elem_type(recv_type)
@@ -27529,9 +27604,32 @@ class Compiler
         if mname == "exist?"
           return "sp_file_exist(" + compile_arg0(nid) + ")"
         end
+        if mname == "readable?"
+          # Reuse the exist check: on every platform Spinel
+          # targets, a fopen-able file is also readable from
+          # the same process. Distinguishing the two would
+          # need access(2), which isn't worth a runtime fn for
+          # the dead-code optcarrot battery-save path that
+          # surfaced this.
+          return "sp_file_exist(" + compile_arg0(nid) + ")"
+        end
         if mname == "delete"
           return "(sp_file_delete(" + compile_arg0(nid) + "), 0)"
         end
+        if mname == "binwrite"
+          # NOTE: `sp_file_write` uses fputs, so an embedded NUL
+          # in the payload truncates the write — fine for the
+          # optcarrot save-RAM dead-code path that surfaced
+          # this, not safe for general binary use.
+          args_id_bw = @nd_arguments[nid]
+          if args_id_bw >= 0
+            a_bw = get_args(args_id_bw)
+            if a_bw.length >= 2
+              return "(sp_file_write(" + compile_expr(a_bw[0]) + ", " + compile_expr(a_bw[1]) + "), 0)"
+            end
+          end
+          return "0"
+        end
         if mname == "join"
           args_id = @nd_arguments[nid]
           if args_id >= 0
@@ -27864,6 +27962,16 @@ class Compiler
         if @cls_is_value_type[ci] == 1
           arrow = "."
         end
+        # `<obj>.class` — collapse to the class name as a string
+        # literal. Spinel doesn't allocate runtime Class objects,
+        # but the typical consumers (interpolation in inspect,
+        # `.to_s.split("::").last` shape) all treat the result as
+        # a string. Underscore-flattened nested module names
+        # (`Optcarrot_NES`) render as-is rather than the original
+        # `Optcarrot::NES` form; the loss is cosmetic.
+        if mname == "class"
+          return c_string_literal(cname)
+        end
         # attr_reader
         readers = @cls_attr_readers[ci].split(";")
         j = 0

data/vendor/spinel/test/file_class_methods_int_recv.rb

@@ -0,0 +1,20 @@
+# `File.readable?` and `File.binwrite` — class-method stubs in
+# the `rcname == "File"` dispatch block, plus `IntArray#pack("C*")`
+# which is the symmetric inverse of `String#bytes`.
+#
+# Surfaced via optcarrot's battery-save dead code path:
+#   `return unless File.readable?(sav)` and
+#   `File.binwrite(sav, @wrk.pack("C*"))`.
+#
+# `readable?` reuses the exist check (close enough on POSIX).
+# `binwrite` reuses `sp_file_write` — fputs-based, so embedded
+# NULs truncate; acceptable for the NUL-free use sites that
+# exist in practice.
+
+path = "/tmp/spinel_file_class_test"
+
+File.binwrite(path, [72, 105, 33].pack("C*"))   # "Hi!"
+puts File.readable?(path)
+puts File.read(path)
+File.delete(path)
+puts File.exist?(path)

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

@@ -0,0 +1,3 @@
+true
+Hi!
+false

data/vendor/spinel/test/float_array_sort.rb

@@ -0,0 +1,18 @@
+# `Array#sort` (non-bang) on a float array. Surfaced via
+# optcarrot's `@fps_history.sort[(@fps_history.length * 0.05).floor]`
+# p95 calculation. Mirrors the existing int_array sort path —
+# yields a fresh sorted array; the source stays untouched.
+
+a = [3.5, 1.25, 2.0, 0.75, 4.125]
+b = a.sort
+puts b.length
+
+i = 0
+while i < b.length
+  puts b[i]
+  i = i + 1
+end
+
+# Source unchanged.
+puts a[0]
+puts a[1]

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

@@ -0,0 +1,8 @@
+5
+0.75
+1.25
+2.0
+3.5
+4.125
+3.5
+1.25

data/vendor/spinel/test/int_array_replace_expr.rb

@@ -0,0 +1,23 @@
+# `Array#replace` in *expression* position on an int_array.
+# The stmt-form arm has long supported this; the expr-form was
+# missing — unresolved-call warning + literal `0` emitted.
+# Surfaced via optcarrot's `def load_battery; ...; @wrk.replace(sav.bytes); end`,
+# where the call sits at the tail of the method (its value is
+# the implicit return).
+
+a = [1, 2, 3]
+b = [10, 20, 30, 40]
+
+# Expression position: assigned. Should yield the (mutated) `a`.
+c = a.replace(b)
+
+# `a` mutated in place
+puts a[0]
+puts a[1]
+puts a[2]
+puts a[3]
+puts a.length
+
+# `c` is the same array (replace returns the receiver)
+puts c[0]
+puts c.length

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

@@ -0,0 +1,7 @@
+10
+20
+30
+40
+4
+10
+4

data/vendor/spinel/test/integer_literal_no_int32_overflow.rb

@@ -0,0 +1,29 @@
+# Spinel's integers are mrb_int (long long); Ruby integers don't
+# overflow in the same range. But emitting a plain `24329 * 256 *
+# 500` in C lets the C compiler fold the constant using `int`
+# arithmetic, overflowing at 3,114,112,000 to a wrong negative
+# result on 32-bit-int platforms.
+#
+# Surfaced via optcarrot's `APU::Mixer::TND_1 = 100 * 24329 * 256
+# / 500`-shaped constant expressions whose intermediate products
+# clear int32 max. Same hazard for any constant-init expression
+# of integer literals whose folded result exceeds INT_MAX.
+#
+# Fix: emit the `LL` suffix on every IntegerNode literal so
+# operands carry `long long` type at the C level. Runtime
+# expressions assigned to `mrb_int` slots already promoted
+# implicitly; only constant-init contexts (where the C compiler
+# folds before any assignment) saw the overflow.
+
+# Each chain straddles int32: max 2^31 - 1 = 2,147,483,647.
+A = 24329 * 256 * 500           # 3,114,112,000
+B = 100000 * 100000              # 10,000,000,000
+C = 65535 * 65535                # 4,294,836,225
+D = 2 ** 40                      # 1,099,511,627,776
+E = 1_000_000_000 + 1_000_000_000 # 2,000,000,000 — sum overflow
+
+puts A
+puts B
+puts C
+puts D
+puts E

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

@@ -0,0 +1,5 @@
+3114112000
+10000000000
+4294836225
+1099511627776
+2000000000

data/vendor/spinel/test/obj_class_returns_string.rb

@@ -0,0 +1,24 @@
+# `<user_obj>.class` collapses to the class name as a string.
+# Spinel doesn't allocate runtime Class objects, so the only
+# coherent representation for `obj.class` is the textual name.
+# The two real-world consumers in optcarrot are:
+#   1. `"#<#{ self.class }>"`-style interpolation in `inspect`
+#   2. `self.class.to_s.split("::").last`-style introspection
+# Both work fine if `.class` simply yields the class name as a
+# string (the second loses the `::` namespace because Spinel
+# flattens nested modules with `_`, but that's a cosmetic loss).
+
+class Foo
+  def to_s
+    "<" + self.class + ">"
+  end
+end
+
+class Bar
+  def label
+    self.class.to_s
+  end
+end
+
+puts Foo.new.to_s   # => <Foo>
+puts Bar.new.label  # => Bar

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

@@ -0,0 +1,2 @@
+<Foo>
+Bar

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyduino
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Joseph Schito
@@ -345,6 +345,10 @@ files:
 - vendor/spinel/test/fiber_yield_across_method_call.rb.expected
 - vendor/spinel/test/file_basename_gc.rb
 - vendor/spinel/test/file_basename_gc.rb.expected
+- vendor/spinel/test/file_class_methods_int_recv.rb
+- vendor/spinel/test/file_class_methods_int_recv.rb.expected
+- vendor/spinel/test/float_array_sort.rb
+- vendor/spinel/test/float_array_sort.rb.expected
 - vendor/spinel/test/forward_call_class_method_inherited_init.rb
 - vendor/spinel/test/forward_call_class_method_inherited_init.rb.expected
 - vendor/spinel/test/forward_call_class_method_inherited_init_int_array.rb
@@ -407,6 +411,8 @@ files:
 - vendor/spinel/test/inspect.rb.expected
 - vendor/spinel/test/instance_eval_trampoline.rb
 - vendor/spinel/test/instance_eval_trampoline.rb.expected
+- vendor/spinel/test/int_array_replace_expr.rb
+- vendor/spinel/test/int_array_replace_expr.rb.expected
 - vendor/spinel/test/int_bracket_skip_sym_idx.rb
 - vendor/spinel/test/int_bracket_skip_sym_idx.rb.expected
 - vendor/spinel/test/int_keyed_hash_lookup_as_array.rb
@@ -417,6 +423,8 @@ files:
 - vendor/spinel/test/integer_div.rb.expected
 - vendor/spinel/test/integer_div_by_zero.rb
 - vendor/spinel/test/integer_div_by_zero.rb.expected
+- vendor/spinel/test/integer_literal_no_int32_overflow.rb
+- vendor/spinel/test/integer_literal_no_int32_overflow.rb.expected
 - vendor/spinel/test/interp_method_widening.rb
 - vendor/spinel/test/interp_method_widening.rb.expected
 - vendor/spinel/test/interp_symbol.rb
@@ -560,6 +568,8 @@ files:
 - vendor/spinel/test/nullable.rb.expected
 - vendor/spinel/test/obj_array.rb
 - vendor/spinel/test/obj_array.rb.expected
+- vendor/spinel/test/obj_class_returns_string.rb
+- vendor/spinel/test/obj_class_returns_string.rb.expected
 - vendor/spinel/test/object_new_sentinel.rb
 - vendor/spinel/test/object_new_sentinel.rb.expected
 - vendor/spinel/test/object_truthy.rb