Paul, this breaks compilation with R13B04: make[3]: Entering directory `/home/fdmanana/git/hub/couchdb/src/snappy' /bin/bash ../../libtool --tag=CXX --mode=compile g++ -DHAVE_CONFIG_H -I. -I../.. -I../../src/snappy/google-snappy -D_XOPEN_SOURCE -L/usr/lib/xulrunner-devel-1.9.2.17/lib/ -L/usr/local/lib -L/opt/local/lib -I/opt/r13b04/lib/erlang/usr/include -I/usr/lib/xulrunner-devel-1.9.2.17/include/ -DXP_UNIX -g -O2 -MT snappy_nif.lo -MD -MP -MF .deps/snappy_nif.Tpo -c -o snappy_nif.lo snappy_nif.cc libtool: compile: g++ -DHAVE_CONFIG_H -I. -I../.. -I../../src/snappy/google-snappy -D_XOPEN_SOURCE -L/usr/lib/xulrunner-devel-1.9.2.17/lib/ -L/usr/local/lib -L/opt/local/lib -I/opt/r13b04/lib/erlang/usr/include -I/usr/lib/xulrunner-devel-1.9.2.17/include/ -DXP_UNIX -g -O2 -MT snappy_nif.lo -MD -MP -MF .deps/snappy_nif.Tpo -c snappy_nif.cc -fPIC -DPIC -o .libs/snappy_nif.o /opt/r13b04/lib/erlang/usr/include/erl_nif_api_funcs.h: In function ‘ERL_NIF_TERM make_atom(ErlNifEnv*, const char*)’: /opt/r13b04/lib/erlang/usr/include/erl_nif_api_funcs.h:48: error: too many arguments to function ‘int enif_make_existing_atom(ErlNifEnv*, const char*, ERL_NIF_TERM*)’ snappy_nif.cc:114: error: at this point in file make[3]: *** [snappy_nif.lo] Error 1 make[3]: Leaving directory `/home/fdmanana/git/hub/couchdb/src/snappy' make[2]: *** [all-recursive] Error 1 make[2]: Leaving directory `/home/fdmanana/git/hub/couchdb/src' make[1]: *** [all-recursive] Error 1 make[1]: Leaving directory `/home/fdmanana/git/hub/couchdb' make: *** [all] Error 2
Can you fix it? Thanks On Mon, May 2, 2011 at 6:51 PM, <[email protected]> wrote: > Author: davisp > Date: Mon May 2 17:51:28 2011 > New Revision: 1098691 > > URL: http://svn.apache.org/viewvc?rev=1098691&view=rev > Log: > Refactored snappy NIF. > > > Modified: > couchdb/trunk/src/snappy/snappy.erl > couchdb/trunk/src/snappy/snappy_nif.cc > > Modified: couchdb/trunk/src/snappy/snappy.erl > URL: > http://svn.apache.org/viewvc/couchdb/trunk/src/snappy/snappy.erl?rev=1098691&r1=1098690&r2=1098691&view=diff > ============================================================================== > --- couchdb/trunk/src/snappy/snappy.erl (original) > +++ couchdb/trunk/src/snappy/snappy.erl Mon May 2 17:51:28 2011 > @@ -16,8 +16,7 @@ > -module(snappy). > > -export([compress/1, decompress/1]). > --export([get_uncompressed_length/1]). > --export([is_valid_compressed_buffer/1]). > +-export([uncompressed_length/1, is_valid/1]). > > -on_load(init/0). > > @@ -49,9 +48,9 @@ decompress(_IoList) -> > exit(snappy_nif_not_loaded). > > > -get_uncompressed_length(_IoList) -> > +uncompressed_length(_IoList) -> > exit(snappy_nif_not_loaded). > > > -is_valid_compressed_buffer(_IoList) -> > +is_valid(_IoList) -> > exit(snappy_nif_not_loaded). > > Modified: couchdb/trunk/src/snappy/snappy_nif.cc > URL: > http://svn.apache.org/viewvc/couchdb/trunk/src/snappy/snappy_nif.cc?rev=1098691&r1=1098690&r2=1098691&view=diff > ============================================================================== > --- couchdb/trunk/src/snappy/snappy_nif.cc (original) > +++ couchdb/trunk/src/snappy/snappy_nif.cc Mon May 2 17:51:28 2011 > @@ -26,206 +26,240 @@ > #error OTP R13B03 not supported. Upgrade to R13B04 or later. > #endif > > +#ifdef __cplusplus > +#define BEGIN_C extern "C" { > +#define END_C } > +#else > +#define BEGIN_C > +#define END_C > +#endif > > -class SnappyNifSink : public snappy::Sink { > -public: > - SnappyNifSink(ErlNifEnv* e) : env(e), length(0) { > - if (!enif_alloc_binary_compat(env, 0, &bin)) { > - enif_release_binary_compat(env, &bin); > - throw std::bad_alloc(); > - } > +#define SC_PTR(c) reinterpret_cast<char *>(c) > + > +class SnappyNifSink : public snappy::Sink > +{ > + public: > + SnappyNifSink(ErlNifEnv* e); > + ~SnappyNifSink(); > + > + void Append(const char* data, size_t n); > + char* GetAppendBuffer(size_t len, char* scratch); > + ErlNifBinary& getBin(); > + > + private: > + ErlNifEnv* env; > + ErlNifBinary bin; > + size_t length; > +}; > + > +SnappyNifSink::SnappyNifSink(ErlNifEnv* e) : env(e), length(0) > +{ > + if(!enif_alloc_binary_compat(env, 0, &bin)) { > + env = NULL; > + throw std::bad_alloc(); > } > +} > > - void Append(const char *data, size_t n) { > - if (data != reinterpret_cast<const char *>(bin.data + length)) { > - memcpy(bin.data + length, data, n); > - } > - length += n; > +SnappyNifSink::~SnappyNifSink() > +{ > + if(env != NULL) { > + enif_release_binary_compat(env, &bin); > } > +} > > - char* GetAppendBuffer(size_t len, char* scratch) { > - if ((length + len) > bin.size) { > - size_t sz = (len * 4) < 8192 ? 8192 : (len * 4); > +void > +SnappyNifSink::Append(const char *data, size_t n) > +{ > + if(data != (SC_PTR(bin.data) + length)) { > + memcpy(bin.data + length, data, n); > + } > + length += n; > +} > > - if (!enif_realloc_binary_compat(env, &bin, bin.size + sz)) { > - enif_release_binary_compat(env, &bin); > - throw std::bad_alloc(); > - } > - } > +char* > +SnappyNifSink::GetAppendBuffer(size_t len, char* scratch) > +{ > + size_t sz; > + > + if((length + len) > bin.size) { > + sz = (len * 4) < 8192 ? 8192 : (len * 4); > > - return reinterpret_cast<char *>(bin.data + length); > + if(!enif_realloc_binary_compat(env, &bin, bin.size + sz)) { > + throw std::bad_alloc(); > + } > } > > - ErlNifBinary& getBin() { > - if (bin.size > length) { > - if (!enif_realloc_binary_compat(env, &bin, length)) { > - // shouldn't happen > - enif_release_binary_compat(env, &bin); > - throw std::bad_alloc(); > - } > + return SC_PTR(bin.data) + length; > +} > + > +ErlNifBinary& > +SnappyNifSink::getBin() > +{ > + if(bin.size > length) { > + if(!enif_realloc_binary_compat(env, &bin, length)) { > + throw std::bad_alloc(); > } > - return bin; > } > + return bin; > +} > + > + > +BEGIN_C > > -private: > - ErlNifEnv* env; > - ErlNifBinary bin; > - size_t length; > -}; > > +ERL_NIF_TERM > +make_atom(ErlNifEnv* env, const char* name) > +{ > + ERL_NIF_TERM ret; > + if(enif_make_existing_atom(env, name, &ret, ERL_NIF_LATIN1)) { > + return ret; > + } > + return enif_make_atom(env, name); > +} > > -extern "C" { > > - ERL_NIF_TERM snappy_compress(ErlNifEnv* env, int argc, const > ERL_NIF_TERM argv[]) { > - ErlNifBinary input; > +ERL_NIF_TERM > +make_ok(ErlNifEnv* env, ERL_NIF_TERM mesg) > +{ > + ERL_NIF_TERM ok = make_atom(env, "ok"); > + return enif_make_tuple2(env, ok, mesg); > +} > > - if (!enif_inspect_iolist_as_binary(env, argv[0], &input)) { > - return enif_make_badarg(env); > - } > > - try { > - snappy::ByteArraySource source(reinterpret_cast<const char > *>(input.data), > - input.size); > - SnappyNifSink sink(env); > +ERL_NIF_TERM > +make_error(ErlNifEnv* env, const char* mesg) > +{ > + ERL_NIF_TERM error = make_atom(env, "error"); > + return enif_make_tuple2(env, error, make_atom(env, mesg)); > +} > > - snappy::Compress(&source, &sink); > > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "ok"), > - enif_make_binary(env, &sink.getBin())); > - } catch(std::bad_alloc e) { > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "error"), > - enif_make_atom(env, > "insufficient_memory")); > - } catch(...) { > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "error"), > - enif_make_atom(env, "unknown")); > - } > +ERL_NIF_TERM > +snappy_compress(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) > +{ > + ErlNifBinary input; > + > + if(!enif_inspect_iolist_as_binary(env, argv[0], &input)) { > + return enif_make_badarg(env); > + } > + > + try { > + snappy::ByteArraySource source(SC_PTR(input.data), input.size); > + SnappyNifSink sink(env); > + snappy::Compress(&source, &sink); > + return make_ok(env, enif_make_binary(env, &sink.getBin())); > + } catch(std::bad_alloc e) { > + return make_error(env, "insufficient_memory"); > + } catch(...) { > + return make_error(env, "unknown"); > } > +} > > > - ERL_NIF_TERM snappy_decompress(ErlNifEnv* env, int argc, const > ERL_NIF_TERM argv[]) { > - ErlNifBinary input; > +ERL_NIF_TERM > +snappy_decompress(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) > +{ > + ErlNifBinary bin; > + ErlNifBinary ret; > + size_t len; > + > + if(!enif_inspect_iolist_as_binary(env, argv[0], &bin)) { > + return enif_make_badarg(env); > + } > > - if (!enif_inspect_iolist_as_binary(env, argv[0], &input)) { > - return enif_make_badarg(env); > + try { > + if(!snappy::GetUncompressedLength(SC_PTR(bin.data), bin.size, &len)) > { > + return make_error(env, "data_not_compressed"); > } > > - try { > - size_t len = -1; > - bool isCompressed = snappy::GetUncompressedLength( > - reinterpret_cast<const char *>(input.data), input.size, > &len); > + if(!enif_alloc_binary_compat(env, len, &ret)) { > + return make_error(env, "insufficient_memory"); > + } > > - if (!isCompressed) { > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "error"), > - enif_make_atom(env, > "not_compressed_data")); > - } > + if(!snappy::RawUncompress(SC_PTR(bin.data), bin.size, > + SC_PTR(ret.data))) { > + return make_error(env, "corrupted_data"); > + } > > - ErlNifBinary retBin; > + return make_ok(env, enif_make_binary(env, &ret)); > + } catch(...) { > + return make_error(env, "unknown"); > + } > +} > > - if (!enif_alloc_binary_compat(env, len, &retBin)) { > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "error"), > - enif_make_atom(env, > "insufficient_memory")); > - } > > - bool valid = snappy::RawUncompress(reinterpret_cast<const char > *>(input.data), > - input.size, > - reinterpret_cast<char > *>(retBin.data)); > +ERL_NIF_TERM > +snappy_uncompressed_length(ErlNifEnv* env, int argc, const ERL_NIF_TERM > argv[]) > +{ > + ErlNifBinary bin; > + size_t len; > > - if (!valid) { > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "error"), > - enif_make_atom(env, > "corrupted_data")); > - } > + if(!enif_inspect_iolist_as_binary(env, argv[0], &bin)) { > + return enif_make_badarg(env); > + } > > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "ok"), > - enif_make_binary(env, &retBin)); > - } catch(...) { > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "error"), > - enif_make_atom(env, "unknown")); > + try { > + if(!snappy::GetUncompressedLength(SC_PTR(bin.data), bin.size, &len)) > { > + return make_error(env, "data_not_compressed"); > } > + return make_ok(env, enif_make_ulong(env, len)); > + } catch(...) { > + return make_error(env, "unknown"); > } > +} > > > - ERL_NIF_TERM snappy_get_uncompressed_length(ErlNifEnv* env, int argc, > const ERL_NIF_TERM argv[]) { > - ErlNifBinary input; > - > - if (!enif_inspect_iolist_as_binary(env, argv[0], &input)) { > - return enif_make_badarg(env); > - } > +ERL_NIF_TERM > +snappy_is_valid(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) > +{ > + ErlNifBinary bin; > > - try { > - size_t len = -1; > - bool isCompressed = snappy::GetUncompressedLength( > - reinterpret_cast<const char *>(input.data), input.size, > &len); > + if (!enif_inspect_iolist_as_binary(env, argv[0], &bin)) { > + return enif_make_badarg(env); > + } > > - if (isCompressed) { > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "ok"), > - enif_make_ulong(env, len)); > - } else { > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "error"), > - enif_make_atom(env, > "not_compressed_data")); > - } > - } catch(...) { > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "error"), > - enif_make_atom(env, "unknown")); > + try { > + if(snappy::IsValidCompressedBuffer(SC_PTR(bin.data), bin.size)) { > + return make_atom(env, "true"); > + } else { > + return make_atom(env, "false"); > } > + } catch(...) { > + return make_error(env, "unknown"); > } > +} > > > - ERL_NIF_TERM snappy_is_valid_compressed_buffer(ErlNifEnv* env, int argc, > const ERL_NIF_TERM argv[]) { > - ErlNifBinary input; > - > - if (!enif_inspect_iolist_as_binary(env, argv[0], &input)) { > - return enif_make_badarg(env); > - } > - > - try { > - bool valid = snappy::IsValidCompressedBuffer( > - reinterpret_cast<const char *>(input.data), input.size); > +int > +on_load(ErlNifEnv* env, void** priv, ERL_NIF_TERM info) > +{ > + return 0; > +} > > - if (valid) { > - return enif_make_atom(env, "true"); > - } else { > - return enif_make_atom(env, "false"); > - } > - } catch(...) { > - return enif_make_tuple(env, 2, > - enif_make_atom(env, "error"), > - enif_make_atom(env, "unknown")); > - } > - } > > +int > +on_reload(ErlNifEnv* env, void** priv, ERL_NIF_TERM info) > +{ > + return 0; > +} > > > - int on_load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM info) { > - return 0; > - } > +int > +on_upgrade(ErlNifEnv* env, void** priv, void** old_priv, ERL_NIF_TERM info) > +{ > + return 0; > +} > > > - int on_reload(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM info) { > - return 0; > - } > +static ErlNifFunc nif_functions[] = { > + {"compress", 1, snappy_compress}, > + {"decompress", 1, snappy_decompress}, > + {"uncompressed_length", 1, snappy_uncompressed_length}, > + {"is_valid", 1, snappy_is_valid} > +}; > > - int on_upgrade(ErlNifEnv* env, void** priv_data, void** old_data, > ERL_NIF_TERM info) { > - return 0; > - } > > +ERL_NIF_INIT(snappy, nif_functions, &on_load, &on_reload, &on_upgrade, NULL); > > - static ErlNifFunc nif_functions[] = { > - {"compress", 1, snappy_compress}, > - {"decompress", 1, snappy_decompress}, > - {"get_uncompressed_length", 1, snappy_get_uncompressed_length}, > - {"is_valid_compressed_buffer", 1, snappy_is_valid_compressed_buffer} > - }; > > - ERL_NIF_INIT(snappy, nif_functions, &on_load, &on_reload, &on_upgrade, > NULL); > -} > +END_C > \ No newline at end of file > > > -- Filipe David Manana, [email protected], [email protected] "Reasonable men adapt themselves to the world. Unreasonable men adapt the world to themselves. That's why all progress depends on unreasonable men."
