xnd 0.2.0dev5 → 0.2.0dev6

data/ext/ruby_xnd/util.h

@@ -44,127 +44,18 @@
 #include "ndtypes.h"
 
 /* Raise an error stored in $!. Clears it before raising. */
-inline void
-raise_error(void)
-{
-  VALUE exeception = rb_errinfo();
+void raise_error(void);
 
-  rb_set_errinfo(Qnil);
-  rb_exc_raise(exeception);
-}
+void set_error_info(VALUE err, const char * msg);
 
-inline void
-set_error_info(VALUE err, const char * msg)
-{
-  rb_set_errinfo(rb_exc_new2(err, msg));
-}
+size_t safe_downcast(int64_t size);
 
-static inline size_t
-safe_downcast(int64_t size)
-{
-#if SIZE_MAX < INT64_MAX
-    if (size > INT32_MAX) {
-      rb_raise(rb_eSizeError,
-                "sizes should never exceed INT32_MAX on 32-bit platforms.");
-    }
-#endif
-    return (size_t)size;
-}
+bool check_invariants(const ndt_t *t);
 
-static inline bool
-check_invariants(const ndt_t *t)
-{
-#if SIZE_MAX < INT64_MAX
-    return safe_downcast(t->datasize) >= 0;
-#else
-    (void)t;
-    return 1;
-#endif
-}
+VALUE array_new(int64_t size);
 
-static inline VALUE
-array_new(int64_t size)
-{
-#if SIZE_MAX < INT64_MAX
-    size_t n = safe_downcast(size);
-    return n < 0 ? NULL : rb_ary_new2(n);
-#else
-    return rb_ary_new2(size);
-#endif
-}
+VALUE bytes_from_string_and_size(const char *str, int64_t size);
 
-static inline VALUE
-bytes_from_string_and_size(const char *str, int64_t size)
-{
-#if SIZE_MAX < INT64_MAX
-    size_t n = safe_downcast(size);
-    return n < 0 ? NULL : rb_str_new(str, n);
-#else
-    return rb_str_new(str, size);
-#endif
-}
-
-static long long
-mod(long long a, long long b)
-{
-    long long r = a % b;
-    return r < 0 ? r + b : r;
-}
-
-static inline int
-rb_range_unpack(VALUE range, long long *begin, long long *end, long long *step, size_t size)
-{
-  /* FIXME: As of 27 Aug. 2018 Ruby trunk implements step as a property of
-     Range and XND will support it as and when it is available. Maybe for 
-     now we can implement a #step iterator in a separate method.
-  */
- *step = 1;
- VALUE rb_begin = rb_funcall(range, rb_intern("begin"), 0, NULL);
- VALUE rb_end = rb_funcall(range, rb_intern("end"), 0, NULL);
- int exclude_end = RTEST(rb_funcall(range, rb_intern("exclude_end?"), 0, NULL));
- 
- if (RB_TYPE_P(rb_begin, T_FLOAT)) {
-   double value = RFLOAT_VALUE(rb_begin);
-
-   if (isinf(value)) {
-     *begin = 0;  
-   }
- }
- else {
-   long long temp = NUM2LL(rb_begin);
-
-   if (temp < 0) {            /* if negative index map to positive. */
-     temp = mod(temp, (long long)size);
-   }
-
-   *begin = temp;
- }
-
- if (RB_TYPE_P(rb_end, T_FLOAT)) {
-   double value = RFLOAT_VALUE(rb_end);
-
-   if (isinf(value)) {
-     *end = INT64_MAX;
-     return;
-   }
- }
- else {
-   long long temp = NUM2LL(rb_end);
-
-   if (temp < 0) {              /* if negative index map to ppositive. */
-     temp = mod(temp, (long long)size);
-   }
-   
-   *end = temp;
- }
-
- /* a[0..0] in Ruby returns the 0th index. 
-    a[0...0] in Ruby returns empty array like a[0:0] in Python.
-    libxnd does not include the last index by default.  
-*/
- if (!exclude_end) {          
-   *end += 1;
- }
-}
+int ndt_exists(void);
 
 #endif  /* UTIL_H */

data/lib/xnd.rb

@@ -29,18 +29,25 @@
 #  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 require 'ndtypes'
-require "ruby_xnd.so"
+begin
+  require "ruby_xnd.so"
+rescue LoadError
+  require 'ruby_xnd/ruby_xnd.so'
+end
 
-require 'xnd/monkeys'
 require 'xnd/version'
 
 INF = Float::INFINITY
 
