oj_windows 3.16.15

data/ext/oj_windows/rails.h

@@ -0,0 +1,18 @@
+// Copyright (c) 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OJ_RAILS_H
+#define OJ_RAILS_H
+
+#include "dump.h"
+
+extern void oj_mimic_rails_init(void);
+extern ROpt oj_rails_get_opt(ROptTable rot, VALUE clas);
+
+extern bool oj_rails_hash_opt;
+extern bool oj_rails_array_opt;
+extern bool oj_rails_float_opt;
+
+extern VALUE oj_optimize_rails(VALUE self);
+
+#endif /* OJ_RAILS_H */

data/ext/oj_windows/reader.c

@@ -0,0 +1,222 @@
+// Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#ifdef NEEDS_UIO
+#if NEEDS_UIO
+#include <sys/uio.h>
+#endif
+#endif
+#include <time.h>
+#if !IS_WINDOWS
+#include <unistd.h>
+#endif
+
+#include "mem.h"
+#include "oj.h"
+#include "reader.h"
+#include "ruby.h"
+
+#define BUF_PAD 4
+
+static VALUE rescue_cb(VALUE rdr, VALUE err);
+static VALUE io_cb(VALUE rdr);
+static VALUE partial_io_cb(VALUE rdr);
+static int   read_from_io(Reader reader);
+static int   read_from_fd(Reader reader);
+static int   read_from_io_partial(Reader reader);
+// static int		read_from_str(Reader reader);
+
+void oj_reader_init(Reader reader, VALUE io, int fd, bool to_s) {
+    VALUE io_class = rb_obj_class(io);
+    VALUE stat;
+    VALUE ftype;
+
+    reader->head            = reader->base;
+    *((char *)reader->head) = '\0';
+    reader->end             = reader->head + sizeof(reader->base) - BUF_PAD;
+    reader->tail            = reader->head;
+    reader->read_end        = reader->head;
+    reader->pro             = 0;
+    reader->str             = 0;
+    reader->pos             = 0;
+    reader->line            = 1;
+    reader->col             = 0;
+    reader->free_head       = 0;
+
+    if (0 != fd) {
+        reader->read_func = read_from_fd;
+        reader->fd        = fd;
+    } else if (rb_cString == io_class) {
+        reader->read_func = 0;
+        reader->in_str    = StringValuePtr(io);
+        reader->head      = (char *)reader->in_str;
+        reader->tail      = reader->head;
+        reader->read_end  = reader->head + RSTRING_LEN(io);
+    } else if (oj_stringio_class == io_class) {
+        VALUE s = rb_funcall2(io, oj_string_id, 0, 0);
+
+        reader->read_func = 0;
+        reader->in_str    = StringValuePtr(s);
+        reader->head      = (char *)reader->in_str;
+        reader->tail      = reader->head;
+        reader->read_end  = reader->head + RSTRING_LEN(s);
+    } else if (rb_cFile == io_class && Qnil != (stat = rb_funcall(io, oj_stat_id, 0)) &&
+               Qnil != (ftype = rb_funcall(stat, oj_ftype_id, 0)) && 0 == strcmp("file", StringValuePtr(ftype)) &&
+               0 == FIX2INT(rb_funcall(io, oj_pos_id, 0))) {
+        reader->read_func = read_from_fd;
+        reader->fd        = FIX2INT(rb_funcall(io, oj_fileno_id, 0));
+    } else if (rb_respond_to(io, oj_readpartial_id)) {
+        reader->read_func = read_from_io_partial;
+        reader->io        = io;
+    } else if (rb_respond_to(io, oj_read_id)) {
+        reader->read_func = read_from_io;
+        reader->io        = io;
+    } else if (to_s) {
+        volatile VALUE rstr = oj_safe_string_convert(io);
+
+        reader->read_func = 0;
+        reader->in_str    = StringValuePtr(rstr);
+        reader->head      = (char *)reader->in_str;
+        reader->tail      = reader->head;
+        reader->read_end  = reader->head + RSTRING_LEN(rstr);
+    } else {
+        rb_raise(rb_eArgError, "parser io argument must be a String or respond to readpartial() or read().\n");
+    }
+}
+
+int oj_reader_read(Reader reader) {
+    int    err;
+    size_t shift = 0;
+
+    if (0 == reader->read_func) {
+        return -1;
+    }
+    // if there is not much room to read into, shift or realloc a larger buffer.
+    if (reader->head < reader->tail && 4096 > reader->end - reader->tail) {
+        if (0 == reader->pro) {
+            shift = reader->tail - reader->head;
+        } else {
+            shift = reader->pro - reader->head - 1;  // leave one character so we can backup one
+        }
+        if (0 >= shift) { /* no space left so allocate more */
+            const char *old  = reader->head;
+            size_t      size = reader->end - reader->head + BUF_PAD;
+
+            if (reader->head == reader->base) {
+                reader->head = OJ_R_ALLOC_N(char, size * 2);
+                memcpy((char *)reader->head, old, size);
+            } else {
+                OJ_R_REALLOC_N(reader->head, char, size * 2);
+            }
+            reader->free_head = 1;
+            reader->end       = reader->head + size * 2 - BUF_PAD;
+            reader->tail      = reader->head + (reader->tail - old);
+            reader->read_end  = reader->head + (reader->read_end - old);
+            if (0 != reader->pro) {
+                reader->pro = reader->head + (reader->pro - old);
+            }
+            if (0 != reader->str) {
+                reader->str = reader->head + (reader->str - old);
+            }
+        } else {
+            memmove((char *)reader->head, reader->head + shift, reader->read_end - (reader->head + shift));
+            reader->tail -= shift;
+            reader->read_end -= shift;
+            if (0 != reader->pro) {
+                reader->pro -= shift;
+            }
+            if (0 != reader->str) {
+                reader->str -= shift;
+            }
+        }
+    }
+    err                       = reader->read_func(reader);
+    *(char *)reader->read_end = '\0';
+
+    return err;
+}
+
+static VALUE rescue_cb(VALUE rbuf, VALUE err) {
+    VALUE clas = rb_obj_class(err);
+
+    if (rb_eTypeError != clas && rb_eEOFError != clas) {
+        Reader reader = (Reader)rbuf;
+
+        rb_raise(clas, "at line %d, column %d\n", reader->line, reader->col);
+    }
+    return Qfalse;
+}
+
+static VALUE partial_io_cb(VALUE rbuf) {
+    Reader reader = (Reader)rbuf;
+    VALUE  args[1];
+    VALUE  rstr;
+    char  *str;
+    size_t cnt;
+
+    args[0] = ULONG2NUM(reader->end - reader->tail);
+    rstr    = rb_funcall2(reader->io, oj_readpartial_id, 1, args);
+    if (Qnil == rstr) {
+        return Qfalse;
+    }
+    str = StringValuePtr(rstr);
+    cnt = RSTRING_LEN(rstr);
+    strcpy(reader->tail, str);
+    reader->read_end = reader->tail + cnt;
+
+    return Qtrue;
+}
+
+static VALUE io_cb(VALUE rbuf) {
+    Reader reader = (Reader)rbuf;
+    VALUE  args[1];
+    VALUE  rstr;
+    char  *str;
+    size_t cnt;
+
+    args[0] = ULONG2NUM(reader->end - reader->tail);
+    rstr    = rb_funcall2(reader->io, oj_read_id, 1, args);
+    if (Qnil == rstr) {
+        return Qfalse;
+    }
+    str = StringValuePtr(rstr);
+    cnt = RSTRING_LEN(rstr);
+    strcpy(reader->tail, str);
+    reader->read_end = reader->tail + cnt;
+
+    return Qtrue;
+}
+
+static int read_from_io_partial(Reader reader) {
+    return (Qfalse == rb_rescue(partial_io_cb, (VALUE)reader, rescue_cb, (VALUE)reader));
+}
+
+static int read_from_io(Reader reader) {
+    return (Qfalse == rb_rescue(io_cb, (VALUE)reader, rescue_cb, (VALUE)reader));
+}
+
+static int read_from_fd(Reader reader) {
+    ssize_t cnt;
+    size_t  max = reader->end - reader->tail;
+
+    cnt = read(reader->fd, reader->tail, max);
+    if (cnt <= 0) {
+        return -1;
+    } else if (0 != cnt) {
+        reader->read_end = reader->tail + cnt;
+    }
+    return 0;
+}
+
+// This is only called when the end of the string is reached so just return -1.
+/*
+static int
+read_from_str(Reader reader) {
+    return -1;
+}
+*/

