ndtypes 0.2.0dev4

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

@@ -0,0 +1,230 @@
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <limits.h>
+#include <assert.h>
+#include "ndtypes.h"
+#include "overflow.h"
+
+
+#if defined(_MSC_VER)
+  #pragma warning(disable : 4232)
+#else
+  #include "config.h"
+  #ifdef WITH_VALGRIND
+    #include <valgrind/memcheck.h>
+  #endif
+#endif
+
+#if SIZE_MAX > UINTPTR_MAX
+  #error "need SIZE_MAX <= UINTPTR_MAX"
+#endif
+
+
+/* Custom allocation and free functions */
+void *(* ndt_mallocfunc)(size_t size) = malloc;
+void *(* ndt_callocfunc)(size_t nmemb, size_t size) = calloc;
+void *(* ndt_reallocfunc)(void *ptr, size_t size) = realloc;
+void (* ndt_freefunc)(void *ptr) = free;
+
+
+static inline int
+ispower2(uint16_t n)
+{
+    return n != 0 && (n & (n-1)) == 0;
+}
+
+static inline size_t
+convert_req(int64_t nmemb, int64_t size, bool *overflow)
+{
+    int64_t req;
+
+    assert(nmemb >= 0 && size >= 0);
+    if (nmemb == 0 || size == 0) {
+        return 1;
+    }
+
+    req = MULi64(nmemb, size, overflow);
+
+#if SIZE_MAX < INT64_MAX
+    if (req > INT32_MAX) {
+        *overflow = 1;
+        return SIZE_MAX;
+    }
+#endif
+
+    return (size_t)req;
+}
+
+/* malloc with overflow checking */
+void *
+ndt_alloc(int64_t nmemb, int64_t size)
+{
+    bool overflow = 0;
+    size_t req;
+
+    req = convert_req(nmemb, size, &overflow);
+    if (overflow) {
+        return NULL;
+    }
+
+    return ndt_mallocfunc(req);
+}
+
+void *
+ndt_alloc_size(size_t size)
+{
+    return ndt_mallocfunc(size);
+}
+
+/* calloc */
+void *
+ndt_calloc(int64_t nmemb, int64_t size)
+{
+    assert(nmemb >= 0 && size >= 0);
+    nmemb = nmemb == 0 ? 1 : nmemb;
+    size = size == 0 ? 1 : size;
+
+#if SIZE_MAX < INT64_MAX
+    if (nmemb > INT32_MAX || size > INT32_MAX) {
+        return NULL;
+    }
+#endif
+
+    return ndt_callocfunc((size_t)nmemb, (size_t)size);
+}
+
+/* realloc with overflow checking */
+void *
+ndt_realloc(void *ptr, int64_t nmemb, int64_t size)
+{
+    bool overflow = 0;
+    size_t req;
+
+    req = convert_req(nmemb, size, &overflow);
+    if (overflow) {
+        return NULL;
+    }
+
+    return ndt_reallocfunc(ptr, req);
+}
+
+/* free */
+void
+ndt_free(void *ptr)
+{
+    ndt_freefunc(ptr);
+}
+
+/* aligned calloc */
+void *
+ndt_aligned_calloc(uint16_t alignment, int64_t size)
+{
+    bool overflow = 0;
+    uintptr_t uintptr, aligned;
+    int64_t req;
+    uint32_t extra;
+    void *ptr;
+
+    if (!ispower2(alignment)) {
+        return NULL;
+    }
+
+    if (alignment < MAX_ALIGN) {
+        alignment = MAX_ALIGN;
+    }
+
+    if (size == 0) {
+        size = 1;
+    }
+
+    extra = alignment - 1;
+    extra = extra + sizeof(uintptr_t);
+
+    req = ADDi64(size, extra, &overflow);
+    if (overflow) {
+        return NULL;
+    }
+
+#if SIZE_MAX < INT64_MAX
+    if (req > INT32_MAX) {
+        return NULL;
+    }
+#endif
+
+    ptr = ndt_callocfunc((size_t)req, 1);
+    if (ptr == NULL) {
+        return NULL;
+    }
+
+    uintptr = (uintptr_t)ptr;
+    aligned = uintptr + extra;
+    if (aligned < uintptr) {
+        free(ptr);
+        return NULL;
+    }
+
+    aligned = aligned - (aligned % alignment);
+    *((uintptr_t *)aligned - 1) = uintptr;
+
+#ifdef WITH_VALGRIND
+{
+    uintptr_t leading_noaccess = aligned - uintptr;
+    uintptr_t trailing_noaccess = req - (size + leading_noaccess);
+    VALGRIND_MAKE_MEM_NOACCESS(uintptr, leading_noaccess);
+    VALGRIND_MAKE_MEM_NOACCESS(aligned+size, trailing_noaccess);
+}
+#endif
+
+    return (void *)aligned;
+}
+
+void
+ndt_aligned_free(void *aligned)
+{
+    uintptr_t uintptr;
+
+    if (aligned == NULL) {
+        return;
+    }
+
+#ifdef WITH_VALGRIND
+    VALGRIND_MAKE_MEM_DEFINED((uintptr_t *)aligned - 1, sizeof(uintptr_t));
+#endif
+
+    uintptr = *((uintptr_t *)aligned - 1);
+    ndt_freefunc((void *)uintptr);
+}

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

