binyo 0.0.1

data/ext/binyo/bytelist.h

@@ -0,0 +1,45 @@
+/*
+ * 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.
+ */
+
+#if !defined(_BYTELIST_H_)
+#define _BYTELIST_H_
+
+extern VALUE cBinyoByteList;
+
+struct binyo_bytelist_st;
+typedef struct binyo_bytelist_st binyo_bytelist;
+
+binyo_bytelist * binyo_bytelist_new_size(size_t size);
+binyo_bytelist * binyo_bytelist_new_size_default(size_t size, uint8_t default_value);
+binyo_bytelist * binyo_bytelist_new_bytes(uint8_t *bytes, size_t len);
+void binyo_bytelist_free(binyo_bytelist *bytelist);
+
+void Init_binyo_bytelist(void);
+
+#endif /* _BYTELIST_H_ */
+
+

data/ext/binyo/error.c

@@ -0,0 +1,202 @@
+/*
+ * 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_err_stack_elem_st binyo_err_stack_elem;
+
+typedef struct binyo_err_stack_st {
+    int count;
+    binyo_err_stack_elem *head;
+} binyo_err_stack;
+
+struct binyo_err_stack_elem_st {
+    char *message;
+    size_t len;
+    binyo_err_stack_elem *prev;
+};
+
+static binyo_err_stack err_stack = { 0 };
+
+#define int_err_stack_empty()	(err_stack.count == 0)
+
+static void
+int_err_stack_push(char *message, size_t len)
+{
+    binyo_err_stack_elem *elem;
+
+    elem = ALLOC(binyo_err_stack_elem);
+    elem->message = message;
+    elem->len = len;
+    elem->prev = err_stack.head;
+    err_stack.head = elem;
+    err_stack.count++;
+}
+
+static char *
+int_err_stack_pop()
+{
+    char *message;
+    binyo_err_stack_elem *head = err_stack.head;
+
+    if (!head) return NULL;
+
+    err_stack.head = head->prev;
+    message = head->message;
+    xfree(head);
+    err_stack.count--;
+    return message;
+}
+
+int
+binyo_has_errors(void)
+{
+    return !int_err_stack_empty();
+}
+
+int
+binyo_error_message(char *buf, int buf_len)
+{
+    binyo_err_stack_elem *head = err_stack.head;
+    int len = 0;
+
+    while (head) {
+	int cur_len;
+	char *message = head->message;
+	cur_len = snprintf(buf + len, buf_len, "%s%s", (len ? ": " : ""), message);
+	if (cur_len > 0)
+	    len += cur_len;
+	head = head->prev;
+    }
+
+    return len;
+}
+
+void
+binyo_error_add(const char *format, ...)
+{
+    char *buf;
+    int len = 0;
+    va_list args;
+
+    va_start(args, format);
+    buf = ALLOC_N(char, BUFSIZ);
+    if ((len = vsnprintf(buf, BUFSIZ, format, args)) < 0) return;
+    int_err_stack_push(buf, len);
+    va_end(args);
+}
+
+static int
+int_error_msg_create(char *buf, int len, const char *format, va_list args)
+{
+    int l;
+
+    if ((l = vsnprintf(buf, len, format, args)) < 0) {
+	return -1;
+    }
+
+    while (!int_err_stack_empty()) {
+	int cur_len;
+	char *message = int_err_stack_pop();
+	cur_len = snprintf(buf + l, len, "%s%s", (l ? ": " : ""), message);
+	xfree(message);
+	if (cur_len > 0)
+	    l += cur_len;
+    }
+
+    return l;
+}
+
+
+static VALUE
+int_error_create(VALUE exception_class, const char *format, va_list args)
+{
+    char buf[BUFSIZ];
+    int len = 0;
+
+    if ((len = int_error_msg_create(buf, BUFSIZ, format, args)) < 0) {
+	return rb_funcall(exception_class, rb_intern("new"), 0);
+    }
+
+    return rb_exc_new(exception_class, buf, len);
+}
+
+static VALUE
+int_error_enhance(VALUE exception_class, VALUE active_exc, const char *format, va_list args)
+{
+    char buf[BUFSIZ];
+    int len;
+    VALUE orig_msg;
+    long orig_len;
+    const char *active_name = rb_class2name(CLASS_OF(active_exc));
+    size_t active_name_len = strlen(active_name);
+
+    if ((len = int_error_msg_create(buf, BUFSIZ, format, args)) < 0) {
+	return active_exc;
+    }
+
+    orig_msg = rb_funcall(active_exc, rb_intern("message"), 0);
+    StringValueCStr(orig_msg);
+    orig_len = RSTRING_LEN(orig_msg);
+    if (len <= BUFSIZ - ( (int) active_name_len ) - orig_len - 4) {
+	strcat(buf, ": ");
+	strcat(buf, active_name);
+	strcat(buf, ": ");
+	strcat(buf, RSTRING_PTR(orig_msg));
+	len += active_name_len + orig_len + 4;
+    }
+
+    return rb_exc_new(exception_class, buf, len);
+}
+
+void
+binyo_error_raise(VALUE exception_class, const char *format, ...)
+{
+    VALUE exc;
+    VALUE active_exc;
+    va_list args;
+
+    va_start(args, format);
+    active_exc = rb_errinfo();
+    if (NIL_P(active_exc)) {
+	exc = int_error_create(exception_class, format, args);
+    } else {
+	exc = int_error_enhance(exception_class, active_exc, format, args);
+    }
+    va_end(args);
+    rb_exc_raise(exc);
+}
+
+void
+binyo_error_clear(void)
+{
+    while (!int_err_stack_empty()) {
+	xfree(int_err_stack_pop());
+    }
+}
+

data/ext/binyo/extconf.h

@@ -0,0 +1,5 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#define HAVE_RUBY_IO_H 1
+#define HAVE_RB_IO_CHECK_BYTE_READABLE 1
+#endif

data/ext/binyo/extconf.rb

@@ -0,0 +1,73 @@
+=begin
+
+= Info
+
+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.
+
+=end
+
+require 'mkmf'
+
+dir_config('profiler')
+
+message "=== binyo - Fast binary IO for Ruby ===\n"
+
+arg = ARGV.shift
+if arg
+  if arg.include? "-g"
+    debug = true
+  elsif arg.include? "-p"
+    profiler = true
+    unless have_library("profiler", "ProfilerStart")
+      message "'libprofiler' could not be found.\n"
+      exit 1
+    end 
+  end
+end
+
+if CONFIG['GCC'] == 'yes'
+  if debug
+    flags = "--coverage -g3 -fprofile-arcs -ftest-coverage"
+    message "!! set #{flags} for coverage !!"
+    $CFLAGS += " #{flags}"
+    $DLDFLAGS += " #{flags}"
+    $LIBS += " -lgcov"
+  end
+  if profiler
+    message "Linking to profiler library\n"
+    pkg_config('profiler')
+    $LIBS += " -lprofiler"
+  end
+end
+
+message "=== Checking Ruby features ===\n"
+
+have_header("ruby/io.h")
+have_func("rb_io_check_byte_readable")
+
+create_header
+create_makefile("binyo")
+message "Done.\n"

data/ext/binyo/io.c

@@ -0,0 +1,324 @@
+/*
+ * 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"
+
+#define int_check_stream(io) 		if (!(io) || !(io)->methods) \
+						    rb_raise(eBinyoError, "Stream not initialized properly")
+
+#define int_check_stream_has(io, m) 		if (!(io) || !(io)->methods || !(io)->methods->m) \
+						    rb_raise(eBinyoError, "Stream not initialized properly")
+
+VALUE sBinyo_ID_SEEK_CUR, sBinyo_ID_SEEK_SET, sBinyo_ID_SEEK_END;
+ID sBinyo_ID_READ, sBinyo_ID_SEEK, sBinyo_ID_WRITE, sBinyo_ID_CLOSE;
+
+void
+binyo_add_io_error(void)
+{
+    int err = binyo_last_sys_error();
+    binyo_error_add("Error stream IO: %d", err);
+}
+
+/* instream */
+
+static int
+int_read_all(binyo_instream *in, VALUE vbuf, VALUE *out)
+{
+    uint8_t *buf;
+    ssize_t r;
+
+    buf = ALLOC_N(uint8_t, BINYO_IO_BUF_SIZE);
+
+    while ((r = binyo_instream_read(in, buf, BINYO_IO_BUF_SIZE)) >= 0) {
+	rb_str_buf_cat(vbuf, (const char *) buf, r);
+    }
+
+    xfree(buf);
+    if (r == BINYO_ERR) return BINYO_ERR;
+    *out = vbuf;
+    return BINYO_OK;
+}
+
+static int
+int_rb_read_generic(binyo_instream *in, VALUE vlen, VALUE vbuf, VALUE *out)
+{
+    long len;
+    size_t tlen;
+    ssize_t r;
+    uint8_t *buf;
+
+    if (NIL_P(vbuf)) {
+	vbuf = rb_str_new2("");
+	rb_enc_associate(vbuf, rb_ascii8bit_encoding());
+    }
+
+    if (NIL_P(vlen))
+	 return int_read_all(in, vbuf, out);
+
+    len = NUM2LONG(vlen);
+    if (len < 0) {
+	binyo_error_add("Negative length given");
+	return BINYO_ERR;
+    }
+    if ((size_t) len > SIZE_MAX) {
+	binyo_error_add("Size too large: %ld", len);
+	return BINYO_ERR;
+    }
+
+    tlen = (size_t) len;
+    if (len == 0) {
+	rb_str_resize(vbuf, 0);
+	*out = vbuf;
+	return BINYO_OK;
+    }
+
+    buf = ALLOC_N(uint8_t, tlen);
+    r = binyo_instream_read(in, buf, tlen);
+
+    if (r == BINYO_ERR) {
+	binyo_error_add("Error while reading from stream");
+	xfree(buf);
+	return BINYO_ERR;
+    }
+    else if (r == BINYO_IO_EOF) {
+	xfree(buf);
+	rb_str_resize(vbuf, 0);
+	*out = Qnil;
+	return BINYO_OK;
+    }
+    else {
+	rb_str_buf_cat(vbuf, (const char *)buf, r);
+	xfree(buf);
+	*out = vbuf;
+	return BINYO_OK;
+    }
+}
+
+int
+binyo_instream_rb_read(binyo_instream *in, VALUE vlen, VALUE vbuf, VALUE *out)
+{
+    int_check_stream(in);
+
+    if (in->methods->rb_read) {
+	return in->methods->rb_read(in, vlen, vbuf, out);
+    }
+    else {
+	return int_rb_read_generic(in, vlen, vbuf, out);
+    }
+}
+
+ssize_t 
+binyo_instream_read(binyo_instream *in, uint8_t *buf, size_t len)
+{
+    int_check_stream_has(in, read);
+
+    if (len > SSIZE_MAX) {
+	binyo_error_add("Size too large: %ld", len);
+	return BINYO_ERR;
+    }
+    return in->methods->read(in, buf, len);
+}
+
+static ssize_t
+int_gets_generic(binyo_instream *in, char *line, size_t len)
+{
+    ssize_t ret = 0, r = 0;
+    char *p = line;
+    char *end = line + len;
+
+    if (!line) return BINYO_ERR;
+
+    while (p < end) {
+	if ((r = in->methods->read(in, (uint8_t *) p, 1)) < 0)
+	    break;
+	if (r == 1) {
+	    if (*p == '\n')
+		break;
+	    p++;
+	    ret++;
+	}
+    }
+
+    if (r == BINYO_ERR) return BINYO_ERR;
+    if (ret == 0 && r == BINYO_IO_EOF) return BINYO_IO_EOF;
+
+    /* normalize CRLF */
+    if (*p == '\n' && *(p - 1) == '\r')
+       ret--;	
+
+    return ret;
+}
+
+ssize_t
+binyo_instream_gets(binyo_instream *in, char *line, size_t len)
+{
+    int_check_stream(in);
+    if (len > SSIZE_MAX) {
+	binyo_error_add("Size too large: %ld", len);
+	return BINYO_ERR;
+    }
+    if (in->methods->gets) {
+	return in->methods->gets(in, line, len);
+    }
+    else {
+	return int_gets_generic(in, line, len);
+    }
+}
+
+int
+binyo_instream_seek(binyo_instream *in, off_t offset, int whence)
+{
+    int_check_stream_has(in, seek);
+    return in->methods->seek(in, offset, whence);
+}
+
+void
+binyo_instream_mark(binyo_instream *in)
+{
+    int_check_stream(in);
+    if (in->methods->mark)
+	in->methods->mark(in);
+}
+
+void
+binyo_instream_free(binyo_instream *in)
+{
+    int_check_stream(in);
+    if (in->methods->free)
+	in->methods->free(in);
+    xfree(in);
+}
+
+static binyo_instream *
+int_instream_common_new(VALUE value)
+{
+    int type;
+
+    type = TYPE(value);
+
+    if (type == T_STRING) {
+	return binyo_instream_new_bytes((uint8_t *)RSTRING_PTR(value), RSTRING_LEN(value));
+    }
+    else {
+	if (type == T_FILE) {
+	    return binyo_instream_new_fd_io(value);
+	}
+	else if (rb_respond_to(value, sBinyo_ID_READ)) {
+	    return binyo_instream_new_io_generic(value);
+	}
+    }
+    return NULL;
+}
+
+binyo_instream *
+binyo_instream_new_value(VALUE value)
+{
+    return int_instream_common_new(value);
+}
+
+/* end instream */
+
+/* outstream */
+
+ssize_t 
+binyo_outstream_write(binyo_outstream *out, uint8_t *buf, size_t len)
+{
+    int_check_stream_has(out, write);
+    if (len > SSIZE_MAX) {
+	binyo_error_add("Size too large: %ld", len);
+	return BINYO_ERR;
+    }
+    return out->methods->write(out, buf, len);
+}
+
+int
+binyo_outstream_rb_write(binyo_outstream *out, VALUE vbuf, VALUE *ret)
+{
+    int_check_stream(out);
+
+    if (out->methods->rb_write) {
+	return out->methods->rb_write(out, vbuf, ret);
+    }
+    else {
+	ssize_t w;
+	w = binyo_outstream_write(out, (uint8_t *) RSTRING_PTR(vbuf), RSTRING_LEN(vbuf));
+	if (w == BINYO_ERR) {
+	    binyo_error_add("Error while writing to stream");
+	    return BINYO_ERR;
+	}
+	*ret = LONG2NUM(w);
+	return BINYO_OK;
+    }
+}
+
+void
+binyo_outstream_mark(binyo_outstream *out)
+{
+    int_check_stream(out);
+    if (out->methods->mark)
+	out->methods->mark(out);
+}
+
+void
+binyo_outstream_free(binyo_outstream *out)
+{
+    int_check_stream(out);
+    if (out->methods->free)
+	out->methods->free(out);
+    xfree(out);
+}
+
+binyo_outstream *
+binyo_outstream_new_value(VALUE value)
+{
+    int type;
+
+    type = TYPE(value);
+
+    if (type == T_FILE)
+	return binyo_outstream_new_fd_io(value);
+    if (rb_respond_to(value, sBinyo_ID_WRITE))
+	return binyo_outstream_new_io_generic(value);
+    binyo_error_add("Value cannot be converted into a stream");
+    return NULL;
+}
+
+/* end outstream */
+
+void
+Init_binyo_io(void)
+{
+    sBinyo_ID_SEEK = rb_intern("seek");
+    sBinyo_ID_READ = rb_intern("read");
+    sBinyo_ID_WRITE = rb_intern("write");
+    sBinyo_ID_CLOSE = rb_intern("close");
+
+    sBinyo_ID_SEEK_CUR = rb_const_get(rb_cIO, rb_intern("SEEK_CUR"));
+    sBinyo_ID_SEEK_SET = rb_const_get(rb_cIO, rb_intern("SEEK_SET"));
+    sBinyo_ID_SEEK_END = rb_const_get(rb_cIO, rb_intern("SEEK_END"));
+}
+