ndtypes 0.2.0dev4

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

@@ -0,0 +1,92 @@
+/*
+ * 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 PARSEFUNCS_H
+#define PARSEFUNCS_H
+
+
+#include "ndtypes.h"
+#include "seq.h"
+#include "attr.h"
+
+
+/* LOCAL SCOPE */
+NDT_PRAGMA(NDT_HIDE_SYMBOLS_START)
+
+
+/*****************************************************************************/
+/*                        Functions used in the lexer                        */
+/*****************************************************************************/
+
+char *mk_stringlit(const char *lexeme, ndt_context_t *ctx);
+
+
+/*****************************************************************************/
+/*                          Parser helper functions                          */
+/*****************************************************************************/
+
+enum ndt_encoding encoding_from_string(char *s, ndt_context_t *ctx);
+ndt_attr_t *mk_attr(char *name, char *value, ndt_context_t *ctx);
+ndt_attr_t *mk_attr_from_seq(char *name, ndt_string_seq_t *seq, ndt_context_t *ctx);
+
+
+/*****************************************************************************/
+/*                    Parser functions for creating types                    */
+/*****************************************************************************/
+
+ndt_t *mk_function(ndt_type_seq_t *in, ndt_type_seq_t *out, ndt_context_t *ctx);
+
+ndt_t *mk_fortran(ndt_t *type, ndt_context_t *ctx);
+ndt_t *mk_contig(char *name, ndt_t *type, ndt_context_t *ctx);
+ndt_t *mk_fixed_dim_from_shape(char *v, ndt_t *type, ndt_context_t *ctx);
+ndt_t *mk_fixed_dim_from_attrs(ndt_attr_seq_t *attrs, ndt_t *type, ndt_context_t *ctx);
+
+ndt_t *mk_var_dim(ndt_meta_t *m, ndt_attr_seq_t *seq, ndt_t *type, ndt_context_t *ctx);
+ndt_t *mk_var_ellipsis(ndt_t *type, ndt_context_t *ctx);
+
+ndt_field_t *mk_field(char *name, ndt_t *type, ndt_attr_seq_t *seq, ndt_context_t *ctx);
+ndt_t *mk_tuple(enum ndt_variadic flag, ndt_field_seq_t *fields, ndt_attr_seq_t *attrs, ndt_context_t *ctx);
+ndt_t *mk_record(enum ndt_variadic flag, ndt_field_seq_t *fields, ndt_attr_seq_t *attrs, ndt_context_t *ctx);
+
+ndt_t *mk_categorical(ndt_value_seq_t *seq, ndt_context_t *ctx);
+
+ndt_t *mk_fixed_string(char *v, enum ndt_encoding encoding, ndt_context_t *ctx);
+ndt_t *mk_bytes(ndt_attr_seq_t *seq, ndt_context_t *ctx);
+ndt_t *mk_fixed_bytes(ndt_attr_seq_t *seq, ndt_context_t *ctx);
+
+
+/* END LOCAL SCOPE */
+NDT_PRAGMA(NDT_HIDE_SYMBOLS_END)
+
+
+#endif /*  PARSEFUNCS_H */

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

