arraybuffer 0.0.3 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19ea4341e8a445c5f0f7fb037201da95de458b1c598b19dfcdede555a7ada4af
-  data.tar.gz: 55c21ac531706d232aeb9997c214ea99124e5c5d72ca94266abcf91b47431408
+  metadata.gz: 517c77a2de7cbcd60febb5217cd77f8b249848c7947519a50f9a63fb291713a4
+  data.tar.gz: 56cfdbea1a7222001ebd918d7e8e10674837b51621d490de97d104b059ee8301
 SHA512:
-  metadata.gz: 761a077323636bb899b3c764f1b6225e0af328468d70a82a8d2cad42e70c585eeda68c6bbb8bf23c2ba3b80f495fc93402ef9b7e92cea77936d1e22a7a8b48fc
-  data.tar.gz: c1f26cdd5a15d3cb1068be495f8b1aee915b29a647fec7fc146420f0b39bf67a186a64b7b7fd52d58e744a380c3a5426ec0a906f0d71ac87313dca883093883a
+  metadata.gz: bae4c20202057631b3f554adecee91ade37f2d7f12de3cb88dc03405c321be5f79fac4931f6642af74d73e38dd2cab35857cc826eb2e45d6f9275ad3621c3213
+  data.tar.gz: a6955800866b293dfd7fbcd55b56b936876124081044e14024fe9f21b2ccbec0193a77c435f11ab0b5133fa2ba86de267f0f024a1cb00e22f93ad664c87cc746

data/ext/arraybuffer/arraybuffer.c

@@ -1,6 +1,11 @@
 #include "arraybuffer.h"
 #include "extconf.h"
 #include <string.h>
+#include <ruby/version.h>
+
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+#include <ruby/memory_view.h>
+#endif
 
 extern VALUE cArrayBuffer;
 
@@ -12,15 +17,43 @@ extern VALUE cArrayBuffer;
     rb_raise(rb_eArgError, "Index out of bounds: %d", (idx)); \
   }
 
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+static bool
+r_bb_mv_get(VALUE self, rb_memory_view_t *view, int flags) {
+  DECLAREBB(self);
+  if (!bb->size)
+    return 0;
+  rb_memory_view_init_as_byte_array(view, self, bb->ptr, (const ssize_t)bb->size, 0);
+  return 1;
+}
+
+// static bool
+// r_bb_mv_release(VALUE self, rb_memory_view_t *view) {
+//   return 1;
+// }
+
+static bool
+r_bb_mv_available_p(VALUE self) {
+  DECLAREBB(self);
+  return bb->size > 0 ? 1 : 0;
+}
+
+static rb_memory_view_entry_t cArrayBufferMemoryView = {
+  r_bb_mv_get,
+  NULL, // r_bb_mv_release,
+  r_bb_mv_available_p
+};
+#endif
+
 static void
 t_bb_gc_mark(struct LLC_ArrayBuffer *bb) {
+  if (bb->backing_str) {
+    rb_gc_mark(bb->backing_str);
+  }
 }
 
 static void
 t_bb_free(struct LLC_ArrayBuffer *bb) {
-  if (bb->ptr)
-    xfree(bb->ptr);
-
   xfree(bb);
 }
 
@@ -29,18 +62,46 @@ t_bb_allocator(VALUE klass) {
   struct LLC_ArrayBuffer *bb = (struct LLC_ArrayBuffer*)xmalloc(sizeof(struct LLC_ArrayBuffer));
   bb->ptr = NULL;
   bb->size = 0;
+  bb->backing_str = NULL;
 
   return Data_Wrap_Struct(klass, t_bb_gc_mark, t_bb_free, bb);
 }
 
+#if (RUBY_API_VERSION_CODE >= 30100)
+  // Ruby 3.1 and later
+
+  #define BB_BACKING_PTR(bb) \
+    (FL_TEST((bb)->backing_str, RSTRING_NOEMBED) ? RSTRING((bb)->backing_str)->as.heap.ptr : &RSTRING(bb->backing_str)->as.embed.ary)
+#else
+  // Before ruby 3.1
+
+  #define BB_BACKING_PTR(bb) \
+    (FL_TEST((bb)->backing_str, RSTRING_NOEMBED) ? RSTRING((bb)->backing_str)->as.heap.ptr : &RSTRING(bb->backing_str)->as.ary)
+#endif
+
+static void
+t_bb_reassign_ptr(struct LLC_ArrayBuffer *bb) {
+  if (!bb->backing_str) {
+    bb->ptr = NULL;
+    return;
+  }
+
+  rb_str_set_len(bb->backing_str, bb->size);
+  bb->ptr = BB_BACKING_PTR(bb);
+  bb->ptr[bb->size] = 0;
+}
+
 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);
