rubyduino 0.1.1

data/vendor/spinel/lib/erb.rb

@@ -0,0 +1,19 @@
+# Spinel lib: erb
+#
+# Minimal ERB placeholder. Full ERB requires eval which is AOT-incompatible.
+# For lrama, output.rb should be rewritten to use direct string generation.
+
+class ERB
+  def initialize(input, opts)
+    @input = input
+    @filename = ""
+  end
+
+  def filename=(name)
+    @filename = name
+  end
+
+  def result_with_hash(vars)
+    @input
+  end
+end

data/vendor/spinel/lib/forwardable.rb

@@ -0,0 +1,8 @@
+# Spinel stub: forwardable
+#
+# Provides Forwardable module with def_delegators.
+# In Spinel, extend Forwardable is a no-op and def_delegators
+# is handled at compile time by generating forwarding methods.
+
+module Forwardable
+end

data/vendor/spinel/lib/mruby_shim.h

@@ -0,0 +1,118 @@
+/*
+ * Minimal shim to compile mruby-bigint without the full mruby runtime.
+ * Provides just enough types and macros for bigint.c to compile standalone.
+ */
+#ifndef MRUBY_SHIM_H
+#define MRUBY_SHIM_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+
+/* GCC < 10 doesn't predefine __has_builtin, so #if expressions like
+   `defined(__GNUC__) || __has_builtin(...)` choke on the bare token.
+   Provide a no-op fallback so the || short-circuits cleanly on the
+   left when the compiler doesn't support __has_builtin (issue #55). */
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+/* Basic mruby types */
+typedef int64_t mrb_int;
+typedef uint64_t mrb_uint;
+typedef double mrb_float;
+typedef int mrb_bool;
+#define TRUE 1
+#define FALSE 0
+#define MRB_INT_MAX INT64_MAX
+#define MRB_INT_MIN INT64_MIN
+#define MRB_INT_BIT 64
+
+/* mrb_state stub */
+typedef struct mrb_state {
+  int dummy;
+} mrb_state;
+
+/* Memory allocation */
+#define mrb_malloc(mrb, sz) malloc(sz)
+#define mrb_realloc(mrb, p, sz) realloc(p, sz)
+#define mrb_free(mrb, p) free(p)
+#define mrb_malloc_simple(mrb, sz) malloc(sz)
+
+/* Error handling — sp_bigint.c is compiled as a separate TU and
+   would otherwise hard-exit on internal errors (mini-gmp's zero-
+   divisor check, allocation overflow, etc.). The mrb_raise macro
+   now dispatches on the symbolic class enum: ZeroDivisionError is
+   routed through sp_bigint_raise_zerodiv (defined non-static in
+   sp_runtime.h, linked from gen.c) so it reaches spinel's longjmp
+   rescue net and is catchable by `rescue ZeroDivisionError`.
+   Other classes still hard-exit — they're internal invariants
+   (allocation overflow) where graceful handling buys little. */
+extern void sp_bigint_raise_zerodiv(const char *msg);
+#define E_RANGE_ERROR 1
+#define E_RUNTIME_ERROR 2
+#define E_ARGUMENT_ERROR 3
+#define E_TYPE_ERROR 4
+#define E_ZERODIV_ERROR 5
+#define mrb_raise(mrb, cls, msg) do { \
+  if ((cls) == E_ZERODIV_ERROR) { sp_bigint_raise_zerodiv(msg); } \
+  else { fprintf(stderr, "%s\n", msg); exit(1); } \
+} while(0)
+#define mrb_int_zerodiv(mrb) sp_bigint_raise_zerodiv("divided by 0")
+
+/* mrb_value stub - tagged union */
+typedef struct mrb_value {
+  union {
+    mrb_int i;
+    mrb_float f;
+    void *p;
+  } value;
+  int tt;
+} mrb_value;
+
+enum mrb_vtype {
+  MRB_TT_FALSE = 0,
+  MRB_TT_TRUE,
+  MRB_TT_INTEGER,
+  MRB_TT_FLOAT,
+  MRB_TT_STRING,
+  MRB_TT_BIGINT,
+};
+
+#define mrb_integer(v) ((v).value.i)
+#define mrb_float(v) ((v).value.f)
+#define mrb_ptr(v) ((v).value.p)
+#define mrb_type(v) ((v).tt)
+#define mrb_integer_p(v) ((v).tt == MRB_TT_INTEGER)
+#define mrb_float_p(v) ((v).tt == MRB_TT_FLOAT)
+#define mrb_bigint_p(v) ((v).tt == MRB_TT_BIGINT)
+#define mrb_fixnum_value(i) ((mrb_value){{.i=(i)}, MRB_TT_INTEGER})
+#define mrb_int_value(mrb, i) mrb_fixnum_value(i)
+
+/* Object header stub */
+#define MRB_OBJECT_HEADER uint32_t flags; uint32_t _pad
+#define mrb_obj_ptr(v) ((struct RBasic*)mrb_ptr(v))
+#define mrb_static_assert_object_size(t) /* nop */
+#define mrb_assert(x) assert(x)
+
+/* String */
+#define RSTRING_PTR(s) ((const char*)mrb_ptr(s))
+#define RSTRING_LEN(s) ((mrb_int)strlen(RSTRING_PTR(s)))
+
+/* nil value */
+static inline mrb_value mrb_nil_value(void) {
+  mrb_value v; v.tt = MRB_TT_FALSE; v.value.i = 0; return v;
+}
+
+/* MRB_ENSURE stub - execute body, no exception handling */
+#define MRB_ENSURE(mrb, exc, body, data) \
+  { mrb_value exc = body(mrb, data); (void)exc; } if(0)
+
+/* Bigint object creation */
+struct RBasic {
+  MRB_OBJECT_HEADER;
+};
+
+#endif /* MRUBY_SHIM_H */

