Implements Elixir support as discussed in davisp/jiffy#64

c_src/decoder.c

@@ -52,6 +52,7 @@ typedef struct {
     size_t          bytes_per_iter;
     int             is_partial;
     int             return_maps;
+    int             use_nil;
 
     char*           p;
     unsigned char*  u;
@@ -79,6 +80,7 @@ dec_new(ErlNifEnv* env)
     d->bytes_per_iter = DEFAULT_BYTES_PER_ITER;
     d->is_partial = 0;
     d->return_maps = 0;
+    d->use_nil = 0;
 
     d->p = NULL;
     d->u = NULL;
@@ -707,6 +709,8 @@ decode_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 #else
             return enif_make_badarg(env);
 #endif
+        } else if(enif_compare(val, d->atoms->atom_use_nil) == 0) {
+            d->use_nil = 1;
         } else {
             return enif_make_badarg(env);
         }
@@ -777,7 +781,7 @@ decode_iter(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
                             ret = dec_error(d, "invalid_literal");
                             goto done;
                         }
-                        val = d->atoms->atom_null;
+                        val = d->use_nil ? d->atoms->atom_nil : d->atoms->atom_null;
                         dec_pop(d, st_value);
                         d->i += 4;
                         break;

c_src/encoder.c

@@ -33,6 +33,7 @@ typedef struct {
 
     int             uescape;
     int             pretty;
+    int             use_nil;
 
     int             shiftcnt;
     int             count;
@@ -75,6 +76,7 @@ enc_new(ErlNifEnv* env)
     e->bytes_per_iter = DEFAULT_BYTES_PER_ITER;
     e->uescape = 0;
     e->pretty = 0;
+    e->use_nil = 0;
     e->shiftcnt = 0;
     e->count = 0;
 
@@ -578,6 +580,8 @@ encode_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
             e->uescape = 1;
         } else if(enif_compare(val, e->atoms->atom_pretty) == 0) {
             e->pretty = 1;
+        } else if(enif_compare(val, e->atoms->atom_use_nil) == 0) {
+            e->use_nil = 1;
         } else if(enif_compare(val, e->atoms->atom_force_utf8) == 0) {
             // Ignore, handled in Erlang
         } else if(get_bytes_per_iter(env, val, &(e->bytes_per_iter))) {
@@ -708,11 +712,12 @@ encode_iter(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
             stack = enif_make_list_cell(env, curr, stack);
             stack = enif_make_list_cell(env, e->atoms->ref_array, stack);
             stack = enif_make_list_cell(env, item, stack);
-        } else if(enif_compare(curr, e->atoms->atom_null) == 0) {
+        } else if(enif_compare(curr, e->atoms->atom_null) == 0 
+                    || (e->use_nil && enif_compare(curr, e->atoms->atom_nil) == 0)) {
             if(!enc_literal(e, "null", 4)) {
                 ret = enc_error(e, "null");
                 goto done;
-            }
+            }        
         } else if(enif_compare(curr, e->atoms->atom_true) == 0) {
             if(!enc_literal(e, "true", 4)) {
                 ret = enc_error(e, "true");

c_src/jiffy.c

@@ -26,6 +26,8 @@ load(ErlNifEnv* env, void** priv, ERL_NIF_TERM info)
     st->atom_iter = make_atom(env, "iter");
     st->atom_bytes_per_iter = make_atom(env, "bytes_per_iter");
     st->atom_return_maps = make_atom(env, "return_maps");
+    st->atom_nil = make_atom(env, "nil");
+    st->atom_use_nil = make_atom(env, "use_nil");
 
     // Markers used in encoding
     st->ref_object = make_atom(env, "$object_ref$");

c_src/jiffy.h

@@ -28,6 +28,8 @@ typedef struct {
     ERL_NIF_TERM    atom_iter;
     ERL_NIF_TERM    atom_bytes_per_iter;
     ERL_NIF_TERM    atom_return_maps;
+    ERL_NIF_TERM    atom_nil;
+    ERL_NIF_TERM    atom_use_nil;
 
     ERL_NIF_TERM    ref_object;
     ERL_NIF_TERM    ref_array;

test/jiffy_02_literal_tests.erl

@@ -26,3 +26,9 @@ null_test_() ->
         {"Decode", ?_assertEqual(null, jiffy:decode(<<"null">>))},
         {"Encode", ?_assertEqual(<<"null">>, jiffy:encode(null))}
     ]}.
+
+nil_test_() ->
+    {"null", [
+        {"Decode", ?_assertEqual(nil, jiffy:decode(<<"null">>, [use_nil]))},
+        {"Encode", ?_assertEqual(<<"null">>, jiffy:encode(nil, [use_nil]))}
+    ]}.