Merge branch 'v0.6'

Conflicts:
	src/handle_wrap.cc
	src/node_zlib.cc
	src/process_wrap.cc

diff --cc Makefile
Simple merge

diff --cc src/handle_wrap.cc
Simple merge

diff --cc src/node_zlib.cc
index 228427b,fe7be74..a597ffa
--- 1/src/node_zlib.cc
--- 2/src/node_zlib.cc
+++ b/src/node_zlib.cc
@@@ -29,21 -29,14 +29,16 @@@
  
  #include <node.h>
  #include <node_buffer.h>
- #include <req_wrap.h>
- 
- #include <node_vars.h>
 +#include <node_vars.h>
 +// We do the following to minimize the detal between v0.6 branch. We want to
 +// use the variables as they were being used before.
 +#define callback_sym NODE_VAR(callback_sym)
  
  
  namespace node {
  using namespace v8;
  
- // write() returns one of these, and then calls the cb() when it's done.
- typedef ReqWrap<uv_work_t> WorkReqWrap;
  
 -static Persistent<String> callback_sym;
 -
  enum node_zlib_mode {
    DEFLATE = 1,
    INFLATE,
@@@ -130,11 -122,7 +127,7 @@@ template <node_zlib_mode mode> class ZC
      // set this so that later on, I can easily tell how much was written.
      ctx->chunk_size_ = out_len;
  
-     // build up the work request
-     uv_work_t* work_req = new uv_work_t();
-     work_req->data = req_wrap;
- 
 -    uv_queue_work(uv_default_loop(),
 +    uv_queue_work(Loop(),
                    work_req,
                    ZCtx<mode>::Process,
                    ZCtx<mode>::After);
@@@ -168,23 -154,7 +159,23 @@@
        case INFLATE:
        case GUNZIP:
        case INFLATERAW:
-         err = inflate(&(ctx->strm_), ctx->flush_);
+         err = inflate(&ctx->strm_, ctx->flush_);
 +
 +        // If data was encoded with dictionary
 +        if (err == Z_NEED_DICT) {
 +          assert(ctx->dictionary_ != NULL && "Stream has no dictionary");
 +
 +          // Load it
 +          err = inflateSetDictionary(
 +              &(ctx->strm_),
 +              ctx->dictionary_,
 +              ctx->dictionary_len_
 +          );
 +          assert(err == Z_OK && "Failed to set dictionary");
 +
 +          // And try to decode again
 +          err = inflate(&(ctx->strm_), ctx->flush_);
 +        }
          break;
        default:
          assert(0 && "wtf?");
@@@ -224,12 -193,11 +214,11 @@@
    }
  
    // just pull the ints out of the args and call the other Init
-   static Handle<Value>
-   Init(const Arguments& args) {
+   static Handle<Value> Init(const Arguments& args) {
      HandleScope scope;
  
 -    assert(args.Length() == 4 &&
 -           "init(windowBits, level, memLevel, strategy)");
 +    assert((args.Length() == 4 || args.Length() == 5) &&
 +           "init(windowBits, level, memLevel, strategy, [dictionary])");
  
      ZCtx<mode> *ctx = ObjectWrap::Unwrap< ZCtx<mode> >(args.This());
  
@@@ -265,14 -221,8 +254,8 @@@
      return Undefined();
    }
  
-   static void
-   Init(ZCtx *ctx,
-        int level,
-        int windowBits,
-        int memLevel,
-        int strategy,
-        char* dictionary,
-        size_t dictionary_len) {
+   static void Init(ZCtx *ctx, int level, int windowBits, int memLevel,
 -                   int strategy) {
++                   int strategy, char* dictionary, size_t dictionary_len) {
      ctx->level_ = level;
      ctx->windowBits_ = windowBits;
      ctx->memLevel_ = memLevel;
@@@ -318,29 -268,9 +301,30 @@@
          assert(0 && "wtf?");
      }
  
 +    assert(err == Z_OK);
 +
 +    ctx->dictionary_ = reinterpret_cast<Bytef *>(dictionary);
 +    ctx->dictionary_len_ = dictionary_len;
 +
 +    if (dictionary != NULL) {
 +      switch (mode) {
 +        case DEFLATE:
 +        case DEFLATERAW:
 +          err = deflateSetDictionary(
 +              &(ctx->strm_),
 +              ctx->dictionary_,
 +              dictionary_len
 +          );
 +          break;
 +        default:
 +          break;
 +      }
 +
 +      assert(err == Z_OK && "Failed to set dictionary");
 +    }
 +
+     ctx->write_in_progress_ = false;
      ctx->init_done_ = true;
 -    assert(err == Z_OK);
    }
  
   private:

diff --cc src/process_wrap.cc
index 847a763,6600a04..5c4282f
--- 1/src/process_wrap.cc
--- 2/src/process_wrap.cc
+++ b/src/process_wrap.cc
@@@ -176,12 -175,16 +176,16 @@@ class ProcessWrap : public HandleWrap 
          Get(String::NewSymbol("windowsVerbatimArguments"))->IsTrue();
  #endif
  
 -    int r = uv_spawn(uv_default_loop(), &wrap->process_, options);
 +    int r = uv_spawn(Loop(), &wrap->process_, options);
  
-     wrap->SetHandle((uv_handle_t*)&wrap->process_);
-     assert(wrap->process_.data == wrap);
- 
-     wrap->object_->Set(String::New("pid"), Integer::New(wrap->process_.pid));
+     if (r) {
 -      SetErrno(uv_last_error(uv_default_loop()));
++      SetErrno(uv_last_error(Loop()));
+     }
+     else {
+       wrap->SetHandle((uv_handle_t*)&wrap->process_);
+       assert(wrap->process_.data == wrap);
+       wrap->object_->Set(String::New("pid"), Integer::New(wrap->process_.pid));
+     }
  
      if (options.args) {
        for (int i = 0; options.args[i]; i++) free(options.args[i]);

diff --cc src/stream_wrap.cc
index a64b4c3,b363049..37eb592
--- 1/src/stream_wrap.cc
--- 2/src/stream_wrap.cc
+++ b/src/stream_wrap.cc
@@@ -27,17 -26,6 +27,18 @@@
  #include <tcp_wrap.h>
  #include <req_wrap.h>
  
 +#include <node_vars.h>
 +
 +// We do the following to minimize the detal between v0.6 branch. We want to
 +// use the variables as they were being used before.
 +#define slab_used NODE_VAR(slab_used)
 +#define slab_sym NODE_VAR(slab_sym)
 +#define handle_that_last_alloced NODE_VAR(handle_that_last_alloced)
 +#define buffer_sym NODE_VAR(buffer_sym)
++#define buffer_constructor_template NODE_VAR(buffer_constructor_template)
 +#define write_queue_size_sym NODE_VAR(write_queue_size_sym)
 +#define stream_wrap_initialized NODE_VAR(stream_wrap_initialized)
 +
  
  namespace node {
  
@@@ -153,13 -149,17 +154,17 @@@ Handle<Value> StreamWrap::ReadStop(cons
  }
  
  
- inline char* StreamWrap::NewSlab(Handle<Object> global,
-                                         Handle<Object> wrap_obj) {
-   Buffer* b = Buffer::New(SLAB_SIZE);
-   global->SetHiddenValue(slab_sym, b->handle_);
+ char* StreamWrap::NewSlab(Handle<Object> global,
+                           Handle<Object> wrap_obj) {
+   HandleScope scope;
+   Local<Value> arg = Integer::NewFromUnsigned(SLAB_SIZE);
 -  Local<Object> b = Buffer::constructor_template->GetFunction()->
++  Local<Object> b = buffer_constructor_template->GetFunction()->
+     NewInstance(1, &arg);
+   if (b.IsEmpty()) return NULL;
+   global->SetHiddenValue(slab_sym, b);
    assert(Buffer::Length(b) == SLAB_SIZE);
    slab_used = 0;
-   wrap_obj->SetHiddenValue(slab_sym, b->handle_);
+   wrap_obj->SetHiddenValue(slab_sym, b);
    return Buffer::Data(b);
  }