if (initialized) {

return;

} else {

initialized = true;

}

HandleScope scope;

HandleWrap::Initialize(target);

slab_sym = Persistent<String>::New(String::NewSymbol("slab"));

buffer_sym = Persistent<String>::New(String::NewSymbol("buffer"));

write_queue_size_sym =

Persistent<String>::New(String::NewSymbol("writeQueueSize"));

: HandleWrap(object, (uv_handle_t*)stream) {

stream_ = stream;

if (stream) {

stream->data = this;

}

HandleWrap::SetHandle(h);

stream_ = (uv_stream_t*)h;

stream_->data = this;

HandleScope scope;

UNWRAP

bool ipc_pipe = wrap->stream_->type == UV_NAMED_PIPE &&

((uv_pipe_t*)wrap->stream_)->ipc;

int r;

if (ipc_pipe) {

r = uv_read2_start(wrap->stream_, OnAlloc, OnRead2);

} else {

r = uv_read_start(wrap->stream_, OnAlloc, OnRead);

}

// Error starting the tcp.

if (r) SetErrno(uv_last_error(uv_default_loop()));

return scope.Close(Integer::New(r));

HandleScope scope;

UNWRAP

int r = uv_read_stop(wrap->stream_);

// Error starting the tcp.

if (r) SetErrno(uv_last_error(uv_default_loop()));

return scope.Close(Integer::New(r));

HandleScope scope;

StreamWrap* wrap = static_cast<StreamWrap*>(handle->data);

assert(wrap->stream_ == reinterpret_cast<uv_stream_t*>(handle));

char* slab = NULL;

Handle<Object> global = Context::GetCurrent()->Global();

Local<Value> slab_v = global->GetHiddenValue(slab_sym);

if (slab_v.IsEmpty()) {

// No slab currently. Create a new one.

slab = NewSlab(global, wrap->object_);

} else {

// Use existing slab.

Local<Object> slab_obj = slab_v->ToObject();

slab = Buffer::Data(slab_obj);

assert(Buffer::Length(slab_obj) == SLAB_SIZE);

assert(SLAB_SIZE >= slab_used);

// If less than 64kb is remaining on the slab allocate a new one.

if (SLAB_SIZE - slab_used < 64 * 1024) {

slab = NewSlab(global, wrap->object_);

} else {

wrap->object_->SetHiddenValue(slab_sym, slab_obj);

}

}

uv_buf_t buf;

buf.base = slab + slab_used;

buf.len = MIN(SLAB_SIZE - slab_used, suggested_size);

wrap->slab_offset_ = slab_used;

slab_used += buf.len;

handle_that_last_alloced = reinterpret_cast<uv_stream_t*>(handle);

return buf;

uv_buf_t buf, uv_handle_type pending) {

HandleScope scope;

StreamWrap* wrap = static_cast<StreamWrap*>(handle->data);

// We should not be getting this callback if someone as already called

// uv_close() on the handle.

assert(wrap->object_.IsEmpty() == false);

// Remove the reference to the slab to avoid memory leaks;

Local<Value> slab_v = wrap->object_->GetHiddenValue(slab_sym);

wrap->object_->SetHiddenValue(slab_sym, v8::Null());

if (nread < 0) {

// EOF or Error

if (handle_that_last_alloced == handle) {

slab_used -= buf.len;

}

SetErrno(uv_last_error(uv_default_loop()));

MakeCallback(wrap->object_, "onread", 0, NULL);

return;

}

assert(nread <= buf.len);

if (handle_that_last_alloced == handle) {

slab_used -= (buf.len - nread);

}

if (nread == 0) return;

int argc = 3;

Local<Value> argv[4] = {

slab_v,

Integer::New(wrap->slab_offset_),

Integer::New(nread)

};

Local<Object> pending_obj;

if (pending == UV_TCP) {

pending_obj = TCPWrap::Instantiate();

} else if (pending == UV_NAMED_PIPE) {

pending_obj = PipeWrap::Instantiate();

} else {

// We only support sending UV_TCP and UV_NAMED_PIPE right now.

assert(pending == UV_UNKNOWN_HANDLE);

}

if (!pending_obj.IsEmpty()) {

assert(pending_obj->InternalFieldCount() > 0);

StreamWrap* pending_wrap =

static_cast<StreamWrap*>(pending_obj->GetPointerFromInternalField(0));

if (uv_accept(handle, pending_wrap->GetStream())) abort();

argv[3] = pending_obj;

argc++;

}

MakeCallback(wrap->object_, "onread", argc, argv);

HandleScope scope;

UNWRAP

bool ipc_pipe = wrap->stream_->type == UV_NAMED_PIPE &&

((uv_pipe_t*)wrap->stream_)->ipc;

// The first argument is a buffer.

assert(Buffer::HasInstance(args[0]));

Local<Object> buffer_obj = args[0]->ToObject();

size_t offset = 0;

size_t length = Buffer::Length(buffer_obj);

if (args.Length() > 1) {

offset = args[1]->IntegerValue();

}

if (args.Length() > 2) {

length = args[2]->IntegerValue();

}

WriteWrap* req_wrap = new WriteWrap();

req_wrap->object_->SetHiddenValue(buffer_sym, buffer_obj);

uv_buf_t buf;

buf.base = Buffer::Data(buffer_obj) + offset;

buf.len = length;

int r;

if (!ipc_pipe) {

r = uv_write(&req_wrap->req_, wrap->stream_, &buf, 1, StreamWrap::AfterWrite);

} else {

uv_stream_t* send_stream = NULL;

if (args[3]->IsObject()) {

Local<Object> send_stream_obj = args[3]->ToObject();

assert(send_stream_obj->InternalFieldCount() > 0);

StreamWrap* send_stream_wrap = static_cast<StreamWrap*>(

send_stream_obj->GetPointerFromInternalField(0));

send_stream = send_stream_wrap->GetStream();

}

r = uv_write2(&req_wrap->req_,

wrap->stream_,

&buf,

1,

send_stream,

StreamWrap::AfterWrite);

}

req_wrap->Dispatched();

wrap->UpdateWriteQueueSize();

if (r) {

SetErrno(uv_last_error(uv_default_loop()));

delete req_wrap;

return scope.Close(v8::Null());

} else {

return scope.Close(req_wrap->object_);

}

WriteWrap* req_wrap = (WriteWrap*) req->data;

StreamWrap* wrap = (StreamWrap*) req->handle->data;

HandleScope scope;

// The wrap and request objects should still be there.

assert(req_wrap->object_.IsEmpty() == false);

assert(wrap->object_.IsEmpty() == false);

if (status) {

SetErrno(uv_last_error(uv_default_loop()));

}

wrap->UpdateWriteQueueSize();

Local<Value> argv[4] = {

Integer::New(status),

Local<Value>::New(wrap->object_),

Local<Value>::New(req_wrap->object_),

req_wrap->object_->GetHiddenValue(buffer_sym),

};

MakeCallback(req_wrap->object_, "oncomplete", 4, argv);

delete req_wrap;

HandleScope scope;

UNWRAP

ShutdownWrap* req_wrap = new ShutdownWrap();

int r = uv_shutdown(&req_wrap->req_, wrap->stream_, AfterShutdown);

req_wrap->Dispatched();

if (r) {

SetErrno(uv_last_error(uv_default_loop()));

delete req_wrap;

return scope.Close(v8::Null());

} else {

return scope.Close(req_wrap->object_);

}

ReqWrap<uv_shutdown_t>* req_wrap = (ReqWrap<uv_shutdown_t>*) req->data;

StreamWrap* wrap = (StreamWrap*) req->handle->data;

// The wrap and request objects should still be there.

assert(req_wrap->object_.IsEmpty() == false);

assert(wrap->object_.IsEmpty() == false);

HandleScope scope;

if (status) {

SetErrno(uv_last_error(uv_default_loop()));

}

Local<Value> argv[3] = {

Integer::New(status),

Local<Value>::New(wrap->object_),

Local<Value>::New(req_wrap->object_)

};

MakeCallback(req_wrap->object_, "oncomplete", 3, argv);

delete req_wrap;