+  if (bb->backing_str)
+    rb_gc_mark(bb->backing_str);
+
+  bb->backing_str = rb_str_buf_new(s);
+
+  t_bb_reassign_ptr(bb);
   memset(bb->ptr, 0, (size_t)s);
   return self;
 }
@@ -96,31 +157,9 @@ t_bb_realloc(VALUE self, VALUE _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);
+  rb_str_resize(bb->backing_str, new_size);
+  bb->size = new_size;
+  t_bb_reassign_ptr(bb);
 
   return self;
 }
@@ -128,8 +167,8 @@ t_bb_realloc(VALUE self, VALUE _new_size) {
 /*
  * 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.
+ * The returned string is the backing string of the buffer.
+ * It's encoding is always ASCII-8BIT.
  * If the buffer has size zero, an empty string is returned.
  *
  * @return [String]
@@ -137,9 +176,7 @@ t_bb_realloc(VALUE self, VALUE _new_size) {
 static VALUE
 t_bb_bytes(VALUE self) {
   DECLAREBB(self);
-  return rb_tainted_str_new(
-    (const char*)bb->ptr,
-    bb->size);
+  return bb->backing_str;
 }
 
 void
@@ -156,4 +193,9 @@ Init_arraybuffer() {
   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);
+  rb_define_method(cArrayBuffer, "to_s", t_bb_bytes, 0);
+
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+  rb_memory_view_register(cArrayBuffer, &cArrayBufferMemoryView);
+#endif
 }

data/ext/arraybuffer/arraybuffer.h

@@ -6,6 +6,7 @@
 struct LLC_ArrayBuffer {
   unsigned char *ptr;
   unsigned int size;
+  VALUE backing_str;
 };
 
 #endif

data/ext/arraybuffer/dataview.c

@@ -6,6 +6,10 @@
 #include <string.h>
 #endif
 
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+#include <ruby/memory_view.h>
+#endif
+
 extern VALUE cArrayBuffer;
 extern VALUE cDataView;
 
@@ -42,6 +46,39 @@ t_dv_allocator(VALUE klass) {
   return Data_Wrap_Struct(klass, t_dv_gc_mark, t_dv_free, dv);
 }
 
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+static bool
+r_dv_mv_get(VALUE self, rb_memory_view_t *view, int flags) {
+  DECLAREDV(self);
+  if (!dv->size)
+    return 0;
+
+  DECLAREBB(dv->bb_obj);
+
+  char *ptr = (char*)bb->ptr + (size_t)dv->offset;
+
+  rb_memory_view_init_as_byte_array(view, self, ptr, (const ssize_t)dv->size, 0);
+  return 1;
+}
+
+// static bool
+// r_dv_mv_release(VALUE self, rb_memory_view_t *view) {
+//   return 1;
+// }
+
+static bool
+r_dv_mv_available_p(VALUE self) {
+  DECLAREDV(self);
+  return dv->size > 0 ? 1 : 0;
+}
+
+static rb_memory_view_entry_t cDataViewMemoryView = {
+  r_dv_mv_get,
+  NULL, // r_dv_mv_release,
+  r_dv_mv_available_p
+};
+#endif
+
 /*
  * call-seq:
  *  initialize(buffer, offset, size, endianess:)
@@ -434,6 +471,71 @@ t_dv_setu32(VALUE self, VALUE index, VALUE value) {
   return self;
 }
 
+static VALUE
+t_dv_setbytes(VALUE self, VALUE index, VALUE bytes) {
+  DECLAREDV(self); DECLARENCHECKIDX(index); DECLAREBB(dv->bb_obj);
+  unsigned int idx0 = dv->offset + (unsigned int)idx;
+  CHECKBOUNDSBB(idx0);
+
+  if (RB_TYPE_P(bytes, T_ARRAY)) {
+    const unsigned int length = (unsigned int)rb_array_len(bytes);
+    const VALUE* items = rb_array_const_ptr(bytes);
+    CHECKBOUNDSBB(idx0 + length);
+
+    for (unsigned int i = 0; i < length; i++) {
+      if (!RB_FIXNUM_P(items[i]))
+        rb_raise(rb_eRuntimeError, "array contains non fixnum value at index %d", i);
+      int num = NUM2INT(items[i]);
+      ADJUSTBOUNDS(num, 0xFF);
+      bb->ptr[idx0 + i] = (unsigned char)num;
+    }
+  } else if (RB_TYPE_P(bytes, T_STRING)) {
+    const char *str_ptr = RSTRING_PTR(bytes);
+    const unsigned int length = (unsigned int)RSTRING_LEN(bytes);
+    CHECKBOUNDSBB(idx0 + length);
+
+    for (unsigned int i = 0; i < length; i++) {
+      bb->ptr[idx0 + i] = (unsigned char)str_ptr[i];
+    }
+  } else if (RB_TYPE_P(bytes, T_DATA) &&
+    (CLASS_OF(bytes) == cArrayBuffer || CLASS_OF(bytes) == cDataView)) {
+    unsigned int length;
+    const char *src_bytes;
+    if (CLASS_OF(bytes) == cArrayBuffer) {
+      struct LLC_ArrayBuffer *src_bb = (struct LLC_ArrayBuffer*)rb_data_object_get(bytes);
+      length = src_bb->size;
+      src_bytes = (const char*)src_bb->ptr;
+    } else {
+      struct LLC_DataView *src_dv = (struct LLC_DataView*)rb_data_object_get(bytes);
+      struct LLC_ArrayBuffer *src_bb = (struct LLC_ArrayBuffer*)rb_data_object_get(src_dv->bb_obj);
+      length = src_dv->size;
+      src_bytes = (const char*)(src_bb->ptr + (size_t)src_dv->offset);
+      if (src_dv->offset >= src_bb->size)
+        rb_raise(rb_eRuntimeError, "offset exceeds the underlying source buffer size");
+      if (src_dv->offset + length >= src_bb->size)
+        rb_raise(rb_eRuntimeError, "offset + size exceeds the underlying source buffer size");
+    }
+
+    CHECKBOUNDSBB(idx0 + length);
+    memcpy((void*)(bb->ptr + (size_t)idx0), src_bytes, (size_t)length);
+  } else {
+    rb_raise(rb_eArgError, "Invalid type: %+"PRIsVALUE, CLASS_OF(bytes));
+  }
+
+  return self;
+}
+
+VALUE
+t_dv_to_s(VALUE self) {
+  DECLAREDV(self);
+  DECLAREBB(dv->bb_obj);
+
+  const char *ptr = (const char*)bb->ptr + (size_t)dv->offset;
+  size_t len = (size_t)dv->size;
+
+  return rb_str_new(ptr, len);
+}
+
 void
 Init_dataview() {
   idEndianess = rb_intern("endianess");
@@ -456,6 +558,8 @@ Init_dataview() {
   rb_define_method(cDataView, "setU24", t_dv_setu24, 2);
   rb_define_method(cDataView, "setU32", t_dv_setu32, 2);
 
+  rb_define_method(cDataView, "setBytes", t_dv_setbytes, 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);
@@ -464,4 +568,10 @@ Init_dataview() {
   rb_define_method(cDataView, "size", t_dv_size, 0);
   rb_define_alias(cDataView, "length", "size");
   rb_define_method(cDataView, "each", t_dv_each, 0);
+
+  rb_define_method(cDataView, "to_s", t_dv_to_s, 0);
+
+#ifdef HAVE_RUBY_MEMORY_VIEW_H
+  rb_memory_view_register(cDataView, &cDataViewMemoryView);
+#endif
 }

data/ext/arraybuffer/extconf.rb

@@ -3,5 +3,9 @@ require 'mkmf'
 
 # preparation for compilation goes here
 
+if have_header("ruby/memory_view.h")
+  have_type("rb_memory_view_t", ["ruby/memory_view.h"])
+end
+
 create_header
 create_makefile 'arraybuffer_ext'

data/extconf.h

@@ -1,3 +1,5 @@
 #ifndef EXTCONF_H
 #define EXTCONF_H
+#define HAVE_RUBY_MEMORY_VIEW_H 1
+#define HAVE_TYPE_RB_MEMORY_VIEW_T 1
 #endif

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arraybuffer
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.6
 platform: ruby
 authors:
 - André Diego Piske
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-17 00:00:00.000000000 Z
+date: 2022-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,7 +24,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.9'
-description: 
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description:
 email:
 - andrepiske@gmail.com
 executables: []
@@ -40,12 +54,13 @@ files:
 - ext/arraybuffer/extconf.rb
 - extconf.h
 - lib/arraybuffer.rb
+- lib/arraybuffer_ext.bundle
 homepage: https://github.com/andrepiske/rb-arraybuffer
 licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/andrepiske/rb-arraybuffer
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -60,8 +75,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.3.11
+signing_key:
 specification_version: 4
-summary: Low level byte operators and buffers
+summary: An array buffer (a.k.a. byte array) implementation forRuby, implemented natively.
 test_files: []