oj 3.11.3 → 3.11.8

data/ext/oj/rails.h

@@ -1,18 +1,18 @@
 // Copyright (c) 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
 #ifndef OJ_RAILS_H
 #define OJ_RAILS_H
 
 #include "dump.h"
 
-extern void	oj_mimic_rails_init();
-extern ROpt	oj_rails_get_opt(ROptTable rot, VALUE clas);
+extern void oj_mimic_rails_init();
+extern ROpt oj_rails_get_opt(ROptTable rot, VALUE clas);
 
-extern bool	oj_rails_hash_opt;
-extern bool	oj_rails_array_opt;
-extern bool	oj_rails_float_opt;
-
-extern VALUE	oj_optimize_rails(VALUE self);
+extern bool oj_rails_hash_opt;
+extern bool oj_rails_array_opt;
+extern bool oj_rails_float_opt;
 
+extern VALUE oj_optimize_rails(VALUE self);
 
 #endif /* OJ_RAILS_H */

data/ext/oj/reader.c

@@ -1,220 +1,215 @@
 // Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
-#include <stdlib.h>
 #include <errno.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <strings.h>
 #include <sys/types.h>
 #if NEEDS_UIO
 #include <sys/uio.h>
 #endif
-#include <unistd.h>
 #include <time.h>
+#include <unistd.h>
 
-#include "ruby.h"
 #include "oj.h"
 #include "reader.h"
+#include "ruby.h"
 
