oj_windows 3.16.15

data/ext/oj_windows/usual.h

@@ -0,0 +1,69 @@
+// Copyright (c) 2022, Peter Ohler, All rights reserved.
+
+#include <ruby.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+struct _cache;
+struct _ojParser;
+
+// Used to mark the start of each Hash, Array, or Object. The members point at
+// positions of the start in the value stack and if not an Array into the key
+// stack.
+typedef struct _col {
+    long vi;  // value stack index
+    long ki;  // key stack index if an hash else -1 for an array
+} *Col;
+
+typedef union _key {
+    struct {
+        int16_t len;
+        char    buf[30];
+    };
+    struct {
+        int16_t xlen;  // should be the same as len
+        char   *key;
+    };
+} *Key;
+
+#define MISS_AUTO 'A'
+#define MISS_RAISE 'R'
+#define MISS_IGNORE 'I'
+
+typedef struct _usual {
+    VALUE *vhead;
+    VALUE *vtail;
+    VALUE *vend;
+
+    Col chead;
+    Col ctail;
+    Col cend;
+
+    Key khead;
+    Key ktail;
+    Key kend;
+
+    VALUE (*get_key)(struct _ojParser *p, Key kp);
+    struct _cache *key_cache;  // same as str_cache or sym_cache
+    struct _cache *str_cache;
+    struct _cache *sym_cache;
+    struct _cache *class_cache;
+    struct _cache *attr_cache;
+
+    VALUE array_class;
+    VALUE hash_class;
+
+    char   *create_id;
+    uint8_t create_id_len;
+    uint8_t cache_str;
+    uint8_t cache_xrate;
+    uint8_t miss_class;
+    bool    cache_keys;
+    bool    ignore_json_create;
+    bool    raise_on_empty;
+} *Usual;
+
+// Initialize the parser with the usual delegate. If the usual delegate is
+// wrapped then this function is called first and then the parser functions
+// can be replaced.
+extern void oj_init_usual(struct _ojParser *p, Usual d);

data/ext/oj_windows/util.c

