Clean up codes

- Remove #if macros when possible
 - Remove shell scripts on Makefile

Makefile

@@ -2,7 +2,6 @@ REBAR?=./rebar
 
 all: build
 
-
 clean:
 	$(REBAR) clean
 	rm -rf logs
@@ -40,11 +39,7 @@ check: build etap eunit
 
 
 %.beam: %.erl
-	rm -f .test_map
-	erl -eval '#{}, halt().' -noshell || touch .test_map
-	@if test ! -d .test_map; then \
-		erlc -DTEST_MAP -o test/ $<; \
-	fi
+	erlc -DTEST_MAP -o test/ $<
 
 
 .PHONY: all clean distclean depends build etap eunit check

c_src/decoder.c

@@ -90,7 +90,6 @@ dec_init(Decoder* d, ErlNifEnv* env, ERL_NIF_TERM arg, ERL_NIF_TERM opts, ErlNif
     d->st_data[0] = st_value;
     d->st_top++;
 
-#if MAP_SUPPORT
     ERL_NIF_TERM val;
     while(enif_get_list_cell(env, opts, &val, &opts)) {
         if(enif_compare(val, d->atoms->atom_map) == 0) {
@@ -99,7 +98,6 @@ dec_init(Decoder* d, ErlNifEnv* env, ERL_NIF_TERM arg, ERL_NIF_TERM opts, ErlNif
             return 0;
         }
     }
-#endif
     return 1;
 }
 
@@ -588,36 +586,47 @@ parse:
     return 1;
 }
 
-#if MAP_SUPPORT
 ERL_NIF_TERM
 make_object_map(ErlNifEnv* env, ERL_NIF_TERM pairs)
 {
-    ERL_NIF_TERM ret = enif_make_new_map(env);
+    ERL_NIF_TERM ret;
     ERL_NIF_TERM key, val;
 
+#if MAP_SUPPORT
+    ret = enif_make_new_map(env);
+
     while(enif_get_list_cell(env, pairs, &val, &pairs)) {
         if(!enif_get_list_cell(env, pairs, &key, &pairs)) {
             assert(0 == 1 && "Unbalanced object pairs.");
         }
         enif_make_map_put(env, ret, key, val, &ret);
     }
+#else
+    assert(0 == 1 && "maps not supported");
+#endif
 
     return ret;
 }
+
+
 ERL_NIF_TERM
 make_empty_object_map(ErlNifEnv* env) {
-    return enif_make_new_map(env);
-}
+    ERL_NIF_TERM ret;
+#if MAP_SUPPORT
+    ret = enif_make_new_map(env);
+#else
+    assert(0 == 1 && "maps not supported");
 #endif
 
+    return ret;
+}
+
 ERL_NIF_TERM
 make_empty_object(Decoder* d) {
     ErlNifEnv* env = d->env;
-#if MAP_SUPPORT
     if(d->to_map) {
         return make_empty_object_map(env);
     }
-#endif
 
     return enif_make_tuple1(env, enif_make_list(env, 0));
 }
@@ -626,11 +635,9 @@ ERL_NIF_TERM
 make_object(Decoder* d, ERL_NIF_TERM pairs)
 {
     ErlNifEnv* env = d->env;
-#if MAP_SUPPORT
     if(d->to_map) {
         return make_object_map(env, pairs);
     }
-#endif
 
     ERL_NIF_TERM ret = enif_make_list(env, 0);
     ERL_NIF_TERM key, val;
@@ -682,12 +689,10 @@ decode(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
         return enif_make_badarg(env);
     }
 
-#if !MAP_SUPPORT
-    if(d->to_map) {
+    if(d->to_map && !maps_enabled()) {
         ret = dec_error(d, "map_unavailable");
         goto done;
     }
-#endif
 
     //fprintf(stderr, "Parsing:\r\n");
     while(d->i < bin.size) {

c_src/jiffy.c

@@ -23,15 +23,12 @@ load(ErlNifEnv* env, void** priv, ERL_NIF_TERM info)
     st->atom_uescape = make_atom(env, "uescape");
     st->atom_pretty = make_atom(env, "pretty");
     st->atom_force_utf8 = make_atom(env, "force_utf8");
+    st->atom_map = make_atom(env, "map");
 
     // Markers used in encoding
     st->ref_object = make_atom(env, "$object_ref$");
     st->ref_array = make_atom(env, "$array_ref$");
 
-#if MAP_SUPPORT
-    st->atom_map = make_atom(env, "map");
-#endif
-
     *priv = (void*) st;
 
     return 0;

c_src/jiffy.h

@@ -21,9 +21,7 @@ typedef struct {
     ERL_NIF_TERM    atom_uescape;
     ERL_NIF_TERM    atom_pretty;
     ERL_NIF_TERM    atom_force_utf8;
-#ifdef MAP_SUPPORT
     ERL_NIF_TERM    atom_map;
-#endif
 
     ERL_NIF_TERM    ref_object;
     ERL_NIF_TERM    ref_array;
@@ -32,6 +30,7 @@ typedef struct {
 ERL_NIF_TERM make_atom(ErlNifEnv* env, const char* name);
 ERL_NIF_TERM make_ok(jiffy_st* st, ErlNifEnv* env, ERL_NIF_TERM data);
 ERL_NIF_TERM make_error(jiffy_st* st, ErlNifEnv* env, const char* error);
+int maps_enabled(void);
 
 ERL_NIF_TERM decode(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
 ERL_NIF_TERM encode(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);

c_src/util.c

@@ -24,3 +24,12 @@ make_error(jiffy_st* st, ErlNifEnv* env, const char* error)
 {
     return enif_make_tuple2(env, st->atom_error, make_atom(env, error));
 }
+
+int
+maps_enabled(void) {
+#if MAP_SUPPORT
+    return 1;
+#else
+    return 0;
+#endif
+}

test/util.erl

@@ -30,15 +30,15 @@ check_good({J, E, J2}, Options) ->
     check_map({J, J2}, Options),
     etap:is(do_encode(E, Options), J2, ok_enc(E, J2)).
 
--ifdef(TEST_MAP).
 check_map({J, J2}, Options) ->
-    E2 = jiffy:decode(J, [map]),
-    % etap function breaks all tests because of etap:plan, so stop
-    % if map test failed
-    J2 = do_encode(E2, Options).
--else.
-check_map(_, _) -> ok.
--endif.
+    try jiffy:decode(J, [map]) of
+        E2 ->
+            % etap function breaks all tests because of etap:plan, so stop
+            % if map test failed
+            J2 = do_encode(E2, Options)
+    catch throw:{error, {1, map_unavailable}} ->
+        ok
+    end.
 
 check_error({J, E}) ->
     etap:fun_is(