qr_reader-native 0.0.1

data/ext/qr_reader_native/sp_exc.h

@@ -0,0 +1,186 @@
+#ifndef SP_EXC_H
+#define SP_EXC_H
+/* sp_exc.h -- sp_Exception struct + cold ops.
+ *
+ * sp_user_exc_parent_fn is a function-pointer HOOK (like
+ * sp_gc_mark_globals_hook): codegen's emitted main() sets it to the
+ * per-program sp_user_exc_parent (`sp_user_exc_parent_fn =
+ * sp_user_exc_parent;`), which stays static/resident since its body is
+ * program-specific. Everything that reaches the user exception hierarchy
+ * only needs the POINTER, resolved at runtime -- not the per-program
+ * function itself -- so it's a real cross-archive dependency, not a
+ * program-generated-code blocker. sp_pending_exc_recv/key/val/flags (the
+ * raise-site introspection staging slots) are the same shape: already
+ * SP_TLS globals, just needed `static` removed.
+ *
+ * sp_exc_sym_slot/sp_exc_recover_named (need sp_sym_intern, a REAL
+ * program-generated function whose body differs per compiled program --
+ * not a hook) stay in spinel_rt.h,
+ * along with sp_exc_reason_acc/sp_exc_tag_acc (the two accessors that
+ * call sp_exc_sym_slot) and the raise/longjmp control flow
+ * (sp_raise_exc/sp_raise_cls and friends), which threads through the
+ * TU-local exception-stack globals.
+ *
+ * 0 optcarrot uses for every function below.
+ */
+#include "sp_types.h"   /* sp_int, sp_bool */
+#include "sp_gc.h"      /* sp_RbVal, sp_gc_alloc, sp_gc_mark, sp_mark_string */
+#include "sp_alloc.h"   /* sp_box_nil/int, sp_str_empty, sp_raise_cls, sp_sprintf */
+#include <signal.h>     /* SIGINT for sp_exc_new's Interrupt#signo default */
+
+typedef struct sp_Exception_s {
+  const char *cls_name;
+  const char *parent_cls_name; /* builtin ancestor for user subclasses, or NULL */
+  const char *msg;
+  struct sp_Exception_s *cause; /* the exception being handled when this was raised, or NULL */
+  sp_RbVal result;             /* StopIteration#result (the iteration's return value); nil otherwise */
+  sp_RbVal xname;              /* NameError/NoMethodError#name (the missing name); nil otherwise */
+  sp_RbVal xkey;               /* KeyError#key / UncaughtThrowError#tag / LocalJumpError#reason /
+                                  NoMethodError#args; nil otherwise */
+  sp_RbVal xrecv;              /* KeyError/NameError/NoMethodError/FrozenError#receiver; nil otherwise */
+  sp_bool has_recv;           /* was a receiver actually recorded? nil is a legal
+                                  receiver (nil.foo), so the box cannot say (#3036) */
+  sp_bool has_key;            /* likewise for KeyError#key (#3030) */
+  sp_bool priv_call;          /* NoMethodError#private_call? (#3042) */
+  sp_StrArray *backtrace;     /* an attached backtrace set by #set_backtrace; nil
+                                 means "no caller ever set one" (CRuby answers
+                                 nil for the unset case). The GC mark visits it
+                                 alongside the boxed fields. */
+  void *msg_h;                /* the message as a shared String handle (an
+                                 sp_String *), or NULL: a program built
+                                 --share-strings raises with the String it
+                                 was given, which #message answers itself
+                                 (sp_exc_attach_msg). Read the message
+                                 through sp_exc_message / sp_exc_msg_text. */
+} sp_Exception;
+
+extern const char *(*sp_user_exc_parent_fn)(const char *);   /* set by the generated main() */
+/* The modules a class includes, NULL-terminated, or NULL for none. Ruby's type
+   hierarchy is not a chain -- `rescue IO::WaitReadable` and `e.is_a?(Retryable)`
+   both ask about a MODULE, which a single-parent walk cannot answer. Same shape
+   as the parent hook: a builtin table plus a per-program hook. */
+extern const char *const *(*sp_user_exc_modules_fn)(const char *);
+const char *const *sp_exc_modules_of_name(const char *cls);
+/* CRuby aliases some exception classes to one object (Errno::EWOULDBLOCK IS
+   Errno::EAGAIN). Names cannot express identity, so both sides of a match are
+   canonicalized first. Returns `cls` itself when it has no alias. */
+const char *sp_exc_canonical_name(const char *cls);
+extern SP_TLS sp_RbVal sp_pending_exc_recv, sp_pending_exc_key, sp_pending_exc_val;
+extern SP_TLS unsigned char sp_pending_exc_flags;
+
+int sp_exc_cls_matches(const char *raised, const char *target);
+sp_bool sp_exc_has_acc(sp_Exception *e, const char *acc);   /* has the class-gated accessor */
+int sp_exc_nearest_cls(const char *raised, const char *const *targets, int n);
+SP_COLD void sp_exc_acc_gate(sp_Exception *e, const char *cls, const char *acc);
+int sp_exc_is_standard_error(const char *raised);
+sp_Exception *sp_exc_new_for_catch(const char *cls, const char *msg);
+/* The message a bare `raise` carries: empty, and distinct from "no message
+   given" (which falls back to the class name, as Exception.new does) (#3711). */
+extern const char *const sp_exc_no_msg;
+/* The same for an explicitly given empty literal (`raise C, ""`), whose
+   message CRuby keeps frozen: also "" to every reader of the raw message,
+   and an exception built from it holds a frozen "". */
+extern const char *const sp_exc_no_msg_frozen;
+/* Is m one of the two explicit-empty sentinels? A raise's message is
+   laundered onto the heap unless it is one, which keeps its identity. */
+static inline int sp_exc_msg_empty_given(const char *m) {
+  return m == sp_exc_no_msg || m == sp_exc_no_msg_frozen;
+}
+/* An explicitly given raise message: an empty one stays empty rather than
+   falling back to the class name the way a message-less raise does. */
+const char *sp_exc_msg_counted(const char *m, size_t n);   /* lib/sp_exc.c */
+const char *sp_exc_msg_counted_frozen(const char *m, size_t n);   /* the same, for a frozen String */
+const char *sp_exc_msg_plain(const char *m);   /* a frozen counted message as frozen text */
+const char *sp_exc_cat(int n, ...);   /* parts joined by byte length, NULs kept */
+const char *sp_exc_full_text(volatile sp_Exception *e, const char *msg);       /* "Class: msg" */
+const char *sp_exc_detailed_text(volatile sp_Exception *e, const char *msg);   /* "msg (Class)" */
+/* m is a Spinel String here (the generated code gives only those), so its header's
+   length is safe to read; a NUL inside it travels as a counted message (#7556). */
+static inline const char *sp_exc_msg_given(const char *m) {
+  if (!m) return m;
+  size_t n = sp_str_byte_len(m);
+  /* a frozen String (a literal) travels counted with its frozen mark, an
+     empty one as the frozen empty sentinel */
+  if (sp_str_is_frozen_val(m)) return n == 0 ? sp_exc_no_msg_frozen : sp_exc_msg_counted_frozen(m, n);
+  if (n == 0) return sp_exc_no_msg;
+  return memchr(m, 0, n) ? sp_exc_msg_counted(m, n) : m;
+}
+void *sp_exc_new_sub_sized(size_t sz, const char *cls_name, const char *msg);
+
+void sp_exc_gc_scan(void *p);
+sp_Exception *sp_exc_new(const char *cls_name, const char *msg);
+sp_bool sp_exc_eq(sp_Exception *a, sp_Exception *b);
+/* Exception#set_backtrace: attach (or replace) the backtrace array. The
+ * StrArray is GC-managed; the sp_Exception holds a single owner reference
+ * and is updated in place. Returns the boxed value so chained assignments
+ * (`e = e.set_backtrace(bt)`) work. */
+sp_RbVal sp_Exception_set_backtrace(sp_Exception *e, sp_StrArray *bt);
+sp_Exception *sp_exc_new_sub(const char *cls_name, const char *parent_cls, const char *msg);
+sp_Exception *sp_exc_dup(sp_Exception *e);
+void *sp_exc_apply_staged(const char *cls, const char *msg, void *obj);
+int sp_exc_exit_status(void *obj);
+sp_Exception *sp_exc_exception(sp_Exception *e, const char *msg);
+const char *sp_exc_class_name(volatile sp_Exception *ve);
+const char *sp_exc_message(volatile sp_Exception *ve);
+/* the message's text now, not to be kept (a handle's live buffer) */
+const char *sp_exc_msg_text(volatile sp_Exception *ve);
+/* e with the String handle h as its message (sp_Exception.msg_h); answers e */
+void *sp_exc_attach_msg(void *e, void *h);
+/* #to_s as #inspect renders it: a user override (the generated program's
+   sp_user_exc_to_s, installed in the hook) else the stored message */
+extern const char *(*sp_user_exc_to_s_fn)(sp_Exception *);
+const char *sp_exc_to_s_text(sp_Exception *e);
+const char *sp_exc_inspect(void *p);   /* #<Cls: msg>, for the inspect dispatch */
+sp_Exception *sp_exc_cause(volatile sp_Exception *ve);
+sp_RbVal sp_exc_result(volatile sp_Exception *ve);
+const char *sp_errno_class_name(int e);   /* "Errno::ENOENT" for ENOENT; the parent for an unlisted one */
+sp_RbVal sp_exc_errno_acc(sp_Exception *e);   /* SystemCallError#errno */
+enum { SP_SYSERR_NONE, SP_SYSERR_NUM, SP_SYSERR_BASE, SP_SYSERR_BARE };
+int sp_syserr_kind(const char *cls, sp_int *num);   /* where cls stands in the SystemCallError family */
+const char *sp_syserr_text(int has_num, sp_int num, const char *func, const char *msg);
+void sp_exc_syserr_init(sp_Exception *e);   /* #errno from the class's Errno ancestor */
+sp_int sp_errno_num(const char *cls);   /* Errno::ENOENT::Errno */
+const char *sp_exc_parent_of_name(const char *cls);
+sp_RbVal sp_exc_name_acc(sp_Exception *e);
+sp_RbVal sp_exc_key_acc(sp_Exception *e);
+sp_RbVal sp_exc_receiver_acc(sp_Exception *e);
+sp_RbVal sp_exc_args_acc(sp_Exception *e);
+sp_RbVal sp_exc_path_acc(sp_Exception *e);   /* LoadError#path */
+sp_bool sp_exc_private_call_acc(sp_Exception *e);
+sp_RbVal sp_exc_exit_value_acc(sp_Exception *e);
+sp_RbVal sp_exc_throw_value_acc(sp_Exception *e);
+sp_int sp_exc_status_acc(sp_Exception *e);
+sp_bool sp_exc_success_acc(sp_Exception *e);
+sp_int sp_exc_signo_acc(sp_Exception *e);
+const char *sp_exc_signm_acc(sp_Exception *e);
+
+/* ---- Signal/Interrupt exception constructors: relocated from
+   spinel_rt.h (0 optcarrot uses). sp_signal_resolve/sp_signal_signame
+   are already non-static (resolved at the final link). ---- */
+int sp_signal_resolve(sp_RbVal sig);
+const char *sp_signal_signame(sp_int no);
+sp_Exception *sp_signal_exc_new_m(sp_RbVal sig, const char *msg);
+sp_Exception *sp_signal_exc_new(sp_RbVal sig);
+sp_Exception *sp_interrupt_new(const char *msg);
+
+/* ---- The arity ArgumentError every binder raises: CRuby's words for a
+   positional count the callee cannot take (rb_arity_error_new): `given G,
+   expected N` for an exact count, `N..M` with optionals, `N+` past a rest
+   (max < 0). `kw` is NULL or the "; required keyword(s): a, b" CRuby appends
+   for a callee with required keywords (argument_arity_error, vm_args.c) --
+   a fact of the signature the compiler spells (arity_kw_suffix), so the
+   run-time count and the compile-time one read the same. ---- */
+SP_NORETURN void sp_raise_arity(sp_int given, sp_int min, sp_int max, const char *kw);
+static inline void sp_arity_check(sp_int given, sp_int min, sp_int max, const char *kw) {
+  if (given < min || (max >= 0 && given > max)) sp_raise_arity(given, min, max, kw);
+}
+/* The keyword ArgumentErrors in CRuby's words (argument_kw_error): `kind`
+   "missing" or "unknown", naming the `count` keywords in `names`, each
+   already inspected and joined by ", ". */
+SP_NORETURN void sp_raise_kw_error(const char *kind, sp_int count, const char *names);
+/* Exception#is_a?(ClassName), modules and the user hierarchy included. */
+sp_int sp_exc_is_a(volatile sp_Exception *ve, const char *cn);
+/* A fixed-depth handler stack overflowed: CRuby's words on stderr, then exit. */
+SP_NORETURN SP_COLD void sp_stack_too_deep(void);
+
+#endif