@@ -0,0 +1,136 @@
+// Copyright (c) 2019 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include "util.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#define SECS_PER_DAY 86400LL
+#define SECS_PER_YEAR 31536000LL
+#define SECS_PER_LEAP 31622400LL
+#define SECS_PER_QUAD_YEAR (SECS_PER_YEAR * 3 + SECS_PER_LEAP)
+#define SECS_PER_CENT (SECS_PER_QUAD_YEAR * 24 + SECS_PER_YEAR * 4)
+#define SECS_PER_LEAP_CENT (SECS_PER_CENT + SECS_PER_DAY)
+#define SECS_PER_QUAD_CENT (SECS_PER_CENT * 4 + SECS_PER_DAY)
+
+static int64_t eom_secs[] = {
+    2678400,   // January (31)
+    5097600,   // February (28)	2419200	 2505600
+    7776000,   // March (31)
+    10368000,  // April (30  2592000
+    13046400,  // May (31)
+    15638400,  // June (30)
+    18316800,  // July (31)
+    20995200,  // August (31)
+    23587200,  // September (30)
+    26265600,  // October (31)
+    28857600,  // November (30)
+    31536000,  // December (31)
+};
+
+static int64_t eom_leap_secs[] = {
+    2678400,   // January (31)
+    5184000,   // February (28)	2419200	 2505600
+    7862400,   // March (31)
+    10454400,  // April (30  2592000
+    13132800,  // May (31)
+    15724800,  // June (30)
+    18403200,  // July (31)
+    21081600,  // August (31)
+    23673600,  // September (30)
+    26352000,  // October (31)
+    28944000,  // November (30)
+    31622400,  // December (31)
+};
+
+void sec_as_time(int64_t secs, TimeInfo ti) {
+    int64_t  qc   = 0;
+    int64_t  c    = 0;
+    int64_t  qy   = 0;
+    int64_t  y    = 0;
+    bool     leap = false;
+    int64_t *ms;
+    int      m;
+    int      shift = 0;
+
+    secs += 62167219200LL;  // normalize to first day of the year 0
+    if (secs < 0) {
+        shift = -secs / SECS_PER_QUAD_CENT;
+        shift++;
+        secs += shift * SECS_PER_QUAD_CENT;
+    }
+    qc   = secs / SECS_PER_QUAD_CENT;
+    secs = secs - qc * SECS_PER_QUAD_CENT;
+    if (secs < SECS_PER_LEAP) {
+        leap = true;
+    } else if (secs < SECS_PER_QUAD_YEAR) {
+        if (SECS_PER_LEAP <= secs) {
+            secs -= SECS_PER_LEAP;
+            y    = secs / SECS_PER_YEAR;
+            secs = secs - y * SECS_PER_YEAR;
+            y++;
+            leap = false;
+        }
+    } else if (secs < SECS_PER_LEAP_CENT) {  // first century in 400 years is a leap century (one
+                                             // extra day)
+        qy   = secs / SECS_PER_QUAD_YEAR;
+        secs = secs - qy * SECS_PER_QUAD_YEAR;
+        if (secs < SECS_PER_LEAP) {
+            leap = true;
+        } else {
+            secs -= SECS_PER_LEAP;
+            y    = secs / SECS_PER_YEAR;
+            secs = secs - y * SECS_PER_YEAR;
+            y++;
+        }
+    } else {
+        secs -= SECS_PER_LEAP_CENT;
+        c    = secs / SECS_PER_CENT;
+        secs = secs - c * SECS_PER_CENT;
+        c++;
+        if (secs < SECS_PER_YEAR * 4) {
+            y    = secs / SECS_PER_YEAR;
+            secs = secs - y * SECS_PER_YEAR;
+        } else {
+            secs -= SECS_PER_YEAR * 4;
+            qy   = secs / SECS_PER_QUAD_YEAR;
+            secs = secs - qy * SECS_PER_QUAD_YEAR;
+            qy++;
+            if (secs < SECS_PER_LEAP) {
+                leap = true;
+            } else {
+                secs -= SECS_PER_LEAP;
+                y    = secs / SECS_PER_YEAR;
+                secs = secs - y * SECS_PER_YEAR;
+                y++;
+            }
+        }
+    }
+    ti->year = (int)((qc - (int64_t)shift) * 400 + c * 100 + qy * 4 + y);
+    if (leap) {
+        ms = eom_leap_secs;
+    } else {
+        ms = eom_secs;
+    }
+    for (m = 1; m <= 12; m++, ms++) {
+        if (secs < *ms) {
+            if (1 < m) {
+                secs -= *(ms - 1);
+            }
+            ti->mon = m;
+            break;
+        }
+    }
+    ti->day = (int)(secs / 86400LL);
+    secs    = secs - (int64_t)ti->day * 86400LL;
+    ti->day++;
+    ti->hour = (int)(secs / 3600LL);
+    secs     = secs - (int64_t)ti->hour * 3600LL;
+    ti->min  = (int)(secs / 60LL);
+    secs     = secs - (int64_t)ti->min * 60LL;
+    ti->sec  = (int)secs;
+}

data/ext/oj_windows/util.h

@@ -0,0 +1,20 @@
+// Copyright (c) 2019 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OJ_UTIL_H
+#define OJ_UTIL_H
+
+#include <stdint.h>
+
+typedef struct _timeInfo {
+    int sec;
+    int min;
+    int hour;
+    int day;
+    int mon;
+    int year;
+}* TimeInfo;
+
+extern void sec_as_time(int64_t secs, TimeInfo ti);
+
+#endif /* OJ_UTIL_H */

data/ext/oj_windows/val_stack.c

