import old string parsing and fix parsing of single quoted strings
This commit is contained in:
alisdair sullivan
parent
257d7ee387
commit
5d40e559c9
1 changed files with 458 additions and 138 deletions
|
|
@ -158,9 +158,9 @@ definitely_bom(Bin, Handler, Stack, Config) ->
|
|||
|
||||
|
||||
value(<<?doublequote, Rest/binary>>, Handler, Stack, Config) ->
|
||||
string(Rest, Handler, [string|Stack], Config);
|
||||
string(Rest, Handler, [?new_seq()|Stack], Config);
|
||||
value(<<?singlequote, Rest/binary>>, Handler, Stack, Config = #config{single_quoted_strings=true}) ->
|
||||
string(Rest, Handler, [single_quoted_string|Stack], Config);
|
||||
string(Rest, Handler, [?new_seq(), single_quote|Stack], Config);
|
||||
value(<<$t, Rest/binary>>, Handler, Stack, Config) ->
|
||||
tr(Rest, Handler, Stack, Config);
|
||||
value(<<$f, Rest/binary>>, Handler, Stack, Config) ->
|
||||
|
|
@ -188,9 +188,9 @@ value(Bin, Handler, Stack, Config) ->
|
|||
|
||||
|
||||
object(<<?doublequote, Rest/binary>>, Handler, Stack, Config) ->
|
||||
string(Rest, Handler, [string|Stack], Config);
|
||||
string(Rest, Handler, [?new_seq()|Stack], Config);
|
||||
object(<<?singlequote, Rest/binary>>, Handler, Stack, Config = #config{single_quoted_strings=true}) ->
|
||||
string(Rest, Handler, [single_quoted_string|Stack], Config);
|
||||
string(Rest, Handler, [?new_seq(), single_quote|Stack], Config);
|
||||
object(<<?end_object, Rest/binary>>, Handler, [key|Stack], Config) ->
|
||||
maybe_done(Rest, handle_event(end_object, Handler, Config), Stack, Config);
|
||||
object(<<S, Rest/binary>>, Handler, Stack, Config) when ?is_whitespace(S) ->
|
||||
|
|
@ -228,9 +228,9 @@ colon(Bin, Handler, Stack, Config) ->
|
|||
|
||||
|
||||
key(<<?doublequote, Rest/binary>>, Handler, Stack, Config) ->
|
||||
string(Rest, Handler, [string|Stack], Config);
|
||||
string(Rest, Handler, [?new_seq()|Stack], Config);
|
||||
key(<<?singlequote, Rest/binary>>, Handler, Stack, Config = #config{single_quoted_strings=true}) ->
|
||||
string(Rest, Handler, [single_quoted_string|Stack], Config);
|
||||
string(Rest, Handler, [?new_seq(), single_quote|Stack], Config);
|
||||
key(<<S, Rest/binary>>, Handler, Stack, Config) when ?is_whitespace(S) ->
|
||||
key(Rest, Handler, Stack, Config);
|
||||
key(<<?solidus, Rest/binary>>, Handler, Stack, Config=#config{comments=true}) ->
|
||||
|
|
@ -241,146 +241,466 @@ key(Bin, Handler, Stack, Config) ->
|
|||
?error([Bin, Handler, Stack, Config]).
|
||||
|
||||
|
||||
string(Bin, Handler, Stack, Config) -> string(Bin, Handler, Stack, Config, <<>>).
|
||||
%% string appends it's output to the term at the top of the stack. for
|
||||
%% efficiency the strings are build in reverse order and reversed before
|
||||
%% being added to the output stream
|
||||
%% when parsing strings, the naive detection of partial codepoints is
|
||||
%% insufficient. this incredibly anal function should detect all badly formed
|
||||
%% utf sequences
|
||||
partial_utf(<<>>) -> true;
|
||||
partial_utf(<<X>>) when X >= 16#c2, X =< 16#f4 -> true;
|
||||
partial_utf(<<X, Y>>) when X >= 16#e0, X =< 16#f4, Y >= 16#80, Y =< 16#bf -> true;
|
||||
partial_utf(<<X, Y, Z>>)
|
||||
when X >= 16#f0, X =< 16#f4,
|
||||
Y >= 16#80, Y =< 16#bf,
|
||||
Z >= 16#80, Z =< 16#bf ->
|
||||
true;
|
||||
partial_utf(_) -> false.
|
||||
|
||||
string(Bin, Handler, [StringType|Stack], Config, Acc) ->
|
||||
Length = cut(Bin),
|
||||
<<String:Length/binary, Rest/binary>> = Bin,
|
||||
case Rest of
|
||||
<<?doublequote, Rem/binary>> when StringType == string ->
|
||||
finish_string(Rem, Handler, Stack, Config, <<Acc/binary, String/binary>>);
|
||||
<<?singlequote, Rem/binary>> when StringType == single_quoted_string ->
|
||||
finish_string(Rem, Handler, Stack, Config, <<Acc/binary, String/binary>>);
|
||||
<<Codepoint/utf8, Rem/binary>> when Codepoint == ?doublequote; Codepoint == ?singlequote ->
|
||||
string(Rem, Handler, [StringType|Stack], Config, <<Acc/binary, String/binary, Codepoint/utf8>>)
|
||||
|
||||
%% explicitly whitelist ascii set for better efficiency (seriously, it's worth
|
||||
%% almost a 20% increase)
|
||||
string(<<32, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 32)|Stack], Config);
|
||||
string(<<33, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 33)|Stack], Config);
|
||||
string(<<?doublequote, Rest/binary>>, Handler, S, Config) ->
|
||||
case S of
|
||||
[Acc, key|Stack] ->
|
||||
colon(Rest, handle_event({key, ?end_seq(Acc)}, Handler, Config), [key|Stack], Config);
|
||||
[Acc, single_quote|Stack] ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace(?doublequote, Config)), single_quote|Stack], Config);
|
||||
[Acc|Stack] ->
|
||||
maybe_done(Rest, handle_event({string, ?end_seq(Acc)}, Handler, Config), Stack, Config)
|
||||
end;
|
||||
string(<<35, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 35)|Stack], Config);
|
||||
string(<<36, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 36)|Stack], Config);
|
||||
string(<<37, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 37)|Stack], Config);
|
||||
string(<<38, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 38)|Stack], Config);
|
||||
string(<<?singlequote, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
case Config#config.single_quoted_strings of
|
||||
true ->
|
||||
case Stack of
|
||||
[single_quote, key|S] ->
|
||||
colon(Rest, handle_event({key, ?end_seq(Acc)}, Handler, Config), [key|S], Config)
|
||||
; [single_quote|S] ->
|
||||
maybe_done(Rest, handle_event({string, ?end_seq(Acc)}, Handler, Config), S, Config)
|
||||
; _ ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace(?singlequote, Config))|Stack], Config)
|
||||
end
|
||||
; false ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, ?singlequote)|Stack], Config)
|
||||
end;
|
||||
string(<<40, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 40)|Stack], Config);
|
||||
string(<<41, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 41)|Stack], Config);
|
||||
string(<<42, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 42)|Stack], Config);
|
||||
string(<<43, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 43)|Stack], Config);
|
||||
string(<<44, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 44)|Stack], Config);
|
||||
string(<<45, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 45)|Stack], Config);
|
||||
string(<<46, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 46)|Stack], Config);
|
||||
string(<<$/, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace($/, Config))|Stack], Config);
|
||||
string(<<48, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 48)|Stack], Config);
|
||||
string(<<49, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 49)|Stack], Config);
|
||||
string(<<50, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 50)|Stack], Config);
|
||||
string(<<51, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 51)|Stack], Config);
|
||||
string(<<52, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 52)|Stack], Config);
|
||||
string(<<53, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 53)|Stack], Config);
|
||||
string(<<54, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 54)|Stack], Config);
|
||||
string(<<55, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 55)|Stack], Config);
|
||||
string(<<56, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 56)|Stack], Config);
|
||||
string(<<57, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 57)|Stack], Config);
|
||||
string(<<58, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 58)|Stack], Config);
|
||||
string(<<59, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 59)|Stack], Config);
|
||||
string(<<60, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 60)|Stack], Config);
|
||||
string(<<61, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 61)|Stack], Config);
|
||||
string(<<62, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 62)|Stack], Config);
|
||||
string(<<63, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 63)|Stack], Config);
|
||||
string(<<64, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 64)|Stack], Config);
|
||||
string(<<65, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 65)|Stack], Config);
|
||||
string(<<66, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 66)|Stack], Config);
|
||||
string(<<67, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 67)|Stack], Config);
|
||||
string(<<68, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 68)|Stack], Config);
|
||||
string(<<69, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 69)|Stack], Config);
|
||||
string(<<70, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 70)|Stack], Config);
|
||||
string(<<71, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 71)|Stack], Config);
|
||||
string(<<72, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 72)|Stack], Config);
|
||||
string(<<73, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 73)|Stack], Config);
|
||||
string(<<74, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 74)|Stack], Config);
|
||||
string(<<75, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 75)|Stack], Config);
|
||||
string(<<76, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 76)|Stack], Config);
|
||||
string(<<77, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 77)|Stack], Config);
|
||||
string(<<78, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 78)|Stack], Config);
|
||||
string(<<79, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 79)|Stack], Config);
|
||||
string(<<80, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 80)|Stack], Config);
|
||||
string(<<81, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 81)|Stack], Config);
|
||||
string(<<82, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 82)|Stack], Config);
|
||||
string(<<83, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 83)|Stack], Config);
|
||||
string(<<84, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 84)|Stack], Config);
|
||||
string(<<85, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 85)|Stack], Config);
|
||||
string(<<86, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 86)|Stack], Config);
|
||||
string(<<87, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 87)|Stack], Config);
|
||||
string(<<88, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 88)|Stack], Config);
|
||||
string(<<89, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 89)|Stack], Config);
|
||||
string(<<90, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 90)|Stack], Config);
|
||||
string(<<91, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 91)|Stack], Config);
|
||||
string(<<?rsolidus/utf8, Rest/binary>>, Handler, Stack, Config) ->
|
||||
escape(Rest, Handler, Stack, Config);
|
||||
string(<<93, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 93)|Stack], Config);
|
||||
string(<<94, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 94)|Stack], Config);
|
||||
string(<<95, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 95)|Stack], Config);
|
||||
string(<<96, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 96)|Stack], Config);
|
||||
string(<<97, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 97)|Stack], Config);
|
||||
string(<<98, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 98)|Stack], Config);
|
||||
string(<<99, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 99)|Stack], Config);
|
||||
string(<<100, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 100)|Stack], Config);
|
||||
string(<<101, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 101)|Stack], Config);
|
||||
string(<<102, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 102)|Stack], Config);
|
||||
string(<<103, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 103)|Stack], Config);
|
||||
string(<<104, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 104)|Stack], Config);
|
||||
string(<<105, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 105)|Stack], Config);
|
||||
string(<<106, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 106)|Stack], Config);
|
||||
string(<<107, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 107)|Stack], Config);
|
||||
string(<<108, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 108)|Stack], Config);
|
||||
string(<<109, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 109)|Stack], Config);
|
||||
string(<<110, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 110)|Stack], Config);
|
||||
string(<<111, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 111)|Stack], Config);
|
||||
string(<<112, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 112)|Stack], Config);
|
||||
string(<<113, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 113)|Stack], Config);
|
||||
string(<<114, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 114)|Stack], Config);
|
||||
string(<<115, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 115)|Stack], Config);
|
||||
string(<<116, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 116)|Stack], Config);
|
||||
string(<<117, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 117)|Stack], Config);
|
||||
string(<<118, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 118)|Stack], Config);
|
||||
string(<<119, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 119)|Stack], Config);
|
||||
string(<<120, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 120)|Stack], Config);
|
||||
string(<<121, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 121)|Stack], Config);
|
||||
string(<<122, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 122)|Stack], Config);
|
||||
string(<<123, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 123)|Stack], Config);
|
||||
string(<<124, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 124)|Stack], Config);
|
||||
string(<<125, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 125)|Stack], Config);
|
||||
string(<<126, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 126)|Stack], Config);
|
||||
string(<<127, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 127)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#20, X < 16#2028 ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X == 16#2028; X == 16#2029 ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace(X, Config))|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X > 16#2029, X < 16#d800 ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X > 16#dfff, X < 16#fdd0 ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X > 16#fdef, X < 16#fffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#10000, X < 16#1fffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#20000, X < 16#2fffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#30000, X < 16#3fffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#40000, X < 16#4fffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#50000, X < 16#5fffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#60000, X < 16#6fffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#70000, X < 16#7fffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#80000, X < 16#8fffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#90000, X < 16#9fffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#a0000, X < 16#afffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#b0000, X < 16#bfffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#c0000, X < 16#cfffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#d0000, X < 16#dfffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#e0000, X < 16#efffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#f0000, X < 16#ffffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 16#100000, X < 16#10fffe ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, X)|Stack], Config);
|
||||
string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
case Config#config.replaced_bad_utf8 of
|
||||
true -> noncharacter(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config)
|
||||
; false -> ?error([<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Config])
|
||||
end;
|
||||
string(Bin, Handler, Stack, Config) ->
|
||||
case partial_utf(Bin) of
|
||||
true -> ?incomplete(string, Bin, Handler, Stack, Config)
|
||||
; false ->
|
||||
case Config#config.replaced_bad_utf8 of
|
||||
true -> noncharacter(Bin, Handler, Stack, Config)
|
||||
; false -> ?error([Bin, Handler, Stack, Config])
|
||||
end
|
||||
end.
|
||||
|
||||
|
||||
finish_string(Rest, Handler, [key|_] = Stack, Config, Acc) ->
|
||||
State = handle_event({key, Acc}, Handler, Config),
|
||||
colon(Rest, State, Stack, Config);
|
||||
finish_string(Rest, Handler, Stack, Config, Acc) ->
|
||||
State = handle_event({string, Acc}, Handler, Config),
|
||||
maybe_done(Rest, State, Stack, Config).
|
||||
%% we don't need to guard against partial utf here, because it's already taken
|
||||
%% care of in string
|
||||
%% surrogates
|
||||
noncharacter(<<237, X, _, Rest/binary>>, Handler, [Acc|Stack], Config) when X >= 160 ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 16#fffd)|Stack], Config);
|
||||
%% u+fffe and u+ffff for R14BXX
|
||||
noncharacter(<<239, 191, X, Rest/binary>>, Handler, [Acc|Stack], Config) when X == 190; X == 191 ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 16#fffd)|Stack], Config);
|
||||
%% u+xfffe, u+xffff and other noncharacters
|
||||
noncharacter(<<_/utf8, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 16#fffd)|Stack], Config);
|
||||
%% overlong encodings and missing continuations of a 2 byte sequence
|
||||
noncharacter(<<X, Rest/binary>>, Handler, Stack, Config) when X >= 192, X =< 223 ->
|
||||
strip_continuations(Rest, Handler, [1|Stack], Config);
|
||||
%% overlong encodings and missing continuations of a 3 byte sequence
|
||||
noncharacter(<<X, Rest/binary>>, Handler, Stack, Config) when X >= 224, X =< 239 ->
|
||||
strip_continuations(Rest, Handler, [2|Stack], Config);
|
||||
%% overlong encodings and missing continuations of a 4 byte sequence
|
||||
noncharacter(<<X, Rest/binary>>, Handler, Stack, Config) when X >= 240, X =< 247 ->
|
||||
strip_continuations(Rest, Handler, [3|Stack], Config);
|
||||
%% unexpected bytes, including orphan continuations
|
||||
noncharacter(<<_, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 16#fffd)|Stack], Config);
|
||||
noncharacter(<<>>, Handler, Stack, Config) ->
|
||||
?incomplete(noncharacter, <<>>, Handler, Stack, Config).
|
||||
|
||||
|
||||
cut(Bin) -> cut(Bin, 0).
|
||||
%% strips continuation bytes after bad utf bytes, guards against both too short
|
||||
%% and overlong sequences. N is the maximum number of bytes to strip
|
||||
strip_continuations(Rest, Handler, [0, Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 16#fffd)|Stack], Config);
|
||||
strip_continuations(<<X, Rest/binary>>, Handler, [N|Stack], Config) when X >= 128, X =< 191 ->
|
||||
strip_continuations(Rest, Handler, [N - 1|Stack], Config);
|
||||
%% incomplete
|
||||
strip_continuations(<<>>, Handler, Stack, Config) ->
|
||||
?incomplete(strip_continuations, <<>>, Handler, Stack, Config);
|
||||
%% not a continuation byte, dispatch back to string
|
||||
strip_continuations(Rest, Handler, [_, Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 16#fffd)|Stack], Config).
|
||||
|
||||
cut(<<32, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<33, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<35, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<36, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<37, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<38, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<40, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<41, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<42, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<43, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<44, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<45, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<46, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<48, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<49, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<50, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<51, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<52, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<53, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<54, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<55, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<56, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<57, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<58, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<59, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<60, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<61, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<62, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<63, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<64, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<65, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<66, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<67, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<68, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<69, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<70, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<71, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<72, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<73, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<74, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<75, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<76, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<77, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<78, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<79, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<80, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<81, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<82, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<83, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<84, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<85, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<86, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<87, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<88, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<89, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<90, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<91, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<93, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<94, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<95, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<96, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<97, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<98, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<99, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<100, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<101, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<102, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<103, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<104, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<105, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<106, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<107, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<108, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<109, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<110, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<111, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<112, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<113, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<114, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<115, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<116, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<117, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<118, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<119, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<120, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<121, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<122, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<123, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<124, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<125, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<126, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<127, Rest/binary>>, N) -> cut(Rest, N + 1);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 128, X < 16#0800 -> cut(Rest, N + 2);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#0800, X < 16#2028 -> cut(Rest, N + 3);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#202a, X < 16#d800 -> cut(Rest, N + 3);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X > 16#dfff, X < 16#fdd0 -> cut(Rest, N + 3);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X > 16#fdef, X < 16#fffe -> cut(Rest, N + 3);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#10000, X < 16#1fffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#20000, X < 16#2fffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#30000, X < 16#3fffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#40000, X < 16#4fffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#50000, X < 16#5fffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#60000, X < 16#6fffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#70000, X < 16#7fffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#80000, X < 16#8fffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#90000, X < 16#9fffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#a0000, X < 16#afffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#b0000, X < 16#bfffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#c0000, X < 16#cfffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#d0000, X < 16#dfffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#e0000, X < 16#efffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#f0000, X < 16#ffffe -> cut(Rest, N + 4);
|
||||
cut(<<X/utf8, Rest/binary>>, N) when X >= 16#100000, X < 16#10fffe -> cut(Rest, N + 4);
|
||||
cut(_, N) -> N.
|
||||
|
||||
escape(<<$b, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace($\b, Config))|Stack], Config);
|
||||
escape(<<$f, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace($\f, Config))|Stack], Config);
|
||||
escape(<<$n, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace($\n, Config))|Stack], Config);
|
||||
escape(<<$r, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace($\r, Config))|Stack], Config);
|
||||
escape(<<$t, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace($\t, Config))|Stack], Config);
|
||||
escape(<<?rsolidus, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace($\\, Config))|Stack], Config);
|
||||
escape(<<?solidus, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace($/, Config))|Stack], Config);
|
||||
escape(<<?doublequote, Rest/binary>>, Handler, [Acc|Stack], Config) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace($\", Config))|Stack], Config);
|
||||
escape(<<?singlequote, Rest/binary>>, Handler, [Acc|Stack], Config = #config{single_quoted_strings=true}) ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, maybe_replace(?singlequote, Config))|Stack], Config);
|
||||
escape(<<$u, Rest/binary>>, Handler, Stack, Config) ->
|
||||
escaped_unicode(Rest, Handler, Stack, Config);
|
||||
escape(<<>>, Handler, Stack, Config) ->
|
||||
?incomplete(escape, <<>>, Handler, Stack, Config);
|
||||
escape(Bin, Handler, [Acc|Stack], Config=#config{ignored_bad_escapes=true}) ->
|
||||
string(Bin, Handler, [?acc_seq(Acc, ?rsolidus)|Stack], Config);
|
||||
escape(Bin, Handler, Stack, Config) ->
|
||||
?error([Bin, Handler, Stack, Config]).
|
||||
|
||||
|
||||
%% this code is ugly and unfortunate, but so is json's handling of escaped
|
||||
%% unicode codepoint sequences.
|
||||
escaped_unicode(<<A, B, C, D, Rest/binary>>, Handler, [Acc|Stack], Config)
|
||||
when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
|
||||
case erlang:list_to_integer([A, B, C, D], 16) of
|
||||
%% high surrogate, dispatch to low surrogate
|
||||
X when X >= 16#d800, X =< 16#dbff ->
|
||||
low_surrogate(Rest, Handler, [X, Acc|Stack], Config)
|
||||
%% low surrogate, illegal in this position
|
||||
; X when X >= 16#dc00, X =< 16#dfff ->
|
||||
case Config#config.replaced_bad_utf8 of
|
||||
true -> string(Rest, Handler, [?acc_seq(Acc, 16#fffd)|Stack], Config)
|
||||
; false -> ?error([<<A, B, C, D, Rest/binary>>, Handler, [Acc|Stack], Config])
|
||||
end
|
||||
%% anything else
|
||||
; X -> string(Rest, Handler, [?acc_seq(Acc, maybe_replace(X, Config))|Stack], Config)
|
||||
end;
|
||||
escaped_unicode(Bin, Handler, Stack, Config) ->
|
||||
case is_partial_escape(Bin) of
|
||||
true -> ?incomplete(escaped_unicode, Bin, Handler, Stack, Config)
|
||||
; false -> ?error([Bin, Handler, Stack, Config])
|
||||
end.
|
||||
|
||||
|
||||
is_partial_escape(<<A, B, C>>) when ?is_hex(A), ?is_hex(B), ?is_hex(C) -> true;
|
||||
is_partial_escape(<<A, B>>) when ?is_hex(A), ?is_hex(B) -> true;
|
||||
is_partial_escape(<<A>>) when ?is_hex(A) -> true;
|
||||
is_partial_escape(<<>>) -> true;
|
||||
is_partial_escape(_) -> false.
|
||||
|
||||
|
||||
low_surrogate(<<?rsolidus, $u, A, B, C, D, Rest/binary>>, Handler, [High, Acc|Stack], Config)
|
||||
when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
|
||||
case erlang:list_to_integer([A, B, C, D], 16) of
|
||||
X when X >= 16#dc00, X =< 16#dfff ->
|
||||
Y = surrogate_to_codepoint(High, X),
|
||||
case (Y =< 16#d800 orelse Y >= 16#e000) of
|
||||
true -> string(Rest, Handler, [?acc_seq(Acc, Y)|Stack], Config)
|
||||
; false ->
|
||||
case Config#config.replaced_bad_utf8 of
|
||||
true ->
|
||||
string(Rest, Handler, [?acc_seq(Acc, 16#fffd, 16#fffd)|Stack], Config)
|
||||
; false ->
|
||||
?error([<<?rsolidus, $u, A, B, C, D, Rest/binary>>, Handler, [High, Acc|Stack], Config])
|
||||
end
|
||||
end
|
||||
; _ ->
|
||||
case Config#config.replaced_bad_utf8 of
|
||||
true -> string(Rest, Handler, [?acc_seq(Acc, 16#fffd, 16#fffd)|Stack], Config)
|
||||
; false -> ?error([<<?rsolidus, $u, A, B, C, D, Rest/binary>>, Handler, [High, Acc|Stack], Config])
|
||||
end
|
||||
end;
|
||||
low_surrogate(Bin, Handler, [High, Acc|Stack], Config) ->
|
||||
case is_partial_low(Bin) of
|
||||
true -> ?incomplete(low_surrogate, Bin, Handler, [High, Acc|Stack], Config)
|
||||
; false ->
|
||||
case Config#config.replaced_bad_utf8 of
|
||||
true -> string(Bin, Handler, [?acc_seq(Acc, 16#fffd)|Stack], Config)
|
||||
; false -> ?error([Bin, Handler, [High, Acc|Stack], Config])
|
||||
end
|
||||
end.
|
||||
|
||||
|
||||
is_partial_low(<<?rsolidus, $u, A, B, C>>) when ?is_hex(A), ?is_hex(B), ?is_hex(C) -> true;
|
||||
is_partial_low(<<?rsolidus, $u, A, B>>) when ?is_hex(A), ?is_hex(B) -> true;
|
||||
is_partial_low(<<?rsolidus, $u, A>>) when ?is_hex(A) -> true;
|
||||
is_partial_low(<<?rsolidus, $u>>) -> true;
|
||||
is_partial_low(<<?rsolidus>>) -> true;
|
||||
is_partial_low(<<>>) -> true;
|
||||
is_partial_low(_) -> false.
|
||||
|
||||
|
||||
%% stole this from the unicode spec
|
||||
surrogate_to_codepoint(High, Low) ->
|
||||
(High - 16#d800) * 16#400 + (Low - 16#dc00) + 16#10000.
|
||||
|
||||
|
||||
maybe_replace(X, #config{dirty_strings=true}) when is_integer(X) -> [X];
|
||||
maybe_replace($\b, #config{escaped_strings=true}) -> [$\\, $b];
|
||||
maybe_replace($\t, #config{escaped_strings=true}) -> [$\\, $t];
|
||||
maybe_replace($\n, #config{escaped_strings=true}) -> [$\\, $n];
|
||||
maybe_replace($\f, #config{escaped_strings=true}) -> [$\\, $f];
|
||||
maybe_replace($\r, #config{escaped_strings=true}) -> [$\\, $r];
|
||||
maybe_replace($\", #config{escaped_strings=true}) -> [$\\, $\"];
|
||||
maybe_replace($', Config=#config{escaped_strings=true}) ->
|
||||
case Config#config.single_quoted_strings of
|
||||
true -> [$\\, $']
|
||||
; false -> [$']
|
||||
end;
|
||||
maybe_replace($/, Config=#config{escaped_strings=true}) ->
|
||||
case Config#config.escaped_forward_slashes of
|
||||
true -> [$\\, $/]
|
||||
; false -> [$/]
|
||||
end;
|
||||
maybe_replace($\\, #config{escaped_strings=true}) -> [$\\, $\\];
|
||||
maybe_replace(X, Config=#config{escaped_strings=true}) when X == 16#2028; X == 16#2029 ->
|
||||
case Config#config.unescaped_jsonp of
|
||||
true -> [X]
|
||||
; false -> jsx_utils:json_escape_sequence(X)
|
||||
end;
|
||||
maybe_replace(X, #config{escaped_strings=true}) when X < 32 ->
|
||||
jsx_utils:json_escape_sequence(X);
|
||||
maybe_replace(X, _Config) -> [X].
|
||||
|
||||
|
||||
%% like strings, numbers are collected in an intermediate accumulator before
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue