umgeher/jsx
0
Fork 0
Code Issues Pull requests Activity

switch to a counting implementation of number parsing a la strings

Browse source
This commit is contained in:
alisdair sullivan 2014-12-09 01:47:55 -08:00
parent e5e04db58e
commit e2ba87f1cb
1 changed files with 154 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

238
src/jsx_decoder.erl
View file

@ -58,12 +58,7 @@ resume(Rest, State, Handler, Acc, Stack, Config) ->
colon -> colon(Rest, Handler, Stack, Config); colon -> colon(Rest, Handler, Stack, Config);
key -> key(Rest, Handler, Stack, Config); key -> key(Rest, Handler, Stack, Config);
string -> string(Rest, Handler, Acc, Stack, Config); string -> string(Rest, Handler, Acc, Stack, Config);
integer -> integer(Rest, Handler, Acc, Stack, Config); number -> number(Rest, Handler, Acc, Stack, Config);
decimal -> decimal(Rest, Handler, Acc, Stack, Config);
e -> e(Rest, Handler, Acc, Stack, Config);
ex -> ex(Rest, Handler, Acc, Stack, Config);
exp -> exp(Rest, Handler, Acc, Stack, Config);
zero -> zero(Rest, Handler, Acc, Stack, Config);
true -> true(Rest, Handler, Stack, Config); true -> true(Rest, Handler, Stack, Config);
false -> false(Rest, Handler, Stack, Config); false -> false(Rest, Handler, Stack, Config);
null -> null(Rest, Handler, Stack, Config); null -> null(Rest, Handler, Stack, Config);
@ -188,27 +183,27 @@ value(<<$f, $a, $l, $s, $e, Rest/binary>>, Handler, Stack, Config) ->
value(<<$n, $u, $l, $l, Rest/binary>>, Handler, Stack, Config) -> value(<<$n, $u, $l, $l, Rest/binary>>, Handler, Stack, Config) ->
maybe_done(Rest, handle_event({literal, null}, Handler, Config), Stack, Config); maybe_done(Rest, handle_event({literal, null}, Handler, Config), Stack, Config);
value(<<?zero, Rest/binary>>, Handler, Stack, Config) -> value(<<?zero, Rest/binary>>, Handler, Stack, Config) ->
zero(Rest, Handler, [$0], Stack, Config); number(Rest, Handler, [?zero], [zero|Stack], Config);
value(<<$1, Rest/binary>>, Handler, Stack, Config) -> value(<<$1, Rest/binary>>, Handler, Stack, Config) ->
integer(Rest, Handler, [$1], Stack, Config); number(Rest, Handler, [$1], [integer|Stack], Config);
value(<<$2, Rest/binary>>, Handler, Stack, Config) -> value(<<$2, Rest/binary>>, Handler, Stack, Config) ->
integer(Rest, Handler, [$2], Stack, Config); number(Rest, Handler, [$2], [integer|Stack], Config);
value(<<$3, Rest/binary>>, Handler, Stack, Config) -> value(<<$3, Rest/binary>>, Handler, Stack, Config) ->
integer(Rest, Handler, [$3], Stack, Config); number(Rest, Handler, [$3], [integer|Stack], Config);
value(<<$4, Rest/binary>>, Handler, Stack, Config) -> value(<<$4, Rest/binary>>, Handler, Stack, Config) ->
integer(Rest, Handler, [$4], Stack, Config); number(Rest, Handler, [$4], [integer|Stack], Config);
value(<<$5, Rest/binary>>, Handler, Stack, Config) -> value(<<$5, Rest/binary>>, Handler, Stack, Config) ->
integer(Rest, Handler, [$5], Stack, Config); number(Rest, Handler, [$5], [integer|Stack], Config);
value(<<$6, Rest/binary>>, Handler, Stack, Config) -> value(<<$6, Rest/binary>>, Handler, Stack, Config) ->
integer(Rest, Handler, [$6], Stack, Config); number(Rest, Handler, [$6], [integer|Stack], Config);
value(<<$7, Rest/binary>>, Handler, Stack, Config) -> value(<<$7, Rest/binary>>, Handler, Stack, Config) ->
integer(Rest, Handler, [$7], Stack, Config); number(Rest, Handler, [$7], [integer|Stack], Config);
value(<<$8, Rest/binary>>, Handler, Stack, Config) -> value(<<$8, Rest/binary>>, Handler, Stack, Config) ->
integer(Rest, Handler, [$8], Stack, Config); number(Rest, Handler, [$8], [integer|Stack], Config);
value(<<$9, Rest/binary>>, Handler, Stack, Config) -> value(<<$9, Rest/binary>>, Handler, Stack, Config) ->
integer(Rest, Handler, [$9], Stack, Config); number(Rest, Handler, [$9], [integer|Stack], Config);
value(<<?negative, Rest/binary>>, Handler, Stack, Config) -> value(<<?negative, Rest/binary>>, Handler, Stack, Config) ->
negative(Rest, Handler, [$-], Stack, Config); number(Rest, Handler, [$-], [negative|Stack], Config);
value(<<?newline, Rest/binary>>, Handler, Stack, Config) -> value(<<?newline, Rest/binary>>, Handler, Stack, Config) ->
value(Rest, Handler, Stack, Config); value(Rest, Handler, Stack, Config);
value(<<$t, Rest/binary>>, Handler, Stack, Config) -> value(<<$t, Rest/binary>>, Handler, Stack, Config) ->
@ -384,9 +379,9 @@ string(<<239, 191, 190, Rest/binary>>, Handler, Acc, Stack, Config) ->
string(Rest, Handler, [Acc, <<16#fffe/utf8>>], Stack, Config); string(Rest, Handler, [Acc, <<16#fffe/utf8>>], Stack, Config);
string(<<239, 191, 191, Rest/binary>>, Handler, Acc, Stack, Config) -> string(<<239, 191, 191, Rest/binary>>, Handler, Acc, Stack, Config) ->
string(Rest, Handler, [Acc, <<16#ffff/utf8>>], Stack, Config); string(Rest, Handler, [Acc, <<16#ffff/utf8>>], Stack, Config);
%% partial utf8 codepoints
string(<<>>, Handler, Acc, Stack, Config) -> string(<<>>, Handler, Acc, Stack, Config) ->
incomplete(string, <<>>, Handler, Acc, Stack, Config); incomplete(string, <<>>, Handler, Acc, Stack, Config);
%% partial utf8 codepoints
string(<<X>>, Handler, Acc, Stack, Config) when X >= 2#11000000 -> string(<<X>>, Handler, Acc, Stack, Config) when X >= 2#11000000 ->
incomplete(string, <<X>>, Handler, Acc, Stack, Config); incomplete(string, <<X>>, Handler, Acc, Stack, Config);
string(<<X, Y>>, Handler, Acc, Stack, Config) when X >= 2#11100000, Y >= 2#10000000 -> string(<<X, Y>>, Handler, Acc, Stack, Config) when X >= 2#11100000, Y >= 2#10000000 ->
@ -849,98 +844,173 @@ to_hex(15) -> $f;
to_hex(X) -> X + 48. to_hex(X) -> X + 48.
%% like in strings, there's some pseudo states in here that will never number(<<$e, Rest/binary>>, Handler, Acc, [integer|Stack], Config) ->
%% show up in incompletes. some show up in value, some show up in number(Rest, Handler, [Acc, $., $0, $e], [e|Stack], Config);
%% integer, decimal or exp number(<<$E, Rest/binary>>, Handler, Acc, [integer|Stack], Config) ->
negative(<<$0, Rest/binary>>, Handler, Acc, Stack, Config) -> number(Rest, Handler, [Acc, $., $0, $e], [e|Stack], Config);
zero(Rest, Handler, [Acc, $0], Stack, Config); number(<<$e, Rest/binary>>, Handler, Acc, [zero|Stack], Config) ->
negative(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when ?is_nonzero(S) -> number(Rest, Handler, [Acc, $., $0, $e], [e|Stack], Config);
integer(Rest, Handler, [Acc, S], Stack, Config); number(<<$E, Rest/binary>>, Handler, Acc, [zero|Stack], Config) ->
negative(<<>>, Handler, [?negative], Stack, Config) -> number(Rest, Handler, [Acc, $., $0, $e], [e|Stack], Config);
incomplete(value, <<?negative>>, Handler, Stack, Config); number(<<>>, Handler, Acc, [State|Stack], Config=#config{stream=false}) ->
negative(Bin, Handler, Acc, Stack, Config) -> NumType = case State of
?error(negative, Bin, Handler, Acc, Stack, Config). zero -> integer;
integer -> integer;
decimal -> float;
exp -> float
end,
finish_number(<<>>, Handler, {NumType, iolist_to_binary(Acc)}, Stack, Config);
number(<<>>, Handler, Acc, Stack, Config) ->
incomplete(number, <<>>, Handler, Acc, Stack, Config);
number(Bin, Handler, Acc, [State|Stack], Config) ->
Counted = case State of
zero -> zero(Bin, 0);
integer -> integer(Bin, 0);
negative -> negative(Bin, 0);
initialdecimal -> initialdecimal(Bin, 0);
decimal -> decimal(Bin, 0);
e -> e(Bin, 0);
ex -> ex(Bin, 0);
exp -> exp(Bin, 0)
end,
case Counted of
{finish_integer, Size} ->
<<Clean:Size/binary, Rest/binary>> = Bin,
finish_number(Rest, Handler, {integer, iolist_to_binary([Acc, Clean])}, Stack, Config);
{finish_float, Size} ->
<<Clean:Size/binary, Rest/binary>> = Bin,
finish_number(Rest, Handler, {float, iolist_to_binary([Acc, Clean])}, Stack, Config);
{error, Size} ->
<<Clean:Size/binary, Rest/binary>> = Bin,
?error(number, Rest, Handler, [Acc, Clean], Stack, Config);
{NewState, Size} ->
<<Clean:Size/binary, Rest/binary>> = Bin,
number(Rest, Handler, [Acc, Clean], [NewState|Stack], Config)
end.
zero(<<?decimalpoint, Rest/binary>>, Handler, Acc, Stack, Config) -> zero(<<?decimalpoint, Rest/binary>>, N) -> initialdecimal(Rest, N + 1);
decimal(Rest, Handler, [Acc, ?decimalpoint], Stack, Config); zero(<<>>, N) -> {zero, N};
zero(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= $e; S =:= $E -> zero(_, N) -> {finish_integer, N}.
e(Rest, Handler, [Acc, ".0e"], Stack, Config);
zero(Bin, Handler, Acc, Stack, Config) ->
finish_number(Bin, Handler, {zero, iolist_to_binary(Acc)}, Stack, Config).
integer(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) -> integer(<<$0, Rest/binary>>, N) -> integer(Rest, N + 1);
integer(Rest, Handler, [Acc, S], Stack, Config); integer(<<$1, Rest/binary>>, N) -> integer(Rest, N + 1);
integer(<<?decimalpoint, Rest/binary>>, Handler, Acc, Stack, Config) -> integer(<<$2, Rest/binary>>, N) -> integer(Rest, N + 1);
initialdecimal(Rest, Handler, [Acc, ?decimalpoint], Stack, Config); integer(<<$3, Rest/binary>>, N) -> integer(Rest, N + 1);
integer(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= $e; S =:= $E -> integer(<<$4, Rest/binary>>, N) -> integer(Rest, N + 1);
e(Rest, Handler, [Acc, ".0e"], Stack, Config); integer(<<$5, Rest/binary>>, N) -> integer(Rest, N + 1);
integer(Bin, Handler, Acc, Stack, Config) -> integer(<<$6, Rest/binary>>, N) -> integer(Rest, N + 1);
finish_number(Bin, Handler, {integer, iolist_to_binary(Acc)}, Stack, Config). integer(<<$7, Rest/binary>>, N) -> integer(Rest, N + 1);
integer(<<$8, Rest/binary>>, N) -> integer(Rest, N + 1);
integer(<<$9, Rest/binary>>, N) -> integer(Rest, N + 1);
integer(<<?decimalpoint, Rest/binary>>, N) -> initialdecimal(Rest, N + 1);
integer(<<$e, _/binary>>, N) -> {integer, N};
integer(<<$E, _/binary>>, N) -> {integer, N};
integer(<<>>, N) -> {integer, N};
integer(_, N) -> {finish_integer, N}.
initialdecimal(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) -> negative(<<$0, Rest/binary>>, N) -> zero(Rest, N + 1);
decimal(Rest, Handler, [Acc, S], Stack, Config); negative(<<$1, Rest/binary>>, N) -> integer(Rest, N + 1);
initialdecimal(<<>>, Handler, Acc, Stack, Config) -> negative(<<$2, Rest/binary>>, N) -> integer(Rest, N + 1);
[?decimalpoint|Rest] = lists:reverse(Acc), negative(<<$3, Rest/binary>>, N) -> integer(Rest, N + 1);
incomplete(integer, <<?decimalpoint>>, Handler, lists:reverse(Rest), Stack, Config); negative(<<$4, Rest/binary>>, N) -> integer(Rest, N + 1);
initialdecimal(Bin, Handler, Acc, Stack, Config) -> negative(<<$5, Rest/binary>>, N) -> integer(Rest, N + 1);
?error(initialdecimal, Bin, Handler, Acc, Stack, Config). negative(<<$6, Rest/binary>>, N) -> integer(Rest, N + 1);
negative(<<$7, Rest/binary>>, N) -> integer(Rest, N + 1);
negative(<<$8, Rest/binary>>, N) -> integer(Rest, N + 1);
negative(<<$9, Rest/binary>>, N) -> integer(Rest, N + 1);
negative(<<>>, N) -> {negative, N};
negative(_, N) -> {error, N}.
decimal(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) -> initialdecimal(<<$0, Rest/binary>>, N) -> decimal(Rest, N + 1);
decimal(Rest, Handler, [Acc, S], Stack, Config); initialdecimal(<<$1, Rest/binary>>, N) -> decimal(Rest, N + 1);
decimal(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= $e; S =:= $E -> initialdecimal(<<$2, Rest/binary>>, N) -> decimal(Rest, N + 1);
e(Rest, Handler, [Acc, $e], Stack, Config); initialdecimal(<<$3, Rest/binary>>, N) -> decimal(Rest, N + 1);
decimal(Bin, Handler, Acc, Stack, Config) -> initialdecimal(<<$4, Rest/binary>>, N) -> decimal(Rest, N + 1);
finish_number(Bin, Handler, {decimal, iolist_to_binary(Acc)}, Stack, Config). initialdecimal(<<$5, Rest/binary>>, N) -> decimal(Rest, N + 1);
initialdecimal(<<$6, Rest/binary>>, N) -> decimal(Rest, N + 1);
initialdecimal(<<$7, Rest/binary>>, N) -> decimal(Rest, N + 1);
initialdecimal(<<$8, Rest/binary>>, N) -> decimal(Rest, N + 1);
initialdecimal(<<$9, Rest/binary>>, N) -> decimal(Rest, N + 1);
initialdecimal(<<>>, N) -> {initialdecimal, N};
initialdecimal(_, N) -> {error, N}.
e(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) -> decimal(<<$0, Rest/binary>>, N) -> decimal(Rest, N + 1);
exp(Rest, Handler, [Acc, S], Stack, Config); decimal(<<$1, Rest/binary>>, N) -> decimal(Rest, N + 1);
e(<<Sign, Rest/binary>>, Handler, Acc, Stack, Config) when Sign =:= ?positive; Sign =:= ?negative -> decimal(<<$2, Rest/binary>>, N) -> decimal(Rest, N + 1);
ex(Rest, Handler, [Acc, Sign], Stack, Config); decimal(<<$3, Rest/binary>>, N) -> decimal(Rest, N + 1);
e(<<>>, Handler, Acc, Stack, Config) -> decimal(<<$4, Rest/binary>>, N) -> decimal(Rest, N + 1);
incomplete(e, <<>>, Handler, Acc, Stack, Config); decimal(<<$5, Rest/binary>>, N) -> decimal(Rest, N + 1);
e(Bin, Handler, Acc, Stack, Config) -> decimal(<<$6, Rest/binary>>, N) -> decimal(Rest, N + 1);
?error(e, Bin, Handler, Acc, Stack, Config). decimal(<<$7, Rest/binary>>, N) -> decimal(Rest, N + 1);
decimal(<<$8, Rest/binary>>, N) -> decimal(Rest, N + 1);
decimal(<<$9, Rest/binary>>, N) -> decimal(Rest, N + 1);
decimal(<<$e, Rest/binary>>, N) -> e(Rest, N + 1);
decimal(<<$E, Rest/binary>>, N) -> e(Rest, N + 1);
decimal(<<>>, N) -> {decimal, N};
decimal(_, N) -> {finish_float, N}.
ex(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) -> e(<<$0, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(Rest, Handler, [Acc, S], Stack, Config); e(<<$1, Rest/binary>>, N) -> exp(Rest, N + 1);
ex(<<>>, Handler, Acc, Stack, Config) -> e(<<$2, Rest/binary>>, N) -> exp(Rest, N + 1);
incomplete(ex, <<>>, Handler, Acc, Stack, Config); e(<<$3, Rest/binary>>, N) -> exp(Rest, N + 1);
ex(Bin, Handler, Acc, Stack, Config) -> e(<<$4, Rest/binary>>, N) -> exp(Rest, N + 1);
?error(ex, Bin, Handler, Acc, Stack, Config). e(<<$5, Rest/binary>>, N) -> exp(Rest, N + 1);
e(<<$6, Rest/binary>>, N) -> exp(Rest, N + 1);
e(<<$7, Rest/binary>>, N) -> exp(Rest, N + 1);
e(<<$8, Rest/binary>>, N) -> exp(Rest, N + 1);
e(<<$9, Rest/binary>>, N) -> exp(Rest, N + 1);
e(<<?positive, Rest/binary>>, N) -> ex(Rest, N + 1);
e(<<?negative, Rest/binary>>, N) -> ex(Rest, N + 1);
e(<<>>, N) -> {e, N};
e(_, N) -> {error, N}.
exp(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) -> ex(<<$0, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(Rest, Handler, [Acc, S], Stack, Config); ex(<<$1, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(Bin, Handler, Acc, Stack, Config) -> ex(<<$2, Rest/binary>>, N) -> exp(Rest, N + 1);
finish_number(Bin, Handler, {exp, iolist_to_binary(Acc)}, Stack, Config). ex(<<$3, Rest/binary>>, N) -> exp(Rest, N + 1);
ex(<<$4, Rest/binary>>, N) -> exp(Rest, N + 1);
ex(<<$5, Rest/binary>>, N) -> exp(Rest, N + 1);
ex(<<$6, Rest/binary>>, N) -> exp(Rest, N + 1);
ex(<<$7, Rest/binary>>, N) -> exp(Rest, N + 1);
ex(<<$8, Rest/binary>>, N) -> exp(Rest, N + 1);
ex(<<$9, Rest/binary>>, N) -> exp(Rest, N + 1);
ex(<<>>, N) -> {ex, N};
ex(_, N) -> {error, N}.
exp(<<$0, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(<<$1, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(<<$2, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(<<$3, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(<<$4, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(<<$5, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(<<$6, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(<<$7, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(<<$8, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(<<$9, Rest/binary>>, N) -> exp(Rest, N + 1);
exp(<<>>, N) -> {exp, N};
exp(_, N) -> {finish_float, N}.
finish_number(Rest, Handler, Acc, [], Config=#config{stream=false}) ->
maybe_done(Rest, handle_event(format_number(Acc), Handler, Config), [], Config);
finish_number(<<>>, Handler, {NumType, Acc}, Stack, Config) ->
incomplete(NumType, <<>>, Handler, Acc, Stack, Config);
finish_number(Rest, Handler, Acc, Stack, Config) -> finish_number(Rest, Handler, Acc, Stack, Config) ->
maybe_done(Rest, handle_event(format_number(Acc), Handler, Config), Stack, Config). maybe_done(Rest, handle_event(format_number(Acc), Handler, Config), Stack, Config).
-ifndef(no_binary_to_whatever). -ifndef(no_binary_to_whatever).
format_number({zero, Acc}) -> {integer, binary_to_integer(Acc)};
format_number({integer, Acc}) -> {integer, binary_to_integer(Acc)}; format_number({integer, Acc}) -> {integer, binary_to_integer(Acc)};
format_number({decimal, Acc}) -> {float, binary_to_float(Acc)}; format_number({float, Acc}) -> {float, binary_to_float(Acc)}.
format_number({exp, Acc}) -> {float, binary_to_float(Acc)}.
-endif. -endif.
-ifdef(no_binary_to_whatever). -ifdef(no_binary_to_whatever).
format_number({zero, Acc}) -> {integer, list_to_integer(unicode:characters_to_list(Acc))};
format_number({integer, Acc}) -> {integer, list_to_integer(unicode:characters_to_list(Acc))}; format_number({integer, Acc}) -> {integer, list_to_integer(unicode:characters_to_list(Acc))};
format_number({decimal, Acc}) -> {float, list_to_float(unicode:characters_to_list(Acc))}; format_number({float, Acc}) -> {float, list_to_float(unicode:characters_to_list(Acc))}.
format_number({exp, Acc}) -> {float, list_to_float(unicode:characters_to_list(Acc))}.
-endif. -endif.