oj 3.11.3 → 3.11.8

data/ext/oj/trace.c

@@ -1,27 +1,27 @@
 // Copyright (c) 2018 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
-#include "parse.h"
 #include "trace.h"
 
-#define MAX_INDENT	256
+#include "parse.h"
+
+#define MAX_INDENT 256
 
-static void
-fill_indent(char *indent, int depth) {
+static void fill_indent(char *indent, int depth) {
     if (MAX_INDENT <= depth) {
-	depth = MAX_INDENT - 1;
+        depth = MAX_INDENT - 1;
     } else if (depth < 0) {
-	depth = 0;
+        depth = 0;
     }
     if (0 < depth) {
-	memset(indent, ' ', 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];
+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);
@@ -29,46 +29,42 @@ oj_trace(const char *func, VALUE obj, const char *file, int line, int depth, Tra
     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);
+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);
+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;
+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);
+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);

data/ext/oj/trace.h

@@ -1,25 +1,28 @@
 // Copyright (c) 2018 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
 #ifndef OJ_TRACE_H
 #define OJ_TRACE_H
 
-#include <stdbool.h>
 #include <ruby.h>
+#include <stdbool.h>
 
 typedef enum {
-    TraceIn		= '}',
-    TraceOut		= '{',
-    TraceCall		= '-',
-    TraceRubyIn		= '>',
-    TraceRubyOut	= '<',
+    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);
+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

@@ -1,4 +1,5 @@
 // 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 = (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 = (int)(secs / 86400LL);
-    secs = secs - (int64_t)ti->day * 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;
+    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.
+// 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,18 +1,19 @@
 // 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 mark(void *ptr) {
+    ValStack stack = (ValStack)ptr;
+    Val      v;
 
     if (0 == ptr) {
-	return;
+        return;
     }
 #ifdef HAVE_PTHREAD_MUTEX_INIT
     pthread_mutex_lock(&stack->mutex);
@@ -21,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);
@@ -48,43 +49,42 @@ mark(void *ptr) {
 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);
 }
 
-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";
 }