oj 3.9.1 → 3.16.11

data/ext/oj/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/util.c

@@ -1,4 +1,5 @@
-// Copyright (c) 2019, Peter Ohler, All rights reserved.
+// 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"
 
@@ -8,129 +9,128 @@
 #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)
+#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_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)
+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;
 
-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
+    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;
+        shift = -secs / SECS_PER_QUAD_CENT;
+        shift++;
+        secs += shift * SECS_PER_QUAD_CENT;
     }
-    qc = secs / SECS_PER_QUAD_CENT;
+    qc   = secs / SECS_PER_QUAD_CENT;
     secs = secs - qc * SECS_PER_QUAD_CENT;
     if (secs < SECS_PER_LEAP) {
-	leap = true;
+        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++;
-	}
+        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++;
-	    }
-	}
+        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 = (qc - shift) * 400 + c * 100 + qy * 4 + y;
+    ti->year = (int)((qc - (int64_t)shift) * 400 + c * 100 + qy * 4 + y);
     if (leap) {
-	ms = eom_leap_secs;
+        ms = eom_leap_secs;
     } else {
-	ms = eom_secs;
+        ms = eom_secs;
     }
     for (m = 1; m <= 12; m++, ms++) {
-	if (secs < *ms) {
-	    if (1 < m) {
-		secs -= *(ms - 1);
-	    }
-	    ti->mon = m;
-	    break;
-	}
+        if (secs < *ms) {
+            if (1 < m) {
+                secs -= *(ms - 1);
+            }
+            ti->mon = m;
+            break;
+        }
     }
-    ti->day = secs / 86400LL;
-    secs = secs - (int64_t)ti->day * 86400LL;
+    ti->day = (int)(secs / 86400LL);
+    secs    = secs - (int64_t)ti->day * 86400LL;
     ti->day++;
-    ti->hour = secs / 3600LL;
-    secs = secs - (int64_t)ti->hour * 3600LL;
-    ti->min = secs / 60LL;
-    secs = secs - (int64_t)ti->min * 60LL;
-    ti->sec = secs;
+    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/util.h

@@ -1,4 +1,5 @@
-// Copyright (c) 2019, Peter Ohler, All rights reserved.
+// 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
@@ -12,8 +13,8 @@ typedef struct _timeInfo {
     int day;
     int mon;
     int year;
-} *TimeInfo;
+}* TimeInfo;
 
-extern void	sec_as_time(int64_t secs, TimeInfo ti);
+extern void sec_as_time(int64_t secs, TimeInfo ti);
 
 #endif /* OJ_UTIL_H */

data/ext/oj/val_stack.c

@@ -1,46 +1,19 @@
-/* val_stack.c
- * Copyright (c) 2011, Peter Ohler
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  - Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- *
- *  - 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.
- *
- *  - Neither the name of Peter Ohler 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.
- */
+// 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 "oj.h"
 #include "odd.h"
-#include "val_stack.h"
+#include "oj.h"
 
-static void
-mark(void *ptr) {
-    ValStack	stack = (ValStack)ptr;
-    Val		v;
+static void stack_mark(void *ptr) {
+    ValStack stack = (ValStack)ptr;
+    Val      v;
 
-    if (0 == ptr) {
-	return;
+    if (NULL == ptr) {
+        return;
     }
 #ifdef HAVE_PTHREAD_MUTEX_INIT
     pthread_mutex_lock(&stack->mutex);
@@ -49,22 +22,22 @@ mark(void *ptr) {
     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;
+        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);
-		}
-	    }
-	}
+            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);
@@ -73,46 +46,56 @@ mark(void *ptr) {
 #endif
 }
 
+static const rb_data_type_t oj_stack_type = {
+    "Oj/stack",
+    {
+        stack_mark,
+        NULL,
+        NULL,
+    },
+    0,
+    0,
+};
+
 VALUE
 oj_stack_init(ValStack stack) {
 #ifdef HAVE_PTHREAD_MUTEX_INIT
-    int	err;
+    int err;
 
     if (0 != (err = pthread_mutex_init(&stack->mutex, 0))) {
-	rb_raise(rb_eException, "failed to initialize a mutex. %s", strerror(err));
+        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            = 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;
+    stack->head->odd_args  = NULL;
+    stack->head->clas      = Qundef;
+    stack->head->klen      = 0;
+    stack->head->clen      = 0;
+    stack->head->next      = NEXT_NONE;
 
-    return Data_Wrap_Struct(oj_cstack_class, mark, 0, stack);
+    return TypedData_Wrap_Struct(oj_cstack_class, &oj_stack_type, stack);
 }
 
-const char*
-oj_stack_next_string(ValNext n) {
+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;
+    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";
 }