ray 0.0.0.pre1 → 0.0.0.pre2

data/psp/syck/yaml2byte.c

@@ -0,0 +1,257 @@
+/*
+ * yaml2byte.c
+ *
+ * $Author: shyouhei $
+ * $Date: 2007-02-13 08:01:19 +0900 (Tue, 13 Feb 2007) $
+ *
+ * Copyright (C) 2003 why the lucky stiff, clark evans
+ *
+ *   WARNING WARNING WARNING  --- THIS IS *NOT JUST* PLAYING
+ *   ANYMORE! -- WHY HAS EMBRACED THIS AS THE REAL THING!
+ */ 
+#include <ruby/ruby.h>
+#include "syck.h"
+#include <assert.h>
+#define YAMLBYTE_UTF8
+#include "yamlbyte.h"
+
+#include <stdio.h>
+#define TRACE0(a)  \
+    do { printf(a); printf("\n"); fflush(stdout); } while(0)
+#define TRACE1(a,b) \
+    do { printf(a,b); printf("\n"); fflush(stdout); } while(0)
+#define TRACE2(a,b,c) \
+    do { printf(a,b,c); printf("\n"); fflush(stdout); } while(0)
+#define TRACE3(a,b,c,d) \
+    do { printf(a,b,c,d); printf("\n"); fflush(stdout); } while(0)
+
+/* Reinvent the wheel... */
+#define CHUNKSIZE 64
+#define HASH ((long)0xCAFECAFE)
+typedef struct {
+   long hash;
+   char *buffer;
+   long length;
+   long remaining;
+   int  printed;
+} bytestring_t;
+bytestring_t *bytestring_alloc() {
+    bytestring_t *ret; 
+    /*TRACE0("bytestring_alloc()");*/
+    ret = S_ALLOC(bytestring_t);
+    ret->hash   = HASH;
+    ret->length = CHUNKSIZE;
+    ret->remaining = ret->length;
+    ret->buffer = S_ALLOC_N(char, ret->length + 1 );
+    ret->buffer[0] = 0;
+    ret->printed = 0;
+    return ret;
+}
+void bytestring_append(bytestring_t *str, char code, 
+                       char *start, char *finish) 
+{
+    long grow;
+    long length = 2;   /* CODE + LF */
+    char *curr;
+    assert(str && HASH == str->hash);
+    /*TRACE0("bytestring_append()");*/
+    if(start) {
+        if(!finish)
+            finish = start + strlen(start);
+        length += (finish-start);
+    }
+    if(length > str->remaining) {
+        grow = (length - str->remaining) + CHUNKSIZE;
+        str->remaining += grow;
+        str->length    += grow; 
+        str->buffer = S_REALLOC_N( str->buffer, char, str->length + 1 );
+        assert(str->buffer);
+    }
+    curr = str->buffer + (str->length - str->remaining);
+    *curr = code;
+    curr += 1;
+    if(start) 
+        while(start < finish)
+            *curr ++ = *start ++;
+    *curr = '\n';
+    curr += 1;
+    *curr = 0;
+    str->remaining = str->remaining - length;
+    assert( (str->buffer + str->length) - str->remaining );
+}
+void bytestring_extend(bytestring_t *str, bytestring_t *ext)
+{
+    char *from;
+    char *curr;
+    char *stop;
+    long grow;
+    long length;
+    assert(str && HASH == str->hash);
+    assert(ext && HASH == ext->hash);
+    if(ext->printed) {
+        assert(ext->buffer[0] ==YAMLBYTE_ANCHOR);
+        curr = ext->buffer;
+        while( '\n' != *curr)
+            curr++;
+        bytestring_append(str, YAMLBYTE_ALIAS, ext->buffer + 1, curr);
+    } else {
+        ext->printed = 1;
+        length  = (ext->length - ext->remaining);
+        if(length > str->remaining) {
+            grow = (length - str->remaining) + CHUNKSIZE;
+            str->remaining += grow;
+            str->length    += grow; 
+            str->buffer = S_REALLOC_N( str->buffer, char, str->length + 1 );
+        }
+        curr = str->buffer + (str->length - str->remaining);
+        from = ext->buffer;
+        stop = ext->buffer + length;
+        while( from < stop )
+            *curr ++ = *from ++;
+        *curr = 0;
+        str->remaining = str->remaining - length;
+        assert( (str->buffer + str->length) - str->remaining );
+    }
+}
+
+/* convert SyckNode into yamlbyte_buffer_t objects */
+SYMID
+syck_yaml2byte_handler(p, n)
+    SyckParser *p;
+    SyckNode *n;
+{
+    SYMID oid;
+    long i;
+    char ch;
+    char nextcode;
+    char *start;
+    char *current;
+    char *finish;
+    bytestring_t *val = NULL;
+    bytestring_t *sav = NULL;
+    /*TRACE0("syck_yaml2byte_handler()");*/
+    val = bytestring_alloc();
+    if(n->anchor) bytestring_append(val,YAMLBYTE_ANCHOR, n->anchor, NULL);
+    if ( n->type_id )
+    {
+        if ( p->taguri_expansion )
+        {
+            bytestring_append(val,YAMLBYTE_TRANSFER, n->type_id, NULL);
+        }
+        else
+        {
+            char *type_tag = S_ALLOC_N( char, strlen( n->type_id ) + 1 );
+            type_tag[0] = '\0';
+            strcat( type_tag, "!" );
+            strcat( type_tag, n->type_id );
+            bytestring_append( val, YAMLBYTE_TRANSFER, type_tag, NULL);
+	    S_FREE(type_tag);
+        }
+    }
+    switch (n->kind)
+    {
+        case syck_str_kind:
+            nextcode = YAMLBYTE_SCALAR;
+            start  = n->data.str->ptr;
+            finish = start + n->data.str->len - 1;
+            current = start;
+            /*TRACE2("SCALAR: %s %d", start, n->data.str->len); */
+            while(1) {
+                ch = *current;
+                if('\n' == ch || 0 == ch || current > finish) {
+                    if(current >= start) {
+                        bytestring_append(val, nextcode, start, current);
+                        nextcode = YAMLBYTE_CONTINUE;
+                    }
+                    start = current + 1;
+                    if(current > finish)
+                    {
+                        break;
+                    }
+                    else if('\n' == ch )
+                    {
+                        bytestring_append(val,YAMLBYTE_NEWLINE,NULL,NULL);
+                    }
+                    else if(0 == ch)
+                    {
+                        bytestring_append(val,YAMLBYTE_NULLCHAR,NULL,NULL);
+                    }
+                    else 
+                    {
+                        assert("oops");
+                    }
+                }
+                current += 1;
+            }
+        break;
+        case syck_seq_kind:
+            bytestring_append(val,YAMLBYTE_SEQUENCE,NULL,NULL);
+            for ( i = 0; i < n->data.list->idx; i++ )
+            {
+                oid = syck_seq_read( n, i );
+                syck_lookup_sym( p, oid, (char **)&sav );
+                bytestring_extend(val, sav);
+            }
+            bytestring_append(val,YAMLBYTE_END_BRANCH,NULL,NULL);
+        break;
+        case syck_map_kind:
+            bytestring_append(val,YAMLBYTE_MAPPING,NULL,NULL);
+            for ( i = 0; i < n->data.pairs->idx; i++ )
+            {
+                oid = syck_map_read( n, map_key, i );
+                syck_lookup_sym( p, oid, (char **)&sav );
+                bytestring_extend(val, sav);
+                oid = syck_map_read( n, map_value, i );
+                syck_lookup_sym( p, oid, (char **)&sav );
+                bytestring_extend(val, sav);
+            }
+            bytestring_append(val,YAMLBYTE_END_BRANCH,NULL,NULL);
+        break;
+    }
+    oid = syck_add_sym( p, (char *) val );
+    /*TRACE1("Saving: %s", val->buffer );*/
+    return oid;
+}
+
+char *
+syck_yaml2byte(char *yamlstr)
+{
+    SYMID oid;
+    char *ret;
+    bytestring_t *sav; 
+
+    SyckParser *parser = syck_new_parser();
+    syck_parser_str_auto( parser, yamlstr, NULL );
+    syck_parser_handler( parser, syck_yaml2byte_handler );
+    syck_parser_error_handler( parser, NULL );
+    syck_parser_implicit_typing( parser, 1 );
+    syck_parser_taguri_expansion( parser, 1 );
+    oid = syck_parse( parser );
+
+    if ( syck_lookup_sym( parser, oid, (char **)&sav ) == 1 ) {
+        ret = S_ALLOC_N( char, strlen( sav->buffer ) + 3 );
+        ret[0] = '\0';
+        strcat( ret, "D\n" );
+        strcat( ret, sav->buffer );
+    }
+    else
+    {
+        ret = NULL;
+    }
+
+    syck_free_parser( parser );
+    return ret;
+}
+
+#ifdef TEST_YBEXT
+#include <stdio.h>
+int main() {
+   char *yaml = "test: 1\nand: \"with new\\nline\\n\"\nalso: &3 three\nmore: *3";
+   printf("--- # YAML \n");
+   printf(yaml);
+   printf("\n...\n");
+   printf(syck_yaml2byte(yaml));
+   return 0;
+}
+#endif
+