data/ext/oj_windows/reader.h

@@ -0,0 +1,137 @@
+// Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OJ_READER_H
+#define OJ_READER_H
+
+#include "mem.h"
+
+typedef struct _reader {
+    char  base[0x00001000];
+    char *head;
+    char *end;
+    char *tail;
+    char *read_end; /* one past last character read */
+    char *pro;      /* protection start, buffer can not slide past this point */
+    char *str;      /* start of current string being read */
+    long  pos;
+    int   line;
+    int   col;
+    int   free_head;
+    int (*read_func)(struct _reader *reader);
+    union {
+        int         fd;
+        VALUE       io;
+        const char *in_str;
+    };
+} *Reader;
+
+extern void oj_reader_init(Reader reader, VALUE io, int fd, bool to_s);
+extern int  oj_reader_read(Reader reader);
+
+static inline char reader_get(Reader reader) {
+    // printf("*** drive get from '%s'  from start: %ld	buf: %p	 from read_end: %ld\n",
+    // reader->tail, reader->tail - reader->head, reader->head, reader->read_end - reader->tail);
+    if (reader->read_end <= reader->tail) {
+        if (0 != oj_reader_read(reader)) {
+            return '\0';
+        }
+    }
+    if ('\n' == *reader->tail) {
+        reader->line++;
+        reader->col = 0;
+    }
+    reader->col++;
+    reader->pos++;
+
+    return *reader->tail++;
+}
+
+static inline void reader_backup(Reader reader) {
+    reader->tail--;
+    reader->col--;
+    reader->pos--;
+    if (0 >= reader->col) {
+        reader->line--;
+        // allow col to be negative since we never backup twice in a row
+    }
+}
+
+static inline void reader_protect(Reader reader) {
+    reader->pro = reader->tail;
+    reader->str = reader->tail;  // can't have str before pro
+}
+
+static inline void reader_release(Reader reader) {
+    reader->pro = 0;
+}
+
+/* Starts by reading a character so it is safe to use with an empty or
+ * compacted buffer.
+ */
+static inline char reader_next_non_white(Reader reader) {
+    char c;
+
+    while ('\0' != (c = reader_get(reader))) {
+        switch (c) {
+        case ' ':
+        case '\t':
+        case '\f':
+        case '\n':
+        case '\r': break;
+        default: return c;
+        }
+    }
+    return '\0';
+}
+
+/* Starts by reading a character so it is safe to use with an empty or
+ * compacted buffer.
+ */
+static inline char reader_next_white(Reader reader) {
+    char c;
+
+    while ('\0' != (c = reader_get(reader))) {
+        switch (c) {
+        case ' ':
+        case '\t':
+        case '\f':
+        case '\n':
+        case '\r':
+        case '\0': return c;
+        default: break;
+        }
+    }
+    return '\0';
+}
+
+static inline int reader_expect(Reader reader, const char *s) {
+    for (; '\0' != *s; s++) {
+        if (reader_get(reader) != *s) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+static inline void reader_cleanup(Reader reader) {
+    if (reader->free_head && 0 != reader->head) {
+        OJ_R_FREE((char *)reader->head);
+        reader->head      = 0;
+        reader->free_head = 0;
+    }
+}
+
+static inline int is_white(char c) {
+    switch (c) {
+    case ' ':
+    case '\t':
+    case '\f':
+    case '\n':
+    case '\r': return 1;
+    default: break;
+    }
+    return 0;
+}
+
+#endif /* OJ_READER_H */

data/ext/oj_windows/resolve.c

@@ -0,0 +1,80 @@
+// Copyright (c) 2012 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+#include <pthread.h>
+#endif
+
+#include "err.h"
+#include "intern.h"
+#include "oj.h"
+#include "parse.h"
+
+inline static VALUE resolve_classname(VALUE mod, const char *classname, int auto_define) {
+    VALUE clas;
+    ID    ci = rb_intern(classname);
+
+    if (rb_const_defined_at(mod, ci)) {
+        clas = rb_const_get_at(mod, ci);
+    } else if (auto_define) {
+        clas = rb_define_class_under(mod, classname, oj_bag_class);
+    } else {
+        clas = Qundef;
+    }
+    return clas;
+}
+
+static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class) {
+    char        class_name[1024];
+    VALUE       clas;
+    char       *end = class_name + sizeof(class_name) - 1;
+    char       *s;
+    const char *n = name;
+
+    clas = rb_cObject;
+    for (s = class_name; 0 < len; n++, len--) {
+        if (':' == *n) {
+            *s = '\0';
+            n++;
+            len--;
+            if (':' != *n) {
+                return Qundef;
+            }
+            if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
+                return Qundef;
+            }
+            s = class_name;
+        } else if (end <= s) {
+            return Qundef;
+        } else {
+            *s++ = *n;
+        }
+    }
+    *s = '\0';
+    if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
+        oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class %s is not defined", name);
+        if (Qnil != error_class) {
+            pi->err_class = error_class;
+        }
+    }
+    return clas;
+}
+
+VALUE
+oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class) {
+    if (No == pi->options.class_cache) {
+        return resolve_classpath(pi, name, len, auto_define, error_class);
+    }
+    return oj_class_intern(name, len, true, pi, auto_define, error_class);
+}
+
+VALUE
+oj_name2struct(ParseInfo pi, VALUE nameVal, VALUE error_class) {
+    size_t      len = RSTRING_LEN(nameVal);
+    const char *str = StringValuePtr(nameVal);
+
+    return resolve_classpath(pi, str, len, 0, error_class);
+}

