libbin 1.0.8 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac7b79d2e9bfeed5936680b7b192091988b66bebf8b7a9606468212f176929ae
-  data.tar.gz: 273e0156acc7f86fb799f7b5aafc99c3fb428ac69bcbe5fbda2a265d9543fb04
+  metadata.gz: 8a0a92cec0fde131c6254ad8b5f8a405e68c2a9bd7699a11e7cd24d7e5d0c110
+  data.tar.gz: 17732019c6941e79fcfaf233aba722e08b6470e851adae24a01b9e36c90608ca
 SHA512:
-  metadata.gz: 1268f8a9247714f2f2dac82b929f559eba7a8561b75f6fa89474e8a3d12b88723d37a6d065b679c41861dd3454a7a19b6d4e41f415a76f8fb77fa5ae3fed1a7d
-  data.tar.gz: e9dd37966771af9750ec9a302048cd14e156d7fd1f4c82c5336f1db50a96e00b9a1b5d04627a21abec24f725556c8fd1dbb9808be567bf09ba429c7b66d5e13a
+  metadata.gz: 2caa512271ce77e4f23ad01d5eb9a1c4a9049eefd8578dcc8b69730183b25311a60a0a1ae97674b9f87778f9e9dad09b5fdcb2acb7a4a3d50110b388f03e106a
+  data.tar.gz: 600b1878941b3fa53cc9191bc7de026b9f205ce36520915925a6d4664ddba00d92bcdd4c035424d35eb4b97d2eaf732c2339aad785c603ada01790026f1f0f63

data/ext/libbin/data_types.c

@@ -2,30 +2,42 @@
 #include "./libbin_c.h"
 
 VALUE cDataShape;
+VALUE cDataRange;
 VALUE cScalar;
 
 static ID id_read, id_write;
 
-/* size(value, previous_offset = 0, parent = nil, index = nil, length = nil)*/
+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, "14", NULL, NULL, NULL, NULL, &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, previous_offset = 0, parent = nil, index = nil, kind = DataShape, length = nil) */
+/* 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, "15", NULL, &previous_offset, NULL, NULL, &kind, &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))                                                                           \
@@ -179,28 +191,30 @@ static VALUE CLASS ## _convert(int argc, VALUE* argv, VALUE self) {
   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);                                                            \
+        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(cDataConverter, #CLASS_NAME, cScalar); \
-  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_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_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)                    \
@@ -344,6 +358,11 @@ 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;
@@ -436,18 +455,90 @@ static VALUE cStr_convert(int argc, VALUE* argv, VALUE self) {
 }
 
 static void define_cStr() {
-  cStr = rb_define_class_under(cDataConverter, "Str", cScalar);
+  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(cDataConverter, "Scalar", rb_cObject);
+  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);

data/ext/libbin/data_types.h

@@ -8,7 +8,8 @@ union float_u {
 
 extern VALUE cScalar;
 extern VALUE cDataShape;
-extern VALUE cDataConverter;
+extern VALUE cDataRange;
+extern VALUE cStructure;
 
 void define_cScalar();