File 3324-fixup-ensure-that-the-list-parser-also-fun... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 3324-fixup-ensure-that-the-list-parser-also-functions.patch of Package erlang (Revision ac78bcc5a6f7a4d1efd770008567e9f7)

Currently displaying revision ac78bcc5a6f7a4d1efd770008567e9f7 , Show latest

From d93ac2f51105890ef084a72baa6ca7b7197137d8 Mon Sep 17 00:00:00 2001
From: zadean <contact@zadean.com>
Date: Thu, 12 Sep 2019 13:06:51 +0200
Subject: [PATCH 4/5] fixup: ensure that the list parser also functions

---
 lib/xmerl/src/xmerl_sax_parser_base.erlsrc | 172 ++++++++++++++++-------------
 1 file changed, 97 insertions(+), 75 deletions(-)

diff --git a/lib/xmerl/src/xmerl_sax_parser_base.erlsrc b/lib/xmerl/src/xmerl_sax_parser_base.erlsrc
index a1305902d1..593a218fd2 100644
--- a/lib/xmerl/src/xmerl_sax_parser_base.erlsrc
+++ b/lib/xmerl/src/xmerl_sax_parser_base.erlsrc
@@ -297,7 +297,7 @@ parse_text_decl(?STRING("<?xml") = Bytes, State) ->
     cf(Bytes, State, fun parse_text_decl/2);
 parse_text_decl(?STRING_REST("<?xml", Rest1), State) ->
     parse_text_decl_1(Rest1, State);
-parse_text_decl(Bytes, State) when is_binary(Bytes) ->
+parse_text_decl(Bytes, State) ->
     {Bytes, State}.
 
 parse_text_decl_1(?STRING_EMPTY, State) ->
@@ -308,12 +308,12 @@ parse_text_decl_1(?STRING("v") = Rest, State) ->
     cf(Rest, State, fun parse_text_decl_1/2);
 parse_text_decl_1(?STRING("e") = Rest, State) ->
     cf(Rest, State, fun parse_text_decl_2/2);
-parse_text_decl_1(?STRING_UNBOUND_REST("?>", _Rest) = _Bytes, State) ->
+parse_text_decl_1(?STRING_REST("?>", _Rest) = _Bytes, State) ->
     ?fatal_error(State, "expecting attribute encoding");
 parse_text_decl_1(?STRING_UNBOUND_REST(C, _) = Rest, State) when ?is_whitespace(C) ->
     {_WS, Rest1, State1} = whitespace(Rest, State, []),
     parse_text_decl_1(Rest1, State1);
-parse_text_decl_1(?STRING_UNBOUND_REST("v", Rest) = _Bytes, State) ->
+parse_text_decl_1(?STRING_REST("v", Rest) = _Bytes, State) ->
     case parse_name(Rest, State, [$v]) of
         {"version", Rest1, State1} ->
             {Rest2, State2} = parse_eq(Rest1, State1),
@@ -322,7 +322,7 @@ parse_text_decl_1(?STRING_UNBOUND_REST("v", Rest) = _Bytes, State) ->
         {_, _, State1} ->
             ?fatal_error(State1, "expecting attribute version")
     end;
-parse_text_decl_1(?STRING_UNBOUND_REST("e", _) = Bytes, State) ->
+parse_text_decl_1(?STRING_REST("e", _) = Bytes, State) ->
     parse_text_decl_2(Bytes, State);
 parse_text_decl_1(?STRING_UNBOUND_REST(_, _), State) ->
     ?fatal_error(State, "expecting attribute encoding or version");
@@ -337,7 +337,7 @@ parse_text_decl_2(?STRING("e") = Rest, State) ->
 parse_text_decl_2(?STRING_UNBOUND_REST(C, _) = Rest, State) when ?is_whitespace(C) ->
     {_WS, Rest1, State1} = whitespace(Rest, State, []),
     parse_text_decl_2(Rest1, State1);
-parse_text_decl_2(?STRING_UNBOUND_REST("e", Rest) = _Bytes, State) ->
+parse_text_decl_2(?STRING_REST("e", Rest) = _Bytes, State) ->
     case parse_name(Rest, State, [$e]) of
         {"encoding", Rest1, State1} ->
             {Rest2, State2} = parse_eq(Rest1, State1),