@@ -0,0 +1,101 @@
+// Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include "val_stack.h"
+
+#include <string.h>
+
+#include "odd.h"
+#include "oj.h"
+
+static void stack_mark(void *ptr) {
+    ValStack stack = (ValStack)ptr;
+    Val      v;
+
+    if (NULL == ptr) {
+        return;
+    }
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_lock(&stack->mutex);
+#else
+    rb_mutex_lock(stack->mutex);
+    rb_gc_mark(stack->mutex);
+#endif
+    for (v = stack->head; v < stack->tail; v++) {
+        if (Qnil != v->val && Qundef != v->val) {
+            rb_gc_mark(v->val);
+        }
+        if (Qnil != v->key_val && Qundef != v->key_val) {
+            rb_gc_mark(v->key_val);
+        }
+        if (NULL != v->odd_args) {
+            VALUE *a;
+            int    i;
+
+            for (i = v->odd_args->odd->attr_cnt, a = v->odd_args->args; 0 < i; i--, a++) {
+                if (Qnil != *a) {
+                    rb_gc_mark(*a);
+                }
+            }
+        }
+    }
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_unlock(&stack->mutex);
+#else
+    rb_mutex_unlock(stack->mutex);
+#endif
+}
+
+static const rb_data_type_t oj_stack_type = {
+    "oj_windows/stack",
+    {
+        stack_mark,
+        NULL,
+        NULL,
+    },
+    0,
+    0,
+};
+
+VALUE
+oj_stack_init(ValStack stack) {
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+    int err;
+
+    if (0 != (err = pthread_mutex_init(&stack->mutex, 0))) {
+        rb_raise(rb_eException, "failed to initialize a mutex. %s", strerror(err));
+    }
+#else
+    stack->mutex = rb_mutex_new();
+#endif
+    stack->head            = stack->base;
+    stack->end             = stack->base + sizeof(stack->base) / sizeof(struct _val);
+    stack->tail            = stack->head;
+    stack->head->val       = Qundef;
+    stack->head->key       = NULL;
+    stack->head->key_val   = Qundef;
+    stack->head->classname = NULL;
+    stack->head->odd_args  = NULL;
+    stack->head->clas      = Qundef;
+    stack->head->klen      = 0;
+    stack->head->clen      = 0;
+    stack->head->next      = NEXT_NONE;
+
+    return TypedData_Wrap_Struct(oj_cstack_class, &oj_stack_type, stack);
+}
+
+const char *oj_stack_next_string(ValNext n) {
+    switch (n) {
+    case NEXT_ARRAY_NEW: return "array element or close";
+    case NEXT_ARRAY_ELEMENT: return "array element";
+    case NEXT_ARRAY_COMMA: return "comma";
+    case NEXT_HASH_NEW: return "hash pair or close";
+    case NEXT_HASH_KEY: return "hash key";
+    case NEXT_HASH_COLON: return "colon";
+    case NEXT_HASH_VALUE: return "hash value";
+    case NEXT_HASH_COMMA: return "comma";
+    case NEXT_NONE: break;
+    default: break;
+    }
+    return "nothing";
+}

data/ext/oj_windows/val_stack.h

