carray 3.0.4 → 3.0.5

data/ext/carray_sort.c

@@ -103,16 +103,207 @@ sort_addr_merge (struct sort_addr_key *a, struct sort_addr_key *aux,
                  ca_size_t n, int (*cmp)(const void *, const void *))
 CA_SORT_MERGE_BY_CMP(struct sort_addr_key)
 
+/* -------------------------------------------------------------------
+
+  Multi-key sort by refinement (MSD), for keys of the numeric data types.
+
+  The first key is sorted whole by the typed pair kernel
+  (ca_sort_quick_pair_*); then only the runs of rows that tie on it are
+  sorted by the second key, and so on, until no run is left or the keys
+  run out.  The answer is the one sort_addr_cmp gives:
+
+  - a pair sorts by (value, row), so rows that tie on every key stay in
+    row order (the stable tie-break of sort_addr_cmp);
+  - each run is split into numbers, NaN and masked cells, in the order
+    sort_addr_cmp puts them (numbers, NaN, masked for masked_last;
+    masked, numbers, NaN otherwise).  The NaN and the masked cells of a
+    run tie among themselves (CA_FLOAT_ORDER_CMP / sort_addr_cmp), so
+    each is a run for the next key.  The split is a stable one done in
+    the load, not ca_partition_nan_pair_*, which allocates on every call
+    and is called here once per run;
+  - -0.0 and 0.0 tie, by == as by CA_FLOAT_ORDER_CMP.
+
+  A run is (lo, n): the rows perm[lo..lo+n).  Within a run the rows are
+  in row order, since they tie on every key before it, so the stable
+  split keeps them so.
+
+------------------------------------------------------------------- */
+
+typedef struct {
+  ca_size_t lo;
+  ca_size_t n;
+} msd_run_t;
+
+typedef struct {
+  msd_run_t *runs;
+  ca_size_t  count;
+} msd_runs_t;
+
+static void
+msd_add_run (msd_runs_t *out, ca_size_t lo, ca_size_t n)
+{
+  if ( out && n > 1 ) {
+    out->runs[out->count].lo = lo;
+    out->runs[out->count].n  = n;
+    out->count++;
+  }
+}
+
+/* Sort each run of +in+ by +key+, writing the new order into perm, and
+   add the runs that still tie to +out+ (NULL for the last key). */
+#define DEFINE_MSD_REFINE(TYPE, SUFFIX, IS_FLOAT)                             \
+static void                                                                   \
+msd_refine_##SUFFIX (CArray *key, ca_size_t *perm, void *vbuf,                \
+                     msd_runs_t *in, msd_runs_t *out, int masked_last)        \
+{                                                                             \
+  const TYPE *ptr = (const TYPE *) key->ptr;                                  \
+  const boolean8_t *m = ( key->mask ) ? (boolean8_t *) key->mask->ptr : NULL; \
+  ca_pair_##SUFFIX *buf = (ca_pair_##SUFFIX *) vbuf;                          \
+  ca_size_t r;                                                                \
+                                                                              \
+  for (r=0; r<in->count; r++) {                                               \
+    ca_size_t lo = in->runs[r].lo;                                            \
+    ca_size_t n  = in->runs[r].n;                                             \
+    ca_size_t *p = perm + lo;                                                 \
+    ca_size_t n_num = 0, n_nan = 0, n_mask = 0;                               \
+    ca_size_t o_num, o_nan, o_mask;                                           \
+    ca_size_t k, s;                                                           \
+                                                                              \
+    for (k=0; k<n; k++) {                                                     \
+      ca_size_t row = p[k];                                                   \
+      if ( m && m[row] )                 n_mask++;                            \
+      else if ( IS_FLOAT && isnan((double) ptr[row]) ) n_nan++;               \
+      else                               n_num++;                             \
+    }                                                                         \
+    o_mask = masked_last ? n_num + n_nan : 0;                                 \
+    o_num  = masked_last ? 0 : n_mask;                                        \
+    o_nan  = o_num + n_num;                                                   \
+    {                                                                         \
+      ca_size_t i_num = o_num, i_nan = o_nan, i_mask = o_mask;                \
+      for (k=0; k<n; k++) {                                                   \
+        ca_size_t row = p[k];                                                 \
+        TYPE v = ptr[row];                                                    \
+        ca_size_t at;                                                         \
+        if ( m && m[row] )             at = i_mask++;                         \
+        else if ( IS_FLOAT && isnan((double) v) ) at = i_nan++;               \
+        else                           at = i_num++;                          \
+        buf[at].v = v;                                                        \
+        buf[at].i = row;                                                      \
+      }                                                                       \
+    }                                                                         \
+    ca_sort_quick_pair_##SUFFIX(buf + o_num, n_num);                          \
+    for (k=0; k<n; k++) {                                                     \
+      p[k] = buf[k].i;                                                        \
+    }                                                                         \
+    if ( ! out ) continue;                                                    \
+    for (s=0, k=1; k<=n_num; k++) {                                           \
+      if ( k == n_num || buf[o_num + k].v != buf[o_num + s].v ) {             \
+        msd_add_run(out, lo + o_num + s, k - s);                              \
+        s = k;                                                                \
+      }                                                                       \
+    }                                                                         \
+    msd_add_run(out, lo + o_nan,  n_nan);                                     \
+    msd_add_run(out, lo + o_mask, n_mask);                                    \
+  }                                                                           \
+}
+
+DEFINE_MSD_REFINE(int8_t,    i8,  0)
+DEFINE_MSD_REFINE(uint8_t,   u8,  0)
+DEFINE_MSD_REFINE(int16_t,   i16, 0)
+DEFINE_MSD_REFINE(uint16_t,  u16, 0)
+DEFINE_MSD_REFINE(int32_t,   i32, 0)
+DEFINE_MSD_REFINE(uint32_t,  u32, 0)
+DEFINE_MSD_REFINE(int64_t,   i64, 0)
+DEFINE_MSD_REFINE(uint64_t,  u64, 0)
+DEFINE_MSD_REFINE(float32_t, f32, 1)
+DEFINE_MSD_REFINE(double,    f64, 1)
+
+/* Whether every key has a typed pair kernel, so that MSD can sort them. */
+static int
+msd_is_sortable (struct cmp_base *base)
+{
+  int j;
+  for (j=0; j<base->n; j++) {
+    switch ( base->ca[j]->data_type ) {
+    case CA_BOOLEAN: case CA_INT8:  case CA_UINT8:
+    case CA_INT16:   case CA_UINT16:
+    case CA_INT32:   case CA_UINT32:
+    case CA_INT64:   case CA_UINT64:
+    case CA_FLOAT32: case CA_FLOAT64:
+      break;
+    default:
+      return 0;
+    }
+  }
+  return 1;
+}
+
+typedef struct {
+  struct cmp_base *base;
+  ca_size_t       *perm;      /* elements rows, the answer */
+  void            *buf;       /* elements pairs of 16 bytes */
+  msd_run_t       *runs[2];   /* elements / 2 + 1 runs each */
+  ca_size_t        elements;
+} msd_sort_t;
+
+static void
+msd_sort (msd_sort_t *s)
+{
+  struct cmp_base *base = s->base;
+  msd_runs_t a, b, *in = &a, *out = &b;
+  ca_size_t i;
+  int j;
+
+  for (i=0; i<s->elements; i++) {
+    s->perm[i] = i;
+  }
+  a.runs = s->runs[0];  a.count = 0;
+  b.runs = s->runs[1];  b.count = 0;
+  msd_add_run(in, 0, s->elements);
+
+  for (j=0; j<base->n && in->count > 0; j++) {
+    CArray *key = base->ca[j];
+    msd_runs_t *next = ( j < base->n - 1 ) ? out : NULL;
+    msd_runs_t *t;
+    if ( next ) next->count = 0;
+    switch ( key->data_type ) {
+    case CA_BOOLEAN:
+    case CA_INT8:    msd_refine_i8 (key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_UINT8:   msd_refine_u8 (key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_INT16:   msd_refine_i16(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_UINT16:  msd_refine_u16(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_INT32:   msd_refine_i32(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_UINT32:  msd_refine_u32(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_INT64:   msd_refine_i64(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_UINT64:  msd_refine_u64(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_FLOAT32: msd_refine_f32(key, s->perm, s->buf, in, next, base->masked_last); break;
+    case CA_FLOAT64: msd_refine_f64(key, s->perm, s->buf, in, next, base->masked_last); break;
+    default:
+      rb_raise(rb_eRuntimeError, "%s: [BUG] data type %d has no pair kernel",
+               ca_calling_method_name(), (int) key->data_type);
+    }
+    if ( ! next ) break;
+    t = in; in = out; out = t;
+  }
+}
+
+/* ----------------------------------------------------------------- */
+
 typedef struct {
   struct sort_addr_key *data;
   struct sort_addr_key *aux;     /* NULL: no object key, libc sorts */
   ca_size_t             elements;
+  msd_sort_t           *msd;     /* non-NULL: every key is numeric, sort by MSD */
 } sort_addr_run_t;
 
 static VALUE
 sort_addr_run (VALUE arg)
 {
   sort_addr_run_t *r = (sort_addr_run_t *) arg;
+  if ( r->msd ) {
+    msd_sort(r->msd);
+    return Qnil;
+  }
   if ( r->aux ) {
     sort_addr_merge(r->data, r->aux, r->elements,
                     (int (*)(const void*,const void*)) sort_addr_cmp);
@@ -145,8 +336,9 @@ rb_ca_s_sort_addr_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
   CArray *co;
   struct cmp_base base_s, *base = &base_s;
   struct sort_addr_key *data;
-  volatile VALUE hlist = 0, hdata = 0, haux = 0, hmodes = 0;
+  volatile VALUE hlist = 0, hdata = 0, haux = 0, hmodes = 0, hruns0 = 0, hruns1 = 0;
   sort_addr_run_t run;
+  msd_sort_t msd;
   char *modes;
   int has_object = 0;
   ca_size_t elements;
@@ -203,26 +395,42 @@ rb_ca_s_sort_addr_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
   }
   modes[argc] = '\0';
 
-  data = ALLOCV_N(struct sort_addr_key, hdata, elements);
-  for (i=0; i<elements; i++) {
-    data[i].i = i;
-    data[i].base = base;
-  }
-
-  run.data     = data;
-  run.aux      = has_object ? ALLOCV_N(struct sort_addr_key, haux, elements) : NULL;
-  run.elements = elements;
-  ca_attach_window(argc, base->ca, modes, sort_addr_run, (VALUE) &run);
-
   out = rb_ca_template_with_type(argv[0], INT2NUM(CA_SIZE), INT2NUM(0));
   TypedData_Get_Struct(out, CArray, &carray_data_type, co);
   q = (ca_size_t *) co->ptr;
-  
-  for (i=0; i<elements; i++) {
-    *q = data[i].i;
-    q++;
+
+  run.data     = NULL;
+  run.aux      = NULL;
+  run.elements = elements;
+  run.msd      = NULL;
+
+  if ( msd_is_sortable(base) ) {
+    ca_size_t nruns = elements / 2 + 1;
+    msd.base     = base;
+    msd.perm     = q;
+    msd.buf      = ALLOCV(hdata, (size_t) elements * sizeof(ca_pair_f64));
+    msd.runs[0]  = ALLOCV_N(msd_run_t, hruns0, nruns);
+    msd.runs[1]  = ( argc > 1 ) ? ALLOCV_N(msd_run_t, hruns1, nruns) : NULL;
+    msd.elements = elements;
+    run.msd      = &msd;
+    ca_attach_window(argc, base->ca, modes, sort_addr_run, (VALUE) &run);
+  }
+  else {
+    data = ALLOCV_N(struct sort_addr_key, hdata, elements);
+    for (i=0; i<elements; i++) {
+      data[i].i = i;
+      data[i].base = base;
+    }
+    run.data = data;
+    run.aux  = has_object ? ALLOCV_N(struct sort_addr_key, haux, elements) : NULL;
+    ca_attach_window(argc, base->ca, modes, sort_addr_run, (VALUE) &run);
+    for (i=0; i<elements; i++) {
+      q[i] = data[i].i;
+    }
   }
 
+  ALLOCV_END(hruns1);
+  ALLOCV_END(hruns0);
   ALLOCV_END(haux);
   ALLOCV_END(hdata);
   ALLOCV_END(hmodes);

data/ext/carray_sort_kernel.c

@@ -453,16 +453,15 @@ DEFINE_PARTITION_NAN(double,    f64);
    preserved), so argsort on NaN-containing input keeps NaN indices
    in ascending order.
 
-   Implementation: 2-pass stable filter via xmalloc scratch (single
-   xmalloc + xfree per fiber; negligible overhead vs the sort
-   itself). */
+   Implementation: 2-pass stable filter through scratch, n pairs that
+   the caller provides.  The caller takes it before it opens its walks:
+   an allocation here, inside the walk, would raise past their finish. */
 #define DEFINE_PARTITION_NAN_PAIR(TYPE, SUFFIX)                            \
 ca_size_t                                                                  \
-ca_partition_nan_pair_##SUFFIX (ca_pair_##SUFFIX *a, ca_size_t n)          \
+ca_partition_nan_pair_##SUFFIX (ca_pair_##SUFFIX *a, ca_size_t n,          \
+                                ca_pair_##SUFFIX *scratch)                 \
 {                                                                          \
   if ( n == 0 ) return 0;                                                  \
-  ca_pair_##SUFFIX *scratch =                                              \
-    (ca_pair_##SUFFIX *) xmalloc((size_t) n * sizeof(ca_pair_##SUFFIX));   \
   ca_size_t fin = 0, nan_pos = 0;                                          \
   for ( ca_size_t k = 0; k < n; k++ ) {                                    \
     if ( !isnan(a[k].v) ) scratch[fin++] = a[k];                           \
@@ -472,7 +471,6 @@ ca_partition_nan_pair_##SUFFIX (ca_pair_##SUFFIX *a, ca_size_t n)          \
     if ( isnan(a[k].v) ) scratch[finite_count + nan_pos++] = a[k];         \
   }                                                                        \
   memcpy(a, scratch, (size_t) n * sizeof(ca_pair_##SUFFIX));               \
-  xfree(scratch);                                                          \
   return finite_count;                                                     \
 }                                                                          \
 struct ca_partition_nan_pair_##SUFFIX##_eat_semicolon

data/ext/carray_struct.c

@@ -194,20 +194,40 @@ ca_struct_write_primitive_fast (char *p, int type_code, VALUE val)
    to keep neighbouring bits untouched.
    --------------------------------------------------------------------- */
 
+/* The word's bytes are read and written least significant first on
+   every host: the layout numbers the bits byte by byte from the record's
+   start, so a field read through a wider word than its neighbour still
+   sees the same bits. */
+static uint64_t
+ca_struct_load_le (const char *p, int n)
+{
+  uint64_t word = 0;
+  int i;
+  for (i = 0; i < n; i++) {
+    word |= (uint64_t) (uint8_t) p[i] << (8 * i);
+  }
+  return word;
+}
+
+static void
+ca_struct_store_le (char *p, int n, uint64_t word)
+{
+  int i;
+  for (i = 0; i < n; i++) {
+    p[i] = (char) (word >> (8 * i));
+  }
+}
+
 static VALUE
 ca_struct_read_bitfield_fast (const char *p, int view_bytes,
                               int bit_in_word, int bits)
 {
-  uint64_t word = 0;
-  switch (view_bytes) {
-  case 1: { uint8_t  v; memcpy(&v, p, 1); word = v; break; }
-  case 2: { uint16_t v; memcpy(&v, p, 2); word = v; break; }
-  case 4: { uint32_t v; memcpy(&v, p, 4); word = v; break; }
-  case 8: { uint64_t v; memcpy(&v, p, 8); word = v; break; }
-  default:
+  uint64_t word;
+  if ( view_bytes != 1 && view_bytes != 2 && view_bytes != 4 && view_bytes != 8 ) {
     rb_raise(rb_eRuntimeError,
              "[BUG] bitfield view_bytes %d not in {1,2,4,8}", view_bytes);
   }
+  word = ca_struct_load_le(p, view_bytes);
   uint64_t mask = (bits >= 64) ? ~(uint64_t)0
                                : ((uint64_t)1 << bits) - 1;
   uint64_t val  = (word >> bit_in_word) & mask;
@@ -224,7 +244,11 @@ static void
 ca_struct_write_bitfield_fast (char *p, int view_bytes,
                                int bit_in_word, int bits, VALUE val)
 {
-  uint64_t v;
+  uint64_t v, word;
+  if ( view_bytes != 1 && view_bytes != 2 && view_bytes != 4 && view_bytes != 8 ) {
+    rb_raise(rb_eRuntimeError,
+             "[BUG] bitfield view_bytes %d not in {1,2,4,8}", view_bytes);
+  }
   if ( bits == 1 ) {
     if      ( val == Qtrue  || val == INT2FIX(1) ) v = 1;
     else if ( val == Qfalse || val == INT2FIX(0) ) v = 0;
@@ -240,41 +264,9 @@ ca_struct_write_bitfield_fast (char *p, int view_bytes,
   uint64_t mask = (bits >= 64) ? ~(uint64_t)0
                                : ((uint64_t)1 << bits) - 1;
   v &= mask;
-  uint64_t shifted_mask = mask << bit_in_word;
-  uint64_t shifted_val  = v    << bit_in_word;
-  switch (view_bytes) {
-  case 1: {
-    uint8_t word;
-    memcpy(&word, p, 1);
-    word = (uint8_t)((word & ~(uint8_t)shifted_mask) | (uint8_t)shifted_val);
-    memcpy(p, &word, 1);
-    return;
-  }
-  case 2: {
-    uint16_t word;
-    memcpy(&word, p, 2);
-    word = (uint16_t)((word & ~(uint16_t)shifted_mask) | (uint16_t)shifted_val);
-    memcpy(p, &word, 2);
-    return;
-  }
-  case 4: {
-    uint32_t word;
-    memcpy(&word, p, 4);
-    word = (uint32_t)((word & ~(uint32_t)shifted_mask) | (uint32_t)shifted_val);
-    memcpy(p, &word, 4);
-    return;
-  }
-  case 8: {
-    uint64_t word;
-    memcpy(&word, p, 8);
-    word = (word & ~shifted_mask) | shifted_val;
-    memcpy(p, &word, 8);
-    return;
-  }
-  default:
-    rb_raise(rb_eRuntimeError,
-             "[BUG] bitfield view_bytes %d not in {1,2,4,8}", view_bytes);
-  }
+  word = ca_struct_load_le(p, view_bytes);
+  word = (word & ~(mask << bit_in_word)) | (v << bit_in_word);
+  ca_struct_store_le(p, view_bytes, word);
 }
 
 /* ---------------------------------------------------------------------

data/ext/carray_time_text.c

@@ -234,7 +234,9 @@ ca_time_text_read (VALUE str, ca_time_text_t *t, int wide)
         }
       }
     }
-    if ( hour > 24 || min > 59 || sec > 59 ) {
+    /* Second 60 is the leap second; it carries into the next minute below,
+       as CArray.time reads it. */
+    if ( hour > 24 || min > 59 || sec > 60 ) {
       return CA_TIME_TEXT_UNREADABLE;
     }
     /* Hour 24 is the end of the day, 24:00:00, and nothing past it, as in
@@ -359,7 +361,7 @@ rb_ca_parse_time_text (int argc, VALUE *argv, VALUE self)
   boolean8_t *m_in, *m_out;
   int64_t *days, *nsod, *months, *ticks;
   int64_t per_day = 1, ns_per_tick = 1;
-  ID unit;
+  ID unit = 0;
   int clock = 0, fraction = 0, coarse = 2, any = 0, wide;
   int calendar = 0;              /* 1 ticks of months, 2 of years */
   ca_size_t i;

data/ext/carray_utils.c

@@ -371,6 +371,10 @@ ca_parse_range_without_check (VALUE arg, ca_size_t size,
     last  = NUM2SIZE(x.end);
     excl  = RTEST(x.exclude_end);
     step  = NUM2SIZE(x.step);
+    if ( step == 0 ) {
+      rb_raise(rb_eArgError, "%s: step should not be 0",
+               ca_calling_method_name());
+    }
     if ( excl ) {
       last += ( (last>=start) ? -1 : 1 );
     }
@@ -391,6 +395,10 @@ ca_parse_range_without_check (VALUE arg, ca_size_t size,
       if ( NIL_P(arg0) ) {              /* [nil,k] */
         start = 0;
         step  = NUM2SIZE(arg1);
+        if ( step == 0 ) {
+          rb_raise(rb_eArgError, "%s: step should not be 0",
+                   ca_calling_method_name());
+        }
         count = (size-1)/llabs(step) + 1;
         *poffset = start;
         *pcount  = count;
@@ -401,6 +409,10 @@ ca_parse_range_without_check (VALUE arg, ca_size_t size,
         last  = NUM2SIZE(RANGE_END(arg0));
         excl  = RTEST(RANGE_EXCL(arg0));
         step  = NUM2SIZE(arg1);
+        if ( step == 0 ) {
+          rb_raise(rb_eArgError, "%s: step should not be 0",
+                   ca_calling_method_name());
+        }
         if ( excl ) {
           last += ( (last>=start) ? -1 : 1 );
         }
@@ -418,6 +430,10 @@ ca_parse_range_without_check (VALUE arg, ca_size_t size,
         last  = NUM2SIZE(x.end);
         excl  = RTEST(x.exclude_end);
         step  = NUM2SIZE(x.step);
+        if ( step == 0 ) {
+          rb_raise(rb_eArgError, "%s: step should not be 0",
+                   ca_calling_method_name());
+        }
         if ( excl ) {
           last += ( (last>=start) ? -1 : 1 );
         }
@@ -922,6 +938,15 @@ ca_reduce_fill (VALUE result, VALUE fill, int whole)
     if ( ca_has_mask(cr) ) {
       result = rb_ca_mask_fill_copy(result, fill);
     }
+    else if ( cr->elements > 0 ) {
+      /* No cell needed the fill, but a fill the result cannot hold is
+         refused all the same, not only when some cell happens to be
+         undefined: it goes into a one-cell array of the result's kind. */
+      volatile VALUE one = rb_funcall(rb_funcall(result, rb_intern("flatten"), 0),
+                                      rb_intern("[]"), 1,
+                                      rb_range_new(INT2FIX(0), INT2FIX(0), 0));
+      rb_ca_store_addr(rb_ca_template(one), 0, fill);
+    }
     return whole ? rb_ca_fetch_addr(result, 0) : result;
   }
   return ( result == CA_UNDEF ) ? fill : result;
@@ -1253,11 +1278,36 @@ rb_hash_has_key(VALUE hash, VALUE key)
   return Qfalse;
 }
 
+/* The next comma-separated key of a spec, its length in *len, or NULL
+   past the last key.  The spec is read in place: a copy to cut up would
+   be a C allocation, and its failure has nowhere to go but to drop every
+   keyword. */
+static const char *
+option_key (const char **sp, long *len)
+{
+  const char *p = *sp, *end;
+
+  if ( p == NULL ) {
+    return NULL;
+  }
+  end = strchr(p, ',');
+  if ( end ) {
+    *len = end - p;
+    *sp  = end + 1;
+  }
+  else {
+    *len = (long) strlen(p);
+    *sp  = NULL;
+  }
+  return p;
+}
+
 void
 rb_scan_options (VALUE ropt, const char *spec_in, ...)
 {
   VALUE *vp;
-  char *sp, *tok, *spec;
+  const char *sp, *tok;
+  long len;
   int has_option = 0;
   va_list vals;
 
@@ -1272,22 +1322,19 @@ rb_scan_options (VALUE ropt, const char *spec_in, ...)
   }
 
   va_start(vals, spec_in);
-  sp = spec = strdup(spec_in);
-  tok = strsep1(&sp, ',');
-  while ( tok != NULL ) {
+  sp = spec_in;
+  while ( ( tok = option_key(&sp, &len) ) != NULL ) {
     vp = va_arg(vals, VALUE*);
     if ( has_option ) {
-      VALUE key = ID2SYM(rb_intern(tok));
+      VALUE key = ID2SYM(rb_intern2(tok, len));
       if ( rb_hash_has_key(ropt, key) ) {
         *vp = rb_hash_aref(ropt, key);
       }
       /* key absent: leave *vp unchanged (caller's pre-initialized default) */
     }
     /* opts == Qnil: leave all *vp unchanged */
-    tok = strsep1(&sp, ',');
   }
   va_end(vals);
-  free(spec);
 
   /* Strict: reject any key not named in spec, matching Ruby's native
      keyword-argument behaviour ("unknown keyword: :foo").  Every call
@@ -1300,15 +1347,12 @@ rb_scan_options (VALUE ropt, const char *spec_in, ...)
       VALUE key = rb_ary_entry(keys, i);
       VALUE kname = SYMBOL_P(key) ? rb_sym2str(key) : rb_obj_as_string(key);
       const char *kn = StringValueCStr(kname);
-      char *sp2, *tok2, *spec2;
+      long kn_len = RSTRING_LEN(kname);
       int found = 0;
-      sp2 = spec2 = strdup(spec_in);
-      tok2 = strsep1(&sp2, ',');
-      while ( tok2 != NULL ) {
-        if ( strcmp(tok2, kn) == 0 ) { found = 1; break; }
-        tok2 = strsep1(&sp2, ',');
+      sp = spec_in;
+      while ( ( tok = option_key(&sp, &len) ) != NULL ) {
+        if ( len == kn_len && memcmp(tok, kn, len) == 0 ) { found = 1; break; }
       }
-      free(spec2);
       if ( ! found ) {
         rb_raise(rb_eArgError, "unknown keyword: %"PRIsVALUE, rb_inspect(key));
       }
@@ -1341,7 +1385,8 @@ void
 rb_set_options (VALUE ropt, const char *spec_in, ...)
 {
   VALUE rval;
-  char *sp, *tok, *spec;
+  const char *sp, *tok;
+  long len;
   int has_option = 0;
   va_list vals;
 
@@ -1356,17 +1401,14 @@ rb_set_options (VALUE ropt, const char *spec_in, ...)
   }
 
   va_start(vals, spec_in);
-  sp = spec = strdup(spec_in);
-  tok = strsep1(&sp, ',');
-  while ( tok != NULL ) {
+  sp = spec_in;
+  while ( ( tok = option_key(&sp, &len) ) != NULL ) {
     rval = va_arg(vals, VALUE);
     if ( has_option ) {
-      rb_hash_aset(ropt, ID2SYM(rb_intern(tok)), rval);
+      rb_hash_aset(ropt, ID2SYM(rb_intern2(tok, len)), rval);
     }
-    tok = strsep1(&sp, ',');
   }
   va_end(vals);
-  free(spec);
 
   return;
 }