@@ -0,0 +1,246 @@
+/*
+ * 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 <assert.h>
+#include <setjmp.h>
+#include "ndtypes.h"
+#include "seq.h"
+#include "grammar.h"
+#include "lexer.h"
+
+
+#ifdef YYDEBUG
+int ndt_yydebug = 1;
+#endif
+
+
+static FILE *
+ndt_fopen(const char *name, const char *mode)
+{
+#ifdef _MSC_VER
+    FILE *fp;
+
+    (void)fopen_s(&fp, name, mode);
+    return fp;
+#else
+    return fopen(name, mode);
+#endif
+}
+
+/* The yy_fatal_error() function of flex calls exit(). We intercept the function
+   and do a longjmp() for proper error handling. */
+jmp_buf ndt_lexerror;
+
+
+static ndt_t *
+_ndt_from_fp(ndt_meta_t *m, FILE *fp, ndt_context_t *ctx)
+{
+    volatile yyscan_t scanner = NULL;
+    ndt_t *ast = NULL;
+    int ret;
+
+    if (setjmp(ndt_lexerror) == 0) {
+        if (ndt_yylex_init_extra(ctx, (yyscan_t *)&scanner) != 0) {
+            ndt_err_format(ctx, NDT_LexError, "lexer initialization failed");
+            return NULL;
+        }
+
+        if (fp != stdin) {
+            ndt_yyset_in(fp, scanner);
+        }
+
+        ret = ndt_yyparse(scanner, &ast, m, ctx);
+        ndt_yylex_destroy(scanner);
+
+        if (ret == 2) {
+            ndt_err_format(ctx, NDT_MemoryError, "out of memory");
+        }
+
+        return ast;
+    }
+    else {
+        if (scanner) {
+            ndt_yylex_destroy(scanner);
+        }
+        ndt_err_format(ctx, NDT_MemoryError,
+            "out of memory (most likely) or internal lexer error");
+        return NULL;
+    }
+}
+
+static ndt_t *
+_ndt_from_file(ndt_meta_t *m, const char *name, ndt_context_t *ctx)
+{
+    FILE *fp;
+    ndt_t *t;
+
+    if (strcmp(name, "-") == 0) {
+        fp = stdin;
+    }
+    else {
+        fp = ndt_fopen(name, "rb");
+        if (fp == NULL) {
+            ndt_err_format(ctx, NDT_OSError, "could not open %s", name);
+            return NULL;
+        }
+    }
+
+    t = _ndt_from_fp(m, fp, ctx);
+    fclose(fp);
+
+    return t;
+}
+
+ndt_t *
+ndt_from_file(const char *name, ndt_context_t *ctx)
+{
+    return _ndt_from_file(NULL, name, ctx);
+}
+
+ndt_t *
+ndt_from_file_fill_meta(ndt_meta_t *m, const char *name, ndt_context_t *ctx)
+{
+    return _ndt_from_file(m, name, ctx);
+}
+
+static ndt_t *
+_ndt_from_string(ndt_meta_t *m, const char *input, ndt_context_t *ctx)
+{
+    volatile yyscan_t scanner = NULL;
+    volatile YY_BUFFER_STATE state = NULL;
+    char *buffer;
+    size_t size;
+    ndt_t *ast = NULL;
+    int ret;
+
+    size = strlen(input);
+    if (size > INT_MAX / 2) {
+        /* The code generated by flex truncates size_t in several places. */
+        ndt_err_format(ctx, NDT_LexError, "maximum input length: %d", INT_MAX/2);
+        return NULL;
+    }
+
+    buffer = ndt_alloc_size(size+2);
+    if (buffer == NULL) {
+        return ndt_memory_error(ctx);
+    }
+    memcpy(buffer, input, size);
+    buffer[size] = '\0';
+    buffer[size+1] = '\0';
+
+    if (setjmp(ndt_lexerror) == 0) {
+        if (ndt_yylex_init_extra(ctx, (yyscan_t *)&scanner) != 0) {
+            ndt_err_format(ctx, NDT_LexError, "lexer initialization failed");
+            ndt_free(buffer);
+            return NULL;
+        }
+
+        state = ndt_yy_scan_buffer(buffer, size+2, scanner);
+        state->yy_bs_lineno = 1;
+        state->yy_bs_column = 1;
+
+        ret = ndt_yyparse(scanner, &ast, m, ctx);
+        ndt_yy_delete_buffer(state, scanner);
+        ndt_yylex_destroy(scanner);
+        ndt_free(buffer);
+
+        if (ret == 2) {
+            ndt_err_format(ctx, NDT_MemoryError, "out of memory");
+        }
+
+        return ast;
+    }
+    else { /* fatal lexer error */
+        if (state) {
+            ndt_free(state);
+        }
+        if (scanner) {
+            ndt_yylex_destroy(scanner);
+        }
+        ndt_free(buffer);
+        ndt_err_format(ctx, NDT_MemoryError, "flex: internal lexer error");
+        return NULL;
+    }
+}
+
+ndt_t *
+ndt_from_string(const char *input, ndt_context_t *ctx)
+{
+    return _ndt_from_string(NULL, input, ctx);
+}
+
+ndt_t *
+ndt_from_string_v(const char *input, ndt_context_t *ctx)
+{
+    ndt_t *t = _ndt_from_string(NULL, input, ctx);
+    if (t == NULL) {
+        ndt_err_append(ctx, input);
+    }
+    return t;
+}
+
+ndt_t *
+ndt_from_string_fill_meta(ndt_meta_t *m, const char *input, ndt_context_t *ctx)
+{
+    return _ndt_from_string(m, input, ctx);
+}
+
+ndt_t *
+ndt_from_metadata_and_dtype(const ndt_meta_t *m, const char *dtype, ndt_context_t *ctx)
+{
+    ndt_t *t, *type;
+    int i;
+
+    type = ndt_from_string(dtype, ctx);
+    if (type == NULL) {
+        return NULL;
+    }
+
+    if (ndt_is_abstract(type)) {
+        ndt_err_format(ctx, NDT_InvalidArgumentError,
+            "cannot create abstract type with offsets");
+        ndt_del(type);
+        return NULL;
+    }
+
+    for (i=0, t=type; i < m->ndims; i++, type=t) {
+        t = ndt_var_dim(type, ExternalOffsets, m->noffsets[i], m->offsets[i],
+                        0, NULL, ctx);
+        if (t == NULL) {
+            return NULL;
+        }
+    }
+
+    return t;
+}

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

