oj 3.10.7

data/ext/oj/trace.c

@@ -0,0 +1,79 @@
+/* trace.h
+ * Copyright (c) 2018, Peter Ohler
+ * All rights reserved.
+ */
+
+#include "parse.h"
+#include "trace.h"
+
+#define MAX_INDENT	256
+
+static void
+fill_indent(char *indent, int depth) {
+    if (MAX_INDENT <= depth) {
+	depth = MAX_INDENT - 1;
+    } else if (depth < 0) {
+	depth = 0;
+    }
+    if (0 < depth) {
+	memset(indent, ' ', depth);
+    }
+    indent[depth] = '\0';
+}
+
+void
+oj_trace(const char *func, VALUE obj, const char *file, int line, int depth, TraceWhere where) {
+    char	fmt[64];
+    char	indent[MAX_INDENT];
+
+    depth *= 2;
+    fill_indent(indent, depth);
+    sprintf(fmt, "#0:%%13s:%%3d:Oj:%c:%%%ds %%s %%s\n", where, depth);
+    printf(fmt, file, line, indent, func, rb_obj_classname(obj));
+}
+
+void
+oj_trace_parse_call(const char *func, ParseInfo pi, const char *file, int line, VALUE obj) {
+    char	fmt[64];
+    char	indent[MAX_INDENT];
+    int		depth = (int)(stack_size(&pi->stack) * 2);
+    
+    fill_indent(indent, depth);
+    sprintf(fmt, "#0:%%13s:%%3d:Oj:-:%%%ds %%s %%s\n", depth);
+    printf(fmt, file, line, indent, func, rb_obj_classname(obj));
+}
+
+void
+oj_trace_parse_in(const char *func, ParseInfo pi, const char *file, int line) {
+    char	fmt[64];
+    char	indent[MAX_INDENT];
+    int		depth = (int)(stack_size(&pi->stack) * 2);
+    
+    fill_indent(indent, depth);
+    sprintf(fmt, "#0:%%13s:%%3d:Oj:}:%%%ds %%s\n", depth);
+    printf(fmt, file, line, indent, func);
+}
+
+void
+oj_trace_parse_hash_end(ParseInfo pi, const char *file, int line) {
+    char	fmt[64];
+    char	indent[MAX_INDENT];
+    int		depth = (int)(stack_size(&pi->stack) * 2 - 2);
+    Val		v = stack_peek(&pi->stack);
+    VALUE	obj = v->val;
+    
+    fill_indent(indent, depth);
+    sprintf(fmt, "#0:%%13s:%%3d:Oj:{:%%%ds hash_end %%s\n", depth);
+    printf(fmt, file, line, indent, rb_obj_classname(obj));
+}
+
+void
+oj_trace_parse_array_end(ParseInfo pi, const char *file, int line) {
+    char	fmt[64];
+    char	indent[MAX_INDENT];
+    int		depth = (int)(stack_size(&pi->stack) * 2);
+    
+    fill_indent(indent, depth);
+    sprintf(fmt, "#0:%%13s:%%3d:Oj:{:%%%ds array_ned\n", depth);
+    printf(fmt, file, line, indent);
+}

data/ext/oj/trace.h

@@ -0,0 +1,28 @@
+/* trace.h
+ * Copyright (c) 2018, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef OJ_TRACE_H
+#define OJ_TRACE_H
+
+#include <stdbool.h>
+#include <ruby.h>
+
+typedef enum {
+    TraceIn		= '}',
+    TraceOut		= '{',
+    TraceCall		= '-',
+    TraceRubyIn		= '>',
+    TraceRubyOut	= '<',
+} TraceWhere;
+
+struct _parseInfo;
+
+extern void	oj_trace(const char *func, VALUE obj, const char *file, int line, int depth, TraceWhere where);
+extern void	oj_trace_parse_in(const char *func, struct _parseInfo *pi, const char *file, int line);
+extern void	oj_trace_parse_call(const char *func, struct _parseInfo *pi, const char *file, int line, VALUE obj);
+extern void	oj_trace_parse_hash_end(struct _parseInfo *pi, const char *file, int line);
+extern void	oj_trace_parse_array_end(struct _parseInfo *pi, const char *file, int line);
+
+#endif /* OJ_TRACE_H */

data/ext/oj/util.c

@@ -0,0 +1,136 @@
+// Copyright (c) 2019, Peter Ohler, All rights reserved.
+
+#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/util.h

@@ -0,0 +1,19 @@
+// Copyright (c) 2019, Peter Ohler, All rights reserved.
+
+#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/val_stack.c

@@ -0,0 +1,118 @@
+/* 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.
+ */
+
+#include <string.h>
+
+#include "oj.h"
+#include "odd.h"
+#include "val_stack.h"
+
+static void
+mark(void *ptr) {
+    ValStack	stack = (ValStack)ptr;
+    Val		v;
+
+    if (0 == 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
+}
+
+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 Data_Wrap_Struct(oj_cstack_class, mark, 0, 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/val_stack.h

@@ -0,0 +1,185 @@
+/* val_stack.h
+ * 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.
+ */
+
+#ifndef OJ_VAL_STACK_H
+#define OJ_VAL_STACK_H
+
+#include "ruby.h"
+#include "odd.h"
+#include <stdint.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) {
+        xfree(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 = ALLOC_N(struct _val, len + STACK_INC);
+	    memcpy(head, stack->base, sizeof(struct _val) * len);
+	} else {
+	    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 */