libbin 1.0.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e87d96cfea4bd0ff2ca321e9e318eb2afcdddee0764811db35e2a92835396db8
-  data.tar.gz: e75d3aa6a8374e04db4e84db9eb88bc768a99e3ceff932d0ce26d4f6501ae5e6
+  metadata.gz: 8a0a92cec0fde131c6254ad8b5f8a405e68c2a9bd7699a11e7cd24d7e5d0c110
+  data.tar.gz: 17732019c6941e79fcfaf233aba722e08b6470e851adae24a01b9e36c90608ca
 SHA512:
-  metadata.gz: f9d940fd59641087b72fb734ba2db6833aa0c7b4620205e8e568580ccc64d4e1f49a433ca206ebe474b8e3946417d1a96491bc79ff977435ef442ad35d9590f7
-  data.tar.gz: 3b04707ce8a3d434596e641dabf1a4a58d95403207d492089029c37f68e4bdf49e568420f7736f426cd95377e7adf1a95ff306d3bcd3c9b0d71544fc541ef156
+  metadata.gz: 2caa512271ce77e4f23ad01d5eb9a1c4a9049eefd8578dcc8b69730183b25311a60a0a1ae97674b9f87778f9e9dad09b5fdcb2acb7a4a3d50110b388f03e106a
+  data.tar.gz: 600b1878941b3fa53cc9191bc7de026b9f205ce36520915925a6d4664ddba00d92bcdd4c035424d35eb4b97d2eaf732c2339aad785c603ada01790026f1f0f63

data/ext/libbin/data_types.c