-#define BUF_PAD	4
-
-static VALUE		rescue_cb(VALUE rdr, VALUE err);
-static VALUE		io_cb(VALUE rdr);
-static VALUE		partial_io_cb(VALUE rdr);
-static int		read_from_io(Reader reader);
-static int		read_from_fd(Reader reader);
-static int		read_from_io_partial(Reader reader);
-//static int		read_from_str(Reader reader);
-
-void
-oj_reader_init(Reader reader, VALUE io, int fd, bool to_s) {
-    VALUE	io_class = rb_obj_class(io);
-    VALUE	stat;
-    VALUE	ftype;
-
-    reader->head = reader->base;
-    *((char*)reader->head) = '\0';
-    reader->end = reader->head + sizeof(reader->base) - BUF_PAD;
-    reader->tail = reader->head;
-    reader->read_end = reader->head;
-    reader->pro = 0;
-    reader->str = 0;
-    reader->pos = 0;
-    reader->line = 1;
-    reader->col = 0;
-    reader->free_head = 0;
+#define BUF_PAD 4
+
+static VALUE rescue_cb(VALUE rdr, VALUE err);
+static VALUE io_cb(VALUE rdr);
+static VALUE partial_io_cb(VALUE rdr);
+static int   read_from_io(Reader reader);
+static int   read_from_fd(Reader reader);
+static int   read_from_io_partial(Reader reader);
+// static int		read_from_str(Reader reader);
+
+void oj_reader_init(Reader reader, VALUE io, int fd, bool to_s) {
+    VALUE io_class = rb_obj_class(io);
+    VALUE stat;
+    VALUE ftype;
+
+    reader->head            = reader->base;
+    *((char *)reader->head) = '\0';
+    reader->end             = reader->head + sizeof(reader->base) - BUF_PAD;
+    reader->tail            = reader->head;
+    reader->read_end        = reader->head;
+    reader->pro             = 0;
+    reader->str             = 0;
+    reader->pos             = 0;
+    reader->line            = 1;
+    reader->col             = 0;
+    reader->free_head       = 0;
 
     if (0 != fd) {
-	reader->read_func = read_from_fd;
-	reader->fd = fd;
+        reader->read_func = read_from_fd;
+        reader->fd        = fd;
     } else if (rb_cString == io_class) {
-	reader->read_func = 0;
-	reader->in_str = StringValuePtr(io);
-	reader->head = (char*)reader->in_str;
-	reader->tail = reader->head;
-	reader->read_end = reader->head + RSTRING_LEN(io);
+        reader->read_func = 0;
+        reader->in_str    = StringValuePtr(io);
+        reader->head      = (char *)reader->in_str;
+        reader->tail      = reader->head;
+        reader->read_end  = reader->head + RSTRING_LEN(io);
     } else if (oj_stringio_class == io_class) {
-	VALUE	s = rb_funcall2(io, oj_string_id, 0, 0);
-
-	reader->read_func = 0;
-	reader->in_str = StringValuePtr(s);
-	reader->head = (char*)reader->in_str;
-	reader->tail = reader->head;
-	reader->read_end = reader->head + RSTRING_LEN(s);
-    } else if (rb_cFile == io_class &&
-	       Qnil != (stat = rb_funcall(io, oj_stat_id, 0)) &&
-	       Qnil != (ftype = rb_funcall(stat, oj_ftype_id, 0)) &&
-	       0 == strcmp("file", StringValuePtr(ftype)) &&
-	       0 == FIX2INT(rb_funcall(io, oj_pos_id, 0))) {
-	reader->read_func = read_from_fd;
-	reader->fd = FIX2INT(rb_funcall(io, oj_fileno_id, 0));
+        VALUE s = rb_funcall2(io, oj_string_id, 0, 0);
+
+        reader->read_func = 0;
+        reader->in_str    = StringValuePtr(s);
+        reader->head      = (char *)reader->in_str;
+        reader->tail      = reader->head;
+        reader->read_end  = reader->head + RSTRING_LEN(s);
+    } else if (rb_cFile == io_class && Qnil != (stat = rb_funcall(io, oj_stat_id, 0)) &&
+               Qnil != (ftype = rb_funcall(stat, oj_ftype_id, 0)) &&
+               0 == strcmp("file", StringValuePtr(ftype)) &&
+               0 == FIX2INT(rb_funcall(io, oj_pos_id, 0))) {
+        reader->read_func = read_from_fd;
+        reader->fd        = FIX2INT(rb_funcall(io, oj_fileno_id, 0));
     } else if (rb_respond_to(io, oj_readpartial_id)) {
-	reader->read_func = read_from_io_partial;
-	reader->io = io;
+        reader->read_func = read_from_io_partial;
+        reader->io        = io;
     } else if (rb_respond_to(io, oj_read_id)) {
-	reader->read_func = read_from_io;
-	reader->io = io;
+        reader->read_func = read_from_io;
+        reader->io        = io;
     } else if (to_s) {
-	volatile VALUE	rstr = rb_funcall(io, oj_to_s_id, 0);
+        volatile VALUE rstr = rb_funcall(io, oj_to_s_id, 0);
 
-	reader->read_func = 0;
-	reader->in_str = StringValuePtr(rstr);
-	reader->head = (char*)reader->in_str;
-	reader->tail = reader->head;
-	reader->read_end = reader->head + RSTRING_LEN(rstr);
+        reader->read_func = 0;
+        reader->in_str    = StringValuePtr(rstr);
+        reader->head      = (char *)reader->in_str;
+        reader->tail      = reader->head;
+        reader->read_end  = reader->head + RSTRING_LEN(rstr);
     } else {
-	rb_raise(rb_eArgError, "parser io argument must be a String or respond to readpartial() or read().\n");
+        rb_raise(rb_eArgError,
+                 "parser io argument must be a String or respond to readpartial() or read().\n");
     }
 }
 
-int
-oj_reader_read(Reader reader) {
-    int		err;
-    size_t	shift = 0;
+int oj_reader_read(Reader reader) {
+    int    err;
+    size_t shift = 0;
 
     if (0 == reader->read_func) {
-	return -1;
+        return -1;
     }
     // if there is not much room to read into, shift or realloc a larger buffer.
     if (reader->head < reader->tail && 4096 > reader->end - reader->tail) {
-	if (0 == reader->pro) {
-	    shift = reader->tail - reader->head;
-	} else {
-	    shift = reader->pro - reader->head - 1; // leave one character so we can backup one
-	}
-	if (0 >= shift) { /* no space left so allocate more */
-	    const char	*old = reader->head;
-	    size_t	size = reader->end - reader->head + BUF_PAD;
-
-	    if (reader->head == reader->base) {
-		reader->head = ALLOC_N(char, size * 2);
-		memcpy((char*)reader->head, old, size);
-	    } else {
-		REALLOC_N(reader->head, char, size * 2);
-	    }
-	    reader->free_head = 1;
-	    reader->end = reader->head + size * 2 - BUF_PAD;
-	    reader->tail = reader->head + (reader->tail - old);
-	    reader->read_end = reader->head + (reader->read_end - old);
-	    if (0 != reader->pro) {
-		reader->pro = reader->head + (reader->pro - old);
-	    }
-	    if (0 != reader->str) {
-		reader->str = reader->head + (reader->str - old);
-	    }
-	} else {
-	    memmove((char*)reader->head, reader->head + shift, reader->read_end - (reader->head + shift));
-	    reader->tail -= shift;
-	    reader->read_end -= shift;
-	    if (0 != reader->pro) {
-		reader->pro -= shift;
-	    }
-	    if (0 != reader->str) {
-		reader->str -= shift;
-	    }
-	}
+        if (0 == reader->pro) {
+            shift = reader->tail - reader->head;
+        } else {
+            shift = reader->pro - reader->head - 1;  // leave one character so we can backup one
+        }
+        if (0 >= shift) { /* no space left so allocate more */
+            const char *old  = reader->head;
+            size_t      size = reader->end - reader->head + BUF_PAD;
+
+            if (reader->head == reader->base) {
+                reader->head = ALLOC_N(char, size * 2);
+                memcpy((char *)reader->head, old, size);
+            } else {
+                REALLOC_N(reader->head, char, size * 2);
+            }
+            reader->free_head = 1;
+            reader->end       = reader->head + size * 2 - BUF_PAD;
+            reader->tail      = reader->head + (reader->tail - old);
+            reader->read_end  = reader->head + (reader->read_end - old);
+            if (0 != reader->pro) {
+                reader->pro = reader->head + (reader->pro - old);
+            }
+            if (0 != reader->str) {
+                reader->str = reader->head + (reader->str - old);
+            }
+        } else {
+            memmove((char *)reader->head,
+                    reader->head + shift,
+                    reader->read_end - (reader->head + shift));
+            reader->tail -= shift;
+            reader->read_end -= shift;
+            if (0 != reader->pro) {
+                reader->pro -= shift;
+            }
+            if (0 != reader->str) {
+                reader->str -= shift;
+            }
+        }
     }
-    err = reader->read_func(reader);
-    *(char*)reader->read_end = '\0';
+    err                       = reader->read_func(reader);
+    *(char *)reader->read_end = '\0';
 
     return err;
 }
 
-static VALUE
-rescue_cb(VALUE rbuf, VALUE err) {
-    VALUE	clas = rb_obj_class(err);
+static VALUE rescue_cb(VALUE rbuf, VALUE err) {
+    VALUE clas = rb_obj_class(err);
 
     if (rb_eTypeError != clas && rb_eEOFError != clas) {
-	Reader	reader = (Reader)rbuf;
+        Reader reader = (Reader)rbuf;
 
-	rb_raise(clas, "at line %d, column %d\n", reader->line, reader->col);
+        rb_raise(clas, "at line %d, column %d\n", reader->line, reader->col);
     }
     return Qfalse;
 }
 
-static VALUE
-partial_io_cb(VALUE rbuf) {
-    Reader	reader = (Reader)rbuf;
-    VALUE	args[1];
-    VALUE	rstr;
-    char	*str;
-    size_t	cnt;
+static VALUE partial_io_cb(VALUE rbuf) {
+    Reader reader = (Reader)rbuf;
+    VALUE  args[1];
+    VALUE  rstr;
+    char * str;
+    size_t cnt;
 
     args[0] = ULONG2NUM(reader->end - reader->tail);
-    rstr = rb_funcall2(reader->io, oj_readpartial_id, 1, args);
+    rstr    = rb_funcall2(reader->io, oj_readpartial_id, 1, args);
     if (Qnil == rstr) {
-	return Qfalse;
+        return Qfalse;
     }
     str = StringValuePtr(rstr);
     cnt = RSTRING_LEN(rstr);
-    //printf("*** partial read %lu bytes, str: '%s'\n", cnt, str);
+    // printf("*** partial read %lu bytes, str: '%s'\n", cnt, str);
     strcpy(reader->tail, str);
     reader->read_end = reader->tail + cnt;
 
     return Qtrue;
 }
 
-static VALUE
-io_cb(VALUE rbuf) {
-    Reader	reader = (Reader)rbuf;
-    VALUE	args[1];
-    VALUE	rstr;
-    char	*str;
-    size_t	cnt;
+static VALUE io_cb(VALUE rbuf) {
+    Reader reader = (Reader)rbuf;
+    VALUE  args[1];
+    VALUE  rstr;
+    char * str;
+    size_t cnt;
 
     args[0] = ULONG2NUM(reader->end - reader->tail);
-    rstr = rb_funcall2(reader->io, oj_read_id, 1, args);
+    rstr    = rb_funcall2(reader->io, oj_read_id, 1, args);
     if (Qnil == rstr) {
-	return Qfalse;
+        return Qfalse;
     }
     str = StringValuePtr(rstr);
     cnt = RSTRING_LEN(rstr);
-    //printf("*** read %lu bytes, str: '%s'\n", cnt, str);
+    // printf("*** read %lu bytes, str: '%s'\n", cnt, str);
     strcpy(reader->tail, str);
     reader->read_end = reader->tail + cnt;
 
     return Qtrue;
 }
 
-static int
-read_from_io_partial(Reader reader) {
+static int read_from_io_partial(Reader reader) {
     return (Qfalse == rb_rescue(partial_io_cb, (VALUE)reader, rescue_cb, (VALUE)reader));
 }
 
-static int
-read_from_io(Reader reader) {
+static int read_from_io(Reader reader) {
     return (Qfalse == rb_rescue(io_cb, (VALUE)reader, rescue_cb, (VALUE)reader));
 }
 
-static int
-read_from_fd(Reader reader) {
-    ssize_t	cnt;
-    size_t	max = reader->end - reader->tail;
+static int read_from_fd(Reader reader) {
+    ssize_t cnt;
+    size_t  max = reader->end - reader->tail;
 
     cnt = read(reader->fd, reader->tail, max);
     if (cnt <= 0) {
-	return -1;
+        return -1;
     } else if (0 != cnt) {
-	reader->read_end = reader->tail + cnt;
+        reader->read_end = reader->tail + cnt;
     }
     return 0;
 }

data/ext/oj/reader.h

@@ -1,42 +1,43 @@
 // 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_READER_H
 #define OJ_READER_H
 
 typedef struct _reader {
-    char	base[0x00001000];
-    char	*head;
-    char	*end;
-    char	*tail;
-    char	*read_end;	/* one past last character read */
-    char	*pro;		/* protection start, buffer can not slide past this point */
-    char	*str;		/* start of current string being read */
-    long	pos;
-    int		line;
-    int		col;
-    int		free_head;
-    int		(*read_func)(struct _reader *reader);
+    char  base[0x00001000];
+    char *head;
+    char *end;
+    char *tail;
+    char *read_end; /* one past last character read */
+    char *pro;      /* protection start, buffer can not slide past this point */
+    char *str;      /* start of current string being read */
+    long  pos;
+    int   line;
+    int   col;
+    int   free_head;
+    int (*read_func)(struct _reader *reader);
     union {
-	int		fd;
-	VALUE		io;
-	const char	*in_str;
+        int         fd;
+        VALUE       io;
+        const char *in_str;
     };
-} *Reader;
+} * Reader;
 
-extern void	oj_reader_init(Reader reader, VALUE io, int fd, bool to_s);
-extern int	oj_reader_read(Reader reader);
+extern void oj_reader_init(Reader reader, VALUE io, int fd, bool to_s);
+extern int  oj_reader_read(Reader reader);
 
-static inline char
-reader_get(Reader reader) {
-    //printf("*** drive get from '%s'  from start: %ld	buf: %p	 from read_end: %ld\n", reader->tail, reader->tail - reader->head, reader->head, reader->read_end - reader->tail);
+static inline char reader_get(Reader reader) {
+    // printf("*** drive get from '%s'  from start: %ld	buf: %p	 from read_end: %ld\n",
+    // reader->tail, reader->tail - reader->head, reader->head, reader->read_end - reader->tail);
     if (reader->read_end <= reader->tail) {
-	if (0 != oj_reader_read(reader)) {
-	    return '\0';
-	}
+        if (0 != oj_reader_read(reader)) {
+            return '\0';
+        }
     }
     if ('\n' == *reader->tail) {
-	reader->line++;
-	reader->col = 0;
+        reader->line++;
+        reader->col = 0;
     }
     reader->col++;
     reader->pos++;
@@ -44,46 +45,40 @@ reader_get(Reader reader) {
     return *reader->tail++;
 }
 
-static inline void
-reader_backup(Reader reader) {
+static inline void reader_backup(Reader reader) {
     reader->tail--;
     reader->col--;
     reader->pos--;
     if (0 >= reader->col) {
-	reader->line--;
-	// allow col to be negative since we never backup twice in a row
+        reader->line--;
+        // allow col to be negative since we never backup twice in a row
     }
 }
 
-static inline void
-reader_protect(Reader reader) {
+static inline void reader_protect(Reader reader) {
     reader->pro = reader->tail;
-    reader->str = reader->tail; // can't have str before pro
+    reader->str = reader->tail;  // can't have str before pro
 }
 
-static inline void
-reader_release(Reader reader) {
+static inline void reader_release(Reader reader) {
     reader->pro = 0;
 }
 
 /* Starts by reading a character so it is safe to use with an empty or
  * compacted buffer.
  */
-static inline char
-reader_next_non_white(Reader reader) {
-    char	c;
+static inline char reader_next_non_white(Reader reader) {
+    char c;
 
     while ('\0' != (c = reader_get(reader))) {
-	switch(c) {
-	case ' ':
-	case '\t':
-	case '\f':
-	case '\n':
-	case '\r':
-	    break;
-	default:
-	    return c;
-	}
+        switch (c) {
+        case ' ':
+        case '\t':
+        case '\f':
+        case '\n':
+        case '\r': break;
+        default: return c;
+        }
     }
     return '\0';
 }
@@ -91,56 +86,48 @@ reader_next_non_white(Reader reader) {
 /* Starts by reading a character so it is safe to use with an empty or
  * compacted buffer.
  */
-static inline char
-reader_next_white(Reader reader) {
-    char	c;
+static inline char reader_next_white(Reader reader) {
+    char c;
 
     while ('\0' != (c = reader_get(reader))) {
-	switch(c) {
-	case ' ':
-	case '\t':
-	case '\f':
-	case '\n':
-	case '\r':
-	case '\0':
-	    return c;
-	default:
-	    break;
-	}
+        switch (c) {
+        case ' ':
+        case '\t':
+        case '\f':
+        case '\n':
+        case '\r':
+        case '\0': return c;
+        default: break;
+        }
     }
     return '\0';
 }
 
-static inline int
-reader_expect(Reader reader, const char *s) {
+static inline int reader_expect(Reader reader, const char *s) {
     for (; '\0' != *s; s++) {
-	if (reader_get(reader) != *s) {
-	    return -1;
-	}
+        if (reader_get(reader) != *s) {
+            return -1;
+        }
     }
     return 0;
 }
 
-static inline void
-reader_cleanup(Reader reader) {
+static inline void reader_cleanup(Reader reader) {
     if (reader->free_head && 0 != reader->head) {
-	xfree((char*)reader->head);
-	reader->head = 0;
-	reader->free_head = 0;
+        xfree((char *)reader->head);
+        reader->head      = 0;
+        reader->free_head = 0;
     }
 }
 
-static inline int
-is_white(char c) {
-    switch(c) {
+static inline int is_white(char c) {
+    switch (c) {
     case ' ':
     case '\t':
     case '\f':
     case '\n':
-    case '\r':
-	return 1;
-    default:
-	break;
+    case '\r': return 1;
+    default: break;
     }
     return 0;
 }