rubyduino 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aebef08a8012ff1994cfef5f943278222b9cc76c0147398d467d2a815121c37c
-  data.tar.gz: d48692b143f9248dcae3cddc6db3b823ce9386e0a28e693133c88d28a4fea72d
+  metadata.gz: 1ec4285a969c2afed1449f750c1674b63f1ba5cb5b454994cfdb9356173595cb
+  data.tar.gz: 8e1dba9b348672d0aa96f4eb7645242da1e111fa36595c1f601ab9a1fa45acdf
 SHA512:
-  metadata.gz: 3bbdc16bf822d3bc4ed389a64fbaa3fbc61d9dfa97604baf0c19d35a9ab0918040e1e2de5d1ccae958b2972338e18be6725eeefdd40291ab0b06fbeab067302b
-  data.tar.gz: 54625b52317c6de6607655e81cbb1e9b19f493c9b1eb669f50edfe080c06b6a863ed07ab72d29e55af1a626a23d760103aa7142843f81499cd6aa7fb9879e989
+  metadata.gz: 736ec9d0f9c5665ba2f88f647c36d0dcd1010a3e4d405d1a49a6032d1eaefaa60aecbd64a2d9e103796f9bf7443a8163370dc5951fdcd14bb589938452cc5ca7
+  data.tar.gz: 203d97b5aed491505f46e681d04aa4128dce2349ac93513d8cf307f1b8e96ddeaaa31478788c5f9aa919a028fe276cbab1b10a6c54466b69cf7ee17f2a1abc35

data/CHANGELOG.md

@@ -1,9 +1,19 @@
 ## [Unreleased]
 
-## [0.1.0] - 2026-05-08
+## [0.1.3] - 2026-05-08
 
-- Initial release
+- Add the built-in `ArduinoUNO` prelude with FFI-backed GPIO, analog read, and millisecond delay bindings
+- Replace the legacy `system("pin13:*")` sketch API with top-level helpers like `pin_mode`, `digital_write`, and `delay_ms`
+- Update the default hello example to use the new ArduinoUNO API
+
+## [0.1.2] - 2026-05-08
+
+- Update vendored Spinel revision
 
 ## [0.1.1] - 2026-05-08
 
 - Fix avrdude discovery for installed command
+
+## [0.1.0] - 2026-05-08
+
+- Initial release

data/README.md

@@ -1,6 +1,7 @@
 <div align="center">
 
-# Rubyduino
+# Rubyduino 
+[Experimental]
 
 <img width="250" height="250" alt="image copy" src="https://github.com/user-attachments/assets/156c7d41-ed42-43f3-a720-ed2e9c12b52c" />
 