@@ -0,0 +1,151 @@
+// 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_VAL_STACK_H
+#define OJ_VAL_STACK_H
+
+#include <stdint.h>
+
+#include "mem.h"
+#include "odd.h"
+#include "ruby.h"
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+#include <pthread.h>
+#endif
+
+#define STACK_INC 64
+
+typedef enum {
+    NEXT_NONE          = 0,
+    NEXT_ARRAY_NEW     = 'a',
+    NEXT_ARRAY_ELEMENT = 'e',
+    NEXT_ARRAY_COMMA   = ',',
+    NEXT_HASH_NEW      = 'h',
+    NEXT_HASH_KEY      = 'k',
+    NEXT_HASH_COLON    = ':',
+    NEXT_HASH_VALUE    = 'v',
+    NEXT_HASH_COMMA    = 'n',
+} ValNext;
+
+typedef struct _val {
+    volatile VALUE val;
+    const char    *key;
+    char           karray[32];
+    volatile VALUE key_val;
+    const char    *classname;
+    VALUE          clas;
+    OddArgs        odd_args;
+    uint16_t       klen;
+    uint16_t       clen;
+    char           next;  // ValNext
+    char           k1;    // first original character in the key
+    char           kalloc;
+} *Val;
+
+typedef struct _valStack {
+    struct _val base[STACK_INC];
+    Val         head;  // current stack
+    Val         end;   // stack end
+    Val         tail;  // pointer to one past last element name on stack
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+    pthread_mutex_t mutex;
+#else
+    VALUE mutex;
+#endif
+
+} *ValStack;
+
+extern VALUE oj_stack_init(ValStack stack);
+
+inline static int stack_empty(ValStack stack) {
+    return (stack->head == stack->tail);
+}
+
+inline static void stack_cleanup(ValStack stack) {
+    if (stack->base != stack->head) {
+        OJ_R_FREE(stack->head);
+        stack->head = NULL;
+    }
+}
+
+inline static void stack_push(ValStack stack, VALUE val, ValNext next) {
+    if (stack->end <= stack->tail) {
+        size_t len  = stack->end - stack->head;
+        size_t toff = stack->tail - stack->head;
+        Val    head = stack->head;
+
+        // A realloc can trigger a GC so make sure it happens outside the lock
+        // but lock before changing pointers.
+        if (stack->base == stack->head) {
+            head = OJ_R_ALLOC_N(struct _val, len + STACK_INC);
+            memcpy(head, stack->base, sizeof(struct _val) * len);
+        } else {
+            OJ_R_REALLOC_N(head, struct _val, len + STACK_INC);
+        }
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+        pthread_mutex_lock(&stack->mutex);
+#else
+        rb_mutex_lock(stack->mutex);
+#endif
+        stack->head = head;
+        stack->tail = stack->head + toff;
+        stack->end  = stack->head + len + STACK_INC;
+#ifdef HAVE_PTHREAD_MUTEX_INIT
+        pthread_mutex_unlock(&stack->mutex);
+#else
+        rb_mutex_unlock(stack->mutex);
+#endif
+    }
+    stack->tail->val       = val;
+    stack->tail->next      = next;
+    stack->tail->classname = NULL;
+    stack->tail->clas      = Qundef;
+    stack->tail->odd_args  = NULL;
+    stack->tail->key       = 0;
+    stack->tail->key_val   = Qundef;
+    stack->tail->clen      = 0;
+    stack->tail->klen      = 0;
+    stack->tail->kalloc    = 0;
+    stack->tail++;
+}
+
+inline static size_t stack_size(ValStack stack) {
+    return stack->tail - stack->head;
+}
+
+inline static Val stack_peek(ValStack stack) {
+    if (stack->head < stack->tail) {
+        return stack->tail - 1;
+    }
+    return 0;
+}
+
+inline static Val stack_peek_up(ValStack stack) {
+    if (stack->head < stack->tail - 1) {
+        return stack->tail - 2;
+    }
+    return 0;
+}
+
+inline static Val stack_prev(ValStack stack) {
+    return stack->tail;
+}
+
+inline static VALUE stack_head_val(ValStack stack) {
+    if (Qundef != stack->head->val) {
+        return stack->head->val;
+    }
+    return Qnil;
+}
+
+inline static Val stack_pop(ValStack stack) {
+    if (stack->head < stack->tail) {
+        stack->tail--;
+        return stack->tail;
+    }
+    return 0;
+}
+
+extern const char *oj_stack_next_string(ValNext n);
+
+#endif /* OJ_VAL_STACK_H */

data/ext/oj_windows/validate.c

@@ -0,0 +1,46 @@
+// Copyright (c) 2021, Peter Ohler, All rights reserved.
+
+#include "parser.h"
+
+static void noop(ojParser p) {
+}
+
+static VALUE option(ojParser p, const char *key, VALUE value) {
+    rb_raise(rb_eArgError, "%s is not an option for the validate delegate", key);
+    return Qnil;
+}
+
+static VALUE result(ojParser p) {
+    return Qnil;
+}
+
+static void dfree(ojParser p) {
+}
+
+static void mark(ojParser p) {
+}
+
+void oj_set_parser_validator(ojParser p) {
+    Funcs end = p->funcs + 3;
+    Funcs f;
+    p->ctx = NULL;
+
+    for (f = p->funcs; f < end; f++) {
+        f->add_null     = noop;
+        f->add_true     = noop;
+        f->add_false    = noop;
+        f->add_int      = noop;
+        f->add_float    = noop;
+        f->add_big      = noop;
+        f->add_str      = noop;
+        f->open_array   = noop;
+        f->close_array  = noop;
+        f->open_object  = noop;
+        f->close_object = noop;
+    }
+    p->option = option;
+    p->result = result;
+    p->free   = dfree;
+    p->mark   = mark;
+    p->start  = noop;
+}