ox 2.14.14 → 2.14.17

data/ext/ox/sax_buf.c

@@ -3,96 +3,94 @@
  * All rights reserved.
  */
 
-#include <stdlib.h>
 #include <errno.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <strings.h>
 #include <sys/types.h>
 #if HAVE_SYS_UIO_H
 #include <sys/uio.h>
 #endif
-#include <unistd.h>
 #include <time.h>
+#include <unistd.h>
 
-#include "ruby.h"
 #include "ox.h"
+#include "ruby.h"
 #include "sax.h"
 
-#define BUF_PAD	4
+#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(Buf buf);
-static int		read_from_fd(Buf buf);
-static int		read_from_io_partial(Buf buf);
-static int		read_from_str(Buf buf);
+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(Buf buf);
+static int   read_from_fd(Buf buf);
+static int   read_from_io_partial(Buf buf);
+static int   read_from_str(Buf buf);
 
-void
-ox_sax_buf_init(Buf buf, VALUE io) {
-    volatile VALUE	io_class = rb_obj_class(io);
-    VALUE		rfd;
+void ox_sax_buf_init(Buf buf, VALUE io) {
+    volatile VALUE io_class = rb_obj_class(io);
+    VALUE          rfd;
 
     if (rb_cString == io_class) {
-	buf->read_func = read_from_str;
-	buf->in.str = StringValuePtr(io);
+        buf->read_func = read_from_str;
+        buf->in.str    = StringValuePtr(io);
     } else if (ox_stringio_class == io_class && 0 == FIX2INT(rb_funcall2(io, ox_pos_id, 0, 0))) {
-	volatile VALUE	s = rb_funcall2(io, ox_string_id, 0, 0);
+        volatile VALUE s = rb_funcall2(io, ox_string_id, 0, 0);
 
-	buf->read_func = read_from_str;
-	buf->in.str = StringValuePtr(s);
+        buf->read_func = read_from_str;
+        buf->in.str    = StringValuePtr(s);
     } else if (rb_cFile == io_class && Qnil != (rfd = rb_funcall(io, ox_fileno_id, 0))) {
-	buf->read_func = read_from_fd;
-	buf->in.fd = FIX2INT(rfd);
+        buf->read_func = read_from_fd;
+        buf->in.fd     = FIX2INT(rfd);
     } else if (rb_respond_to(io, ox_readpartial_id)) {
-	buf->read_func = read_from_io_partial;
-	buf->in.io = io;
+        buf->read_func = read_from_io_partial;
+        buf->in.io     = io;
     } else if (rb_respond_to(io, ox_read_id)) {
-	buf->read_func = read_from_io;
-	buf->in.io = io;
+        buf->read_func = read_from_io;
+        buf->in.io     = io;
     } else {
         rb_raise(ox_arg_error_class, "sax_parser io argument must respond to readpartial() or read().\n");
     }
-    buf->head = buf->base;
-    *buf->head = '\0';
-    buf->end = buf->head + sizeof(buf->base) - BUF_PAD;
-    buf->tail = buf->head;
+    buf->head     = buf->base;
+    *buf->head    = '\0';
+    buf->end      = buf->head + sizeof(buf->base) - BUF_PAD;
+    buf->tail     = buf->head;
     buf->read_end = buf->head;
-    buf->pro = 0;
-    buf->str = 0;
-    buf->pos = 0;
-    buf->line = 1;
-    buf->col = 0;
-    buf->pro_pos = 1;
+    buf->pro      = 0;
+    buf->str      = 0;
+    buf->pos      = 0;
+    buf->line     = 1;
+    buf->col      = 0;
+    buf->pro_pos  = 1;
     buf->pro_line = 1;
-    buf->pro_col = 0;
-    buf->dr = 0;
+    buf->pro_col  = 0;
+    buf->dr       = 0;
 }
 
-int
-ox_sax_buf_read(Buf buf) {
-    int         err;
-    size_t      shift = 0;
+int ox_sax_buf_read(Buf buf) {
+    int    err;
+    size_t shift = 0;
 
     // if there is not much room to read into, shift or realloc a larger buffer.
     if (buf->head < buf->tail && 4096 > buf->end - buf->tail) {
         if (0 == buf->pro) {
             shift = buf->tail - buf->head;
         } else {
-            shift = buf->pro - buf->head - 1; // leave one character so we cab backup one
+            shift = buf->pro - buf->head - 1;  // leave one character so we cab backup one
         }
-        if (0 >= shift) { /* no space left so allocate more */
-            char        *old = buf->head;
-            size_t      size = buf->end - buf->head + BUF_PAD;
+        if (0 >= shift) {                      /* no space left so allocate more */
+            char  *old  = buf->head;
+            size_t size = buf->end - buf->head + BUF_PAD;
 
             if (buf->head == buf->base) {
                 buf->head = ALLOC_N(char, size * 2);
                 memcpy(buf->head, old, size);
             } else {
-		REALLOC_N(buf->head, char, size * 2);
+                REALLOC_N(buf->head, char, size * 2);
             }
-            buf->end = buf->head + size * 2 - BUF_PAD;
-            buf->tail = buf->head + (buf->tail - old);
+            buf->end      = buf->head + size * 2 - BUF_PAD;
+            buf->tail     = buf->head + (buf->tail - old);
             buf->read_end = buf->head + (buf->read_end - old);
             if (0 != buf->pro) {
                 buf->pro = buf->head + (buf->pro - old);
@@ -112,77 +110,71 @@ ox_sax_buf_read(Buf buf) {
             }
         }
     }
-    err = buf->read_func(buf);
+    err            = buf->read_func(buf);
     *buf->read_end = '\0';
 
     return err;
 }
 
-static VALUE
-rescue_cb(VALUE rbuf, VALUE err) {
-    VALUE	err_class = rb_obj_class(err);
+static VALUE rescue_cb(VALUE rbuf, VALUE err) {
+    VALUE err_class = rb_obj_class(err);
 
     if (err_class != rb_eTypeError && err_class != rb_eEOFError) {
-	Buf	buf = (Buf)rbuf;
+        Buf buf = (Buf)rbuf;
 
-        //ox_sax_drive_cleanup(buf->dr); called after exiting protect
+        // ox_sax_drive_cleanup(buf->dr); called after exiting protect
         rb_raise(err, "at line %ld, column %ld\n", (long)buf->line, (long)buf->col);
     }
     return Qfalse;
 }
 
-static VALUE
-partial_io_cb(VALUE rbuf) {
-    Buf		buf = (Buf)rbuf;
-    VALUE	args[1];
-    VALUE	rstr;
-    char	*str;
-    size_t	cnt;
+static VALUE partial_io_cb(VALUE rbuf) {
+    Buf    buf = (Buf)rbuf;
+    VALUE  args[1];
+    VALUE  rstr;
+    char  *str;
+    size_t cnt;
 
     args[0] = ULONG2NUM(buf->end - buf->tail);
-    rstr = rb_funcall2(buf->in.io, ox_readpartial_id, 1, args);
-    str = StringValuePtr(rstr);
-    cnt = strlen(str);
-    //printf("*** read partial %lu bytes, str: '%s'\n", cnt, str);
+    rstr    = rb_funcall2(buf->in.io, ox_readpartial_id, 1, args);
+    str     = StringValuePtr(rstr);
+    cnt     = strlen(str);
+    // printf("*** read partial %lu bytes, str: '%s'\n", cnt, str);
     strcpy(buf->tail, str);
     buf->read_end = buf->tail + cnt;
 
     return Qtrue;
 }
 
-static VALUE
-io_cb(VALUE rbuf) {
-    Buf		buf = (Buf)rbuf;
-    VALUE	args[1];
-    VALUE	rstr;
-    char	*str;
-    size_t	cnt;
+static VALUE io_cb(VALUE rbuf) {
+    Buf    buf = (Buf)rbuf;
+    VALUE  args[1];
+    VALUE  rstr;
+    char  *str;
+    size_t cnt;
 
     args[0] = ULONG2NUM(buf->end - buf->tail);
-    rstr = rb_funcall2(buf->in.io, ox_read_id, 1, args);
-    str = StringValuePtr(rstr);
-    cnt = strlen(str);
-    //printf("*** read %lu bytes, str: '%s'\n", cnt, str);
+    rstr    = rb_funcall2(buf->in.io, ox_read_id, 1, args);
+    str     = StringValuePtr(rstr);
+    cnt     = strlen(str);
+    // printf("*** read %lu bytes, str: '%s'\n", cnt, str);
     strcpy(buf->tail, str);
     buf->read_end = buf->tail + cnt;
 
     return Qtrue;
 }
 
-static int
-read_from_io_partial(Buf buf) {
+static int read_from_io_partial(Buf buf) {
     return (Qfalse == rb_rescue(partial_io_cb, (VALUE)buf, rescue_cb, (VALUE)buf));
 }
 
-static int
-read_from_io(Buf buf) {
+static int read_from_io(Buf buf) {
     return (Qfalse == rb_rescue(io_cb, (VALUE)buf, rescue_cb, (VALUE)buf));
 }
 
-static int
-read_from_fd(Buf buf) {
-    ssize_t     cnt;
-    size_t      max = buf->end - buf->tail;
+static int read_from_fd(Buf buf) {
+    ssize_t cnt;
+    size_t  max = buf->end - buf->tail;
 
     cnt = read(buf->in.fd, buf->tail, max);
     if (cnt < 0) {
@@ -194,22 +186,21 @@ read_from_fd(Buf buf) {
     return 0;
 }
 
-static int
-read_from_str(Buf buf) {
-    size_t      max = buf->end - buf->tail - 1;
-    char	*s;
-    size_t	cnt;
+static int read_from_str(Buf buf) {
+    size_t max = buf->end - buf->tail - 1;
+    char  *s;
+    size_t cnt;
 
     if ('\0' == *buf->in.str) {
-	return -1;
+        return -1;
     }
     cnt = strlen(buf->in.str) + 1;
     if (max < cnt) {
-	cnt = max;
+        cnt = max;
     }
     strncpy(buf->tail, buf->in.str, cnt);
-    s = buf->tail + cnt - 1;
-    *s = '\0';
+    s   = buf->tail + cnt - 1;
+    *s  = '\0';
     cnt = s - buf->tail;
     buf->in.str += cnt;
     buf->read_end = buf->tail + cnt;

data/ext/ox/sax_buf.h

@@ -9,44 +9,45 @@
 #include <stdio.h>
 
 typedef struct _buf {
-    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 */
-    off_t	pos;
-    off_t	line;
-    off_t	col;
-    off_t	pro_pos;
-    off_t	pro_line;
-    off_t	pro_col;
-    int		(*read_func)(struct _buf *buf);
+    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 */
+    off_t pos;
+    off_t line;
+    off_t col;
+    off_t pro_pos;
+    off_t pro_line;
+    off_t pro_col;
+    int (*read_func)(struct _buf *buf);
     union {
-        int     	fd;
-        VALUE   	io;
-	const char	*str;
+        int         fd;
+        VALUE       io;
+        const char *str;
     } in;
-    struct _saxDrive	*dr;
+    struct _saxDrive *dr;
 } *Buf;
 
 typedef struct _checkPt {
-    off_t	pro_dif;
-    off_t	pos;
-    off_t	line;
-    off_t	col;
-    char	c;
+    off_t pro_dif;
+    off_t pos;
+    off_t line;
+    off_t col;
+    char  c;
 } *CheckPt;
 
-#define CHECK_PT_INIT { -1, 0, 0, 0, '\0' }
+#define CHECK_PT_INIT \
+    { -1, 0, 0, 0, '\0' }
 
-extern void	ox_sax_buf_init(Buf buf, VALUE io);
-extern int	ox_sax_buf_read(Buf buf);
+extern void ox_sax_buf_init(Buf buf, VALUE io);
+extern int  ox_sax_buf_read(Buf buf);
 
-static inline char
-buf_get(Buf buf) {
-    //printf("*** drive get from '%s'  from start: %ld  buf: %p  from read_end: %ld\n", buf->tail, buf->tail - buf->head, buf->head, buf->read_end - buf->tail);
+static inline char buf_get(Buf buf) {
+    // printf("*** drive get from '%s'  from start: %ld  buf: %p  from read_end: %ld\n", buf->tail, buf->tail -
+    // buf->head, buf->head, buf->read_end - buf->tail);
     if (buf->read_end <= buf->tail) {
         if (0 != ox_sax_buf_read(buf)) {
             return '\0';
@@ -56,59 +57,53 @@ buf_get(Buf buf) {
         buf->line++;
         buf->col = 0;
     } else {
-	buf->col++;
+        buf->col++;
     }
     buf->pos++;
 
     return *buf->tail++;
 }
 
-static inline void
-buf_backup(Buf buf) {
+static inline void buf_backup(Buf buf) {
     buf->tail--;
     buf->col--;
     buf->pos--;
     if (0 >= buf->col) {
-	buf->line--;
-	// allow col to be negative since we never backup twice in a row
+        buf->line--;
+        // allow col to be negative since we never backup twice in a row
     }
 }
 
-static inline void
-buf_protect(Buf buf) {
-    buf->pro = buf->tail;
-    buf->str = buf->tail; // can't have str before pro
-    buf->pro_pos = buf->pos;
+static inline void buf_protect(Buf buf) {
+    buf->pro      = buf->tail;
+    buf->str      = buf->tail;  // can't have str before pro
+    buf->pro_pos  = buf->pos;
     buf->pro_line = buf->line;
-    buf->pro_col = buf->col;
+    buf->pro_col  = buf->col;
 }
 
-static inline void
-buf_reset(Buf buf) {
+static inline void buf_reset(Buf buf) {
     buf->tail = buf->pro;
-    buf->pos = buf->pro_pos;
+    buf->pos  = buf->pro_pos;
     buf->line = buf->pro_line;
-    buf->col = buf->pro_col;
+    buf->col  = buf->pro_col;
 }
 
 /* Starts by reading a character so it is safe to use with an empty or
  * compacted buffer.
  */
-static inline char
-buf_next_non_white(Buf buf) {
-    char        c;
+static inline char buf_next_non_white(Buf buf) {
+    char c;
 
     while ('\0' != (c = buf_get(buf))) {
-	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';
 }
@@ -116,107 +111,93 @@ buf_next_non_white(Buf buf) {
 /* Starts by reading a character so it is safe to use with an empty or
  * compacted buffer.
  */
-static inline char
-buf_next_white(Buf buf) {
-    char        c;
+static inline char buf_next_white(Buf buf) {
+    char c;
 
     while ('\0' != (c = buf_get(buf))) {
-	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 void
-buf_cleanup(Buf buf) {
+static inline void buf_cleanup(Buf buf) {
     if (buf->base != buf->head && 0 != buf->head) {
         xfree(buf->head);
-	buf->head = 0;
+        buf->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;
 }
 
-static inline void
-buf_checkpoint(Buf buf, CheckPt cp) {
+static inline void buf_checkpoint(Buf buf, CheckPt cp) {
     cp->pro_dif = (int)(buf->tail - buf->pro);
-    cp->pos = buf->pos;
-    cp->line = buf->line;
-    cp->col = buf->col;
-    cp->c = *(buf->tail - 1);
+    cp->pos     = buf->pos;
+    cp->line    = buf->line;
+    cp->col     = buf->col;
+    cp->c       = *(buf->tail - 1);
 }
 
-static inline int
-buf_checkset(CheckPt cp) {
+static inline int buf_checkset(CheckPt cp) {
     return (0 <= cp->pro_dif);
 }
 
-static inline char
-buf_checkback(Buf buf, CheckPt cp) {
+static inline char buf_checkback(Buf buf, CheckPt cp) {
     buf->tail = buf->pro + cp->pro_dif;
-    buf->pos = cp->pos;
+    buf->pos  = cp->pos;
     buf->line = cp->line;
-    buf->col = cp->col;
+    buf->col  = cp->col;
     return cp->c;
 }
 
-static inline void
-buf_collapse_return(char *str) {
-    char	*s = str;
-    char	*back = str;
+static inline void buf_collapse_return(char *str) {
+    char *s    = str;
+    char *back = str;
 
     for (; '\0' != *s; s++) {
-	if (back != str && '\n' == *s && '\r' == *(back - 1)) {
-	    *(back - 1) = '\n';
-	} else {
-	    *back++ = *s;
-	}
+        if (back != str && '\n' == *s && '\r' == *(back - 1)) {
+            *(back - 1) = '\n';
+        } else {
+            *back++ = *s;
+        }
     }
     *back = '\0';
 }
 
-static inline void
-buf_collapse_white(char *str) {
-    char	*s = str;
-    char	*back = str;
+static inline void buf_collapse_white(char *str) {
+    char *s    = str;
+    char *back = str;
 
     for (; '\0' != *s; s++) {
-	switch(*s) {
-	case ' ':
-	case '\t':
-	case '\f':
-	case '\n':
-	case '\r':
-	    if (back == str || ' ' != *(back - 1)) {
-		*back++ = ' ';
-	    }
-	    break;
-	default:
-	    *back++ = *s;
-	    break;
-	}
+        switch (*s) {
+        case ' ':
+        case '\t':
+        case '\f':
+        case '\n':
+        case '\r':
+            if (back == str || ' ' != *(back - 1)) {
+                *back++ = ' ';
+            }
+            break;
+        default: *back++ = *s; break;
+        }
     }
     *back = '\0';
 }