From 0d0cd252406a5624394828b22b090442f74d8f5f Mon Sep 17 00:00:00 2001 From: jihyun Date: Sun, 9 Feb 2014 11:07:41 +0900 Subject: [PATCH] Clean up codes - Remove #if macros when possible - Remove shell scripts on Makefile --- Makefile | 7 +------ c_src/decoder.c | 31 ++++++++++++++++++------------- c_src/jiffy.c | 5 +---- c_src/jiffy.h | 3 +-- c_src/util.c | 9 +++++++++ test/util.erl | 16 ++++++++-------- 6 files changed, 38 insertions(+), 33 deletions(-) diff --git a/Makefile b/Makefile index bb2f305..831deb5 100644 --- a/Makefile +++ b/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 diff --git a/c_src/decoder.c b/c_src/decoder.c index 1757a18..58bb0ae 100644 --- a/c_src/decoder.c +++ b/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) { diff --git a/c_src/jiffy.c b/c_src/jiffy.c index 284049d..0f106c3 100644 --- a/c_src/jiffy.c +++ b/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; diff --git a/c_src/jiffy.h b/c_src/jiffy.h index d86cc67..f609aa3 100644 --- a/c_src/jiffy.h +++ b/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[]); diff --git a/c_src/util.c b/c_src/util.c index f1be3ec..460f332 100644 --- a/c_src/util.c +++ b/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 +} diff --git a/test/util.erl b/test/util.erl index e5826d7..6f35810 100644 --- a/test/util.erl +++ b/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(