@@ -0,0 +1,268 @@
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <assert.h>
+#include "ndtypes.h"
+#include "seq.h"
+#include "attr.h"
+
+
+/*****************************************************************************/
+/*                    Type attributes used in the parser                     */
+/*****************************************************************************/
+
+void
+ndt_attr_del(ndt_attr_t *attr)
+{
+    int64_t i;
+
+    if (attr == NULL) {
+        return;
+    }
+
+    ndt_free(attr->name);
+
+    switch (attr->tag) {
+    case AttrValue:
+        ndt_free(attr->AttrValue);
+        ndt_free(attr);
+        return;
+    case AttrList:
+        for (i = 0; i < attr->AttrList.len; i++) {
+            ndt_free(attr->AttrList.items[i]);
+        }
+        ndt_free(attr->AttrList.items);
+        ndt_free(attr);
+        return;
+    }
+
+    /* NOT REACHED: tags should be exhaustive. */
+    ndt_internal_error("invalid attribute");
+}
+
+void
+ndt_attr_array_del(ndt_attr_t *attr, int64_t nattr)
+{
+    int64_t i, k;
+
+    if (attr == NULL) {
+        return;
+    }
+
+    for (i = 0; i < nattr; i++) {
+        ndt_free(attr[i].name);
+
+        switch (attr[i].tag) {
+        case AttrValue:
+            ndt_free(attr[i].AttrValue);
+            continue;
+        case AttrList:
+            for (k = 0; k < attr[i].AttrList.len; k++) {
+                ndt_free(attr[i].AttrList.items[k]);
+            }
+            ndt_free(attr[i].AttrList.items);
+            continue;
+        }
+
+        /* NOT REACHED: tags should be exhaustive. */
+        ndt_internal_error("invalid attribute");
+    }
+
+    ndt_free(attr);
+}
+
+/* Attribute sequences */
+NDT_SEQ_NEW(ndt_attr)
+NDT_SEQ_DEL(ndt_attr)
+NDT_SEQ_GROW(ndt_attr)
+NDT_SEQ_APPEND(ndt_attr)
+NDT_SEQ_FINALIZE(ndt_attr)
+
+
+int
+ndt_parse_attr(const attr_spec *spec, ndt_context_t *ctx,
+               const ndt_attr_seq_t *seq, ...)
+{
+    va_list ap;
+    ndt_attr_t const *v[MAX_ATTR] = {NULL};
+    int found;
+    int64_t i, k;
+
+    if (seq->len < spec->min || seq->len > spec->max) {
+        ndt_err_format(ctx, NDT_InvalidArgumentError,
+                       "too %s arguments", seq->len < spec->min ? "few" : "many");
+        return -1;
+    }
+
+    /* Quadratic time algorithm, we have a small number of args. */
+    for (i = 0; i < seq->len; i++) {
+        found = 0;
+        for (k = 0; k < spec->max; k++) {
+            if (strcmp(seq->ptr[i].name, spec->names[k]) == 0) {
+                if (v[k]) {
+                    ndt_err_format(ctx, NDT_InvalidArgumentError,
+                        "duplicate argument: %s", spec->names[k]);
+                    return -1;
+                }
+                found = 1;
+                v[k] = &seq->ptr[i];
+            }
+        }
+        if (!found) {
+            ndt_err_format(ctx, NDT_InvalidArgumentError,
+                "invalid argument: %s", seq->ptr[i].name);
+            return -1;
+        }
+    }
+
+    for (i = 0; i < spec->min; i++) {
+        if (v[i] == NULL) {
+            ndt_err_format(ctx, NDT_InvalidArgumentError,
+                           "missing required keyword: '%s'", spec->names[i]);
+            return -1;
+        }
+    }
+
+    va_start(ap, seq);
+    for (i = 0; i < spec->max; i++) {
+        void *ptr = va_arg(ap, void *);
+        if (v[i] == NULL) {
+            continue;
+        }
+
+        switch(spec->tags[i]) {
+        case AttrBool:
+            *(bool *)ptr = ndt_strtobool(v[i]->AttrValue, ctx);
+            goto endloop;
+        case AttrChar:
+            *(char *)ptr = ndt_strtochar(v[i]->AttrValue, ctx);
+            goto endloop;
+        case AttrInt8:
+            *(int8_t *)ptr = (int8_t)ndt_strtol(v[i]->AttrValue, INT8_MIN, INT8_MAX, ctx);
+            goto endloop;
+        case AttrInt16:
+            *(int16_t *)ptr = (int16_t)ndt_strtol(v[i]->AttrValue, INT16_MIN, INT16_MAX, ctx);
+            goto endloop;
+        case AttrInt32:
+            *(int32_t *)ptr = (int32_t)ndt_strtol(v[i]->AttrValue, INT32_MIN, INT32_MAX, ctx);
+            goto endloop;
+        case AttrInt64:
+            *(int64_t *)ptr = (int64_t)ndt_strtoll(v[i]->AttrValue, INT64_MIN, INT64_MAX, ctx);
+            goto endloop;
+        case AttrUint8:
+            *(uint8_t *)ptr = (uint8_t)ndt_strtoul(v[i]->AttrValue, UINT8_MAX, ctx);
+            goto endloop;
+        case AttrUint16:
+            *(uint16_t *)ptr = (uint16_t)ndt_strtoul(v[i]->AttrValue, UINT16_MAX, ctx);
+            goto endloop;
+        case AttrUint32:
+            *(uint32_t *)ptr = (uint32_t)ndt_strtoul(v[i]->AttrValue, UINT32_MAX, ctx);
+            goto endloop;
+        case AttrUint64:
+            *(uint64_t *)ptr = (uint64_t)ndt_strtoull(v[i]->AttrValue, UINT64_MAX, ctx);
+            goto endloop;
+        case AttrSize:
+            *(size_t *)ptr = (size_t)ndt_strtoull(v[i]->AttrValue, SIZE_MAX, ctx);
+            goto endloop;
+        case AttrFloat32:
+            *(float *)ptr = ndt_strtof(v[i]->AttrValue, ctx);
+            goto endloop;
+        case AttrFloat64:
+            *(double *)ptr = ndt_strtod(v[i]->AttrValue, ctx);
+            goto endloop;
+
+        case AttrCharOpt:
+            ((char_opt_t *)ptr)->tag = Some;
+            ((char_opt_t *)ptr)->Some = ndt_strtochar(v[i]->AttrValue, ctx);
+            goto endloop;
+
+        case AttrInt64Opt:
+            ((int64_opt_t *)ptr)->tag = Some;
+            ((int64_opt_t *)ptr)->Some = (int64_t)ndt_strtoll(v[i]->AttrValue, INT64_MIN, INT64_MAX, ctx);
+            goto endloop;
+
+        case AttrUint16Opt:
+            ((uint16_opt_t *)ptr)->tag = Some;
+            ((uint16_opt_t *)ptr)->Some = (uint16_t)ndt_strtoul(v[i]->AttrValue, UINT16_MAX, ctx);
+            goto endloop;
+
+        case AttrString: {
+            char *value = ndt_strdup(v[i]->AttrValue, ctx);
+            if (value == NULL) {
+                return -1;
+            }
+            *(char **)ptr = value;
+            goto endloop;
+        }
+
+        case AttrInt32List: {
+            int32_t *values = ndt_alloc(v[i]->AttrList.len, sizeof(int32_t));
+
+            if (values == NULL) {
+                ndt_err_format(ctx, NDT_MemoryError, "out of memory");
+                return -1;
+            }
+
+            for (k = 0; k < v[i]->AttrList.len; k++) {
+                values[k] = (int32_t)ndt_strtol(v[i]->AttrList.items[k], 0, INT32_MAX, ctx);
+                if (ndt_err_occurred(ctx)) {
+                    ndt_free(values);
+                    return -1;
+                }
+            }
+
+            *(int32_t **)ptr = values;
+
+            ptr = va_arg(ap, void *);
+            *(int64_t *)ptr = v[i]->AttrList.len;
+            i++;
+            goto endloop;
+          }
+        }
+
+        /* NOT REACHED: tags should be exhaustive */
+        ndt_err_format(ctx, NDT_RuntimeError, "invalid attribute tag", v[i]);
+
+     endloop:
+        if (ndt_err_occurred(ctx)) {
+            return -1;
+        }
+    }
+    va_end(ap);
+
+    return 0;
+}