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, 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(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(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(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(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(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(input.data), > -                                               input.size, > -                                               reinterpret_cast(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(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(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, fdmanana@gmail.com, fdmanana@apache.org "Reasonable men adapt themselves to the world.  Unreasonable men adapt the world to themselves.  That's why all progress depends on unreasonable men."