xnd 0.2.0dev3

data/ext/ruby_xnd/xnd/libxnd/contrib.h

@@ -0,0 +1,313 @@
+#ifndef CONTRIB_H
+#define CONTRIB_H
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <math.h>
+
+
+/* PSF copyright: Written by Jim Hugunin and Chris Chase. */
+static inline int64_t
+xnd_slice_adjust_indices(int64_t length,
+                         int64_t *start, int64_t *stop, int64_t step)
+{
+    /* this is harder to get right than you might think */
+
+    assert(step != 0);
+    assert(step >= -INT64_MAX);
+
+    if (*start < 0) {
+        *start += length;
+        if (*start < 0) {
+            *start = (step < 0) ? -1 : 0;
+        }
+    }
+    else if (*start >= length) {
+        *start = (step < 0) ? length - 1 : length;
+    }
+
+    if (*stop < 0) {
+        *stop += length;
+        if (*stop < 0) {
+            *stop = (step < 0) ? -1 : 0;
+        }
+    }
+    else if (*stop >= length) {
+        *stop = (step < 0) ? length - 1 : length;
+    }
+
+    if (step < 0) {
+        if (*stop < *start) {
+            return (*start - *stop - 1) / (-step) + 1;
+        }
+    }
+    else {
+        if (*start < *stop) {
+            return (*stop - *start - 1) / step + 1;
+        }
+    }
+
+    return 0;
+}
+
+/* PSF copyright: Original by Eli Stevens and Mark Dickinson. */
+static inline int
+xnd_float_pack2(double x, unsigned char *p, int le, ndt_context_t *ctx)
+{
+    unsigned char sign;
+    int e;
+    double f;
+    unsigned short bits;
+    int incr = 1;
+
+    if (x == 0.0) {
+        sign = (copysign(1.0, x) == -1.0);
+        e = 0;
+        bits = 0;
+    }
+    else if (isinf(x)) {
+        sign = (x < 0.0);
+        e = 0x1f;
+        bits = 0;
+    }
+    else if (isnan(x)) {
+        /* There are 2046 distinct half-precision NaNs (1022 signaling and
+           1024 quiet), but there are only two quiet NaNs that don't arise by
+           quieting a signaling NaN; we get those by setting the topmost bit
+           of the fraction field and clearing all other fraction bits. We
+           choose the one with the appropriate sign. */
+        sign = (copysign(1.0, x) == -1.0);
+        e = 0x1f;
+        bits = 512;
+    }
+    else {
+        sign = (x < 0.0);
+        if (sign) {
+            x = -x;
+        }
+
+        f = frexp(x, &e);
+        if (f < 0.5 || f >= 1.0) {
+            ndt_err_format(ctx, NDT_RuntimeError,
+                           "frexp() result out of range");
+            return -1;
+        }
+
+        /* Normalize f to be in the range [1.0, 2.0) */
+        f *= 2.0;
+        e--;
+
+        if (e >= 16) {
+            goto overflow;
+        }
+        else if (e < -25) {
+            /* |x| < 2**-25. Underflow to zero. */
+            f = 0.0;
+            e = 0;
+        }
+        else if (e < -14) {
+            /* |x| < 2**-14. Gradual underflow */
+            f = ldexp(f, 14 + e);
+            e = 0;
+        }
+        else /* if (!(e == 0 && f == 0.0)) */ {
+            e += 15;
+            f -= 1.0; /* Get rid of leading 1 */
+        }
+
+        f *= 1024.0; /* 2**10 */
+        /* Round to even */
+        bits = (unsigned short)f; /* Note the truncation */
+        assert(bits < 1024);
+        assert(e < 31);
+        if ((f - bits > 0.5) || ((f - bits == 0.5) && (bits % 2 == 1))) {
+            ++bits;
+            if (bits == 1024) {
+                /* The carry propagated out of a string of 10 1 bits. */
+                bits = 0;
+                ++e;
+                if (e == 31)
+                    goto overflow;
+            }
+        }
+    }
+
+    bits |= (e << 10) | (sign << 15);
+
+    /* Write out result. */
+    if (le) {
+        p += 1;
+        incr = -1;
+    }
+
+    /* First byte */
+    *p = (unsigned char)((bits >> 8) & 0xFF);
+    p += incr;
+
+    /* Second byte */
+    *p = (unsigned char)(bits & 0xFF);
+
+    return 0;
+
+overflow:
+    ndt_err_format(ctx, NDT_ValueError,
+        "float too large to pack with float16 type");
+    return -1;
+}
+
+/* PSF copyright: Original by Tim Peters. */
+static inline int
+xnd_float_pack4(double x, unsigned char *p, int le, ndt_context_t *ctx)
+{
+    float y = (float)x;
+    int i, incr = 1;
+
+    if (isinf(y) && !isinf(x)) {
+        goto overflow;
+    }
+
+    unsigned char s[sizeof(float)];
+    memcpy(s, &y, sizeof(float));
+
+    if ((xnd_float_is_little_endian() && !le) ||
+        (xnd_float_is_big_endian() && le)) {
+        p += 3;
+        incr = -1;
+    }
+
+    for (i = 0; i < 4; i++) {
+        *p = s[i];
+        p += incr;
+    }
+
+    return 0;
+
+overflow:
+    ndt_err_format(ctx, NDT_ValueError,
+        "float too large to pack with float32 type");
+    return -1;
+}
+
+/* PSF copyright: Original by Tim Peters. */
+static inline void
+xnd_float_pack8(double x, unsigned char *p, int le)
+{
+    const unsigned char *s = (unsigned char*)&x;
+    int i, incr = 1;
+
+    if ((xnd_double_is_little_endian() && !le) ||
+        (xnd_double_is_big_endian() && le)) {
+        p += 7;
+        incr = -1;
+    }
+
+    for (i = 0; i < 8; i++) {
+        *p = *s++;
+        p += incr;
+    }
+}
+
+/* PSF copyright: Original by Eli Stevens and Mark Dickinson. */
+static inline double
+xnd_float_unpack2(const unsigned char *p, int le)
+{
+    unsigned char sign;
+    int e;
+    unsigned int f;
+    double x;
+    int incr = 1;
+
+    if (le) {
+        p += 1;
+        incr = -1;
+    }
+
+    /* First byte */
+    sign = (*p >> 7) & 1;
+    e = (*p & 0x7C) >> 2;
+    f = (*p & 0x03) << 8;
+    p += incr;
+
+    /* Second byte */
+    f |= *p;
+
+    if (e == 0x1f) {
+        if (f == 0) {
+            /* Infinity */
+            return sign ? -INFINITY : INFINITY;
+        }
+        else {
+            /* NaN */
+            return sign ? -NAN : NAN;
+        }
+    }
+
+    x = (double)f / 1024.0;
+
+    if (e == 0) {
+        e = -14;
+    }
+    else {
+        x += 1.0;
+        e -= 15;
+    }
+    x = ldexp(x, e);
+
+    if (sign)
+        x = -x;
+
+    return x;
+}
+
+/* PSF copyright: Original by Tim Peters. */
+static inline double
+xnd_float_unpack4(const unsigned char *p, int le)
+{
+    float x;
+
+    if ((xnd_float_is_little_endian() && !le) ||
+        (xnd_float_is_big_endian() && le)) {
+        char buf[4];
+        char *d = &buf[3];
+        int i;
+
+        for (i = 0; i < 4; i++) {
+            *d-- = *p++;
+        }
+        memcpy(&x, buf, 4);
+    }
+    else {
+        memcpy(&x, p, 4);
+    }
+
+    return x;
+}
+
+/* PSF copyright: Original by Tim Peters. */
+static inline double
+xnd_float_unpack8(const unsigned char *p, int le)
+{
+    double x;
+
+    if ((xnd_double_is_little_endian() && !le) ||
+        (xnd_double_is_big_endian() && le)) {
+        char buf[8];
+        char *d = &buf[7];
+        int i;
+
+        for (i = 0; i < 8; i++) {
+            *d-- = *p++;
+        }
+        memcpy(&x, buf, 8);
+    }
+    else {
+        memcpy(&x, p, 8);
+    }
+
+    return x;
+}
+
+
+#endif /* CONTRIB_H */

