binyo 0.0.1

data/ext/binyo/io_in_fd.c

@@ -0,0 +1,166 @@
+/*
+ * binyo - Fast binary IO for Ruby
+ *
+ * Copyright (c) 2012-2013
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <unistd.h>
+#include <errno.h>
+#include "binyo.h"
+
+typedef struct binyo_instream_fd_st {
+    binyo_instream_interface *methods;
+    int fd;
+} binyo_instream_fd;
+
+#define int_safe_cast(out, in)	binyo_safe_cast_instream((out), (in), BINYO_INSTREAM_TYPE_FD, binyo_instream_fd)
+    
+static binyo_instream_fd *int_fd_alloc(void);
+static ssize_t int_fd_read(binyo_instream *in, uint8_t *buf, size_t len);
+static ssize_t int_fd_gets(binyo_instream *in, char *line, size_t len);
+static int int_fd_seek(binyo_instream *in, off_t offset, int whence);
+static void int_fd_free(binyo_instream *in);
+
+static binyo_instream_interface binyo_interface_fd = {
+    BINYO_INSTREAM_TYPE_FD,
+    int_fd_read,
+    NULL,
+    int_fd_gets,
+    int_fd_seek,
+    NULL,
+    int_fd_free
+};
+
+binyo_instream *
+binyo_instream_new_fd_io(VALUE value)
+{
+    rb_io_t *fptr;
+    GetOpenFile(value, fptr);
+    rb_io_check_byte_readable(fptr);
+    return binyo_instream_new_fd(fptr->fd);
+}
+
+binyo_instream *
+binyo_instream_new_fd(int fd)
+{
+    binyo_instream_fd *in;
+
+    in = int_fd_alloc();
+    in->fd = fd;
+    return (binyo_instream *) in;
+}
+
+static binyo_instream_fd*
+int_fd_alloc(void)
+{
+    binyo_instream_fd *ret;
+    ret = ALLOC(binyo_instream_fd);
+    memset(ret, 0, sizeof(binyo_instream_fd));
+    ret->methods = &binyo_interface_fd;
+    return ret;
+}
+
+static ssize_t
+int_fd_read(binyo_instream *instream, uint8_t *buf, size_t len)
+{
+    int fd;
+    ssize_t r;
+    binyo_instream_fd *in;
+
+    int_safe_cast(in, instream);
+    if (!buf) return BINYO_ERR;
+
+    fd = in->fd;
+    binyo_clear_sys_error();
+    r = read(fd, buf, len);
+    
+    if (r == -1) {
+	binyo_add_io_error();
+	return BINYO_ERR; 
+    }
+    else if (r == 0) {
+	return BINYO_IO_EOF;
+    }
+    else {
+    	return r;
+    }
+}
+
+static ssize_t
+int_fd_gets(binyo_instream *instream, char *line, size_t len)
+{
+    int fd;
+    binyo_instream_fd *in;
+    ssize_t ret = 0, r = 0;
+    char *p = line;
+    char *end = line + len;
+
+    int_safe_cast(in, instream);
+    if (!line) return BINYO_ERR;
+
+    fd = in->fd;
+    binyo_clear_sys_error();
+
+    while ( (p < end) &&
+	    ((r = read(fd, p, 1)) == 1) &&
+	    (*p != '\n') ) {
+	    p++;
+	    ret++;
+    }
+
+    if (r == -1) {
+	return BINYO_ERR;
+    }
+    
+    if (ret == 0 && r == 0)
+	return BINYO_IO_EOF;
+
+    if (*p == '\n' && *(p - 1) == '\r')
+	ret--;
+
+    return ret;
+}
+
+static int
+int_fd_seek(binyo_instream *instream, off_t offset, int whence)
+{
+    int fd;
+    long off;
+    binyo_instream_fd *in;
+
+    int_safe_cast(in, instream);
+    fd = in->fd;
+    off = lseek(fd, offset, whence);
+
+    if (off == -1) 
+	return BINYO_ERR;
+    return BINYO_OK;
+}
+
+static void
+int_fd_free(binyo_instream *instream)
+{
+    /* do not close the fd, should be done explicitly */
+}
+

data/ext/binyo/io_in_generic.c

