xnd 0.2.0dev3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ffef6659002865013b6d317fc2ac6bb681fc08a3
+  data.tar.gz: 86f1b508eafa5c9aae610e2d83213b9d36e505cc
+SHA512:
+  metadata.gz: 6829849586822ece90df0993fecd46c9fccac58de72998a2ca12b12b1626581d4b3ea303f583c142a75b7ad2b023b7b00b5d17c89609f3ce047f697c58b582c6
+  data.tar.gz: 206e74e6b6cc11941b16ea2d12e5bd8d1e1878364e927ed2ad6d6748239a400ab32457a5f0dae1c114419f86ede9bbecd07c52c700fb4897e30487f7279efaaf

data/CONTRIBUTING.md

@@ -0,0 +1,42 @@
+# Developer notes
+
+## Using C APIs from other Ruby libraries
+
+The xnd Ruby wrapper uses type definitions, macros and functions from the
+libndtypes Ruby wrapper. For this purpose, it is important to make sure that
+xnd can find the correct headers and shared object files during compile and
+linking time.
+
+This requires some modifications in both the ndtypes and xnd repos. ndtypes
+must ensure that the relevant header files and shared object are exposed to
+other Ruby gems.
+
+## structs in XND
+
+The primary struct that contains data for the XND type is the following:
+```
+typedef struct XndObject {
+  VALUE mblock;              /* owner of the primary type and memory block */
+  VALUE type;                /* owner of the current type. lives and dies with this obj. */
+  xnd_t xnd;                 /* typed view, does not own anything */
+} XndObject;
+```
+As the comments say, the `mblock` is an object of type `MemoryBlockObject` that
+is never revealed to the user. It is shared between multiple instances of XND objects
+and contains the primary type (i.e the type of the root object).
+
+The `type` attribute is of type `NDT` and exists only on a per-object basis. It is specific
+to the particular instance of `XndObject`. Therefore, whenever making a view, it is important
+to store a reference to the `mblock` in the GC guard so that the memory that the view needs
+to access for its data needs does not get GC'd in case the root object needs to be GC'd.
+
+## Infinite ranges
+
+Ruby 2.6 will introduce infinite ranges using a prettier and less verbose syntax, but for now
+we're stuck with using `Float::INFINITY` every time we want to specify an infinite range. This
+can quickly get tedious to type. Therefore XND introduces the following syntax for infinite
+ranges for references arrays:
+
+* Full range (`0..Float::INFINITY`) : `INF`.
+* Part range (`4..Float::INFINITY`) : `4..INF`.
+

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+gemspec
+

data/README.md

@@ -0,0 +1,7 @@
+# Introduction
+
+# Installation
+
+# Usage
+
+# Acknowledgments

data/Rakefile