data/ext/qr_reader_native/sp_exc_ctx.h

@@ -0,0 +1,56 @@
+#ifndef SP_EXC_CTX_H
+#define SP_EXC_CTX_H
+/* sp_exc_ctx.h -- the per-fiber exception/catch handler context (#1474) and
+ * the proc-return home node whose chain it carries.
+ *
+ * Types only, plus the three context operations that touch nothing else
+ * (sp_exc_ctx_new/free/mark, lib/sp_exc.c). sp_exc_ctx_save/load copy the
+ * handler stacks in and out, and those stacks are TU-local statics of
+ * spinel_rt.h, so the two stay there. */
+#include <setjmp.h>
+#include "sp_types.h"   /* sp_int */
+#include "sp_gc.h"      /* sp_RbVal */
+#include "sp_inspect.h" /* sp_poly_recur_frame */
+
+/* A non-lambda proc's home method: a node on that method's C stack, linked
+   onto the per-fiber chain sp_proc_ret_head (see the proc-return machinery in
+   spinel_rt.h). */
+typedef struct sp_proc_home {
+  jmp_buf jb;                 /* the home method's setjmp target (on its C stack) */
+  sp_RbVal val;               /* the in-flight return value (nil until delivered) */
+  int exc_top;                /* sp_exc_top at the method's entry */
+  int catch_top;              /* sp_catch_top at the method's entry */
+  int recur_mark;             /* walk-path depth at the method's entry (see sp_poly_recur_mark) */
+  sp_int id;                 /* fresh id captured by the home's returning procs */
+  struct sp_proc_home *prev;  /* enclosing home, forming the per-fiber chain */
+} sp_proc_home;
+
+/* The live prefix of every handler array, saved into the outgoing fiber's
+   context and loaded from the incoming one's at each switch. */
+typedef struct {
+  jmp_buf *es; const char **em; const char **ec; void **eo; int en, ecap;
+  jmp_buf *cs; const char **ct; unsigned char *ctk; sp_RbVal *cv; int *cet;  int cn, ccap;
+  jmp_buf *bs; sp_RbVal *bv; sp_int *bser; int *bet;     int bn, bcap;  /* break scopes */
+  sp_proc_home *prhead;  /* this fiber's proc-return chain head (nodes on its C stack) */
+  int uk, ut, ue; sp_proc_home *uh;  /* transient unwind state (in flight only while running ensures) */
+  void **shand; int rn, rcap;        /* sp_exc_handling prefix [0..sp_rescue_sp) */
+  void *pcause;                      /* sp_pending_cause */
+  void *icause;                      /* sp_inflight_cause: the exception an ensure body runs for */
+  sp_poly_recur_frame *rrf; int rrn, rrcap;  /* sp_poly_recur_stack prefix [0..sp_poly_recur_top) */
+  int *rrem, *rrcm, *rrbm;           /* the walk-path marks of the exception, catch and break arms */
+  int *erm, *ersm, *crm;             /* the GC-root and rescue-stack watermarks of the exception
+                                        arms and the GC-root watermark of the catch arms: what a
+                                        handler restores sp_gc_nroots / sp_rescue_sp to. They are
+                                        per worker like the arms, so without travelling with the
+                                        context a green thread that parked inside a begin and
+                                        resumed after another fiber's arm sat at the same index
+                                        restored the OTHER fiber's watermark: a raise's dead root
+                                        stayed on the list and the next collection read a stack
+                                        slot that was no longer a string (#4546) */
+} sp_exc_ctx_t;
+
+void *sp_exc_ctx_new(void);
+void sp_exc_ctx_free(void *p);
+void sp_exc_ctx_mark(void *p);   /* GC: a suspended fiber's carried exc objects */
+
+#endif