@@ -354,7 +354,7 @@ parse_text_decl_3(?STRING_EMPTY, State) ->
     cf(?STRING_EMPTY, State, fun parse_text_decl_3/2);
 parse_text_decl_3(?STRING("?") = Rest, State) ->
     cf(Rest, State, fun parse_text_decl_3/2);
-parse_text_decl_3(?STRING_UNBOUND_REST("?>", Rest) = _Bytes, State) ->
+parse_text_decl_3(?STRING_REST("?>", Rest) = _Bytes, State) ->
     {Rest, State};
 parse_text_decl_3(?STRING_UNBOUND_REST(C, _) = Rest, State) when ?is_whitespace(C) ->
     {_WS, Rest1, State1} = whitespace(Rest, State, []),
@@ -985,9 +985,9 @@ parse_attributes(Bytes, State, CurrentTag) ->
 % check that the next character is valid
 parse_attributes_1(?STRING_EMPTY, State, CurrentTag) ->
     cf(?STRING_EMPTY, State, CurrentTag, fun parse_attributes_1/3);
-parse_attributes_1(?STRING_UNBOUND_REST("/", _) = Bytes, State, CurrentTag) ->
+parse_attributes_1(?STRING_REST("/", _) = Bytes, State, CurrentTag) ->
     parse_attributes(Bytes, State, CurrentTag);
-parse_attributes_1(?STRING_UNBOUND_REST(">", _) = Bytes, State, CurrentTag) ->
+parse_attributes_1(?STRING_REST(">", _) = Bytes, State, CurrentTag) ->
     parse_attributes(Bytes, State, CurrentTag);
 parse_attributes_1(?STRING_UNBOUND_REST(C, _) = Bytes, State, CurrentTag) when ?is_whitespace(C) ->
     parse_attributes(Bytes, State, CurrentTag);
@@ -1907,7 +1907,7 @@ parse_system_literal(?STRING_EMPTY, State, Stop, Acc) ->
     cf(?STRING_EMPTY, State, Stop, Acc, fun parse_system_literal/4);
 parse_system_literal(?STRING_UNBOUND_REST(Stop, Rest), State, Stop, Acc) ->
     {lists:reverse(Acc), Rest, State};
-parse_system_literal(?STRING_UNBOUND_REST("#", _), State, _, _) ->
+parse_system_literal(?STRING_REST("#", _), State, _, _) ->
     ?fatal_error(State, "Fragment found in system identifier");
 parse_system_literal(?STRING_UNBOUND_REST(C, Rest), State, Stop, Acc) ->
     parse_system_literal(Rest, State, Stop, [C |Acc]);