@@ -0,0 +1,135 @@
+require 'rake'
+require 'rake/extensiontask'
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+require 'fileutils'
+require 'xnd/version.rb'
+
+gemspec = eval(IO.read("xnd.gemspec"))
+
+ext_name = "ruby_xnd"
+Rake::ExtensionTask.new(ext_name, gemspec) do |ext|
+  ext.ext_dir = "ext/#{ext_name}"
+  ext.source_pattern = "**/*.{c,h}"
+end
+
+def run *cmd
+  sh(cmd.join(" "))
+end
+
+task :console do
+  cmd = ['irb', "-r './lib/xnd.rb'"]
+  run(*cmd)
+end
+
+task :pry do
+  cmd = ['pry', "-r './lib/xnd.rb'"]
+  run(*cmd)
+end
+
+BASEDIR = Pathname( __FILE__ ).dirname.relative_path_from( Pathname.pwd )
+SPECDIR = BASEDIR + 'spec'
+
+VALGRIND_OPTIONS = [
+    "--tool=memcheck",
+    #"--leak-check=yes",
+    "--num-callers=15",
+    #"--error-limit=no",
+    "--partial-loads-ok=yes",
+    "--undef-value-errors=no" #,
+    #"--dsymutil=yes"
+]
+
+CALLGRIND_OPTIONS = [
+    "--tool=callgrind",
+    "--dump-instr=yes",
+    "--simulate-cache=yes",
+    "--collect-jumps=yes"
+]
+
+VALGRIND_MEMORYFILL_OPTIONS = [
+    "--freelist-vol=100000000",
+    "--malloc-fill=6D",
+    "--free-fill=66 ",
+]
+
+GDB_OPTIONS = []
+
+namespace :spec do
+  # partial-loads-ok and undef-value-errors necessary to ignore
+  # spurious (and eminently ignorable) warnings from the ruby
+  # interpreter
+
+  RSPEC_CMD = [ 'ruby', '-S', 'rspec', '-Ilib:ext', SPECDIR.to_s ]
+
+  desc "Run specs under GDB."
+  task :gdb => [ :compile ] do |task|
+          cmd = [ 'gdb' ] + GDB_OPTIONS
+    cmd += [ '--args' ]
+    cmd += RSPEC_CMD
+    run( *cmd )
+  end
+
+  desc "Run specs under cgdb."
+  task :cgdb => [ :compile ] do |task|
+    cmd = [ 'cgdb' ] + GDB_OPTIONS
+    cmd += [ '--args' ]
+    cmd += RSPEC_CMD
+    run( *cmd )
+  end
+
+  desc "Run specs under Valgrind."
+  task :valgrind => [ :compile ] do |task|
+    cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
+    cmd += RSPEC_CMD
+    run( *cmd )
+  end
+
+  desc "Run specs under Callgrind."
+  task :callgrind => [ :compile ] do |task|
+    cmd = [ 'valgrind' ] + CALLGRIND_OPTIONS
+    cmd += RSPEC_CMD
+    run( *cmd )
+  end
+end
+
+LEAKCHECK_CMD = [ 'ruby', '-Ilib:ext', "#{SPECDIR}/leakcheck.rb" ]
+
+desc "Run leakcheck script."
+task :leakcheck => [ :compile ] do |task|
+  cmd = [ 'valgrind' ] + VALGRIND_OPTIONS
+  cmd += LEAKCHECK_CMD
+  run( *cmd )
+end
+
+task :clobber do |task|
+  [
+    "ext/#{ext_name}/include",
+    "ext/#{ext_name}/share",
+    "ext/#{ext_name}/lib",
+  ].each do |f|
+    puts "deleting folder #{f}..."
+    FileUtils.rm_rf(f)
+  end
+
+  Dir.chdir("ext/#{ext_name}/xnd/libxnd/") do
+    system("make clean")
+  end
+end
+
+task :develop do
+  ext_xnd = "ext/ruby_xnd/xnd"
+  puts "deleting previously created #{ext_xnd} directory..."
+  FileUtils.rm_rf(ext_xnd)
+  Dir.mkdir(ext_xnd)
+
+  puts "cloning xnd repo into ext/ folder..."
+  system("git clone https://github.com/plures/xnd #{ext_xnd}")
+
+  Dir.chdir(ext_xnd) do
+    system("git checkout #{RubyXND::COMMIT}")
+  end
+
+  puts "building gem with rake build..."
+  system("rake build")
+end

data/ext/ruby_xnd/extconf.rb