@@ -0,0 +1,557 @@
+#include "ruby.h"
+#include "./libbin_c.h"
+
+VALUE cDataShape;
+VALUE cDataRange;
+VALUE cScalar;
+
+static ID id_read, id_write;
+
+static VALUE cScalar_always_align(VALUE self) {
+  return Qfalse;
+}
+
+/* align() */
+#define MAKE_TYPE_ALIGN(CLASS, MAPPED_TYPE) \
+static VALUE CLASS ## _align(VALUE self) {  \
+  (void)self;                               \
+  return INT2FIX(sizeof(MAPPED_TYPE));      \
+}
+
+/* size(value = nil, previous_offset = 0, parent = nil, index = nil, length = nil) */
+#define MAKE_TYPE_SIZE(CLASS, MAPPED_TYPE)                         \
+static VALUE CLASS ## _size(int argc, VALUE* argv, VALUE self) {   \
+  (void)self;                                                      \
+  VALUE length;                                                    \
+  rb_scan_args(argc, argv, "05", NULL, NULL, NULL, NULL, &length); \
+  if (RTEST(length))                                               \
+    return ULL2NUM(sizeof(MAPPED_TYPE)*NUM2ULL(length));           \
+  else                                                             \
+    return INT2FIX(sizeof(MAPPED_TYPE));                           \
+}
+
+/* shape(value = nil, previous_offset = 0, parent = nil, index = nil, kind = DataShape, length = nil) */
+#define MAKE_TYPE_SHAPE(CLASS, MAPPED_TYPE)                                                  \
+static VALUE CLASS ## _shape(int argc, VALUE* argv, VALUE self) {                            \
+  (void)self;                                                                                \
+  VALUE previous_offset;                                                                     \
+  VALUE kind;                                                                                \
+  VALUE length;                                                                              \
+  rb_scan_args(argc, argv, "06", NULL, &previous_offset, NULL, NULL, &kind, &length);        \
+  if (NIL_P(previous_offset))                                                                \
+    previous_offset = INT2FIX(0);                                                            \
+  if (NIL_P(kind))                                                                           \
+    kind = cDataShape;                                                                       \
+  if (NIL_P(length))                                                                         \
+    length = INT2FIX(1);                                                                     \
+  VALUE args[] = {  previous_offset,                                                         \
+    LL2NUM(NUM2LL(previous_offset) - 1 + NUM2LL(length) * (ptrdiff_t)sizeof(MAPPED_TYPE)) }; \
+  return rb_class_new_instance(2, args, kind);                                               \
+}
+
+#define MAKE_LOAD_LOOP(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT) \
+do {                                                              \
+  if (RTEST(length)) {                                            \
+    res = rb_ary_new_capa(n);                                     \
+    long i = 0;                                                   \
+    for (MAPPED_TYPE *p = data; p != data + n; p++, i++)          \
+       rb_ary_store(res, i, RUBY_CONVERT(NATIVE_CONVERT(*p)));    \
+  } else                                                          \
+    res = RUBY_CONVERT(NATIVE_CONVERT(*data));                    \
+} while (0)
+
+#define MAKE_LOAD_ENDIAN(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT)        \
+do {                                                                       \
+  if (little)                                                              \
+    MAKE_LOAD_LOOP(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT ## _ ## le ); \
+  else                                                                     \
+    MAKE_LOAD_LOOP(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT ## _ ## be ); \
+} while (0)
+
+#define MAKE_LOAD(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT) \
+  MAKE_LOAD_LOOP(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT)
+
+/* load(input, input_big = LibBin::default_big?, parent = nil, index = nil, length = nil) */
+#define MAKE_TYPE_LOAD(CLASS, MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT, LOAD) \
+static VALUE CLASS ## _load(int argc, VALUE* argv, VALUE self) {               \
+  (void)self;                                                                  \
+  VALUE input;                                                                 \
+  VALUE input_big;                                                             \
+  VALUE length;                                                                \
+  rb_scan_args(argc, argv, "14", &input, &input_big, NULL, NULL, &length);     \
+  if (NIL_P(input_big))                                                        \
+    input_big = rb_funcall(mLibBin, rb_intern("default_big?"), 0);             \
+  unsigned little = RTEST(input_big) ? 0 : 1;                                  \
+  long n = RTEST(length) ? NUM2LONG(length) : 1;                               \
+  size_t cnt = sizeof(MAPPED_TYPE) * n;                                        \
+  VALUE res;                                                                   \
+  VALUE str = rb_funcall(input, id_read, 1, ULL2NUM(cnt));                     \
+  if (NIL_P(str) || RSTRING_LEN(str) < (long)cnt)                              \
+    rb_raise(rb_eRuntimeError,                                                 \
+        "could not read enough data: got %ld needed %zu",                      \
+        NIL_P(str) ? 0 : RSTRING_LEN(str), cnt);                               \
+  MAPPED_TYPE *data = (MAPPED_TYPE *)RSTRING_PTR(str);                         \
+  LOAD(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT);                             \
+  RB_GC_GUARD(str);                                                            \
+  return res;                                                                  \
+}
+
+#define MAKE_DUMP_LOOP(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT)           \
+do {                                                                        \
+  if (RTEST(length))                                                        \
+    for (long i = 0; i < n; i++) {                                          \
+      MAPPED_TYPE v = NATIVE_CONVERT(RUBY_CONVERT(rb_ary_entry(value, i))); \
+      rb_str_cat(str, (char *)&v, sizeof(MAPPED_TYPE));                     \
+    }                                                                       \
+  else {                                                                    \
+    MAPPED_TYPE v = NATIVE_CONVERT(RUBY_CONVERT(value));                    \
+    rb_str_cat(str, (char *)&v, sizeof(MAPPED_TYPE));                       \
+  }                                                                         \
+} while (0)
+
+#define MAKE_DUMP_ENDIAN(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT)        \
+do {                                                                       \
+  if (little)                                                              \
+    MAKE_DUMP_LOOP(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT ## _ ## le ); \
+  else                                                                     \
+    MAKE_DUMP_LOOP(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT ## _ ## be ); \
+} while (0)
+
+#define MAKE_DUMP(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT) \
+  MAKE_DUMP_LOOP(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT)
+
+/* dump(value, output, output_big = LibBin::default_big?, parent = nil, index = nil, length = nil) */
+#define MAKE_TYPE_DUMP(CLASS, MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT, DUMP)       \
+static VALUE CLASS ## _dump(int argc, VALUE* argv, VALUE self) {                     \
+  (void)self;                                                                        \
+  VALUE value;                                                                       \
+  VALUE output;                                                                      \
+  VALUE output_big;                                                                  \
+  VALUE length;                                                                      \
+  rb_scan_args(argc, argv, "24", &value, &output, &output_big, NULL, NULL, &length); \
+  if (NIL_P(output_big))                                                             \
+    output_big = rb_funcall(mLibBin, rb_intern("default_big?"), 0);                  \
+  unsigned little = RTEST(output_big) ? 0 : 1;                                       \
+  long n = RTEST(length) ? NUM2LONG(length) : 1;                                     \
+  size_t cnt = sizeof(MAPPED_TYPE) * n;                                              \
+  VALUE str = rb_str_buf_new((long)cnt);                                             \
+  DUMP(MAPPED_TYPE, RUBY_CONVERT, NATIVE_CONVERT);                                   \
+  rb_funcall(output, id_write, 1, str);                                              \
+  return Qnil;                                                                       \
+}
+
+#define MAKE_CONVERT_LOOP(MAPPED_TYPE, MAPPED_SWAP, SWAP_COND, RUBY_CONVERT, NATIVE_CONVERT) \
+do {                                                                                         \
+  if (RTEST(length)) {                                                                       \
+    res = rb_ary_new_capa(n);                                                                \
+    long i = 0;                                                                              \
+    for (MAPPED_TYPE *p = data; p != data + n; p++, i++) {                                   \
+      rb_ary_store(res, i, RUBY_CONVERT(NATIVE_CONVERT(*p)));                                \
+      if (SWAP_COND)                                                                         \
+        *p = MAPPED_SWAP(*p);                                                                \
+    }                                                                                        \
+  } else {                                                                                   \
+    res = RUBY_CONVERT(NATIVE_CONVERT(*data));                                               \
+    if (SWAP_COND)                                                                           \
+      *data = MAPPED_SWAP(*data);                                                            \
+  }                                                                                          \
+} while(0)
+
+#define MAKE_CONVERT_ENDIAN(MAPPED_TYPE, MAPPED_SWAP, RUBY_CONVERT, NATIVE_CONVERT)                        \
+do {                                                                                                       \
+  if (little_input)                                                                                        \
+    MAKE_CONVERT_LOOP(MAPPED_TYPE, MAPPED_SWAP, !little_output, RUBY_CONVERT, NATIVE_CONVERT ## _ ## le ); \
+  else                                                                                                     \
+    MAKE_CONVERT_LOOP(MAPPED_TYPE, MAPPED_SWAP, little_output, RUBY_CONVERT, NATIVE_CONVERT ## _ ## be );  \
+} while (0)
+
+#define MAKE_CONVERT(MAPPED_TYPE, MAPPED_SWAP, RUBY_CONVERT, NATIVE_CONVERT) \
+  MAKE_CONVERT_LOOP(MAPPED_TYPE, MAPPED_SWAP, 0, RUBY_CONVERT, NATIVE_CONVERT)
+
+
+/* convert(input, output, input_big = LibBin::default_big?, output_big = !input_big, parent = nil, index = nil, length = nil) */
+#define MAKE_TYPE_CONVERT(CLASS, MAPPED_TYPE, MAPPED_SWAP, RUBY_CONVERT, NATIVE_CONVERT, CONVERT)          \
+static VALUE CLASS ## _convert(int argc, VALUE* argv, VALUE self) {                                        \
+  (void)self;                                                                                              \
+  VALUE input;                                                                                             \
+  VALUE output;                                                                                            \
+  VALUE input_big;                                                                                         \
+  VALUE output_big;                                                                                        \
+  VALUE length;                                                                                            \
+  rb_scan_args(argc, argv, "25", &input, &output, &input_big, &output_big, NULL, NULL, &length);           \
+  if (NIL_P(input_big))                                                                                    \
+    input_big = rb_funcall(mLibBin, rb_intern("default_big?"), 0);                                         \
+  unsigned little_input = RTEST(input_big) ? 0 : 1;                                                        \
+  if (NIL_P(output_big))                                                                                   \
+    output_big = little_input ? Qtrue : Qfalse;                                                            \
+  unsigned little_output = RTEST(output_big) ? 0 : 1;                                                      \
+  long n = RTEST(length) ? NUM2LONG(length) : 1;                                                           \
+  size_t cnt = sizeof(MAPPED_TYPE) * n;                                                                    \
+  VALUE res;                                                                                               \
+  VALUE str = rb_funcall(input, id_read, 1, ULL2NUM(cnt));                                                 \
+  if (NIL_P(str)  || RSTRING_LEN(str) < (long)cnt)                                                         \
+    rb_raise(rb_eRuntimeError, "could not read enough data: got %ld needed %zu",                           \
+        NIL_P(str) ? 0 : RSTRING_LEN(str), cnt);                                                           \
+  MAPPED_TYPE *data = (MAPPED_TYPE *)RSTRING_PTR(str);                                                     \
+  CONVERT(MAPPED_TYPE, MAPPED_SWAP, RUBY_CONVERT, NATIVE_CONVERT);                                         \
+  rb_funcall(output, id_write, 1, str);                                                                    \
+  return res;                                                                                              \
+}
+
+#define MAKE_CLASS_DEFINE(CLASS_NAME, CLASS)                                  \
+static void define_ ## CLASS() {                                              \
+  CLASS = rb_define_class_under(cStructure, #CLASS_NAME, cScalar);        \
+  rb_define_singleton_method(CLASS, "align", CLASS ## _align, 0);             \
+  rb_define_singleton_method(CLASS, "size", CLASS ## _size, -1);              \
+  rb_define_singleton_method(CLASS, "shape", CLASS ## _shape, -1);            \
+  rb_define_singleton_method(CLASS, "load", CLASS ## _load, -1);              \
+  rb_define_singleton_method(CLASS, "dump", CLASS ## _dump, -1);              \
+  rb_define_singleton_method(CLASS, "convert", CLASS ## _convert, -1);        \
+}
+
+#define MAKE_STATIC_OBJECT(CLASS) \
+static VALUE CLASS;
+
+#define MAKE_CLASS_TYPE_ENDIAN_EX(CLASS_NAME, CLASS, MAPPED_TYPE, MAPPED_SWAP, RUBY_CONVERT_TO, RUBY_CONVERT_FROM, NATIVE_CONVERT_TO, NATIVE_CONVERT_FROM, ENDIAN) \
+  MAKE_STATIC_OBJECT(CLASS)                                                                                      \
+  MAKE_TYPE_ALIGN(CLASS, MAPPED_TYPE)                                                                            \
+  MAKE_TYPE_SIZE(CLASS, MAPPED_TYPE)                                                                             \
+  MAKE_TYPE_SHAPE(CLASS, MAPPED_TYPE)                                                                            \
+  MAKE_TYPE_LOAD(CLASS, MAPPED_TYPE, RUBY_CONVERT_TO, NATIVE_CONVERT_TO, MAKE_LOAD ## ENDIAN)                    \
+  MAKE_TYPE_DUMP(CLASS, MAPPED_TYPE, RUBY_CONVERT_FROM, NATIVE_CONVERT_FROM, MAKE_DUMP ## ENDIAN)                \
+  MAKE_TYPE_CONVERT(CLASS, MAPPED_TYPE, MAPPED_SWAP, RUBY_CONVERT_TO, NATIVE_CONVERT_TO, MAKE_CONVERT ## ENDIAN) \
+  MAKE_CLASS_DEFINE(CLASS_NAME, CLASS)
+
+#define MAKE_CLASS_TYPE_ENDIAN(CLASS_NAME, CLASS, MAPPED_TYPE, MAPPED_SWAP, RUBY_CONVERT_TO, RUBY_CONVERT_FROM, NATIVE_CONVERT_TO, NATIVE_CONVERT_FROM, ENDIAN) \
+  MAKE_CLASS_TYPE_ENDIAN_EX(CLASS_NAME, CLASS, MAPPED_TYPE, MAPPED_SWAP, RUBY_CONVERT_TO, RUBY_CONVERT_FROM, NATIVE_CONVERT_TO, NATIVE_CONVERT_FROM, ENDIAN)
+
+#define ENDIAN_little
+#define ENDIAN_big
+#define ENDIAN_nil _ENDIAN
+#define ENDIAN_suffix_little _le
+#define ENDIAN_suffix_big _be
+#define ENDIAN_suffix_nil
+#define ENDIAN_SUFFIX_little _LE
+#define ENDIAN_SUFFIX_big _BE
+#define ENDIAN_SUFFIX_nil
+
+#define MAKE_ENDIAN(ENDIAN) ENDIAN_ ## ENDIAN
+#define MAKE_ENDIAN_suffix(ENDIAN) ENDIAN_suffix_ ## ENDIAN
+#define MAKE_ENDIAN_SUFFIX(ENDIAN) ENDIAN_SUFFIX_ ## ENDIAN
+#define MAKE_CONVERT_NAME_SUFFIX_EX(NAME, SUFFIX) NAME ## SUFFIX
+#define MAKE_CONVERT_NAME_SUFFIX(NAME, SUFFIX) MAKE_CONVERT_NAME_SUFFIX_EX(NAME, SUFFIX)
+#define MAKE_CONVERT_NAME_MAKE_SUFFIX(NAME, ENDIAN, MAKE_SUFFIX) MAKE_CONVERT_NAME_SUFFIX(NAME, MAKE_SUFFIX(ENDIAN))
+#define MAKE_CLASS_NAME(CLASS_NAME, ENDIAN) MAKE_CONVERT_NAME_MAKE_SUFFIX(CLASS_NAME, ENDIAN, MAKE_ENDIAN_SUFFIX)
+#define MAKE_C_CLASS_NAME(CLASS_NAME, ENDIAN) MAKE_CONVERT_NAME_MAKE_SUFFIX(c ## CLASS_NAME, ENDIAN, MAKE_ENDIAN_SUFFIX)
+#define MAKE_CONVERT_NAME(NAME, ENDIAN) MAKE_CONVERT_NAME_MAKE_SUFFIX(NAME, ENDIAN, MAKE_ENDIAN_suffix)
+
+#define MAKE_CLASS(CLASS_NAME, SIZE, RUBY_CONVERT_TO, RUBY_CONVERT_FROM, NATIVE_CONVERT_TO, NATIVE_CONVERT_FROM, ENDIAN) \
+  MAKE_CLASS_TYPE_ENDIAN(MAKE_CLASS_NAME(CLASS_NAME, ENDIAN),            \
+                         MAKE_C_CLASS_NAME(CLASS_NAME, ENDIAN),          \
+                         uint ## SIZE ## _t,                             \
+                         bswap_uint ## SIZE,                             \
+                         RUBY_CONVERT_TO,                                \
+                         RUBY_CONVERT_FROM,                              \
+                         MAKE_CONVERT_NAME(NATIVE_CONVERT_TO, ENDIAN),   \
+                         MAKE_CONVERT_NAME(NATIVE_CONVERT_FROM, ENDIAN), \
+                         MAKE_ENDIAN(ENDIAN))
+
+#define MAKE_CLASSES(CLASS_NAME, SIZE, RUBY_CONVERT_TO, RUBY_CONVERT_FROM, NATIVE_CONVERT_TO, NATIVE_CONVERT_FROM) \
+  MAKE_CLASS(CLASS_NAME, SIZE, RUBY_CONVERT_TO, RUBY_CONVERT_FROM, NATIVE_CONVERT_TO, NATIVE_CONVERT_FROM, nil)    \
+  MAKE_CLASS(CLASS_NAME, SIZE, RUBY_CONVERT_TO, RUBY_CONVERT_FROM, NATIVE_CONVERT_TO, NATIVE_CONVERT_FROM, little) \
+  MAKE_CLASS(CLASS_NAME, SIZE, RUBY_CONVERT_TO, RUBY_CONVERT_FROM, NATIVE_CONVERT_TO, NATIVE_CONVERT_FROM, big)
+
+#define MAKE_CALL_DEFINE(CLASS_NAME) \
+do {                                 \
+  define_ ## CLASS_NAME();           \
+} while (0)
+
+#define MAKE_CALL_DEFINE_EX(CLASS_NAME) \
+  MAKE_CALL_DEFINE(CLASS_NAME)
+
+#define MAKE_CALL_DEFINES(CLASS_NAME)                         \
+do {                                                          \
+  MAKE_CALL_DEFINE_EX(MAKE_C_CLASS_NAME(CLASS_NAME, nil));    \
+  MAKE_CALL_DEFINE_EX(MAKE_C_CLASS_NAME(CLASS_NAME, little)); \
+  MAKE_CALL_DEFINE_EX(MAKE_C_CLASS_NAME(CLASS_NAME, big));    \
+} while (0)
+
+static inline float half_to_float_le(uint16_t val) {
+  val = unpack_half_le(val);
+  union float_u u;
+  u.i = half_to_float(val);
+  return u.f;
+}
+
+static inline float half_to_float_be(uint16_t val) {
+  val = unpack_half_be(val);
+  union float_u u;
+  u.i = half_to_float(val);
+  return u.f;
+}
+
+static inline uint16_t float_to_half_le(float f) {
+  uint16_t res;
+  union float_u u;
+  u.f = f;
+  res = half_from_float(u.i);
+  res = pack_half_le(res);
+  return res;
+}
+
+static inline uint16_t float_to_half_be(float f) {
+  uint16_t res;
+  union float_u u;
+  u.f = f;
+  res = half_from_float(u.i);
+  res = pack_half_be(res);
+  return res;
+}
+
+
+MAKE_CLASSES(Half, 16, DBL2NUM, NUM2DBL, half_to_float, float_to_half)
+
+static inline float pghalf_to_float_le(uint16_t val) {
+  val = unpack_pghalf_le(val);
+  union float_u u;
+  u.i = pghalf_to_float(val);
+  return u.f;
+}
+
+static inline float pghalf_to_float_be(uint16_t val) {
+  val = unpack_pghalf_be(val);
+  union float_u u;
+  u.i = pghalf_to_float(val);
+  return u.f;
+}
+
+static inline uint16_t float_to_pghalf_le(float f) {
+  uint16_t res;
+  union float_u u;
+  u.f = f;
+  res = pghalf_from_float(u.i);
+  res = pack_pghalf_le(res);
+  return res;
+}
+
+static inline uint16_t float_to_pghalf_be(float f) {
+  uint16_t res;
+  union float_u u;
+  u.f = f;
+  res = pghalf_from_float(u.i);
+  res = pack_pghalf_be(res);
+  return res;
+}
+
+MAKE_CLASSES(PGHalf, 16, DBL2NUM, NUM2DBL, pghalf_to_float, float_to_pghalf)
+
+MAKE_CLASSES(Int8, 8, INT2FIX, NUM2SHORT, unpack_int8, pack_int8)
+MAKE_CLASSES(UInt8, 8, USHORT2NUM, NUM2USHORT, unpack_uint8, pack_uint8)
+MAKE_CLASSES(Int16, 16, INT2FIX, NUM2SHORT, unpack_int16, pack_int16)
+MAKE_CLASSES(UInt16, 16, USHORT2NUM, NUM2USHORT, unpack_uint16, pack_uint16)
+MAKE_CLASSES(Int32, 32, INT2NUM, NUM2INT, unpack_int32, pack_int32)
+MAKE_CLASSES(UInt32, 32, UINT2NUM, NUM2UINT, unpack_uint32, pack_uint32)
+MAKE_CLASSES(Int64, 64, LL2NUM, NUM2LL, unpack_int64, pack_int64)
+MAKE_CLASSES(UInt64, 64, ULL2NUM, NUM2ULL, unpack_uint64, pack_uint64)
+MAKE_CLASSES(Flt, 32, DBL2NUM, NUM2DBL, unpack_float, pack_float)
+MAKE_CLASSES(Double, 64, DBL2NUM, NUM2DBL, unpack_double, pack_double)
+
+static VALUE cStr;
+
+static VALUE cStr_align(VALUE self) {
+  (void)self;
+  return INT2FIX(sizeof(char));
+}
+
+static VALUE cStr_size(int argc, VALUE* argv, VALUE self) {
+  (void)self;
+  VALUE value;
+  VALUE length;
+  rb_scan_args(argc, argv, "14", &value, NULL, NULL, NULL, &length);
+  if (RTEST(length))
+    return length;
+  else
+    return rb_funcall(value, rb_intern("bytesize"), 0);
+}
+
+static VALUE cStr_shape(int argc, VALUE* argv, VALUE self) {
+  (void)self;
+  VALUE value;
+  VALUE previous_offset;
+  VALUE kind;
+  VALUE length;
+  rb_scan_args(argc, argv, "15", &value, &previous_offset, NULL, NULL, &kind, &length);
+  if (NIL_P(previous_offset))
+    previous_offset = INT2FIX(0);
+  if (NIL_P(kind))
+    kind = cDataShape;
+  if (NIL_P(length)) {
+    VALUE args[] = { previous_offset, LL2NUM(NUM2LL(previous_offset) - 1 + RSTRING_LEN(value)) };
+    return rb_class_new_instance(2, args, kind);
+  } else {
+    VALUE args[] = { previous_offset, LL2NUM(NUM2LL(previous_offset) - 1 + NUM2LL(length)) };
+    return rb_class_new_instance(2, args, kind);
+  }
+}
+
+static VALUE cStr_load(int argc, VALUE* argv, VALUE self) {
+  (void)self;
+  VALUE input;
+  VALUE length;
+  rb_scan_args(argc, argv, "14", &input, NULL, NULL, NULL, &length);
+  if (NIL_P(length))
+    return rb_funcall(input, rb_intern("readline"), 1, rb_str_new_static("", 1));
+  else {
+    VALUE str = rb_funcall(input, id_read, 1, length);
+    if (NIL_P(str) || RSTRING_LEN(str) < NUM2LONG(length))
+      rb_raise(rb_eRuntimeError,
+        "could not read enough data: got %ld needed %zu", RSTRING_LEN(str), NUM2LONG(length));
+    return str;
+  }
+}
+
+static VALUE cStr_dump(int argc, VALUE* argv, VALUE self) {
+  (void)self;
+  VALUE value;
+  VALUE output;
+  VALUE length;
+  rb_scan_args(argc, argv, "24", &value, &output, NULL, NULL, NULL, &length);
+  if (NIL_P(length))
+    rb_funcall(output, id_write, 1, value);
+  else {
+    long l = NUM2LONG(length);
+    long vl = RSTRING_LEN(value);
+    VALUE str;
+    if (vl > l)
+      str = rb_str_new(RSTRING_PTR(value), l);
+    else {
+      str = rb_str_buf_new(l);
+      rb_str_cat(str, RSTRING_PTR(value), vl);
+      for (long i = 0; i < l - vl; i++)
+        rb_str_cat(str, "", 1);
+    }
+    rb_funcall(output, id_write, 1, str);
+  }
+  return Qnil;
+}
+
+static VALUE cStr_convert(int argc, VALUE* argv, VALUE self) {
+  (void)self;
+  VALUE input;
+  VALUE output;
+  VALUE length;
+  rb_scan_args(argc, argv, "25", &input, &output, NULL, NULL, NULL, NULL, &length);
+  VALUE str;
+  if (NIL_P(length))
+    str = rb_funcall(input, rb_intern("readline"), 1, rb_str_new_static("", 1));
+  else {
+    str = rb_funcall(input, id_read, 1, length);
+    if (NIL_P(str) || RSTRING_LEN(str) < NUM2LONG(length))
+      rb_raise(rb_eRuntimeError,
+        "could not read enough data: got %ld needed %zu", RSTRING_LEN(str), NUM2LONG(length));
+  }
+  rb_funcall(output, id_write, 1, str);
+  return str;
+}
+
+static void define_cStr() {
+  cStr = rb_define_class_under(cStructure, "Str", cScalar);
+  /**
+   * Returns the alignement of the underlying character type.
+   * @return [Integer]
+   */
+  rb_define_singleton_method(cStr, "align", cStr_align, 0);
+  /**
+   * @overload size(value, offset = 0, parent = nil, index = nil, length = nil)
+   *   Returns the size of a string.
+   *   @param value [Object] string to dump.
+   *   @param offset [Integer] ignored.
+   *   @param parent [Structure] ignored.
+   *   @param index [Integer] ignored.
+   *   @param length [Integer] if given the length of the vector. Else
+   *   the size of the string.
+   *   @return [Integer] the size of the string or <tt>sizeof(char) * length</tt>.
+   */
+  rb_define_singleton_method(cStr, "size", cStr_size, -1);
+  /**
+   * @overload shape(value, offset = 0, parent = nil, index = nil, kind = DataShape, length = nil)
+   *   Returns the shape of a string field
+   *   @param value [Object] ignored.
+   *   @param offset [Integer] start of the shape.
+   *   @param parent [Structure] ignored.
+   *   @param index [Integer] ignored.
+   *   @param kind [Class] shape class. Will be instantiated through
+   *     new with the +offset+ and <tt>offset + sizeof($3) * length - 1</tt>.
+   *   @param length [Integer] if given the length of the string to
+   *     consider. Else the length is the size of the string.
+   *   @return [kind] a new instance of +kind+
+   */
+  rb_define_singleton_method(cStr, "shape", cStr_shape, -1);
+  /**
+   * @overload load(input, input_big = LibBin::default_big?, parent = nil, index = nil, length = nil)
+   *   Load a string field from +input+, and return it.
+   *   @param input [IO] the stream to load the field from.
+   *   @param input_big [Boolean] the endianness of +input+
+   *   @param parent [Structure] ignored.
+   *   @param index [Integer] ignored.
+   *   @param length [Integer] if given the length of the string. Else
+   *     the string is considered NULL terminated.
+   *   @return [String] the Ruby representation of the string.
+   */
+  rb_define_singleton_method(cStr, "load", cStr_load, -1);
+  /**
+   * @overload dump(value, output, output_big = LibBin::default_big?, parent = nil, index = nil, length = nil)
+   *   Dump a string field to +output+.
+   *   @param value [Numeric, Array<Numeric>] the Ruby representation
+   *     of the string.
+   *   @param output [IO] the stream to dump the field to.
+   *   @param output_big [Boolean] the endianness of +output+.
+   *   @param parent [Structure] ignored.
+   *   @param index [Integer] ignored.
+   *   @param length [Integer] if given the length of the string to dump. Else
+   *     the length is the size of the string.
+   *   @return [nil]
+   */
+  rb_define_singleton_method(cStr, "dump", cStr_dump, -1);
+  /**
+   * @overload convert(input, output, input_big = LibBin::default_big?, output_big = !input_big, parent = nil, index = nil, length = nil)
+   *   Convert a string field by loading it from +input+,
+   *   dumping it to +output+, and returning the loaded field.
+   *   @param input [IO] the stream to load the field from.
+   *   @param output [IO] the stream to dump the field to.
+   *   @param input_big [Boolean] the endianness of +input+
+   *   @param output_big [Boolean] the endianness of +output+.
+   *   @param parent [Structure] ignored.
+   *   @param index [Integer] ignored.
+   *   @param length [Integer] if given the length of the string to reqd. Else
+   *     the string is considered NULL terminated.
+   *   @return [String] the Ruby representation of the string.
+   */
+  rb_define_singleton_method(cStr, "convert", cStr_convert, -1);
+}
+
+void define_cScalar() {
+  id_read = rb_intern("read");
+  id_write = rb_intern("write");
+  cScalar = rb_define_class_under(cStructure, "Scalar", rb_cObject);
+  /**
+   * Returns false as scalars are not required to be aligned.
+   * @return [false] return false.
+   */
+  rb_define_singleton_method(cScalar, "always_align", cScalar_always_align, 0);
+  MAKE_CALL_DEFINES(Half);
+  MAKE_CALL_DEFINES(PGHalf);
+  MAKE_CALL_DEFINES(Int8);
+  MAKE_CALL_DEFINES(UInt8);
+  MAKE_CALL_DEFINES(Int16);
+  MAKE_CALL_DEFINES(UInt16);
+  MAKE_CALL_DEFINES(Int32);
+  MAKE_CALL_DEFINES(UInt32);
+  MAKE_CALL_DEFINES(Int64);
+  MAKE_CALL_DEFINES(UInt64);
+  MAKE_CALL_DEFINES(Flt);
+  MAKE_CALL_DEFINES(Double);
+  define_cStr();
+}
+
+

data/ext/libbin/data_types.h

@@ -0,0 +1,16 @@
+#ifndef DATA_TYPES_H__
+#define DATA_TYPES_H__
+
+union float_u {
+  float f;
+  uint32_t i;
+};
+
+extern VALUE cScalar;
+extern VALUE cDataShape;
+extern VALUE cDataRange;
+extern VALUE cStructure;
+
+void define_cScalar();
+
+#endif