diff --git a/src/async.cc b/src/async.cc index 8bc429726ff..5edf8183ddf 100644 --- a/src/async.cc +++ b/src/async.cc @@ -36,7 +36,7 @@ void AsyncWorker::WorkComplete () { void AsyncWorker::HandleOKCallback () { v8::Local argv[0]; - RUN_CALLBACK(callback, argv, 0); + LD_RUN_CALLBACK(callback, argv, 0); } void AsyncWorker::HandleErrorCallback () { @@ -45,7 +45,7 @@ void AsyncWorker::HandleErrorCallback () { v8::Exception::Error(v8::String::New(status.ToString().c_str())) ) }; - RUN_CALLBACK(callback, argv, 1); + LD_RUN_CALLBACK(callback, argv, 1); } void AsyncExecute (uv_work_t* req) { diff --git a/src/async.h b/src/async.h index 1e56e4d8e1c..65c16cf87db 100644 --- a/src/async.h +++ b/src/async.h @@ -3,8 +3,8 @@ * MIT +no-false-attribs License */ -#ifndef LU_ASYNC_H -#define LU_ASYNC_H +#ifndef LD_ASYNC_H +#define LD_ASYNC_H #include diff --git a/src/batch.h b/src/batch.h index 4d90f16baef..90aa2d9fe8f 100644 --- a/src/batch.h +++ b/src/batch.h @@ -3,8 +3,8 @@ * MIT +no-false-attribs License */ -#ifndef LU_BATCH_H -#define LU_BATCH_H +#ifndef LD_BATCH_H +#define LD_BATCH_H #include "leveldb/write_batch.h" diff --git a/src/database.cc b/src/database.cc index 677af461708..3602538e38c 100644 --- a/src/database.cc +++ b/src/database.cc @@ -143,14 +143,14 @@ v8::Handle Database::New (const v8::Arguments& args) { v8::HandleScope scope; if (args.Length() == 0) { - THROW_RETURN("leveldown() requires at least a location argument") + LD_THROW_RETURN("leveldown() requires at least a location argument") } if (!args[0]->IsString()) { - THROW_RETURN("leveldown() requires a location string argument") + LD_THROW_RETURN("leveldown() requires a location string argument") } - FROM_V8_STRING(location, v8::Handle::Cast(args[0])) + LD_FROM_V8_STRING(location, v8::Handle::Cast(args[0])) Database* obj = new Database(location); obj->Wrap(args.This()); @@ -177,12 +177,12 @@ v8::Handle Database::NewInstance (const v8::Arguments& args) { v8::Handle Database::Open (const v8::Arguments& args) { v8::HandleScope scope; - METHOD_SETUP_COMMON(open, 0, 1) + LD_METHOD_SETUP_COMMON(open, 0, 1) - BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, createIfMissing) - BOOLEAN_OPTION_VALUE(optionsObj, errorIfExists) - BOOLEAN_OPTION_VALUE(optionsObj, compression) - UINT32_OPTION_VALUE(optionsObj, cacheSize, 8 << 20) + LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, createIfMissing) + LD_BOOLEAN_OPTION_VALUE(optionsObj, errorIfExists) + LD_BOOLEAN_OPTION_VALUE(optionsObj, compression) + LD_UINT32_OPTION_VALUE(optionsObj, cacheSize, 8 << 20) OpenWorker* worker = new OpenWorker( database @@ -201,7 +201,7 @@ v8::Handle Database::Open (const v8::Arguments& args) { v8::Handle Database::Close (const v8::Arguments& args) { v8::HandleScope scope; - METHOD_SETUP_COMMON_ONEARG(close) + LD_METHOD_SETUP_COMMON_ONEARG(close) CloseWorker* worker = new CloseWorker(database, callback); AsyncQueueWorker(worker); @@ -212,22 +212,22 @@ v8::Handle Database::Close (const v8::Arguments& args) { v8::Handle Database::Put (const v8::Arguments& args) { v8::HandleScope scope; - METHOD_SETUP_COMMON(put, 2, 3) + LD_METHOD_SETUP_COMMON(put, 2, 3) - CB_ERR_IF_NULL_OR_UNDEFINED(0, Key) - CB_ERR_IF_NULL_OR_UNDEFINED(1, Value) + LD_CB_ERR_IF_NULL_OR_UNDEFINED(0, Key) + LD_CB_ERR_IF_NULL_OR_UNDEFINED(1, Value) v8::Local keyBufferV = args[0]; v8::Local valueBufferV = args[1]; - STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key) - STRING_OR_BUFFER_TO_SLICE(value, valueBufferV, Value) + LD_STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key) + LD_STRING_OR_BUFFER_TO_SLICE(value, valueBufferV, Value) v8::Persistent keyBuffer = v8::Persistent::New(keyBufferV); v8::Persistent valueBuffer = v8::Persistent::New(valueBufferV); - BOOLEAN_OPTION_VALUE(optionsObj, sync) + LD_BOOLEAN_OPTION_VALUE(optionsObj, sync) WriteWorker* worker = new WriteWorker( database @@ -246,17 +246,17 @@ v8::Handle Database::Put (const v8::Arguments& args) { v8::Handle Database::Get (const v8::Arguments& args) { v8::HandleScope scope; - METHOD_SETUP_COMMON(put, 1, 2) + LD_METHOD_SETUP_COMMON(put, 1, 2) - CB_ERR_IF_NULL_OR_UNDEFINED(0, Key) + LD_CB_ERR_IF_NULL_OR_UNDEFINED(0, Key) v8::Local keyBufferV = args[0]; - STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key) + LD_STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key) v8::Persistent keyBuffer = v8::Persistent::New(keyBufferV); - BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, asBuffer) - BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, fillCache) + LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, asBuffer) + LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, fillCache) ReadWorker* worker = new ReadWorker( database @@ -274,17 +274,17 @@ v8::Handle Database::Get (const v8::Arguments& args) { v8::Handle Database::Delete (const v8::Arguments& args) { v8::HandleScope scope; - METHOD_SETUP_COMMON(put, 1, 2) + LD_METHOD_SETUP_COMMON(put, 1, 2) - CB_ERR_IF_NULL_OR_UNDEFINED(0, Key) + LD_CB_ERR_IF_NULL_OR_UNDEFINED(0, Key) v8::Local keyBufferV = args[0]; - STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key) + LD_STRING_OR_BUFFER_TO_SLICE(key, keyBufferV, Key) v8::Persistent keyBuffer = v8::Persistent::New(keyBufferV); - BOOLEAN_OPTION_VALUE(optionsObj, sync) + LD_BOOLEAN_OPTION_VALUE(optionsObj, sync) DeleteWorker* worker = new DeleteWorker( database @@ -299,18 +299,18 @@ v8::Handle Database::Delete (const v8::Arguments& args) { } /* property key & value strings for elements of the array sent to batch() */ -LU_SYMBOL ( str_key , key ); -LU_SYMBOL ( str_value , value ); -LU_SYMBOL ( str_type , type ); -LU_SYMBOL ( str_del , del ); -LU_SYMBOL ( str_put , put ); +LD_SYMBOL ( str_key , key ); +LD_SYMBOL ( str_value , value ); +LD_SYMBOL ( str_type , type ); +LD_SYMBOL ( str_del , del ); +LD_SYMBOL ( str_put , put ); v8::Handle Database::Batch (const v8::Arguments& args) { v8::HandleScope scope; - METHOD_SETUP_COMMON(batch, 1, 2) + LD_METHOD_SETUP_COMMON(batch, 1, 2) - BOOLEAN_OPTION_VALUE(optionsObj, sync) + LD_BOOLEAN_OPTION_VALUE(optionsObj, sync) v8::Local array = v8::Local::Cast(args[0]); @@ -326,7 +326,7 @@ v8::Handle Database::Batch (const v8::Arguments& args) { v8::Local keyBuffer = obj->Get(str_key); if (obj->Get(str_type)->StrictEquals(str_del)) { - STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, Key) + LD_STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, Key) operations->push_back(new BatchDelete( key @@ -335,8 +335,8 @@ v8::Handle Database::Batch (const v8::Arguments& args) { } else if (obj->Get(str_type)->StrictEquals(str_put) && obj->Has(str_value)) { v8::Local valueBuffer = obj->Get(str_value); - STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, Key) - STRING_OR_BUFFER_TO_SLICE(value, valueBuffer, Value) + LD_STRING_OR_BUFFER_TO_SLICE(key, keyBuffer, Key) + LD_STRING_OR_BUFFER_TO_SLICE(value, valueBuffer, Value) operations->push_back(new BatchWrite( key @@ -370,18 +370,18 @@ v8::Handle Database::ApproximateSize (const v8::Arguments& args) { || endBufferV->IsUndefined() || endBufferV->IsFunction() // callback in pos 1? ) { - THROW_RETURN( \ + LD_THROW_RETURN( \ "approximateSize() requires valid `start`, `end` and `callback` arguments" \ ) } - METHOD_SETUP_COMMON(approximateSize, -1, 2) + LD_METHOD_SETUP_COMMON(approximateSize, -1, 2) - CB_ERR_IF_NULL_OR_UNDEFINED(0, Start) - CB_ERR_IF_NULL_OR_UNDEFINED(1, End) + LD_CB_ERR_IF_NULL_OR_UNDEFINED(0, Start) + LD_CB_ERR_IF_NULL_OR_UNDEFINED(1, End) - STRING_OR_BUFFER_TO_SLICE(start, startBufferV, Start) - STRING_OR_BUFFER_TO_SLICE(end, endBufferV, End) + LD_STRING_OR_BUFFER_TO_SLICE(start, startBufferV, Start) + LD_STRING_OR_BUFFER_TO_SLICE(end, endBufferV, End) v8::Persistent startBuffer = v8::Persistent::New(startBufferV); diff --git a/src/database.h b/src/database.h index ae070b85f72..67f1e2cfff8 100644 --- a/src/database.h +++ b/src/database.h @@ -3,8 +3,8 @@ * MIT +no-false-attribs License */ -#ifndef LU_DATABASE_H -#define LU_DATABASE_H +#ifndef LD_DATABASE_H +#define LD_DATABASE_H #include @@ -14,13 +14,13 @@ namespace leveldown { -LU_SYMBOL ( option_createIfMissing , createIfMissing ); // for open() -LU_SYMBOL ( option_errorIfExists , errorIfExists ); // for open() -LU_SYMBOL ( option_compression , compression ); // for open() -LU_SYMBOL ( option_cacheSize , cacheSize ); // for open() -LU_SYMBOL ( option_sync , sync ); // for put() and delete() -LU_SYMBOL ( option_asBuffer , asBuffer ); // for get() -LU_SYMBOL ( option_fillCache , fillcache ); // for get() and readStream() +LD_SYMBOL ( option_createIfMissing , createIfMissing ); // for open() +LD_SYMBOL ( option_errorIfExists , errorIfExists ); // for open() +LD_SYMBOL ( option_compression , compression ); // for open() +LD_SYMBOL ( option_cacheSize , cacheSize ); // for open() +LD_SYMBOL ( option_sync , sync ); // for put() and delete() +LD_SYMBOL ( option_asBuffer , asBuffer ); // for get() +LD_SYMBOL ( option_fillCache , fillcache ); // for get() and readStream() struct AsyncDescriptor; @@ -66,15 +66,15 @@ class Database : public node::ObjectWrap { static v8::Persistent constructor; - LU_V8_METHOD( New ) - LU_V8_METHOD( Open ) - LU_V8_METHOD( Close ) - LU_V8_METHOD( Put ) - LU_V8_METHOD( Delete ) - LU_V8_METHOD( Get ) - LU_V8_METHOD( Batch ) - LU_V8_METHOD( Iterator ) - LU_V8_METHOD( ApproximateSize ) + LD_V8_METHOD( New ) + LD_V8_METHOD( Open ) + LD_V8_METHOD( Close ) + LD_V8_METHOD( Put ) + LD_V8_METHOD( Delete ) + LD_V8_METHOD( Get ) + LD_V8_METHOD( Batch ) + LD_V8_METHOD( Iterator ) + LD_V8_METHOD( ApproximateSize ) }; } // namespace leveldown diff --git a/src/database_async.cc b/src/database_async.cc index 368e15f8fca..4345a05f631 100644 --- a/src/database_async.cc +++ b/src/database_async.cc @@ -117,7 +117,7 @@ void ReadWorker::HandleOKCallback () { v8::Local::New(v8::Null()) , returnValue }; - RUN_CALLBACK(callback, argv, 2); + LD_RUN_CALLBACK(callback, argv, 2); } /** DELETE WORKER **/ @@ -232,7 +232,7 @@ void ApproximateSizeWorker::HandleOKCallback () { v8::Local::New(v8::Null()) , returnValue }; - RUN_CALLBACK(callback, argv, 2); + LD_RUN_CALLBACK(callback, argv, 2); } } // namespace leveldown diff --git a/src/database_async.h b/src/database_async.h index f9e08a5d0f5..2f66deeca9f 100644 --- a/src/database_async.h +++ b/src/database_async.h @@ -3,8 +3,8 @@ * MIT +no-false-attribs License */ -#ifndef LU_DATABASE_ASYNC_H -#define LU_DATABASE_ASYNC_H +#ifndef LD_DATABASE_ASYNC_H +#define LD_DATABASE_ASYNC_H #include #include diff --git a/src/iterator.cc b/src/iterator.cc index 838d3b67c60..924e65d0c55 100644 --- a/src/iterator.cc +++ b/src/iterator.cc @@ -118,15 +118,15 @@ v8::Handle Iterator::Next (const v8::Arguments& args) { Iterator* iterator = node::ObjectWrap::Unwrap(args.This()); if (args.Length() == 0 || !args[0]->IsFunction()) { - THROW_RETURN("next() requires a callback argument") + LD_THROW_RETURN("next() requires a callback argument") } if (iterator->ended) { - THROW_RETURN("Cannot call next() after end()") + LD_THROW_RETURN("Cannot call next() after end()") } if (iterator->nexting) { - THROW_RETURN("Cannot call next() before previous next() has completed") + LD_THROW_RETURN("Cannot call next() before previous next() has completed") } v8::Persistent callback = @@ -148,11 +148,11 @@ v8::Handle Iterator::End (const v8::Arguments& args) { Iterator* iterator = node::ObjectWrap::Unwrap(args.This()); if (args.Length() == 0 || !args[0]->IsFunction()) { - THROW_RETURN("end() requires a callback argument") + LD_THROW_RETURN("end() requires a callback argument") } if (iterator->ended) { - THROW_RETURN("end() already called on iterator") + LD_THROW_RETURN("end() already called on iterator") } v8::Persistent callback = @@ -213,7 +213,7 @@ v8::Handle Iterator::NewInstance ( v8::Handle Iterator::New (const v8::Arguments& args) { v8::HandleScope scope; - //TODO: remove this, it's only here to make STRING_OR_BUFFER_TO_SLICE happy + //TODO: remove this, it's only here to make LD_STRING_OR_BUFFER_TO_SLICE happy v8::Local callback; Database* database = node::ObjectWrap::Unwrap(args[0]->ToObject()); @@ -233,7 +233,7 @@ v8::Handle Iterator::New (const v8::Arguments& args) { || optionsObj->Get(option_start)->IsString())) { startBuffer = v8::Local::New(optionsObj->Get(option_start)); - STRING_OR_BUFFER_TO_SLICE(_start, startBuffer, Start) + LD_STRING_OR_BUFFER_TO_SLICE(_start, startBuffer, Start) start = new leveldb::Slice(_start.data(), _start.size()); } @@ -243,7 +243,7 @@ v8::Handle Iterator::New (const v8::Arguments& args) { v8::Local endBuffer = v8::Local::New(optionsObj->Get(option_end)); - STRING_OR_BUFFER_TO_SLICE(_end, endBuffer, End) + LD_STRING_OR_BUFFER_TO_SLICE(_end, endBuffer, End) end = new std::string(_end.data(), _end.size()); } @@ -253,12 +253,12 @@ v8::Handle Iterator::New (const v8::Arguments& args) { } } - BOOLEAN_OPTION_VALUE(optionsObj, reverse) - BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, keys) - BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, values) - BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, keyAsBuffer) - BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, valueAsBuffer) - BOOLEAN_OPTION_VALUE(optionsObj, fillCache) + LD_BOOLEAN_OPTION_VALUE(optionsObj, reverse) + LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, keys) + LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, values) + LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, keyAsBuffer) + LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, valueAsBuffer) + LD_BOOLEAN_OPTION_VALUE(optionsObj, fillCache) Iterator* iterator = new Iterator( database diff --git a/src/iterator.h b/src/iterator.h index cc5389c7097..6df6957dbc6 100644 --- a/src/iterator.h +++ b/src/iterator.h @@ -3,8 +3,8 @@ * MIT +no-false-attribs License */ -#ifndef LU_ITERATOR_H -#define LU_ITERATOR_H +#ifndef LD_ITERATOR_H +#define LD_ITERATOR_H #include @@ -14,14 +14,14 @@ namespace leveldown { -LU_SYMBOL ( option_start , start ); -LU_SYMBOL ( option_end , end ); -LU_SYMBOL ( option_limit , limit ); -LU_SYMBOL ( option_reverse , reverse ); -LU_SYMBOL ( option_keys , keys ); -LU_SYMBOL ( option_values , values ); -LU_SYMBOL ( option_keyAsBuffer , keyAsBuffer ); -LU_SYMBOL ( option_valueAsBuffer , valueAsBuffer ); +LD_SYMBOL ( option_start , start ); +LD_SYMBOL ( option_end , end ); +LD_SYMBOL ( option_limit , limit ); +LD_SYMBOL ( option_reverse , reverse ); +LD_SYMBOL ( option_keys , keys ); +LD_SYMBOL ( option_values , values ); +LD_SYMBOL ( option_keyAsBuffer , keyAsBuffer ); +LD_SYMBOL ( option_valueAsBuffer , valueAsBuffer ); v8::Handle CreateIterator (const v8::Arguments& args); @@ -79,9 +79,9 @@ class Iterator : public node::ObjectWrap { static v8::Persistent constructor; - LU_V8_METHOD( New ) - LU_V8_METHOD( Next ) - LU_V8_METHOD( End ) + LD_V8_METHOD( New ) + LD_V8_METHOD( Next ) + LD_V8_METHOD( End ) }; } // namespace leveldown diff --git a/src/iterator_async.cc b/src/iterator_async.cc index e855d9bb3a4..a1b3991822d 100644 --- a/src/iterator_async.cc +++ b/src/iterator_async.cc @@ -60,10 +60,10 @@ void NextWorker::HandleOKCallback () { , returnKey , returnValue }; - RUN_CALLBACK(callback, argv, 3); + LD_RUN_CALLBACK(callback, argv, 3); } else { v8::Local argv[0]; - RUN_CALLBACK(callback, argv, 0); + LD_RUN_CALLBACK(callback, argv, 0); } } diff --git a/src/iterator_async.h b/src/iterator_async.h index 4325d20e649..9d445935c4b 100644 --- a/src/iterator_async.h +++ b/src/iterator_async.h @@ -3,8 +3,8 @@ * MIT +no-false-attribs License */ -#ifndef LU_ITERATOR_ASYNC_H -#define LU_ITERATOR_ASYNC_H +#ifndef LD_ITERATOR_ASYNC_H +#define LD_ITERATOR_ASYNC_H #include diff --git a/src/leveldown.h b/src/leveldown.h index c37aa5b95b7..3f2f1d1767c 100644 --- a/src/leveldown.h +++ b/src/leveldown.h @@ -2,28 +2,28 @@ * See list at * MIT +no-false-attribs License */ -#ifndef LU_LEVELDOWN_H -#define LU_LEVELDOWN_H +#ifndef LD_LEVELDOWN_H +#define LD_LEVELDOWN_H -#define LU_SYMBOL(var, key) \ +#define LD_SYMBOL(var, key) \ static const v8::Persistent var = \ v8::Persistent::New(v8::String::NewSymbol(#key)); -#define LU_V8_METHOD(name) \ +#define LD_V8_METHOD(name) \ static v8::Handle name (const v8::Arguments& args); -#define CB_ERR_IF_NULL_OR_UNDEFINED(index, name) \ +#define LD_CB_ERR_IF_NULL_OR_UNDEFINED(index, name) \ if (args[index]->IsNull() || args[index]->IsUndefined()) { \ v8::Local argv[] = { \ v8::Local::New(v8::Exception::Error( \ v8::String::New(#name " argument cannot be `null` or `undefined`")) \ ) \ }; \ - RUN_CALLBACK(callback, argv, 1); \ + LD_RUN_CALLBACK(callback, argv, 1); \ return v8::Undefined(); \ } -#define FROM_V8_STRING(to, from) \ +#define LD_FROM_V8_STRING(to, from) \ size_t to ## Sz_; \ char* to; \ v8::Local to ## Str = from->ToString(); \ @@ -31,20 +31,20 @@ to = new char[to ## Sz_ + 1]; \ to ## Str->WriteUtf8(to, -1, NULL, v8::String::NO_OPTIONS); -#define STRING_OR_BUFFER_TO_SLICE(to, from, name) \ +#define LD_STRING_OR_BUFFER_TO_SLICE(to, from, name) \ size_t to ## Sz_; \ char* to ## Ch_; \ if (node::Buffer::HasInstance(from->ToObject())) { \ to ## Sz_ = node::Buffer::Length(from->ToObject()); \ if (to ## Sz_ == 0) { \ - RETURN_CALLBACK_OR_ERROR(callback, #name " argument cannot be an empty Buffer") \ + LD_RETURN_CALLBACK_OR_ERROR(callback, #name " argument cannot be an empty Buffer") \ } \ to ## Ch_ = node::Buffer::Data(from->ToObject()); \ } else { \ v8::Local to ## Str = from->ToString(); \ to ## Sz_ = to ## Str->Utf8Length(); \ if (to ## Sz_ == 0) { \ - RETURN_CALLBACK_OR_ERROR(callback, #name " argument cannot be an empty String") \ + LD_RETURN_CALLBACK_OR_ERROR(callback, #name " argument cannot be an empty String") \ } \ to ## Ch_ = new char[to ## Sz_]; \ to ## Str->WriteUtf8( \ @@ -55,55 +55,55 @@ } \ leveldb::Slice to(to ## Ch_, to ## Sz_); -#define BOOLEAN_OPTION_VALUE(optionsObj, opt) \ +#define LD_BOOLEAN_OPTION_VALUE(optionsObj, opt) \ bool opt = !optionsObj.IsEmpty() \ && optionsObj->Has(option_ ## opt) \ && optionsObj->Get(option_ ## opt)->BooleanValue(); -#define BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, opt) \ +#define LD_BOOLEAN_OPTION_VALUE_DEFTRUE(optionsObj, opt) \ bool opt = optionsObj.IsEmpty() \ || !optionsObj->Has(option_ ## opt) \ || optionsObj->Get(option_ ## opt)->BooleanValue(); -#define UINT32_OPTION_VALUE(optionsObj, opt, default) \ +#define LD_UINT32_OPTION_VALUE(optionsObj, opt, default) \ uint32_t opt = !optionsObj.IsEmpty() \ && optionsObj->Has(option_ ## opt) \ && optionsObj->Get(option_ ## opt)->IsUint32() \ ? optionsObj->Get(option_ ## opt)->Uint32Value() \ : default; -#define RETURN_CALLBACK_OR_ERROR(callback, msg) \ +#define LD_RETURN_CALLBACK_OR_ERROR(callback, msg) \ if (callback->IsFunction()) { \ v8::Local argv[] = { \ v8::Local::New(v8::Exception::Error( \ v8::String::New(msg)) \ ) \ }; \ - RUN_CALLBACK(callback, argv, 1) \ + LD_RUN_CALLBACK(callback, argv, 1) \ return v8::Undefined(); \ } \ - THROW_RETURN(msg) + LD_THROW_RETURN(msg) -#define RUN_CALLBACK(callback, argv, length) \ +#define LD_RUN_CALLBACK(callback, argv, length) \ v8::TryCatch try_catch; \ callback->Call(v8::Context::GetCurrent()->Global(), length, argv); \ if (try_catch.HasCaught()) { \ node::FatalException(try_catch); \ } -#define THROW_RETURN(msg) \ +#define LD_THROW_RETURN(msg) \ v8::ThrowException(v8::Exception::Error(v8::String::New(#msg))); \ return v8::Undefined(); -/* METHOD_SETUP_COMMON setup the following objects: +/* LD_METHOD_SETUP_COMMON setup the following objects: * - Database* database * - v8::Local optionsObj (may be empty) * - v8::Persistent callback (won't be empty) - * Will THROW_RETURN if there isn't a callback in arg 0 or 1 + * Will LD_THROW_RETURN if there isn't a callback in arg 0 or 1 */ -#define METHOD_SETUP_COMMON(name, optionPos, callbackPos) \ +#define LD_METHOD_SETUP_COMMON(name, optionPos, callbackPos) \ if (args.Length() == 0) { \ - THROW_RETURN(name() requires a callback argument) \ + LD_THROW_RETURN(name() requires a callback argument) \ } \ Database* database = ObjectWrap::Unwrap(args.This()); \ v8::Local optionsObj; \ @@ -124,9 +124,9 @@ v8::Local::Cast(args[callbackPos]) \ ); \ } else { \ - THROW_RETURN(name() requires a callback argument) \ + LD_THROW_RETURN(name() requires a callback argument) \ } -#define METHOD_SETUP_COMMON_ONEARG(name) METHOD_SETUP_COMMON(name, -1, 0) +#define LD_METHOD_SETUP_COMMON_ONEARG(name) LD_METHOD_SETUP_COMMON(name, -1, 0) #endif