@@ -0,0 +1,70 @@
+require 'mkmf'
+
+def windows?
+  (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+end
+
+def mac?
+  (/darwin/ =~ RUBY_PLATFORM) != nil
+end
+
+def unix?
+  !windows?
+end
+
+# libndtypes config
+
+ndtypes_version = ">= 0.2.0dev3"
+ndtypes_spec = Gem::Specification.find_by_name("ndtypes", ndtypes_version)
+ndtypes_extdir = File.join(ndtypes_spec.gem_dir, 'ext', 'ruby_ndtypes')
+ndtypes_includedir = File.join(ndtypes_extdir, 'include')
+ndtypes_libdir = File.join(ndtypes_extdir, 'lib')
+
+find_header("ruby_ndtypes.h", ndtypes_includedir)
+raise "cannot find ruby_ndtypes.h in path #{ndtypes_includedir}." unless have_header("ruby_ndtypes.h")
+
+find_header("ndtypes.h", ndtypes_includedir)
+find_library("ndtypes", nil, ndtypes_libdir)
+
+dir_config("ndtypes", [ndtypes_includedir], [ndtypes_libdir])
+
+# libxnd config
+
+puts "compiling libxnd for your machine..."
+Dir.chdir(File.join(File.dirname(__FILE__) + "/xnd")) do
+  if unix?
+    Dir.chdir("libxnd") do
+      Dir.mkdir(".objs") unless Dir.exists? ".objs"
+    end
+    
+    system("./configure --prefix=#{File.expand_path("../")} --with-docs=no " +
+           "--with-includes=#{ndtypes_includedir}")
+    system("make")
+    system("make install")
+  elsif windows?
+    raise NotImplementedError, "need to specify build instructions for windows."
+  end
+end
+
+binaries = File.expand_path(File.join(File.dirname(__FILE__) + "/lib/"))
+headers = File.expand_path(File.join(File.dirname(__FILE__) + "/include/"))
+
+find_library("xnd", nil, binaries)
+find_header("xnd.h", headers)
+
+dir_config("xnd", [headers], [binaries])
+
+$INSTALLFILES = [
+  ["ruby_xnd.h", "$(archdir)"],
+  ["xnd.h", "$(archdir)"]
+]
+
+# for macOS
+append_ldflags("-Wl,-rpath #{binaries}")
+
+basenames = %w{float_pack_unpack gc_guard ruby_xnd}
+$objs = basenames.map { |b| "#{b}.o"   }
+$srcs = basenames.map { |b| "#{b}.c" }
+
+$CFLAGS += " -fPIC -g "
+create_makefile("ruby_xnd/ruby_xnd")

data/ext/ruby_xnd/float_pack_unpack.c

@@ -0,0 +1,277 @@
+/* BSD 3-Clause License
+ *
+ * Copyright (c) 2018, Quansight and Sameer Deshmukh
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* Functions for packing and unpacking floats from char * arrays. 
+
+   Author: Sameer Deshmukh (@v0dro)
+*/
+
+#include "ruby_xnd_internal.h"
+
+/* Pack a 32-bit float into a contiguous unsigned char* buffer. 
+   
+   Reference:
+   https://github.com/python/cpython/blob/master/Include/floatobject.h#L77
+
+   @param num The number to be packed.
+   @param ptr
+   @param le Le is a boolean argument. True if you want the string in
+   litte-endian format, false if you want it in big-endian format.
+   
+   @return 0 if success. Raise ruby error if failure.
+*/
+int
+rb_xnd_pack_float32(double num, unsigned char* ptr, int le)
+{
+  float y = (float)num;
+  int i, incr = 1;
+
+  if (isinf(y) && !isinf(num)) {
+    rb_raise(rb_eRangeError, "cannot fit value in 32-bit floating point number.");
+  }
+
+  unsigned char s[sizeof(float)];
+  memcpy(s, &y, sizeof(float));
+
+#ifdef XND_DEBUG
+  if (!le) { // choose big-endian
+    ptr += 3;
+    incr = -1;
+  }
+#else
+  if ((IEEE_LITTLE_ENDIAN_P && !le) || (IEEE_BIG_ENDIAN_P && le)) { // choose big-endian
+    ptr += 3;
+    incr = -1;
+  }
+#endif
+
+  for (i = 0; i < sizeof(float); ++i) {
+    *ptr = s[i];
+    ptr += incr;
+  }
+
+  return 0;
+}
+
+/* Unpack a 32-bit float from a contiguos unsigned char* buffer. 
+  
+   @param ptr : 
+   @param le Le is a boolean argument. True if you want the string in
+   litte-endian format, false if you want it in big-endian format.
+
+   @return unpacked number as a double.
+*/
+int
+rb_xnd_unpack_float32(float *x, unsigned char* ptr, int le)
+{
+#ifdef XND_DEBUG
+  if (!le) // big-endian
+#else
+    if ((IEEE_LITTLE_ENDIAN_P && !le) || (IEEE_BIG_ENDIAN_P && le))// big-endian
+#endif
+      {
+        char buf[4];
+        char *d = &buf[3];
+        int i;
+
+        for (i = 0; i < sizeof(float); ++i) {
+          *d-- = *ptr++;
+        }
+        memcpy(x, buf, sizeof(float));
+      }
+    else {
+      memcpy(x, ptr, sizeof(float));
+    }
+
+  return 0;
+}
+
+/* Pack 64 bit floating point number into an unsigned char array.
+
+   @param num
+   @param ptr
+   @param le
+ */
+int
+rb_xnd_pack_float64(double num, unsigned char *ptr, int le)
+{
+  int i, incr = 1;
+
+  unsigned char s[sizeof(double)];
+  memcpy(s, &num, sizeof(double));
+
+#ifdef XND_DEBUG
+  if (!le) { // choose big-endian
+    ptr += 7;
+    incr = -1;
+  }
+#else
+  if ((IEEE_LITTLE_ENDIAN_P && !le) || (IEEE_BIG_ENDIAN_P && le)) { // choose big-endian
+    ptr += 7;
+    incr = -1;
+  }
+#endif
+
+  for (i = 0; i < sizeof(double); ++i) {
+    *ptr = s[i];
+    ptr += incr;
+  }
+
+  return 0;
+}
+
+/* Unpack a 64-bit floating point number from an unsigned char array and return
+   the resulting number as a type double.
+ */
+int
+rb_xnd_unpack_float64(double *x, unsigned char *ptr, int le)
+{
+#ifdef XND_DEBUG
+  if (!le) { // big-endian 
+#else
+    if ((IEEE_LITTLE_ENDIAN_P && !le) || (IEEE_BIG_ENDIAN_P && le)) { // big-endian
+#endif
+        char buf[sizeof(double)];
+        char *d = &buf[sizeof(double)-1];
+        int i;
+
+        for (i = 0; i < sizeof(double); ++i) {
+          *d-- = *ptr++;
+        }
+        memcpy(x, buf, sizeof(double));
+      }
+    else {
+      memcpy(x, ptr, sizeof(double));
+    }
+
+  return 0;
+}
+
+#ifdef XND_DEBUG
+/* Functions for testing packing/unpacking functions. 
+
+   In order to avoid the need for injecting the dependency of a C testing framework,
+   these are tests that work with the pack/unpack functions and are called in the
+   Init_ function if XND_DEBUG is defined.
+*/
+void
+test_pack_float32(void)
+{
+  double num = 16448.0;
+  int i;
+  unsigned char ptr[4];
+
+  /* test big endian */
+  unsigned char ans_bige[4] = {0x46, 0x80, 0x80, 0x00};
+  rb_xnd_pack_float32(num, ptr, 0);
+  for (i = 0; i < 4; i++) {
+    assert(ans_bige[i] == ptr[i]);
+  }
+
+  /* test little endian */
+  unsigned char ans_lite[4] = {0, 0X80, 0X80, 0X46};
+  rb_xnd_pack_float32(num, ptr, 1);
+  for (i = 0; i < 4; i++) {
+    assert(ans_lite[i] == ptr[i]);
+  }
+}
+
+void test_unpack_float32(void)
+{
+  float answer = 16448.0, result = 0.0;
+  
+  /* test big endian */
+  unsigned char ptr_bige[4] = {0x46, 0x80, 0x80, 0x00};
+  rb_xnd_unpack_float32(&result, ptr_bige, 0);
+  assert(answer == result);
+  
+  /* test little endian */
+  unsigned char ptr_lite[4] = {0, 0X80, 0X80, 0X46};
+  rb_xnd_unpack_float32(&result, ptr_lite, 1);
+  assert(answer == result);
+}
+
+void test_pack_float64(void)
+{
+  double num = 16448.0;
+  int i;
+  unsigned char ptr[8];
+
+  /* test big endian. */
+  unsigned char ans_bige[8] = {0x40, 0xD0, 0x10, 0, 0, 0, 0, 0};
+  rb_xnd_pack_float64(num, ptr, 0);
+  for (i = 0; i < 8; i++) {
+    assert(ans_bige[i] == ptr[i]);
+  }
+
+  /* test little endian. */
+  unsigned char ans_lite[8] = {0, 0, 0, 0, 0, 0X10, 0XD0, 0X40};
+  rb_xnd_pack_float64(num, ptr, 1);
+  for (i = 0; i < 8; i++) {
+    assert(ans_lite[i] == ptr[i]);
+  }
+
+  double a = 1.0;
+  unsigned char ans_lite_a[8] = {0, 0, 0, 0, 0, 0, 0xF0, 0x3F};
+  rb_xnd_pack_float64(a, ptr, 1);
+  for (i = 0; i < 8; i++) {
+    assert(ans_lite_a[i] == ptr[i]);
+  }
+}
+
+void test_unpack_float64(void)
+{
+  double answer = 16448.0, result = 0.0;
+
+  /* test big-endian */
+  unsigned char ptr_bige[8] = {0x40, 0xD0, 0x10, 0, 0, 0, 0, 0};
+  rb_xnd_unpack_float64(&result, ptr_bige, 0);
+  assert(answer == result);
+
+  /* test little-endian */
+  unsigned char ptr_lite[8] = {0, 0, 0, 0, 0, 0X10, 0XD0, 0X40};
+  rb_xnd_unpack_float64(&result, ptr_lite, 1);
+  assert(answer == result);
+
+  double a = 1.0;
+  unsigned char ans_lite_a[8] = {0, 0, 0, 0, 0, 0, 0xF0, 0x3F};
+  rb_xnd_unpack_float64(&result, ans_lite_a, 1);
+  assert(a == result);
+}
+
+void run_float_pack_unpack_tests(void)
+{
+  test_pack_float32();
+  test_unpack_float32();
+  test_pack_float64();
+  test_unpack_float64();
+}
+#endif