@@ -0,0 +1,182 @@
+/*
+ * binyo - Fast binary IO for Ruby
+ *
+ * Copyright (c) 2012-2013
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "binyo.h"
+
+typedef struct binyo_instream_io_st {
+    binyo_instream_interface *methods;
+    VALUE io;
+} binyo_instream_io;
+
+#define int_safe_cast(out, in)		binyo_safe_cast_instream((out), (in), BINYO_INSTREAM_TYPE_IO_GENERIC, binyo_instream_io)
+
+static binyo_instream_io* int_io_alloc(void);
+static ssize_t int_io_read(binyo_instream *in, uint8_t *buf, size_t len);
+static int int_io_rb_read(binyo_instream *in, VALUE vlen, VALUE vbuf, VALUE *out);
+static int int_io_seek(binyo_instream *in, off_t offset, int whence);
+static void int_io_mark(binyo_instream *in);
+static void int_io_free(binyo_instream *in);
+
+static binyo_instream_interface binyo_interface_io_generic = {
+    BINYO_INSTREAM_TYPE_IO_GENERIC,
+    int_io_read,
+    int_io_rb_read,
+    NULL,
+    int_io_seek,
+    int_io_mark,
+    int_io_free
+};
+
+binyo_instream *
+binyo_instream_new_io_generic(VALUE io)
+{
+    binyo_instream_io *in;
+
+    in = int_io_alloc();
+    in->io = io;
+    return (binyo_instream *) in;
+}
+
+static binyo_instream_io*
+int_io_alloc(void)
+{
+    binyo_instream_io *ret;
+    ret = ALLOC(binyo_instream_io);
+    memset(ret, 0, sizeof(binyo_instream_io));
+    ret->methods = &binyo_interface_io_generic;
+    return ret;
+}
+
+static VALUE
+int_io_rb_protected_read(VALUE args)
+{
+    VALUE io, vbuf, vlen;
+    io = rb_ary_entry(args, 0);
+    vlen = rb_ary_entry(args, 1);
+    vbuf = rb_ary_entry(args, 2);
+    return rb_funcall(io, sBinyo_ID_READ, 2, vlen, vbuf);
+}
+
+static int
+int_io_rb_read_impl(binyo_instream_io *in, VALUE vlen, VALUE vbuf, VALUE *out)
+{
+    VALUE args = rb_ary_new();
+    int state = 0;
+    rb_ary_push(args, in->io);
+    rb_ary_push(args, vlen);
+    rb_ary_push(args, vbuf);
+    *out = rb_protect(int_io_rb_protected_read, args, &state);
+    return state == 0 ? BINYO_OK : BINYO_ERR;
+}
+
+static ssize_t
+int_io_read(binyo_instream *instream, uint8_t *buf, size_t len)
+{
+    VALUE read, vlen, vbuf;
+    binyo_instream_io *in;
+
+    int_safe_cast(in, instream);
+
+    if (!buf) return BINYO_ERR;
+
+    vlen = LONG2NUM(len);
+    vbuf = rb_str_new2("");
+    rb_enc_associate(vbuf, rb_ascii8bit_encoding());
+
+    if (!int_io_rb_read_impl(in, vlen, vbuf, &read)) {
+	binyo_error_add("Error while reading from IO");
+	return BINYO_ERR;
+    }
+    
+    if (NIL_P(read)) {
+	return BINYO_IO_EOF;
+    }
+    else {
+	ssize_t r = (ssize_t) RSTRING_LEN(read);
+	memcpy(buf, RSTRING_PTR(read), r);
+	return r;
+    }
+}
+
+static int
+int_io_rb_read(binyo_instream *instream, VALUE vlen, VALUE vbuf, VALUE *out)
+{
+    binyo_instream_io *in;
+
+    int_safe_cast(in, instream);
+    return int_io_rb_read_impl(in, vlen, vbuf, out);
+}
+
+static VALUE
+int_whence_sym_for(int whence)
+{
+    switch (whence) {
+	case SEEK_CUR:
+	    return sBinyo_ID_SEEK_CUR;
+	case SEEK_SET:
+	    return sBinyo_ID_SEEK_SET;
+	case SEEK_END:
+	    return sBinyo_ID_SEEK_END;
+	default:
+	    binyo_error_add("Unknown whence: %d", whence);
+	    return Qnil;
+    }
+}
+
+/* TODO: rb_protect */
+static int
+int_io_seek(binyo_instream *instream, off_t offset, int whence)
+{
+    VALUE io, whencesym;
+    binyo_instream_io *in;
+
+    int_safe_cast(in, instream);
+
+    io = in->io;
+    whencesym = int_whence_sym_for(whence);
+    if (NIL_P(whencesym)) return BINYO_ERR;
+    rb_funcall(io, sBinyo_ID_SEEK, 2, LONG2NUM(offset), whencesym);
+    return BINYO_OK;
+}
+
+static void
+int_io_mark(binyo_instream *instream)
+{
+    binyo_instream_io *in;
+
+    if (!instream) return;
+    int_safe_cast(in, instream);
+
+    rb_gc_mark(in->io);
+}
+
+static void
+int_io_free(binyo_instream *instream)
+{
+    /* do nothing */
+}
+

data/ext/binyo/io_in_seq.c

