ndtypes 0.2.0dev5 → 0.2.0dev6

data/ext/ruby_ndtypes/ndtypes/libndtypes/seq.c

@@ -178,22 +178,23 @@ ndt_type_seq_t *
 ndt_type_seq_new(ndt_t *elt, ndt_context_t *ctx)
 {
     ndt_type_seq_t *seq;
-    ndt_t **ptr;
+    const ndt_t **ptr;
 
     seq = ndt_alloc_size(sizeof *seq);
     if (seq == NULL) {
-        ndt_del(elt);
+        ndt_decref(elt);
         return ndt_memory_error(ctx);
     }
 
     ptr = ndt_alloc_size(2 * (sizeof *ptr));
     if (ptr == NULL) {
         ndt_free(seq);
-        ndt_del(elt);
+        ndt_decref(elt);
         return ndt_memory_error(ctx);
     }
 
     ptr[0] = elt;
+
     seq->len = 1;
     seq->reserved = 2;
     seq->ptr = ptr;
@@ -213,9 +214,9 @@ ndt_type_seq_del(ndt_type_seq_t *seq)
 static int
 ndt_type_seq_grow(ndt_type_seq_t *seq, ndt_context_t *ctx)
 {
-    ndt_t **ptr;
+    const ndt_t **ptr;
 
-    ptr = ndt_realloc(seq->ptr, seq->reserved, 2 * (sizeof *ptr));
+    ptr = ndt_realloc((void *)seq->ptr, seq->reserved, 2 * (sizeof *ptr));
     if (ptr == NULL) {
         ndt_err_format(ctx, NDT_MemoryError, "out of memory");
         return -1;
@@ -235,7 +236,6 @@ ndt_type_seq_append(ndt_type_seq_t *seq, ndt_t *elt, ndt_context_t *ctx)
     if (seq->len == seq->reserved) {
         if (ndt_type_seq_grow(seq, ctx) < 0) {
             ndt_type_seq_del(seq);
-            ndt_free(elt);
             return NULL;
         }
     }
@@ -249,7 +249,7 @@ ndt_type_seq_append(ndt_type_seq_t *seq, ndt_t *elt, ndt_context_t *ctx)
 ndt_type_seq_t *
 ndt_type_seq_finalize(ndt_type_seq_t *seq)
 {
-    ndt_t **ptr;
+    const ndt_t **ptr;
 
     if (seq == NULL) {
         return NULL;
@@ -257,7 +257,7 @@ ndt_type_seq_finalize(ndt_type_seq_t *seq)
 
     assert(seq->len <= seq->reserved);
 
-    ptr = ndt_realloc(seq->ptr, seq->len, sizeof *ptr);
+    ptr = ndt_realloc((void *)seq->ptr, seq->len, sizeof *ptr);
     if (ptr == NULL) {
         return seq; /* seq is still valid */
     }

data/ext/ruby_ndtypes/ndtypes/libndtypes/seq.h

@@ -168,7 +168,7 @@ typedef struct {
 typedef struct {
     int64_t len;
     int64_t reserved;
-    ndt_t **ptr;
+    const ndt_t **ptr;
 } ndt_type_seq_t;
 
 

data/ext/ruby_ndtypes/ndtypes/libndtypes/serialize/Makefile

@@ -0,0 +1,48 @@
+
+CC = gcc
+LD = gcc
+
+CONFIGURE_CFLAGS = -I.. -Wall -Wextra -std=c11 -pedantic -O2 -g
+NDT_CFLAGS = $(strip $(CONFIGURE_CFLAGS) $(CFLAGS))
+NDT_CFLAGS_SHARED = $(NDT_CFLAGS) -fPIC
+
+CONFIGURE_COV_CFLAGS = -I.. -Wall -Wextra -std=c11 -pedantic -O0 -g -fno-inline -fprofile-arcs -ftest-coverage
+ifeq ($(MAKECMDGOALS), coverage)
+  NDT_CFLAGS = $(strip $(CONFIGURE_COV_CFLAGS) $(CFLAGS))
+endif
+
+
+OBJS = serialize.o deserialize.o
+SHARED_OBJS = .objs/serialize.o .objs/deserialize.o
+
+
+default: $(OBJS) $(SHARED_OBJS)
+
+
+serialize.o:\
+Makefile serialize.c ../ndtypes.h
+	$(CC) $(NDT_CFLAGS) -c serialize.c
+
+.objs/serialize.o:\
+Makefile serialize.c ../ndtypes.h
+	$(CC) $(NDT_CFLAGS_SHARED) -c serialize.c -o .objs/serialize.o
+
+deserialize.o:\
+Makefile deserialize.c ../ndtypes.h
+	$(CC) $(NDT_CFLAGS) -c deserialize.c
+
+.objs/deserialize.o:\
+Makefile deserialize.c ../ndtypes.h
+	$(CC) $(NDT_CFLAGS_SHARED) -c deserialize.c -o .objs/deserialize.o
+
+
+FORCE:
+
+clean: FORCE
+	rm -f *.o *.so *.gch *.gcda *.gcno *.gcov *.dyn *.dpi *.lock
+	cd .objs && rm -f *.o *.so *.gch *.gcda *.gcno *.gcov *.dyn *.dpi *.lock
+
+distclean: clean
+	rm -f Makefile
+
+

data/ext/ruby_ndtypes/ndtypes/libndtypes/serialize/deserialize.c

@@ -40,8 +40,8 @@
 #include "overflow.h"
 
 
-static ndt_t *read_type(ndt_meta_t *m, const char * const ptr, int64_t offset,
-                        const int64_t len, ndt_context_t *ctx);
+static const ndt_t *read_type(const char * const ptr, int64_t offset,
+                              const int64_t len, ndt_context_t *ctx);
 
 
 
@@ -247,7 +247,7 @@ copy_common(ndt_t *t, const common_t *f)
 static ndt_t *
 new_copy_common(const common_t *f, ndt_context_t *ctx)
 {
-    ndt_t *t = ndt_new(f->tag, ctx);
+    ndt_t *t = ndt_new(f->tag, f->flags, ctx);
     if (t == NULL) {
         return NULL;
     }
@@ -350,12 +350,12 @@ read_common_fields(common_t *fields, const char * const ptr,
     return read_uint16(&fields->align, ptr, offset, len, ctx);
 }
 
-static ndt_t *
-read_module(ndt_meta_t *m, const common_t *fields, const char * const ptr,
-            int64_t offset, const int64_t len, ndt_context_t *ctx)
+static const ndt_t *
+read_module(const common_t *fields, const char * const ptr, int64_t offset,
+            const int64_t len, ndt_context_t *ctx)
 {
     char *name;
-    ndt_t *type;
+    const ndt_t *type;
     ndt_t *t;
 
     offset = read_string(&name, ptr, offset, len, ctx);
@@ -363,7 +363,7 @@ read_module(ndt_meta_t *m, const common_t *fields, const char * const ptr,
         return NULL;
     }
 
-    type = read_type(m, ptr, offset, len, ctx);
+    type = read_type(ptr, offset, len, ctx);
     if (type == NULL) {
         ndt_free(name);
         return NULL;
@@ -371,7 +371,7 @@ read_module(ndt_meta_t *m, const common_t *fields, const char * const ptr,
 
     t = new_copy_common(fields, ctx);
     if (t == NULL) {
-        ndt_del(type);
+        ndt_decref(type);
         ndt_free(name);
         return NULL;
     }
@@ -381,9 +381,9 @@ read_module(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     return t;
 }
 
-static ndt_t *
-read_function(ndt_meta_t *m, common_t *fields, const char * const ptr,
-              int64_t offset, const int64_t len, ndt_context_t *ctx)
+static const ndt_t *
+read_function(common_t *fields, const char * const ptr, int64_t offset,
+              const int64_t len, ndt_context_t *ctx)
 {
     int64_t metaoffset;
     int64_t nin;
@@ -412,9 +412,9 @@ read_function(ndt_meta_t *m, common_t *fields, const char * const ptr,
         metaoffset = next_metaoffset(&offset, ptr, metaoffset, len, ctx);
         if (metaoffset < 0) return NULL;
 
-        t->Function.types[i] = read_type(m, ptr, offset, len, ctx);
+        t->Function.types[i] = read_type(ptr, offset, len, ctx);
         if (t->Function.types[i] == NULL) {
-            ndt_del(t);
+            ndt_decref(t);
             return NULL;
         }
     }
@@ -425,15 +425,15 @@ read_function(ndt_meta_t *m, common_t *fields, const char * const ptr,
     return t;
 }
 
-static ndt_t *
-read_fixed_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
-               int64_t offset, const int64_t len, ndt_context_t *ctx)
+static const ndt_t *
+read_fixed_dim(const common_t *fields, const char * const ptr, int64_t offset,
+               const int64_t len, ndt_context_t *ctx)
 {
     ndt_contig tag;
     int64_t shape;
     int64_t step;
     int64_t itemsize;
-    ndt_t *type;
+    const ndt_t *type;
     ndt_t *t;
 
     offset = ndt_contig_from_uint8(&tag, ptr, offset, len, ctx);
@@ -448,14 +448,14 @@ read_fixed_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     offset = read_pos_int64(&itemsize, ptr, offset, len, ctx);
     if (offset < 0) return NULL;
 
-    type = read_type(m, ptr, offset, len, ctx);
+    type = read_type(ptr, offset, len, ctx);
     if (type == NULL) {
         return NULL;
     }
 
     t = new_copy_common(fields, ctx);
     if (t == NULL) {
-        ndt_del(type);
+        ndt_decref(type);
         return NULL;
     }
     t->FixedDim.tag = tag;
@@ -467,13 +467,13 @@ read_fixed_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     return t;
 }
 
-static ndt_t *
-read_symbolic_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
-                  int64_t offset, const int64_t len, ndt_context_t *ctx)
+static const ndt_t *
+read_symbolic_dim(const common_t *fields, const char * const ptr, int64_t offset,
+                  const int64_t len, ndt_context_t *ctx)
 {
     ndt_contig tag;
     char *name;
-    ndt_t *type;
+    const ndt_t *type;
     ndt_t *t;
 
     offset = ndt_contig_from_uint8(&tag, ptr, offset, len, ctx);
@@ -486,7 +486,7 @@ read_symbolic_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
         return NULL;
     }
 
-    type = read_type(m, ptr, offset, len, ctx);
+    type = read_type(ptr, offset, len, ctx);
     if (type == NULL) {
         ndt_free(name);
         return NULL;
@@ -494,7 +494,7 @@ read_symbolic_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
 
     t = new_copy_common(fields, ctx);
     if (t == NULL) {
-        ndt_del(type);
+        ndt_decref(type);
         ndt_free(name);
         return NULL;
     }
@@ -505,13 +505,13 @@ read_symbolic_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     return t;
 }
 
-static ndt_t *
-read_ellipsis_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
-                  int64_t offset, const int64_t len, ndt_context_t *ctx)
+static const ndt_t *
+read_ellipsis_dim(const common_t *fields, const char * const ptr, int64_t offset,
+                  const int64_t len, ndt_context_t *ctx)
 {
     ndt_contig tag;
     char *name;
-    ndt_t *type;
+    const ndt_t *type;
     ndt_t *t;
 
     offset = ndt_contig_from_uint8(&tag, ptr, offset, len, ctx);
@@ -528,7 +528,7 @@ read_ellipsis_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
         name = NULL;
     }
 
-    type = read_type(m, ptr, offset, len, ctx);
+    type = read_type(ptr, offset, len, ctx);
     if (type == NULL) {
         ndt_free(name);
         return NULL;
@@ -536,7 +536,7 @@ read_ellipsis_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
 
     t = new_copy_common(fields, ctx);
     if (t == NULL) {
-        ndt_del(type);
+        ndt_decref(type);
         ndt_free(name);
         return NULL;
     }
@@ -547,16 +547,16 @@ read_ellipsis_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     return t;
 }
 
-static ndt_t *
-read_var_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
-             int64_t offset, const int64_t len, ndt_context_t *ctx)
+static const ndt_t *
+read_var_dim(const common_t *fields, const char * const ptr, int64_t offset,
+             const int64_t len, ndt_context_t *ctx)
 {
     int64_t itemsize;
     int32_t noffsets;
-    int32_t *offsets;
+    ndt_offsets_t *offsets = NULL;
     int32_t nslices = 0;
     ndt_slice_t *slices = NULL;
-    ndt_t *type;
+    const ndt_t *type;
     ndt_t *t;
 
     offset = read_pos_int64(&itemsize, ptr, offset, len, ctx);
@@ -568,26 +568,28 @@ read_var_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     offset = read_pos_int32(&nslices, ptr, offset, len, ctx);
     if (offset < 0) return NULL;
 
-    offsets = ndt_alloc(noffsets, sizeof *offsets);
-    if (offsets == NULL) {
-        return ndt_memory_error(ctx);
-    }
+    if (noffsets > 0) {
+        offsets = ndt_offsets_new(noffsets, ctx);
+        if (offsets == NULL) {
+            return NULL;
+        }
 
-    offset = read_int32_array(offsets, noffsets, ptr, offset, len, ctx);
-    if (offset < 0) {
-        ndt_free(offsets);
-        return NULL;
+        offset = read_int32_array((int32_t *)offsets->v, noffsets, ptr, offset, len, ctx);
+        if (offset < 0) {
+            ndt_decref_offsets(offsets);
+            return NULL;
+        }
     }
 
     slices = ndt_alloc(nslices, sizeof *slices);
     if (slices == NULL) {
-        ndt_free(offsets);
+        ndt_decref_offsets(offsets);
         return ndt_memory_error(ctx);
     }
 
     offset = read_ndt_slice_array(slices, nslices, ptr, offset, len, ctx);
     if (offset < 0) {
-        ndt_free(offsets);
+        ndt_decref_offsets(offsets);
         ndt_free(slices);
         return NULL;
     }
@@ -597,38 +599,79 @@ read_var_dim(ndt_meta_t *m, const common_t *fields, const char * const ptr,
         slices = NULL;
     }
 
-    type = read_type(m, ptr, offset, len, ctx);
+    type = read_type(ptr, offset, len, ctx);
     if (type == NULL) {
-        ndt_free(offsets);
+        ndt_decref_offsets(offsets);
         ndt_free(slices);
         return NULL;
     }
 
     t = new_copy_common(fields, ctx);
     if (t == NULL) {
-        ndt_free(offsets);
+        ndt_decref_offsets(offsets);
         ndt_free(slices);
-        ndt_del(type);
+        ndt_decref(type);
         return NULL;
     }
     t->VarDim.type = type;
-    t->Concrete.VarDim.flag = ExternalOffsets;
     t->Concrete.VarDim.itemsize = itemsize;
-    t->Concrete.VarDim.noffsets = noffsets;
     t->Concrete.VarDim.offsets = offsets;
     t->Concrete.VarDim.nslices = nslices;
     t->Concrete.VarDim.slices = slices;
 
-    m->noffsets[m->ndims] = noffsets;
-    m->offsets[m->ndims] = offsets;
-    m->ndims++;
+    return t;
+}
+
+static const ndt_t *
+read_var_dim_elem(const common_t *fields, const char * const ptr, int64_t offset,
+                  const int64_t len, ndt_context_t *ctx)
+{
+    ndt_t *t;
+    int64_t index;
+
+    offset = read_pos_int64(&index, ptr, offset, len, ctx);
+    if (offset < 0) return NULL;
+
+    t = (ndt_t *)read_var_dim(fields, ptr, offset, len, ctx);
+    if (t == NULL) {
+        return NULL;
+    }
+    t->tag = VarDimElem;
+    t->VarDimElem.index = index;
+
+    return t;
+}
+
+static const ndt_t *
+read_array(const common_t *fields, const char * const ptr, int64_t offset,
+           const int64_t len, ndt_context_t *ctx)
+{
+    const ndt_t *type;
+    ndt_t *t;
+    int64_t itemsize;
+
+    offset = read_pos_int64(&itemsize, ptr, offset, len, ctx);
+    if (offset < 0) return NULL;
+
+    type = read_type(ptr, offset, len, ctx);
+    if (type == NULL) {
+        return NULL;
+    }
+
+    t = new_copy_common(fields, ctx);
+    if (t == NULL) {
+        ndt_decref(type);
+        return NULL;
+    }
+    t->Array.itemsize = itemsize;
+    t->Array.type = type;
 
     return t;
 }
 
 static ndt_t *
-read_tuple(ndt_meta_t *m, const common_t *fields, const char * const ptr,
-           int64_t offset, const int64_t len, ndt_context_t *ctx)
+read_tuple(const common_t *fields, const char * const ptr, int64_t offset,
+           const int64_t len, ndt_context_t *ctx)
 {
     int64_t metaoffset;
     enum ndt_variadic flag;
@@ -641,7 +684,7 @@ read_tuple(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     offset = read_pos_int64(&shape, ptr, offset, len, ctx);
     if (offset < 0) return NULL;
 
-    t = ndt_tuple_new(flag, shape, ctx);
+    t = ndt_tuple_new(flag, shape, 0, ctx);
     if (t == NULL) {
         return NULL;
     }
@@ -661,7 +704,7 @@ read_tuple(ndt_meta_t *m, const common_t *fields, const char * const ptr,
         metaoffset = next_metaoffset(&offset, ptr, metaoffset, len, ctx);
         if (metaoffset < 0) goto error;
 
-        t->Tuple.types[i] = read_type(m, ptr, offset, len, ctx);
+        t->Tuple.types[i] = read_type(ptr, offset, len, ctx);
         if (t->Tuple.types[i] == NULL) {
             goto error;
         }
@@ -670,13 +713,13 @@ read_tuple(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     return t;
 
 error:
-    ndt_del(t);
+    ndt_decref(t);
     return NULL;
 }
 
-static ndt_t *
-read_record(ndt_meta_t *m, const common_t *fields, const char * const ptr,
-            int64_t offset, const int64_t len, ndt_context_t *ctx)
+static const ndt_t *
+read_record(const common_t *fields, const char * const ptr, int64_t offset,
+            const int64_t len, ndt_context_t *ctx)
 {
     int64_t metaoffset;
     enum ndt_variadic flag;
@@ -689,7 +732,7 @@ read_record(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     offset = read_pos_int64(&shape, ptr, offset, len, ctx);
     if (offset < 0) return NULL;
 
-    t = ndt_record_new(flag, shape, ctx);
+    t = ndt_record_new(flag, shape, 0, ctx);
     if (t == NULL) {
         return NULL;
     }
@@ -712,7 +755,7 @@ read_record(ndt_meta_t *m, const common_t *fields, const char * const ptr,
         metaoffset = next_metaoffset(&offset, ptr, metaoffset, len, ctx);
         if (metaoffset < 0) goto error;
 
-        t->Record.types[i] = read_type(m, ptr, offset, len, ctx);
+        t->Record.types[i] = read_type(ptr, offset, len, ctx);
         if (t->Record.types[i] == NULL) {
             goto error;
         }
@@ -721,25 +764,63 @@ read_record(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     return t;
 
 error:
-    ndt_del(t);
+    ndt_decref(t);
     return NULL;
 }
 
-static ndt_t *
-read_ref(ndt_meta_t *m, const common_t *fields, const char * const ptr,
-         int64_t offset, const int64_t len, ndt_context_t *ctx)
+static const ndt_t *
+read_union(const common_t *fields, const char * const ptr, int64_t offset,
+           const int64_t len, ndt_context_t *ctx)
+{
+    int64_t metaoffset;
+    int64_t ntags;
+    ndt_t *t;
+
+    offset = read_pos_int64(&ntags, ptr, offset, len, ctx);
+    if (offset < 0) return NULL;
+
+    t = ndt_union_new(ntags, 0, ctx);
+    if (t == NULL) {
+        return NULL;
+    }
+    copy_common(t, fields);
+
+    offset = read_string_array(t->Union.tags, ntags, ptr, offset, len, ctx);
+    if (offset < 0) goto error;
+
+    metaoffset = offset;
+    for (int64_t i = 0; i < ntags; i++) {
+        metaoffset = next_metaoffset(&offset, ptr, metaoffset, len, ctx);
+        if (metaoffset < 0) goto error;
+
+        t->Union.types[i] = read_type(ptr, offset, len, ctx);
+        if (t->Union.types[i] == NULL) {
+            goto error;
+        }
+    }
+
+    return t;
+
+error:
+    ndt_decref(t);
+    return NULL;
+}
+
+static const ndt_t *
+read_ref(const common_t *fields, const char * const ptr, int64_t offset,
+         const int64_t len, ndt_context_t *ctx)
 {
-    ndt_t *type;
+    const ndt_t *type;
     ndt_t *t;
 
-    type = read_type(m, ptr, offset, len, ctx);
+    type = read_type(ptr, offset, len, ctx);
     if (type == NULL) {
         return NULL;
     }
 
     t = new_copy_common(fields, ctx);
     if (t == NULL) {
-        ndt_del(type);
+        ndt_decref(type);
         return NULL;
     }
     t->Ref.type = type;
@@ -747,18 +828,18 @@ read_ref(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     return t;
 }
 
-static ndt_t *
-read_constr(ndt_meta_t *m, const common_t *fields, const char * const ptr,
-            int64_t offset, const int64_t len, ndt_context_t *ctx)
+static const ndt_t *
+read_constr(const common_t *fields, const char * const ptr, int64_t offset,
+            const int64_t len, ndt_context_t *ctx)
 {
     char *name;
-    ndt_t *type;
+    const ndt_t *type;
     ndt_t *t;
 
     offset = read_string(&name, ptr, offset, len, ctx);
     if (offset < 0) return NULL;
 
-    type = read_type(m, ptr, offset, len, ctx);
+    type = read_type(ptr, offset, len, ctx);
     if (type == NULL) {
         ndt_free(name);
         return NULL;
@@ -766,7 +847,7 @@ read_constr(ndt_meta_t *m, const common_t *fields, const char * const ptr,
 
     t = new_copy_common(fields, ctx);
     if (t == NULL) {
-        ndt_del(type);
+        ndt_decref(type);
         ndt_free(name);
         return NULL;
     }
@@ -776,19 +857,19 @@ read_constr(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     return t;
 }
 
-static ndt_t *
-read_nominal(ndt_meta_t *m, const common_t *fields, const char * const ptr,
-             int64_t offset, const int64_t len, ndt_context_t *ctx)
+static const ndt_t *
+read_nominal(const common_t *fields, const char * const ptr, int64_t offset,
+             const int64_t len, ndt_context_t *ctx)
 {
     char *name;
-    ndt_t *type;
+    const ndt_t *type;
     const ndt_typedef_t *d;
     ndt_t *t;
 
     offset = read_string(&name, ptr, offset, len, ctx);
     if (offset < 0) return NULL;
 
-    type = read_type(m, ptr, offset, len, ctx);
+    type = read_type(ptr, offset, len, ctx);
     if (type == NULL) {
         ndt_free(name);
         return NULL;
@@ -797,14 +878,14 @@ read_nominal(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     d = ndt_typedef_find(name, ctx);
     if (d == NULL) {
         ndt_free(name);
-        ndt_del(type);
+        ndt_decref(type);
         return NULL;
     }
 
     t = new_copy_common(fields, ctx);
     if (t == NULL) {
         ndt_free(name);
-        ndt_del(type);
+        ndt_decref(type);
         return NULL;
     }
     t->Nominal.name = name;
@@ -814,7 +895,7 @@ read_nominal(ndt_meta_t *m, const common_t *fields, const char * const ptr,
     return t;
 }
 
-static ndt_t *
+static const ndt_t *
 read_categorical(const common_t *fields, const char * const ptr, int64_t offset,
                  const int64_t len, ndt_context_t *ctx)
 {
@@ -847,7 +928,7 @@ read_categorical(const common_t *fields, const char * const ptr, int64_t offset,
     return t;
 }
 
-static ndt_t *
+static const ndt_t *
 read_fixed_string(const common_t *fields, const char * const ptr, int64_t offset,
                   const int64_t len, ndt_context_t *ctx)
 {
@@ -871,7 +952,7 @@ read_fixed_string(const common_t *fields, const char * const ptr, int64_t offset
     return t;
 }
 
-static ndt_t *
+static const ndt_t *
 read_fixed_bytes(const common_t *fields, const char * const ptr, int64_t offset,
                  const int64_t len, ndt_context_t *ctx)
 {
@@ -895,7 +976,7 @@ read_fixed_bytes(const common_t *fields, const char * const ptr, int64_t offset,
     return t;
 }
 
-static ndt_t *
+static const ndt_t *
 read_bytes(const common_t *fields, const char * const ptr, int64_t offset,
            const int64_t len, ndt_context_t *ctx)
 {
@@ -914,7 +995,7 @@ read_bytes(const common_t *fields, const char * const ptr, int64_t offset,
     return t;
 }
 
-static ndt_t *
+static const ndt_t *
 read_char(const common_t *fields, const char * const ptr, int64_t offset,
           const int64_t len, ndt_context_t *ctx)
 {
@@ -933,7 +1014,7 @@ read_char(const common_t *fields, const char * const ptr, int64_t offset,
     return t;
 }
 
-static ndt_t *
+static const ndt_t *
 read_typevar(const common_t *fields, const char * const ptr, int64_t offset,
              const int64_t len, ndt_context_t *ctx)
 {
@@ -953,8 +1034,8 @@ read_typevar(const common_t *fields, const char * const ptr, int64_t offset,
     return t;
 }
 
-static ndt_t *
-read_type(ndt_meta_t *m, const char * const ptr, int64_t offset, const int64_t len,
+static const ndt_t *
+read_type(const char * const ptr, int64_t offset, const int64_t len,
           ndt_context_t *ctx)
 {
     common_t fields;
@@ -963,17 +1044,20 @@ read_type(ndt_meta_t *m, const char * const ptr, int64_t offset, const int64_t l
     if (offset < 0) return NULL;
 
     switch (fields.tag) {
-    case Module: return read_module(m, &fields, ptr, offset, len, ctx);
-    case Function: return read_function(m, &fields, ptr, offset, len, ctx);
-    case FixedDim: return read_fixed_dim(m, &fields, ptr, offset, len, ctx);
-    case SymbolicDim: return read_symbolic_dim(m, &fields, ptr, offset, len, ctx);
-    case EllipsisDim: return read_ellipsis_dim(m, &fields, ptr, offset, len, ctx);
-    case VarDim: return read_var_dim(m, &fields, ptr, offset, len, ctx);
-    case Tuple: return read_tuple(m, &fields, ptr, offset, len, ctx);
-    case Record: return read_record(m, &fields, ptr, offset, len, ctx);
-    case Ref: return read_ref(m, &fields, ptr, offset, len, ctx);
-    case Constr: return read_constr(m, &fields, ptr, offset, len, ctx);
-    case Nominal: return read_nominal(m, &fields, ptr, offset, len, ctx);
+    case Module: return read_module(&fields, ptr, offset, len, ctx);
+    case Function: return read_function(&fields, ptr, offset, len, ctx);
+    case FixedDim: return read_fixed_dim(&fields, ptr, offset, len, ctx);
+    case SymbolicDim: return read_symbolic_dim(&fields, ptr, offset, len, ctx);
+    case EllipsisDim: return read_ellipsis_dim(&fields, ptr, offset, len, ctx);
+    case VarDim: return read_var_dim(&fields, ptr, offset, len, ctx);
+    case VarDimElem: return read_var_dim_elem(&fields, ptr, offset, len, ctx);
+    case Array: return read_array(&fields, ptr, offset, len, ctx);
+    case Tuple: return read_tuple(&fields, ptr, offset, len, ctx);
+    case Record: return read_record(&fields, ptr, offset, len, ctx);
+    case Union: return read_union(&fields, ptr, offset, len, ctx);
+    case Ref: return read_ref(&fields, ptr, offset, len, ctx);
+    case Constr: return read_constr(&fields, ptr, offset, len, ctx);
+    case Nominal: return read_nominal(&fields, ptr, offset, len, ctx);
     case Categorical: return read_categorical(&fields, ptr, offset, len, ctx);
     case FixedString: return read_fixed_string(&fields, ptr, offset, len, ctx);
     case FixedBytes: return read_fixed_bytes(&fields, ptr, offset, len, ctx);
@@ -981,16 +1065,17 @@ read_type(ndt_meta_t *m, const char * const ptr, int64_t offset, const int64_t l
     case Char: return read_char(&fields, ptr, offset, len, ctx);
     case Typevar: return read_typevar(&fields, ptr, offset, len, ctx);
 
-    case Bool:
-    case Int8: case Int16: case Int32: case Int64:
-    case Uint8: case Uint16: case Uint32: case Uint64:
-    case Float16: case Float32: case Float64:
-    case Complex32: case Complex64: case Complex128:
     case String:
+    case Bool:
+    case SignedKind: case Int8: case Int16: case Int32: case Int64:
+    case UnsignedKind: case Uint8: case Uint16: case Uint32: case Uint64:
+    case FloatKind: case BFloat16: case Float16: case Float32: case Float64:
+    case ComplexKind: case BComplex32: case Complex32: case Complex64: case Complex128:
+        return ndt_primitive(fields.tag, fields.flags, ctx);
 
     case AnyKind:
-    case ScalarKind: case SignedKind: case UnsignedKind: case FloatKind:
-    case ComplexKind: case FixedStringKind: case FixedBytesKind:
+    case ScalarKind:
+    case FixedStringKind: case FixedBytesKind:
         return new_copy_common(&fields, ctx);
     }
 
@@ -999,9 +1084,8 @@ read_type(ndt_meta_t *m, const char * const ptr, int64_t offset, const int64_t l
     return NULL;
 }
 
-ndt_t *
-ndt_deserialize(ndt_meta_t *m, const char * const ptr, int64_t len,
-                ndt_context_t *ctx)
+const ndt_t *
+ndt_deserialize(const char * const ptr, int64_t len, ndt_context_t *ctx)
 {
-    return read_type(m, ptr, 0, len, ctx);
+    return read_type(ptr, 0, len, ctx);
 }