-class RubyXND
+class XND
   class Ellipsis
     def to_s
       "..."
     end
+
+    def == other
+      other.is_a?(XND::Ellipsis) ? true : false
+    end
   end
 end
 
@@ -122,6 +129,7 @@ class XND < RubyXND
           end
 
           t = dtype
+
           var = shapes.map { |lst| lst.uniq.size > 1 || nil }.any?
           shapes.each do |lst|
             opt = lst.include? nil

data/lib/xnd/version.rb

@@ -1,6 +1,6 @@
 class RubyXND
   # VERSION number should be the version of libxnd this is built against.
-  VERSION = "0.2.0dev5"
+  VERSION = "0.2.0dev6"
   # Working commit in xnd repo
   COMMIT = "31ec2d8501af442e1a5054d9531a5e2cefb242cb"
 end

data/xnd.gemspec

@@ -37,8 +37,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
-  
-  spec.add_development_dependency 'rspec', '~> 3.8'
+
+  spec.add_development_dependency 'minitest', '~> 5.11'
+  spec.add_development_dependency 'minitest-hooks'
   spec.add_development_dependency 'rake-compiler'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'pry-byebug'

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: xnd
 version: !ruby/object:Gem::Version
-  version: 0.2.0dev5
+  version: 0.2.0dev6
 platform: ruby
 authors:
 - Sameer Deshmukh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-25 00:00:00.000000000 Z
+date: 2018-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '5.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: minitest-hooks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -101,16 +115,12 @@ files:
 - ext/ruby_xnd/float_pack_unpack.h
 - ext/ruby_xnd/gc_guard.c
 - ext/ruby_xnd/gc_guard.h
-- ext/ruby_xnd/include/xnd.h
-- ext/ruby_xnd/lib/libxnd.a
-- ext/ruby_xnd/lib/libxnd.so
-- ext/ruby_xnd/lib/libxnd.so.0
-- ext/ruby_xnd/lib/libxnd.so.0.2.0dev3
 - ext/ruby_xnd/memory_block_object.c
 - ext/ruby_xnd/memory_block_object.h
 - ext/ruby_xnd/ruby_xnd.c
 - ext/ruby_xnd/ruby_xnd.h
 - ext/ruby_xnd/ruby_xnd_internal.h
+- ext/ruby_xnd/util.c
 - ext/ruby_xnd/util.h
 - ext/ruby_xnd/xnd/AUTHORS.txt
 - ext/ruby_xnd/xnd/INSTALL.txt
@@ -171,16 +181,8 @@ files:
 - ext/ruby_xnd/xnd/vcbuild/vcbuild64.bat
 - ext/ruby_xnd/xnd/vcbuild/vcclean.bat
 - ext/ruby_xnd/xnd/vcbuild/vcdistclean.bat
-- lib/ruby_xnd.so
 - lib/xnd.rb
-- lib/xnd/monkeys.rb
 - lib/xnd/version.rb
-- spec/debug_spec.rb
-- spec/gc_guard_spec.rb
-- spec/leakcheck.rb
-- spec/spec_helper.rb
-- spec/type_inference_spec.rb
-- spec/xnd_spec.rb
 - xnd.gemspec
 homepage: https://github.com/plures/xnd
 licenses:
@@ -206,10 +208,4 @@ rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Ruby wrapper over libxnd. A library for typed data containers.
-test_files:
-- spec/debug_spec.rb
-- spec/gc_guard_spec.rb
-- spec/leakcheck.rb
-- spec/spec_helper.rb
-- spec/type_inference_spec.rb
-- spec/xnd_spec.rb
+test_files: []

data/ext/ruby_xnd/include/xnd.h

