oj 2.18.5 → 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

@@ -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/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/val_stack.c

@@ -1,98 +1,101 @@
-/* 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 "oj.h"
 #include "val_stack.h"
 
-static void
-mark(void *ptr) {
-    ValStack	stack = (ValStack)ptr;
-    Val		v;
+#include <string.h>
+
+#include "odd.h"
+#include "oj.h"
 
-    if (0 == ptr) {
-	return;
+static void stack_mark(void *ptr) {
+    ValStack stack = (ValStack)ptr;
+    Val      v;
+
+    if (NULL == ptr) {
+        return;
     }
-#if USE_PTHREAD_MUTEX
+#ifdef HAVE_PTHREAD_MUTEX_INIT
     pthread_mutex_lock(&stack->mutex);
-#elif USE_RB_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 (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);
+                }
+            }
+        }
     }
-#if USE_PTHREAD_MUTEX
+#ifdef HAVE_PTHREAD_MUTEX_INIT
     pthread_mutex_unlock(&stack->mutex);
-#elif USE_RB_MUTEX
+#else
     rb_mutex_unlock(stack->mutex);
 #endif
 }
 
+static const rb_data_type_t oj_stack_type = {
+    "Oj/stack",
+    {
+        stack_mark,
+        NULL,
+        NULL,
+    },
+    0,
+    0,
+};
+
 VALUE
 oj_stack_init(ValStack stack) {
-#if USE_PTHREAD_MUTEX
-    pthread_mutex_init(&stack->mutex, 0);
-#elif USE_RB_MUTEX
+#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 = 0;
-    stack->head->key_val = Qundef;
-    stack->head->classname = 0;
-    stack->head->klen = 0;
-    stack->head->clen = 0;
-    stack->head->next = NEXT_NONE;
-    return Data_Wrap_Struct(oj_cstack_class, mark, 0, stack);
+    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) {
+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";
 }

data/ext/oj/val_stack.h

@@ -1,184 +1,151 @@
-/* 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__
+// 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 "ruby.h"
-#include "odd.h"
 #include <stdint.h>
-#if USE_PTHREAD_MUTEX
+
+#include "mem.h"
+#include "odd.h"
+#include "ruby.h"
+#ifdef HAVE_PTHREAD_MUTEX_INIT
 #include <pthread.h>
 #endif
 
-#define STACK_INC	64
+#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',
+    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;
-    union {
-	const char	*classname;
-	OddArgs		odd_args;
-    };
-    uint16_t		klen;
-    uint16_t		clen;
-    char		next; // ValNext
-    char		k1;   // first original character in the key
-    char		kalloc;
+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
-#if USE_PTHREAD_MUTEX
-    pthread_mutex_t	mutex;
-#elif USE_RB_MUTEX
-    VALUE		mutex;
+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);
+extern VALUE oj_stack_init(ValStack stack);
 
-inline static int
-stack_empty(ValStack stack) {
+inline static int stack_empty(ValStack stack) {
     return (stack->head == stack->tail);
 }
 
-inline static void
-stack_cleanup(ValStack stack) {
+inline static void stack_cleanup(ValStack stack) {
     if (stack->base != stack->head) {
-        xfree(stack->head);
-	stack->head = NULL;
+        OJ_R_FREE(stack->head);
+        stack->head = NULL;
     }
 }
 
-inline static void
-stack_push(ValStack stack, VALUE val, ValNext next) {
+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);
-	}
-#if USE_PTHREAD_MUTEX
-	pthread_mutex_lock(&stack->mutex);
-#elif USE_RB_MUTEX
-	rb_mutex_lock(stack->mutex);
+        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;
-#if USE_PTHREAD_MUTEX
-	pthread_mutex_unlock(&stack->mutex);
-#elif USE_RB_MUTEX
-	rb_mutex_unlock(stack->mutex);
+        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 = 0;
-    stack->tail->key = 0;
-    stack->tail->key_val = Qundef;
-    stack->tail->clen = 0;
-    stack->tail->klen = 0;
-    stack->tail->kalloc = 0;
+    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) {
+inline static size_t stack_size(ValStack stack) {
     return stack->tail - stack->head;
 }
 
-inline static Val
-stack_peek(ValStack stack) {
+inline static Val stack_peek(ValStack stack) {
     if (stack->head < stack->tail) {
-	return stack->tail - 1;
+        return stack->tail - 1;
     }
     return 0;
 }
 
-inline static Val
-stack_peek_up(ValStack stack) {
+inline static Val stack_peek_up(ValStack stack) {
     if (stack->head < stack->tail - 1) {
-	return stack->tail - 2;
+        return stack->tail - 2;
     }
     return 0;
 }
 
-inline static Val
-stack_prev(ValStack stack) {
+inline static Val stack_prev(ValStack stack) {
     return stack->tail;
 }
 
-inline static VALUE
-stack_head_val(ValStack stack) {
+inline static VALUE stack_head_val(ValStack stack) {
     if (Qundef != stack->head->val) {
-	return stack->head->val;
+        return stack->head->val;
     }
     return Qnil;
 }
 
-inline static Val
-stack_pop(ValStack stack) {
+inline static Val stack_pop(ValStack stack) {
     if (stack->head < stack->tail) {
-	stack->tail--;
-	return stack->tail;
+        stack->tail--;
+        return stack->tail;
     }
     return 0;
 }
 
-extern const char*	oj_stack_next_string(ValNext n);
+extern const char *oj_stack_next_string(ValNext n);
 
-#endif /* __OJ_VAL_STACK_H__ */
+#endif /* OJ_VAL_STACK_H */