@@ -15,14 +16,13 @@ Under the hood it uses [Spinel](https://github.com/matz/spinel), a Ruby AOT comp
 <img width="500" height="281" alt="IMG_0197" src="https://github.com/user-attachments/assets/d2b1cc69-647a-4f63-b090-31b13a21e5a8" />
 
 ```ruby
-system("pin13:output")
+pin_mode(ArduinoUNO::LED_BUILTIN, ArduinoUNO::OUTPUT)
 
 loop do
-  duration = 0.1
-  system("pin13:high")
-  sleep duration
-  system("pin13:low")
-  sleep duration
+  digital_write(ArduinoUNO::LED_BUILTIN, ArduinoUNO::HIGH)
+  delay_ms(100)
+  digital_write(ArduinoUNO::LED_BUILTIN, ArduinoUNO::LOW)
+  delay_ms(100)
 end
 ```
 

data/bin/rubyduino

@@ -98,6 +98,7 @@ rubyduino_dir = File.join(root_dir, "lib/rubyduino")
 parse_bin = File.join(spinel_dir, "spinel_parse")
 codegen_rb = File.join(rubyduino_dir, "spinel_arduino_codegen.rb")
 entry_c = File.join(rubyduino_dir, "arduino_entry.c")
+arduino_uno_rb = File.join(rubyduino_dir, "arduino_uno.rb")
 
 mcu = "atmega328p"
 f_cpu = "16000000UL"
@@ -137,6 +138,7 @@ abort "rubyduino: #{source}: No such file" unless File.file?(source)
 abort "rubyduino: missing Spinel checkout at #{spinel_dir}" unless Dir.exist?(spinel_dir)
 abort "rubyduino: missing #{codegen_rb}" unless File.file?(codegen_rb)
 abort "rubyduino: missing #{entry_c}" unless File.file?(entry_c)
+abort "rubyduino: missing #{arduino_uno_rb}" unless File.file?(arduino_uno_rb)
 abort "rubyduino: avr-gcc not found" unless command?("avr-gcc")
 abort "rubyduino: avr-objcopy not found" unless command?("avr-objcopy")
 
@@ -164,9 +166,11 @@ avrdude = find_avrdude
 abort "rubyduino: avrdude not found" unless avrdude
 
 ast_tmp = File.join(Dir.tmpdir, "spinel_arduino_ast.#{$PROCESS_ID}.#{rand(1_000_000)}")
+source_tmp = File.join(Dir.tmpdir, "rubyduino_source.#{$PROCESS_ID}.#{rand(1_000_000)}.rb")
 begin
   warn "Spinel: #{source} -> #{c_file}"
-  run!(parse_bin, source, ast_tmp)
+  File.write(source_tmp, "#{File.read(arduino_uno_rb)}\n#{File.read(source)}")
+  run!(parse_bin, source_tmp, ast_tmp)
   run!(RbConfig.ruby, codegen_rb, ast_tmp, c_file)
 
   warn "AVR: #{c_file} -> #{hex_file}"
@@ -183,4 +187,5 @@ begin
   run!(avrdude, *conf_args, "-p#{mcu}", "-carduino", "-P#{port}", "-b#{baud}", "-D", "-Uflash:w:#{hex_file}:i")
 ensure
   FileUtils.rm_f(ast_tmp)
+  FileUtils.rm_f(source_tmp)
 end

data/examples/hello.rb

@@ -1,9 +1,8 @@
-system("pin13:output")
+pin_mode(ArduinoUNO::LED_BUILTIN, ArduinoUNO::OUTPUT)
 
 loop do
-  duration = 0.1
-  system("pin13:high")
-  sleep duration
-  system("pin13:low")
-  sleep duration
+  digital_write(ArduinoUNO::LED_BUILTIN, ArduinoUNO::HIGH)
+  delay_ms(100)
+  digital_write(ArduinoUNO::LED_BUILTIN, ArduinoUNO::LOW)
+  delay_ms(100)
 end

data/lib/rubyduino/arduino_uno.rb

@@ -0,0 +1,43 @@
+module ArduinoUNO
+  LOW = 0
+  HIGH = 1
+
+  INPUT = 0
+  OUTPUT = 1
+  INPUT_PULLUP = 2
+
+  A0 = 14
+  A1 = 15
+  A2 = 16
+  A3 = 17
+  A4 = 18
+  A5 = 19
+
+  LED_BUILTIN = 13
+
+  ffi_func :pin_mode, [:uint8, :uint8], :int
+  ffi_func :digital_write, [:uint8, :uint8], :int
+  ffi_func :digital_read, [:uint8], :int
+  ffi_func :analog_read, [:uint8], :int
+  ffi_func :delay_ms, [:uint32], :void
+end
+
+def pin_mode(pin, mode)
+  ArduinoUNO.pin_mode(pin, mode)
+end
+
+def digital_write(pin, value)
+  ArduinoUNO.digital_write(pin, value)
+end
+
+def digital_read(pin)
+  ArduinoUNO.digital_read(pin)
+end
+
+def analog_read(pin)
+  ArduinoUNO.analog_read(pin)
+end
+
+def delay_ms(ms)
+  ArduinoUNO.delay_ms(ms)
+end

data/lib/rubyduino/sp_runtime.h

@@ -3,6 +3,7 @@
 
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 #include <avr/io.h>
 #include <util/delay.h>
 #include <util/delay_basic.h>
@@ -46,6 +47,7 @@ static void sp_gc_mark(void *ptr) {
 
 typedef struct {
   mrb_int *data;
+  mrb_int start;
   mrb_int len;
   mrb_int cap;
 } sp_IntArray;
@@ -69,6 +71,7 @@ static sp_Range sp_range_new(mrb_int first, mrb_int last) {
 
 static sp_IntArray *sp_IntArray_new(void) {
   sp_IntArray *array = (sp_IntArray *)malloc(sizeof(sp_IntArray));
+  array->start = 0;
   array->len = 0;
   array->cap = 4;
   array->data = (mrb_int *)malloc(sizeof(mrb_int) * array->cap);
@@ -80,7 +83,7 @@ static void sp_IntArray_push(sp_IntArray *array, mrb_int value) {
     array->cap *= 2;
     array->data = (mrb_int *)realloc(array->data, sizeof(mrb_int) * array->cap);
   }
-  array->data[array->len] = value;
+  array->data[array->start + array->len] = value;
   array->len++;
 }
 
@@ -89,7 +92,7 @@ static mrb_int sp_IntArray_length(sp_IntArray *array) {
 }
 
 static mrb_int sp_IntArray_get(sp_IntArray *array, mrb_int index) {
-  return array->data[index];
+  return array->data[array->start + index];
 }
 
 static sp_FloatArray *sp_FloatArray_new(void) {
@@ -117,30 +120,140 @@ static mrb_float sp_FloatArray_get(sp_FloatArray *array, mrb_int index) {
   return array->data[index];
 }
 
-static int sp_streq(const char *a, const char *b) {
-  while (*a && *b && *a == *b) {
-    a++;
-    b++;
+static int rd_uno_valid_pin(uint8_t pin) {
+  return pin <= 19;
+}
+
+static volatile uint8_t *rd_uno_ddr(uint8_t pin) {
+  if (pin <= 7) {
+    return &DDRD;
   }
-  return *a == *b;
+  if (pin <= 13) {
+    return &DDRB;
+  }
+  if (pin <= 19) {
+    return &DDRC;
+  }
+  return NULL;
 }
 
-static int sp_arduino_system(const char *cmd) {
-  if (sp_streq(cmd, "pin13:output")) {
-    DDRB |= _BV(DDB5);
+static volatile uint8_t *rd_uno_port(uint8_t pin) {
+  if (pin <= 7) {
+    return &PORTD;
+  }
+  if (pin <= 13) {
+    return &PORTB;
+  }
+  if (pin <= 19) {
+    return &PORTC;
+  }
+  return NULL;
+}
+
+static volatile uint8_t *rd_uno_pin_reg(uint8_t pin) {
+  if (pin <= 7) {
+    return &PIND;
+  }
+  if (pin <= 13) {
+    return &PINB;
+  }
+  if (pin <= 19) {
+    return &PINC;
+  }
+  return NULL;
+}
+
+static uint8_t rd_uno_bit(uint8_t pin) {
+  if (pin <= 7) {
+    return pin;
+  }
+  if (pin <= 13) {
+    return pin - 8;
+  }
+  return pin - 14;
+}
+
+int pin_mode(uint8_t pin, uint8_t mode) {
+  volatile uint8_t *ddr = rd_uno_ddr(pin);
+  volatile uint8_t *port = rd_uno_port(pin);
+  uint8_t mask;
+
+  if (!ddr || !port) {
+    return 1;
+  }
+
+  mask = (uint8_t)(1 << rd_uno_bit(pin));
+
+  if (mode == 1) {
+    *ddr |= mask;
     return 0;
   }
-  if (sp_streq(cmd, "pin13:high")) {
-    PORTB |= _BV(PORTB5);
+
+  if (mode == 0) {
+    *ddr &= (uint8_t)~mask;
+    *port &= (uint8_t)~mask;
     return 0;
   }
-  if (sp_streq(cmd, "pin13:low")) {
-    PORTB &= (uint8_t)~_BV(PORTB5);
+
+  if (mode == 2) {
+    *ddr &= (uint8_t)~mask;
+    *port |= mask;
     return 0;
   }
+
   return 1;
 }
 
+int digital_write(uint8_t pin, uint8_t value) {
+  volatile uint8_t *port = rd_uno_port(pin);
+  uint8_t mask;
+
+  if (!port) {
+    return 1;
+  }
+
+  mask = (uint8_t)(1 << rd_uno_bit(pin));
+
+  if (value) {
+    *port |= mask;
+  } else {
+    *port &= (uint8_t)~mask;
+  }
+
+  return 0;
+}
+
+int digital_read(uint8_t pin) {
+  volatile uint8_t *reg = rd_uno_pin_reg(pin);
+
+  if (!reg) {
+    return -1;
+  }
+
+  return ((*reg & (uint8_t)(1 << rd_uno_bit(pin))) != 0) ? 1 : 0;
+}
+
+int analog_read(uint8_t pin) {
+  uint8_t channel = pin;
+
+  if (pin >= 14 && pin <= 19) {
+    channel = pin - 14;
+  }
+
+  if (channel > 5 || !rd_uno_valid_pin(pin)) {
+    return -1;
+  }
+
+  ADMUX = (uint8_t)((1 << REFS0) | channel);
+  ADCSRA = (uint8_t)((1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0));
+  ADCSRA |= (uint8_t)(1 << ADSC);
+
+  while (ADCSRA & (uint8_t)(1 << ADSC)) {
+  }
+
+  return ADC;
+}
+
 static void sp_arduino_delay_ms(unsigned long ms) {
   while (ms > 0) {
     _delay_loop_2((uint16_t)(F_CPU / 4000UL));
@@ -148,12 +261,10 @@ static void sp_arduino_delay_ms(unsigned long ms) {
   }
 }
 
-static void sp_arduino_sleep_seconds(double seconds) {
-  sp_arduino_delay_ms((unsigned long)(seconds * 1000.0 + 0.5));
+void delay_ms(uint32_t ms) {
+  sp_arduino_delay_ms(ms);
 }
 
-#define system(cmd) sp_arduino_system(cmd)
-#define sleep(seconds) sp_arduino_delay_ms((unsigned long)((seconds) * 1000.0 + 0.5))
 #define fflush(stream) ((void)0)
 
 #endif

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/spinel_arduino_codegen.rb

@@ -26,9 +26,6 @@ load_spinel_compiler
 module SpinelArduinoCodegen
   def compile_no_recv_call_expr(nid, mname)
     case mname
-    when "sleep"
-      compile_arduino_sleep(nid)
-      "0"
     when "rand"
       arduino_rand = compile_arduino_rand(nid)
       return arduino_rand if arduino_rand
@@ -41,21 +38,6 @@ module SpinelArduinoCodegen
 
   private
 
-  def compile_arduino_sleep(nid)
-    args_id = @nd_arguments[nid]
-    return if args_id < 0
-
-    arg_ids = get_args(args_id)
-    return if arg_ids.empty?
-
-    arg = arg_ids.first
-    if numeric_literal_node?(arg)
-      emit_arduino_delay_literal(numeric_literal_value(arg))
-    else
-      emit("  sp_arduino_sleep_seconds(" + compile_expr(arg) + ");")
-    end
-  end
-
   def compile_arduino_rand(nid)
     args_id = @nd_arguments[nid]
     return nil if args_id < 0
@@ -79,32 +61,9 @@ module SpinelArduinoCodegen
     "((mrb_int)(#{first} + (rand() % #{span})))"
   end
 
-  def emit_arduino_delay_literal(seconds)
-    ms = (seconds * 1000.0).round
-    parts = []
-    while ms >= 250
-      parts << "_delay_ms(250.0)"
-      ms -= 250
-    end
-    parts << "_delay_ms(#{ms}.0)" if ms > 0
-    emit("  " + parts.join("; ") + ";") unless parts.empty?
-  end
-
   def integer_literal_node?(nid)
     nid && nid >= 0 && @nd_type[nid] == "IntegerNode"
   end
-
-  def numeric_literal_node?(nid)
-    nid && nid >= 0 && %w[IntegerNode FloatNode].include?(@nd_type[nid])
-  end
-
-  def numeric_literal_value(nid)
-    if @nd_type[nid] == "IntegerNode"
-      @nd_value[nid].to_f
-    else
-      @nd_content[nid].to_f
-    end
-  end
 end
 
 Compiler.prepend(SpinelArduinoCodegen)

data/lib/rubyduino/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubyduino
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 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.3
 platform: ruby
 authors:
 - Joseph Schito
@@ -27,6 +27,7 @@ files:
 - examples/hello.rb
 - lib/rubyduino.rb
 - lib/rubyduino/arduino_entry.c
+- lib/rubyduino/arduino_uno.rb
 - lib/rubyduino/sp_runtime.h
 - lib/rubyduino/spinel.rb
 - lib/rubyduino/spinel_arduino_codegen.rb
@@ -345,6 +346,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 +412,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 +424,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 +569,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