arraybuffer 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 19ea4341e8a445c5f0f7fb037201da95de458b1c598b19dfcdede555a7ada4af
+  data.tar.gz: 55c21ac531706d232aeb9997c214ea99124e5c5d72ca94266abcf91b47431408
+SHA512:
+  metadata.gz: 761a077323636bb899b3c764f1b6225e0af328468d70a82a8d2cad42e70c585eeda68c6bbb8bf23c2ba3b80f495fc93402ef9b7e92cea77936d1e22a7a8b48fc
+  data.tar.gz: c1f26cdd5a15d3cb1068be495f8b1aee915b29a647fec7fc146420f0b39bf67a186a64b7b7fd52d58e744a380c3a5426ec0a906f0d71ac87313dca883093883a

data/ext/arraybuffer/arraybuffer.c

@@ -0,0 +1,159 @@
+#include "arraybuffer.h"
+#include "extconf.h"
+#include <string.h>
+
+extern VALUE cArrayBuffer;
+
+#define DECLAREBB(self) \
+  struct LLC_ArrayBuffer *bb = (struct LLC_ArrayBuffer*)rb_data_object_get((self))
+
+#define CHECKBOUNDS(bb, idx) \
+  if (!(bb)->ptr || (idx) < 0 || (idx) >= (bb)->size) { \
+    rb_raise(rb_eArgError, "Index out of bounds: %d", (idx)); \
+  }
+
+static void
+t_bb_gc_mark(struct LLC_ArrayBuffer *bb) {
+}
+
+static void
+t_bb_free(struct LLC_ArrayBuffer *bb) {
+  if (bb->ptr)
+    xfree(bb->ptr);
+
+  xfree(bb);
+}
+
+static VALUE
+t_bb_allocator(VALUE klass) {
+  struct LLC_ArrayBuffer *bb = (struct LLC_ArrayBuffer*)xmalloc(sizeof(struct LLC_ArrayBuffer));
+  bb->ptr = NULL;
+  bb->size = 0;
+
+  return Data_Wrap_Struct(klass, t_bb_gc_mark, t_bb_free, bb);
+}
+
+static VALUE
+t_bb_initialize(VALUE self, VALUE size) {
+  DECLAREBB(self);
+  unsigned int s = NUM2UINT(size);
+  bb->size = s;
+  if (bb->ptr)
+    xfree(bb->ptr);
+  bb->ptr = xmalloc(s);
+  memset(bb->ptr, 0, (size_t)s);
+  return self;
+}
+
+static VALUE
+t_bb_getbyte(VALUE self, VALUE index) {
+  DECLAREBB(self);
+  int idx = NUM2INT(index);
+  if (idx < 0)
+    idx += (int)bb->size;
+  CHECKBOUNDS(bb, idx);
+  return UINT2NUM((unsigned int)bb->ptr[idx]);
+}
+
+static VALUE
+t_bb_setbyte(VALUE self, VALUE index, VALUE value) {
+  DECLAREBB(self);
+  int idx = NUM2INT(index);
+  unsigned int val = NUM2UINT(value);
+  if (idx < 0)
+    idx += (int)bb->size;
+  CHECKBOUNDS(bb, idx);
+  bb->ptr[idx] = (unsigned char)val;
+  return self;
+}
+
+static VALUE
+t_bb_size(VALUE self) {
+  DECLAREBB(self);
+  return UINT2NUM(bb->size);
+}
+
+static VALUE
+t_bb_each(VALUE self) {
+  DECLAREBB(self);
+
+  if (rb_block_given_p()) {
+    for (int i = 0; i < bb->size; i++) {
+      unsigned int val = (unsigned int)bb->ptr[i];
+      rb_yield(UINT2NUM(val));
+    }
+  } else {
+    rb_raise(rb_eArgError, "no block given");
+  }
+
+  return self;
+}
+
+static VALUE
+t_bb_realloc(VALUE self, VALUE _new_size) {
+  DECLAREBB(self);
+  unsigned int new_size = NUM2UINT(_new_size);
+  if (new_size == bb->size)
+    return self;
+
+  void *old_ptr = (void*)bb->ptr;
+  if (new_size > 0) {
+    char *new_ptr = (void*)xmalloc(new_size);
+    if (old_ptr) {
+      if (new_size > bb->size) {
+        size_t diff = (size_t)(new_size - bb->size);
+        memcpy(new_ptr, old_ptr, (size_t)bb->size);
+        xfree(old_ptr);
+        old_ptr = NULL;
+        memset((char*)new_ptr + (size_t)bb->size, 0, diff);
+      } else {
+        memcpy(new_ptr, old_ptr, (size_t)new_size);
+      }
+    } else {
+      memset(new_ptr, 0, new_size);
+    }
+    bb->size = new_size;
+    bb->ptr = (unsigned char*)new_ptr;
+  } else {
+    bb->size = 0;
+    bb->ptr = NULL;
+  }
+
+  if (old_ptr)
+    xfree(old_ptr);
+
+  return self;
+}
+
+/*
+ * Returns a ASCII-8BIT string with the contents of the buffer
+ *
+ * The returned string is a copy of the buffer. It's encoding is always
+ * ASCII-8BIT.
+ * If the buffer has size zero, an empty string is returned.
+ *
+ * @return [String]
+ */
+static VALUE
+t_bb_bytes(VALUE self) {
+  DECLAREBB(self);
+  return rb_tainted_str_new(
+    (const char*)bb->ptr,
+    bb->size);
+}
+
+void
+Init_arraybuffer() {
+  cArrayBuffer = rb_define_class("ArrayBuffer", rb_cObject);
+  rb_define_alloc_func(cArrayBuffer, t_bb_allocator);
+  rb_include_module(cArrayBuffer, rb_mEnumerable);
+
+  rb_define_method(cArrayBuffer, "initialize", t_bb_initialize, 1);
+  rb_define_method(cArrayBuffer, "[]", t_bb_getbyte, 1);
+  rb_define_method(cArrayBuffer, "[]=", t_bb_setbyte, 2);
+  rb_define_method(cArrayBuffer, "size", t_bb_size, 0);
+  rb_define_alias(cArrayBuffer, "length", "size");
+  rb_define_method(cArrayBuffer, "each", t_bb_each, 0);
+  rb_define_method(cArrayBuffer, "realloc", t_bb_realloc, 1);
+  rb_define_method(cArrayBuffer, "bytes", t_bb_bytes, 0);
+}