@@ -2139,7 +2139,8 @@ handle_external_entity({file, FileToOpen}, #xmerl_sax_parser_state{encoding = En
             {Head1, State3} = encode_external_input(Head, Enc1, Enc, State2),
             ConFun = external_continuation_cb(Enc1, Enc),
             {Acc1, ?STRING_EMPTY, EntityState} = 
-                parse_external_entity_1(Head1, State3#xmerl_sax_parser_state{continuation_fun = ConFun}, Acc),
+                parse_external_entity_1(Head1, State3#xmerl_sax_parser_state{continuation_fun = ConFun,
+                                                                             encoding = Enc}, Acc),
             ok = file:close(FD),
         {Acc1, 
          EntityState#xmerl_sax_parser_state.event_state,
@@ -2566,7 +2567,7 @@ parse_doctype_decl_2(?STRING("IGNO") = Bytes, State) ->
     cf(Bytes, State, fun parse_doctype_decl_2/2);
 parse_doctype_decl_2(?STRING("IGNOR") = Bytes, State) ->
     cf(Bytes, State, fun parse_doctype_decl_2/2);
-parse_doctype_decl_2(?STRING_UNBOUND_REST("IGNORE", Rest), State) ->
+parse_doctype_decl_2(?STRING_REST("IGNORE", Rest), State) ->
     case State#xmerl_sax_parser_state.file_type of
         normal ->
             ?fatal_error(State, "Conditional sections may only appear in the external DTD subset.");
@@ -2576,7 +2577,7 @@ parse_doctype_decl_2(?STRING_UNBOUND_REST("IGNORE", Rest), State) ->
 parse_doctype_decl_2(?STRING_UNBOUND_REST(C, _) = Bytes, State) when ?is_whitespace(C) ->
     {_WS, Rest, State1} = whitespace(Bytes, State, []),
     parse_doctype_decl_2(Rest, State1);
-parse_doctype_decl_2(?STRING_UNBOUND_REST("%", Rest), State) ->
+parse_doctype_decl_2(?STRING_REST("%", Rest), State) ->
     {Ref, Rest1, State1} = parse_pe_reference(Rest, State),
     case Ref of
         {internal_parameter, _, RefValue} ->
@@ -2684,11 +2685,11 @@ parse_element_content_1(?STRING_REST("EMPTY", Rest), State, Acc) ->
     parse_element_content_1(Rest, State, "YTPME" ++ Acc);
 parse_element_content_1(?STRING_REST(">", Rest), State, Acc) ->
     {lists:reverse(delete_leading_whitespace(Acc)), Rest, State};
-parse_element_content_1(?STRING_UNBOUND_REST("(", Rest), State, []) ->
+parse_element_content_1(?STRING_REST("(", Rest), State, []) ->
     parse_element_content_2(Rest, State, [$(], {1, [none]});
-parse_element_content_1(?STRING_UNBOUND_REST("(", _), State, _) ->
+parse_element_content_1(?STRING_REST("(", _), State, _) ->
     ?fatal_error(State, "> expected");
-parse_element_content_1(?STRING_UNBOUND_REST("%", Rest), State, Acc) ->
+parse_element_content_1(?STRING_REST("%", Rest), State, Acc) ->
     {Ref, Rest1, State1} = parse_pe_reference(Rest, State),
     case Ref of
         {internal_parameter, _, RefValue} ->
@@ -2741,7 +2742,7 @@ parse_element_content_2(?STRING_REST("#PCDATA", _), State, _, {_, ['|'|_]}) ->
     ?fatal_error(State, "#PCDATA can only come first in element content.");
 parse_element_content_2(?STRING_REST("#PCDATA", Rest), State, Acc, {1, Sep}) ->
     parse_element_content_4(Rest, State, "ATADCP#" ++ Acc, {1, [any|Sep]});
-parse_element_content_2(?STRING_UNBOUND_REST("%", Rest), State, Acc, Depth) ->
+parse_element_content_2(?STRING_REST("%", Rest), State, Acc, Depth) ->
     case State#xmerl_sax_parser_state.file_type of
         normal ->
             % not allowed locally
@@ -2764,7 +2765,7 @@ parse_element_content_2(?STRING_UNBOUND_REST("%", Rest), State, Acc, Depth) ->
                     end
             end
     end;
-parse_element_content_2(?STRING_UNBOUND_REST(")", Rest), State, Acc, {1, _}) ->
+parse_element_content_2(?STRING_REST(")", Rest), State, Acc, {1, _}) ->
     case lists:all(fun(C) when ?is_whitespace(C) -> true;
                       ($()-> true;
                       (_) -> false
@@ -2784,14 +2785,14 @@ parse_element_content_2(?STRING_UNBOUND_REST(")", Rest), State, Acc, {1, _}) ->
                     parse_element_content_1(Rest1, State1, Acc1)
             end
     end;
-parse_element_content_2(?STRING_UNBOUND_REST("(", Rest), State, Acc, {Depth, [H|Sep]}) ->
+parse_element_content_2(?STRING_REST("(", Rest), State, Acc, {Depth, [H|Sep]}) ->
     H1 = if H == none -> any;
             H == any -> ?fatal_error(State, "expecting separator");
             true ->
                 check_separator(Acc, H, State)
          end,
     parse_element_content_2(Rest, State, [$(|Acc], {Depth + 1, [none,H1|Sep]});
-parse_element_content_2(?STRING_UNBOUND_REST(")", Rest), State, Acc, {Depth, [_|Sep]}) ->
+parse_element_content_2(?STRING_REST(")", Rest), State, Acc, {Depth, [_|Sep]}) ->
     case Acc of
         [$,|_] ->
             ?fatal_error(State, "expecting value");
@@ -2804,27 +2805,27 @@ parse_element_content_2(?STRING_UNBOUND_REST(")", Rest), State, Acc, {Depth, [_|
 parse_element_content_2(?STRING_UNBOUND_REST(C, _) = Rest, State, Acc, Depth) when ?is_whitespace(C) ->
     {WS, Rest1, State1} = whitespace(Rest, State, []),
     parse_element_content_2(Rest1, State1, WS ++ Acc, Depth);
-parse_element_content_2(?STRING_UNBOUND_REST("|", Rest), State, Acc, {Depth, [any|T]}) ->
+parse_element_content_2(?STRING_REST("|", Rest), State, Acc, {Depth, [any|T]}) ->
     parse_element_content_2(Rest, State, [$||Acc], {Depth, ['|'|T]});
-parse_element_content_2(?STRING_UNBOUND_REST("|", Rest), State, Acc, {_, ['|'|_]} = Sep) ->
+parse_element_content_2(?STRING_REST("|", Rest), State, Acc, {_, ['|'|_]} = Sep) ->
     case Acc of
         [$||_] ->
             ?fatal_error(State, "expecting value");
         _ ->
             parse_element_content_2(Rest, State, [$||Acc], Sep)
     end;
-parse_element_content_2(?STRING_UNBOUND_REST(",", Rest), State, Acc, {Depth, [any|T]}) ->
+parse_element_content_2(?STRING_REST(",", Rest), State, Acc, {Depth, [any|T]}) ->
     parse_element_content_2(Rest, State, [$,|Acc], {Depth, [','|T]});
-parse_element_content_2(?STRING_UNBOUND_REST(",", Rest), State, Acc, {_, [','|_]} = Sep) ->
+parse_element_content_2(?STRING_REST(",", Rest), State, Acc, {_, [','|_]} = Sep) ->
     case Acc of
         [$,|_] ->
             ?fatal_error(State, "expecting value");
         _ ->
             parse_element_content_2(Rest, State, [$,|Acc], Sep)
     end;
-parse_element_content_2(?STRING_UNBOUND_REST("|", _), State, _Acc, {_, [H|_]}) ->
+parse_element_content_2(?STRING_REST("|", _), State, _Acc, {_, [H|_]}) ->
     ?fatal_error(State, "Expected: " ++ atom_to_list(H));
-parse_element_content_2(?STRING_UNBOUND_REST(",", _), State, _Acc, {_, [H|_]}) ->
+parse_element_content_2(?STRING_REST(",", _), State, _Acc, {_, [H|_]}) ->
     ?fatal_error(State, "Expected: " ++ atom_to_list(H));
 parse_element_content_2(?STRING_UNBOUND_REST(C, Rest), State, Acc, {Depth, [H|T]}) ->
     case is_name_start(C) of
@@ -2846,11 +2847,11 @@ parse_element_content_2(Bytes, State, Acc, _Depth) ->
 % maybe parse the cardinality 
 parse_element_content_3(?STRING_EMPTY, State, Acc) ->
     cf(?STRING_EMPTY, State, Acc, fun parse_element_content_3/3);
-parse_element_content_3(?STRING_UNBOUND_REST("?", Rest), State, Acc) ->
+parse_element_content_3(?STRING_REST("?", Rest), State, Acc) ->
     {[$?|Acc], Rest, State};
-parse_element_content_3(?STRING_UNBOUND_REST("+", Rest), State, Acc) ->
+parse_element_content_3(?STRING_REST("+", Rest), State, Acc) ->
     {[$+|Acc], Rest, State};
-parse_element_content_3(?STRING_UNBOUND_REST("*", Rest), State, Acc) ->
+parse_element_content_3(?STRING_REST("*", Rest), State, Acc) ->
     {[$*|Acc], Rest, State};
 parse_element_content_3(Rest, State, Acc) ->
     {Acc, Rest, State}.
@@ -2860,34 +2861,34 @@ parse_element_content_4(?STRING_EMPTY, State, Acc, Depth) ->
     cf(?STRING_EMPTY, State, Acc, Depth, fun parse_element_content_4/4);
 parse_element_content_4(?STRING(")") = Bytes, State, Acc, Depth) ->
     cf(Bytes, State, Acc, Depth, fun parse_element_content_4/4);
-parse_element_content_4(?STRING_UNBOUND_REST("|", Rest), State, Acc, {Depth, [any|T]}) ->
+parse_element_content_4(?STRING_REST("|", Rest), State, Acc, {Depth, [any|T]}) ->
     parse_element_content_4(Rest, State, [$||Acc], {Depth, ['|'|T]});
-parse_element_content_4(?STRING_UNBOUND_REST("|", Rest), State, Acc, {_, ['|'|_]} = Sep) ->
+parse_element_content_4(?STRING_REST("|", Rest), State, Acc, {_, ['|'|_]} = Sep) ->
     case Acc of
         [$||_] ->
             ?fatal_error(State, "expecting value");
         _ ->
             parse_element_content_4(Rest, State, [$||Acc], Sep)
     end;
-parse_element_content_4(?STRING_UNBOUND_REST("|", Rest), State, Acc, Depth) ->
+parse_element_content_4(?STRING_REST("|", Rest), State, Acc, Depth) ->
     parse_element_content_4(Rest, State, [$||Acc], Depth);
 parse_element_content_4(?STRING_UNBOUND_REST(C, Rest), State, Acc, Depth) when ?is_whitespace(C) ->
     parse_element_content_4(Rest, State, [C|Acc], Depth);
 
-parse_element_content_4(?STRING_UNBOUND_REST(")*", Rest), State, Acc, {1, _}) ->
+parse_element_content_4(?STRING_REST(")*", Rest), State, Acc, {1, _}) ->
     parse_element_content_1(Rest, State, [$*,$)|Acc]);
-parse_element_content_4(?STRING_UNBOUND_REST(")", _), State, _, {1, [','|_]}) ->
+parse_element_content_4(?STRING_REST(")", _), State, _, {1, [','|_]}) ->
     ?fatal_error(State, ")* expected after mixed content");
-parse_element_content_4(?STRING_UNBOUND_REST(")", _), State, _, {1, ['|'|_]}) ->
+parse_element_content_4(?STRING_REST(")", _), State, _, {1, ['|'|_]}) ->
     ?fatal_error(State, ")* expected after mixed content");
-parse_element_content_4(?STRING_UNBOUND_REST(")", Rest), State, Acc, {1, _}) ->
+parse_element_content_4(?STRING_REST(")", Rest), State, Acc, {1, _}) ->
     parse_element_content_1(Rest, State, [$)|Acc]);
 
-parse_element_content_4(?STRING_UNBOUND_REST(")*", Rest), State, Acc, {Depth, [_|T]}) ->
+parse_element_content_4(?STRING_REST(")*", Rest), State, Acc, {Depth, [_|T]}) ->
     parse_element_content_2(Rest, State, [$*,$)|Acc], {Depth - 1, T});
-parse_element_content_4(?STRING_UNBOUND_REST(")", Rest), State, Acc, {Depth, [_|T]}) ->
+parse_element_content_4(?STRING_REST(")", Rest), State, Acc, {Depth, [_|T]}) ->
     parse_element_content_2(Rest, State, [$)|Acc], {Depth - 1, T});
-parse_element_content_4(?STRING_UNBOUND_REST("%", Rest), State, Acc, Depth) ->
+parse_element_content_4(?STRING_REST("%", Rest), State, Acc, Depth) ->
     {Ref, Rest1, State1} = parse_pe_reference(Rest, State),
     case Ref of
         {internal_parameter, _, RefValue} ->
@@ -2939,7 +2940,7 @@ parse_att_list_decl(?STRING_EMPTY, State) ->
 parse_att_list_decl(?STRING_UNBOUND_REST(C, _) = Bytes, State) when ?is_whitespace(C) ->
     {_WS, Rest, State1} = whitespace(Bytes, State, []), 
     parse_att_list_decl_1(Rest, State1);
-parse_att_list_decl(?STRING_UNBOUND_REST("%", Rest), State) ->
+parse_att_list_decl(?STRING_REST("%", Rest), State) ->
     {Ref, Rest1, State1} = parse_pe_reference(Rest, State),
     case Ref of
         {internal_parameter, _, RefValue} ->
@@ -2962,7 +2963,7 @@ parse_att_list_decl(Bytes, State) ->
 
 parse_att_list_decl_1(?STRING_EMPTY, State) ->
     cf(?STRING_EMPTY, State, fun parse_att_list_decl_1/2);
-parse_att_list_decl_1(?STRING_UNBOUND_REST("%", Rest), State) ->
+parse_att_list_decl_1(?STRING_REST("%", Rest), State) ->
     case State#xmerl_sax_parser_state.file_type of
         normal ->
             ?fatal_error(State, "Parsed entities not allowed in Internal subset"); %%WFC: PEs in Internal Subset
@@ -3013,7 +3014,7 @@ parse_att_defs(?STRING_REST(">", Rest), State, _ElementName) ->
 parse_att_defs(?STRING_UNBOUND_REST(C, _) = Rest, State, ElementName) when ?is_whitespace(C) ->
     {_WS, Rest1, State1} = whitespace(Rest, State, []),
     parse_att_defs(Rest1, State1, ElementName);
-parse_att_defs(?STRING_UNBOUND_REST("%", Rest), #xmerl_sax_parser_state{file_type = Type} = State, ElementName) ->
+parse_att_defs(?STRING_REST("%", Rest), #xmerl_sax_parser_state{file_type = Type} = State, ElementName) ->
     case Type of
         normal ->
             ?fatal_error(State, "Parsed entities not allowed in Internal subset"); %%WFC: PEs in Internal Subset
@@ -3145,7 +3146,7 @@ parse_att_type_1(?STRING_EMPTY, State, Acc) ->
     cf(?STRING_EMPTY, State, Acc, fun parse_att_type_1/3);
 parse_att_type_1(?STRING_UNBOUND_REST(C, _) = Bytes, State, Acc)  when ?is_whitespace(C) ->
     {lists:reverse(Acc), Bytes, State};
-parse_att_type_1(?STRING_UNBOUND_REST("%", Rest), State, Acc) ->
+parse_att_type_1(?STRING_REST("%", Rest), State, Acc) ->
     {Ref, Rest1, State1} = parse_pe_reference(Rest, State),
     case Ref of
         {internal_parameter, _, RefValue} ->
@@ -3677,9 +3678,9 @@ parse_include_sect(?STRING_REST("\r", Rest), #xmerl_sax_parser_state{line_no=N}
     parse_include_sect(Rest, State#xmerl_sax_parser_state{line_no=N+1});
 parse_include_sect(?STRING_UNBOUND_REST(C, Rest), State) when ?is_whitespace(C) ->
     parse_include_sect(Rest, State);
-parse_include_sect(?STRING_UNBOUND_REST("]>", Rest), State) ->
+parse_include_sect(?STRING_REST("]>", Rest), State) ->
     {Rest, State};
-parse_include_sect(?STRING_UNBOUND_REST("[", Rest), State) ->
+parse_include_sect(?STRING_REST("[", Rest), State) ->
     parse_include_sect_1(Rest, State);
 parse_include_sect(Bytes, State) ->
     unicode_incomplete_check([Bytes, State, fun parse_include_sect/2], 
@@ -3696,7 +3697,7 @@ parse_include_sect_1(?STRING_EMPTY, State) ->
     end;
 parse_include_sect_1(?STRING("]") = Bytes, State) ->
     cf(Bytes, State, fun parse_include_sect_1/2);
-parse_include_sect_1(?STRING_UNBOUND_REST("]>", Rest), State) ->
+parse_include_sect_1(?STRING_REST("]>", Rest), State) ->
     {Rest, State};
 parse_include_sect_1(?STRING_UNBOUND_REST(_, _) = Bytes, State) ->
     {Rest1, State1} = parse_text_decl(Bytes, State),
@@ -3727,7 +3728,7 @@ parse_ignore_sect(?STRING("]") = Bytes, State) ->
 parse_ignore_sect(?STRING_UNBOUND_REST(C, _) = Bytes, State) when ?is_whitespace(C) ->
     {_WS, Rest, State1} = whitespace(Bytes, State, []), 
     parse_ignore_sect(Rest, State1);
-parse_ignore_sect(?STRING_UNBOUND_REST("[", Rest), State) ->
+parse_ignore_sect(?STRING_REST("[", Rest), State) ->
     parse_ignore_sect_1(Rest, State, 1);
 parse_ignore_sect(Bytes, State) ->
     unicode_incomplete_check([Bytes, State, fun parse_ignore_sect/2], 
@@ -3750,11 +3751,11 @@ parse_ignore_sect_1(?STRING("]") = Bytes, State, Depth) ->
     cf(Bytes, State, Depth, fun parse_ignore_sect_1/3);
 parse_ignore_sect_1(?STRING("]]") = Bytes, State, Depth) ->
     cf(Bytes, State, Depth, fun parse_ignore_sect_1/3);
-parse_ignore_sect_1(?STRING_UNBOUND_REST("]]>", Rest), State, 1) ->
+parse_ignore_sect_1(?STRING_REST("]]>", Rest), State, 1) ->
     {Rest, State};
-parse_ignore_sect_1(?STRING_UNBOUND_REST("]]>", Rest), State, Depth) ->
+parse_ignore_sect_1(?STRING_REST("]]>", Rest), State, Depth) ->
     parse_ignore_sect_1(Rest, State, Depth - 1);
-parse_ignore_sect_1(?STRING_UNBOUND_REST("<![", Rest), State, Depth) ->
+parse_ignore_sect_1(?STRING_REST("<![", Rest), State, Depth) ->
     parse_ignore_sect_1(Rest, State, Depth + 1);
 parse_ignore_sect_1(?STRING_UNBOUND_REST(_, Rest), State, Depth) ->
     parse_ignore_sect_1(Rest, State, Depth);
@@ -4768,15 +4769,25 @@ external_continuation_cb(FileEnc, FileEnc) ->
 external_continuation_cb(FileEnc, BaseEnc) ->
     fun({IoDevice, Rest}) ->
         case file:read(IoDevice, 1024) of
+            eof when Rest == <<>>, BaseEnc =:= list ->
+                {[], {IoDevice, <<>>}};
             eof when Rest == <<>> ->
                 {<<>>, {IoDevice, <<>>}};
+            eof when BaseEnc =:= list->
+                {unicode:characters_to_list(Rest, FileEnc), {IoDevice, <<>>}};
             eof ->
                 {unicode:characters_to_binary(Rest, FileEnc, BaseEnc), {IoDevice, <<>>}};
             {error, Err} ->
                 throw({error, Err});
             {ok, FileBin} ->
                 Comp = <<Rest/binary, FileBin/binary>>,
-                case unicode:characters_to_binary(Comp, FileEnc, BaseEnc) of
+                Trans = case BaseEnc of 
+                            list ->
+                                unicode:characters_to_list(Comp, FileEnc);
+                            _ ->
+                                unicode:characters_to_binary(Comp, FileEnc, BaseEnc)
+                        end,
+                case Trans of
                     {incomplete, Good, Bad} ->
                         {Good, {IoDevice, Bad}};
                     {error, _, _} ->
@@ -4787,6 +4798,17 @@ external_continuation_cb(FileEnc, BaseEnc) ->
         end
     end.
 
+encode_external_input(Head, FileEnc, list, #xmerl_sax_parser_state{continuation_state = {FD, _}} = State) ->
+    {NewHead, NewCon} = 
+        case unicode:characters_to_list(Head, FileEnc) of
+            {incomplete, Good, Bad} ->
+                {Good, {FD, Bad}};
+            {error, _, _} ->
+                throw({error, "bad data"});
+            Good ->
+                {Good, {FD, <<>>}}
+        end,
+    {NewHead, State#xmerl_sax_parser_state{continuation_state = NewCon}};
 encode_external_input(Head, FileEnc, BaseEnc, #xmerl_sax_parser_state{continuation_state = {FD, _}} = State) ->
     {NewHead, NewCon} = 
         case unicode:characters_to_binary(Head, FileEnc, BaseEnc) of
@@ -4884,35 +4906,14 @@ add_context_back({ET, CF}, State) ->
 %%         State = #xmerl_sax_parser_state{}
 %% Output:  {utf8|utf16le|utf16be, Xml, State}
 %% Description: Detects which character set is used in a binary stream.
+%%              Uses eecf/3 as only binary input 
+%%              is expected from external files.
 %%----------------------------------------------------------------------
 detect_charset(State) ->
-    case catch cf(<<>>, State, fun detect_charset/2) of
-        {fatal_error, {State1, "No more bytes"}} ->
-            {<<>>, State1};
-        Other ->
-            Other
-    end.
+    eecf(<<>>, State, fun detect_charset/2).
 
 detect_charset(<<>>, State) ->
-    {<<>>, State};
-detect_charset(<<16#00>> = Bytes, State) ->
-    cf(Bytes, State, fun detect_charset/2);
-detect_charset(<<16#00, 16#00>> = Bytes, State) ->
-    cf(Bytes, State, fun detect_charset/2);
-detect_charset(<<16#00, 16#00, 16#FE>> = Bytes, State) ->
-    cf(Bytes, State, fun detect_charset/2);
-detect_charset(<<16#EF>> = Bytes, State) ->
-    cf(Bytes, State, fun detect_charset/2);
-detect_charset(<<16#EF, 16#BB>> = Bytes, State) ->
-    cf(Bytes, State, fun detect_charset/2);
-detect_charset(<<16#FE>> = Bytes, State) ->
-    cf(Bytes, State, fun detect_charset/2);
-detect_charset(<<16#FF>> = Bytes, State) ->
-    cf(Bytes, State, fun detect_charset/2);
-detect_charset(<<16#FF, 16#FE>> = Bytes, State) ->
-    cf(Bytes, State, fun detect_charset/2);
-detect_charset(<<16#FF, 16#FE, 16#00>> = Bytes, State) ->
-    cf(Bytes, State, fun detect_charset/2);
+    {<<>>, State#xmerl_sax_parser_state{encoding = utf8}};
 detect_charset(<<16#00, 16#3C, 16#00, 16#3F, _/binary>> = Xml, State) ->
     {Xml, State#xmerl_sax_parser_state{encoding={utf16, big}}};
 detect_charset(<<16#3C, 16#00, 16#3F, 16#00, _/binary>> = Xml, State) ->
@@ -4926,3 +4927,24 @@ detect_charset(Bytes, State) ->
             {RealBytes, State#xmerl_sax_parser_state{encoding=Enc}}
     end.
 
+%%----------------------------------------------------------------------
+%% Function  : eecf(Bytes, State, NextCall) -> Result
+%% Parameters: Bytes = binary()
+%%             State = #xmerl_sax_parser_state{}
+%%             NextCall = fun()
+%% Result    : {Bytes, State}
+%% Description: Function used on external binary files regardless of encoding.
+%%              Used to get the first block of binary from a file.
+%%----------------------------------------------------------------------
+eecf(Rest, #xmerl_sax_parser_state{continuation_fun = CFun, 
+                                   continuation_state = CState} = State, NextCall) ->
+    try
+        {NewBytes, NewContState} = CFun(CState),
+        NextCall(<<Rest/binary, NewBytes/binary>>,
+                 State#xmerl_sax_parser_state{continuation_state = NewContState})
+    catch
+        throw:ErrorTerm ->
+            ?fatal_error(State, ErrorTerm);
+        exit:Reason ->
+            ?fatal_error(State, {'EXIT', Reason})
+    end.
-- 
2.16.4

Places

File 3324-fixup-ensure-that-the-list-parser-also-functions.patch of Package erlang (Revision ac78bcc5a6f7a4d1efd770008567e9f7)

Places