@@ -0,0 +1,187 @@
+/*
+ * binyo - Fast binary IO for Ruby
+ *
+ * Copyright (c) 2012-2013
+ * Martin Bosslet <martin.bosslet@gmail.com>
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "binyo.h"
+#include <stdarg.h>
+
+typedef struct binyo_instream_seq_st {
+    binyo_instream_interface *methods;
+    binyo_instream *active;
+    int i;
+    binyo_instream **streams;
+    int num;
+} binyo_instream_seq;
+
+#define int_safe_cast(out, in)		binyo_safe_cast_instream((out), (in), BINYO_INSTREAM_TYPE_SEQ, binyo_instream_seq)
+
+static binyo_instream_seq* int_seq_alloc(void);
+static ssize_t int_seq_read(binyo_instream *in, uint8_t *buf, size_t len);
+static int int_seq_seek(binyo_instream *in, off_t offset, int whence);
+static void int_seq_mark(binyo_instream *in);
+static void int_seq_free(binyo_instream *in);
+
+static binyo_instream_interface binyo_interface_seq = {
+    BINYO_INSTREAM_TYPE_SEQ,
+    int_seq_read,
+    NULL,
+    NULL,
+    int_seq_seek,
+    int_seq_mark,
+    int_seq_free
+};
+
+binyo_instream *
+binyo_instream_new_seq(binyo_instream *in1, binyo_instream *in2)
+{
+    return binyo_instream_new_seq_n(2, in1, in2);
+}
+
+binyo_instream *
+binyo_instream_new_seq_n(int num, binyo_instream *in1, binyo_instream *in2, ...)
+{
+    binyo_instream_seq *in;
+    va_list args;
+    int i = 0;
+
+    if (num < 2) {
+	binyo_error_add("At least two streams must be passed");
+	return NULL;
+    }
+
+    in = int_seq_alloc();
+    in->streams = ALLOC_N(binyo_instream *, num);
+    in->streams[i++] = in1;
+    in->streams[i++] = in2;
+    va_start(args, in2);
+
+    while (i < num) {
+	in->streams[i++] = va_arg(args, binyo_instream *);
+    }
+
+    va_end(args);
+    in->num = num;
+    in->i = 0;
+    in->active = in1;
+    return (binyo_instream *) in;
+}
+
+static binyo_instream_seq*
+int_seq_alloc(void)
+{
+    binyo_instream_seq *ret;
+    ret = ALLOC(binyo_instream_seq);
+    memset(ret, 0, sizeof(binyo_instream_seq));
+    ret->methods = &binyo_interface_seq;
+    return ret;
+}
+
+static ssize_t
+int_do_read(binyo_instream_seq *in, uint8_t *buf, size_t len)
+{
+    ssize_t read = 0;
+    size_t total = 0;
+
+    while (total < len && ((read = binyo_instream_read(in->active, buf, len - total)) >= 0)) {
+	total += read;
+	buf += read;
+    }
+
+    if (read == BINYO_ERR) return BINYO_ERR;
+    if (total == 0 && read == BINYO_IO_EOF) return BINYO_IO_EOF;
+    return total;
+}
+
+static ssize_t
+int_seq_read(binyo_instream *instream, uint8_t *buf, size_t len)
+{
+    ssize_t read;
+    binyo_instream_seq *in;
+    size_t total = 0;
+
+    int_safe_cast(in, instream);
+
+    if (!buf) return BINYO_ERR;
+
+    while (total < len) {
+    	read = int_do_read(in, buf, len - total);
+	if (read == BINYO_ERR) return BINYO_ERR;
+	if (read == BINYO_IO_EOF) {
+	    in->i++;
+	    if (in->i == in->num) {
+		return BINYO_IO_EOF;
+	    }
+	    else {
+		in->active = in->streams[in->i];
+	    }
+	}
+	else {
+	    total += read;
+	    buf += read;
+	}
+    }
+
+    return total;
+}
+
+static int
+int_seq_seek(binyo_instream *instream, off_t offset, int whence)
+{
+    binyo_instream_seq *in;
+
+    int_safe_cast(in, instream);
+    return binyo_instream_seek(in->active, offset, whence);
+}
+
+static void
+int_seq_mark(binyo_instream *instream)
+{
+    binyo_instream_seq *in;
+    int i;
+
+    if (!instream) return;
+    int_safe_cast(in, instream);
+
+    for(i=0; i < in->num; i++) {
+	binyo_instream_mark(in->streams[i]);
+    }
+}
+
+static void
+int_seq_free(binyo_instream *instream)
+{
+    binyo_instream_seq *in;
+    int i;
+
+    if (!instream) return;
+    int_safe_cast(in, instream);
+
+    for(i=0; i < in->num; i++) {
+	binyo_instream_free(in->streams[i]);
+    }
+    xfree(in->streams);
+}
+