data/ext/arraybuffer/arraybuffer.h

@@ -0,0 +1,11 @@
+#ifndef LLC_ARRAYBUFFER_H
+#define LLC_ARRAYBUFFER_H
+
+#include <ruby.h>
+
+struct LLC_ArrayBuffer {
+  unsigned char *ptr;
+  unsigned int size;
+};
+
+#endif

data/ext/arraybuffer/arraybuffer_ext.c

@@ -0,0 +1,14 @@
+#include <ruby.h>
+#include "extconf.h"
+
+VALUE cArrayBuffer = Qundef;
+VALUE cDataView = Qundef;
+
+void Init_dataview();
+void Init_arraybuffer();
+
+void
+Init_arraybuffer_ext() {
+  Init_arraybuffer();
+  Init_dataview();
+}

data/ext/arraybuffer/dataview.c

@@ -0,0 +1,467 @@
+#include "dataview.h"
+#include "arraybuffer.h"
+#include "extconf.h"
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+extern VALUE cArrayBuffer;
+extern VALUE cDataView;
+
+static ID idEndianess = Qundef;
+static ID idBig = Qundef;
+static ID idLittle = Qundef;
+
+#define FLAG_LITTLE_ENDIAN 1
+
+#define DECLAREDV(o) \
+  struct LLC_DataView *dv = (struct LLC_DataView*)rb_data_object_get((o))
+#define DECLAREBB(o) \
+  struct LLC_ArrayBuffer *bb = (struct LLC_ArrayBuffer*)rb_data_object_get((o))
+#define CHECK_LITTLEENDIAN(dv) ((dv)->flags & FLAG_LITTLE_ENDIAN)
+
+static void
+t_dv_gc_mark(struct LLC_DataView *dv) {
+  if (dv->bb_obj)
+    rb_gc_mark(dv->bb_obj);
+}
+
+static void
+t_dv_free(struct LLC_DataView *dv) {
+  xfree(dv);
+}
+
+static VALUE
+t_dv_allocator(VALUE klass) {
+  struct LLC_DataView *dv = (struct LLC_DataView*)xmalloc(sizeof(struct LLC_DataView));
+  dv->bb_obj = Qundef;
+  dv->size = 0;
+  dv->offset = 0;
+  dv->flags = 0;
+  return Data_Wrap_Struct(klass, t_dv_gc_mark, t_dv_free, dv);
+}
+
+/*
+ * call-seq:
+ *  initialize(buffer, offset, size, endianess:)
+ *
+ * Constructs a new DataView that provides a view of the data in a ArrayBuffer.
+ *
+ * Example:
+ *   buffer = ArrayBuffer.new(10)
+ *   buffer[1] = 20
+ *   buffer[2] = 55
+ *   view = DataView.new(buffer, 1, endianess: :little)
+ *   view.getU8() == ( 20 & (55 << 8) ) # true
+ *
+ * Or:
+ *
+ *   view = DataView.new(buffer, 1) # default endianess is "big endian"
+ *   view.getU8() == ( (20 << 8) | 55 ) # true
+ *
+ * @param buffer [ArrayBuffer] The array buffer where to operate
+ * @param offset [Integer] Optional. The byte offset from the array buffer. The
+ *   default value is zero
+ * @param size [Integer] Optional. The size in bytes that this DataView can
+ *   see into the array buffer. If left blank, the current size of the array
+ *   buffer will be used
+ * @param endianess [:big, :little] Optional. The default value is big
+ *
+ */
+static VALUE
+t_dv_initialize(int argc, VALUE *argv, VALUE self) {
+  DECLAREDV(self);
+  VALUE bb_obj;
+  VALUE offset;
+  VALUE size;
+  VALUE kwargs;
+  static ID keyword_ids[] = { 0 };
+
+  rb_scan_args(argc, argv, "12:", &bb_obj, &offset, &size, &kwargs);
+
+  DECLAREBB(bb_obj);
+
+  int size_val = NIL_P(size) ? (int)bb->size : NUM2INT(size);
+  if (size_val < 0)
+    size_val += (int)bb->size;
+  if (size_val < 0)
+    rb_raise(rb_eArgError, "calculated size is negative: %d", size_val);
+
+  int offset_val = NIL_P(offset) ? 0 : NUM2INT(offset);
+  if (offset_val < 0)
+    offset_val += (int)bb->size;
+  if (offset_val < 0)
+    rb_raise(rb_eArgError, "calculated offset is negative: %d", offset_val);
+
+  dv->offset = (unsigned long)offset_val;
+  dv->size = (unsigned long)size_val;
+  dv->bb_obj = bb_obj;
+
+  if (!keyword_ids[0]) {
+    keyword_ids[0] = idEndianess;
+  }
+
+  if (!NIL_P(kwargs)) {
+    VALUE endianess;
+    rb_get_kwargs(kwargs, keyword_ids, 0, 1, &endianess);
+    if (endianess != Qundef) {
+      Check_Type(endianess, T_SYMBOL);
+      ID id = SYM2ID(endianess);
+      if (id == idLittle)
+        dv->flags |= FLAG_LITTLE_ENDIAN;
+      else if (id != idBig)
+        rb_raise(rb_eArgError, "endianess must be either :big or :little");
+    }
+  }
+
+  return self;
+}
+
+static VALUE
+t_dv_size(VALUE self) {
+  DECLAREDV(self);
+  return UINT2NUM(dv->size);
+}
+
+static VALUE
+t_dv_offset(VALUE self) {
+  DECLAREDV(self);
+  return UINT2NUM(dv->offset);
+}
+
+static VALUE
+t_dv_endianess(VALUE self) {
+  DECLAREDV(self);
+  return CHECK_LITTLEENDIAN(dv) ?
+    ID2SYM(idLittle) :
+    ID2SYM(idBig);
+}
+
+static VALUE
+t_dv_each(VALUE self) {
+  DECLAREDV(self);
+  DECLAREBB(dv->bb_obj);
+
+  int size = dv->size;
+  if (size + dv->offset >= bb->size)
+    size = bb->size - dv->offset;
+
+  if (rb_block_given_p()) {
+    for (int i = 0; i < size; i++) {
+      unsigned int val = (unsigned int)bb->ptr[i + dv->offset];
+      rb_yield(UINT2NUM(val));
+    }
+  } else {
+    rb_raise(rb_eArgError, "no block given");
+  }
+  return self;
+}
+
+/*
+ * Defined the new offset for the DataView.
+ *
+ * Changing the offset does not affect the size.
+ * If passed a negative value, it will be summed with the underlying buffer
+ * size. The final value must not be lower than zero.
+ *
+ * @param offset [Integer] The new offset
+ */
+static VALUE
+t_dv_setoffset(VALUE self, VALUE offset) {
+  DECLAREDV(self);
+  DECLAREBB(dv->bb_obj);
+  int offset_val = NIL_P(offset) ? 0 : NUM2INT(offset);
+  if (offset_val < 0)
+    offset_val += (int)bb->size;
+  if (offset_val < 0)
+    rb_raise(rb_eArgError, "calculated offset is negative: %d", offset_val);
+
+  dv->offset = (unsigned long)offset_val;
+  return self;
+}
+
+/*
+ * Defined the new offset for the DataView.
+ *
+ * Changing the size does not affect the offset.
+ * If passed a negative value, it will be summed with the underlying buffer
+ * size. The final value must not be lower than zero.
+ *
+ * @param size [Integer] The new size. Must be zero or greater
+ */
+static VALUE
+t_dv_setsize(VALUE self, VALUE size) {
+  DECLAREDV(self);
+  DECLAREBB(dv->bb_obj);
+  int size_val = NIL_P(size) ? (int)bb->size : NUM2INT(size);
+  if (size_val < 0)
+    size_val += (int)bb->size;
+  if (size_val < 0)
+    rb_raise(rb_eArgError, "calculated size is negative: %d", size_val);
+
+  dv->size = (unsigned long)size_val;
+  return self;
+}
+
+#define DECLARENCHECKIDX(index) int idx = NUM2INT(index); \
+  if (idx < 0) idx += (int)dv->size; \
+  if (idx < 0 || idx >= dv->size) rb_raise(rb_eArgError, "index out of bounds: %d", idx);
+
+#define CHECKBOUNDSBB(v) if ((v) < 0 || (v) >= (bb)->size) \
+  rb_raise(rb_eArgError, "index out of underlying buffer bounds: %d", (v));
+
+/*
+ * Reads a bit at index.
+ *
+ * This method differs from the other in that the +index+ is given in bits, not
+ * in bytes.
+ * Thus it's possible to read from index +0+ to +(size * 8) - 1+
+ *
+ * @return [Integer] Either 0 or 1
+ */
+static VALUE
+t_dv_getbit(VALUE self, VALUE index) {
+  DECLAREDV(self); DECLAREBB(dv->bb_obj);
+  int idx = NUM2INT(index);
+  if (idx < 0)
+    idx += (int)dv->size * 8;
+  if (idx < 0 || idx >= dv->size * 8)
+    rb_raise(rb_eArgError, "index out of bounds: %d", idx);
+
+  unsigned int bit_idx = ((unsigned int)idx) & 7;
+  unsigned int byte_idx = (((unsigned int)idx) >> 3) + dv->offset;
+  unsigned char bit_mask = 1 << bit_idx;
+
+  CHECKBOUNDSBB(byte_idx);
+  return (bb->ptr[byte_idx] & bit_mask) ? UINT2NUM(1) : UINT2NUM(0);
+}
+
+/*
+ * Reads the byte at index as an +unsigned char+
+ *
+ * @return [Integer] Integer between 0 and 255
+ */
+static VALUE
+t_dv_getu8(VALUE self, VALUE index) {
+  DECLAREDV(self); DECLARENCHECKIDX(index); DECLAREBB(dv->bb_obj);
+  unsigned int real_idx = dv->offset + (unsigned int)idx;
+  CHECKBOUNDSBB(real_idx);
+  return UINT2NUM(bb->ptr[real_idx]);
+}
+
+/*
+ * Reads two bytes starting at index as an +unsigned short+
+ *
+ * @return [Integer] Integer between 0 and 65535
+ */
+static VALUE
+t_dv_getu16(VALUE self, VALUE index) {
+  DECLAREDV(self); DECLARENCHECKIDX(index); DECLAREBB(dv->bb_obj);
+  unsigned int idx0 = dv->offset + (unsigned int)idx;
+  unsigned int idx1 = dv->offset + (unsigned int)idx + 1;
+  CHECKBOUNDSBB(idx0);
+  CHECKBOUNDSBB(idx1);
+  unsigned short val = 0;
+  if (CHECK_LITTLEENDIAN(dv)) {
+    val |= bb->ptr[idx0];
+    val |= bb->ptr[idx1] << 8;
+  } else {
+    val |= bb->ptr[idx0] << 8;
+    val |= bb->ptr[idx1];
+  }
+  return UINT2NUM(val);
+}
+
+/*
+ * Reads three bytes starting at index as a 3 bytes long unsigned integer
+ *
+ * @return [Integer] Integer between 0 and 16777215
+ */
+static VALUE
+t_dv_getu24(VALUE self, VALUE index) {
+  DECLAREDV(self); DECLARENCHECKIDX(index); DECLAREBB(dv->bb_obj);
+  unsigned int idx0 = dv->offset + (unsigned int)idx;
+  unsigned int idx1 = dv->offset + (unsigned int)idx + 1;
+  unsigned int idx2 = dv->offset + (unsigned int)idx + 2;
+  CHECKBOUNDSBB(idx0);
+  CHECKBOUNDSBB(idx2);
+  unsigned int val = 0;
+  if (CHECK_LITTLEENDIAN(dv)) {
+    val |= bb->ptr[idx0];
+    val |= bb->ptr[idx1] << 8;
+    val |= bb->ptr[idx2] << 16;
+  } else {
+    val |= bb->ptr[idx0] << 16;
+    val |= bb->ptr[idx1] << 8;
+    val |= bb->ptr[idx2];
+  }
+  return UINT2NUM(val);
+}
+
+/*
+ * Reads four bytes starting at index as a 4 bytes long unsigned integer
+ *
+ * @return [Integer] Integer between 0 and 4294967295
+ */
+static VALUE
+t_dv_getu32(VALUE self, VALUE index) {
+  DECLAREDV(self); DECLARENCHECKIDX(index); DECLAREBB(dv->bb_obj);
+  unsigned int idx0 = dv->offset + (unsigned int)idx;
+  unsigned int idx1 = dv->offset + (unsigned int)idx + 1;
+  unsigned int idx2 = dv->offset + (unsigned int)idx + 2;
+  unsigned int idx3 = dv->offset + (unsigned int)idx + 3;
+  CHECKBOUNDSBB(idx0);
+  CHECKBOUNDSBB(idx3);
+  unsigned int val = 0;
+  if (CHECK_LITTLEENDIAN(dv)) {
+    val |= bb->ptr[idx0];
+    val |= bb->ptr[idx1] << 8;
+    val |= bb->ptr[idx2] << 16;
+    val |= bb->ptr[idx3] << 24;
+  } else {
+    val |= bb->ptr[idx0] << 24;
+    val |= bb->ptr[idx1] << 16;
+    val |= bb->ptr[idx2] << 8;
+    val |= bb->ptr[idx3];
+  }
+  return UINT2NUM(val);
+}
+
+#define ADJUSTBOUNDS(val, max) if (val < 0) val = 0; else if (val > max) val = max;
+
+/*
+ * Interprets one byte at index and assigns it an unsigned value
+ *
+ * Values lower than zero will be set to 0 and values greater than 255
+ * will be capped.
+ */
+static VALUE
+t_dv_setu8(VALUE self, VALUE index, VALUE value) {
+  DECLAREDV(self); DECLARENCHECKIDX(index); DECLAREBB(dv->bb_obj);
+  unsigned int idx0 = dv->offset + (unsigned int)idx;
+  CHECKBOUNDSBB(idx0);
+  int val = NUM2INT(value);
+  ADJUSTBOUNDS(val, 0xFF);
+  bb->ptr[idx0] = (unsigned char)val;
+  return self;
+}
+
+/*
+ * Interprets two bytes starting at index and sets them an unsigned value
+ *
+ * Values lower than zero will be set to 0 and values greater than 65535
+ * will be capped.
+ */
+static VALUE
+t_dv_setu16(VALUE self, VALUE index, VALUE value) {
+  DECLAREDV(self); DECLARENCHECKIDX(index); DECLAREBB(dv->bb_obj);
+  unsigned int idx0 = dv->offset + (unsigned int)idx;
+  unsigned int idx1 = dv->offset + (unsigned int)idx + 1;
+  CHECKBOUNDSBB(idx0);
+  CHECKBOUNDSBB(idx1);
+  int val = NUM2INT(value);
+  ADJUSTBOUNDS(val, 0xFFFF);
+  unsigned int uval = (unsigned int)val;
+  if (CHECK_LITTLEENDIAN(dv)) {
+    bb->ptr[idx0] = (unsigned char)(uval & 0xFF);
+    bb->ptr[idx1] = (unsigned char)((uval >> 8) & 0xFF);
+  } else {
+    bb->ptr[idx0] = (unsigned char)((uval >> 8) & 0xFF);
+    bb->ptr[idx1] = (unsigned char)(uval & 0xFF);
+  }
+  return self;
+}
+
+/*
+ * Interprets three bytes starting at index and sets them an unsigned value
+ *
+ * Values lower than zero will be set to 0 and values greater than 16777215
+ * will be capped.
+ */
+static VALUE
+t_dv_setu24(VALUE self, VALUE index, VALUE value) {
+  DECLAREDV(self); DECLARENCHECKIDX(index); DECLAREBB(dv->bb_obj);
+  unsigned int idx0 = dv->offset + (unsigned int)idx;
+  unsigned int idx1 = dv->offset + (unsigned int)idx + 1;
+  unsigned int idx2 = dv->offset + (unsigned int)idx + 2;
+  CHECKBOUNDSBB(idx0);
+  CHECKBOUNDSBB(idx2);
+  int val = NUM2INT(value);
+  ADJUSTBOUNDS(val, 0xFFFFFF);
+  unsigned int uval = (unsigned int)val;
+  if (CHECK_LITTLEENDIAN(dv)) {
+    bb->ptr[idx0] = (unsigned char)(uval & 0xFF);
+    bb->ptr[idx1] = (unsigned char)((uval >> 8) & 0xFF);
+    bb->ptr[idx2] = (unsigned char)((uval >> 16) & 0xFF);
+  } else {
+    bb->ptr[idx0] = (unsigned char)((uval >> 16) & 0xFF);
+    bb->ptr[idx1] = (unsigned char)((uval >> 8) & 0xFF);
+    bb->ptr[idx2] = (unsigned char)(uval & 0xFF);
+  }
+  return self;
+}
+
+/*
+ * Interprets four bytes starting at index and sets them an unsigned value
+ *
+ * Values lower than zero will be set to 0 and values greater than 4294967295
+ * will be capped.
+ */
+static VALUE
+t_dv_setu32(VALUE self, VALUE index, VALUE value) {
+  DECLAREDV(self); DECLARENCHECKIDX(index); DECLAREBB(dv->bb_obj);
+  unsigned int idx0 = dv->offset + (unsigned int)idx;
+  unsigned int idx1 = dv->offset + (unsigned int)idx + 1;
+  unsigned int idx2 = dv->offset + (unsigned int)idx + 2;
+  unsigned int idx3 = dv->offset + (unsigned int)idx + 3;
+  CHECKBOUNDSBB(idx0);
+  CHECKBOUNDSBB(idx3);
+  long val = NUM2LONG(value);
+  ADJUSTBOUNDS(val, 0xFFFFFFFF);
+  unsigned long uval = (unsigned long)val;
+  if (CHECK_LITTLEENDIAN(dv)) {
+    bb->ptr[idx0] = (unsigned char)(uval & 0xFF);
+    bb->ptr[idx1] = (unsigned char)((uval >> 8) & 0xFF);
+    bb->ptr[idx2] = (unsigned char)((uval >> 16) & 0xFF);
+    bb->ptr[idx3] = (unsigned char)((uval >> 24) & 0xFF);
+  } else {
+    bb->ptr[idx0] = (unsigned char)((uval >> 24) & 0xFF);
+    bb->ptr[idx1] = (unsigned char)((uval >> 16) & 0xFF);
+    bb->ptr[idx2] = (unsigned char)((uval >> 8) & 0xFF);
+    bb->ptr[idx3] = (unsigned char)(uval & 0xFF);
+  }
+  return self;
+}
+
+void
+Init_dataview() {
+  idEndianess = rb_intern("endianess");
+  idLittle = rb_intern("little");
+  idBig = rb_intern("big");
+
+  cDataView = rb_define_class("DataView", rb_cObject);
+  rb_define_alloc_func(cDataView, t_dv_allocator);
+  rb_include_module(cDataView, rb_mEnumerable);
+
+  rb_define_method(cDataView, "initialize", t_dv_initialize, -1);
+  rb_define_method(cDataView, "getBit", t_dv_getbit, 1);
+  rb_define_method(cDataView, "getU8", t_dv_getu8, 1);
+  rb_define_method(cDataView, "getU16", t_dv_getu16, 1);
+  rb_define_method(cDataView, "getU24", t_dv_getu24, 1);
+  rb_define_method(cDataView, "getU32", t_dv_getu32, 1);
+
+  rb_define_method(cDataView, "setU8", t_dv_setu8, 2);
+  rb_define_method(cDataView, "setU16", t_dv_setu16, 2);
+  rb_define_method(cDataView, "setU24", t_dv_setu24, 2);
+  rb_define_method(cDataView, "setU32", t_dv_setu32, 2);
+
+  rb_define_method(cDataView, "endianess", t_dv_endianess, 0);
+  rb_define_method(cDataView, "offset=", t_dv_setoffset, 1);
+  rb_define_method(cDataView, "offset", t_dv_offset, 0);
+  rb_define_method(cDataView, "size=", t_dv_setsize, 1);
+  rb_define_alias(cDataView, "length=", "size=");
+  rb_define_method(cDataView, "size", t_dv_size, 0);
+  rb_define_alias(cDataView, "length", "size");
+  rb_define_method(cDataView, "each", t_dv_each, 0);
+}