data/ext/ruby_xnd/xnd/libxnd/copy.c

@@ -0,0 +1,944 @@
+/*
+ * 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.
+ */
+
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <string.h>
+#include <assert.h>
+#include "ndtypes.h"
+#include "xnd.h"
+#include "contrib.h"
+
+
+/*****************************************************************************/
+/*                           Copying with exact casts                        */
+/*****************************************************************************/
+
+static int
+type_error(ndt_context_t *ctx)
+{
+    ndt_err_format(ctx, NDT_TypeError,
+        "incompatible types of source and destination in copy function");
+    return -1;
+}
+
+static int
+value_error(ndt_context_t *ctx)
+{
+    ndt_err_format(ctx, NDT_ValueError,
+        "incompatible value for destination type in copy function");
+    return -1;
+}
+
+/* Skip all ref chains. */
+static int
+copy_ref(xnd_t *y, const xnd_t *x, const uint32_t flags, ndt_context_t *ctx)
+{
+    const ndt_t *t = x->type;
+    const ndt_t *u = y->type;
+    xnd_t xnext, ynext;
+
+    while (t->tag == Ref) {
+        xnext = xnd_ref_next(x, ctx);
+        if (xnext.ptr == NULL) {
+            return -1;
+        }
+        x = &xnext;
+        t = x->type;
+    }
+
+    while (u->tag == Ref) {
+        ynext = xnd_ref_next(y, ctx);
+        if (ynext.ptr == NULL) {
+            return -1;
+        }
+        y = &ynext;
+        u = y->type;
+    }
+
+    return xnd_copy(y, x, flags, ctx);
+}
+
+static int
+copy_int64(xnd_t * const x, const int64_t i64, ndt_context_t *ctx)
+{
+    const ndt_t * const t = x->type;
+
+    switch (t->tag) {
+    case Int8: {
+        if (i64 < INT8_MIN || i64 > INT8_MAX) {
+            return value_error(ctx);
+        }
+        int8_t i8 = (int8_t)i64;
+        PACK_SINGLE(x->ptr, i8, int8_t, t->flags);
+        return 0;
+    }
+
+    case Int16: {
+        if (i64 < INT16_MIN || i64 > INT16_MAX) {
+            return value_error(ctx);
+        }
+        int16_t i16 = (int16_t)i64;
+        PACK_SINGLE(x->ptr, i16, int16_t, t->flags);
+        return 0;
+    }
+
+    case Int32: {
+        if (i64 < INT32_MIN || i64 > INT32_MAX) {
+            return value_error(ctx);
+        }
+        int32_t i32 = (int32_t)i64;
+        PACK_SINGLE(x->ptr, i32, int32_t, t->flags);
+        return 0;
+    }
+
+    case Int64: {
+        PACK_SINGLE(x->ptr, i64, int64_t, t->flags);
+        return 0;
+    }
+
+    case Uint8: {
+        if (i64 < 0 || i64 > UINT8_MAX) {
+            return value_error(ctx);
+        }
+        uint8_t u8 = (uint8_t)i64;
+        PACK_SINGLE(x->ptr, u8, uint8_t, t->flags);
+        return 0;
+    }
+
+    case Uint16: {
+        if (i64 < 0 || i64 > UINT16_MAX) {
+            return value_error(ctx);
+        }
+        uint16_t u16 = (uint16_t)i64;;
+        PACK_SINGLE(x->ptr, u16, uint16_t, t->flags);
+        return 0;
+    }
+
+    case Uint32: {
+        if (i64 < 0 || i64 > UINT32_MAX) {
+            return value_error(ctx);
+        }
+        uint32_t u32 = (uint32_t)i64;
+        PACK_SINGLE(x->ptr, u32, uint32_t, t->flags);
+        return 0;
+    }
+
+    case Uint64: {
+        if (i64 < 0) {
+            return value_error(ctx);
+        }
+        uint64_t u64 = (uint64_t)i64;
+        PACK_SINGLE(x->ptr, u64, uint64_t, t->flags);
+        return 0;
+    }
+
+    case Float16: {
+        if (i64 < -4503599627370496LL || i64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+        double real = (double)i64;
+        return xnd_float_pack2(real, (unsigned char *)x->ptr, le(t->flags), ctx);
+    }
+
+    case Float32: {
+        if (i64 < -4503599627370496LL || i64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+        double real = (double)i64;
+        return xnd_float_pack4(real, (unsigned char *)x->ptr, le(t->flags), ctx);
+    }
+
+    case Float64: {
+        if (i64 < -4503599627370496LL || i64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+        double real = (double)i64;
+        xnd_float_pack8(real, (unsigned char *)x->ptr, le(t->flags));
+        return 0;
+    }
+
+    case Complex32: {
+        if (i64 < -4503599627370496LL || i64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+
+        double real = (double)i64;
+        double imag = 0.0;
+
+        if (xnd_float_pack2(real, (unsigned char *)x->ptr, le(t->flags), ctx) < 0) {
+            return -1;
+        }
+
+        return xnd_float_pack2(imag, (unsigned char *)(x->ptr+2), le(t->flags), ctx);
+    }
+
+    case Complex64: {
+        if (i64 < -4503599627370496LL || i64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+
+        double real = (double)i64;
+        double imag = 0.0;
+
+        if (xnd_float_pack4(real, (unsigned char *)x->ptr, le(t->flags), ctx) < 0) {
+            return -1;
+        }
+
+        return xnd_float_pack4(imag, (unsigned char *)(x->ptr+4), le(t->flags), ctx);
+    }
+
+    case Complex128: {
+        if (i64 < -4503599627370496LL || i64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+
+        double real = (double)i64;
+        double imag = 0.0;
+
+        xnd_float_pack8(real, (unsigned char *)x->ptr, le(t->flags));
+        xnd_float_pack8(imag, (unsigned char *)(x->ptr+8), le(t->flags));
+
+        return 0;
+    }
+
+    default:
+        return type_error(ctx);
+    }
+}
+
+static int
+copy_uint64(xnd_t * const x, const uint64_t u64, ndt_context_t *ctx)
+{
+    const ndt_t * const t = x->type;
+
+    switch (t->tag) {
+    case Int8: {
+        if (u64 > INT8_MAX) {
+            return value_error(ctx);
+        }
+        int8_t i8 = (int8_t)u64;
+        PACK_SINGLE(x->ptr, i8, int8_t, t->flags);
+        return 0;
+    }
+
+    case Int16: {
+        if (u64 > INT16_MAX) {
+            return value_error(ctx);
+        }
+        int16_t i16 = (int16_t)u64;
+        PACK_SINGLE(x->ptr, i16, int16_t, t->flags);
+        return 0;
+    }
+
+    case Int32: {
+        if (u64 > INT32_MAX) {
+            return value_error(ctx);
+        }
+        int32_t i32 = (int32_t)u64;
+        PACK_SINGLE(x->ptr, i32, int32_t, t->flags);
+        return 0;
+    }
+
+    case Int64: {
+        if (u64 > INT64_MAX) {
+            return value_error(ctx);
+        }
+        int64_t i64 = (int64_t)u64;
+        PACK_SINGLE(x->ptr, i64, int64_t, t->flags);
+        return 0;
+    }
+
+    case Uint8: {
+        if (u64 > UINT8_MAX) {
+            return value_error(ctx);
+        }
+        uint8_t u8 = (uint8_t)u64;
+        PACK_SINGLE(x->ptr, u8, uint8_t, t->flags);
+        return 0;
+    }
+
+    case Uint16: {
+        if (u64 > UINT16_MAX) {
+            return value_error(ctx);
+        }
+        uint16_t u16 = (uint16_t)u64;
+        PACK_SINGLE(x->ptr, u16, uint16_t, t->flags);
+        return 0;
+    }
+
+    case Uint32: {
+        if (u64 > UINT32_MAX) {
+            return value_error(ctx);
+        }
+        uint32_t u32 = (uint32_t)u64;
+        PACK_SINGLE(x->ptr, u32, uint32_t, t->flags);
+        return 0;
+    }
+
+    case Uint64: {
+        PACK_SINGLE(x->ptr, u64, uint64_t, t->flags);
+        return 0;
+    }
+
+    case Float16: {
+        if (u64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+        double real = (double)u64;
+        return xnd_float_pack2(real, (unsigned char *)x->ptr, le(t->flags), ctx);
+    }
+
+    case Float32: {
+        if (u64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+        double real = (double)u64;
+        return xnd_float_pack4(real, (unsigned char *)x->ptr, le(t->flags), ctx);
+    }
+
+    case Float64: {
+        if (u64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+        double real = (double)u64;
+        xnd_float_pack8(real, (unsigned char *)x->ptr, le(t->flags));
+        return 0;
+    }
+
+    case Complex32: {
+        if (u64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+
+        double real = (double)u64;
+        double imag = 0.0;
+
+        if (xnd_float_pack2(real, (unsigned char *)x->ptr, le(t->flags), ctx) < 0) {
+            return -1;
+        }
+
+        return xnd_float_pack2(imag, (unsigned char *)x->ptr+2, le(t->flags), ctx);
+    }
+
+    case Complex64: {
+        if (u64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+
+        double real = (double)u64;
+        double imag = 0.0;
+
+        if (xnd_float_pack4(real, (unsigned char *)x->ptr, le(t->flags), ctx) < 0) {
+            return -1;
+        }
+
+        return xnd_float_pack4(imag, (unsigned char *)(x->ptr+4), le(t->flags), ctx);
+    }
+
+    case Complex128: {
+        if (u64 > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+
+        double real = (double)u64;
+        double imag = 0.0;
+
+        xnd_float_pack8(real, (unsigned char *)x->ptr, le(t->flags));
+        xnd_float_pack8(imag, (unsigned char *)(x->ptr+8), le(t->flags));
+        return 0;
+    }
+
+    default:
+        return type_error(ctx);
+    }
+}
+
+static inline bool
+isint(double real)
+{
+    double intpart;
+    double fracpart;
+
+    fracpart = modf(real, &intpart);
+    if (fracpart == 0.0) {
+        return (!isinf(intpart) && !isnan(intpart));
+    }
+
+    return false;
+}
+
+static int
+copy_float64(xnd_t * const x, const double real, ndt_context_t *ctx)
+{
+    const ndt_t * const t = x->type;
+
+    switch (t->tag) {
+    case Int8: {
+        if (!isint(real) || real < INT8_MIN || real > INT8_MAX) {
+            return value_error(ctx);
+        }
+        int8_t i8 = (int8_t)real;
+        PACK_SINGLE(x->ptr, i8, int8_t, t->flags);
+        return 0;
+    }
+
+    case Int16: {
+        if (!isint(real) || real < INT16_MIN || real > INT16_MAX) {
+            return value_error(ctx);
+        }
+        int16_t i16 = (int16_t)real;
+        PACK_SINGLE(x->ptr, i16, int16_t, t->flags);
+        return 0;
+    }
+
+    case Int32: {
+        if (!isint(real) || real < INT32_MIN || real > INT32_MAX) {
+            return value_error(ctx);
+        }
+        int32_t i32 = (int32_t)real;
+        PACK_SINGLE(x->ptr, i32, int32_t, t->flags);
+        return 0;
+    }
+
+    case Int64: {
+        if (!isint(real) || real < -4503599627370496LL || real > 4503599627370496LL) {
+            return value_error(ctx);
+        }
+        int64_t i64 = (int64_t)real;
+        PACK_SINGLE(x->ptr, i64, int64_t, t->flags);
+        return 0;
+    }
+
+    case Uint8: {
+        if (!isint(real) || real < 0 || real > UINT8_MAX) {
+            return value_error(ctx);
+        }
+        uint8_t u8 = (uint8_t)real;
+        PACK_SINGLE(x->ptr, u8, uint8_t, t->flags);
+        return 0;
+    }
+
+    case Uint16: {
+        if (!isint(real) || real < 0 || real > UINT16_MAX) {
+            return value_error(ctx);
+        }
+        uint16_t u16 = (uint16_t)real;
+        PACK_SINGLE(x->ptr, u16, uint16_t, t->flags);
+        return 0;
+    }
+
+    case Uint32: {
+        if (!isint(real) || real < 0 || real > UINT32_MAX) {
+            return value_error(ctx);
+        }
+        uint32_t u32 = (uint32_t)real;
+        PACK_SINGLE(x->ptr, u32, uint32_t, t->flags);
+        return 0;
+    }
+
+    case Uint64: {
+        if (!isint(real) || real < 0 || real > 4503599627370496ULL) {
+            return value_error(ctx);
+        }
+        uint64_t u64 = (uint64_t)real;
+        PACK_SINGLE(x->ptr, u64, uint64_t, t->flags);
+    }
+
+    case Float16: {
+        return xnd_float_pack2(real, (unsigned char *)x->ptr, le(t->flags), ctx);
+    }
+
+    case Float32: {
+        return xnd_float_pack4(real, (unsigned char *)x->ptr, le(t->flags), ctx);
+    }
+
+    case Float64: {
+        xnd_float_pack8(real, (unsigned char *)x->ptr, le(t->flags));
+        return 0;
+    }
+
+    case Complex32: {
+        double imag = 0.0;
+
+        if (xnd_float_pack2(real, (unsigned char *)x->ptr, le(t->flags), ctx) < 0) {
+            return -1;
+        }
+
+        return xnd_float_pack2(imag, (unsigned char *)(x->ptr+2), le(t->flags), ctx);
+    }
+
+    case Complex64: {
+        double imag = 0.0;
+
+        if (xnd_float_pack4(real, (unsigned char *)x->ptr, le(t->flags), ctx) < 0) {
+            return -1;
+        }
+
+        return xnd_float_pack4(imag, (unsigned char *)(x->ptr+4), le(t->flags), ctx);
+    }
+
+    case Complex128: {
+        double imag = 0.0;
+
+        xnd_float_pack8(real, (unsigned char *)x->ptr, le(t->flags));
+        xnd_float_pack8(imag, (unsigned char *)(x->ptr+8), le(t->flags));
+
+        return 0;
+    }
+
+    default:
+        return type_error(ctx);
+    }
+}
+
+static int
+copy_complex128(xnd_t * const x, const double real, const double imag,
+                ndt_context_t *ctx)
+{
+    const ndt_t * const t = x->type;
+
+    switch (t->tag) {
+    case Int8: case Int16: case Int32: case Int64:
+    case Uint8: case Uint16: case Uint32: case Uint64:
+    case Float16: case Float32: case Float64: {
+       if (imag == 0.0) {
+           return copy_float64(x, real, ctx);
+       }
+
+       return type_error(ctx);
+    }
+
+    case Complex32: {
+        if (xnd_float_pack2(real, (unsigned char *)x->ptr, le(t->flags), ctx) < 0) {
+            return -1;
+        }
+        return xnd_float_pack2(imag, (unsigned char *)(x->ptr+2), le(t->flags), ctx);
+    }
+
+    case Complex64: {
+        if (xnd_float_pack4(real, (unsigned char *)x->ptr, le(t->flags), ctx) < 0) {
+            return -1;
+        }
+        return xnd_float_pack4(imag, (unsigned char *)(x->ptr+4), le(t->flags), ctx);
+    }
+
+    case Complex128: {
+        xnd_float_pack8(real, (unsigned char *)x->ptr, le(t->flags));
+        xnd_float_pack8(imag, (unsigned char *)(x->ptr+8), le(t->flags));
+        return 0;
+    }
+
+    default:
+       return type_error(ctx);
+    }
+}
+
+int
+xnd_copy(xnd_t *y, const xnd_t *x, uint32_t flags, ndt_context_t *ctx)
+{
+    const ndt_t * const t = x->type;
+    const ndt_t * const u = y->type;
+    int n;
+
+    if (xnd_is_na(x)) {
+        if (!ndt_is_optional(u)) {
+            ndt_err_format(ctx, NDT_TypeError,
+                "cannot copy NA to destination with non-optional type");
+            return -1;
+        }
+
+        xnd_set_na(y);
+        return 0;
+    }
+
+    if (t->tag == Ref || u->tag == Ref) {
+        return copy_ref(y, x, flags, ctx);
+    }
+
+    switch (t->tag) {
+    case FixedDim: {
+        int64_t i;
+
+        if (u->tag != FixedDim || u->FixedDim.shape != t->FixedDim.shape) {
+            return type_error(ctx);
+        }
+
+        for (i = 0; i < t->FixedDim.shape; i++) {
+            const xnd_t xnext = xnd_fixed_dim_next(x, i);
+            xnd_t ynext = xnd_fixed_dim_next(y, i);
+            n = xnd_copy(&ynext, &xnext, flags, ctx);
+            if (n < 0) return n;
+        }
+
+        return 0;
+    }
+
+    case VarDim: {
+        int64_t xstart, xstep, xshape;
+        int64_t ystart, ystep, yshape;
+        int64_t i;
+
+        if (u->tag != VarDim) {
+            return type_error(ctx);
+        }
+
+        xshape = ndt_var_indices(&xstart, &xstep, t, x->index, ctx);
+        if (xshape < 0) {
+            return -1;
+        }
+
+        yshape = ndt_var_indices(&ystart, &ystep, u, y->index, ctx);
+        if (yshape < 0) {
+            return -1;
+        }
+
+        if (yshape != xshape) {
+            return type_error(ctx);
+        }
+
+        for (i = 0; i < xshape; i++) {
+            const xnd_t xnext = xnd_var_dim_next(x, xstart, xstep, i);
+            xnd_t ynext = xnd_var_dim_next(y, ystart, ystep, i);
+            n = xnd_copy(&ynext, &xnext, flags, ctx);
+            if (n < 0) return n;
+        }
+
+        return 0;
+    }
+
+    case Tuple: {
+        if (u->tag != Tuple || u->Tuple.shape != t->Tuple.shape) {
+            return type_error(ctx);
+        }
+
+        for (int64_t i = 0; i < t->Tuple.shape; i++) {
+            const xnd_t xnext = xnd_tuple_next(x, i, ctx);
+            if (xnext.ptr == NULL) {
+                return -1;
+            }
+
+            xnd_t ynext = xnd_tuple_next(y, i, ctx);
+            if (ynext.ptr == NULL) {
+                return -1;
+            }
+
+            n = xnd_copy(&ynext, &xnext, flags, ctx);
+            if (n < 0) return n;
+        }
+
+        return 0;
+    }
+
+    case Record: {
+        if (u->tag != Record || u->Record.shape != t->Record.shape) {
+            return type_error(ctx);
+        }
+
+        for (int64_t i = 0; i < t->Record.shape; i++) {
+            if (strcmp(t->Record.names[i], u->Record.names[i]) != 0) {
+                return type_error(ctx);
+            }
+
+            const xnd_t xnext = xnd_record_next(x, i, ctx);
+            if (xnext.ptr == NULL) {
+                return -1;
+            }
+
+            xnd_t ynext = xnd_record_next(y, i, ctx);
+            if (ynext.ptr == NULL) {
+                return -1;
+            }
+
+            n = xnd_copy(&ynext, &xnext, flags, ctx);
+            if (n < 0) return n;
+        }
+
+        return 0;
+    }
+
+    case Constr: {
+        if (u->tag != Constr || strcmp(u->Constr.name, t->Constr.name) != 0) {
+            return type_error(ctx);
+        }
+
+        const xnd_t xnext = xnd_constr_next(x, ctx);
+        if (xnext.ptr == NULL) {
+            return -1;
+        }
+
+        xnd_t ynext = xnd_constr_next(y, ctx);
+        if (ynext.ptr == NULL) {
+            return -1;
+        }
+
+        return xnd_copy(&ynext, &xnext, flags, ctx);
+    }
+
+    case Nominal: {
+        if (u->tag != Nominal) {
+            return type_error(ctx);
+        }
+
+        if (strcmp(t->Nominal.name, u->Nominal.name) != 0) {
+            return type_error(ctx);
+        }
+
+        const xnd_t xnext = xnd_nominal_next(x, ctx);
+        if (xnext.ptr == NULL) {
+            return -1;
+        }
+
+        xnd_t ynext = xnd_nominal_next(y, ctx);
+        if (ynext.ptr == NULL) {
+            return -1;
+        }
+
+        return xnd_copy(&ynext, &xnext, flags, ctx);
+    }
+
+    case Categorical: {
+        int64_t i64;
+
+        if (!ndt_equal(t, u)) {
+            return type_error(ctx);
+        }
+
+        UNPACK_SINGLE(i64, x->ptr, int64_t, t->flags);
+        PACK_SINGLE(y->ptr, i64, int64_t, u->flags);
+        return 0;
+    }
+
+    case Char: {
+        ndt_err_format(ctx, NDT_NotImplementedError, "char not implemented");
+        return -1;
+    }
+
+    case Bool: {
+        bool b;
+
+        if (u->tag != Bool) {
+            return type_error(ctx);
+        }
+
+        UNPACK_SINGLE(b, x->ptr, bool, u->flags);
+        PACK_SINGLE(y->ptr, b, bool, t->flags);
+        return 0;
+    }
+
+    case Int8: {
+        int8_t i8;
+        UNPACK_SINGLE(i8, x->ptr, int8_t, t->flags);
+        return copy_int64(y, i8, ctx);
+    }
+
+    case Int16: {
+        int16_t i16;
+        UNPACK_SINGLE(i16, x->ptr, int16_t, t->flags);
+        return copy_int64(y, i16, ctx);
+    }
+
+    case Int32: {
+        int32_t i32;
+        UNPACK_SINGLE(i32, x->ptr, int32_t, t->flags);
+        return copy_int64(y, i32, ctx);
+    }
+
+    case Int64: {
+        int64_t i64;
+        UNPACK_SINGLE(i64, x->ptr, int64_t, t->flags);
+        return copy_int64(y, i64, ctx);
+    }
+
+    case Uint8: {
+        uint8_t u8;
+        UNPACK_SINGLE(u8, x->ptr, uint8_t, t->flags);
+        return copy_uint64(y, u8, ctx);
+    }
+
+    case Uint16: {
+        uint16_t u16;
+        UNPACK_SINGLE(u16, x->ptr, uint16_t, t->flags);
+        return copy_uint64(y, u16, ctx);
+    }
+
+    case Uint32: {
+        uint32_t u32;
+        UNPACK_SINGLE(u32, x->ptr, uint32_t, t->flags);
+        return copy_uint64(y, u32, ctx);
+    }
+
+    case Uint64: {
+        uint64_t u64;
+        UNPACK_SINGLE(u64, x->ptr, uint64_t, t->flags);
+        return copy_uint64(y, u64, ctx);
+    }
+
+    case Float16: {
+        double real = xnd_float_unpack2((unsigned char *)x->ptr, le(t->flags));
+        return copy_float64(y, real, ctx);
+    }
+
+    case Float32: {
+        double real = xnd_float_unpack4((unsigned char *)x->ptr, le(t->flags));
+        return copy_float64(y, real, ctx);
+    }
+
+    case Float64: {
+        double real = xnd_float_unpack8((unsigned char *)x->ptr, le(t->flags));
+        return copy_float64(y, real, ctx);
+    }
+
+    case Complex32: {
+        double real, imag;
+
+        real = xnd_float_unpack2((unsigned char *)x->ptr, le(t->flags));
+        imag = xnd_float_unpack2((unsigned char *)(x->ptr+2), le(t->flags));
+
+        return copy_complex128(y, real, imag, ctx);
+    }
+
+    case Complex64: {
+        double real, imag;
+
+        real = xnd_float_unpack4((unsigned char *)x->ptr, le(t->flags));
+        imag = xnd_float_unpack4((unsigned char *)(x->ptr+4), le(t->flags));
+
+        return copy_complex128(y, real, imag, ctx);
+    }
+
+    case Complex128: {
+        double real, imag;
+
+        real = xnd_float_unpack8((unsigned char *)x->ptr, le(t->flags));
+        imag = xnd_float_unpack8((unsigned char *)(x->ptr+8), le(t->flags));
+
+        return copy_complex128(y, real, imag, ctx);
+    }
+
+    case FixedString: {
+        if (u->tag != FixedString ||
+            u->FixedString.size != t->FixedString.size ||
+            u->FixedString.encoding != t->FixedString.encoding ||
+            u->datasize != t->datasize) {
+            return type_error(ctx);
+        }
+        memcpy(y->ptr, x->ptr, (size_t)t->datasize);
+        return 0;
+    }
+
+    case FixedBytes: {
+        if (u->tag != FixedBytes ||
+            u->FixedBytes.size != t->FixedBytes.size ||
+            u->datasize != t->datasize) {
+            return type_error(ctx);
+        }
+        memcpy(y->ptr, x->ptr, (size_t)t->datasize);
+        return 0;
+    }
+
+    case String: {
+        char *s;
+
+        if (u->tag != String) {
+            return type_error(ctx);
+        }
+
+        s = ndt_strdup(XND_POINTER_DATA(x->ptr), ctx);
+        if (s == NULL) {
+            return -1;
+        }
+
+        if (XND_POINTER_DATA(y->ptr) != NULL) {
+            if (!(flags & XND_OWN_EMBEDDED)) {
+                ndt_err_format(ctx, NDT_RuntimeError,
+                    "cannot free string pointer, xnd does not own it");
+                ndt_free(s);
+                return -1;
+            }
+            ndt_free(XND_POINTER_DATA(y->ptr));
+        }
+
+        XND_POINTER_DATA(y->ptr) = s;
+        return 0;
+    }
+
+    case Bytes: {
+        unsigned char *s;
+        int64_t size;
+
+        if (u->tag != Bytes) {
+            return type_error(ctx);
+        }
+
+        size = XND_BYTES_SIZE(x->ptr);
+
+        s = ndt_aligned_calloc(u->Bytes.target_align, size);
+        if (s == NULL) {
+            (void)ndt_memory_error(ctx);
+            return -1;
+        }
+        memcpy(s, XND_BYTES_DATA(x->ptr), (size_t)size);
+
+        if (XND_BYTES_DATA(y->ptr) != NULL) {
+            if (!(flags & XND_OWN_EMBEDDED)) {
+                ndt_err_format(ctx, NDT_RuntimeError,
+                    "cannot free string pointer, xnd does not own it");
+                ndt_aligned_free(s);
+                return -1;
+            }
+            ndt_aligned_free(XND_BYTES_DATA(y->ptr));
+        }
+
+        XND_BYTES_SIZE(y->ptr) = size;
+        XND_BYTES_DATA(y->ptr) = s;
+        return 0;
+    }
+
+    /* NOT REACHED: intercepted by equal_ref(). */
+    case Ref:
+
+    /* NOT REACHED: xnd types must be concrete. */
+    case Module: case Function:
+    case AnyKind: case SymbolicDim: case EllipsisDim: case Typevar:
+    case ScalarKind: case SignedKind: case UnsignedKind: case FloatKind:
+    case ComplexKind: case FixedStringKind: case FixedBytesKind:
+        ndt_err_format(ctx, NDT_RuntimeError, "unexpected abstract type");
+        return -1;
+    }
+
+    /* NOT REACHED: tags should be exhaustive */
+    ndt_err_format(ctx, NDT_RuntimeError, "invalid type tag");
+    return -1;
+}