data/vendor/spinel/lib/optparse.rb

@@ -0,0 +1,123 @@
+# Spinel stub: optparse
+#
+# Minimal OptionParser implementation for Spinel compilation.
+# Supports the subset of OptionParser used by lrama:
+#   - .on(flag, desc) { |v| ... }  (2-4 args with block)
+#   - .banner=
+#   - .separator(text)
+#   - .on_tail(text)
+#   - .parse!(argv)
+#   - OptionParser::ParseError
+
+class OptionParser
+  class ParseError
+    def initialize(msg)
+      @message = msg
+    end
+
+    def message
+      @message
+    end
+
+    def to_s
+      @message
+    end
+  end
+
+  def initialize
+    @banner = ""
+    @short_flags = []
+    @long_flags = []
+    @handlers = []
+    @expects_value = []
+  end
+
+  def banner=(text)
+    @banner = text
+  end
+
+  def separator(text)
+  end
+
+  def on_tail(text)
+  end
+
+  def on(a1, a2, &block)
+    short = ""
+    long = ""
+    has_value = false
+    if a1[0] == "-" && a1[1] == "-"
+      long = a1
+    else
+      short = a1
+    end
+    if a2[0] == "-" && a2[1] == "-"
+      long = a2
+    end
+    if long.include?("=")
+      has_value = true
+    end
+    @short_flags.push(short)
+    @long_flags.push(long)
+    @handlers.push(block)
+    @expects_value.push(has_value)
+  end
+
+  def parse!(argv)
+    new_argv = []
+    i = 0
+    while i < argv.length
+      arg = argv[i]
+      matched = false
+      j = 0
+      while j < @handlers.length
+        sf = @short_flags[j]
+        lf = @long_flags[j]
+        ev = @expects_value[j]
+        if ev && lf != ""
+          # extract base flag name before "="
+          eq_pos = lf.index("=")
+          if eq_pos
+            base = lf[0, eq_pos]
+          else
+            base = lf
+          end
+          # --flag=VALUE form
+          if arg.length > base.length && arg[0, base.length] == base && arg[base.length] == "="
+            value = arg[(base.length + 1), (arg.length - base.length - 1)]
+            @handlers[j].call(value)
+            matched = true
+          # --flag VALUE form
+          elsif arg == base
+            i += 1
+            if i < argv.length
+              @handlers[j].call(argv[i])
+            end
+            matched = true
+          end
+        else
+          if arg == sf || arg == lf
+            @handlers[j].call(true)
+            matched = true
+          end
+        end
+        j += 1
+      end
+      if !matched
+        new_argv.push(arg)
+      end
+      i += 1
+    end
+    # replace argv contents with unmatched args
+    argv.clear
+    k = 0
+    while k < new_argv.length
+      argv.push(new_argv[k])
+      k += 1
+    end
+  end
+
+  def to_s
+    @banner
+  end
+end