@@ -1,449 +0,0 @@
-/*
- * BSD 3-Clause License
- *
- * Copyright (c) 2017-2018, plures
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *
- * 2. 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.
- *
- * 3. 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.
- */
-
-
-#ifndef XND_H
-#define XND_H
-
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include <assert.h>
-#include "ndtypes.h"
-
-
-#ifdef _MSC_VER
-  #if defined (XND_EXPORT)
-    #define XND_API __declspec(dllexport)
-  #elif defined(XND_IMPORT)
-    #define XND_API __declspec(dllimport)
-  #else
-    #define XND_API
-  #endif
-#else
-  #define XND_API
-#endif
-
-
-#if SIZE_MAX == UINT64_MAX
-  #define XND_SSIZE_MAX INT64_MAX
-#elif SIZE_MAX == UINT32_MAX
-  #define XND_SSIZE_MAX INT32_MAX
-#else
-  #error "unsupported platform: need 32-bit or 64-bit size_t"
-#endif
-
-
-/*
- * Ownership flags: The library itself has no notion of how many exported
- * views a master buffer has. The Python bindings for example use Pythons's
- * reference counting to to keep track of exported memory blocks.
- */
-#define XND_OWN_TYPE     0x00000001U /* type pointer */
-#define XND_OWN_DATA     0x00000002U /* data pointer */
-#define XND_OWN_STRINGS  0x00000004U /* embedded string pointers */
-#define XND_OWN_BYTES    0x00000008U /* embedded bytes pointers */
-#define XND_OWN_POINTERS 0x00000010U /* embedded pointers */
-
-#define XND_OWN_ALL (XND_OWN_TYPE |    \
-                     XND_OWN_DATA |    \
-                     XND_OWN_STRINGS | \
-                     XND_OWN_BYTES |   \
-                     XND_OWN_POINTERS)
-
-#define XND_OWN_EMBEDDED (XND_OWN_DATA |    \
-                          XND_OWN_STRINGS | \
-                          XND_OWN_BYTES |   \
-                          XND_OWN_POINTERS)
-
-
-/* Convenience macros to extract embedded values. */
-#define XND_POINTER_DATA(ptr) (*((char **)ptr))
-#define XND_BYTES_SIZE(ptr) (((ndt_bytes_t *)ptr)->size)
-#define XND_BYTES_DATA(ptr) (((ndt_bytes_t *)ptr)->data)
-
-
-/* Bitmap tree. */
-typedef struct xnd_bitmap xnd_bitmap_t;
-
-struct xnd_bitmap {
-    uint8_t *data;      /* bitmap */
-    int64_t size;       /* number of subtree bitmaps in the "next" array */
-    xnd_bitmap_t *next; /* array of bitmaps for subtrees */
-};
-
-/* Typed memory block, usually a view. */
-typedef struct xnd {
-    xnd_bitmap_t bitmap; /* bitmap tree */
-    int64_t index;       /* linear index for var dims */
-    const ndt_t *type;   /* type of the data */
-    char *ptr;           /* data */
-} xnd_t;
-
-/* Master memory block. */
-typedef struct xnd_master {
-    uint32_t flags; /* ownership flags */
-    xnd_t master;   /* typed memory */
-} xnd_master_t;
-
-/* Used in indexing and slicing. */
-enum xnd_key { Index, FieldName, Slice };
-typedef struct {
-  enum xnd_key tag;
-  union {
-    int64_t Index;
-    const char *FieldName;
-    ndt_slice_t Slice;
-  };
-} xnd_index_t;
-
-
-/* Unstable API: view with ownership tracking. */
-typedef struct xnd_view {
-    uint32_t flags;  /* flags that indicate resource ownership by the view */
-    const void *obj; /* object that holds shared resources */
-    xnd_t view;      /* typed memory */
-} xnd_view_t;
-
-
-/*****************************************************************************/
-/*                         Create xnd memory blocks                          */
-/*****************************************************************************/
-
-XND_API xnd_master_t *xnd_empty_from_string(const char *s, uint32_t flags, ndt_context_t *ctx);
-XND_API xnd_master_t *xnd_empty_from_type(const ndt_t *t, uint32_t flags, ndt_context_t *ctx);
-XND_API void xnd_del(xnd_master_t *x);
-
-/* Create and delete pristine xnd_t buffers. */
-XND_API xnd_master_t *xnd_from_xnd(xnd_t *src, uint32_t flags, ndt_context_t *ctx);
-XND_API void xnd_del_buffer(xnd_t *x, uint32_t flags);
-
-
-/*****************************************************************************/
-/*                         Traverse xnd memory blocks                        */
-/*****************************************************************************/
-
-XND_API xnd_t xnd_subtree_index(const xnd_t *x, const int64_t *indices, int len,
-                                ndt_context_t *ctx);
-
-XND_API xnd_t xnd_subtree(const xnd_t *x, const xnd_index_t indices[], int len,
-                          ndt_context_t *ctx);
-
-XND_API xnd_t xnd_multikey(const xnd_t *x, const xnd_index_t indices[], int len,
-                           ndt_context_t *ctx);
-
-XND_API xnd_t xnd_subscript(const xnd_t *x, const xnd_index_t indices[], int len,
-                            ndt_context_t *ctx);
-
-XND_API xnd_t *xnd_split(const xnd_t *x, int64_t *n, int max_outer, ndt_context_t *ctx);
-
-XND_API int xnd_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx);
-XND_API int xnd_strict_equal(const xnd_t *x, const xnd_t *y, ndt_context_t *ctx);
-
-XND_API int xnd_copy(xnd_t *y, const xnd_t *x, uint32_t flags, ndt_context_t *ctx);
-
-
-/*****************************************************************************/
-/*                                  Bitmaps                                  */
-/*****************************************************************************/
-
-XND_API int xnd_bitmap_init(xnd_bitmap_t *b, const ndt_t *t, ndt_context_t *ctx);
-XND_API void xnd_bitmap_clear(xnd_bitmap_t *b);
-XND_API xnd_bitmap_t xnd_bitmap_next(const xnd_t *x, int64_t i, ndt_context_t *ctx);
-XND_API void xnd_set_valid(xnd_t *x);
-XND_API void xnd_set_na(xnd_t *x);
-XND_API int xnd_is_valid(const xnd_t *x);
-XND_API int xnd_is_na(const xnd_t *x);
-
-
-/*****************************************************************************/
-/*                               Error handling                              */
-/*****************************************************************************/
-
-XND_API extern const xnd_t xnd_error;
-XND_API extern const xnd_bitmap_t xnd_bitmap_empty;
-
-
-/*****************************************************************************/
-/*                                 Unstable API                              */
-/*****************************************************************************/
-
-XND_API extern const xnd_view_t xnd_view_error;
-
-XND_API int xnd_view_err_occurred(const xnd_view_t *x);
-XND_API void xnd_view_clear(xnd_view_t *x);
-XND_API xnd_view_t xnd_view_from_xnd(const void *obj, const xnd_t *x);
-XND_API xnd_view_t xnd_view_subscript(const xnd_view_t *x, const xnd_index_t indices[],
-                                      int len, ndt_context_t *ctx);
-
-
-
-/*****************************************************************************/
-/*                                 Float format                              */
-/*****************************************************************************/
-
-XND_API int xnd_init_float(ndt_context_t *ctx);
-XND_API bool xnd_float_is_little_endian(void);
-XND_API bool xnd_float_is_big_endian(void);
-XND_API bool xnd_double_is_little_endian(void);
-XND_API bool xnd_double_is_big_endian(void);
-
-
-/*****************************************************************************/
-/*                           Static inline functions                         */
-/*****************************************************************************/
-
-/*
- * This looks inefficient, but both gcc and clang clean up unused xnd_t members.
- */
-static inline int64_t
-xnd_ndim(const xnd_t *x)
-{
-    return x->type->ndim;
-}
-
-static inline xnd_t
-xnd_fixed_dim_next(const xnd_t *x, const int64_t i)
-{
-    const ndt_t *t = x->type;
-    const ndt_t *u = t->FixedDim.type;
-    const int64_t step = i * t->Concrete.FixedDim.step;
-    xnd_t next;
-
-    assert(t->tag == FixedDim);
-
-    next.bitmap = x->bitmap;
-    next.index = x->index + step;
-    next.type = u;
-    next.ptr = u->ndim==0 ? x->ptr + next.index * next.type->datasize : x->ptr;
-
-    return next;
-}
-
-static inline int64_t
-xnd_fixed_shape(const xnd_t *x)
-{
-    const ndt_t *t = x->type;
-    assert(t->tag == FixedDim);
-    return t->FixedDim.shape;
-}
-
-static inline int64_t
-xnd_fixed_shape_at(const xnd_t *x, const int i)
-{
-    const ndt_t *t = x->type;
-
-    assert(0 <= i && i < t->ndim);
-    assert(t->tag == FixedDim);
-
-    for (int k = 0; k < i; k++) {
-        t = t->FixedDim.type;
-    }
-    return t->FixedDim.shape;
-}
-
-static inline int64_t
-xnd_fixed_stride(const xnd_t *x)
-{
-    const ndt_t *t = x->type;
-    assert(t->tag == FixedDim);
-    return t->Concrete.FixedDim.step * t->Concrete.FixedDim.itemsize;
-}
-
-static inline char *
-xnd_fixed_apply_index(const xnd_t *x)
-{
-    assert(x->type->tag == FixedDim);
-    return x->ptr + x->index * x->type->Concrete.FixedDim.itemsize;
-}
-
-static inline xnd_t
-xnd_var_dim_next(const xnd_t *x, const int64_t start, const int64_t step,
-                 const int64_t i)
-{
-    const ndt_t *t = x->type;
-    const ndt_t *u = t->VarDim.type;
-    xnd_t next;
-
-    next.bitmap = x->bitmap;
-    next.index = start + i * step;
-    next.type = u;
-    next.ptr = u->ndim==0 ? x->ptr + next.index * next.type->datasize : x->ptr;
-
-    return next;
-}
-
-static inline xnd_t
-xnd_tuple_next(const xnd_t *x, const int64_t i, ndt_context_t *ctx)
-{
-    const ndt_t *t = x->type;
-    xnd_t next;
-
-    next.bitmap = xnd_bitmap_next(x, i, ctx);
-    if (ndt_err_occurred(ctx)) {
-        return xnd_error;
-    }
-
-    next.index = 0;
-    next.type = t->Tuple.types[i];
-    next.ptr = x->ptr + t->Concrete.Tuple.offset[i];
-
-    return next;
-}
-
-static inline xnd_t
-xnd_record_next(const xnd_t *x, const int64_t i, ndt_context_t *ctx)
-{
-    const ndt_t *t = x->type;
-    xnd_t next;
-
-    next.bitmap = xnd_bitmap_next(x, i, ctx);
-    if (ndt_err_occurred(ctx)) {
-        return xnd_error;
-    }
-
-    next.index = 0;
-    next.type = t->Record.types[i];
-    next.ptr = x->ptr + t->Concrete.Record.offset[i];
-
-    return next;
-}
-
-static inline xnd_t
-xnd_ref_next(const xnd_t *x, ndt_context_t *ctx)
-{
-    const ndt_t *t = x->type;
-    xnd_t next;
-
-    next.bitmap = xnd_bitmap_next(x, 0, ctx);
-    if (ndt_err_occurred(ctx)) {
-        return xnd_error;
-    }
-
-    next.index = 0;
-    next.type = t->Ref.type;
-    next.ptr = XND_POINTER_DATA(x->ptr);
-
-    return next;
-}
-
-static inline xnd_t
-xnd_constr_next(const xnd_t *x, ndt_context_t *ctx)
-{
-    const ndt_t *t = x->type;
-    xnd_t next;
-
-    next.bitmap = xnd_bitmap_next(x, 0, ctx);
-    if (ndt_err_occurred(ctx)) {
-        return xnd_error;
-    }
-
-    next.index = 0;
-    next.type = t->Constr.type;
-    next.ptr = x->ptr;
-
-    return next;
-}
-
-static inline xnd_t
-xnd_nominal_next(const xnd_t *x, ndt_context_t *ctx)
-{
-    const ndt_t *t = x->type;
-    xnd_t next;
-
-    next.bitmap = xnd_bitmap_next(x, 0, ctx);
-    if (ndt_err_occurred(ctx)) {
-        return xnd_error;
-    }
-
-    next.index = 0;
-    next.type = t->Nominal.type;
-    next.ptr = x->ptr;
-
-    return next;
-}
-
-#if NDT_SYS_BIG_ENDIAN == 1
-  #define XND_REV_COND NDT_LITTLE_ENDIAN
-#else
-  #define XND_REV_COND NDT_BIG_ENDIAN
-#endif
-
-static inline void
-memcpy_rev(char *dest, const char *src, size_t size)
-{
-    size_t i;
-
-    for (i = 0; i < size; i++) {
-        dest[i] = src[size-1-i];
-    }
-}
-
-static inline void
-bcopy_swap(char *dest, const char *src, size_t size, uint32_t flags)
-{
-    if (flags & XND_REV_COND) {
-        memcpy_rev(dest, src, size);
-    }
-    else {
-        memcpy(dest, src, size);
-    }
-}
-
-static inline int
-le(uint32_t flags)
-{
-#if NDT_SYS_BIG_ENDIAN == 1
-    return flags & NDT_LITTLE_ENDIAN;
-#else
-    return !(flags & NDT_BIG_ENDIAN);
-#endif
-}
-
-
-#define PACK_SINGLE(ptr, src, type, flags) \
-    do {                                                      \
-        type _x;                                              \
-        _x = (type)src;                                       \
-        bcopy_swap(ptr, (const char *)&_x, sizeof _x, flags); \
-    } while (0)
-
-#define UNPACK_SINGLE(dest, ptr, type, flags) \
-    do {                                                \
-        type _x;                                        \
-        bcopy_swap((char *)&_x, ptr, sizeof _x, flags); \
-        dest = _x;                                      \
-    } while (0)
-
-
-#endif /* XND_H */