data/ext/arraybuffer/dataview.h

@@ -0,0 +1,13 @@
+#ifndef LLC_DATAVIEW_H
+#define LLC_DATAVIEW_H
+
+#include <ruby.h>
+
+struct LLC_DataView {
+  VALUE bb_obj;
+  unsigned int offset;
+  unsigned int size;
+  unsigned char flags;
+};
+
+#endif

data/ext/arraybuffer/extconf.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require 'mkmf'
+
+# preparation for compilation goes here
+
+create_header
+create_makefile 'arraybuffer_ext'

data/extconf.h

@@ -0,0 +1,3 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#endif

data/lib/arraybuffer.rb

@@ -0,0 +1 @@
+require "arraybuffer_ext"

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: arraybuffer
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- André Diego Piske
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+description: 
+email:
+- andrepiske@gmail.com
+executables: []
+extensions:
+- ext/arraybuffer/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/arraybuffer/arraybuffer.c
+- ext/arraybuffer/arraybuffer.h
+- ext/arraybuffer/arraybuffer_ext.c
+- ext/arraybuffer/dataview.c
+- ext/arraybuffer/dataview.h
+- ext/arraybuffer/extconf.rb
+- extconf.h
+- lib/arraybuffer.rb
+homepage: https://github.com/andrepiske/rb-arraybuffer
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/andrepiske/rb-arraybuffer
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Low level byte operators and buffers
+test_files: []