@@ -0,0 +1,269 @@
+/*
+ * 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 <assert.h>
+#include "ndtypes.h"
+#include "seq.h"
+
+
+/*****************************************************************************/
+/*                              Field sequences                              */
+/*****************************************************************************/
+
+NDT_SEQ_NEW(ndt_field)
+NDT_SEQ_DEL(ndt_field)
+NDT_SEQ_GROW(ndt_field)
+NDT_SEQ_APPEND(ndt_field)
+NDT_SEQ_FINALIZE(ndt_field)
+
+
+/*****************************************************************************/
+/*                               String sequences                            */
+/*****************************************************************************/
+
+ndt_string_seq_t *
+ndt_string_seq_new(char *elt, ndt_context_t *ctx)
+{
+    ndt_string_seq_t *seq;
+    char **ptr;
+
+    seq = ndt_alloc_size(sizeof *seq);
+    if (seq == NULL) {
+        ndt_free(elt);
+        return ndt_memory_error(ctx);
+    }
+
+    ptr = ndt_alloc_size(2 * (sizeof *ptr));
+    if (ptr == NULL) {
+        ndt_free(seq);
+        ndt_free(elt);
+        return ndt_memory_error(ctx);
+    }
+
+    ptr[0] = elt;
+    seq->len = 1;
+    seq->reserved = 2;
+    seq->ptr = ptr;
+
+    return seq;
+}
+
+void
+ndt_string_seq_del(ndt_string_seq_t *seq)
+{
+    int64_t i;
+
+    if (seq != NULL) {
+        for (i = 0; i < seq->len; i++) {
+            ndt_free(seq->ptr[i]);
+        }
+        ndt_free(seq->ptr);
+        ndt_free(seq);
+    }
+}
+
+static int
+ndt_string_seq_grow(ndt_string_seq_t *seq, ndt_context_t *ctx)
+{
+    char **ptr;
+
+    ptr = ndt_realloc(seq->ptr, seq->reserved, 2 * (sizeof *ptr));
+    if (ptr == NULL) {
+        ndt_err_format(ctx, NDT_MemoryError, "out of memory");
+        return -1;
+    }
+
+    seq->ptr = ptr;
+    seq->reserved = 2 * seq->reserved;
+
+    return 0;
+}
+
+ndt_string_seq_t *
+ndt_string_seq_append(ndt_string_seq_t *seq, char *elt, ndt_context_t *ctx)
+{
+    assert(seq->len <= seq->reserved);
+
+    if (seq->len == seq->reserved) {
+        if (ndt_string_seq_grow(seq, ctx) < 0) {
+            ndt_string_seq_del(seq);
+            ndt_free(elt);
+            return NULL;
+        }
+    }
+
+    seq->ptr[seq->len] = elt;
+    seq->len++;
+
+    return seq;
+}
+
+ndt_string_seq_t *
+ndt_string_seq_finalize(ndt_string_seq_t *seq)
+{
+    char **ptr;
+
+    if (seq == NULL) {
+        return NULL;
+    }
+
+    assert(seq->len <= seq->reserved);
+
+    ptr = ndt_realloc(seq->ptr, seq->len, sizeof *ptr);
+    if (ptr == NULL) {
+        return seq; /* seq is still valid */
+    }
+
+    seq->ptr = ptr;
+    seq->reserved = seq->len;
+
+    return seq;
+}
+
+
+/*****************************************************************************/
+/*                                Type sequences                             */
+/*****************************************************************************/
+
+ndt_type_seq_t *
+ndt_type_seq_empty(ndt_context_t *ctx)
+{
+    ndt_type_seq_t *seq;
+
+    seq = ndt_alloc_size(sizeof *seq);
+    if (seq == NULL) {
+        return ndt_memory_error(ctx);
+    }
+
+    seq->len = 0;
+    seq->reserved = 0;
+    seq->ptr = NULL;
+
+    return seq;
+}
+
+ndt_type_seq_t *
+ndt_type_seq_new(ndt_t *elt, ndt_context_t *ctx)
+{
+    ndt_type_seq_t *seq;
+    ndt_t **ptr;
+
+    seq = ndt_alloc_size(sizeof *seq);
+    if (seq == NULL) {
+        ndt_del(elt);
+        return ndt_memory_error(ctx);
+    }
+
+    ptr = ndt_alloc_size(2 * (sizeof *ptr));
+    if (ptr == NULL) {
+        ndt_free(seq);
+        ndt_del(elt);
+        return ndt_memory_error(ctx);
+    }
+
+    ptr[0] = elt;
+    seq->len = 1;
+    seq->reserved = 2;
+    seq->ptr = ptr;
+
+    return seq;
+}
+
+void
+ndt_type_seq_del(ndt_type_seq_t *seq)
+{
+    if (seq != NULL) {
+        ndt_type_array_del(seq->ptr, seq->len);
+        ndt_free(seq);
+    }
+}
+
+static int
+ndt_type_seq_grow(ndt_type_seq_t *seq, ndt_context_t *ctx)
+{
+    ndt_t **ptr;
+
+    ptr = ndt_realloc(seq->ptr, seq->reserved, 2 * (sizeof *ptr));
+    if (ptr == NULL) {
+        ndt_err_format(ctx, NDT_MemoryError, "out of memory");
+        return -1;
+    }
+
+    seq->ptr = ptr;
+    seq->reserved = 2 * seq->reserved;
+
+    return 0;
+}
+
+ndt_type_seq_t *
+ndt_type_seq_append(ndt_type_seq_t *seq, ndt_t *elt, ndt_context_t *ctx)
+{
+    assert(seq->len <= seq->reserved);
+
+    if (seq->len == seq->reserved) {
+        if (ndt_type_seq_grow(seq, ctx) < 0) {
+            ndt_type_seq_del(seq);
+            ndt_free(elt);
+            return NULL;
+        }
+    }
+
+    seq->ptr[seq->len] = elt;
+    seq->len++;
+
+    return seq;
+}
+
+ndt_type_seq_t *
+ndt_type_seq_finalize(ndt_type_seq_t *seq)
+{
+    ndt_t **ptr;
+
+    if (seq == NULL) {
+        return NULL;
+    }
+
+    assert(seq->len <= seq->reserved);
+
+    ptr = ndt_realloc(seq->ptr, seq->len, sizeof *ptr);
+    if (ptr == NULL) {
+        return seq; /* seq is still valid */
+    }
+
+    seq->ptr = ptr;
+    seq->reserved = seq->len;
+
+    return seq;
+}