data/psp/syck/yamlbyte.h

@@ -0,0 +1,170 @@
+/*  yamlbyte.h
+ *
+ *  The YAML bytecode "C" interface header file.   See the YAML bytecode
+ *  reference for bytecode sequence rules and for the meaning of each
+ *  bytecode.
+ */
+
+#ifndef YAMLBYTE_H
+#define YAMLBYTE_H
+#include <stddef.h>
+
+/* define what a character is */
+typedef unsigned char yamlbyte_utf8_t;
+typedef unsigned short yamlbyte_utf16_t;
+#ifdef YAMLBYTE_UTF8
+  #ifdef YAMLBYTE_UTF16
+    #error Must only define YAMLBYTE_UTF8 or YAMLBYTE_UTF16
+  #endif
+  typedef yamlbyte_utf8_t yamlbyte_char_t;
+#else
+  #ifdef YAMLBYTE_UTF16
+    typedef yamlbyte_utf16_t yamlbyte_char_t;
+  #else
+    #error Must define YAMLBYTE_UTF8 or YAMLBYTE_UTF16
+  #endif
+#endif
+
+/* specify list of bytecodes */
+#define YAMLBYTE_FINISH          ((yamlbyte_char_t) 0)
+#define YAMLBYTE_DOCUMENT        ((yamlbyte_char_t)'D')
+#define YAMLBYTE_DIRECTIVE       ((yamlbyte_char_t)'V')
+#define YAMLBYTE_PAUSE           ((yamlbyte_char_t)'P')
+#define YAMLBYTE_MAPPING         ((yamlbyte_char_t)'M')
+#define YAMLBYTE_SEQUENCE        ((yamlbyte_char_t)'Q')
+#define YAMLBYTE_END_BRANCH      ((yamlbyte_char_t)'E')
+#define YAMLBYTE_SCALAR          ((yamlbyte_char_t)'S')
+#define YAMLBYTE_CONTINUE        ((yamlbyte_char_t)'C')
+#define YAMLBYTE_NEWLINE         ((yamlbyte_char_t)'N')
+#define YAMLBYTE_NULLCHAR        ((yamlbyte_char_t)'Z')
+#define YAMLBYTE_ANCHOR          ((yamlbyte_char_t)'A')
+#define YAMLBYTE_ALIAS           ((yamlbyte_char_t)'R')
+#define YAMLBYTE_TRANSFER        ((yamlbyte_char_t)'T')
+/* formatting bytecodes */
+#define YAMLBYTE_COMMENT         ((yamlbyte_char_t)'c')
+#define YAMLBYTE_INDENT          ((yamlbyte_char_t)'i')
+#define YAMLBYTE_STYLE           ((yamlbyte_char_t)'s')
+/* other bytecodes */
+#define YAMLBYTE_LINE_NUMBER     ((yamlbyte_char_t)'#')
+#define YAMLBYTE_WHOLE_SCALAR    ((yamlbyte_char_t)'<')
+#define YAMLBYTE_NOTICE          ((yamlbyte_char_t)'!')
+#define YAMLBYTE_SPAN            ((yamlbyte_char_t)')')
+#define YAMLBYTE_ALLOC           ((yamlbyte_char_t)'@')
+
+/* second level style bytecodes, ie "s>" */
+#define YAMLBYTE_FLOW            ((yamlbyte_char_t)'>')
+#define YAMLBYTE_LITERAL         ((yamlbyte_char_t)'|')
+#define YAMLBYTE_BLOCK           ((yamlbyte_char_t)'b')
+#define YAMLBYTE_PLAIN           ((yamlbyte_char_t)'p')
+#define YAMLBYTE_INLINE_MAPPING  ((yamlbyte_char_t)'{')
+#define YAMLBYTE_INLINE_SEQUENCE ((yamlbyte_char_t)'[')
+#define YAMLBYTE_SINGLE_QUOTED   ((yamlbyte_char_t)39)
+#define YAMLBYTE_DOUBLE_QUOTED   ((yamlbyte_char_t)'"')
+
+/*
+ * The "C" API has two variants, one based on instructions,
+ * with events delivered via pointers; and the other one
+ * is character based where one or more instructions are
+ * serialized into a buffer.
+ *
+ * Note: In the instruction based API, WHOLE_SCALAR does
+ *       not have the '<here' marshalling stuff.
+ */
+
+typedef void * yamlbyte_consumer_t;
+typedef void * yamlbyte_producer_t;
+
+/* push and pull APIs need a way to communicate results */
+typedef enum {
+    YAMLBYTE_OK          = 0,     /* proceed                        */
+    YAMLBYTE_E_MEMORY    = 'M',   /* could not allocate memory      */
+    YAMLBYTE_E_READ      = 'R',   /* input stream read error        */
+    YAMLBYTE_E_WRITE     = 'W',   /* output stream write error      */
+    YAMLBYTE_E_OTHER     = '?',   /* some other error condition     */
+    YAMLBYTE_E_PARSE     = 'P',   /* parse error, check bytecodes   */
+} yamlbyte_result_t;
+ 
+typedef const yamlbyte_char_t *yamlbyte_buff_t; 
+
+/* 
+ *  The "Instruction" API 
+ */
+
+typedef struct yaml_instruction {
+    yamlbyte_char_t bytecode;
+    yamlbyte_buff_t start;
+    yamlbyte_buff_t finish;  /* open range, *finish is _not_ part */
+} *yamlbyte_inst_t;
+
+/* producer pushes the instruction with one bytecode event to the 
+ * consumer; if the consumer's result is not YAMLBYTE_OK, then
+ * the producer should stop */
+typedef
+  yamlbyte_result_t
+   (*yamlbyte_push_t)(
+     yamlbyte_consumer_t self,
+     yamlbyte_inst_t  inst
+   );
+
+/* consumer pulls a bytecode instruction from the producer; in this
+ * case the instruction (and is buffer) are owned by the producer and
+ * will remain valid till the pull function is called once again;
+ * if the instruction is NULL, then there are no more results; and
+ * it is important to call the pull function till it returns NULL so 
+ * that the producer can clean up its memory allocations */
+typedef 
+   yamlbyte_result_t
+    (*yamlbyte_pull_t)(
+      yamlbyte_producer_t self,
+      yamlbyte_inst_t *inst   /* to be filled in by the producer */
+    ); 
+
+/*
+ *  Buffer based API
+ */
+
+/* producer pushes a null terminated buffer filled with one or more
+ * bytecode events to the consumer; if the consumer's result is not
+ * YAMLBYTE_OK, then the producer should stop */
+typedef
+  yamlbyte_result_t
+   (*yamlbyte_pushbuff_t)(
+     yamlbyte_consumer_t self,
+     yamlbyte_buff_t  buff
+   );
+
+/* consumer pulls bytecode events from the producer; in this case
+ * the buffer is owned by the producer, and will remain valid till
+ * the pull function is called once again; if the buffer pointer
+ * is set to NULL, then there are no more results; it is important
+ * to call the pull function till it returns NULL so that the
+ * producer can clean up its memory allocations */
+typedef 
+   yamlbyte_result_t
+    (*yamlbyte_pullbuff_t)(
+      yamlbyte_producer_t self,
+      yamlbyte_buff_t *buff   /* to be filled in by the producer */
+    ); 
+
+/* convert a pull interface to a push interface; the reverse process
+ * requires threads and thus is language dependent */
+#define YAMLBYTE_PULL2PUSH(pull,producer,push,consumer,result)       \
+    do {                                                         \
+        yamlbyte_pullbuff_t _pull = (pull);                              \
+        yamlbyte_pushbuff_t _push = (push);                              \
+        yamlbyte_result_t _result = YAMLBYTE_OK;                         \
+        yamlbyte_producer_t _producer = (producer);                  \
+        yamlbyte_consumer_t _consumer = (consumer);                  \
+        while(1) {                                               \
+            yamlbyte_buff_t buff = NULL;                           \
+            _result = _pull(_producer,&buff);                    \
+            if(YAMLBYTE_OK != result || NULL == buff)                \
+                break;                                           \
+            _result = _push(_consumer,buff);                     \
+            if(YAMLBYTE_OK != result)                                \
+                break;                                           \
+        }                                                        \
+        (result) = _result;                                      \
+    } while(0)
+
+#endif