data/ext/oj_windows/resolve.h

@@ -0,0 +1,12 @@
+// Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OJ_RESOLVE_H
+#define OJ_RESOLVE_H
+
+#include "ruby.h"
+
+extern VALUE oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class);
+extern VALUE oj_name2struct(ParseInfo pi, VALUE nameVal, VALUE error_class);
+
+#endif /* OJ_RESOLVE_H */

data/ext/oj_windows/rxclass.c

@@ -0,0 +1,144 @@
+// Copyright (c) 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#if !IS_WINDOWS
+#include <regex.h>
+#endif
+
+#include "mem.h"
+#include "rxclass.h"
+
+typedef struct _rxC {
+    struct _rxC *next;
+    VALUE        rrx;
+#if !IS_WINDOWS
+    regex_t rx;
+#endif
+    VALUE clas;
+    char  src[256];
+} *RxC;
+
+void oj_rxclass_init(RxClass rc) {
+    *rc->err = '\0';
+    rc->head = NULL;
+    rc->tail = NULL;
+}
+
+void oj_rxclass_cleanup(RxClass rc) {
+    RxC rxc;
+
+    while (NULL != (rxc = rc->head)) {
+        rc->head = rc->head->next;
+#if !IS_WINDOWS
+        if (Qnil == rxc->rrx) {
+            regfree(&rxc->rx);
+        }
+        OJ_R_FREE(rxc);
+#endif
+    }
+}
+
+void oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas) {
+    RxC rxc = OJ_R_ALLOC_N(struct _rxC, 1);
+
+    memset(rxc, 0, sizeof(struct _rxC));
+    rxc->rrx  = rx;
+    rxc->clas = clas;
+    if (NULL == rc->tail) {
+        rc->head = rxc;
+    } else {
+        rc->tail->next = rxc;
+    }
+    rc->tail = rxc;
+}
+
+// Attempt to compile the expression. If it fails populate the error code..
+int oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
+    RxC rxc;
+#if !IS_WINDOWS
+    int err;
+    int flags = 0;
+#endif
+    if (sizeof(rxc->src) <= strlen(expr)) {
+        snprintf(rc->err,
+                 sizeof(rc->err),
+                 "expressions must be less than %lu characters",
+                 (unsigned long)sizeof(rxc->src));
+        return EINVAL;
+    }
+    rxc       = OJ_R_ALLOC_N(struct _rxC, 1);
+    rxc->next = 0;
+    rxc->clas = clas;
+
+#if IS_WINDOWS
+    rxc->rrx = rb_funcall(rb_cRegexp, rb_intern("new"), 1, rb_str_new2(expr));
+#else
+    rxc->rrx = Qnil;
+    if (0 != (err = regcomp(&rxc->rx, expr, flags))) {
+        regerror(err, &rxc->rx, rc->err, sizeof(rc->err));
+        OJ_FREE(rxc);
+        return err;
+    }
+#endif
+    if (NULL == rc->tail) {
+        rc->head = rxc;
+    } else {
+        rc->tail->next = rxc;
+    }
+    rc->tail = rxc;
+
+    return 0;
+}
+
+VALUE
+oj_rxclass_match(RxClass rc, const char *str, int len) {
+    RxC  rxc;
+    char buf[4096];
+
+    for (rxc = rc->head; NULL != rxc; rxc = rxc->next) {
+        if (Qnil != rxc->rrx) {
+            // Must use a valiabel for this to work.
+            volatile VALUE rstr = rb_str_new(str, len);
+
+            // if (Qtrue == rb_funcall(rxc->rrx, rb_intern("match?"), 1, rstr)) {
+            if (Qnil != rb_funcall(rxc->rrx, rb_intern("match"), 1, rstr)) {
+                return rxc->clas;
+            }
+        } else if (len < (int)sizeof(buf)) {
+#if !IS_WINDOWS
+            // string is not \0 terminated so copy and attempt a match
+            memcpy(buf, str, len);
+            buf[len] = '\0';
+            if (0 == regexec(&rxc->rx, buf, 0, NULL, 0)) {  // match
+                return rxc->clas;
+            }
+#endif
+        } else {
+            // TBD allocate a larger buffer and attempt
+        }
+    }
+    return Qnil;
+}
+
+void oj_rxclass_copy(RxClass src, RxClass dest) {
+    dest->head = NULL;
+    dest->tail = NULL;
+    if (NULL != src->head) {
+        RxC rxc;
+
+        for (rxc = src->head; NULL != rxc; rxc = rxc->next) {
+            if (Qnil != rxc->rrx) {
+                oj_rxclass_rappend(dest, rxc->rrx, rxc->clas);
+            } else {
+#if !IS_WINDOWS
+                oj_rxclass_append(dest, rxc->src, rxc->clas);
+#endif
+            }
+        }
+    }
+}

data/ext/oj_windows/rxclass.h

@@ -0,0 +1,26 @@
+// Copyright (c) 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OJ_RXCLASS_H
+#define OJ_RXCLASS_H
+
+#include <stdbool.h>
+
+#include "ruby.h"
+
+struct _rxC;
+
+typedef struct _rxClass {
+    struct _rxC *head;
+    struct _rxC *tail;
+    char         err[128];
+} *RxClass;
+
+extern void  oj_rxclass_init(RxClass rc);
+extern void  oj_rxclass_cleanup(RxClass rc);
+extern int   oj_rxclass_append(RxClass rc, const char *expr, VALUE clas);
+extern VALUE oj_rxclass_match(RxClass rc, const char *str, int len);
+extern void  oj_rxclass_copy(RxClass src, RxClass dest);
+extern void  oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas);
+
+#endif /* OJ_RXCLASS_H */