data/psp/thread/thread.c

@@ -0,0 +1,1175 @@
+/*
+ * Optimized Ruby Mutex implementation, loosely based on thread.rb by
+ * Yukihiro Matsumoto <matz@ruby-lang.org>
+ *
+ *  Copyright 2006-2007  MenTaLguY <mental@rydia.net>
+ *
+ * RDoc taken from original.
+ *
+ * This file is made available under the same terms as Ruby.
+ */
+
+#include <ruby/ruby.h>
+#include <ruby/intern.h>
+#include <ruby/rubysig.h>
+
+static VALUE rb_cMutex;
+static VALUE rb_cConditionVariable;
+static VALUE rb_cQueue;
+static VALUE rb_cSizedQueue;
+
+static VALUE set_critical(VALUE value);
+
+static VALUE
+thread_exclusive_do(void)
+{
+    rb_thread_critical = 1;
+
+    return rb_yield(Qundef);
+}
+
+/*
+ *  call-seq:
+ *     Thread.exclusive { block }   => obj
+ *  
+ *  Wraps a block in Thread.critical, restoring the original value
+ *  upon exit from the critical section, and returns the value of the
+ *  block.
+ */
+
+static VALUE
+rb_thread_exclusive(void)
+{
+    return rb_ensure(thread_exclusive_do, Qundef, set_critical, rb_thread_critical);
+}
+
+typedef struct _Entry {
+    VALUE value;
+    struct _Entry *next;
+} Entry;
+
+typedef struct _List {
+    Entry *entries;
+    Entry *last_entry;
+    Entry *entry_pool;
+    unsigned long size;
+} List;
+
+static void
+init_list(List *list)
+{
+    list->entries = NULL;
+    list->last_entry = NULL;
+    list->entry_pool = NULL;
+    list->size = 0;
+}
+
+static void
+mark_list(List *list)
+{
+    Entry *entry;
+    for (entry = list->entries; entry; entry = entry->next) {
+        rb_gc_mark(entry->value);
+    }
+}
+
+static void
+free_entries(Entry *first)
+{
+    Entry *next;
+    while (first) {
+        next = first->next;
+        xfree(first);
+        first = next;
+    }
+}
+
+static void
+finalize_list(List *list)
+{
+    free_entries(list->entries);
+    free_entries(list->entry_pool);
+}
+
+static void
+push_list(List *list, VALUE value)
+{
+    Entry *entry;
+
+    if (list->entry_pool) {
+        entry = list->entry_pool;
+        list->entry_pool = entry->next;
+    } else {
+        entry = ALLOC(Entry);
+    }
+
+    entry->value = value;
+    entry->next = NULL;
+
+    if (list->last_entry) {
+        list->last_entry->next = entry;
+    } else {
+        list->entries = entry;
+    }
+    list->last_entry = entry;
+
+    ++list->size;
+}
+
+static void
+push_multiple_list(List *list, VALUE *values, unsigned count)
+{
+    unsigned i;
+    for (i = 0; i < count; i++) {
+        push_list(list, values[i]);
+    }
+}
+
+static void
+recycle_entries(List *list, Entry *first_entry, Entry *last_entry)
+{
+#ifdef USE_MEM_POOLS
+    last_entry->next = list->entry_pool;
+    list->entry_pool = first_entry;
+#else
+    last_entry->next = NULL;
+    free_entries(first_entry);
+#endif
+}
+
+static VALUE
+shift_list(List *list)
+{
+    Entry *entry;
+    VALUE value;
+
+    entry = list->entries;
+    if (!entry) return Qundef;
+
+    list->entries = entry->next;
+    if (entry == list->last_entry) {
+        list->last_entry = NULL;
+    }
+
+    --list->size;
+
+    value = entry->value;
+    recycle_entries(list, entry, entry);
+
+    return value;
+}
+
+static void
+remove_one(List *list, VALUE value)
+{
+    Entry **ref;
+    Entry *entry;
+
+    for (ref = &list->entries, entry = list->entries;
+              entry != NULL;
+              ref = &entry->next, entry = entry->next) {
+        if (entry->value == value) {
+            *ref = entry->next;
+            recycle_entries(list, entry, entry);
+            break;
+        }
+    }
+}
+
+static void
+clear_list(List *list)
+{
+    if (list->last_entry) {
+        recycle_entries(list, list->entries, list->last_entry);
+        list->entries = NULL;
+        list->last_entry = NULL;
+        list->size = 0;
+    }
+}
+
+static VALUE
+array_from_list(List const *list)
+{
+    VALUE ary;
+    Entry *entry;
+    ary = rb_ary_new();
+    for (entry = list->entries; entry; entry = entry->next) {
+        rb_ary_push(ary, entry->value);
+    }
+    return ary;
+}
+
+static VALUE
+wake_thread(VALUE thread)
+{
+    return rb_rescue2(rb_thread_wakeup, thread,
+      NULL, Qundef, rb_eThreadError, 0);
+}
+
+static VALUE
+run_thread(VALUE thread)
+{
+    return rb_rescue2(rb_thread_run, thread,
+      NULL, Qundef, rb_eThreadError, 0);
+}
+
+static VALUE
+wake_one(List *list)
+{
+    VALUE waking;
+
+    waking = Qnil;
+    while (list->entries && !RTEST(waking)) {
+        waking = wake_thread(shift_list(list));
+    }
+
+    return waking;
+}
+
+static VALUE
+wake_all(List *list)
+{
+    while (list->entries) {
+        wake_one(list);
+    }
+    return Qnil;
+}
+
+static VALUE
+wait_list_inner(List *list)
+{
+    push_list(list, rb_thread_current());
+    rb_thread_stop();
+    return Qnil;
+}
+
+static VALUE
+wait_list_cleanup(List *list)
+{
+    /* cleanup in case of spurious wakeups */
+    remove_one(list, rb_thread_current());
+    return Qnil;
+}
+
+static void
+wait_list(List *list)
+{
+    rb_ensure(wait_list_inner, (VALUE)list, wait_list_cleanup, (VALUE)list);
+}
+
+static void
+assert_no_survivors(List *waiting, const char *label, void *addr)
+{
+    Entry *entry;
+    for (entry = waiting->entries; entry; entry = entry->next) {
+        if (RTEST(wake_thread(entry->value))) {
+            rb_bug("%s %p freed with live thread(s) waiting", label, addr);
+        }
+    }
+}
+
+/*
+ * Document-class: Mutex
+ *
+ * Mutex implements a simple semaphore that can be used to coordinate access to
+ * shared data from multiple concurrent threads.
+ *
+ * Example:
+ *
+ *   require 'thread'
+ *   semaphore = Mutex.new
+ *
+ *   a = Thread.new {
+ *     semaphore.synchronize {
+ *       # access shared resource
+ *     }
+ *   }
+ *
+ *   b = Thread.new {
+ *     semaphore.synchronize {
+ *       # access shared resource
+ *     }
+ *   }
+ *
+ */
+
+typedef struct _Mutex {
+    VALUE owner;
+    List waiting;
+} Mutex;
+
+static void
+mark_mutex(Mutex *mutex)
+{
+    rb_gc_mark(mutex->owner);
+    mark_list(&mutex->waiting);
+}
+
+static void
+finalize_mutex(Mutex *mutex)
+{
+    finalize_list(&mutex->waiting);
+}
+
+static void
+free_mutex(Mutex *mutex)
+{
+    assert_no_survivors(&mutex->waiting, "mutex", mutex);
+    finalize_mutex(mutex);
+    xfree(mutex);
+}
+
+static void
+init_mutex(Mutex *mutex)
+{
+    mutex->owner = Qnil;
+    init_list(&mutex->waiting);
+}
+
+/*
+ * Document-method: new
+ * call-seq: Mutex.new
+ * 
+ * Creates a new Mutex
+ *
+ */
+
+static VALUE 
+rb_mutex_alloc(VALUE klass)
+{
+    Mutex *mutex;
+    mutex = ALLOC(Mutex);
+    init_mutex(mutex);
+    return Data_Wrap_Struct(klass, mark_mutex, free_mutex, mutex);
+}
+
+/*
+ * Document-method: locked?
+ * call-seq: locked?
+ *
+ * Returns +true+ if this lock is currently held by some thread.
+ *
+ */
+
+static VALUE
+rb_mutex_locked_p(VALUE self)
+{
+    Mutex *mutex;
+    Data_Get_Struct(self, Mutex, mutex);
+    return RTEST(mutex->owner) ? Qtrue : Qfalse;
+}
+
+/*
+ * Document-method: try_lock
+ * call-seq: try_lock
+ *
+ * Attempts to obtain the lock and returns immediately. Returns +true+ if the
+ * lock was granted.
+ *
+ */
+
+static VALUE
+rb_mutex_try_lock(VALUE self)
+{
+    Mutex *mutex;
+
+    Data_Get_Struct(self, Mutex, mutex);
+
+    if (RTEST(mutex->owner))
+        return Qfalse;
+
+    mutex->owner = rb_thread_current();
+    return Qtrue;
+}
+
+/*
+ * Document-method: lock
+ * call-seq: lock
+ *
+ * Attempts to grab the lock and waits if it isn't available.
+ *
+ */
+
+static void
+lock_mutex(Mutex *mutex)
+{
+    VALUE current;
+    current = rb_thread_current();
+
+    rb_thread_critical = 1;
+
+    while (RTEST(mutex->owner)) {
+        wait_list(&mutex->waiting);
+        rb_thread_critical = 1;
+    }
+    mutex->owner = current; 
+
+    rb_thread_critical = 0;
+}
+
+static VALUE
+rb_mutex_lock(VALUE self)
+{
+    Mutex *mutex;
+    Data_Get_Struct(self, Mutex, mutex);
+    lock_mutex(mutex);
+    return self;
+}
+
+/*
+ * Document-method: unlock
+ *
+ * Releases the lock. Returns +nil+ if ref wasn't locked.
+ *
+ */
+
+static VALUE
+unlock_mutex_inner(Mutex *mutex)
+{
+    VALUE waking;
+
+    if (!RTEST(mutex->owner)) {
+        return Qundef;
+    }
+    mutex->owner = Qnil;
+    waking = wake_one(&mutex->waiting);
+
+    return waking;
+}
+
+static VALUE
+set_critical(VALUE value)
+{
+    rb_thread_critical = (int)value;
+    return Qundef;
+}
+
+static VALUE
+unlock_mutex(Mutex *mutex)
+{
+    VALUE waking;
+
+    rb_thread_critical = 1;
+    waking = rb_ensure(unlock_mutex_inner, (VALUE)mutex, set_critical, 0);
+
+    if (waking == Qundef) {
+        return Qfalse;
+    }
+
+    if (RTEST(waking)) {
+        run_thread(waking);
+    }
+
+    return Qtrue;
+}
+
+static VALUE
+rb_mutex_unlock(VALUE self)
+{
+    Mutex *mutex;
+    Data_Get_Struct(self, Mutex, mutex);
+
+    if (RTEST(unlock_mutex(mutex))) {
+        return self;
+    } else {
+        return Qnil;
+    }
+}
+
+/*
+ * Document-method: exclusive_unlock
+ * call-seq: exclusive_unlock { ... }
+ *
+ * If the mutex is locked, unlocks the mutex, wakes one waiting thread, and
+ * yields in a critical section.
+ *
+ */
+
+static VALUE
+rb_mutex_exclusive_unlock_inner(Mutex *mutex)
+{
+    VALUE waking;
+    waking = unlock_mutex_inner(mutex);
+    rb_yield(Qundef);
+    return waking;
+}
+
+static VALUE
+rb_mutex_exclusive_unlock(VALUE self)
+{
+    Mutex *mutex;
+    VALUE waking;
+    Data_Get_Struct(self, Mutex, mutex);
+
+    rb_thread_critical = 1;
+    waking = rb_ensure(rb_mutex_exclusive_unlock_inner, (VALUE)mutex, set_critical, 0);
+
+    if (waking == Qundef) {
+        return Qnil;
+    }
+
+    if (RTEST(waking)) {
+        run_thread(waking);
+    }
+
+    return self;
+}
+
+/*
+ * Document-method: synchronize
+ * call-seq: synchronize { ... }
+ *
+ * Obtains a lock, runs the block, and releases the lock when the block
+ * completes.  See the example under Mutex.
+ *
+ */
+
+static VALUE
+rb_mutex_synchronize(VALUE self)
+{
+    rb_mutex_lock(self);
+    return rb_ensure(rb_yield, Qundef, rb_mutex_unlock, self);
+}
+
+/*
+ * Document-class: ConditionVariable
+ *
+ * ConditionVariable objects augment class Mutex. Using condition variables,
+ * it is possible to suspend while in the middle of a critical section until a
+ * resource becomes available.
+ *
+ * Example:
+ *
+ *   require 'thread'
+ *
+ *   mutex = Mutex.new
+ *   resource = ConditionVariable.new
+ *
+ *   a = Thread.new {
+ *     mutex.synchronize {
+ *       # Thread 'a' now needs the resource
+ *       resource.wait(mutex)
+ *       # 'a' can now have the resource
+ *     }
+ *   }
+ *
+ *   b = Thread.new {
+ *     mutex.synchronize {
+ *       # Thread 'b' has finished using the resource
+ *       resource.signal
+ *     }
+ *   }
+ *
+ */
+
+typedef struct _ConditionVariable {
+    List waiting;
+} ConditionVariable;
+
+static void
+mark_condvar(ConditionVariable *condvar)
+{
+    mark_list(&condvar->waiting);
+}
+
+static void
+finalize_condvar(ConditionVariable *condvar)
+{
+    finalize_list(&condvar->waiting);
+}
+
+static void
+free_condvar(ConditionVariable *condvar)
+{
+    assert_no_survivors(&condvar->waiting, "condition variable", condvar);
+    finalize_condvar(condvar);
+    xfree(condvar);
+}
+
+static void
+init_condvar(ConditionVariable *condvar)
+{
+    init_list(&condvar->waiting);
+}
+
+/*
+ * Document-method: new
+ * call-seq: ConditionVariable.new
+ *
+ * Creates a new ConditionVariable
+ *
+ */
+
+static VALUE
+rb_condvar_alloc(VALUE klass)
+{
+    ConditionVariable *condvar;
+
+    condvar = ALLOC(ConditionVariable);
+    init_condvar(condvar);
+
+    return Data_Wrap_Struct(klass, mark_condvar, free_condvar, condvar);
+}
+
+/*
+ * Document-method: wait
+ * call-seq: wait
+ *
+ * Releases the lock held in +mutex+ and waits; reacquires the lock on wakeup.
+ *
+ */
+
+static void
+wait_condvar(ConditionVariable *condvar, Mutex *mutex)
+{
+    rb_thread_critical = 1;
+    if (!RTEST(mutex->owner)) {
+        rb_thread_critical = 0;
+        return;
+    }
+    if (mutex->owner != rb_thread_current()) {
+        rb_thread_critical = 0;
+        rb_raise(rb_eThreadError, "Not owner");
+    }
+    mutex->owner = Qnil;
+    wait_list(&condvar->waiting);
+
+    lock_mutex(mutex);
+}
+
+static VALUE
+legacy_exclusive_unlock(VALUE mutex)
+{
+    return rb_funcall(mutex, rb_intern("exclusive_unlock"), 0);
+}
+
+typedef struct {
+    ConditionVariable *condvar;
+    VALUE mutex;
+} legacy_wait_args;
+
+static VALUE
+legacy_wait(VALUE unused, legacy_wait_args *args)
+{
+    wait_list(&args->condvar->waiting);
+    rb_funcall(args->mutex, rb_intern("lock"), 0);
+    return Qnil;
+}
+
+static VALUE
+rb_condvar_wait(VALUE self, VALUE mutex_v)
+{
+    ConditionVariable *condvar;
+    Data_Get_Struct(self, ConditionVariable, condvar);
+
+    if (CLASS_OF(mutex_v) != rb_cMutex) {
+        /* interoperate with legacy mutex */
+        legacy_wait_args args;
+        args.condvar = condvar;
+        args.mutex = mutex_v;
+        rb_iterate(legacy_exclusive_unlock, mutex_v, legacy_wait, (VALUE)&args);
+    } else {
+        Mutex *mutex;
+        Data_Get_Struct(mutex_v, Mutex, mutex);
+        wait_condvar(condvar, mutex);
+    }
+
+    return self;
+}
+
+/*
+ * Document-method: broadcast
+ * call-seq: broadcast
+ *
+ * Wakes up all threads waiting for this condition.
+ *
+ */
+
+static VALUE
+rb_condvar_broadcast(VALUE self)
+{
+    ConditionVariable *condvar;
+
+    Data_Get_Struct(self, ConditionVariable, condvar);
+  
+    rb_thread_critical = 1;
+    rb_ensure(wake_all, (VALUE)&condvar->waiting, set_critical, 0);
+    rb_thread_schedule();
+
+    return self;
+}
+
+/*
+ * Document-method: signal
+ * call-seq: signal
+ *
+ * Wakes up the first thread in line waiting for this condition.
+ *
+ */
+
+static void
+signal_condvar(ConditionVariable *condvar)
+{
+    VALUE waking;
+    rb_thread_critical = 1;
+    waking = rb_ensure(wake_one, (VALUE)&condvar->waiting, set_critical, 0);
+    if (RTEST(waking)) {
+        run_thread(waking);
+    }
+}
+
+static VALUE
+rb_condvar_signal(VALUE self)
+{
+    ConditionVariable *condvar;
+    Data_Get_Struct(self, ConditionVariable, condvar);
+    signal_condvar(condvar);
+    return self;
+}
+
+/*
+ * Document-class: Queue
+ *
+ * This class provides a way to synchronize communication between threads.
+ *
+ * Example:
+ *
+ *   require 'thread'
+ *
+ *   queue = Queue.new
+ *
+ *   producer = Thread.new do
+ *     5.times do |i|
+ *       sleep rand(i) # simulate expense
+ *       queue << i
+ *       puts "#{i} produced"
+ *     end
+ *   end
+ *
+ *   consumer = Thread.new do
+ *     5.times do |i|
+ *       value = queue.pop
+ *       sleep rand(i/2) # simulate expense
+ *       puts "consumed #{value}"
+ *     end
+ *   end
+ *
+ *   consumer.join
+ *
+ */
+
+typedef struct _Queue {
+    Mutex mutex;
+    ConditionVariable value_available;
+    ConditionVariable space_available;
+    List values;
+    unsigned long capacity;
+} Queue;
+
+static void
+mark_queue(Queue *queue)
+{
+    mark_mutex(&queue->mutex);
+    mark_condvar(&queue->value_available);
+    mark_condvar(&queue->space_available);
+    mark_list(&queue->values);
+}
+
+static void
+finalize_queue(Queue *queue)
+{
+    finalize_mutex(&queue->mutex);
+    finalize_condvar(&queue->value_available);
+    finalize_condvar(&queue->space_available);
+    finalize_list(&queue->values);
+}
+
+static void
+free_queue(Queue *queue)
+{
+    assert_no_survivors(&queue->mutex.waiting, "queue", queue);
+    assert_no_survivors(&queue->space_available.waiting, "queue", queue);
+    assert_no_survivors(&queue->value_available.waiting, "queue", queue);
+    finalize_queue(queue);
+    xfree(queue);
+}
+
+static void
+init_queue(Queue *queue)
+{
+    init_mutex(&queue->mutex);
+    init_condvar(&queue->value_available);
+    init_condvar(&queue->space_available);
+    init_list(&queue->values);
+    queue->capacity = 0;
+}
+
+/*
+ * Document-method: new
+ * call-seq: new
+ *
+ * Creates a new queue.
+ *
+ */
+
+static VALUE
+rb_queue_alloc(VALUE klass)
+{
+    Queue *queue;
+    queue = ALLOC(Queue);
+    init_queue(queue);
+    return Data_Wrap_Struct(klass, mark_queue, free_queue, queue);
+}
+
+static VALUE
+rb_queue_marshal_load(VALUE self, VALUE data)
+{
+    Queue *queue;
+    VALUE array;
+    Data_Get_Struct(self, Queue, queue);
+
+    array = rb_marshal_load(data);
+    if (TYPE(array) != T_ARRAY) {
+        rb_raise(rb_eRuntimeError, "expected Array of queue data");
+    }
+    if (RARRAY(array)->len < 1) {
+        rb_raise(rb_eRuntimeError, "missing capacity value");
+    }
+    queue->capacity = NUM2ULONG(rb_ary_shift(array));
+    push_multiple_list(&queue->values, RARRAY(array)->ptr, (unsigned)RARRAY(array)->len);
+
+    return self;
+}
+
+static VALUE
+rb_queue_marshal_dump(VALUE self)
+{
+    Queue *queue;
+    VALUE array;
+    Data_Get_Struct(self, Queue, queue);
+
+    array = array_from_list(&queue->values);
+    rb_ary_unshift(array, ULONG2NUM(queue->capacity));
+    return rb_marshal_dump(array, Qnil);
+}
+
+/*
+ * Document-method: clear
+ * call-seq: clear
+ *
+ * Removes all objects from the queue.
+ *
+ */
+
+static VALUE
+rb_queue_clear(VALUE self)
+{
+    Queue *queue;
+    Data_Get_Struct(self, Queue, queue);
+
+    lock_mutex(&queue->mutex);
+    clear_list(&queue->values);
+    signal_condvar(&queue->space_available);
+    unlock_mutex(&queue->mutex);
+
+    return self;
+}
+
+/*
+ * Document-method: empty?
+ * call-seq: empty?
+ *
+ * Returns +true+ if the queue is empty.
+ *
+ */
+
+static VALUE
+rb_queue_empty_p(VALUE self)
+{
+    Queue *queue;
+    VALUE result;
+    Data_Get_Struct(self, Queue, queue);
+
+    lock_mutex(&queue->mutex);
+    result = queue->values.size == 0 ? Qtrue : Qfalse;
+    unlock_mutex(&queue->mutex);
+
+    return result;
+}
+
+/*
+ * Document-method: length
+ * call-seq: length
+ *
+ * Returns the length of the queue.
+ *
+ */
+
+static VALUE
+rb_queue_length(VALUE self)
+{
+    Queue *queue;
+    VALUE result;
+    Data_Get_Struct(self, Queue, queue);
+
+    lock_mutex(&queue->mutex);
+    result = ULONG2NUM(queue->values.size);
+    unlock_mutex(&queue->mutex);
+
+    return result;
+}
+
+/*
+ * Document-method: num_waiting
+ * call-seq: num_waiting
+ *
+ * Returns the number of threads waiting on the queue.
+ *
+ */
+
+static VALUE
+rb_queue_num_waiting(VALUE self)
+{
+    Queue *queue;
+    VALUE result;
+    Data_Get_Struct(self, Queue, queue);
+
+    lock_mutex(&queue->mutex);
+    result = ULONG2NUM(queue->value_available.waiting.size +
+      queue->space_available.waiting.size);
+    unlock_mutex(&queue->mutex);
+
+    return result;
+}
+
+/*
+ * Document-method: pop
+ * call_seq: pop(non_block=false)
+ *
+ * Retrieves data from the queue.  If the queue is empty, the calling thread is
+ * suspended until data is pushed onto the queue.  If +non_block+ is true, the
+ * thread isn't suspended, and an exception is raised.
+ *
+ */
+
+static VALUE
+rb_queue_pop(int argc, VALUE *argv, VALUE self)
+{
+    Queue *queue;
+    int should_block;
+    VALUE result;
+    Data_Get_Struct(self, Queue, queue);
+
+    if (argc == 0) {
+        should_block = 1;
+    } else if (argc == 1) {
+        should_block = !RTEST(argv[0]);
+    } else {
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
+    }
+
+    lock_mutex(&queue->mutex);
+    if (!queue->values.entries && !should_block) {
+        unlock_mutex(&queue->mutex);
+        rb_raise(rb_eThreadError, "queue empty");
+    }
+
+    while (!queue->values.entries) {
+        wait_condvar(&queue->value_available, &queue->mutex);
+    }
+
+    result = shift_list(&queue->values);
+    if (queue->capacity && queue->values.size < queue->capacity) {
+        signal_condvar(&queue->space_available);
+    }
+    unlock_mutex(&queue->mutex);
+
+    return result;
+}
+
+/*
+ * Document-method: push
+ * call-seq: push(obj)
+ *
+ * Pushes +obj+ to the queue.
+ *
+ */
+
+static VALUE
+rb_queue_push(VALUE self, VALUE value)
+{
+    Queue *queue;
+    Data_Get_Struct(self, Queue, queue);
+
+    lock_mutex(&queue->mutex);
+    while (queue->capacity && queue->values.size >= queue->capacity) {
+        wait_condvar(&queue->space_available, &queue->mutex);
+    }
+    push_list(&queue->values, value);
+    signal_condvar(&queue->value_available);
+    unlock_mutex(&queue->mutex);
+
+    return self;
+}
+
+/*
+ * Document-class: SizedQueue
+ *
+ * This class represents queues of specified size capacity.  The push operation
+ * may be blocked if the capacity is full.
+ *
+ * See Queue for an example of how a SizedQueue works.
+ *
+ */
+
+/*
+ * Document-method: new
+ * call-seq: new
+ *
+ * Creates a fixed-length queue with a maximum size of +max+.
+ *
+ */
+
+/*
+ * Document-method: max
+ * call-seq: max
+ *
+ * Returns the maximum size of the queue.
+ *
+ */
+
+static VALUE
+rb_sized_queue_max(VALUE self)
+{
+    Queue *queue;
+    VALUE result;
+    Data_Get_Struct(self, Queue, queue);
+
+    lock_mutex(&queue->mutex);
+    result = ULONG2NUM(queue->capacity);
+    unlock_mutex(&queue->mutex);
+
+    return result;
+}
+
+/*
+ * Document-method: max=
+ * call-seq: max=(size)
+ *
+ * Sets the maximum size of the queue.
+ *
+ */
+
+static VALUE
+rb_sized_queue_max_set(VALUE self, VALUE value)
+{
+    Queue *queue;
+    unsigned long new_capacity;
+    unsigned long difference;
+    Data_Get_Struct(self, Queue, queue);
+
+    new_capacity = NUM2ULONG(value);
+
+    if (new_capacity < 1) {
+        rb_raise(rb_eArgError, "value must be positive");
+    }
+
+    lock_mutex(&queue->mutex);
+    if (queue->capacity && new_capacity > queue->capacity) {
+        difference = new_capacity - queue->capacity;
+    } else {
+        difference = 0;
+    }
+    queue->capacity = new_capacity;
+    for (; difference > 0; --difference) {
+        signal_condvar(&queue->space_available);
+    }
+    unlock_mutex(&queue->mutex);
+
+    return self;
+}
+
+/*
+ * Document-method: push
+ * call-seq: push(obj)
+ *
+ * Pushes +obj+ to the queue.  If there is no space left in the queue, waits
+ * until space becomes available.
+ *
+ */
+
+/*
+ * Document-method: pop
+ * call-seq: pop(non_block=false)
+ *
+ * Retrieves data from the queue and runs a waiting thread, if any.
+ *
+ */
+
+/* for marshalling mutexes and condvars */
+
+static VALUE
+dummy_load(VALUE self, VALUE string)
+{
+    return Qnil;
+}
+
+static VALUE
+dummy_dump(VALUE self)
+{
+    return rb_str_new2("");
+}
+
+void
+Init_thread(void)
+{
+    rb_define_singleton_method(rb_cThread, "exclusive", rb_thread_exclusive, 0);
+
+    rb_cMutex = rb_define_class("Mutex", rb_cObject);
+    rb_define_alloc_func(rb_cMutex, rb_mutex_alloc);
+    rb_define_method(rb_cMutex, "marshal_load", dummy_load, 1);
+    rb_define_method(rb_cMutex, "marshal_dump", dummy_dump, 0);
+    rb_define_method(rb_cMutex, "locked?", rb_mutex_locked_p, 0);
+    rb_define_method(rb_cMutex, "try_lock", rb_mutex_try_lock, 0);
+    rb_define_method(rb_cMutex, "lock", rb_mutex_lock, 0);
+    rb_define_method(rb_cMutex, "unlock", rb_mutex_unlock, 0);
+    rb_define_method(rb_cMutex, "exclusive_unlock", rb_mutex_exclusive_unlock, 0);
+    rb_define_method(rb_cMutex, "synchronize", rb_mutex_synchronize, 0);
+
+    rb_cConditionVariable = rb_define_class("ConditionVariable", rb_cObject);
+    rb_define_alloc_func(rb_cConditionVariable, rb_condvar_alloc);
+    rb_define_method(rb_cConditionVariable, "marshal_load", dummy_load, 1);
+    rb_define_method(rb_cConditionVariable, "marshal_dump", dummy_dump, 0);
+    rb_define_method(rb_cConditionVariable, "wait", rb_condvar_wait, 1);
+    rb_define_method(rb_cConditionVariable, "broadcast", rb_condvar_broadcast, 0);
+    rb_define_method(rb_cConditionVariable, "signal", rb_condvar_signal, 0);
+
+    rb_cQueue = rb_define_class("Queue", rb_cObject);
+    rb_define_alloc_func(rb_cQueue, rb_queue_alloc);
+    rb_define_method(rb_cQueue, "marshal_load", rb_queue_marshal_load, 1);
+    rb_define_method(rb_cQueue, "marshal_dump", rb_queue_marshal_dump, 0);
+    rb_define_method(rb_cQueue, "clear", rb_queue_clear, 0);
+    rb_define_method(rb_cQueue, "empty?", rb_queue_empty_p, 0);
+    rb_define_method(rb_cQueue, "length", rb_queue_length, 0);
+    rb_define_method(rb_cQueue, "num_waiting", rb_queue_num_waiting, 0);
+    rb_define_method(rb_cQueue, "pop", rb_queue_pop, -1);
+    rb_define_method(rb_cQueue, "push", rb_queue_push, 1);
+    rb_alias(rb_cQueue, rb_intern("enq"), rb_intern("push"));
+    rb_alias(rb_cQueue, rb_intern("<<"), rb_intern("push"));
+    rb_alias(rb_cQueue, rb_intern("deq"), rb_intern("pop"));
+    rb_alias(rb_cQueue, rb_intern("shift"), rb_intern("pop"));
+    rb_alias(rb_cQueue, rb_intern("size"), rb_intern("length"));
+
+    rb_cSizedQueue = rb_define_class("SizedQueue", rb_cQueue);
+    rb_define_method(rb_cSizedQueue, "initialize", rb_sized_queue_max_set, 1);
+    rb_define_method(rb_cSizedQueue, "num_waiting", rb_queue_num_waiting, 0);
+    rb_define_method(rb_cSizedQueue, "pop", rb_queue_pop, -1);
+    rb_define_method(rb_cSizedQueue, "push", rb_queue_push, 1);
+    rb_define_method(rb_cSizedQueue, "max", rb_sized_queue_max, 0);
+    rb_define_method(rb_cSizedQueue, "max=", rb_sized_queue_max_set, 1);
+    rb_alias(rb_cSizedQueue, rb_intern("enq"), rb_intern("push"));
+    rb_alias(rb_cSizedQueue, rb_intern("<<"), rb_intern("push"));
+    rb_alias(rb_cSizedQueue, rb_intern("deq"), rb_intern("pop"));
+    rb_alias(rb_cSizedQueue, rb_intern("shift"), rb_intern("pop"));
+}
+