-module(ys_parse).

-export([
    parse_doctypedecl/2,
    parse_content/2,
    parse_Misc/2,
    parse_element/2,
    parse_XMLDecl/2
]).

% -define(LINE_NUMBERS, true).
% -ifdef(LINE_NUMBERS).
% -define(bl(State), bump_line(State)).
% bump_line(#{line := L} = State) -> State#{line := L + 1}.
% -else.
% -define(bl(State), State).
% -endif.

-include("yaccety_sax.hrl").

-define(APPEND(Thing, Acc), append(Thing, Acc)).
-define(ACC(Stream, Pos, Len, Acc), ?APPEND(binary_part(Stream, Pos, Len), Acc)).

-define(MATCH, Bytes, Stream, Pos, State).
-define(MATCH1, Bytes1, Stream1, Pos1, State1).
-define(MATCH2, Bytes2, Stream2, Pos2, State2).
-define(MATCH3, Bytes3, Stream3, Pos3, State3).
-define(MATCH4, Bytes4, Stream4, Pos4, State4).
-define(MATCH5, Bytes5, Stream5, Pos5, State5).
-define(MATCH6, Bytes6, Stream6, Pos6, State6).
-define(MATCH7, Bytes7, Stream7, Pos7, State7).

%-define(dbg(_), ok).
%-define(dbg(Thing), io:format("~p~n", [{?LINE, Thing}])).

-define(XML_NS, <<"http://www.w3.org/XML/1998/namespace">>).
-define(XMLNS_NS, <<"http://www.w3.org/2000/xmlns/">>).

-define(WS(Char), (Char == 16#20 orelse Char == 16#9 orelse Char == 16#A orelse Char == 16#D)).

-compile({inline, [append/2, set_state_pos/2, to_binary/1, fatal_error/2]}).

append(<<>>, Acc) -> Acc;
append(Thing, []) -> Thing;
append(Thing, Acc) -> [Acc, Thing].

cf(#ys_state{continuation = undefined} = State) ->
    {no_bytes, State};
cf(#ys_state{continuation = {CF, replacement}, tags = Tags}) ->
    {Bytes, State} = CF(replacement),
    {Bytes, State#ys_state{tags = Tags}};
cf(#ys_state{continuation = {CF, CS}} = State) ->
    case CF(CS) of
        {Bin, CS1} when is_binary(Bin) ->
            {Bin, State#ys_state{continuation = {CF, CS1}}};
        eof ->
            _ = CF(close),
            {<<>>, State#ys_state{continuation = undefined}};
        {error, Err} ->
            {error, {Err, State}}
    end.

cf(_, #ys_state{continuation = undefined} = State, _) ->
    {no_bytes, State};
cf(Part, #ys_state{continuation = {CF, CS}} = State, {partial, BytesNeeded}) ->
    case CF(CS) of
        {Bin, CS1} when is_binary(Bin), byte_size(Bin) >= BytesNeeded ->
            RestBytes = binary_part(Bin, 0, BytesNeeded),
            <<CP/utf8>> = <<Part/bitstring, RestBytes/bitstring>>,
            {<<CP/utf8>>, Bin, BytesNeeded, State#ys_state{
                continuation = {CF, CS1}
            }};
        {Bin, CS1} when is_binary(Bin), byte_size(Bin) >= 0 ->
            cf(
                <<Part/bitstring, Bin/bitstring>>,
                State#ys_state{continuation = {CF, CS1}},
                {partial, BytesNeeded - byte_size(Bin)}
            );
        eof ->
            _ = CF(close),
            {<<>>, <<>>, 0, State#ys_state{continuation = undefined}};
        {error, Err} ->
            {error, {Err, State}}
    end.

-define(CHARPARTFUN(D),
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Char, Stream1, Pos1, State1} = cf(Bytes, State, {partial, D}),
    case Char of
        <<16#FFFE/utf8>> ->
            fatal_error({invalid_character, [Char]}, State1);
        <<16#FFFF/utf8>> ->
            fatal_error({invalid_character, [Char]}, State1);
        _ ->
            Acc2 = ?APPEND(Char, Acc1),
            <<_:Pos1/binary, Rest/bitstring>> = Stream1,
            ?FUNCTION_NAME(Rest, Stream1, Pos1, 0, State1, Acc2)
    end
).

-define(CHARPARTFUNX(D),
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Char, Stream1, Pos1, State1} = cf(Bytes, State, {partial, D}),
    case Char of
        <<16#FFFE/utf8>> ->
            fatal_error({invalid_character, [Char]}, State1);
        <<16#FFFF/utf8>> ->
            fatal_error({invalid_character, [Char]}, State1);
        <<_/utf8>> ->
            Acc2 = ?APPEND(Char, Acc1),
            <<_:Pos1/binary, Rest/bitstring>> = Stream1,
            ?FUNCTION_NAME(Rest, Stream1, Pos1, 0, State1, Acc2, DTD, External)
    end
).

-define(CHARPARTFUND(D),
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Char, Stream1, Pos1, State1} = cf(Bytes, State, {partial, D}),
    case Char of
        <<16#FFFE/utf8>> ->
            fatal_error({invalid_character, [Char]}, State1);
        <<16#FFFF/utf8>> ->
            fatal_error({invalid_character, [Char]}, State1);
        _ ->
            Acc2 = ?APPEND(Char, Acc1),
            <<_:Pos1/binary, Rest/bitstring>> = Stream1,
            ?FUNCTION_NAME(Rest, Stream1, Pos1, 0, State1, Acc2, DTD)
    end
).

-define(NAMECHARPARTFUN(D),
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {CodeChar, Stream1, Pos1, State1} = cf(Bytes, State, {partial, D}),
    case CodeChar of
        <<Char/utf8>> when
            Char == 16#B7;
            Char >= 16#C0, Char =< 16#D6;
            Char >= 16#D8, Char =< 16#F6;
            Char >= 16#F8, Char =< 16#37D;
            Char >= 16#37F, Char =< 16#7FF;
            Char >= 16#800, Char =< 16#1FFF;
            Char >= 16#200C, Char =< 16#200D;
            Char >= 16#203F, Char =< 16#2040;
            Char >= 16#2070, Char =< 16#218F;
            Char >= 16#2C00, Char =< 16#2FEF;
            Char >= 16#3001, Char =< 16#D7FF;
            Char >= 16#F900, Char =< 16#FDCF;
            Char >= 16#FDF0, Char =< 16#FFFD;
            Char >= 16#10000, Char =< 16#EFFFF
        ->
            Acc2 = ?APPEND(CodeChar, Acc1),
            <<_:Pos1/binary, Rest/bitstring>> = Stream1,
            ?FUNCTION_NAME(Rest, Stream1, Pos1, 0, State1, Acc2);
        _ ->
            fatal_error({invalid_character, [CodeChar]}, State1)
    end
).

-define(FSTNAMECHARPARTFUN(D, Next),
    {CodeChar, Stream1, Pos1, State1} = cf(Bytes, State, {partial, D}),
    case CodeChar of
        <<Char/utf8>> when
            Char >= 16#C0, Char =< 16#D6;
            Char >= 16#D8, Char =< 16#F6;
            Char >= 16#F8, Char =< 16#2FF;
            Char >= 16#370, Char =< 16#37D;
            Char >= 16#37F, Char =< 16#7FF;
            Char >= 16#800, Char =< 16#1FFF;
            Char >= 16#200C, Char =< 16#200D;
            Char >= 16#2070, Char =< 16#218F;
            Char >= 16#2C00, Char =< 16#2FEF;
            Char >= 16#3001, Char =< 16#D7FF;
            Char >= 16#F900, Char =< 16#FDCF;
            Char >= 16#FDF0, Char =< 16#FFFD;
            Char >= 16#10000, Char =< 16#EFFFF
        ->
            <<_:Pos1/binary, Rest/bitstring>> = Stream1,
            Next(Rest, Stream1, Pos1, 0, State1, CodeChar);
        _ ->
            fatal_error({invalid_character, [CodeChar]}, State1)
    end
).

-define(GET_PE(Func),
    Func(<<"%", Bytes/bitstring>>, Stream, Pos, State, DTD, true) ->
        {PERef, Bytes1, _, _, State1} = parse_PEReference(Bytes, Stream, Pos + 1, State),
        case resolve_parameter_entity(PERef, DTD, State1, true, true) of
            % Stripping whitespace added in replacement
            {replacement_text, <<" ", ReplacementText/bitstring>>} ->
                RTState = replacement_text_state(Bytes1, State1),
                {_, ?MATCH2} = maybe_consume_s(ReplacementText, ReplacementText, 0, RTState),
                Func(?MATCH2, DTD, true)
        end
).

-define(GET_PE_ACC(Func),
    Func(<<"%", Bytes/bitstring>>, Stream, Pos, State, Acc, DTD, true) ->
        {PERef, Bytes1, _, _, State1} = parse_PEReference(Bytes, Stream, Pos + 1, State),
        case resolve_parameter_entity(PERef, DTD, State1, true, true) of
            % Stripping whitespace added in replacement
            {replacement_text, <<" ", ReplacementText/bitstring>>} ->
                RTState = replacement_text_state(Bytes1, State1),
                {_, ?MATCH2} = maybe_consume_s(ReplacementText, ReplacementText, 0, RTState),
                Func(?MATCH2, Acc, DTD, true)
        end
).
%%----------------------------------------------------------------------
%% XML character range
%% [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] |
%%              [#x10000-#x10FFFF]
%% any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.
%%----------------------------------------------------------------------
-define(ONECHAR,
?FUNCTION_NAME(<<16#9/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc);
?FUNCTION_NAME(<<16#A/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc);
?FUNCTION_NAME(<<16#FFFE/utf8, _Rest/bitstring>>, _, _, _, State, _Acc) ->
    fatal_error({invalid_character, {?LINE, [16#FFFE]}}, State);
?FUNCTION_NAME(<<16#FFFF/utf8, _Rest/bitstring>>, _, _, _, State, _Acc) ->
    fatal_error({invalid_character, {?LINE, [16#FFFF]}}, State);
?FUNCTION_NAME(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc)  ->
    if
        Char < 16#20 ->
            fatal_error({invalid_character, {?LINE, [Char]}}, State);
        Char < 16#80 ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc);
        Char < 16#800 ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 2, State, Acc);
        Char < 16#10000 ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 3, State, Acc);
        true ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 4, State, Acc)
    end;
%%
?FUNCTION_NAME(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc1);
?FUNCTION_NAME(Bytes = <<30:5, _:3>>, Stream, Pos, Len, State, Acc) -> ?CHARPARTFUN(3);
?FUNCTION_NAME(Bytes = <<30:5, _:3, 2:2, _:6>>, Stream, Pos, Len, State, Acc) -> ?CHARPARTFUN(2);
?FUNCTION_NAME(Bytes = <<14:4, _:4>>, Stream, Pos, Len, State, Acc) -> ?CHARPARTFUN(2);
?FUNCTION_NAME(Bytes = <<30:5, _:3, 2:2, _:6, 2:2, _:6>>, Stream, Pos, Len, State, Acc) -> ?CHARPARTFUN(1);
?FUNCTION_NAME(Bytes = <<14:4, _:4, 2:2, _:6>>, Stream, Pos, Len, State, Acc) -> ?CHARPARTFUN(1);
?FUNCTION_NAME(Bytes = <<6:3, _:5>>, Stream, Pos, Len, State, Acc) -> ?CHARPARTFUN(1);
?FUNCTION_NAME(Bytes, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {to_binary(Acc1), Bytes, Stream, Pos + Len, State}
).

-define(ONECHARX,
?FUNCTION_NAME(<<16#9/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, External) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc, DTD, External);
?FUNCTION_NAME(<<16#A/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, External) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc, DTD, External);
?FUNCTION_NAME(<<16#FFFE/utf8, _Rest/bitstring>>, _, _, _, State, _Acc, _DTD, _External) ->
    fatal_error({invalid_character, [16#FFFE]}, State) ;
?FUNCTION_NAME(<<16#FFFF/utf8, _Rest/bitstring>>, _, _, _, State, _Acc, _DTD, _External) ->
    fatal_error({invalid_character, [16#FFFF]}, State) ;
?FUNCTION_NAME(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, External)  ->
    if
        Char < 16#20 ->
            fatal_error({invalid_character, [Char]}, State);
        Char < 16#80 ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc, DTD, External);
        Char < 16#800 ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 2, State, Acc, DTD, External);
        Char < 16#10000 ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 3, State, Acc, DTD, External);
        true ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 4, State, Acc, DTD, External)
    end;
?FUNCTION_NAME(<<>>, Stream, Pos, Len, State, Acc, DTD, External) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc1, DTD, External);
?FUNCTION_NAME(Bytes = <<30:5, _:3>>, Stream, Pos, Len, State, Acc, DTD, External) -> ?CHARPARTFUNX(3);
?FUNCTION_NAME(Bytes = <<30:5, _:3, 2:2, _:6>>, Stream, Pos, Len, State, Acc, DTD, External) -> ?CHARPARTFUNX(2);
?FUNCTION_NAME(Bytes = <<14:4, _:4>>, Stream, Pos, Len, State, Acc, DTD, External) -> ?CHARPARTFUNX(2);
?FUNCTION_NAME(Bytes = <<30:5, _:3, 2:2, _:6, 2:2, _:6>>, Stream, Pos, Len, State, Acc, DTD, External) -> ?CHARPARTFUNX(1);
?FUNCTION_NAME(Bytes = <<14:4, _:4, 2:2, _:6>>, Stream, Pos, Len, State, Acc, DTD, External) -> ?CHARPARTFUNX(1);
?FUNCTION_NAME(Bytes = <<6:3, _:5>>, Stream, Pos, Len, State, Acc, DTD, External) -> ?CHARPARTFUNX(1);
?FUNCTION_NAME(Bytes, Stream, Pos, Len, State, Acc, DTD, External) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {to_binary(Acc1), Bytes, Stream, Pos + Len, State, DTD, External}
).

-define(ONECHARD,
?FUNCTION_NAME(<<16#9/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc, DTD);
?FUNCTION_NAME(<<16#A/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc, DTD);
?FUNCTION_NAME(<<16#FFFE/utf8, _Rest/bitstring>>, _, _, _, State, _Acc, _DTD) ->
    fatal_error({invalid_character, [16#FFFE]}, State) ;
?FUNCTION_NAME(<<16#FFFF/utf8, _Rest/bitstring>>, _, _, _, State, _Acc, _DTD) ->
    fatal_error({invalid_character, [16#FFFF]}, State) ;
?FUNCTION_NAME(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD)  ->
    if
        Char < 16#20 ->
            fatal_error({invalid_character, [Char]}, State);
        Char < 16#80 ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc, DTD);
        Char < 16#800 ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 2, State, Acc, DTD);
        Char < 16#10000 ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 3, State, Acc, DTD);
        true ->
            ?FUNCTION_NAME(Rest, Stream, Pos, Len + 4, State, Acc, DTD)
    end;
?FUNCTION_NAME(<<>>, Stream, Pos, Len, State, Acc, DTD) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc1, DTD);
?FUNCTION_NAME(Bytes = <<30:5, _:3>>, Stream, Pos, Len, State, Acc, DTD) -> ?CHARPARTFUND(3);
?FUNCTION_NAME(Bytes = <<30:5, _:3, 2:2, _:6>>, Stream, Pos, Len, State, Acc, DTD) -> ?CHARPARTFUND(2);
?FUNCTION_NAME(Bytes = <<14:4, _:4>>, Stream, Pos, Len, State, Acc, DTD) -> ?CHARPARTFUND(2);
?FUNCTION_NAME(Bytes = <<30:5, _:3, 2:2, _:6, 2:2, _:6>>, Stream, Pos, Len, State, Acc, DTD) -> ?CHARPARTFUND(1);
?FUNCTION_NAME(Bytes = <<14:4, _:4, 2:2, _:6>>, Stream, Pos, Len, State, Acc, DTD) -> ?CHARPARTFUND(1);
?FUNCTION_NAME(Bytes = <<6:3, _:5>>, Stream, Pos, Len, State, Acc, DTD) -> ?CHARPARTFUND(1);
?FUNCTION_NAME(Bytes, Stream, Pos, Len, State, Acc, DTD) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {to_binary(Acc1), Bytes, Stream, Pos + Len, State, DTD}
).

%%----------------------------------------------------------------------
%% [4a] NameChar
%%      NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
%%----------------------------------------------------------------------
-define(ONENAMECHAR,
?FUNCTION_NAME(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc)
    when
    Char == $-;
    Char == $.;
    Char >= $0, Char =< $9;
    Char == $:;
    Char >= $A, Char =< $Z;
    Char == $_;
    Char >= $a, Char =< $z

    ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc);
?FUNCTION_NAME(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc)
    when
    Char == 16#B7;
    Char >= 16#C0, Char =< 16#D6;
    Char >= 16#D8, Char =< 16#F6;
    Char >= 16#F8, Char =< 16#37D;
    Char >= 16#37F, Char =< 16#7FF
    ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 2, State, Acc);
?FUNCTION_NAME(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc)
    when
    Char >= 16#800, Char =< 16#1FFF;
    Char >= 16#200C, Char =< 16#200D;
    Char >= 16#203F, Char =< 16#2040;
    Char >= 16#2070, Char =< 16#218F;
    Char >= 16#2C00, Char =< 16#2FEF;
    Char >= 16#3001, Char =< 16#D7FF;
    Char >= 16#F900, Char =< 16#FDCF;
    Char >= 16#FDF0, Char =< 16#FFFD
    ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 3, State, Acc);
?FUNCTION_NAME(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc)
    when Char >= 16#10000, Char =< 16#EFFFF ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 4, State, Acc);
?FUNCTION_NAME(Bytes = <<30:5, _:3>>, Stream, Pos, Len, State, Acc) -> ?NAMECHARPARTFUN(3);
?FUNCTION_NAME(Bytes = <<30:5, _:3, 2:2, _:6>>, Stream, Pos, Len, State, Acc) -> ?NAMECHARPARTFUN(2);
?FUNCTION_NAME(Bytes = <<14:4, _:4>>, Stream, Pos, Len, State, Acc) -> ?NAMECHARPARTFUN(2);
?FUNCTION_NAME(Bytes = <<30:5, _:3, 2:2, _:6, 2:2, _:6>>, Stream, Pos, Len, State, Acc) -> ?NAMECHARPARTFUN(1);
?FUNCTION_NAME(Bytes = <<14:4, _:4, 2:2, _:6>>, Stream, Pos, Len, State, Acc) -> ?NAMECHARPARTFUN(1);
?FUNCTION_NAME(Bytes = <<6:3, _:5>>, Stream, Pos, Len, State, Acc) -> ?NAMECHARPARTFUN(1);
?FUNCTION_NAME(Bytes, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {to_binary(Acc1), Bytes, Stream, Pos + Len, State}
).

%%----------------------------------------------------------------------
%% [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
%%----------------------------------------------------------------------
-define(ONEPUBIDCHAR,
?FUNCTION_NAME(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc)
    when
    Char == 16#A;
    Char == 16#D;
    Char == 16#20;
    Char == 16#21;
    Char >= 16#23, Char =< 16#25;
    Char >= 16#27, Char =< 16#3B;
    Char == 16#3D;
    Char >= 16#3F, Char =< 16#5A;
    Char == 16#5F;
    Char >= 16#61, Char =< 16#7A
    ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc);
?FUNCTION_NAME(<<Char/utf8, _/bitstring>>, _, _, _, _State, _) ->
    fatal_error(invalid_pubid_character, Char)
).

%%----------------------------------------------------------------------
%% Consume whitespace characters
%% params:  State
%% returns: {NewPos, NewState} | {error, non_whitespace}
%% [3] S ::= (#x20 | #x9 | #xD | #xA)+
%%----------------------------------------------------------------------
consume_s(<<Char/utf8, Rest/bitstring>>, Stream, Pos, State) when
    Char == 16#20; Char == 16#9; Char == 16#D; Char == 16#A
->
    maybe_consume_s(Rest, Stream, Pos + 1, State, true);
consume_s(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    consume_s(Stream1, Stream1, 0, State1);
consume_s(_, _, _, State) ->
    fatal_error(missing_whitespace, State).

consume_s(<<"%", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {PERef, Bytes1, _, _, State1} = parse_PEReference(Bytes, Stream, Pos + 1, State),
    case resolve_parameter_entity(PERef, DTD, State1, true, true) of
        {replacement_text, ReplacementText} ->
            RTState = replacement_text_state(Bytes1, State1),
            consume_s(ReplacementText, ReplacementText, 0, RTState, DTD)
    end;
consume_s(?MATCH, _DTD) ->
    consume_s(?MATCH).

maybe_consume_s(?MATCH) -> maybe_consume_s(?MATCH, false).

maybe_consume_s(<<Char/utf8, Rest/bitstring>>, Stream, Pos, State, _) when
    Char == 16#20; Char == 16#9; Char == 16#D; Char == 16#A
->
    maybe_consume_s(Rest, Stream, Pos + 1, State, true);
maybe_consume_s(<<>>, Stream, Pos, State, Found) ->
    case cf(State) of
        {no_bytes, State1} -> {Found, <<>>, Stream, Pos, State1};
        {Stream1, State1} -> maybe_consume_s(Stream1, Stream1, 0, State1, Found)
    end;
maybe_consume_s(Part, Stream, Pos, State, Found) ->
    {Found, Part, Stream, Pos, State}.

maybe_consume_dtd_s(?MATCH, DTD) -> maybe_consume_dtd_s(?MATCH, DTD, false).

maybe_consume_dtd_s(<<Char/utf8, Rest/bitstring>>, Stream, Pos, State, DTD, _) when
    Char == 16#20; Char == 16#9; Char == 16#D; Char == 16#A
->
    maybe_consume_dtd_s(Rest, Stream, Pos + 1, State, DTD, true);
maybe_consume_dtd_s(<<"%", Bytes/bitstring>>, Stream, Pos, State, DTD, Found) ->
    {PERef, Bytes1, _, _, State1} = parse_PEReference(Bytes, Stream, Pos + 1, State),
    case resolve_parameter_entity(PERef, DTD, State1, true, true) of
        {replacement_text, ReplacementText} ->
            RTState = replacement_text_state(Bytes1, State1),
            maybe_consume_dtd_s(ReplacementText, ReplacementText, 0, RTState, DTD, Found)
    end;
maybe_consume_dtd_s(<<>>, Stream, Pos, State, DTD, Found) ->
    case cf(State) of
        {no_bytes, State1} -> {Found, <<>>, Stream, Pos, State1};
        {Stream1, State1} -> maybe_consume_dtd_s(Stream1, Stream1, 0, State1, DTD, Found)
    end;
maybe_consume_dtd_s(Part, Stream, Pos, State, _DTD, Found) ->
    {Found, Part, Stream, Pos, State}.

%%----------------------------------------------------------------------
%% Parse Name (does not split prefix and local parts like NCName)
%% params:  State
%% returns: {Name, NewState}
%% [4] NameStartChar
%%     ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D]
%%     | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF]
%%     | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
%% [5] Name ::= NameStartChar (NameChar)*
%%----------------------------------------------------------------------

parse_Name(<<Char/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    if
        Char == $:; Char >= $A, Char =< $Z; Char == $_; Char >= $a, Char =< $z ->
            parse_Name(Rest, Stream, Pos, 1, State, []);
        Char >= 16#C0, Char =< 16#D6;
        Char >= 16#D8, Char =< 16#F6;
        Char >= 16#F8, Char =< 16#2FF;
        Char >= 16#370, Char =< 16#37D;
        Char >= 16#37F, Char =< 16#7FF ->
            parse_Name(Rest, Stream, Pos, 2, State, []);
        Char >= 16#800, Char =< 16#1FFF;
        Char >= 16#200C, Char =< 16#200D;
        Char >= 16#2070, Char =< 16#218F;
        Char >= 16#2C00, Char =< 16#2FEF;
        Char >= 16#3001, Char =< 16#D7FF;
        Char >= 16#F900, Char =< 16#FDCF;
        Char >= 16#FDF0, Char =< 16#FFFD ->
            parse_Name(Rest, Stream, Pos, 3, State, []);
        Char >= 16#10000, Char =< 16#EFFFF ->
            parse_Name(Rest, Stream, Pos, 4, State, []);
        true ->
            fatal_error(bad_name, {[Char], State})
    end;
parse_Name(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_Name(Stream1, Stream1, 0, State1);
parse_Name(Bytes = <<30:5, _:3>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(3, parse_Name);
parse_Name(Bytes = <<30:5, _:3, 2:2, _:6>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(2, parse_Name);
parse_Name(Bytes = <<14:4, _:4>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(2, parse_Name);
parse_Name(Bytes = <<30:5, _:3, 2:2, _:6, 2:2, _:6>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(1, parse_Name);
parse_Name(Bytes = <<14:4, _:4, 2:2, _:6>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(1, parse_Name);
parse_Name(Bytes = <<6:3, _:5>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(1, parse_Name);
parse_Name(Bytes, _, _, State) ->
    fatal_error(bad_name, {Bytes, State}).

parse_Name(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_Name(Stream1, Stream1, 0, 0, State1, Acc1);
?ONENAMECHAR.

%%----------------------------------------------------------------------
%% [67] Reference ::= EntityRef | CharRef
%% & char is removed
%% [66] CharRef ::= '&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';'
%% [WFC: Legal Character]
%% [68] EntityRef ::= '&' Name ';'
%% [WFC: Entity Declared]
%% [WFC: Parsed Entity]
%% [WFC: No Recursion]
%% can be EntityRef | CharRef
%%----------------------------------------------------------------------
parse_Reference(<<>>, _, _, #ys_state{in_replacement = true} = State, _Type) ->
    fatal_error(unbalanced_reference, State);
parse_Reference(<<>>, _, _, State, Type) ->
    {Stream1, State1} = cf(State),
    parse_Reference(Stream1, Stream1, 0, State1, Type);
parse_Reference(<<$#>>, _, _, State, Type) ->
    {Stream1, State1} = cf(State),
    parse_Reference_lb(Stream1, Stream1, State1, Type);
parse_Reference(<<$#, $x, Rest/bitstring>>, Stream, Pos, State, _Type) ->
    parse_Reference_hex(Rest, Stream, Pos + 2, 0, State, []);
parse_Reference(<<$#, Rest/bitstring>>, Stream, Pos, State, _Type) ->
    parse_Reference_dec(Rest, Stream, Pos + 1, 0, State, []);
parse_Reference(?MATCH, Type) ->
    parse_Reference_name(?MATCH, Type).

parse_Reference_lb(<<>>, _, #ys_state{in_replacement = true} = State, _Type) ->
    fatal_error(unbalanced_reference, State);
parse_Reference_lb(<<>>, _, State, Type) ->
    {Stream1, State1} = cf(State),
    parse_Reference_lb(Stream1, Stream1, State1, Type);
parse_Reference_lb(<<$x, Rest/bitstring>>, Stream, State, _Type) ->
    parse_Reference_hex(Rest, Stream, 1, 0, State, []);
parse_Reference_lb(Bytes, Stream, State, _Type) ->
    parse_Reference_dec(Bytes, Stream, 0, 0, State, []).

% hex parse until ';' return char
parse_Reference_hex(<<>>, _, _, _, #ys_state{in_replacement = true} = State, _) ->
    fatal_error(unbalanced_reference, State);
parse_Reference_hex(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_Reference_hex(Stream1, Stream1, 0, 0, State1, Acc1);
parse_Reference_hex(<<$;, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    try
        case binary_to_integer(to_binary(Acc1), 16) of
            Int when
                Int == 16#9;
                Int == 16#A;
                Int == 16#D;
                Int >= 16#20, Int =< 16#D7FF;
                Int >= 16#E000, Int =< 16#FFFD;
                Int >= 16#10000, Int =< 16#10FFFF
            ->
                {{hex, <<Int/utf8>>}, Rest, Stream, Pos + Len + 1, State}
        end
    catch
        _:_ ->
            fatal_error(bad_charref, State)
    end;
parse_Reference_hex(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when
    Char >= $0, Char =< $9; Char >= $a, Char =< $f; Char >= $A, Char =< $F
->
    parse_Reference_hex(Rest, Stream, Pos, Len + 1, State, Acc);
parse_Reference_hex(_, _, _, _, State, _) ->
    fatal_error(bad_charref, State).

% decimal parse until ';' return char
parse_Reference_dec(<<>>, _, _, _, #ys_state{in_replacement = true} = State, _) ->
    fatal_error(unbalanced_reference, State);
parse_Reference_dec(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_Reference_dec(Stream1, Stream1, 0, 0, State1, Acc1);
parse_Reference_dec(<<$;/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    try
        case binary_to_integer(to_binary(Acc1)) of
            Int when
                Int == 16#9;
                Int == 16#A;
                Int == 16#D;
                Int >= 16#20, Int =< 16#D7FF;
                Int >= 16#E000, Int =< 16#FFFD;
                Int >= 16#10000, Int =< 16#10FFFF
            ->
                {{dec, <<Int/utf8>>}, Rest, Stream, Pos + Len + 1, State}
        end
    catch
        _:_ ->
            fatal_error(bad_charref, {Acc1, State})
    end;
parse_Reference_dec(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when
    Char >= $0, Char =< $9
->
    parse_Reference_dec(Rest, Stream, Pos, Len + 1, State, Acc);
parse_Reference_dec(_, _, _, _, State, _) ->
    fatal_error(bad_charref, State).

% Name parse until ';' return Name
parse_Reference_name(?MATCH, Type) ->
    case parse_Name(?MATCH) of
        {Name, <<$;/utf8, Bytes1/bitstring>>, Stream1, Pos1, State1} ->
            NameValue = resolve_general_entity(Name, State1, Type),
            {NameValue, Bytes1, Stream1, Pos1 + 1, State1};
        {_, _, _, _, State1} ->
            fatal_error(bad_charref, State1)
    end.

%%----------------------------------------------------------------------
%% Parse a Comment, leading '<!--' already removed
%% params:  State
%% returns: {Comment, NewState} | NewState (when ignoring)
%% [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
%%----------------------------------------------------------------------
parse_Comment(?MATCH) ->
    {Text, ?MATCH1} = parse_Comment(Bytes, Stream, Pos, 0, State, []),
    case State#ys_state.comments of
        _ when hd(State#ys_state.position) == dtd -> {{comment, Text}, ?MATCH1};
        false -> State1;
        true -> yaccety_sax:event_comment(Text, set_state_pos(State1, Bytes1))
    end.

consume_Comment(?MATCH) ->
    {_, ?MATCH1} = parse_Comment(Bytes, Stream, Pos, 0, State, []),
    {?MATCH1}.

parse_Comment(<<$\r, $\n, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
?FUNCTION_NAME(<<$\r>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    case cf(State) of
        {<<$\n, Bytes1/bitstring>> = Stream1, State1} ->
            ?FUNCTION_NAME(Bytes1, Stream1, 1, 0, State1, Acc2);
        {Stream1, State1} ->
            ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc2)
    end;
parse_Comment(<<$\r, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
parse_Comment(<<>>, _, _, _, #ys_state{in_replacement = true} = State, _) ->
    fatal_error(unbalanced_reference, State);
parse_Comment(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_Comment(Stream1, Stream1, 0, 0, State1, Acc1);
parse_Comment(<<$-/utf8, $-/utf8, $>/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Acc1, Rest, Stream, Pos + Len + 3, State};
parse_Comment(<<$-/utf8, $-/utf8>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_Comment_dashdash(Stream1, Stream1, State1, Acc1);
parse_Comment(<<$-/utf8, $-/utf8, _/bitstring>>, _, _, _, State, _Acc) ->
    fatal_error(bad_comment, State);
parse_Comment(<<$-/utf8>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_Comment_dash(Stream1, Stream1, State1, Acc1);
?ONECHAR.

parse_Comment_dashdash(<<$>/utf8, Rest/bitstring>>, Stream, State, Acc) ->
    {Acc, Rest, Stream, 1, State};
parse_Comment_dashdash(_, _, State, _) ->
    fatal_error(bad_comment, State).

parse_Comment_dash(<<$-/utf8, $>/utf8, Rest/bitstring>>, Stream, State, Acc) ->
    {Acc, Rest, Stream, 2, State};
parse_Comment_dash(<<$-/utf8>>, _, State, Acc) ->
    {Stream1, State1} = cf(State),
    parse_Comment_dashdash(Stream1, Stream1, State1, Acc);
parse_Comment_dash(<<$-/utf8, _/bitstring>>, _, State, _Acc) ->
    fatal_error(bad_comment, State);
parse_Comment_dash(Bytes, Stream, State, Acc) ->
    Acc1 = ?APPEND(<<$-/utf8>>, Acc),
    parse_Comment(Bytes, Stream, 0, 0, State, Acc1).

%%----------------------------------------------------------------------
%% Parse a processing-instruction, leading '<?' already removed
%% params:  State
%% returns: {PI, NewState} | NewState (when ignoring)
%% [16] PI       ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
%% [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
%%----------------------------------------------------------------------

check_pi_name(<<X, M, L>>, State) when
    X == $x orelse X == $X, M == $m orelse M == $M, L == $l orelse L == $L
->
    fatal_error(bad_pi, State);
check_pi_name(_, _) ->
    ok.

parse_PI(?MATCH) ->
    {Name, ?MATCH1} = parse_NCName(?MATCH),
    ok = check_pi_name(Name, State1),
    {IsWs, ?MATCH2} = maybe_consume_s(?MATCH1),
    {Data, ?MATCH3} = parse_PI_data(Bytes2, Stream2, Pos2, 0, State2, []),
    case IsWs of
        false when Data =/= <<>> -> fatal_error(bad_pi, State);
        _ when State#ys_state.proc_inst == false -> State3;
        _ when hd(State#ys_state.position) == dtd -> {{pi, Name, Data}, ?MATCH3};
        _ -> yaccety_sax:event_processingInstruction(Name, Data, set_state_pos(State3, Bytes3))
    end.

parse_PI_data(<<$\r, $\n, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
?FUNCTION_NAME(<<$\r>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    case cf(State) of
        {<<$\n, Bytes1/bitstring>> = Stream1, State1} ->
            ?FUNCTION_NAME(Bytes1, Stream1, 1, 0, State1, Acc2);
        {Stream1, State1} ->
            ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc2)
    end;
parse_PI_data(<<$\r, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
parse_PI_data(<<>>, _Stream, _Pos, _Len, #ys_state{in_replacement = true} = State, _Acc) ->
    fatal_error(unbalanced_reference, State);
parse_PI_data(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_PI_data(Stream1, Stream1, 0, 0, State1, Acc1);
parse_PI_data(<<$?, $>, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {to_binary(Acc1), Rest, Stream, Pos + 2 + Len, State};
parse_PI_data(<<$?>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_PI_data_qm(Stream1, Stream1, State1, Acc1);
?ONECHAR.

parse_PI_data_qm(<<$>/utf8, Rest/bitstring>>, Stream, State, Acc) ->
    {to_binary(Acc), Rest, Stream, 1, State};
parse_PI_data_qm(Bytes, Stream, State, Acc) ->
    Acc1 = ?APPEND(<<$?>>, Acc),
    parse_PI_data(Bytes, Stream, 0, 0, State, Acc1).

%%----------------------------------------------------------------------
%% Parse character data. In content, everything that is not
%%   (element | Reference | CDSect | PI | Comment)
%% params:  State
%% returns: {CharData, IsWs, NewState}
%% [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
%%----------------------------------------------------------------------
parse_CharData(?MATCH) ->
    {{IsWs, Text}, Bytes1, _, _, State1} = parse_CharData_ws(Bytes, Stream, Pos, 0, State, []),
    IsIgnorable = false,
    IsCData = false,
    case State#ys_state.whitespace of
        false when IsWs == true ->
            set_state_pos(State1, Bytes1);
        _ ->
            yaccety_sax:event_characters(
                to_binary(Text),
                IsCData,
                IsIgnorable,
                IsWs,
                set_state_pos(State1, Bytes1)
            )
    end.

parse_CharData(?MATCH, Acc) ->
    {{IsWs, Text}, Bytes1, _, _, State1} = parse_CharData(Bytes, Stream, Pos, 0, State, Acc),
    IsIgnorable = false,
    IsCData = false,
    yaccety_sax:event_characters(
        to_binary(Text), IsCData, IsIgnorable, IsWs, set_state_pos(State1, Bytes1)
    ).

parse_CharData(
    <<$\r, $\n, Rest/bitstring>>,
    Stream,
    Pos,
    Len,
    #ys_state{in_replacement = false} = State,
    Acc
) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    parse_CharData(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
?FUNCTION_NAME(<<$\r>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    case cf(State) of
        {<<$\n, Bytes1/bitstring>> = Stream1, State1} ->
            ?FUNCTION_NAME(Bytes1, Stream1, 1, 0, State1, Acc2);
        {Stream1, State1} ->
            ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc2)
    end;
parse_CharData(
    <<$\r, Rest/bitstring>>,
    Stream,
    Pos,
    Len,
    #ys_state{in_replacement = false} = State,
    Acc
) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    parse_CharData(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
parse_CharData(<<$\r, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    parse_CharData(Rest, Stream, Pos, Len + 1, State, Acc);
parse_CharData(Bytes = <<$</utf8, _/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Text = ?ACC(Stream, Pos, Len, Acc),
    {{false, Text}, Bytes, Stream, Pos + Len, State};
parse_CharData(<<$&/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    case parse_Reference(Rest, Stream, Pos + Len + 1, State, text) of
        {{Name, {replacement_text, Ref}}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, 0, RTState, Acc1);
        {{Type, Ref}, ?MATCH1} when Type == gen; Type == dec; Type == hex ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
        {{Name, Ref}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, 0, RTState, Acc1)
    end;
parse_CharData(<<"]]>"/utf8, _/bitstring>>, _, _, _, State, _Acc) ->
    fatal_error(bad_char_data, State);
parse_CharData(<<"]]"/utf8>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    parse_CharData_bb(cf(State), Acc1);
parse_CharData(<<"]"/utf8>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    parse_CharData_b(cf(State), Acc1);
?ONECHAR.

parse_CharData_bb({<<$>, _/bitstring>>, State}, _Acc) ->
    fatal_error(bad_char_data, State);
parse_CharData_bb({<<"]>", _/bitstring>>, State}, _Acc) ->
    fatal_error(bad_char_data, State);
parse_CharData_bb({<<"]">>, State}, Acc) ->
    Acc1 = ?APPEND(<<"]">>, Acc),
    parse_CharData_bb(cf(State), Acc1);
parse_CharData_bb({Bytes, State}, Acc) ->
    Acc1 = ?APPEND(<<"]]">>, Acc),
    parse_CharData(Bytes, Bytes, 0, 0, State, Acc1).

parse_CharData_b({<<"]>", _/bitstring>>, State}, _Acc) ->
    fatal_error(bad_char_data, State);
parse_CharData_b({<<"]">>, State}, Acc) ->
    parse_CharData_bb(cf(State), Acc);
parse_CharData_b({Bytes, State}, Acc) ->
    Acc1 = ?APPEND(<<"]">>, Acc),
    parse_CharData(Bytes, Bytes, 0, 0, State, Acc1).

parse_CharData_ws(<<$\s, $\s, $\s, $\s, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    parse_CharData_ws(Rest, Stream, Pos, Len + 4, State, Acc);
parse_CharData_ws(<<$\t, $\t, $\t, $\t, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    parse_CharData_ws(Rest, Stream, Pos, Len + 4, State, Acc);
parse_CharData_ws(<<$\s, $\s, $\s, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    parse_CharData_ws(Rest, Stream, Pos, Len + 3, State, Acc);
parse_CharData_ws(<<$\t, $\t, $\t, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    parse_CharData_ws(Rest, Stream, Pos, Len + 3, State, Acc);
parse_CharData_ws(<<$\s, $\s, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    parse_CharData_ws(Rest, Stream, Pos, Len + 2, State, Acc);
parse_CharData_ws(<<$\t, $\t, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    parse_CharData_ws(Rest, Stream, Pos, Len + 2, State, Acc);
parse_CharData_ws(
    <<$\r, $\n, Rest/bitstring>>,
    Stream,
    Pos,
    Len,
    #ys_state{in_replacement = false} = State,
    Acc
) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    parse_CharData_ws(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
?FUNCTION_NAME(<<$\r>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    case cf(State) of
        {<<$\n, Bytes1/bitstring>> = Stream1, State1} ->
            ?FUNCTION_NAME(Bytes1, Stream1, 1, 0, State1, Acc2);
        {Stream1, State1} ->
            ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc2)
    end;
parse_CharData_ws(
    <<$\r, Rest/bitstring>>,
    Stream,
    Pos,
    Len,
    #ys_state{in_replacement = false} = State,
    Acc
) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    parse_CharData_ws(Rest, Stream, Pos + 1, 0, State, Acc2);
parse_CharData_ws(<<$\r, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    parse_CharData_ws(Rest, Stream, Pos, Len + 1, State, Acc);
parse_CharData_ws(<<Char, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when ?WS(Char) ->
    parse_CharData_ws(Rest, Stream, Pos, Len + 1, State, Acc);
parse_CharData_ws(Bytes = <<$<, _/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Text = ?ACC(Stream, Pos, Len, Acc),
    {{true, Text}, Bytes, Stream, Pos + Len, State};
parse_CharData_ws(<<$&, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    case parse_Reference(Rest, Stream, Pos + Len + 1, State, text) of
        {{Name, {replacement_text, Ref}}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, 0, RTState, Acc1);
        {{Type, <<Char>> = Ref}, ?MATCH1} when Type == dec orelse Type == hex, ?WS(Char) ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
        {{Type, Ref}, ?MATCH1} when Type == dec orelse Type == hex ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
        {{gen, Ref}, ?MATCH1} ->
            Acc2 = ?APPEND(Ref, Acc1),
            parse_CharData(Bytes1, Stream1, Pos1, 0, State1, Acc2);
        {{Name, Ref}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, 0, RTState, Acc1)
    end;
parse_CharData_ws(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_CharData_ws(Stream1, Stream1, 0, 0, State1, Acc1);
parse_CharData_ws(Bytes, Stream, Pos, Len, State, Acc) ->
    parse_CharData(Bytes, Stream, Pos, Len, State, Acc).

%%----------------------------------------------------------------------
%% [18] CDSect  ::= CDStart CData CDEnd
%% [19] CDStart ::= '<![CDATA['
%% [20] CData   ::= (Char* - (Char* ']]>' Char*))
%% [21] CDEnd   ::= ']]>'
%% Parse CDATA Section. '<![' is already matched.
%% params:  State
%% returns: {CharData, IsWs, NewState}
%%----------------------------------------------------------------------
parse_CDSect(<<"CDATA["/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_CData(Rest, Stream, Pos + 6, State);
parse_CDSect(<<"CDATA"/utf8>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcdata(Stream1, State1);
parse_CDSect(<<"CDAT"/utf8>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcdat(Stream1, State1);
parse_CDSect(<<"CDA"/utf8>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcda(Stream1, State1);
parse_CDSect(<<"CD"/utf8>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcd(Stream1, State1);
parse_CDSect(<<"C"/utf8>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bc(Stream1, State1);
parse_CDSect(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect(Stream1, Stream1, 0, State1);
parse_CDSect(_, _, _, State) ->
    fatal_error(bad_cdata, State).

parse_CDSect_bc(<<"DATA["/utf8, Rest/bitstring>> = Stream, State) ->
    parse_CData(Rest, Stream, 5, State);
parse_CDSect_bc(<<"DATA"/utf8>>, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcdata(Stream1, State1);
parse_CDSect_bc(<<"DAT"/utf8>>, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcdat(Stream1, State1);
parse_CDSect_bc(<<"DA"/utf8>>, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcda(Stream1, State1);
parse_CDSect_bc(<<"D"/utf8>>, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcd(Stream1, State1);
parse_CDSect_bc(_, State) ->
    fatal_error(bad_cdata, State).

parse_CDSect_bcd(<<"ATA["/utf8, Rest/bitstring>> = Stream, State) ->
    parse_CData(Rest, Stream, 4, State);
parse_CDSect_bcd(<<"ATA"/utf8>>, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcdata(Stream1, State1);
parse_CDSect_bcd(<<"AT"/utf8>>, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcdat(Stream1, State1);
parse_CDSect_bcd(<<"A"/utf8>>, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcda(Stream1, State1);
parse_CDSect_bcd(_, State) ->
    fatal_error(bad_cdata, State).

parse_CDSect_bcda(<<"TA["/utf8, Rest/bitstring>> = Stream, State) ->
    parse_CData(Rest, Stream, 3, State);
parse_CDSect_bcda(<<"TA"/utf8>>, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcdata(Stream1, State1);
parse_CDSect_bcda(<<"T"/utf8>>, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcdat(Stream1, State1);
parse_CDSect_bcda(_, State) ->
    fatal_error(bad_cdata, State).

parse_CDSect_bcdat(<<"A["/utf8, Rest/bitstring>> = Stream, State) ->
    parse_CData(Rest, Stream, 2, State);
parse_CDSect_bcdat(<<"A"/utf8>>, State) ->
    {Stream1, State1} = cf(State),
    parse_CDSect_bcdata(Stream1, State1);
parse_CDSect_bcdat(_, State) ->
    fatal_error(bad_cdata, State).

parse_CDSect_bcdata(<<"["/utf8, Rest/bitstring>> = Stream, State) ->
    parse_CData(Rest, Stream, 1, State);
parse_CDSect_bcdata(_, State) ->
    fatal_error(bad_cdata, State).

parse_CData(Rest, Stream, Pos, State) ->
    {Text, Bytes1, _, _, State1} = parse_CData(Rest, Stream, Pos, 0, State, []),
    yaccety_sax:event_characters(
        to_binary(Text), true, false, false, set_state_pos(State1, Bytes1)
    ).

parse_CData(<<$\r, $\n, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
?FUNCTION_NAME(<<$\r>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    case cf(State) of
        {<<$\n, Bytes1/bitstring>> = Stream1, State1} ->
            ?FUNCTION_NAME(Bytes1, Stream1, 1, 0, State1, Acc2);
        {Stream1, State1} ->
            ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc2)
    end;
parse_CData(<<$\r, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
parse_CData(<<"]]>"/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Text = ?ACC(Stream, Pos, Len, Acc),
    {Text, Rest, Stream, Pos + Len + 3, State};
parse_CData(<<"]]"/utf8>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_CData_bb(Stream1, State1, Acc1);
parse_CData(<<"]"/utf8>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_CData_b(Stream1, State1, Acc1);
parse_CData(<<>>, _, _, _, #ys_state{in_replacement = true} = State, _) ->
    fatal_error(unbalanced_reference, State);
?ONECHAR.

parse_CData_b(<<"]>"/utf8, Rest/bitstring>> = Stream, State, Acc) ->
    {Acc, Rest, Stream, 2, State};
parse_CData_b(<<"]"/utf8>>, State, Acc) ->
    {Stream1, State1} = cf(State),
    parse_CData_bb(Stream1, State1, Acc);
parse_CData_b(<<>>, State, Acc) ->
    {Stream1, State1} = cf(State),
    parse_CData_b(Stream1, State1, Acc);
parse_CData_b(Stream, State, Acc) ->
    Acc1 = ?APPEND(<<"]"/utf8>>, Acc),
    parse_CData(Stream, Stream, 0, 0, State, Acc1).

parse_CData_bb(<<"]"/utf8, Rest/bitstring>>, State, Acc) ->
    Acc1 = ?APPEND(<<"]"/utf8>>, Acc),
    parse_CData_bb(Rest, State, Acc1);
parse_CData_bb(<<">"/utf8, Rest/bitstring>> = Stream, State, Acc) ->
    {Acc, Rest, Stream, 1, State};
parse_CData_bb(<<>>, State, Acc) ->
    {Stream1, State1} = cf(State),
    parse_CData_bb(Stream1, State1, Acc);
parse_CData_bb(Stream, State, Acc) ->
    Acc1 = ?APPEND(<<"]]"/utf8>>, Acc),
    parse_CData(Stream, Stream, 0, 0, State, Acc1).

%%----------------------------------------------------------------------
%% [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'" )
%%----------------------------------------------------------------------
parse_EncodingDecl(?MATCH) ->
    parse_EncodingDeclS(?MATCH).

parse_EncodingDeclS(<<"encoding"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_EncodingDecl_encoding(Rest, Stream, Pos + 8, State);
parse_EncodingDeclS(<<"encodin"/utf8>>, _, _, State) ->
    parse_EncodingDecl_encodin(cf(State));
parse_EncodingDeclS(<<"encodi"/utf8>>, _, _, State) ->
    parse_EncodingDecl_encodi(cf(State));
parse_EncodingDeclS(<<"encod"/utf8>>, _, _, State) ->
    parse_EncodingDecl_encod(cf(State));
parse_EncodingDeclS(<<"enco"/utf8>>, _, _, State) ->
    parse_EncodingDecl_enco(cf(State));
parse_EncodingDeclS(<<"enc"/utf8>>, _, _, State) ->
    parse_EncodingDecl_enc(cf(State));
parse_EncodingDeclS(<<"en"/utf8>>, _, _, State) ->
    parse_EncodingDecl_en(cf(State));
parse_EncodingDeclS(<<"e"/utf8>>, _, _, State) ->
    parse_EncodingDecl_e(cf(State));
parse_EncodingDeclS(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_EncodingDeclS(Stream1, Stream1, 0, State1);
parse_EncodingDeclS(?MATCH) ->
    % no encoding
    {{<<"UTF-8">>, false}, ?MATCH}.

parse_EncodingDecl_e({<<"ncoding"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_EncodingDecl_encoding(Rest, Stream, 7, State);
parse_EncodingDecl_e({<<"ncodin"/utf8>>, State}) ->
    parse_EncodingDecl_encodin(cf(State));
parse_EncodingDecl_e({<<"ncodi"/utf8>>, State}) ->
    parse_EncodingDecl_encodi(cf(State));
parse_EncodingDecl_e({<<"ncod"/utf8>>, State}) ->
    parse_EncodingDecl_encod(cf(State));
parse_EncodingDecl_e({<<"nco"/utf8>>, State}) ->
    parse_EncodingDecl_enco(cf(State));
parse_EncodingDecl_e({<<"nc"/utf8>>, State}) ->
    parse_EncodingDecl_enc(cf(State));
parse_EncodingDecl_e({<<"n"/utf8>>, State}) ->
    parse_EncodingDecl_en(cf(State));
parse_EncodingDecl_e({_, State}) ->
    fatal_error(bad_encoding, State).

parse_EncodingDecl_en({<<"coding"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_EncodingDecl_encoding(Rest, Stream, 6, State);
parse_EncodingDecl_en({<<"codin"/utf8>>, State}) ->
    parse_EncodingDecl_encodin(cf(State));
parse_EncodingDecl_en({<<"codi"/utf8>>, State}) ->
    parse_EncodingDecl_encodi(cf(State));
parse_EncodingDecl_en({<<"cod"/utf8>>, State}) ->
    parse_EncodingDecl_encod(cf(State));
parse_EncodingDecl_en({<<"co"/utf8>>, State}) ->
    parse_EncodingDecl_enco(cf(State));
parse_EncodingDecl_en({<<"c"/utf8>>, State}) ->
    parse_EncodingDecl_enc(cf(State));
parse_EncodingDecl_en({_, State}) ->
    fatal_error(bad_encoding, State).

parse_EncodingDecl_enc({<<"oding"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_EncodingDecl_encoding(Rest, Stream, 5, State);
parse_EncodingDecl_enc({<<"odin"/utf8>>, State}) ->
    parse_EncodingDecl_encodin(cf(State));
parse_EncodingDecl_enc({<<"odi"/utf8>>, State}) ->
    parse_EncodingDecl_encodi(cf(State));
parse_EncodingDecl_enc({<<"od"/utf8>>, State}) ->
    parse_EncodingDecl_encod(cf(State));
parse_EncodingDecl_enc({<<"o"/utf8>>, State}) ->
    parse_EncodingDecl_enco(cf(State));
parse_EncodingDecl_enc({_, State}) ->
    fatal_error(bad_encoding, State).

parse_EncodingDecl_enco({<<"ding"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_EncodingDecl_encoding(Rest, Stream, 4, State);
parse_EncodingDecl_enco({<<"din"/utf8>>, State}) ->
    parse_EncodingDecl_encodin(cf(State));
parse_EncodingDecl_enco({<<"di"/utf8>>, State}) ->
    parse_EncodingDecl_encodi(cf(State));
parse_EncodingDecl_enco({<<"d"/utf8>>, State}) ->
    parse_EncodingDecl_encod(cf(State));
parse_EncodingDecl_enco({_, State}) ->
    fatal_error(bad_encoding, State).

parse_EncodingDecl_encod({<<"ing"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_EncodingDecl_encoding(Rest, Stream, 3, State);
parse_EncodingDecl_encod({<<"in"/utf8>>, State}) ->
    parse_EncodingDecl_encodin(cf(State));
parse_EncodingDecl_encod({<<"i"/utf8>>, State}) ->
    parse_EncodingDecl_encodi(cf(State));
parse_EncodingDecl_encod({_, State}) ->
    fatal_error(bad_encoding, State).

parse_EncodingDecl_encodi({<<"ng"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_EncodingDecl_encoding(Rest, Stream, 2, State);
parse_EncodingDecl_encodi({<<"n"/utf8>>, State}) ->
    parse_EncodingDecl_encodin(cf(State));
parse_EncodingDecl_encodi({_, State}) ->
    fatal_error(bad_encoding, State).

parse_EncodingDecl_encodin({<<"g"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_EncodingDecl_encoding(Rest, Stream, 1, State);
parse_EncodingDecl_encodin({_, State}) ->
    fatal_error(bad_encoding, State).

parse_EncodingDecl_encoding(?MATCH) ->
    {?MATCH1} = parse_Eq(?MATCH),
    parse_EncodingDecl_EncName(?MATCH1).

parse_EncodingDecl_EncName(<<$'/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_EncodingDecl_EncName_sq(Rest, Stream, Pos + 1, State);
parse_EncodingDecl_EncName(<<$"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_EncodingDecl_EncName_dq(Rest, Stream, Pos + 1, State);
parse_EncodingDecl_EncName(_, _, _, State) ->
    fatal_error(bad_encoding, State).

parse_EncodingDecl_EncName_sq(?MATCH) ->
    case parse_EncodingDecl_EncName_name(?MATCH) of
        {Name, <<$'/utf8, Rest/bitstring>>, Stream1, Pos1, State1} ->
            {{Name, true}, Rest, Stream1, Pos1 + 1, State1};
        {_, _, _, _, State1} ->
            fatal_error(bad_encoding, State1)
    end.

parse_EncodingDecl_EncName_dq(?MATCH) ->
    case parse_EncodingDecl_EncName_name(?MATCH) of
        {Name, <<$"/utf8, Rest/bitstring>>, Stream1, Pos1, State1} ->
            {{Name, true}, Rest, Stream1, Pos1 + 1, State1};
        {_, _, _, _, State1} ->
            fatal_error(bad_encoding, State1)
    end.

%%----------------------------------------------------------------------
%% [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
%% /* Encoding name contains only Latin characters */
%%----------------------------------------------------------------------
parse_EncodingDecl_EncName_name(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_EncodingDecl_EncName_name(Stream1, Stream1, 0, State1);
parse_EncodingDecl_EncName_name(<<Char/utf8, Rest/bitstring>>, Stream, Pos, State) when
    Char >= $A andalso Char =< $Z; Char >= $a andalso Char =< $z
->
    parse_EncodingDecl_EncName_name_1(Rest, Stream, Pos, 1, State, []);
parse_EncodingDecl_EncName_name(_, _, _, State) ->
    fatal_error(bad_char, State).

parse_EncodingDecl_EncName_name_1(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_EncodingDecl_EncName_name_1(Stream1, Stream1, 0, 0, State1, Acc1);
parse_EncodingDecl_EncName_name_1(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when
    Char >= $A andalso Char =< $Z;
    Char >= $a andalso Char =< $z;
    Char >= $0 andalso Char =< $9;
    Char == $.;
    Char == $_;
    Char == $-
->
    parse_EncodingDecl_EncName_name_1(Rest, Stream, Pos, Len + 1, State, Acc);
parse_EncodingDecl_EncName_name_1(Bytes, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Acc1, Bytes, Stream, Pos + Len, State}.

%%----------------------------------------------------------------------
%% [25] Eq ::= S? '=' S?
%%----------------------------------------------------------------------
parse_Eq(?MATCH) ->
    {_Found, ?MATCH1} = maybe_consume_s(?MATCH),
    parse_Eq_1(?MATCH1).

parse_Eq_1(<<$=/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    {_Found, ?MATCH1} = maybe_consume_s(Rest, Stream, Pos + 1, State),
    {?MATCH1};
parse_Eq_1(_, _, _, State) ->
    fatal_error(bad_eq, State).

%%----------------------------------------------------------------------
%% [26] VersionNum ::= '1.' [0-9]+
%%----------------------------------------------------------------------
parse_VersionNum_sq(<<$1/utf8, $./utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_VersionNum_digit_sq(Rest, Stream, Pos + 2, 0, State, []);
parse_VersionNum_sq(<<$1/utf8>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_VersionNum_1_sq(Stream1, State1);
parse_VersionNum_sq(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_VersionNum_sq(Stream1, Stream1, 0, State1);
parse_VersionNum_sq(_, _, _, State) ->
    fatal_error(bad_version_num, State).

parse_VersionNum_1_sq(<<$./utf8, Rest/bitstring>> = Stream, State) ->
    parse_VersionNum_digit_sq(Rest, Stream, 1, 0, State, []);
parse_VersionNum_1_sq(_, State) ->
    fatal_error(bad_version_num, State).

parse_VersionNum_digit_sq(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_VersionNum_digit_sq(Stream1, Stream1, 0, 0, State1, Acc1);
parse_VersionNum_digit_sq(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when
    Char >= $0 andalso Char =< $9
->
    parse_VersionNum_digit_sq(Rest, Stream, Pos, Len + 1, State, Acc);
parse_VersionNum_digit_sq(<<$'/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {{version_to_number(Acc1, State), true}, Rest, Stream, Pos + Len + 1, State};
parse_VersionNum_digit_sq(_, _, _, _, State, _) ->
    fatal_error(bad_version_num, State).

parse_VersionNum_dq(<<$1/utf8, $./utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_VersionNum_digit_dq(Rest, Stream, Pos + 2, 0, State, []);
parse_VersionNum_dq(<<$1/utf8>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_VersionNum_1_dq(Stream1, State1);
parse_VersionNum_dq(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_VersionNum_dq(Stream1, Stream1, 0, State1);
parse_VersionNum_dq(_, _, _, State) ->
    fatal_error(bad_version_num, State).

parse_VersionNum_1_dq(<<$./utf8, Rest/bitstring>> = Stream, State) ->
    parse_VersionNum_digit_dq(Rest, Stream, 1, 0, State, []);
parse_VersionNum_1_dq(_, State) ->
    fatal_error(bad_version_num, State).

parse_VersionNum_digit_dq(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_VersionNum_digit_dq(Stream1, Stream1, 0, 0, State1, Acc1);
parse_VersionNum_digit_dq(<<Char/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when
    Char >= $0 andalso Char =< $9
->
    parse_VersionNum_digit_dq(Rest, Stream, Pos, Len + 1, State, Acc);
parse_VersionNum_digit_dq(<<$\"/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {{version_to_number(Acc1, State), true}, Rest, Stream, Pos + Len + 1, State};
parse_VersionNum_digit_dq(_, _, _, _, State, _) ->
    fatal_error(bad_version_num, State).

version_to_number(Acc, State) ->
    case to_binary([<<"1."/utf8>> | Acc]) of
        <<"1."/utf8>> -> fatal_error(bad_version_num, State);
        Bin -> Bin
    end.

%%----------------------------------------------------------------------
%% [24] VersionInfo ::= S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"')
%%----------------------------------------------------------------------
parse_VersionInfo(?MATCH) ->
    {Found, ?MATCH1} = maybe_consume_s(?MATCH),
    case Found of
        true ->
            parse_VersionInfoS(?MATCH1);
        false ->
            {{<<>>, false}, ?MATCH1}
    end.

parse_VersionInfo_version(?MATCH) ->
    case parse_Eq(?MATCH) of
        {<<$'/utf8, Bytes1/bitstring>>, Stream1, Pos1, State1} ->
            parse_VersionNum_sq(Bytes1, Stream1, Pos1 + 1, State1);
        {<<$\"/utf8, Bytes1/bitstring>>, Stream1, Pos1, State1} ->
            parse_VersionNum_dq(Bytes1, Stream1, Pos1 + 1, State1);
        {_, _, _, State1} ->
            fatal_error(bad_version, State1)
    end.

parse_VersionInfoS(<<"version"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_VersionInfo_version(Rest, Stream, Pos + 7, State);
parse_VersionInfoS(<<"versio"/utf8>>, _, _, State) ->
    parse_VersionInfo_versio(cf(State));
parse_VersionInfoS(<<"versi"/utf8>>, _, _, State) ->
    parse_VersionInfo_versi(cf(State));
parse_VersionInfoS(<<"vers"/utf8>>, _, _, State) ->
    parse_VersionInfo_vers(cf(State));
parse_VersionInfoS(<<"ver"/utf8>>, _, _, State) ->
    parse_VersionInfo_ver(cf(State));
parse_VersionInfoS(<<"ve"/utf8>>, _, _, State) ->
    parse_VersionInfo_ve(cf(State));
parse_VersionInfoS(<<"v"/utf8>>, _, _, State) ->
    parse_VersionInfo_v(cf(State));
parse_VersionInfoS(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_VersionInfoS(Stream1, Stream1, 0, State1);
parse_VersionInfoS(?MATCH) ->
    {{<<>>, false}, ?MATCH}.

parse_VersionInfo_v({<<"ersion"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_VersionInfo_version(Rest, Stream, 6, State);
parse_VersionInfo_v({<<"ersio"/utf8>>, State}) ->
    parse_VersionInfo_versio(cf(State));
parse_VersionInfo_v({<<"ersi"/utf8>>, State}) ->
    parse_VersionInfo_versi(cf(State));
parse_VersionInfo_v({<<"ers"/utf8>>, State}) ->
    parse_VersionInfo_vers(cf(State));
parse_VersionInfo_v({<<"er"/utf8>>, State}) ->
    parse_VersionInfo_ver(cf(State));
parse_VersionInfo_v({<<"e"/utf8>>, State}) ->
    parse_VersionInfo_ve(cf(State));
parse_VersionInfo_v({_, State}) ->
    fatal_error(bad_version_num, State).

parse_VersionInfo_ve({<<"rsion"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_VersionInfo_version(Rest, Stream, 5, State);
parse_VersionInfo_ve({<<"rsio"/utf8>>, State}) ->
    parse_VersionInfo_versio(cf(State));
parse_VersionInfo_ve({<<"rsi"/utf8>>, State}) ->
    parse_VersionInfo_versi(cf(State));
parse_VersionInfo_ve({<<"rs"/utf8>>, State}) ->
    parse_VersionInfo_vers(cf(State));
parse_VersionInfo_ve({<<"r"/utf8>>, State}) ->
    parse_VersionInfo_ver(cf(State));
parse_VersionInfo_ve({_, State}) ->
    fatal_error(bad_version_num, State).

parse_VersionInfo_ver({<<"sion"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_VersionInfo_version(Rest, Stream, 4, State);
parse_VersionInfo_ver({<<"sio"/utf8>>, State}) ->
    parse_VersionInfo_versio(cf(State));
parse_VersionInfo_ver({<<"si"/utf8>>, State}) ->
    parse_VersionInfo_versi(cf(State));
parse_VersionInfo_ver({<<"s"/utf8>>, State}) ->
    parse_VersionInfo_vers(cf(State));
parse_VersionInfo_ver({_, State}) ->
    fatal_error(bad_version_num, State).

parse_VersionInfo_vers({<<"ion"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_VersionInfo_version(Rest, Stream, 3, State);
parse_VersionInfo_vers({<<"io"/utf8>>, State}) ->
    parse_VersionInfo_versio(cf(State));
parse_VersionInfo_vers({<<"i"/utf8>>, State}) ->
    parse_VersionInfo_versi(cf(State));
parse_VersionInfo_vers({_, State}) ->
    fatal_error(bad_version_num, State).

parse_VersionInfo_versi({<<"on"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_VersionInfo_version(Rest, Stream, 2, State);
parse_VersionInfo_versi({<<"o"/utf8>>, State}) ->
    parse_VersionInfo_versio(cf(State));
parse_VersionInfo_versi({_, State}) ->
    fatal_error(bad_version_num, State).

parse_VersionInfo_versio({<<"n"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_VersionInfo_version(Rest, Stream, 1, State);
parse_VersionInfo_versio({_, State}) ->
    fatal_error(bad_version_num, State).

%%----------------------------------------------------------------------
%% [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"'))
%% leading space is trimmed already
%%----------------------------------------------------------------------
parse_SDDecl_standalone(?MATCH) ->
    {?MATCH1} = parse_Eq(?MATCH),
    parse_SDDecl_standalone_yesno(?MATCH1).

parse_SDDecl_standalone_yesno(<<$'/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_SDDecl_standalone_yesno_sq(Rest, Stream, Pos + 1, State);
parse_SDDecl_standalone_yesno(<<$"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_SDDecl_standalone_yesno_dq(Rest, Stream, Pos + 1, State);
parse_SDDecl_standalone_yesno(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_SDDecl_standalone_yesno(Stream1, Stream1, 0, State1);
parse_SDDecl_standalone_yesno(_, _, _, State) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalone_yesno_sq(<<"no'"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    {{false, true}, Rest, Stream, Pos + 3, State};
parse_SDDecl_standalone_yesno_sq(<<"no"/utf8>>, _, _, State) ->
    parse_SDDecl_standalone_yesno_sq_no(cf(State));
parse_SDDecl_standalone_yesno_sq(<<"n"/utf8>>, _, _, State) ->
    parse_SDDecl_standalone_yesno_sq_n(cf(State));
parse_SDDecl_standalone_yesno_sq(<<"yes'"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    {{true, true}, Rest, Stream, Pos + 4, State};
parse_SDDecl_standalone_yesno_sq(<<"yes"/utf8>>, _, _, State) ->
    parse_SDDecl_standalone_yesno_sq_yes(cf(State));
parse_SDDecl_standalone_yesno_sq(<<"ye"/utf8>>, _, _, State) ->
    parse_SDDecl_standalone_yesno_sq_ye(cf(State));
parse_SDDecl_standalone_yesno_sq(<<"y"/utf8>>, _, _, State) ->
    parse_SDDecl_standalone_yesno_sq_y(cf(State));
parse_SDDecl_standalone_yesno_sq(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_SDDecl_standalone_yesno_sq(Stream1, Stream1, 0, State1).

parse_SDDecl_standalone_yesno_sq_y({<<"es'"/utf8, Rest/bitstring>> = Stream, State}) ->
    {{true, true}, Rest, Stream, 3, State};
parse_SDDecl_standalone_yesno_sq_y({<<"es"/utf8>>, State}) ->
    parse_SDDecl_standalone_yesno_sq_yes(cf(State));
parse_SDDecl_standalone_yesno_sq_y({<<"e"/utf8>>, State}) ->
    parse_SDDecl_standalone_yesno_sq_ye(cf(State));
parse_SDDecl_standalone_yesno_sq_y({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalone_yesno_sq_ye({<<"s'"/utf8, Rest/bitstring>> = Stream, State}) ->
    {{true, true}, Rest, Stream, 2, State};
parse_SDDecl_standalone_yesno_sq_ye({<<"s"/utf8>>, State}) ->
    parse_SDDecl_standalone_yesno_sq_yes(cf(State));
parse_SDDecl_standalone_yesno_sq_ye({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalone_yesno_sq_yes({<<"'"/utf8, Rest/bitstring>> = Stream, State}) ->
    {{true, true}, Rest, Stream, 1, State};
parse_SDDecl_standalone_yesno_sq_yes({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalone_yesno_dq(<<"no\""/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    {{false, true}, Rest, Stream, Pos + 3, State};
parse_SDDecl_standalone_yesno_dq(<<"no"/utf8>>, _, _, State) ->
    parse_SDDecl_standalone_yesno_dq_no(cf(State));
parse_SDDecl_standalone_yesno_dq(<<"n"/utf8>>, _, _, State) ->
    parse_SDDecl_standalone_yesno_dq_n(cf(State));
parse_SDDecl_standalone_yesno_dq(<<"yes\""/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    {{true, true}, Rest, Stream, Pos + 4, State};
parse_SDDecl_standalone_yesno_dq(<<"yes"/utf8>>, _, _, State) ->
    parse_SDDecl_standalone_yesno_dq_yes(cf(State));
parse_SDDecl_standalone_yesno_dq(<<"ye"/utf8>>, _, _, State) ->
    parse_SDDecl_standalone_yesno_dq_ye(cf(State));
parse_SDDecl_standalone_yesno_dq(<<"y"/utf8>>, _, _, State) ->
    parse_SDDecl_standalone_yesno_dq_y(cf(State));
parse_SDDecl_standalone_yesno_dq(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_SDDecl_standalone_yesno_dq(Stream1, Stream1, 0, State1).

parse_SDDecl_standalone_yesno_sq_n({<<"o'"/utf8, Rest/bitstring>> = Stream, State}) ->
    {{false, true}, Rest, Stream, 2, State};
parse_SDDecl_standalone_yesno_sq_n({<<"o"/utf8>>, State}) ->
    parse_SDDecl_standalone_yesno_sq_no(cf(State));
parse_SDDecl_standalone_yesno_sq_n({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalone_yesno_sq_no({<<"'"/utf8, Rest/bitstring>> = Stream, State}) ->
    {{false, true}, Rest, Stream, 1, State};
parse_SDDecl_standalone_yesno_sq_no({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalone_yesno_dq_n({<<"o\""/utf8, Rest/bitstring>> = Stream, State}) ->
    {{false, true}, Rest, Stream, 2, State};
parse_SDDecl_standalone_yesno_dq_n({<<"o"/utf8>>, State}) ->
    parse_SDDecl_standalone_yesno_dq_no(cf(State));
parse_SDDecl_standalone_yesno_dq_n({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalone_yesno_dq_no({<<"\""/utf8, Rest/bitstring>> = Stream, State}) ->
    {{false, true}, Rest, Stream, 1, State};
parse_SDDecl_standalone_yesno_dq_no({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalone_yesno_dq_y({<<"es\""/utf8, Rest/bitstring>> = Stream, State}) ->
    {{true, true}, Rest, Stream, 3, State};
parse_SDDecl_standalone_yesno_dq_y({<<"es"/utf8>>, State}) ->
    parse_SDDecl_standalone_yesno_dq_yes(cf(State));
parse_SDDecl_standalone_yesno_dq_y({<<"e"/utf8>>, State}) ->
    parse_SDDecl_standalone_yesno_dq_ye(cf(State));
parse_SDDecl_standalone_yesno_dq_y({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalone_yesno_dq_ye({<<"s\""/utf8, Rest/bitstring>> = Stream, State}) ->
    {{true, true}, Rest, Stream, 2, State};
parse_SDDecl_standalone_yesno_dq_ye({<<"s"/utf8>>, State}) ->
    parse_SDDecl_standalone_yesno_dq_yes(cf(State));
parse_SDDecl_standalone_yesno_dq_ye({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalone_yesno_dq_yes({<<"\""/utf8, Rest/bitstring>> = Stream, State}) ->
    {{true, true}, Rest, Stream, 1, State};
parse_SDDecl_standalone_yesno_dq_yes({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl(<<"standalone"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_SDDecl_standalone(Rest, Stream, Pos + 10, State);
parse_SDDecl(<<"standalon"/utf8>>, _, _, State) ->
    parse_SDDecl_standalon(cf(State));
parse_SDDecl(<<"standalo"/utf8>>, _, _, State) ->
    parse_SDDecl_standalo(cf(State));
parse_SDDecl(<<"standal"/utf8>>, _, _, State) ->
    parse_SDDecl_standal(cf(State));
parse_SDDecl(<<"standa"/utf8>>, _, _, State) ->
    parse_SDDecl_standa(cf(State));
parse_SDDecl(<<"stand"/utf8>>, _, _, State) ->
    parse_SDDecl_stand(cf(State));
parse_SDDecl(<<"stan"/utf8>>, _, _, State) ->
    parse_SDDecl_stan(cf(State));
parse_SDDecl(<<"sta"/utf8>>, _, _, State) ->
    parse_SDDecl_sta(cf(State));
parse_SDDecl(<<"st"/utf8>>, _, _, State) ->
    parse_SDDecl_st(cf(State));
parse_SDDecl(<<"s"/utf8>>, _, _, State) ->
    parse_SDDecl_s(cf(State));
parse_SDDecl(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_SDDecl(Stream1, Stream1, 0, State1);
parse_SDDecl(?MATCH) ->
    {{false, false}, ?MATCH}.

parse_SDDecl_s({<<"tandalone"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_SDDecl_standalone(Rest, Stream, 9, State);
parse_SDDecl_s({<<"tandalon"/utf8>>, State}) ->
    parse_SDDecl_standalon(cf(State));
parse_SDDecl_s({<<"tandalo"/utf8>>, State}) ->
    parse_SDDecl_standalo(cf(State));
parse_SDDecl_s({<<"tandal"/utf8>>, State}) ->
    parse_SDDecl_standal(cf(State));
parse_SDDecl_s({<<"tanda"/utf8>>, State}) ->
    parse_SDDecl_standa(cf(State));
parse_SDDecl_s({<<"tand"/utf8>>, State}) ->
    parse_SDDecl_stand(cf(State));
parse_SDDecl_s({<<"tan"/utf8>>, State}) ->
    parse_SDDecl_stan(cf(State));
parse_SDDecl_s({<<"ta"/utf8>>, State}) ->
    parse_SDDecl_sta(cf(State));
parse_SDDecl_s({<<"t"/utf8>>, State}) ->
    parse_SDDecl_st(cf(State));
parse_SDDecl_s({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_st({<<"andalone"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_SDDecl_standalone(Rest, Stream, 8, State);
parse_SDDecl_st({<<"andalon"/utf8>>, State}) ->
    parse_SDDecl_standalon(cf(State));
parse_SDDecl_st({<<"andalo"/utf8>>, State}) ->
    parse_SDDecl_standalo(cf(State));
parse_SDDecl_st({<<"andal"/utf8>>, State}) ->
    parse_SDDecl_standal(cf(State));
parse_SDDecl_st({<<"anda"/utf8>>, State}) ->
    parse_SDDecl_standa(cf(State));
parse_SDDecl_st({<<"and"/utf8>>, State}) ->
    parse_SDDecl_stand(cf(State));
parse_SDDecl_st({<<"an"/utf8>>, State}) ->
    parse_SDDecl_stan(cf(State));
parse_SDDecl_st({<<"a"/utf8>>, State}) ->
    parse_SDDecl_sta(cf(State));
parse_SDDecl_st({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_sta({<<"ndalone"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_SDDecl_standalone(Rest, Stream, 7, State);
parse_SDDecl_sta({<<"ndalon"/utf8>>, State}) ->
    parse_SDDecl_standalon(cf(State));
parse_SDDecl_sta({<<"ndalo"/utf8>>, State}) ->
    parse_SDDecl_standalo(cf(State));
parse_SDDecl_sta({<<"ndal"/utf8>>, State}) ->
    parse_SDDecl_standal(cf(State));
parse_SDDecl_sta({<<"nda"/utf8>>, State}) ->
    parse_SDDecl_standa(cf(State));
parse_SDDecl_sta({<<"nd"/utf8>>, State}) ->
    parse_SDDecl_stand(cf(State));
parse_SDDecl_sta({<<"n"/utf8>>, State}) ->
    parse_SDDecl_stan(cf(State));
parse_SDDecl_sta({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_stan({<<"dalone"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_SDDecl_standalone(Rest, Stream, 6, State);
parse_SDDecl_stan({<<"dalon"/utf8>>, State}) ->
    parse_SDDecl_standalon(cf(State));
parse_SDDecl_stan({<<"dalo"/utf8>>, State}) ->
    parse_SDDecl_standalo(cf(State));
parse_SDDecl_stan({<<"dal"/utf8>>, State}) ->
    parse_SDDecl_standal(cf(State));
parse_SDDecl_stan({<<"da"/utf8>>, State}) ->
    parse_SDDecl_standa(cf(State));
parse_SDDecl_stan({<<"d"/utf8>>, State}) ->
    parse_SDDecl_stand(cf(State));
parse_SDDecl_stan({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_stand({<<"alone"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_SDDecl_standalone(Rest, Stream, 5, State);
parse_SDDecl_stand({<<"alon"/utf8>>, State}) ->
    parse_SDDecl_standalon(cf(State));
parse_SDDecl_stand({<<"alo"/utf8>>, State}) ->
    parse_SDDecl_standalo(cf(State));
parse_SDDecl_stand({<<"al"/utf8>>, State}) ->
    parse_SDDecl_standal(cf(State));
parse_SDDecl_stand({<<"a"/utf8>>, State}) ->
    parse_SDDecl_standa(cf(State));
parse_SDDecl_stand({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standa({<<"lone"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_SDDecl_standalone(Rest, Stream, 4, State);
parse_SDDecl_standa({<<"lon"/utf8>>, State}) ->
    parse_SDDecl_standalon(cf(State));
parse_SDDecl_standa({<<"lo"/utf8>>, State}) ->
    parse_SDDecl_standalo(cf(State));
parse_SDDecl_standa({<<"l"/utf8>>, State}) ->
    parse_SDDecl_standal(cf(State));
parse_SDDecl_standa({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standal({<<"one"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_SDDecl_standalone(Rest, Stream, 3, State);
parse_SDDecl_standal({<<"on"/utf8>>, State}) ->
    parse_SDDecl_standalon(cf(State));
parse_SDDecl_standal({<<"o"/utf8>>, State}) ->
    parse_SDDecl_standalo(cf(State));
parse_SDDecl_standal({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalo({<<"ne"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_SDDecl_standalone(Rest, Stream, 2, State);
parse_SDDecl_standalo({<<"n"/utf8>>, State}) ->
    parse_SDDecl_standalon(cf(State));
parse_SDDecl_standalo({_, State}) ->
    fatal_error(bad_standalone, State).

parse_SDDecl_standalon({<<"e"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_SDDecl_standalone(Rest, Stream, 1, State);
parse_SDDecl_standalon({_, State}) ->
    fatal_error(bad_standalone, State).

%%----------------------------------------------------------------------
%% [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
%%----------------------------------------------------------------------
parse_XMLDecl_ltqxml(?MATCH) ->
    {{Version, true}, ?MATCH1} = parse_VersionInfo(?MATCH),
    {IsWs2, ?MATCH2} = maybe_consume_s(?MATCH1),
    {{Encoding, EncSet}, ?MATCH3} = parse_EncodingDecl(?MATCH2),
    {{Standalone1, SaSet1}, ?MATCH6} =
        case IsWs2 of
            true when EncSet ->
                {IsWs4, ?MATCH4} = maybe_consume_s(?MATCH3),
                {{Standalone, SaSet}, ?MATCH5} = parse_SDDecl(?MATCH4),
                case IsWs4 of
                    false when SaSet -> fatal_error(missing_ws, State);
                    _ -> {{Standalone, SaSet}, ?MATCH5}
                end;
            true ->
                parse_SDDecl(?MATCH3);
            false when EncSet ->
                fatal_error(missing_ws, State);
            false ->
                {IsWs4, ?MATCH4} = maybe_consume_s(?MATCH3),
                {{Standalone, SaSet}, ?MATCH5} = parse_SDDecl(?MATCH4),
                case IsWs4 of
                    false when SaSet -> fatal_error(missing_ws, State);
                    _ -> {{Standalone, SaSet}, ?MATCH5}
                end
        end,
    {_, ?MATCH7} = maybe_consume_s(?MATCH6),
    {Bytes8, _, _, State8} = parse_XMLDecl_end(?MATCH7),
    State9 = set_next_parser_position(misc_pre_dtd, State8),
    yaccety_sax:event_startDocument(
        Version,
        Encoding,
        EncSet,
        Standalone1,
        SaSet1,
        set_state_pos(State9, Bytes8)
    ).

parse_XMLDecl_end(<<"?>"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    {Rest, Stream, Pos + 2, State};
parse_XMLDecl_end(<<"?"/utf8>>, _, _, State) ->
    parse_XMLDecl_end_q(cf(State));
parse_XMLDecl_end(Bytes, _, _, State) ->
    fatal_error(bad_xmldecl, {Bytes, State}).

parse_XMLDecl_end_q({<<$>/utf8, Rest/bitstring>> = Stream, State}) ->
    {Rest, Stream, 1, State};
parse_XMLDecl_end_q({_, State}) ->
    fatal_error(bad_xmldecl, State).

parse_XMLDecl(Stream, State) -> parse_XMLDecl(Stream, Stream, 0, State).

parse_XMLDecl(<<"<?xml"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_XMLDecl_ltqxml(Rest, Stream, Pos + 5, State);
parse_XMLDecl(<<"<?xm"/utf8>>, _, _, State) ->
    parse_XMLDecl_ltqxm(cf(State));
parse_XMLDecl(<<"<?x"/utf8>>, _, _, State) ->
    parse_XMLDecl_ltqx(cf(State));
parse_XMLDecl(<<"<?"/utf8>>, _, _, State) ->
    parse_XMLDecl_ltq(cf(State));
parse_XMLDecl(<<"<">>, _, _, State) ->
    parse_XMLDecl_lt(cf(State));
parse_XMLDecl(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_XMLDecl(Stream1, Stream1, 0, State1);
parse_XMLDecl(Bytes, _, _, State) ->
    % default declaration
    State1 = set_next_parser_position(misc_pre_dtd, State),
    yaccety_sax:event_startDocument(
        <<"1.0">>,
        <<"UTF-8">>,
        false,
        false,
        false,
        set_state_pos(State1, Bytes)
    ).

parse_XMLDecl_lt({<<"?xml"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_XMLDecl_ltqxml(Rest, Stream, 4, State);
parse_XMLDecl_lt({<<"?xm"/utf8>>, State}) ->
    parse_XMLDecl_ltqxm(cf(State));
parse_XMLDecl_lt({<<"?x"/utf8>>, State}) ->
    parse_XMLDecl_ltqx(cf(State));
parse_XMLDecl_lt({<<"?"/utf8>>, State}) ->
    parse_XMLDecl_ltq(cf(State));
parse_XMLDecl_lt({Bytes, State}) ->
    % default declaration, came in with one byte, so assuming a prepend is okay here.
    State1 = set_next_parser_position(misc_pre_dtd, State),
    yaccety_sax:event_startDocument(
        <<"1.0">>,
        <<"UTF-8">>,
        false,
        false,
        false,
        set_state_pos(State1, <<"<", Bytes/bitstring>>)
    ).

parse_XMLDecl_ltq({<<"xml"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_XMLDecl_ltqxml(Rest, Stream, 3, State);
parse_XMLDecl_ltq({<<"xm"/utf8>>, State}) ->
    parse_XMLDecl_ltqxm(cf(State));
parse_XMLDecl_ltq({<<"x"/utf8>>, State}) ->
    parse_XMLDecl_ltqx(cf(State));
parse_XMLDecl_ltq({Bytes, State}) ->
    % default declaration, came in with one byte, so assuming a prepend is okay here.
    State1 = set_next_parser_position(misc_pre_dtd, State),
    yaccety_sax:event_startDocument(
        <<"1.0">>,
        <<"UTF-8">>,
        false,
        false,
        false,
        set_state_pos(State1, <<"<?", Bytes/bitstring>>)
    ).

parse_XMLDecl_ltqx({<<"ml"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_XMLDecl_ltqxml(Rest, Stream, 2, State);
parse_XMLDecl_ltqx({<<"m"/utf8>>, State}) ->
    parse_XMLDecl_ltqxm(cf(State));
parse_XMLDecl_ltqx({_, State}) ->
    fatal_error(bad_xmldecl, State).

parse_XMLDecl_ltqxm({<<"l"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_XMLDecl_ltqxml(Rest, Stream, 1, State);
parse_XMLDecl_ltqxm({_, State}) ->
    fatal_error(bad_xmldecl, State).

%%----------------------------------------------------------------------
%% [27] Misc ::= Comment | PI | S
%%----------------------------------------------------------------------
parse_Misc(Stream, State) -> parse_Misc(Stream, Stream, 0, State).

parse_Misc(<<"<!--"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_Comment(Rest, Stream, Pos + 4, State);
parse_Misc(<<"<?"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_PI(Rest, Stream, Pos + 2, State);
parse_Misc(<<"<!-"/utf8>>, _, _, State) ->
    parse_Misc_ltbangdash(cf(State));
parse_Misc(<<"<!"/utf8>>, _, _, State) ->
    parse_Misc_ltbang(cf(State));
parse_Misc(<<"<"/utf8>>, _, _, State) ->
    parse_Misc_lt(cf(State));
parse_Misc(no_bytes, _, _, State) ->
    {no_bytes, State};
parse_Misc(<<>>, _, _, State) ->
    case cf(State) of
        {no_bytes, State1} -> {no_bytes, State1};
        {Stream1, State1} -> parse_Misc(Stream1, Stream1, 0, State1)
    end;
parse_Misc(?MATCH) ->
    case maybe_consume_s(?MATCH) of
        {true, ?MATCH1} ->
            parse_Misc(?MATCH1);
        {false, Bytes1, _, _, State1} ->
            set_state_pos(State1, Bytes1)
    end.

parse_Misc_lt({<<"!--"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_Comment(Rest, Stream, 3, State);
parse_Misc_lt({<<"!-"/utf8>>, State}) ->
    parse_Misc_ltbangdash(cf(State));
parse_Misc_lt({<<"!"/utf8>>, State}) ->
    parse_Misc_ltbang(cf(State));
parse_Misc_lt({<<"?"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_PI(Rest, Stream, 1, State);
parse_Misc_lt({Bytes, State}) ->
    set_state_pos(State, <<"<", Bytes/bitstring>>).

parse_Misc_ltbang({<<"--"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_Comment(Rest, Stream, 2, State);
parse_Misc_ltbang({<<"-"/utf8>>, State}) ->
    parse_Misc_ltbangdash(cf(State));
parse_Misc_ltbang({Bytes, State}) ->
    set_state_pos(State, <<"<!", Bytes/bitstring>>).

parse_Misc_ltbangdash({<<"-"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_Comment(Rest, Stream, 1, State);
parse_Misc_ltbangdash({_, State}) ->
    fatal_error(bad_misc, State).

%%----------------------------------------------------------------------
%% [43] content ::= CharData? ((element | Reference | CDSect | PI | Comment) CharData?)*
%%----------------------------------------------------------------------
parse_content(Stream, State) -> parse_content(Stream, Stream, 0, State).

parse_content(
    <<"</"/utf8, Rest/bitstring>>,
    Stream,
    Pos,
    #ys_state{in_replacement = false} = State
) ->
    case State#ys_state.namespace_aware of
        true ->
            parse_ETag(Rest, Stream, Pos + 2, State);
        false ->
            parse_ETag_no_ns(Rest, Stream, Pos + 2, State)
    end;
parse_content(<<"<!--"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_Comment(Rest, Stream, Pos + 4, State);
parse_content(<<"<!-"/utf8>>, _, _, State) ->
    parse_content_ltbangdash(cf(State));
parse_content(<<"<!["/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_CDSect(Rest, Stream, Pos + 3, State);
parse_content(<<"<!"/utf8>>, _, _, State) ->
    parse_content_ltbang(cf(State));
parse_content(<<"<?"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_PI(Rest, Stream, Pos + 2, State);
parse_content(<<"<"/utf8>>, _, _, State) ->
    parse_content_lt(cf(State));
parse_content(<<"<"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    case State#ys_state.namespace_aware of
        true ->
            parse_element_lt(Rest, Stream, Pos + 1, State);
        false ->
            parse_element_lt_no_ns(Rest, Stream, Pos + 1, State)
    end;
parse_content(<<"&"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    case parse_Reference(Rest, Stream, Pos + 1, State, content) of
        {{_, {replacement_text, <<>>}}, ?MATCH1} ->
            ?FUNCTION_NAME(?MATCH1);
        {{Name, {replacement_text, Ref}}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, RTState);
        {{gen, Ref}, ?MATCH1} ->
            parse_CharData(?MATCH1, Ref);
        {{Type, Ref}, ?MATCH1} when Type == hex; Type == dec ->
            parse_CharData(?MATCH1, Ref);
        {{Name, Ref}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, RTState)
    end;
parse_content(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_content(Stream1, Stream1, 0, State1);
parse_content(?MATCH) ->
    parse_CharData(?MATCH).

parse_content_lt({<<"!--"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_Comment(Rest, Stream, 3, State);
parse_content_lt({<<"!-"/utf8>>, State}) ->
    parse_content_ltbangdash(cf(State));
parse_content_lt({<<"!["/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_CDSect(Rest, Stream, 2, State);
parse_content_lt({<<"/"/utf8, Rest/bitstring>> = Stream, State}) ->
    case State#ys_state.namespace_aware of
        true ->
            parse_ETag(Rest, Stream, 1, State);
        false ->
            parse_ETag_no_ns(Rest, Stream, 1, State)
    end;
parse_content_lt({<<"!"/utf8>>, State}) ->
    parse_content_ltbang(cf(State));
parse_content_lt({<<"?"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_PI(Rest, Stream, 1, State);
parse_content_lt({<<>>, State}) ->
    parse_content_lt(cf(State));
parse_content_lt({Stream, State}) ->
    case State#ys_state.namespace_aware of
        true ->
            parse_element_lt(Stream, Stream, 0, State);
        false ->
            parse_element_lt_no_ns(Stream, Stream, 0, State)
    end.

parse_content_ltbang({<<"--"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_Comment(Rest, Stream, 2, State);
parse_content_ltbang({<<"-"/utf8>>, State}) ->
    parse_content_ltbangdash(cf(State));
parse_content_ltbang({<<"["/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_CDSect(Rest, Stream, 1, State);
parse_content_ltbang({_, State}) ->
    fatal_error(bad_content, State).

parse_content_ltbangdash({<<"-"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_Comment(Rest, Stream, 1, State);
parse_content_ltbangdash({_, State}) ->
    fatal_error(bad_content, State).

%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%
%%                                                                                                                   %%
%%                                            Namespace Stuff                                                        %%
%%                                                                                                                   %%
%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%

%%----------------------------------------------------------------------
%% [39] element ::= EmptyElemTag | STag content ETag
%%    [WFC: Element Type Match]
%% [40] STag    ::= '<' Name (S Attribute)* S? '>'
%%    [WFC: Unique Att Spec]
%% [12ns] STag                ::=       '<' QName (S Attribute)* S? '>'
%%    [NSC: Prefix Declared]
%%    [WFC: Unique Att Spec]
%% [14ns] EmptyElemTag        ::=       '<' QName (S Attribute)* S? '/>'
%%    [NSC: Prefix Declared]
%%    [WFC: Unique Att Spec]
%%----------------------------------------------------------------------
parse_element(Stream, State) -> parse_element(Stream, Stream, 0, State).

parse_element(<<$</utf8, Rest/bitstring>>, Stream, Pos, State) ->
    case State#ys_state.namespace_aware of
        true ->
            parse_element_lt(Rest, Stream, Pos + 1, State);
        false ->
            parse_element_lt_no_ns(Rest, Stream, Pos + 1, State)
    end;
parse_element(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_element(Stream1, Stream1, 0, State1);
parse_element(B, _, _, State) ->
    fatal_error(non_element, {B, State}).

parse_element_lt_no_ns(?MATCH) ->
    #ys_state{
        tags = Tags,
        position = P
    } = State,
    {{NameP, NameL}, ?MATCH1} = parse_QName(?MATCH),
    QName = {<<>>, NameP, NameL},
    case Bytes1 of
        <<$>/utf8, Bytes2/bitstring>> ->
            State2 = State1#ys_state{
                position = [content | P],
                tags = [QName | Tags],
                rest_stream = Bytes2
            },
            yaccety_sax:event_startElement(QName, [], [], State2);
        <<$//utf8, Rest/bitstring>> ->
            parse_element_empty_no_ns(
                Rest,
                Stream1,
                Pos1 + 1,
                State1,
                QName,
                [],
                P,
                Tags
            );
        _ ->
            {As, ?MATCH2} = parse_attributes_no_ns(?MATCH1, []),
            case Bytes2 of
                <<$>/utf8, Bytes3/bitstring>> ->
                    State3 = State2#ys_state{
                        position = [content | P],
                        tags = [QName | Tags],
                        rest_stream = Bytes3
                    },
                    yaccety_sax:event_startElement(QName, As, [], State3);
                <<$//utf8, Rest/bitstring>> ->
                    parse_element_empty_no_ns(
                        Rest,
                        Stream2,
                        Pos2 + 1,
                        State2,
                        QName,
                        As,
                        P,
                        Tags
                    );
                _ ->
                    fatal_error(bad_element, State2)
            end
    end.

parse_element_lt(
    Bytes,
    Stream,
    Pos,
    #ys_state{
        tags = Tags,
        inscope_ns = [LastNss | _] = Nss,
        position = P,
        dtd = undefined
    } = State
) ->
    {{NameP, NameL}, ?MATCH1} = parse_QName(?MATCH),
    case Bytes1 of
        <<$>/utf8, Bytes2/bitstring>> ->
            QName = expand_qname(NameP, NameL, LastNss),
            State2 = State1#ys_state{
                position = [content | P],
                tags = [QName | Tags],
                inscope_ns = [LastNss | Nss],
                rest_stream = Bytes2
            },
            yaccety_sax:event_startElement(QName, [], [], State2);
        <<$//utf8, Rest/bitstring>> ->
            QName = expand_qname(NameP, NameL, LastNss),
            parse_element_empty(
                Rest,
                Stream1,
                Pos1 + 1,
                State1,
                QName,
                [],
                [],
                P,
                Tags
            );
        _ ->
            {{Ns, As}, ?MATCH2} = parse_attributes(
                ?MATCH1,
                [],
                [],
                {NameP, NameL},
                []
            ),
            NewNsMap = namespace_map_from_list(Ns),
            NamespaceMap = merge_namespaces(LastNss, NewNsMap),
            QName = expand_qname(NameP, NameL, NamespaceMap),
            As1 = qualify_attribute_names(As, NamespaceMap),
            ok = check_attributes(As1, State2),
            case Bytes2 of
                <<$>/utf8, Bytes3/bitstring>> ->
                    State3 = State2#ys_state{
                        position = [content | P],
                        tags = [QName | Tags],
                        inscope_ns = [NamespaceMap | Nss],
                        rest_stream = Bytes3
                    },
                    yaccety_sax:event_startElement(QName, As1, Ns, State3);
                <<$//utf8, Rest/bitstring>> ->
                    parse_element_empty(
                        Rest,
                        Stream2,
                        Pos2 + 1,
                        State2,
                        QName,
                        As1,
                        Ns,
                        P,
                        Tags
                    );
                _ ->
                    fatal_error(bad_element, State2)
            end
    end;
parse_element_lt(?MATCH) ->
    #ys_state{
        tags = Tags,
        inscope_ns = [LastNss | _] = Nss,
        position = P,
        dtd = DTD
    } = State,
    {{NameP, NameL}, ?MATCH1} = parse_QName(?MATCH),
    DTDAtts =
        case DTD of
            #{atts := #{{NameP, NameL} := AttList}} -> AttList;
            _ -> []
        end,
    {{Ns, As}, ?MATCH2} = parse_attributes(
        ?MATCH1,
        [],
        [],
        {NameP, NameL},
        DTDAtts
    ),
    NewNsMap = namespace_map_from_list(Ns),
    NamespaceMap = merge_namespaces(LastNss, NewNsMap),
    QName = expand_qname(NameP, NameL, NamespaceMap),
    As1 = qualify_attribute_names(As, NamespaceMap),
    ok = check_attributes(As1, State2),
    case Bytes2 of
        <<$>/utf8, Bytes3/bitstring>> ->
            State3 = State2#ys_state{
                position = [content | P],
                tags = [QName | Tags],
                inscope_ns = [NamespaceMap | Nss],
                rest_stream = Bytes3,
                in_replacement = false
            },
            yaccety_sax:event_startElement(QName, As1, Ns, State3);
        <<$//utf8, Rest/bitstring>> ->
            parse_element_empty(
                Rest,
                Stream2,
                Pos2 + 1,
                State2,
                QName,
                As1,
                Ns,
                P,
                Tags
            );
        _ ->
            fatal_error(bad_element, State2)
    end.

check_attributes([], _State) -> ok;
check_attributes(Atts, State) -> check_attributes(Atts, #{}, State).

check_attributes([{{?XML_NS, <<"xml">>, <<"space">>}, Value} | _], _, State) when
    Value =/= <<"preserve">>, Value =/= <<"default">>
->
    fatal_error(bad_xml_space, State);
check_attributes([{{Ns, _, Ln}, _} | _], Acc, State) when is_map_key({Ns, Ln}, Acc) ->
    fatal_error(duplicate_attribute, {{Ns, Ln}, State});
check_attributes([{{Ns, _, Ln}, _} | Atts], Acc, State) ->
    check_attributes(Atts, Acc#{{Ns, Ln} => []}, State);
check_attributes([], _, _) ->
    ok.

parse_element_empty_no_ns(<<$>, Bytes/bitstring>>, _, _, State, QName, Ats, P, Tags) ->
    Pss =
        case P of
            % Empty root element
            [element | Ps] -> [empty, misc_post_element | Ps];
            _ -> [empty | P]
        end,
    State1 = State#ys_state{
        position = Pss,
        tags = [QName | Tags],
        rest_stream = Bytes
    },
    yaccety_sax:event_startElement(QName, Ats, [], State1);
parse_element_empty_no_ns(<<>>, _, _, State, Name, Ats, P, Tags) ->
    {Stream1, State1} = cf(State),
    parse_element_empty_no_ns(Stream1, Stream1, 0, State1, Name, Ats, P, Tags);
parse_element_empty_no_ns(_, _, _, State, _, _, _, _) ->
    fatal_error(bad_element, State).

% misc_post_element
parse_element_empty(<<$>, Bytes/bitstring>>, _, _, State, QName, Ats, Nss, P, Tags) ->
    Pss =
        case P of
            % Empty root element
            [element | Ps] -> [empty, misc_post_element | Ps];
            _ -> [empty | P]
        end,
    State1 = State#ys_state{
        position = Pss,
        tags = [QName | Tags],
        rest_stream = Bytes
    },
    yaccety_sax:event_startElement(QName, Ats, Nss, State1);
parse_element_empty(<<>>, _, _, State, Name, Ats, Nss, P, Tags) ->
    {Stream1, State1} = cf(State),
    parse_element_empty(Stream1, Stream1, 0, State1, Name, Ats, Nss, P, Tags);
parse_element_empty(_, _, _, State, _, _, _, _, _) ->
    fatal_error(bad_element, State).

%%----------------------------------------------------------------------
%% [41] Attribute ::= Name Eq AttValue
%% [WFC: No External Entity References]
%% [WFC: No < in Attribute Values]
%% Initial S is trimmed, first character is not ">" or "/"
%% [1ns]  NSAttName           ::=       PrefixedAttName | DefaultAttName
%% [2ns]  PrefixedAttName     ::=       'xmlns:' NCName
%%    [NSC: Reserved Prefixes and Namespace Names]
%% [3ns]  DefaultAttName      ::=       'xmlns'
%% [15ns] Attribute           ::=       NSAttName Eq AttValue | QName Eq AttValue
%%    [NSC: Prefix Declared]
%%    [NSC: No Prefix Undeclaring]
%%    [NSC: Attributes Unique]
%%    [VC: Attribute Value Type]
%%----------------------------------------------------------------------
parse_Attribute(?MATCH) ->
    {{P, L}, ?MATCH1} = parse_QName(?MATCH),
    {Bytes2, Stream2, Pos2, State2} = parse_Eq(?MATCH1),
    {Value, ?MATCH3} = parse_AttValue(?MATCH2),
    {{P, L, Value}, ?MATCH3}.

parse_attributes_no_ns(Bytes = <<$>/utf8, _/bitstring>>, Stream, Pos, State, Atts) ->
    {Atts, ?MATCH};
parse_attributes_no_ns(?MATCH, Atts) ->
    case maybe_consume_s(?MATCH) of
        {false, ?MATCH1} ->
            {Atts, ?MATCH1};
        {true, <<C/utf8, _/bitstring>> = ?MATCH1} when C == $>; C == $/ ->
            {Atts, ?MATCH1};
        {true, ?MATCH1} ->
            {{P, L, Value}, ?MATCH2} = parse_Attribute(?MATCH1),
            parse_attributes_no_ns(?MATCH2, [{{<<>>, P, L}, Value} | Atts])
    end.

fill_default_attributes(Atts, [], _) ->
    Atts;
fill_default_attributes(Atts, DAtts, State) ->
    [
        {Px, Ln,
            case Type of
                cdata -> Fixed2;
                _ -> normalize_attribute_value(Fixed2)
            end}
     || {{Px, Ln}, {Type, {DefType, Fixed}}} <- maps:to_list(DAtts),
        DefType == value orelse DefType == fixed,
        Fixed2 <- [parse_AttValue_x(Fixed, Fixed, 0, 0, State, [])]
    ] ++ Atts.

parse_attributes(Bytes = <<$>/utf8, _/bitstring>>, Stream, Pos, State, Nss, Atts, _, AttList) ->
    NewAtts = fill_default_attributes(Atts, AttList, State),
    {{Nss, NewAtts}, ?MATCH};
parse_attributes(?MATCH, Nss, Atts, EName, AttList) ->
    case maybe_consume_s(?MATCH) of
        {false, ?MATCH1} ->
            NewAtts = fill_default_attributes(Atts, AttList, State1),
            {{Nss, NewAtts}, ?MATCH1};
        {true, <<C/utf8, _/bitstring>> = ?MATCH1} when C == $>; C == $/ ->
            NewAtts = fill_default_attributes(Atts, AttList, State1),
            {{Nss, NewAtts}, ?MATCH1};
        {true, ?MATCH1} ->
            {Att, ?MATCH2} = parse_Attribute(?MATCH1),
            parse_attributes_(Att, ?MATCH2, Nss, Atts, EName, AttList)
    end.

parse_attributes_({<<>>, <<"xmlns">>, ?XML_NS}, _, _, _, State, _, _, _, _) ->
    fatal_error(rebinding_prefix, {<<"xml">>, State});
parse_attributes_({<<>>, <<"xmlns">>, ?XMLNS_NS}, _, _, _, State, _, _, _, _) ->
    fatal_error(rebinding_prefix, {<<"xmlns">>, State});
parse_attributes_({<<>>, <<"xmlns">>, Val}, ?MATCH, Nss, Atts, EName, AttList) ->
    parse_attributes(?MATCH, [{normalize_attribute_value(Val), <<>>} | Nss], Atts, EName, AttList);
parse_attributes_({<<"xmlns">>, Px, <<>>}, _, _, _, State, _, _, _, _) ->
    fatal_error(unbinding_prefix, {Px, State});
parse_attributes_({<<"xmlns">>, <<"xml">>, Val}, _, _, _, State, _, _, _, _) when Val =/= ?XML_NS ->
    fatal_error(rebinding_prefix, {<<"xml">>, State});
parse_attributes_({<<"xmlns">>, Px, ?XML_NS}, _, _, _, State, _, _, _, _) when Px =/= <<"xml">> ->
    fatal_error(rebinding_prefix, {<<"xml">>, State});
parse_attributes_({<<"xmlns">>, _, ?XMLNS_NS}, _, _, _, State, _, _, _, _) ->
    fatal_error(rebinding_prefix, {<<"xmlns">>, State});
parse_attributes_({<<"xmlns">>, <<"xmlns">>, _}, _, _, _, State, _, _, _, _) ->
    fatal_error(rebinding_prefix, {<<"xmlns">>, State});
parse_attributes_({<<"xmlns">>, Px, Val}, ?MATCH, Nss, Atts, EName, AttList) ->
    parse_attributes(?MATCH, [{normalize_attribute_value(Val), Px} | Nss], Atts, EName, AttList);
parse_attributes_(Other, ?MATCH, Nss, Atts, EName, []) ->
    parse_attributes(?MATCH, Nss, [Other | Atts], EName, []);
parse_attributes_({Px, Ln, Val}, ?MATCH, Nss, Atts, EName, AttList) ->
    {Norm, AttList1} =
        case AttList of
            #{{Px, Ln} := {_, cdata, _}} ->
                {Val, maps:remove({Px, Ln}, AttList)};
            #{{Px, Ln} := {cdata, _}} ->
                {Val, maps:remove({Px, Ln}, AttList)};
            #{{Px, Ln} := _} ->
                {normalize_attribute_value(Val), maps:remove({Px, Ln}, AttList)};
            _ ->
                {Val, AttList}
        end,
    parse_attributes(?MATCH, Nss, [{Px, Ln, Norm} | Atts], EName, AttList1).

%%----------------------------------------------------------------------
%% [10] AttValue ::= '"' ([^<&"] | Reference)* '"' |  "'" ([^<&'] | Reference)* "'"
%%----------------------------------------------------------------------
parse_AttValue(<<$'/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_AttValue_sq(Rest, Stream, Pos + 1, 0, State, []);
parse_AttValue(<<$"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_AttValue_dq(Rest, Stream, Pos + 1, 0, State, []);
parse_AttValue(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_AttValue(Stream1, Stream1, 0, State1);
parse_AttValue(_, _, _, State) ->
    fatal_error(bad_attval, State).

parse_AttValue_x(
    <<$\r, $\n, Rest/bitstring>>,
    Stream,
    Pos,
    Len,
    #ys_state{in_replacement = false} = State,
    Acc
) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
parse_AttValue_x(<<$</utf8, _/bitstring>>, _, _, _, State, _Acc) ->
    fatal_error(bad_attval, State);
parse_AttValue_x(<<$&/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    case parse_Reference(Rest, Stream, Pos + Len + 1, State, attribute) of
        {{Name, {replacement_text, Ref}}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, 0, RTState, Acc1);
        {{gen, Ref}, ?MATCH1} ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
        {{Type, Ref}, ?MATCH1} when Type == hex; Type == dec ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
        {{Name, Ref}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, 0, RTState, Acc1)
    end;
parse_AttValue_x(<<>>, Stream, Pos, Len, _State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    to_binary(Acc1);
parse_AttValue_x(<<Char, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when ?WS(Char) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
?ONECHAR.

parse_AttValue_sq(
    <<$', Rest/bitstring>>,
    Stream,
    Pos,
    Len,
    #ys_state{in_replacement = true} = State,
    Acc
) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc);
parse_AttValue_sq(
    <<$\r, $\n, Rest/bitstring>>,
    Stream,
    Pos,
    Len,
    #ys_state{in_replacement = false} = State,
    Acc
) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
parse_AttValue_sq(<<$\r>>, Stream, Pos, Len, #ys_state{in_replacement = false} = State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    case cf(State) of
        {<<$\n, Rest/bitstring>> = Stream1, State1} ->
            Acc2 = ?APPEND(<<$\s>>, Acc1),
            ?FUNCTION_NAME(Rest, Stream1, 1, 0, State1, Acc2);
        {Stream1, State1} ->
            Acc2 = ?APPEND(<<$\s>>, Acc1),
            ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc2)
    end;
parse_AttValue_sq(<<$'/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Value = ?ACC(Stream, Pos, Len, Acc),
    {to_binary(Value), Rest, Stream, Pos + Len + 1, State};
parse_AttValue_sq(<<$</utf8, _/bitstring>>, _, _, _, State, _Acc) ->
    fatal_error(bad_attval, State);
parse_AttValue_sq(<<$&/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    case parse_Reference(Rest, Stream, Pos + Len + 1, State, attribute) of
        {{Name, {replacement_text, Ref}}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, 0, RTState, Acc1);
        {{gen, Ref}, ?MATCH1} ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
        {{Type, Ref}, ?MATCH1} when Type == hex; Type == dec ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
        {{Name, Ref}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, 0, RTState, Acc1)
    end;
parse_AttValue_sq(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc1);
parse_AttValue_sq(<<Char, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when ?WS(Char) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
?ONECHAR.

parse_AttValue_dq(
    <<$", Rest/bitstring>>, Stream, Pos, Len, #ys_state{in_replacement = true} = State, Acc
) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc);
parse_AttValue_dq(
    <<$\r, $\n, Rest/bitstring>>, Stream, Pos, Len, #ys_state{in_replacement = false} = State, Acc
) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
parse_AttValue_dq(<<$\r>>, Stream, Pos, Len, #ys_state{in_replacement = false} = State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    case cf(State) of
        {<<$\n, Rest/bitstring>> = Stream1, State1} ->
            Acc2 = ?APPEND(<<$\s>>, Acc1),
            ?FUNCTION_NAME(Rest, Stream1, 1, 0, State1, Acc2);
        {Stream1, State1} ->
            Acc2 = ?APPEND(<<$\s>>, Acc1),
            ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc2)
    end;
parse_AttValue_dq(<<$"/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Value = ?ACC(Stream, Pos, Len, Acc),
    {to_binary(Value), Rest, Stream, Pos + Len + 1, State};
parse_AttValue_dq(<<$</utf8, _/bitstring>>, _, _, _, State, _Acc) ->
    fatal_error(bad_attval, State);
parse_AttValue_dq(<<$&/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    case parse_Reference(Rest, Stream, Pos + Len + 1, State, attribute) of
        {{Name, {replacement_text, Ref}}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, 0, RTState, Acc1);
        {{gen, Ref}, ?MATCH1} ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
        {{Type, Ref}, ?MATCH1} when Type == hex; Type == dec ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
        {{Name, Ref}, Bytes1, _, _, State1} ->
            RTState = replacement_text_state(Bytes1, State1, Name),
            ?FUNCTION_NAME(Ref, Ref, 0, 0, RTState, Acc1)
    end;
parse_AttValue_dq(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc1);
parse_AttValue_dq(<<Char, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when ?WS(Char) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
?ONECHAR.

parse_AttValue(<<$'/utf8, Rest/bitstring>>, Stream, Pos, State, DTD, External) ->
    parse_AttValue_sq(Rest, Stream, Pos + 1, 0, State, [], DTD, External);
parse_AttValue(<<$"/utf8, Rest/bitstring>>, Stream, Pos, State, DTD, External) ->
    parse_AttValue_dq(Rest, Stream, Pos + 1, 0, State, [], DTD, External);
parse_AttValue(<<>>, _, _, State, DTD, External) ->
    {Stream1, State1} = cf(State),
    parse_AttValue(Stream1, Stream1, 0, State1, DTD, External);
parse_AttValue(_, _, _, State, _DTD, _External) ->
    fatal_error(bad_attval, State).

parse_AttValue_sq(
    <<$', Rest/bitstring>>,
    Stream,
    Pos,
    Len,
    #ys_state{in_replacement = true} = State,
    Acc,
    DTD,
    External
) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc, DTD, External);
parse_AttValue_sq(<<$'/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc, _DTD, _External) ->
    Value = ?ACC(Stream, Pos, Len, Acc),
    {to_binary(Value), Rest, Stream, Pos + Len + 1, State};
parse_AttValue_sq(<<$</utf8, _/bitstring>>, _, _, _, State, _Acc, _, _) ->
    fatal_error(bad_attval, State);
parse_AttValue_sq(<<$&/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, External) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    case parse_Reference(Rest, Stream, Pos + Len + 1, State#ys_state{dtd = DTD}, attribute) of
        {{Name, {replacement_text, _Ref}}, ?MATCH1} ->
            Acc2 = ?APPEND([$&, Name, $;], Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{gen, Ref}, ?MATCH1} ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{Type, Ref}, ?MATCH1} when Type == hex; Type == dec ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{Name, _Ref}, ?MATCH1} ->
            Acc2 = ?APPEND([$&, Name, $;], Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External)
    end;
parse_AttValue_sq(<<>>, Stream, Pos, Len, State, Acc, DTD, External) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc1, DTD, External);
parse_AttValue_sq(<<Char, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, External) when
    ?WS(Char)
->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2, DTD, External);
?ONECHARX.

parse_AttValue_dq(
    <<$", Rest/bitstring>>,
    Stream,
    Pos,
    Len,
    #ys_state{in_replacement = true} = State,
    Acc,
    DTD,
    External
) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc, DTD, External);
parse_AttValue_dq(<<$"/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc, _DTD, _External) ->
    Value = ?ACC(Stream, Pos, Len, Acc),
    {to_binary(Value), Rest, Stream, Pos + Len + 1, State};
parse_AttValue_dq(<<$</utf8, _/bitstring>>, _, _, _, State, _Acc, _, _) ->
    fatal_error(bad_attval, State);
parse_AttValue_dq(<<$&/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, External) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    case parse_Reference(Rest, Stream, Pos + Len + 1, State#ys_state{dtd = DTD}, attribute) of
        {{Name, {replacement_text, _Ref}}, ?MATCH1} ->
            Acc2 = ?APPEND([$&, Name, $;], Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{gen, Ref}, ?MATCH1} ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{Type, Ref}, ?MATCH1} when Type == hex; Type == dec ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{Name, _Ref}, ?MATCH1} ->
            Acc2 = ?APPEND([$&, Name, $;], Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External)
    end;
parse_AttValue_dq(<<>>, Stream, Pos, Len, State, Acc, DTD, External) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc1, DTD, External);
parse_AttValue_dq(<<Char, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, External) when
    ?WS(Char)
->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2, DTD, External);
?ONECHARX.

normalize_attribute_value(Value) ->
    Tokens = get_tokens(Value, Value, 0),
    Comb = combine_tokens(Tokens),
    to_binary(Comb).

get_tokens(<<>>, _, _) -> [];
get_tokens(<<$\s, Rest/bitstring>>, Value, Pos) -> get_tokens(Rest, Value, Pos + 1);
get_tokens(Bytes, Value, Pos) -> get_tokens(Bytes, Value, Pos, 0, []).

get_tokens(<<$\s, Rest/bitstring>>, Value, Pos, 0, Acc) ->
    get_tokens(Rest, Value, Pos + 1, 0, Acc);
get_tokens(<<$\s, Rest/bitstring>>, Value, Pos, Len, Acc) ->
    get_tokens(Rest, Value, Pos + Len + 1, 0, [binary_part(Value, Pos, Len) | Acc]);
get_tokens(<<_, Rest/bitstring>>, Value, Pos, Len, Acc) ->
    get_tokens(Rest, Value, Pos, Len + 1, Acc);
get_tokens(<<>>, _, _, 0, Acc) ->
    Acc;
get_tokens(<<>>, Value, Pos, Len, Acc) ->
    [binary_part(Value, Pos, Len) | Acc].

combine_tokens([]) -> <<>>;
combine_tokens([Token]) -> Token;
combine_tokens([Token | Rest]) -> combine_tokens(Rest, [Token]).

combine_tokens([], Acc) -> Acc;
combine_tokens([Token | Tokens], Acc) -> combine_tokens(Tokens, [Token | [<<$\s>> | Acc]]).

%%----------------------------------------------------------------------
%% -[42] ETag ::= '</' Name S? '>'
%% +[13ns] ETag ::= '</' QName S? '>'  [NSC: Prefix Declared]
%% '</' is already trimmed
%%----------------------------------------------------------------------
parse_ETag(
    Bytes,
    Stream,
    Pos,
    #ys_state{inscope_ns = [Ns | Nss], position = [_, element | _Ps1], tags = [Tag | Ts]} = State
) ->
    {{NameP, NameL}, ?MATCH1} = parse_QName(?MATCH),
    {_, Bytes2, _, _, State2} = maybe_consume_s(?MATCH1),
    case Bytes2 of
        <<$>/utf8, Bytes3/bitstring>> ->
            QName = expand_qname(NameP, NameL, Ns),
            State3 = State2#ys_state{inscope_ns = Nss, position = [misc_post_element], tags = Ts},
            case QName of
                Tag ->
                    yaccety_sax:event_endElement(QName, set_state_pos(State3, Bytes3));
                _ ->
                    fatal_error(unmatched_tag, {Tag, QName})
            end;
        _ ->
            fatal_error(bad_endtag, State2)
    end;
parse_ETag(
    Bytes,
    Stream,
    Pos,
    #ys_state{inscope_ns = [Ns | Nss], position = [_ | Ps], tags = [Tag | Ts]} = State
) ->
    {{NameP, NameL}, ?MATCH1} = parse_QName(?MATCH),
    case Bytes1 of
        <<$>/utf8, Bytes2/bitstring>> ->
            QName = expand_qname(NameP, NameL, Ns),
            State2 = State1#ys_state{inscope_ns = Nss, position = Ps, tags = Ts},
            case QName of
                Tag ->
                    yaccety_sax:event_endElement(QName, set_state_pos(State2, Bytes2));
                _ ->
                    fatal_error(unmatched_tag, {Tag, QName})
            end;
        _ ->
            {_, Bytes2, _, _, State2} = maybe_consume_s(?MATCH1),
            case Bytes2 of
                <<$>/utf8, Bytes3/bitstring>> ->
                    QName = expand_qname(NameP, NameL, Ns),
                    State3 = State2#ys_state{inscope_ns = Nss, position = Ps, tags = Ts},
                    case QName of
                        Tag ->
                            yaccety_sax:event_endElement(
                                QName,
                                set_state_pos(State3, Bytes3)
                            );
                        _ ->
                            fatal_error(unmatched_tag, {Tag, QName})
                    end;
                _ ->
                    fatal_error(bad_endtag, State2)
            end
    end.

parse_ETag_no_ns(
    Bytes,
    Stream,
    Pos,
    #ys_state{position = [_, element | _Ps1], tags = [Tag | Ts]} = State
) ->
    {{NameP, NameL}, ?MATCH1} = parse_QName(?MATCH),
    {_, Bytes2, _, _, State2} = maybe_consume_s(?MATCH1),
    case Bytes2 of
        <<$>/utf8, Bytes3/bitstring>> ->
            QName = {<<>>, NameP, NameL},
            State3 = State2#ys_state{position = [misc_post_element], tags = Ts},
            case QName of
                Tag ->
                    yaccety_sax:event_endElement(QName, set_state_pos(State3, Bytes3));
                _ ->
                    fatal_error(unmatched_tag, {Tag, QName})
            end;
        _ ->
            fatal_error(bad_endtag, State2)
    end;
parse_ETag_no_ns(
    Bytes,
    Stream,
    Pos,
    #ys_state{position = [_ | Ps], tags = [Tag | Ts]} = State
) ->
    {{NameP, NameL}, ?MATCH1} = parse_QName(?MATCH),
    case Bytes1 of
        <<$>/utf8, Bytes2/bitstring>> ->
            QName = {<<>>, NameP, NameL},
            State2 = State1#ys_state{position = Ps, tags = Ts},
            case QName of
                Tag ->
                    yaccety_sax:event_endElement(QName, set_state_pos(State2, Bytes2));
                _ ->
                    fatal_error(unmatched_tag, {Tag, QName})
            end;
        _ ->
            {_, Bytes2, _, _, State2} = maybe_consume_s(?MATCH1),
            case Bytes2 of
                <<$>/utf8, Bytes3/bitstring>> ->
                    QName = {<<>>, NameP, NameL},
                    State3 = State2#ys_state{position = Ps, tags = Ts},
                    case QName of
                        Tag ->
                            yaccety_sax:event_endElement(
                                QName,
                                set_state_pos(State3, Bytes3)
                            );
                        _ ->
                            fatal_error(unmatched_tag, {Tag, QName})
                    end;
                _ ->
                    fatal_error(bad_endtag, State2)
            end
    end.

%%----------------------------------------------------------------------
%% [4ns]  NCName ::= Name - (Char* ':' Char*)  /* An XML Name, minus the ":" */
%%----------------------------------------------------------------------
parse_NCName(<<Char/utf8, Rest/bitstring>>, Stream, Pos, State) when
    Char >= $a, Char =< $z; Char >= $A, Char =< $Z; Char == $_
->
    parse_NCName(Rest, Stream, Pos, 1, State, []);
parse_NCName(<<Char/utf8, Rest/bitstring>>, Stream, Pos, State) when
    Char >= 16#C0, Char =< 16#D6;
    Char >= 16#D8, Char =< 16#F6;
    Char >= 16#F8, Char =< 16#2FF;
    Char >= 16#370, Char =< 16#37D;
    Char >= 16#37F, Char =< 16#7FF
->
    parse_NCName(Rest, Stream, Pos, 2, State, []);
parse_NCName(<<Char/utf8, Rest/bitstring>>, Stream, Pos, State) when
    Char >= 16#800, Char =< 16#1FFF;
    Char >= 16#200C, Char =< 16#200D;
    Char >= 16#2070, Char =< 16#218F;
    Char >= 16#2C00, Char =< 16#2FEF;
    Char >= 16#3001, Char =< 16#D7FF;
    Char >= 16#F900, Char =< 16#FDCF;
    Char >= 16#FDF0, Char =< 16#FFFD
->
    parse_NCName(Rest, Stream, Pos, 3, State, []);
parse_NCName(<<Char/utf8, Rest/bitstring>>, Stream, Pos, State) when
    Char >= 16#10000, Char =< 16#EFFFF
->
    parse_NCName(Rest, Stream, Pos, 4, State, []);
parse_NCName(<<Char/utf8, _Rest/bitstring>>, _, _, _) ->
    fatal_error(bad_name, Char);
parse_NCName(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_NCName(Stream1, Stream1, 0, State1);
parse_NCName(Bytes = <<30:5, _:3>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(3, parse_Name);
parse_NCName(Bytes = <<30:5, _:3, 2:2, _:6>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(2, parse_Name);
parse_NCName(Bytes = <<14:4, _:4>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(2, parse_Name);
parse_NCName(Bytes = <<30:5, _:3, 2:2, _:6, 2:2, _:6>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(1, parse_Name);
parse_NCName(Bytes = <<14:4, _:4, 2:2, _:6>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(1, parse_Name);
parse_NCName(Bytes = <<6:3, _:5>>, _, _, State) ->
    ?FSTNAMECHARPARTFUN(1, parse_Name);
parse_NCName(_, _, _, State) ->
    fatal_error(bad_name, State).

-define(NCNameChar(Char),
    ((Char >= $a andalso Char =< $z) orelse
        (Char >= $A andalso Char =< $Z) orelse
        Char == $_ orelse
        Char == $- orelse
        (Char >= $0 andalso Char =< $9) orelse
        Char == $.)
).

parse_NCName(<<Char, Char1, Char2, Char3, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when
    ?NCNameChar(Char) andalso
        ?NCNameChar(Char1) andalso ?NCNameChar(Char2) andalso ?NCNameChar(Char3)
->
    parse_NCName(Rest, Stream, Pos, Len + 4, State, Acc);
parse_NCName(<<Char, Char1, Char2, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when
    ?NCNameChar(Char) andalso ?NCNameChar(Char1) andalso ?NCNameChar(Char2)
->
    parse_NCName(Rest, Stream, Pos, Len + 3, State, Acc);
parse_NCName(<<Char, Char1, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when
    ?NCNameChar(Char) andalso ?NCNameChar(Char1)
->
    parse_NCName(Rest, Stream, Pos, Len + 2, State, Acc);
parse_NCName(<<Char, Rest/bitstring>>, Stream, Pos, Len, State, Acc) when ?NCNameChar(Char) ->
    parse_NCName(Rest, Stream, Pos, Len + 1, State, Acc);
parse_NCName(<<Char, _/bitstring>> = Bytes, Stream, Pos, Len, State, Acc) when Char < 16#80 ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {to_binary(Acc1), Bytes, Stream, Pos + Len, State};
parse_NCName(<<Char/utf8, Rest/bitstring>> = Bytes, Stream, Pos, Len, State, Acc) ->
    if
        Char == 16#B7;
        Char >= 16#C0, Char =< 16#D6;
        Char >= 16#D8, Char =< 16#F6;
        Char >= 16#F8, Char =< 16#37D;
        Char >= 16#37F, Char =< 16#7FF ->
            parse_NCName(Rest, Stream, Pos, Len + 2, State, Acc);
        Char < 16#800 ->
            Acc1 = ?ACC(Stream, Pos, Len, Acc),
            {Acc1, Bytes, Stream, Pos + Len, State};
        Char >= 16#800, Char =< 16#1FFF;
        Char >= 16#200C, Char =< 16#200D;
        Char >= 16#203F, Char =< 16#2040;
        Char >= 16#2070, Char =< 16#218F;
        Char >= 16#2C00, Char =< 16#2FEF;
        Char >= 16#3001, Char =< 16#D7FF;
        Char >= 16#F900, Char =< 16#FDCF;
        Char >= 16#FDF0, Char =< 16#FFFD ->
            parse_NCName(Rest, Stream, Pos, Len + 3, State, Acc);
        Char >= 16#10000, Char =< 16#EFFFF ->
            parse_NCName(Rest, Stream, Pos, Len + 4, State, Acc);
        true ->
            Acc1 = ?ACC(Stream, Pos, Len, Acc),
            {to_binary(Acc1), Bytes, Stream, Pos + Len, State}
    end;
parse_NCName(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_NCName(Stream1, Stream1, 0, 0, State1, Acc1);
parse_NCName(Bytes = <<30:5, _:3>>, Stream, Pos, Len, State, Acc) ->
    ?NAMECHARPARTFUN(3);
parse_NCName(Bytes = <<30:5, _:3, 2:2, _:6>>, Stream, Pos, Len, State, Acc) ->
    ?NAMECHARPARTFUN(2);
parse_NCName(Bytes = <<14:4, _:4>>, Stream, Pos, Len, State, Acc) ->
    ?NAMECHARPARTFUN(2);
parse_NCName(Bytes = <<30:5, _:3, 2:2, _:6, 2:2, _:6>>, Stream, Pos, Len, State, Acc) ->
    ?NAMECHARPARTFUN(1);
parse_NCName(Bytes = <<14:4, _:4, 2:2, _:6>>, Stream, Pos, Len, State, Acc) ->
    ?NAMECHARPARTFUN(1);
parse_NCName(Bytes = <<6:3, _:5>>, Stream, Pos, Len, State, Acc) ->
    ?NAMECHARPARTFUN(1);
parse_NCName(Bytes, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {to_binary(Acc1), Bytes, Stream, Pos + Len, State}.

%%----------------------------------------------------------------------
%% [7ns]  QName               ::=       PrefixedName | UnprefixedName
%% [8ns]  PrefixedName        ::=       Prefix ':' LocalPart
%% [9ns]  UnprefixedName      ::=       LocalPart
%% [10ns] Prefix              ::=       NCName
%% [11ns] LocalPart           ::=       NCName
%%----------------------------------------------------------------------
parse_QName(?MATCH) ->
    {Name1, ?MATCH1} = parse_NCName(?MATCH),
    case Bytes1 of
        <<$:/utf8, Rest/bitstring>> ->
            {Name2, ?MATCH2} = parse_NCName(Rest, Stream1, Pos1 + 1, State1),
            {{to_binary(Name1), to_binary(Name2)}, ?MATCH2};
        _ ->
            {{<<>>, to_binary(Name1)}, ?MATCH1}
    end.

parse_QName(<<"%", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {PERef, Bytes1, _, _, State1} = parse_PEReference(Bytes, Stream, Pos + 1, State),
    case resolve_parameter_entity(PERef, DTD, State1, false, true) of
        {replacement_text, ReplacementText} ->
            RTState = replacement_text_state(Bytes1, State1),
            {_, ?MATCH2} = maybe_consume_s(ReplacementText, ReplacementText, 0, RTState),
            parse_QName(?MATCH2, DTD)
    end;
parse_QName(?MATCH, _) ->
    parse_QName(?MATCH).

qualify_attribute_names([], _) -> [];
qualify_attribute_names(Atts, Nss) -> [{expand_attribute_qname(P, L, Nss), V} || {P, L, V} <- Atts].

expand_qname(<<>>, L, none) ->
    {<<>>, <<>>, L};
expand_qname(<<"xml">>, L, _) ->
    {?XML_NS, <<"xml">>, L};
expand_qname(P, L, Nss) ->
    case Nss of
        #{P := N} ->
            {N, P, L};
        _ ->
            fatal_error(unknown_prefix, P)
    end.

expand_attribute_qname(<<>>, L, _) -> {<<>>, <<>>, L};
expand_attribute_qname(P, L, Nss) -> expand_qname(P, L, Nss).

set_next_parser_position(Pos, #ys_state{position = S} = State) ->
    State#ys_state{position = [Pos | S]}.

namespace_map_from_list([]) -> none;
namespace_map_from_list(List) -> namespace_map_from_list(List, #{}).

namespace_map_from_list([{_, P} | _], Map) when is_map_key(Map, P) ->
    fatal_error(duplicate_prefix, P);
namespace_map_from_list([{U, P} | T], Map) ->
    namespace_map_from_list(T, Map#{P => U});
namespace_map_from_list([], Map) ->
    Map.

merge_namespaces(none, none) -> none;
merge_namespaces(none, NewNsMap) -> maps:merge(#{<<>> => <<>>}, NewNsMap);
merge_namespaces(LastNss, none) -> LastNss;
merge_namespaces(LastNss, NewNsMap) -> maps:merge(LastNss, NewNsMap).

fatal_error(Reason, State) -> error(Reason, [State]).

set_state_pos(State, Bytes) -> State#ys_state{rest_stream = Bytes}.

%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%
%%                                                                                                                   %%
%%                                                  DTD Stuff                                                        %%
%%                                                                                                                   %%
%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%

%%----------------------------------------------------------------------
%% [16ns] doctypedecl ::= '<!DOCTYPE' S QName (S ExternalID)? S? ('[' (markupdecl | PEReference | S)* ']' S?)? '>'  [VC: Root Element Type]
%%----------------------------------------------------------------------
parse_doctypedecl(Stream, #ys_state{dtd = undefined} = State) ->
    parse_doctypedecl(Stream, Stream, 0, State);
parse_doctypedecl(Stream, #ys_state{dtd = DTD} = State) ->
    {#{pi_comments := PiCms} = DTD1, Bytes1, _, _, State1} = parse_intSubset(
        Stream, Stream, 0, State#ys_state{dtd = undefined}, DTD
    ),
    yaccety_sax:event_dtd(
        DTD1,
        set_state_pos(State1#ys_state{dtd = DTD1#{pi_comments := lists:reverse(PiCms)}}, Bytes1)
    ).

parse_doctypedecl(<<"<!DOCTYPE"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_doctypedecl_ltexDOCTYPE(Rest, Stream, Pos + 9, State);
parse_doctypedecl(<<"<!DOCTYP"/utf8>>, _, _, State) ->
    parse_doctypedecl_ltexDOCTYP(cf(State));
parse_doctypedecl(<<"<!DOCTY"/utf8>>, _, _, State) ->
    parse_doctypedecl_ltexDOCTY(cf(State));
parse_doctypedecl(<<"<!DOCT"/utf8>>, _, _, State) ->
    parse_doctypedecl_ltexDOCT(cf(State));
parse_doctypedecl(<<"<!DOC"/utf8>>, _, _, State) ->
    parse_doctypedecl_ltexDOC(cf(State));
parse_doctypedecl(<<"<!DO"/utf8>>, _, _, State) ->
    parse_doctypedecl_ltexDO(cf(State));
parse_doctypedecl(<<"<!D"/utf8>>, _, _, State) ->
    parse_doctypedecl_ltexD(cf(State));
parse_doctypedecl(<<"<!"/utf8>>, _, _, State) ->
    parse_doctypedecl_ltex(cf(State));
parse_doctypedecl(<<"<"/utf8>>, _, _, State) ->
    parse_doctypedecl_lt(cf(State));
parse_doctypedecl(_, _, _, State) ->
    State.

parse_doctypedecl_ltexDOCTYPE(?MATCH) ->
    {_, ?MATCH1} = consume_s(?MATCH),
    {QName, ?MATCH2} = parse_QName(?MATCH1),
    DTD = empty_proc_dtd(),
    DTD1 = set_dtd_name(DTD, QName),
    case maybe_consume_s(?MATCH2) of
        % Empty DTD
        {_, <<$>/utf8, Bytes3/bitstring>>, _, _, State3} ->
            State4 = State3#ys_state{dtd = DTD1},
            yaccety_sax:event_dtd(DTD1, set_state_pos(State4, Bytes3));
        % No ExternalID
        {_, <<$[/utf8, Bytes3/bitstring>>, Stream3, Pos3, State3} ->
            {DTD2, Bytes4, _, _, State4} = parse_intSubset(Bytes3, Stream3, Pos3 + 1, State3, DTD1),
            State5 = State4#ys_state{dtd = DTD2},
            yaccety_sax:event_dtd(DTD2, set_state_pos(State5, Bytes4));
        % Is ExternalID
        {true, ?MATCH3} ->
            {PubSys, ?MATCH4} = parse_ExternalID(
                Bytes3,
                Stream3,
                Pos3,
                State3
            ),
            {_, ?MATCH5} = maybe_consume_s(?MATCH4),
            DTD2 = set_dtd_external_id(DTD1, PubSys),
            case Bytes5 of
                <<$>/utf8, Bytes6/bitstring>> ->
                    DTD3 = maybe_parse_external_subset(State5, PubSys, DTD2),
                    State6 = State5#ys_state{dtd = DTD3},
                    yaccety_sax:event_dtd(DTD3, set_state_pos(State6, Bytes6));
                <<$[/utf8, Bytes5a/bitstring>> ->
                    {DTD3, Bytes6, _, _, State6} = parse_intSubset(
                        Bytes5a, Stream5, Pos5 + 1, State5, DTD2
                    ),
                    DTD4 = maybe_parse_external_subset(State6, PubSys, DTD3),
                    State7 = State6#ys_state{dtd = DTD4},
                    yaccety_sax:event_dtd(DTD4, set_state_pos(State7, Bytes6));
                _ ->
                    fatal_error(bad_dtd, {Bytes5, State5})
            end
    end.

% TODO: Make this lazy and only called if needed.
maybe_parse_external_subset(#ys_state{external = undefined}, _PubSys, DTD) ->
    DTD;
maybe_parse_external_subset(#ys_state{external = EntResolver, base = Base} = State, PubSys, DTD) ->
    {NewBase, Stream} = EntResolver(PubSys, Base),
    % Make sure the continuation is not called.
    {_, ?MATCH1} = parse_TextDecl(Stream, State#ys_state{continuation = undefined, base = NewBase}),
    {DTD1, Bytes2, _, _, State2} = parse_extSubsetDecl(?MATCH1, DTD),
    case Bytes2 of
        <<>> -> DTD1;
        _ -> fatal_error(bad_dtd, State2)
    end.

%%----------------------------------------------------------------------
%% [75] ExternalID ::= 'SYSTEM' S SystemLiteral | 'PUBLIC' S PubidLiteral S SystemLiteral
%% First byte is in stream.
%% return {Pub, Sys}
%%----------------------------------------------------------------------
parse_ExternalID(<<"SYSTEM", Rest/bitstring>>, Stream, Pos, State) ->
    parse_ExternalID_system(Rest, Stream, Pos + 6, State);
parse_ExternalID(<<"PUBLIC", Rest/bitstring>>, Stream, Pos, State) ->
    parse_ExternalID_public(Rest, Stream, Pos + 6, State);
parse_ExternalID(<<"SYSTE">>, _, _, State) ->
    parse_ExternalID_syste(cf(State));
parse_ExternalID(<<"SYST">>, _, _, State) ->
    parse_ExternalID_syst(cf(State));
parse_ExternalID(<<"SYS">>, _, _, State) ->
    parse_ExternalID_sys(cf(State));
parse_ExternalID(<<"SY">>, _, _, State) ->
    parse_ExternalID_sy(cf(State));
parse_ExternalID(<<"S">>, _, _, State) ->
    parse_ExternalID_s(cf(State));
parse_ExternalID(<<"PUBLI">>, _, _, State) ->
    parse_ExternalID_publi(cf(State));
parse_ExternalID(<<"PUBL">>, _, _, State) ->
    parse_ExternalID_publ(cf(State));
parse_ExternalID(<<"PUB">>, _, _, State) ->
    parse_ExternalID_pub(cf(State));
parse_ExternalID(<<"PU">>, _, _, State) ->
    parse_ExternalID_pu(cf(State));
parse_ExternalID(<<"P">>, _, _, State) ->
    parse_ExternalID_p(cf(State));
parse_ExternalID(?MATCH) ->
    {{<<>>, <<>>}, ?MATCH}.

parse_ExternalID_system(?MATCH) ->
    {_, ?MATCH1} = consume_s(?MATCH),
    {Sys, ?MATCH2} = parse_SystemLiteral(?MATCH1),
    {{<<>>, to_binary(Sys)}, ?MATCH2}.

parse_ExternalID_public(?MATCH) ->
    {_, ?MATCH1} = consume_s(?MATCH),
    {Pub, ?MATCH2} = parse_PubidLiteral(?MATCH1),
    {{_, Sys}, ?MATCH3} = parse_ExternalID_system(?MATCH2),
    {{Pub, Sys}, ?MATCH3}.

%%----------------------------------------------------------------------
%% [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
%%----------------------------------------------------------------------
parse_SystemLiteral(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_SystemLiteral(Stream1, Stream1, 0, State1);
parse_SystemLiteral(<<$'/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_SystemLiteral_sq(Rest, Stream, Pos + 1, 0, State, []);
parse_SystemLiteral(<<$"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_SystemLiteral_dq(Rest, Stream, Pos + 1, 0, State, []);
parse_SystemLiteral(Bytes, _, _, State) ->
    fatal_error(bad_sysid, {Bytes, State}).

parse_SystemLiteral_sq(<<$\r, $\n, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
?FUNCTION_NAME(<<$\r>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    case cf(State) of
        {<<$\n, Bytes1/bitstring>> = Stream1, State1} ->
            ?FUNCTION_NAME(Bytes1, Stream1, 1, 0, State1, Acc2);
        {Stream1, State1} ->
            ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc2)
    end;
parse_SystemLiteral_sq(<<$\r, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
parse_SystemLiteral_sq(<<$'>>, Stream, Pos, Len, State, Acc) ->
    Text = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    {Text, Stream1, Stream1, 0, State1};
parse_SystemLiteral_sq(<<$'/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Text = ?ACC(Stream, Pos, Len, Acc),
    {Text, Rest, Stream, Pos + Len + 1, State};
?ONECHAR.

parse_SystemLiteral_dq(<<$\r, $\n, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
?FUNCTION_NAME(<<$\r>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    case cf(State) of
        {<<$\n, Bytes1/bitstring>> = Stream1, State1} ->
            ?FUNCTION_NAME(Bytes1, Stream1, 1, 0, State1, Acc2);
        {Stream1, State1} ->
            ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc2)
    end;
parse_SystemLiteral_dq(<<$\r, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
parse_SystemLiteral_dq(<<$">>, Stream, Pos, Len, State, Acc) ->
    Text = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    {Text, Stream1, Stream1, 0, State1};
parse_SystemLiteral_dq(<<$"/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Text = ?ACC(Stream, Pos, Len, Acc),
    {Text, Rest, Stream, Pos + Len + 1, State};
?ONECHAR.

%%----------------------------------------------------------------------
%% [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
%%----------------------------------------------------------------------
parse_PubidLiteral(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    parse_PubidLiteral(Stream1, Stream1, 0, State1);
parse_PubidLiteral(<<$'/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_PubidLiteral_sq(Rest, Stream, Pos + 1, 0, State, []);
parse_PubidLiteral(<<$"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_PubidLiteral_dq(Rest, Stream, Pos + 1, 0, State, []);
parse_PubidLiteral(_, _, _, State) ->
    fatal_error(bad_pubid, State).

parse_PubidLiteral_sq(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_PubidLiteral_sq(Stream1, Stream1, 0, 0, State1, Acc1);
parse_PubidLiteral_sq(<<$'/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Text = ?ACC(Stream, Pos, Len, Acc),
    {normalize_PubidLiteral(Text), Rest, Stream, Pos + Len + 1, State};
?ONEPUBIDCHAR.

parse_PubidLiteral_dq(<<>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {Stream1, State1} = cf(State),
    parse_PubidLiteral_dq(Stream1, Stream1, 0, 0, State1, Acc1);
parse_PubidLiteral_dq(<<$"/utf8, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Text = ?ACC(Stream, Pos, Len, Acc),
    {normalize_PubidLiteral(Text), Rest, Stream, Pos + Len + 1, State};
?ONEPUBIDCHAR.

% (markupdecl | PEReference | S)* ']' S?)? '>'
%%----------------------------------------------------------------------
%%  [WFC: PE Between Declarations]
%% [28b] intSubset  ::= (markupdecl | PEReference | S)*
%% [29]  markupdecl ::= elementdecl | AttlistDecl | EntityDecl | NotationDecl | PI | Comment
%%  [VC: Proper Declaration/PE Nesting]
%% [69] PEReference ::= '%' Name ';'
%%  [WFC: PEs in Internal Subset]
%%----------------------------------------------------------------------
parse_intSubset(<<"<!ELEMENT", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {DTD1, ?MATCH1} = parse_elementdecl(Bytes, Stream, Pos + 9, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset(<<"<!ELEMEN">>, _, _, State, DTD) ->
    parse_intSubset_ltexELEMEN(cf(State), DTD);
parse_intSubset(<<"<!ELEME">>, _, _, State, DTD) ->
    parse_intSubset_ltexELEME(cf(State), DTD);
parse_intSubset(<<"<!ELEM">>, _, _, State, DTD) ->
    parse_intSubset_ltexELEM(cf(State), DTD);
parse_intSubset(<<"<!ELE">>, _, _, State, DTD) ->
    parse_intSubset_ltexELE(cf(State), DTD);
parse_intSubset(<<"<!EL">>, _, _, State, DTD) ->
    parse_intSubset_ltexEL(cf(State), DTD);
parse_intSubset(<<"<!E">>, _, _, State, DTD) ->
    parse_intSubset_ltexE(cf(State), DTD);
parse_intSubset(<<"<!-">>, _, _, State, DTD) ->
    parse_intSubset_ltexdash(cf(State), DTD);
parse_intSubset(<<"<!">>, _, _, State, DTD) ->
    parse_intSubset_ltex(cf(State), DTD);
parse_intSubset(<<"<">>, _, _, State, DTD) ->
    parse_intSubset_lt(cf(State), DTD);
parse_intSubset(<<"<!ATTLIST", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {DTD1, ?MATCH1} = parse_AttlistDecl(Bytes, Stream, Pos + 9, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset(<<"<!ATTLIS">>, _, _, State, DTD) ->
    parse_intSubset_ltexATTLIS(cf(State), DTD);
parse_intSubset(<<"<!ATTLI">>, _, _, State, DTD) ->
    parse_intSubset_ltexATTLI(cf(State), DTD);
parse_intSubset(<<"<!ATTL">>, _, _, State, DTD) ->
    parse_intSubset_ltexATTL(cf(State), DTD);
parse_intSubset(<<"<!ATT">>, _, _, State, DTD) ->
    parse_intSubset_ltexATT(cf(State), DTD);
parse_intSubset(<<"<!AT">>, _, _, State, DTD) ->
    parse_intSubset_ltexAT(cf(State), DTD);
parse_intSubset(<<"<!A">>, _, _, State, DTD) ->
    parse_intSubset_ltexA(cf(State), DTD);
parse_intSubset(<<"<!ENTITY", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {DTD1, ?MATCH1} = parse_EntityDecl(Bytes, Stream, Pos + 8, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset(<<"<!ENTIT">>, _, _, State, DTD) ->
    parse_intSubset_ltexENTIT(cf(State), DTD);
parse_intSubset(<<"<!ENTI">>, _, _, State, DTD) ->
    parse_intSubset_ltexENTI(cf(State), DTD);
parse_intSubset(<<"<!ENT">>, _, _, State, DTD) ->
    parse_intSubset_ltexENT(cf(State), DTD);
parse_intSubset(<<"<!EN">>, _, _, State, DTD) ->
    parse_intSubset_ltexEN(cf(State), DTD);
parse_intSubset(<<"<!NOTATION", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {DTD1, ?MATCH1} = parse_NotationDecl(Bytes, Stream, Pos + 10, State, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset(<<"<!NOTATIO">>, _, _, State, DTD) ->
    parse_intSubset_ltexNOTATIO(cf(State), DTD);
parse_intSubset(<<"<!NOTATI">>, _, _, State, DTD) ->
    parse_intSubset_ltexNOTATI(cf(State), DTD);
parse_intSubset(<<"<!NOTAT">>, _, _, State, DTD) ->
    parse_intSubset_ltexNOTAT(cf(State), DTD);
parse_intSubset(<<"<!NOTA">>, _, _, State, DTD) ->
    parse_intSubset_ltexNOTA(cf(State), DTD);
parse_intSubset(<<"<!NOT">>, _, _, State, DTD) ->
    parse_intSubset_ltexNOT(cf(State), DTD);
parse_intSubset(<<"<!NO">>, _, _, State, DTD) ->
    parse_intSubset_ltexNO(cf(State), DTD);
parse_intSubset(<<"<!N">>, _, _, State, DTD) ->
    parse_intSubset_ltexN(cf(State), DTD);
parse_intSubset(<<"%", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    % Reset the replacement text flag since this should all be one piece
    {PERef, ?MATCH1} = parse_PEReference(Bytes, Stream, Pos + 1, State),
    case resolve_parameter_entity(PERef, DTD, State1, false, false) of
        {replacement_text, ReplacementText} ->
            RTState = replacement_text_state(Bytes1, State1),
            parse_intSubset(
                ReplacementText, ReplacementText, 0, RTState#ys_state{in_replacement = false}, DTD
            );
        {dtd, DTD1} ->
            parse_intSubset(?MATCH1, DTD1)
    end;
parse_intSubset(<<"]>", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {DTD, Bytes, Stream, Pos + 2, State};
parse_intSubset(<<"]", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    case maybe_consume_s(Bytes, Stream, Pos + 1, State) of
        {_, <<">", Bytes1/bitstring>>, Stream1, Pos1, State1} ->
            {DTD, Bytes1, Stream1, Pos1 + 1, State1};
        {_, _, _, _, State1} ->
            fatal_error(bad_dtd, State1)
    end;
parse_intSubset(<<Char/utf8, Bytes/bitstring>>, Stream, Pos, State, DTD) when
    Char == 16#20; Char == 16#9; Char == 16#A; Char == 16#D
->
    {_, ?MATCH1} = maybe_consume_s(Bytes, Stream, Pos + 1, State),
    parse_intSubset(?MATCH1, DTD);
parse_intSubset(<<"<!--", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {Comment, ?MATCH1} = parse_Comment(Bytes, Stream, Pos + 4, State),
    DTD1 = add_pi_comment_to_dtd(Comment, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset(<<"<?", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {PI, ?MATCH1} = parse_PI(Bytes, Stream, Pos + 2, State),
    DTD1 = add_pi_comment_to_dtd(PI, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset(<<>>, _, _, State, DTD) ->
    {Bytes1, State1} = cf(State),
    parse_intSubset(Bytes1, Bytes1, 0, State1, DTD);
parse_intSubset(Bytes, _, _, State, _DTD) ->
    fatal_error(bad_dtd, {Bytes, State}).

%%----------------------------------------------------------------------
%% [17ns] elementdecl ::= '<!ELEMENT' S QName S contentspec S? '>' [VC: Unique Element Type Declaration]
%% [46]   contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
%% [19ns] Mixed ::= '(' S? '#PCDATA' (S? '|' S? QName)* S? ')*' | '(' S? '#PCDATA' S? ')'
%% [47]   children ::= (choice | seq) ('?' | '*' | '+')?
%% [49]   choice ::= '(' S? cp ( S? '|' S? cp )+ S? ')'    [VC: Proper Group/PE Nesting]
%% [50]   seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'    [VC: Proper Group/PE Nesting]
%% [18ns] cp ::= (QName | choice | seq) ('?' | '*' | '+')?
%%----------------------------------------------------------------------
parse_elementdecl(?MATCH, DTD, External) ->
    {_, ?MATCH1} = consume_s(?MATCH),
    {QName, ?MATCH2} = parse_QName(?MATCH1),
    {_, ?MATCH3} = consume_s(?MATCH2),
    % TODO: E Deterministic Content Models
    % Each model must be deterministic
    {ContentSpec, ?MATCH4} = parse_contentspec(?MATCH3, DTD, External),
    AfterWs =
        if
            External -> maybe_consume_dtd_s(?MATCH4, DTD);
            true -> maybe_consume_s(?MATCH4)
        end,
    case AfterWs of
        {_, <<$>, Bytes5/bitstring>>, Stream5, Pos5, State5} ->
            DTD1 = add_element_to_dtd({QName, ContentSpec}, DTD),
            {DTD1, Bytes5, Stream5, Pos5 + 1, State5};
        {_, Bytes5, _Stream5, _Pos5, State5} ->
            fatal_error(invalid_elementdecl, {Bytes5, State5})
    end.

parse_contentspec(<<"EMPTY", Rest/bitstring>>, Stream, Pos, State, _, _) ->
    {empty, Rest, Stream, Pos + 5, State};
parse_contentspec(<<"EMPT">>, _, _, State, _, _) ->
    parse_contentspec_EMPT(cf(State));
parse_contentspec(<<"EMP">>, _, _, State, _, _) ->
    parse_contentspec_EMP(cf(State));
parse_contentspec(<<"EM">>, _, _, State, _, _) ->
    parse_contentspec_EM(cf(State));
parse_contentspec(<<"E">>, _, _, State, _, _) ->
    parse_contentspec_E(cf(State));
parse_contentspec(<<"ANY", Rest/bitstring>>, Stream, Pos, State, _, _) ->
    {any, Rest, Stream, Pos + 3, State};
parse_contentspec(<<"AN">>, _, _, State, _, _) ->
    parse_contentspec_AN(cf(State));
parse_contentspec(<<"A">>, _, _, State, _, _) ->
    parse_contentspec_A(cf(State));
parse_contentspec(<<"(", Rest/bitstring>>, Stream, Pos, State, DTD, External) ->
    parse_contentspec_Mixed_or_children(Rest, Stream, Pos + 1, State, DTD, External);
?GET_PE(parse_contentspec).

parse_contentspec_Mixed_or_children(?MATCH, DTD, External) ->
    case maybe_consume_s(?MATCH) of
        {_, <<$#, Bytes1/bitstring>>, Stream1, Pos1, State1} ->
            parse_Mixed(Bytes1, Stream1, Pos1 + 1, State1, DTD, External);
        {_, <<"%", Bytes1/bitstring>>, Stream1, Pos1, State1} when External == true ->
            {PERef, Bytes2, _, _, State2} = parse_PEReference(Bytes1, Stream1, Pos1 + 1, State1),
            case resolve_parameter_entity(PERef, DTD, State2, true, true) of
                {replacement_text, <<" ", ReplacementText/bitstring>>} ->
                    RTState = replacement_text_state(Bytes2, State2),
                    {_, ?MATCH3} = maybe_consume_s(ReplacementText, ReplacementText, 0, RTState),
                    ?FUNCTION_NAME(?MATCH3, DTD, true)
            end;
        {_, ?MATCH1} ->
            parse_children(?MATCH1, DTD, External)
    end.

parse_Mixed(<<"PCDATA", Rest/bitstring>>, Stream, Pos, State, DTD, External) ->
    parse_Mixed_(Rest, Stream, Pos + 6, State, DTD, External);
parse_Mixed(<<"PCDAT">>, _, _, State, DTD, External) ->
    parse_Mixed_PCDAT(cf(State), DTD, External);
parse_Mixed(<<"PCDA">>, _, _, State, DTD, External) ->
    parse_Mixed_PCDA(cf(State), DTD, External);
parse_Mixed(<<"PCD">>, _, _, State, DTD, External) ->
    parse_Mixed_PCD(cf(State), DTD, External);
parse_Mixed(<<"PC">>, _, _, State, DTD, External) ->
    parse_Mixed_PC(cf(State), DTD, External);
parse_Mixed(<<"P">>, _, _, State, DTD, External) ->
    parse_Mixed_P(cf(State), DTD, External);
parse_Mixed(<<>>, _, _, State, DTD, External) ->
    {Stream1, State1} = cf(State),
    parse_Mixed(Stream1, Stream1, 0, State1, DTD, External).

parse_Mixed_(?MATCH, DTD, External) ->
    case maybe_consume_s(?MATCH) of
        {_, <<$), $*, Bytes1/bitstring>>, Stream1, Pos1, State1} ->
            {{mixed, []}, Bytes1, Stream1, Pos1 + 2, State1};
        {_, <<$)>>, _, _, State1} ->
            case cf(State1) of
                {<<$*, Bytes2/bitstring>> = Stream2, State2} ->
                    {{mixed, []}, Bytes2, Stream2, 1, State2};
                {Bytes2, State2} ->
                    {{mixed, []}, Bytes2, Bytes2, 0, State2}
            end;
        {_, <<$), Bytes1/bitstring>>, Stream1, Pos1, State1} ->
            {{mixed, []}, Bytes1, Stream1, Pos1 + 1, State1};
        {_, <<$|, _/bitstring>> = ?MATCH1} ->
            parse_Mixed_names(?MATCH1, [], DTD, External);
        {_, <<$%, Bytes1/bitstring>>, Stream1, Pos1, State1} when External == true ->
            {PERef, Bytes2, _, _, State2} = parse_PEReference(Bytes1, Stream1, Pos1 + 1, State1),
            case resolve_parameter_entity(PERef, DTD, State2, true, true) of
                {replacement_text, ReplacementText} ->
                    RTState = replacement_text_state(Bytes2, State2),
                    {_, ?MATCH3} = maybe_consume_s(ReplacementText, ReplacementText, 0, RTState),
                    ?FUNCTION_NAME(?MATCH3, DTD, External)
            end
    end.

parse_Mixed_names(<<")*", Rest/bitstring>>, Stream, Pos, State, Acc, _DTD, _External) ->
    {{mixed, Acc}, Rest, Stream, Pos + 2, State};
parse_Mixed_names(<<$|, Rest/bitstring>>, Stream, Pos, State, Acc, DTD, false) ->
    {_, ?MATCH1} = maybe_consume_s(Rest, Stream, Pos + 1, State),
    {Name, ?MATCH2} = parse_QName(?MATCH1),
    {_, ?MATCH3} = maybe_consume_s(?MATCH2),
    parse_Mixed_names(?MATCH3, [Name | Acc], DTD, false);
parse_Mixed_names(<<$|, Rest/bitstring>>, Stream, Pos, State, Acc, DTD, External) ->
    {_, ?MATCH1} = maybe_consume_s(Rest, Stream, Pos + 1, State),
    {Name, ?MATCH2} = parse_QName(?MATCH1, DTD),
    {_, ?MATCH3} = maybe_consume_s(?MATCH2),
    parse_Mixed_names(?MATCH3, [Name | Acc], DTD, External);
parse_Mixed_names(<<")">>, _, _, State, Acc, _DTD, _External) ->
    {<<$*, Bytes1/bitstring>> = Stream1, State1} = cf(State),
    {{mixed, Acc}, Bytes1, Stream1, 1, State1};
parse_Mixed_names(<<>>, _, _, State, Acc, DTD, External) ->
    {Stream1, State1} = cf(State),
    parse_Mixed_names(Stream1, Stream1, 0, State1, Acc, DTD, External).

parse_children(?MATCH, DTD, External) ->
    {Seq, ?MATCH2} =
        case parse_choice_or_seq(?MATCH, DTD, External) of
            {CorS, <<$?, Bytes1/bitstring>>, Stream1, Pos1, State1} ->
                {{CorS, '?'}, Bytes1, Stream1, Pos1 + 1, State1};
            {CorS, <<$*, Bytes1/bitstring>>, Stream1, Pos1, State1} ->
                {{CorS, '*'}, Bytes1, Stream1, Pos1 + 1, State1};
            {CorS, <<$+, Bytes1/bitstring>>, Stream1, Pos1, State1} ->
                {{CorS, '+'}, Bytes1, Stream1, Pos1 + 1, State1};
            {CorS, ?MATCH1} ->
                {{CorS, 'one'}, ?MATCH1}
        end,
    {_, ?MATCH3} = maybe_consume_s(?MATCH2),
    {Seq, ?MATCH3}.

?GET_PE(parse_choice_or_seq);
parse_choice_or_seq(?MATCH, DTD, External) ->
    {CP, ?MATCH1} = parse_cp(?MATCH, DTD, External),
    case maybe_consume_s(?MATCH1) of
        {_, <<$|, _/bitstring>> = ?MATCH2} ->
            parse_choice(?MATCH2, [CP], DTD, External);
        {_, <<$,, _/bitstring>> = ?MATCH2} ->
            parse_seq(?MATCH2, DTD, External, [CP]);
        {_, <<$)>>, _Stream2, _Pos2, State2} ->
            {Stream3, State3} = cf(State2),
            {{seq, [CP]}, Stream3, Stream3, 0, State3};
        {_, <<$), Bytes2/bitstring>>, Stream2, Pos2, State2} ->
            {{seq, [CP]}, Bytes2, Stream2, Pos2 + 1, State2}
    end.

?GET_PE(parse_cp);
parse_cp(<<>>, _Stream, _Pos, State, DTD, External) ->
    {Stream1, State1} = cf(State),
    ?FUNCTION_NAME(Stream1, Stream1, 0, State1, DTD, External);
parse_cp(<<$(, Rest/bitstring>>, Stream, Pos, State, DTD, External) ->
    {_, ?MATCH1} = maybe_consume_s(Rest, Stream, Pos + 1, State),
    case parse_choice_or_seq(?MATCH1, DTD, External) of
        {CorS, <<$?, Bytes2/bitstring>>, Stream2, Pos2, State2} ->
            {{CorS, '?'}, Bytes2, Stream2, Pos2 + 1, State2};
        {CorS, <<$*, Bytes2/bitstring>>, Stream2, Pos2, State2} ->
            {{CorS, '*'}, Bytes2, Stream2, Pos2 + 1, State2};
        {CorS, <<$+, Bytes2/bitstring>>, Stream2, Pos2, State2} ->
            {{CorS, '+'}, Bytes2, Stream2, Pos2 + 1, State2};
        {CorS, ?MATCH2} ->
            {{CorS, 'one'}, ?MATCH2}
    end;
parse_cp(?MATCH, _, _) ->
    {_, ?MATCH1} = maybe_consume_s(?MATCH),
    case parse_QName(?MATCH1) of
        {QName, <<$?, Bytes2/bitstring>>, Stream2, Pos2, State2} ->
            {{QName, '?'}, Bytes2, Stream2, Pos2 + 1, State2};
        {QName, <<$*, Bytes2/bitstring>>, Stream2, Pos2, State2} ->
            {{QName, '*'}, Bytes2, Stream2, Pos2 + 1, State2};
        {QName, <<$+, Bytes2/bitstring>>, Stream2, Pos2, State2} ->
            {{QName, '+'}, Bytes2, Stream2, Pos2 + 1, State2};
        {QName, ?MATCH2} ->
            {{QName, 'one'}, ?MATCH2}
    end.

parse_choice(<<$|, Rest/bitstring>>, Stream, Pos, State, Acc, DTD, External) ->
    {_, ?MATCH1} = maybe_consume_s(Rest, Stream, Pos + 1, State),
    {CP, ?MATCH2} = parse_cp(?MATCH1, DTD, External),
    {_, ?MATCH3} = maybe_consume_s(?MATCH2),
    parse_choice(?MATCH3, [CP | Acc], DTD, External);
parse_choice(<<$)>>, _Stream, _Pos, State, Acc, _DTD, _External) ->
    {Stream1, State1} = cf(State),
    Choice = lists:reverse(Acc),
    case model_is_deterministic(Choice) of
        true -> {{choice, Choice}, Stream1, Stream1, 0, State1};
        false -> fatal_error(non_deterministic_model, State)
    end;
parse_choice(<<$), Rest/bitstring>>, Stream, Pos, State, Acc, _, _) ->
    Choice = lists:reverse(Acc),
    case model_is_deterministic(Choice) of
        true -> {{choice, Choice}, Rest, Stream, Pos + 1, State};
        false -> fatal_error(non_deterministic_model, State)
    end;
?GET_PE_ACC(parse_choice).

parse_seq(<<$,, Rest/bitstring>>, Stream, Pos, State, DTD, External, Acc) ->
    {_, ?MATCH1} = maybe_consume_s(Rest, Stream, Pos + 1, State),
    {CP, ?MATCH2} = parse_cp(?MATCH1, DTD, External),
    {_, ?MATCH3} = maybe_consume_s(?MATCH2),
    parse_seq(?MATCH3, DTD, External, [CP | Acc]);
parse_seq(<<$)>>, _Stream, _Pos, State, _DTD, _External, Acc) ->
    {Stream1, State1} = cf(State),
    {{seq, lists:reverse(Acc)}, Stream1, Stream1, 0, State1};
parse_seq(<<$), Rest/bitstring>>, Stream, Pos, State, _, _, Acc) ->
    {{seq, lists:reverse(Acc)}, Rest, Stream, Pos + 1, State};
parse_seq(Bytes, _, _, _, _, _, _) ->
    fatal_error(non_deterministic_model, Bytes).

model_is_deterministic(Model) ->
    Names = [Name || {Name, _} <- Model],
    lists:sort(Names) == lists:usort(Names).

%%----------------------------------------------------------------------
%% [20ns] AttlistDecl ::= '<!ATTLIST' S QName AttDef* S? '>'
%% [21ns] AttDef ::= S (QName | NSAttName) S AttType S DefaultDecl
%% [1ns]  NSAttName ::= PrefixedAttName | DefaultAttName
%% [2ns]  PrefixedAttName ::= 'xmlns:' NCName	[NSC: Reserved Prefixes and Namespace Names]
%% [3ns]  DefaultAttName ::= 'xmlns'
%% [54]   AttType ::= StringType | TokenizedType | EnumeratedType
%% [55]   StringType ::= 'CDATA'
%% [56]   TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'
%% [57]   EnumeratedType ::= NotationType | Enumeration
%% [58]   NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'     [VC: Notation Attributes]
%% [59]   Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'    [VC: Enumeration]
%% [60]   DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue)
%% [10]   AttValue ::= '"' ([^<&"] | Reference)* '"' |  "'" ([^<&'] | Reference)* "'"
%%----------------------------------------------------------------------
parse_AttlistDecl(<<"%", Bytes/bitstring>>, Stream, Pos, State, DTD, true) ->
    {PERef, Bytes1, _, _, State1} = parse_PEReference(Bytes, Stream, Pos + 1, State),
    case resolve_parameter_entity(PERef, DTD, State1, true, true) of
        {replacement_text, ReplacementText} ->
            RTState = replacement_text_state(Bytes1, State1),
            parse_AttlistDecl(ReplacementText, ReplacementText, 0, RTState, DTD, true)
    end;
parse_AttlistDecl(?MATCH, DTD, true) ->
    {_, ?MATCH1} = consume_s(Bytes, Stream, Pos, State),
    {ElemName, ?MATCH2} = parse_QName(?MATCH1, DTD),
    {AttDefs, ?MATCH3} = parse_AttDef(?MATCH2, #{}, DTD, true),
    DTD1 = add_attlist_to_dtd({ElemName, AttDefs}, DTD),
    {DTD1, ?MATCH3};
parse_AttlistDecl(?MATCH, DTD, External) ->
    {_, ?MATCH1} = consume_s(Bytes, Stream, Pos, State),
    {ElemName, ?MATCH2} = parse_QName(?MATCH1),
    {AttDefs, ?MATCH3} = parse_AttDef(?MATCH2, #{}, DTD, External),
    DTD1 = add_attlist_to_dtd({ElemName, AttDefs}, DTD),
    {DTD1, ?MATCH3}.

parse_AttDef(?MATCH, Acc, DTD, External) ->
    case maybe_consume_s(?MATCH) of
        {_, <<$>, Bytes1/bitstring>>, Stream1, Pos1, State1} ->
            {Acc, Bytes1, Stream1, Pos1 + 1, State1};
        {true, ?MATCH1} when External == true ->
            {QName, ?MATCH2} = parse_QName(?MATCH1, DTD),
            {_, ?MATCH3} = consume_s(?MATCH2),
            {AttType, ?MATCH4} = parse_AttType(?MATCH3),
            {_, ?MATCH5} = consume_s(?MATCH4, DTD),
            {DefaultDecl, ?MATCH6} = parse_DefaultDecl(?MATCH5, DTD, External),
            parse_AttDef(?MATCH6, Acc#{QName => {AttType, DefaultDecl}}, DTD, External);
        {true, ?MATCH1} ->
            {QName, ?MATCH2} = parse_QName(?MATCH1),
            {_, ?MATCH3} = consume_s(?MATCH2),
            {AttType, ?MATCH4} = parse_AttType(?MATCH3),
            {_, ?MATCH5} = consume_s(?MATCH4),
            {DefaultDecl, ?MATCH6} = parse_DefaultDecl(?MATCH5, DTD, External),
            parse_AttDef(?MATCH6, Acc#{QName => {AttType, DefaultDecl}}, DTD, External)
    end.

parse_DefaultDecl_hREQUIRED(?MATCH) -> {required, ?MATCH}.

parse_DefaultDecl_hIMPLIED(?MATCH) -> {implied, ?MATCH}.

parse_DefaultDecl_hFIXED(?MATCH, DTD, External) ->
    {_, ?MATCH1} = consume_s(?MATCH),
    State0 = State1#ys_state{in_replacement = false},
    {AttValue, ?MATCH2} = parse_AttValue(Bytes1, Stream1, Pos1, State0, DTD, External),
    {{fixed, AttValue}, ?MATCH2}.

parse_DefaultDecl(<<"#REQUIRED", Rest/bitstring>>, Stream, Pos, State, _, _) ->
    parse_DefaultDecl_hREQUIRED(Rest, Stream, Pos + 9, State);
parse_DefaultDecl(<<"#REQUIRE">>, _, _, State, _, _) ->
    parse_DefaultDecl_hREQUIRE(cf(State));
parse_DefaultDecl(<<"#REQUIR">>, _, _, State, _, _) ->
    parse_DefaultDecl_hREQUIR(cf(State));
parse_DefaultDecl(<<"#REQUI">>, _, _, State, _, _) ->
    parse_DefaultDecl_hREQUI(cf(State));
parse_DefaultDecl(<<"#REQU">>, _, _, State, _, _) ->
    parse_DefaultDecl_hREQU(cf(State));
parse_DefaultDecl(<<"#REQ">>, _, _, State, _, _) ->
    parse_DefaultDecl_hREQ(cf(State));
parse_DefaultDecl(<<"#RE">>, _, _, State, _, _) ->
    parse_DefaultDecl_hRE(cf(State));
parse_DefaultDecl(<<"#R">>, _, _, State, _, _) ->
    parse_DefaultDecl_hR(cf(State));
parse_DefaultDecl(<<"#">>, _, _, State, DTD, _) ->
    parse_DefaultDecl_h(cf(State), DTD);
parse_DefaultDecl(<<"#IMPLIED", Rest/bitstring>>, Stream, Pos, State, _, _) ->
    parse_DefaultDecl_hIMPLIED(Rest, Stream, Pos + 8, State);
parse_DefaultDecl(<<"#IMPLIE">>, _, _, State, _, _) ->
    parse_DefaultDecl_hIMPLIE(cf(State));
parse_DefaultDecl(<<"#IMPLI">>, _, _, State, _, _) ->
    parse_DefaultDecl_hIMPLI(cf(State));
parse_DefaultDecl(<<"#IMPL">>, _, _, State, _, _) ->
    parse_DefaultDecl_hIMPL(cf(State));
parse_DefaultDecl(<<"#IMP">>, _, _, State, _, _) ->
    parse_DefaultDecl_hIMP(cf(State));
parse_DefaultDecl(<<"#IM">>, _, _, State, _, _) ->
    parse_DefaultDecl_hIM(cf(State));
parse_DefaultDecl(<<"#I">>, _, _, State, _, _) ->
    parse_DefaultDecl_hI(cf(State));
parse_DefaultDecl(<<"#FIXED", Rest/bitstring>>, Stream, Pos, State, DTD, External) ->
    parse_DefaultDecl_hFIXED(Rest, Stream, Pos + 6, State, DTD, External);
parse_DefaultDecl(<<"#FIXE">>, _, _, State, DTD, _) ->
    parse_DefaultDecl_hFIXE(cf(State), DTD);
parse_DefaultDecl(<<"#FIX">>, _, _, State, DTD, _) ->
    parse_DefaultDecl_hFIX(cf(State), DTD);
parse_DefaultDecl(<<"#FI">>, _, _, State, DTD, _) ->
    parse_DefaultDecl_hFI(cf(State), DTD);
parse_DefaultDecl(<<"#F">>, _, _, State, DTD, _) ->
    parse_DefaultDecl_hF(cf(State), DTD);
?GET_PE(parse_DefaultDecl);
parse_DefaultDecl(?MATCH, DTD, External) ->
    % Faking not in replacement to block single quote characters in value
    State0 = State#ys_state{in_replacement = false},
    {AttValue, ?MATCH1} = parse_AttValue(Bytes, Stream, Pos, State0, DTD, External),
    {{value, AttValue}, ?MATCH1}.

%% [55]   StringType ::= 'CDATA'
%% [56]   TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'
%% [57]   EnumeratedType ::= NotationType | Enumeration
%% [58]   NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'     [VC: Notation Attributes]
%% [59]   Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'    [VC: Enumeration]
parse_AttType(<<"CDATA", Rest/bitstring>>, Stream, Pos, State) ->
    {cdata, Rest, Stream, Pos + 5, State};
parse_AttType(<<"CDAT">>, _, _, State) ->
    parse_AttType_CDAT(cf(State));
parse_AttType(<<"CDA">>, _, _, State) ->
    parse_AttType_CDA(cf(State));
parse_AttType(<<"CD">>, _, _, State) ->
    parse_AttType_CD(cf(State));
parse_AttType(<<"C">>, _, _, State) ->
    parse_AttType_C(cf(State));
parse_AttType(<<$(, Rest/bitstring>>, Stream, Pos, State) ->
    {_, ?MATCH1} = maybe_consume_s(Rest, Stream, Pos + 1, State),
    {Nmtoken, ?MATCH2} = parse_Nmtoken(?MATCH1),
    {_, ?MATCH3} = maybe_consume_s(?MATCH2),
    parse_AttType_Enumeration(?MATCH3, [Nmtoken]);
parse_AttType(<<"NOTATION", Rest/bitstring>>, Stream, Pos, State) ->
    parse_AttType_NOTATION(Rest, Stream, Pos + 8, State);
parse_AttType(<<"NOTATIO">>, _, _, State) ->
    parse_AttType_NOTATIO(cf(State));
parse_AttType(<<"NOTATI">>, _, _, State) ->
    parse_AttType_NOTATI(cf(State));
parse_AttType(<<"NOTAT">>, _, _, State) ->
    parse_AttType_NOTAT(cf(State));
parse_AttType(<<"NOTA">>, _, _, State) ->
    parse_AttType_NOTA(cf(State));
parse_AttType(<<"NOT">>, _, _, State) ->
    parse_AttType_NOT(cf(State));
parse_AttType(<<"NO">>, _, _, State) ->
    parse_AttType_NO(cf(State));
parse_AttType(<<"NMTOKENS", Rest/bitstring>>, Stream, Pos, State) ->
    {nmtokens, Rest, Stream, Pos + 8, State};
parse_AttType(<<"NMTOKEN">>, _, _, State) ->
    parse_AttType_NMTOKEN(cf(State));
parse_AttType(<<"NMTOKE">>, _, _, State) ->
    parse_AttType_NMTOKE(cf(State));
parse_AttType(<<"NMTOK">>, _, _, State) ->
    parse_AttType_NMTOK(cf(State));
parse_AttType(<<"NMTO">>, _, _, State) ->
    parse_AttType_NMTO(cf(State));
parse_AttType(<<"NMT">>, _, _, State) ->
    parse_AttType_NMT(cf(State));
parse_AttType(<<"NM">>, _, _, State) ->
    parse_AttType_NM(cf(State));
parse_AttType(<<"N">>, _, _, State) ->
    parse_AttType_N(cf(State));
parse_AttType(<<"NMTOKEN", Rest/bitstring>>, Stream, Pos, State) ->
    {nmtoken, Rest, Stream, Pos + 7, State};
parse_AttType(<<"ENTITIES", Rest/bitstring>>, Stream, Pos, State) ->
    {entities, Rest, Stream, Pos + 8, State};
parse_AttType(<<"ENTITIE">>, _, _, State) ->
    parse_AttType_ENTITIE(cf(State));
parse_AttType(<<"ENTITI">>, _, _, State) ->
    parse_AttType_ENTITI(cf(State));
parse_AttType(<<"ENTIT">>, _, _, State) ->
    parse_AttType_ENTIT(cf(State));
parse_AttType(<<"ENTI">>, _, _, State) ->
    parse_AttType_ENTI(cf(State));
parse_AttType(<<"ENT">>, _, _, State) ->
    parse_AttType_ENT(cf(State));
parse_AttType(<<"EN">>, _, _, State) ->
    parse_AttType_EN(cf(State));
parse_AttType(<<"E">>, _, _, State) ->
    parse_AttType_E(cf(State));
parse_AttType(<<"ENTITY", Rest/bitstring>>, Stream, Pos, State) ->
    {entity, Rest, Stream, Pos + 6, State};
parse_AttType(<<"IDREFS", Rest/bitstring>>, Stream, Pos, State) ->
    {idrefs, Rest, Stream, Pos + 6, State};
parse_AttType(<<"IDREF">>, _, _, State) ->
    parse_AttType_IDREF(cf(State));
parse_AttType(<<"IDRE">>, _, _, State) ->
    parse_AttType_IDRE(cf(State));
parse_AttType(<<"IDR">>, _, _, State) ->
    parse_AttType_IDR(cf(State));
parse_AttType(<<"IDREF", Rest/bitstring>>, Stream, Pos, State) ->
    {idref, Rest, Stream, Pos + 5, State};
parse_AttType(<<"ID">>, _, _, State) ->
    parse_AttType_ID(cf(State));
parse_AttType(<<"ID", Rest/bitstring>>, Stream, Pos, State) ->
    {id, Rest, Stream, Pos + 2, State};
parse_AttType(<<"I">>, _, _, State) ->
    parse_AttType_I(cf(State)).

%% [58]   NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'     [VC: Notation Attributes]
parse_AttType_NOTATION(?MATCH) ->
    {_, <<$(, Bytes1/bitstring>>, Stream1, Pos1, State1} = consume_s(?MATCH),
    {_, ?MATCH2} = maybe_consume_s(Bytes1, Stream1, Pos1 + 1, State1),
    {Name, ?MATCH3} = parse_Name(?MATCH2),
    {_, ?MATCH4} = maybe_consume_s(?MATCH3),
    parse_AttType_NOTATION_names(?MATCH4, [Name]).

parse_AttType_NOTATION_names(<<$), Rest/bitstring>>, Stream, Pos, State, Acc) ->
    {{notation, lists:reverse(Acc)}, Rest, Stream, Pos + 1, State};
parse_AttType_NOTATION_names(<<$|, Rest/bitstring>>, Stream, Pos, State, Acc) ->
    {_, ?MATCH1} = maybe_consume_s(Rest, Stream, Pos + 1, State),
    {Name, ?MATCH2} = parse_Name(?MATCH1),
    {_, ?MATCH3} = maybe_consume_s(?MATCH2),
    parse_AttType_NOTATION_names(?MATCH3, [Name | Acc]).

%% [59]   Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'    [VC: Enumeration]
parse_AttType_Enumeration(<<$), Rest/bitstring>>, Stream, Pos, State, Acc) ->
    {{enum, lists:reverse(Acc)}, Rest, Stream, Pos + 1, State};
parse_AttType_Enumeration(<<$|, Rest/bitstring>>, Stream, Pos, State, Acc) ->
    {_, ?MATCH1} = maybe_consume_s(Rest, Stream, Pos + 1, State),
    {Nmtoken, ?MATCH2} = parse_Nmtoken(?MATCH1),
    {_, ?MATCH3} = maybe_consume_s(?MATCH2),
    parse_AttType_Enumeration(?MATCH3, [Nmtoken | Acc]).

%%----------------------------------------------------------------------
%% [70]   EntityDecl ::= GEDecl | PEDecl
%% [71]   GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
%% [73]   EntityDef ::= EntityValue | (ExternalID NDataDecl?)
%% [9]    EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |  "'" ([^%&'] | PEReference | Reference)* "'"
%% [76]   NDataDecl ::= S 'NDATA' S Name     [VC: Notation Declared]
%% [72]   PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
%% [74]   PEDef ::= EntityValue | ExternalID
%%----------------------------------------------------------------------
parse_EntityDecl(?MATCH, DTD, External) ->
    case consume_s(?MATCH) of
        {_, <<$%, Bytes1/bitstring>>, Stream1, Pos1, State1} ->
            %% [72]   PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
            {_, ?MATCH2} = consume_s(Bytes1, Stream1, Pos1 + 1, State1),
            {Name, ?MATCH3} = parse_NCName(?MATCH2),
            {_, ?MATCH4} = consume_s(?MATCH3),
            {{InEx, EntityValue, DTD1}, ?MATCH5} = parse_PEDef(?MATCH4, DTD, External),
            {_, <<$>, Bytes6/bitstring>>, Stream6, Pos6, State6} = maybe_consume_s(?MATCH5),
            DTD2 = add_entity_to_dtd({Name, {parameter, InEx, EntityValue}}, DTD1),
            {DTD2, Bytes6, Stream6, Pos6 + 1, State6};
        {_, ?MATCH1} ->
            %% [71]   GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
            {Name, ?MATCH2} = parse_NCName(?MATCH1),
            {_, ?MATCH3} = consume_s(?MATCH2),
            {{EntityType, EntityValue, DTD1}, ?MATCH4} = parse_EntityDef(?MATCH3, DTD, External),
            {_, <<$>, Bytes5/bitstring>>, Stream5, Pos5, State5} = maybe_consume_s(?MATCH4),
            DTD2 = add_entity_to_dtd({Name, {general, EntityType, EntityValue}}, DTD1),
            {DTD2, Bytes5, Stream5, Pos5 + 1, State5}
    end.

% quote == EntityValue, P or S == ExternalID
parse_PEDef(<<Char, _/bitstring>> = ?MATCH, DTD, _) when Char == $P; Char == $S ->
    {Val, ?MATCH1} = parse_ExternalID(?MATCH),
    {{external, Val, DTD}, ?MATCH1};
parse_PEDef(?MATCH, DTD, External) ->
    case parse_EntityValue(?MATCH, DTD, External) of
        {{Val, DTD1}, ?MATCH1} -> {{internal, Val, DTD1}, ?MATCH1};
        {Val, ?MATCH1} -> {{internal, Val, DTD}, ?MATCH1}
    end.

parse_EntityDef(<<Char, _/bitstring>> = ?MATCH, DTD, _) when Char == $P; Char == $S ->
    {{Pub, Sys}, ?MATCH1} = parse_ExternalID(?MATCH),
    case maybe_consume_s(?MATCH1) of
        {true, <<$N, Bytes2/bitstring>>, Stream2, Pos2, State2} ->
            {Name, ?MATCH3} = parse_NDataDecl(Bytes2, Stream2, Pos2 + 1, State2),
            {{external, {Pub, Sys, Name}, DTD}, ?MATCH3};
        {_, ?MATCH2} ->
            {{external, {Pub, Sys}, DTD}, ?MATCH2}
    end;
parse_EntityDef(?MATCH, DTD, External) ->
    case parse_EntityValue(?MATCH, DTD, External) of
        {{Val, DTD1}, ?MATCH1} -> {{internal, Val, DTD1}, ?MATCH1};
        {Val, ?MATCH1} -> {{internal, Val, DTD}, ?MATCH1}
    end.

parse_NDataDecl(<<"DATA", Rest/bitstring>>, Stream, Pos, State) ->
    parse_NDataDecl_NDATA(Rest, Stream, Pos + 4, State);
parse_NDataDecl(<<"DAT">>, _, _, State) ->
    parse_NDataDecl_NDAT(cf(State));
parse_NDataDecl(<<"DA">>, _, _, State) ->
    parse_NDataDecl_NDA(cf(State));
parse_NDataDecl(<<"D">>, _, _, State) ->
    parse_NDataDecl_ND(cf(State));
parse_NDataDecl(<<>>, _, _, State) ->
    {Bytes1, State1} = cf(State),
    parse_NDataDecl(Bytes1, Bytes1, 0, State1).

parse_NDataDecl_ND({<<"ATA", Rest/bitstring>> = Stream, State}) ->
    parse_NDataDecl_NDATA(Rest, Stream, 3, State);
parse_NDataDecl_ND({<<"AT">>, State}) ->
    parse_NDataDecl_NDAT(cf(State));
parse_NDataDecl_ND({<<"A">>, State}) ->
    parse_NDataDecl_NDA(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_NDataDecl_NDA({<<"TA", Rest/bitstring>> = Stream, State}) ->
    parse_NDataDecl_NDATA(Rest, Stream, 2, State);
parse_NDataDecl_NDA({<<"T">>, State}) ->
    parse_NDataDecl_NDAT(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_NDataDecl_NDAT({<<"A", Rest/bitstring>> = Stream, State}) ->
    parse_NDataDecl_NDATA(Rest, Stream, 1, State);
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

%% [76]   NDataDecl ::= S 'NDATA' S Name
parse_NDataDecl_NDATA(?MATCH) ->
    {_, ?MATCH1} = consume_s(?MATCH),
    parse_Name(?MATCH1).

%% [9]    EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |  "'" ([^%&'] | PEReference | Reference)* "'"
parse_EntityValue(<<$', Rest/bitstring>>, Stream, Pos, State, DTD, External) ->
    parse_EntityValue_sq(Rest, Stream, Pos + 1, 0, State, [], DTD, External);
parse_EntityValue(<<$", Rest/bitstring>>, Stream, Pos, State, DTD, External) ->
    parse_EntityValue_dq(Rest, Stream, Pos + 1, 0, State, [], DTD, External).

parse_EntityValue_sq(<<$\r, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, External) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc, DTD, External);
parse_EntityValue_sq(
    <<$', Rest/bitstring>>,
    Stream,
    Pos,
    Len,
    #ys_state{in_replacement = false} = State,
    Acc,
    DTD,
    External
) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    if
        External ->
            {{to_binary(Acc1), DTD}, Rest, Stream, Pos + 1 + Len, State};
        true ->
            {to_binary(Acc1), Rest, Stream, Pos + 1 + Len, State}
    end;
parse_EntityValue_sq(<<$%, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, true) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {PERef, ?MATCH1} = parse_PEReference(Rest, Stream, Pos + Len + 1, State),
    case resolve_parameter_entity(PERef, DTD, State1, false, true) of
        {replacement_text, ReplacementText} ->
            RTState = replacement_text_state(Bytes1, State1),
            ?FUNCTION_NAME(ReplacementText, ReplacementText, 0, 0, RTState, Acc1, DTD, true);
        {dtd, DTD1} ->
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc1, DTD1, true)
    end;
parse_EntityValue_sq(<<$%, _Rest/bitstring>>, _Stream, _Pos, _Len, State, _Acc, _DTD, false) ->
    fatal_error(pe_in_markup, State);
parse_EntityValue_sq(<<$&, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, External) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    case parse_Reference(Rest, Stream, Pos + Len + 1, State, entity) of
        {{_Name, {replacement_text, Ref}}, ?MATCH1} ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{gen, <<$<>>}, ?MATCH1} ->
            Acc2 = ?APPEND(<<"&lt;">>, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{gen, <<$&>>}, ?MATCH1} ->
            Acc2 = ?APPEND(<<"&amp;">>, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{Type, <<$&>>}, ?MATCH1} when Type == hex; Type == dec ->
            Acc2 = ?APPEND(<<"&#38;">>, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{Type, <<$\r>>}, ?MATCH1} when Type == hex; Type == dec ->
            Acc2 = ?APPEND(<<"&#xD;">>, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{_, Ref}, ?MATCH1} ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External)
    end;
?ONECHARX.

parse_EntityValue_dq(<<$\r, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, External) ->
    ?FUNCTION_NAME(Rest, Stream, Pos, Len + 1, State, Acc, DTD, External);
parse_EntityValue_dq(
    <<$", Rest/bitstring>>,
    Stream,
    Pos,
    Len,
    #ys_state{in_replacement = false} = State,
    Acc,
    DTD,
    External
) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    if
        External ->
            {{to_binary(Acc1), DTD}, Rest, Stream, Pos + 1 + Len, State};
        true ->
            {to_binary(Acc1), Rest, Stream, Pos + 1 + Len, State}
    end;
% Not allowed in internal, is allowed in external.
parse_EntityValue_dq(<<$%, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, true) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {PERef, ?MATCH1} = parse_PEReference(Rest, Stream, Pos + Len + 1, State),
    case resolve_parameter_entity(PERef, DTD, State1, false, true) of
        {replacement_text, ReplacementText} ->
            RTState = replacement_text_state(Bytes1, State1),
            ?FUNCTION_NAME(ReplacementText, ReplacementText, 0, 0, RTState, Acc1, DTD, true);
        {dtd, DTD1} ->
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc1, DTD1, true)
    end;
parse_EntityValue_dq(<<$%, _Rest/bitstring>>, _Stream, _Pos, _Len, State, _Acc, _DTD, false) ->
    fatal_error(pe_in_markup, State);
parse_EntityValue_dq(<<$&, Rest/bitstring>>, Stream, Pos, Len, State, Acc, DTD, External) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    case parse_Reference(Rest, Stream, Pos + Len + 1, State#ys_state{dtd = DTD}, entity) of
        {{_Name, {replacement_text, Ref}}, ?MATCH1} ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{gen, <<$<>>}, ?MATCH1} ->
            Acc2 = ?APPEND(<<"&lt;">>, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{gen, <<$&>>}, ?MATCH1} ->
            Acc2 = ?APPEND(<<"&amp;">>, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{Type, <<$&>>}, ?MATCH1} when Type == hex; Type == dec ->
            Acc2 = ?APPEND(<<"&#38;">>, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{Type, <<$\r>>}, ?MATCH1} when Type == hex; Type == dec ->
            Acc2 = ?APPEND(<<"&#xD;">>, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External);
        {{_, Ref}, ?MATCH1} ->
            Acc2 = ?APPEND(Ref, Acc1),
            ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2, DTD, External)
    end;
?ONECHARX.

%%----------------------------------------------------------------------
%% [82]   NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>'    [VC: Unique Notation Name]
%% [83]   PublicID            ::=       'PUBLIC' S PubidLiteral
%%----------------------------------------------------------------------
parse_NotationDecl(?MATCH, DTD) ->
    {_, ?MATCH1} = consume_s(?MATCH),
    {Name, ?MATCH2} = parse_NCName(?MATCH1),
    {_, ?MATCH3} = consume_s(?MATCH2),
    {{Pub, Sys}, ?MATCH4} =
        case Bytes3 of
            <<$S, _/bitstring>> ->
                parse_ExternalID(?MATCH3);
            <<$P, _/bitstring>> ->
                parse_PublicID(?MATCH3)
        end,
    case Bytes4 of
        <<$>, Bytes5/bitstring>> ->
            DTD1 = add_notation_to_dtd({Name, Pub, Sys}, DTD),
            {DTD1, Bytes5, Stream4, Pos4 + 1, State4};
        _ ->
            {Sys1, <<$>, Bytes5/bitstring>>, Stream5, Pos5, State5} = parse_SystemLiteral(?MATCH4),
            DTD1 = add_notation_to_dtd({Name, Pub, Sys1}, DTD),
            {DTD1, Bytes5, Stream5, Pos5 + 1, State5}
    end.

parse_PublicID(<<"PUBLIC", Rest/bitstring>>, Stream, Pos, State) ->
    parse_PublicID_PUBLIC(Rest, Stream, Pos + 6, State);
parse_PublicID(<<"PUBLI">>, _, _, State) ->
    parse_PublicID_PUBLI(cf(State));
parse_PublicID(<<"PUBL">>, _, _, State) ->
    parse_PublicID_PUBL(cf(State));
parse_PublicID(<<"PUB">>, _, _, State) ->
    parse_PublicID_PUB(cf(State));
parse_PublicID(<<"PU">>, _, _, State) ->
    parse_PublicID_PU(cf(State));
parse_PublicID(<<"P">>, _, _, State) ->
    parse_PublicID_P(cf(State));
?FUNCTION_NAME(<<>>, _, _, State) ->
    {Stream1, State1} = cf(State),
    ?FUNCTION_NAME(Stream1, Stream1, 0, State1).

parse_PublicID_P({<<"UBLIC", Rest/bitstring>> = Stream, State}) ->
    parse_PublicID_PUBLIC(Rest, Stream, 5, State);
parse_PublicID_P({<<"UBLI">>, State}) ->
    parse_PublicID_PUBLI(cf(State));
parse_PublicID_P({<<"UBL">>, State}) ->
    parse_PublicID_PUBL(cf(State));
parse_PublicID_P({<<"UB">>, State}) ->
    parse_PublicID_PUB(cf(State));
parse_PublicID_P({<<"U">>, State}) ->
    parse_PublicID_PU(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_PublicID_PU({<<"BLIC", Rest/bitstring>> = Stream, State}) ->
    parse_PublicID_PUBLIC(Rest, Stream, 4, State);
parse_PublicID_PU({<<"BLI">>, State}) ->
    parse_PublicID_PUBLI(cf(State));
parse_PublicID_PU({<<"BL">>, State}) ->
    parse_PublicID_PUBL(cf(State));
parse_PublicID_PU({<<"B">>, State}) ->
    parse_PublicID_PUB(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_PublicID_PUB({<<"LIC", Rest/bitstring>> = Stream, State}) ->
    parse_PublicID_PUBLIC(Rest, Stream, 3, State);
parse_PublicID_PUB({<<"LI">>, State}) ->
    parse_PublicID_PUBLI(cf(State));
parse_PublicID_PUB({<<"L">>, State}) ->
    parse_PublicID_PUBL(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_PublicID_PUBL({<<"IC", Rest/bitstring>> = Stream, State}) ->
    parse_PublicID_PUBLIC(Rest, Stream, 2, State);
parse_PublicID_PUBL({<<"I">>, State}) ->
    parse_PublicID_PUBLI(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_PublicID_PUBLI({<<"C", Rest/bitstring>> = Stream, State}) ->
    parse_PublicID_PUBLIC(Rest, Stream, 1, State);
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_PublicID_PUBLIC(?MATCH) ->
    {_, ?MATCH1} = consume_s(?MATCH),
    {Pub, ?MATCH2} = parse_PubidLiteral(?MATCH1),
    {_, ?MATCH3} = maybe_consume_s(?MATCH2),
    {{Pub, <<>>}, ?MATCH3}.

%%----------------------------------------------------------------------
%% Consume Nmtoken
%% [7] Nmtoken ::= (NameChar)+
%%----------------------------------------------------------------------
parse_Nmtoken(?MATCH) ->
    case parse_Name(Bytes, Stream, Pos, 0, State, []) of
        {<<>>, _, _, _, State1} -> fatal_error(bad_token, State1);
        Ret -> Ret
    end.

%%----------------------------------------------------------------------
%% [69] PEReference ::= '%' Name ';'
%% [WFC: No Recursion]
%% [WFC: In DTD]
%% % already trimmed
%% returns Name
%%----------------------------------------------------------------------
parse_PEReference(?MATCH) ->
    case parse_Name(?MATCH) of
        {Name, <<$;/utf8, Bytes1/bitstring>>, Stream1, Pos1, State1} ->
            {Name, Bytes1, Stream1, Pos1 + 1, State1};
        {_, Bytes1, _, _, State1} ->
            fatal_error(bad_peref, {Bytes1, State1})
    end.

%%----------------------------------------------------------------------
%% [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? ('[' intSubset ']' S?)? '>'
%% [16ns] doctypedecl ::= '<!DOCTYPE' S QName (S ExternalID)? S? ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
%% [VC: Root Element Type]
%% [WFC: External Subset]
%%----------------------------------------------------------------------

parse_doctypedecl_lt({<<"!DOCTYPE"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_doctypedecl_ltexDOCTYPE(Rest, Stream, 8, State);
parse_doctypedecl_lt({<<"!DOCTYP"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTYP(cf(State));
parse_doctypedecl_lt({<<"!DOCTY"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTY(cf(State));
parse_doctypedecl_lt({<<"!DOCT"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCT(cf(State));
parse_doctypedecl_lt({<<"!DOC"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOC(cf(State));
parse_doctypedecl_lt({<<"!DO"/utf8>>, State}) ->
    parse_doctypedecl_ltexDO(cf(State));
parse_doctypedecl_lt({<<"!D"/utf8>>, State}) ->
    parse_doctypedecl_ltexD(cf(State));
parse_doctypedecl_lt({<<"!"/utf8>>, State}) ->
    parse_doctypedecl_ltex(cf(State));
parse_doctypedecl_lt({<<>>, State}) ->
    parse_doctypedecl_lt(cf(State));
parse_doctypedecl_lt({_, State}) ->
    fatal_error(bad_doctype, State).

parse_doctypedecl_ltex({<<"DOCTYPE"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_doctypedecl_ltexDOCTYPE(Rest, Stream, 7, State);
parse_doctypedecl_ltex({<<"DOCTYP"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTYP(cf(State));
parse_doctypedecl_ltex({<<"DOCTY"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTY(cf(State));
parse_doctypedecl_ltex({<<"DOCT"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCT(cf(State));
parse_doctypedecl_ltex({<<"DOC"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOC(cf(State));
parse_doctypedecl_ltex({<<"DO"/utf8>>, State}) ->
    parse_doctypedecl_ltexDO(cf(State));
parse_doctypedecl_ltex({<<"D"/utf8>>, State}) ->
    parse_doctypedecl_ltexD(cf(State));
parse_doctypedecl_ltex({<<>>, State}) ->
    parse_doctypedecl_ltex(cf(State));
parse_doctypedecl_ltex({_, State}) ->
    fatal_error(bad_doctype, State).

parse_doctypedecl_ltexD({<<"OCTYPE"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_doctypedecl_ltexDOCTYPE(Rest, Stream, 6, State);
parse_doctypedecl_ltexD({<<"OCTYP"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTYP(cf(State));
parse_doctypedecl_ltexD({<<"OCTY"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTY(cf(State));
parse_doctypedecl_ltexD({<<"OCT"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCT(cf(State));
parse_doctypedecl_ltexD({<<"OC"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOC(cf(State));
parse_doctypedecl_ltexD({<<"O"/utf8>>, State}) ->
    parse_doctypedecl_ltexDO(cf(State));
parse_doctypedecl_ltexD({<<>>, State}) ->
    parse_doctypedecl_ltexD(cf(State));
parse_doctypedecl_ltexD({_, State}) ->
    fatal_error(bad_doctype, State).

parse_doctypedecl_ltexDO({<<"CTYPE"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_doctypedecl_ltexDOCTYPE(Rest, Stream, 5, State);
parse_doctypedecl_ltexDO({<<"CTYP"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTYP(cf(State));
parse_doctypedecl_ltexDO({<<"CTY"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTY(cf(State));
parse_doctypedecl_ltexDO({<<"CT"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCT(cf(State));
parse_doctypedecl_ltexDO({<<"C"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOC(cf(State));
parse_doctypedecl_ltexDO({<<>>, State}) ->
    parse_doctypedecl_ltexDO(cf(State));
parse_doctypedecl_ltexDO({_, State}) ->
    fatal_error(bad_doctype, State).

parse_doctypedecl_ltexDOC({<<"TYPE"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_doctypedecl_ltexDOCTYPE(Rest, Stream, 4, State);
parse_doctypedecl_ltexDOC({<<"TYP"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTYP(cf(State));
parse_doctypedecl_ltexDOC({<<"TY"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTY(cf(State));
parse_doctypedecl_ltexDOC({<<"T"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCT(cf(State));
parse_doctypedecl_ltexDOC({<<>>, State}) ->
    parse_doctypedecl_ltexDOC(cf(State));
parse_doctypedecl_ltexDOC({_, State}) ->
    fatal_error(bad_doctype, State).

parse_doctypedecl_ltexDOCT({<<"YPE"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_doctypedecl_ltexDOCTYPE(Rest, Stream, 3, State);
parse_doctypedecl_ltexDOCT({<<"YP"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTYP(cf(State));
parse_doctypedecl_ltexDOCT({<<"Y"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTY(cf(State));
parse_doctypedecl_ltexDOCT({<<>>, State}) ->
    parse_doctypedecl_ltexDOCT(cf(State));
parse_doctypedecl_ltexDOCT({_, State}) ->
    fatal_error(bad_doctype, State).

parse_doctypedecl_ltexDOCTY({<<"PE"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_doctypedecl_ltexDOCTYPE(Rest, Stream, 2, State);
parse_doctypedecl_ltexDOCTY({<<"P"/utf8>>, State}) ->
    parse_doctypedecl_ltexDOCTYP(cf(State));
parse_doctypedecl_ltexDOCTY({<<>>, State}) ->
    parse_doctypedecl_ltexDOCTY(cf(State));
parse_doctypedecl_ltexDOCTY({_, State}) ->
    fatal_error(bad_doctype, State).

parse_doctypedecl_ltexDOCTYP({<<"E"/utf8, Rest/bitstring>> = Stream, State}) ->
    parse_doctypedecl_ltexDOCTYPE(Rest, Stream, 1, State);
parse_doctypedecl_ltexDOCTYP({<<>>, State}) ->
    parse_doctypedecl_ltexDOCTYP(cf(State));
parse_doctypedecl_ltexDOCTYP({_, State}) ->
    fatal_error(bad_doctype, State).

parse_ExternalID_syste({<<"M", Rest/bitstring>> = Stream, State}) ->
    parse_ExternalID_system(Rest, Stream, 1, State);
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_ExternalID_syste({_, State}) ->
    fatal_error(bad_system_id, State).

parse_ExternalID_syst({<<"EM", Rest/bitstring>> = Stream, State}) ->
    parse_ExternalID_system(Rest, Stream, 2, State);
parse_ExternalID_syst({<<"E">>, State}) ->
    parse_ExternalID_syste(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_ExternalID_syst({_, State}) ->
    fatal_error(bad_system_id, State).

parse_ExternalID_sys({<<"TEM", Rest/bitstring>> = Stream, State}) ->
    parse_ExternalID_system(Rest, Stream, 3, State);
parse_ExternalID_sys({<<"TE">>, State}) ->
    parse_ExternalID_syste(cf(State));
parse_ExternalID_sys({<<"T">>, State}) ->
    parse_ExternalID_syst(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_ExternalID_sys({_, State}) ->
    fatal_error(bad_system_id, State).

parse_ExternalID_sy({<<"STEM", Rest/bitstring>> = Stream, State}) ->
    parse_ExternalID_system(Rest, Stream, 4, State);
parse_ExternalID_sy({<<"STE">>, State}) ->
    parse_ExternalID_syste(cf(State));
parse_ExternalID_sy({<<"ST">>, State}) ->
    parse_ExternalID_syst(cf(State));
parse_ExternalID_sy({<<"S">>, State}) ->
    parse_ExternalID_sys(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_ExternalID_sy({_, State}) ->
    fatal_error(bad_system_id, State).

parse_ExternalID_s({<<"YSTEM", Rest/bitstring>> = Stream, State}) ->
    parse_ExternalID_system(Rest, Stream, 5, State);
parse_ExternalID_s({<<"YSTE">>, State}) ->
    parse_ExternalID_syste(cf(State));
parse_ExternalID_s({<<"YST">>, State}) ->
    parse_ExternalID_syst(cf(State));
parse_ExternalID_s({<<"YS">>, State}) ->
    parse_ExternalID_sys(cf(State));
parse_ExternalID_s({<<"Y">>, State}) ->
    parse_ExternalID_sy(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_ExternalID_s({_, State}) ->
    fatal_error(bad_system_id, State).

parse_ExternalID_publi({<<"C", Rest/bitstring>> = Stream, State}) ->
    parse_ExternalID_public(Rest, Stream, 1, State);
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_ExternalID_publi({_, State}) ->
    fatal_error(bad_public_id, State).

parse_ExternalID_publ({<<"IC", Rest/bitstring>> = Stream, State}) ->
    parse_ExternalID_public(Rest, Stream, 2, State);
parse_ExternalID_publ({<<"I">>, State}) ->
    parse_ExternalID_publi(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_ExternalID_publ({_, State}) ->
    fatal_error(bad_public_id, State).

parse_ExternalID_pub({<<"LIC", Rest/bitstring>> = Stream, State}) ->
    parse_ExternalID_public(Rest, Stream, 3, State);
parse_ExternalID_pub({<<"LI">>, State}) ->
    parse_ExternalID_publi(cf(State));
parse_ExternalID_pub({<<"L">>, State}) ->
    parse_ExternalID_publ(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_ExternalID_pub({_, State}) ->
    fatal_error(bad_public_id, State).

parse_ExternalID_pu({<<"BLIC", Rest/bitstring>> = Stream, State}) ->
    parse_ExternalID_public(Rest, Stream, 4, State);
parse_ExternalID_pu({<<"BLI">>, State}) ->
    parse_ExternalID_publi(cf(State));
parse_ExternalID_pu({<<"BL">>, State}) ->
    parse_ExternalID_publ(cf(State));
parse_ExternalID_pu({<<"B">>, State}) ->
    parse_ExternalID_pub(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_ExternalID_pu({_, State}) ->
    fatal_error(bad_public_id, State).

parse_ExternalID_p({<<"UBLIC", Rest/bitstring>> = Stream, State}) ->
    parse_ExternalID_public(Rest, Stream, 5, State);
parse_ExternalID_p({<<"UBLI">>, State}) ->
    parse_ExternalID_publi(cf(State));
parse_ExternalID_p({<<"UBL">>, State}) ->
    parse_ExternalID_publ(cf(State));
parse_ExternalID_p({<<"UB">>, State}) ->
    parse_ExternalID_pub(cf(State));
parse_ExternalID_p({<<"U">>, State}) ->
    parse_ExternalID_pu(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_ExternalID_p({_, State}) ->
    fatal_error(bad_public_id, State).

parse_intSubset_ltex({<<"--"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {?MATCH1} = consume_Comment(Bytes, Stream, 2, State),
    parse_intSubset(?MATCH1, DTD);
parse_intSubset_ltex({<<"-"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexdash(cf(State), DTD);
parse_intSubset_ltex({<<"ELEMENT"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_elementdecl(Bytes, Stream, 7, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltex({<<"ELEMEN"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEMEN(cf(State), DTD);
parse_intSubset_ltex({<<"ELEME"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEME(cf(State), DTD);
parse_intSubset_ltex({<<"ELEM"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEM(cf(State), DTD);
parse_intSubset_ltex({<<"ELE"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELE(cf(State), DTD);
parse_intSubset_ltex({<<"EL"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexEL(cf(State), DTD);
parse_intSubset_ltex({<<"E"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexE(cf(State), DTD);
parse_intSubset_ltex({<<"ATTLIST"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_AttlistDecl(Bytes, Stream, 7, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltex({<<"ATTLIS"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLIS(cf(State), DTD);
parse_intSubset_ltex({<<"ATTLI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLI(cf(State), DTD);
parse_intSubset_ltex({<<"ATTL"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTL(cf(State), DTD);
parse_intSubset_ltex({<<"ATT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATT(cf(State), DTD);
parse_intSubset_ltex({<<"AT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexAT(cf(State), DTD);
parse_intSubset_ltex({<<"A"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexA(cf(State), DTD);
parse_intSubset_ltex({<<"ENTITY"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_EntityDecl(Bytes, Stream, 6, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltex({<<"ENTIT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENTIT(cf(State), DTD);
parse_intSubset_ltex({<<"ENTI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENTI(cf(State), DTD);
parse_intSubset_ltex({<<"ENT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENT(cf(State), DTD);
parse_intSubset_ltex({<<"EN"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexEN(cf(State), DTD);
parse_intSubset_ltex({<<"NOTATION"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_NotationDecl(Bytes, Stream, 8, State, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltex({<<"NOTATIO"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATIO(cf(State), DTD);
parse_intSubset_ltex({<<"NOTATI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATI(cf(State), DTD);
parse_intSubset_ltex({<<"NOTAT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTAT(cf(State), DTD);
parse_intSubset_ltex({<<"NOTA"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTA(cf(State), DTD);
parse_intSubset_ltex({<<"NOT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOT(cf(State), DTD);
parse_intSubset_ltex({<<"NO"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNO(cf(State), DTD);
parse_intSubset_ltex({<<"N"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexN(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltex({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_lt({<<"?"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {PI, ?MATCH1} = parse_PI(Bytes, Stream, 1, State),
    DTD1 = add_pi_comment_to_dtd(PI, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_lt({<<"!--"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {?MATCH1} = consume_Comment(Bytes, Stream, 3, State),
    parse_intSubset(?MATCH1, DTD);
parse_intSubset_lt({<<"!-"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexdash(cf(State), DTD);
parse_intSubset_lt({<<"!ELEMENT"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_elementdecl(Bytes, Stream, 8, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_lt({<<"!ELEMEN"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEMEN(cf(State), DTD);
parse_intSubset_lt({<<"!ELEME"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEME(cf(State), DTD);
parse_intSubset_lt({<<"!ELEM"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEM(cf(State), DTD);
parse_intSubset_lt({<<"!ELE"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELE(cf(State), DTD);
parse_intSubset_lt({<<"!EL"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexEL(cf(State), DTD);
parse_intSubset_lt({<<"!E"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexE(cf(State), DTD);
parse_intSubset_lt({<<"!"/utf8>>, State}, DTD) ->
    parse_intSubset_ltex(cf(State), DTD);
parse_intSubset_lt({<<"!ATTLIST"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_AttlistDecl(Bytes, Stream, 8, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_lt({<<"!ATTLIS"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLIS(cf(State), DTD);
parse_intSubset_lt({<<"!ATTLI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLI(cf(State), DTD);
parse_intSubset_lt({<<"!ATTL"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTL(cf(State), DTD);
parse_intSubset_lt({<<"!ATT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATT(cf(State), DTD);
parse_intSubset_lt({<<"!AT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexAT(cf(State), DTD);
parse_intSubset_lt({<<"!A"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexA(cf(State), DTD);
parse_intSubset_lt({<<"!ENTITY"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_EntityDecl(Bytes, Stream, 7, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_lt({<<"!ENTIT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENTIT(cf(State), DTD);
parse_intSubset_lt({<<"!ENTI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENTI(cf(State), DTD);
parse_intSubset_lt({<<"!ENT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENT(cf(State), DTD);
parse_intSubset_lt({<<"!EN"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexEN(cf(State), DTD);
parse_intSubset_lt({<<"!NOTATION"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_NotationDecl(Bytes, Stream, 9, State, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_lt({<<"!NOTATIO"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATIO(cf(State), DTD);
parse_intSubset_lt({<<"!NOTATI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATI(cf(State), DTD);
parse_intSubset_lt({<<"!NOTAT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTAT(cf(State), DTD);
parse_intSubset_lt({<<"!NOTA"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTA(cf(State), DTD);
parse_intSubset_lt({<<"!NOT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOT(cf(State), DTD);
parse_intSubset_lt({<<"!NO"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNO(cf(State), DTD);
parse_intSubset_lt({<<"!N"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexN(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_lt({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexN({<<"OTATION"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_NotationDecl(Bytes, Stream, 7, State, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexN({<<"OTATIO"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATIO(cf(State), DTD);
parse_intSubset_ltexN({<<"OTATI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATI(cf(State), DTD);
parse_intSubset_ltexN({<<"OTAT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTAT(cf(State), DTD);
parse_intSubset_ltexN({<<"OTA"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTA(cf(State), DTD);
parse_intSubset_ltexN({<<"OT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOT(cf(State), DTD);
parse_intSubset_ltexN({<<"O"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNO(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexN({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexNO({<<"TATION"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_NotationDecl(Bytes, Stream, 6, State, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexNO({<<"TATIO"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATIO(cf(State), DTD);
parse_intSubset_ltexNO({<<"TATI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATI(cf(State), DTD);
parse_intSubset_ltexNO({<<"TAT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTAT(cf(State), DTD);
parse_intSubset_ltexNO({<<"TA"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTA(cf(State), DTD);
parse_intSubset_ltexNO({<<"T"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOT(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexNO({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexNOT({<<"ATION"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_NotationDecl(Bytes, Stream, 5, State, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexNOT({<<"ATIO"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATIO(cf(State), DTD);
parse_intSubset_ltexNOT({<<"ATI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATI(cf(State), DTD);
parse_intSubset_ltexNOT({<<"AT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTAT(cf(State), DTD);
parse_intSubset_ltexNOT({<<"A"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTA(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexNOT({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexNOTA({<<"TION"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_NotationDecl(Bytes, Stream, 4, State, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexNOTA({<<"TIO"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATIO(cf(State), DTD);
parse_intSubset_ltexNOTA({<<"TI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATI(cf(State), DTD);
parse_intSubset_ltexNOTA({<<"T"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTAT(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexNOTA({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexNOTAT({<<"ION"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_NotationDecl(Bytes, Stream, 3, State, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexNOTAT({<<"IO"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATIO(cf(State), DTD);
parse_intSubset_ltexNOTAT({<<"I"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATI(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexNOTAT({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexNOTATI({<<"ON"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_NotationDecl(Bytes, Stream, 2, State, DTD),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexNOTATI({<<"O"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexNOTATIO(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexNOTATI({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexNOTATIO({<<"N"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_NotationDecl(Bytes, Stream, 1, State, DTD),
    parse_intSubset(?MATCH1, DTD1);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexNOTATIO({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexA({<<"TTLIST"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_AttlistDecl(Bytes, Stream, 6, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexA({<<"TTLIS"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLIS(cf(State), DTD);
parse_intSubset_ltexA({<<"TTLI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLI(cf(State), DTD);
parse_intSubset_ltexA({<<"TTL"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTL(cf(State), DTD);
parse_intSubset_ltexA({<<"TT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATT(cf(State), DTD);
parse_intSubset_ltexA({<<"T"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexAT(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexA({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexAT({<<"TLIST"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_AttlistDecl(Bytes, Stream, 5, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexAT({<<"TLIS"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLIS(cf(State), DTD);
parse_intSubset_ltexAT({<<"TLI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLI(cf(State), DTD);
parse_intSubset_ltexAT({<<"TL"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTL(cf(State), DTD);
parse_intSubset_ltexAT({<<"T"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATT(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexAT({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexATT({<<"LIST"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_AttlistDecl(Bytes, Stream, 4, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexATT({<<"LIS"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLIS(cf(State), DTD);
parse_intSubset_ltexATT({<<"LI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLI(cf(State), DTD);
parse_intSubset_ltexATT({<<"L"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTL(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexATT({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexATTL({<<"IST"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_AttlistDecl(Bytes, Stream, 3, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexATTL({<<"IS"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLIS(cf(State), DTD);
parse_intSubset_ltexATTL({<<"I"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLI(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexATTL({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexATTLI({<<"ST"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_AttlistDecl(Bytes, Stream, 2, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexATTLI({<<"S"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexATTLIS(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexATTLI({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexATTLIS({<<"T"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_AttlistDecl(Bytes, Stream, 1, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexATTLIS({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexE({<<"LEMENT"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_elementdecl(Bytes, Stream, 6, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexE({<<"LEMEN"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEMEN(cf(State), DTD);
parse_intSubset_ltexE({<<"LEME"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEME(cf(State), DTD);
parse_intSubset_ltexE({<<"LEM"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEM(cf(State), DTD);
parse_intSubset_ltexE({<<"LE"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELE(cf(State), DTD);
parse_intSubset_ltexE({<<"L"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexEL(cf(State), DTD);
parse_intSubset_ltexE({<<"NTITY"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_EntityDecl(Bytes, Stream, 5, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexE({<<"NTIT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENTIT(cf(State), DTD);
parse_intSubset_ltexE({<<"NTI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENTI(cf(State), DTD);
parse_intSubset_ltexE({<<"NT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENT(cf(State), DTD);
parse_intSubset_ltexE({<<"N"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexEN(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexE({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexEL({<<"EMENT"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_elementdecl(Bytes, Stream, 5, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexEL({<<"EMEN"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEMEN(cf(State), DTD);
parse_intSubset_ltexEL({<<"EME"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEME(cf(State), DTD);
parse_intSubset_ltexEL({<<"EM"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEM(cf(State), DTD);
parse_intSubset_ltexEL({<<"E"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELE(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexEL({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexELE({<<"MENT"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_elementdecl(Bytes, Stream, 4, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexELE({<<"MEN"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEMEN(cf(State), DTD);
parse_intSubset_ltexELE({<<"ME"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEME(cf(State), DTD);
parse_intSubset_ltexELE({<<"M"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEM(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexELE({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexELEM({<<"ENT"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_elementdecl(Bytes, Stream, 3, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexELEM({<<"EN"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEMEN(cf(State), DTD);
parse_intSubset_ltexELEM({<<"E"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEME(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexELEM({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexELEME({<<"NT"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_elementdecl(Bytes, Stream, 2, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexELEME({<<"N"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexELEMEN(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexELEME({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexELEMEN({<<"T"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_elementdecl(Bytes, Stream, 1, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexELEMEN({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexEN({<<"TITY"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_EntityDecl(Bytes, Stream, 4, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexEN({<<"TIT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENTIT(cf(State), DTD);
parse_intSubset_ltexEN({<<"TI"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENTI(cf(State), DTD);
parse_intSubset_ltexEN({<<"T"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENT(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexEN({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexENT({<<"ITY"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_EntityDecl(Bytes, Stream, 3, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexENT({<<"IT"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENTIT(cf(State), DTD);
parse_intSubset_ltexENT({<<"I"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENTI(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexENT({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexENTI({<<"TY"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_EntityDecl(Bytes, Stream, 2, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
parse_intSubset_ltexENTI({<<"T"/utf8>>, State}, DTD) ->
    parse_intSubset_ltexENTIT(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexENTI({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexENTIT({<<"Y"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {DTD1, ?MATCH1} = parse_EntityDecl(Bytes, Stream, 1, State, DTD, false),
    parse_intSubset(?MATCH1, DTD1);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexENTIT({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_intSubset_ltexdash({<<"-"/utf8, Bytes/bitstring>> = Stream, State}, DTD) ->
    {?MATCH1} = consume_Comment(Bytes, Stream, 1, State),
    parse_intSubset(?MATCH1, DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD);
parse_intSubset_ltexdash({_, State}, _DTD) ->
    fatal_error(bad_dtd, State).

parse_contentspec_E({<<"MPTY", Rest/bitstring>> = Stream, State}) ->
    {empty, Rest, Stream, 4, State};
parse_contentspec_E({<<"MPT">>, State}) ->
    parse_contentspec_EMPT(cf(State));
parse_contentspec_E({<<"MP">>, State}) ->
    parse_contentspec_EMP(cf(State));
parse_contentspec_E({<<"M">>, State}) ->
    parse_contentspec_EM(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_contentspec_EM({<<"PTY", Rest/bitstring>> = Stream, State}) ->
    {empty, Rest, Stream, 3, State};
parse_contentspec_EM({<<"PT">>, State}) ->
    parse_contentspec_EMPT(cf(State));
parse_contentspec_EM({<<"P">>, State}) ->
    parse_contentspec_EMP(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_contentspec_EMP({<<"TY", Rest/bitstring>> = Stream, State}) ->
    {empty, Rest, Stream, 2, State};
parse_contentspec_EMP({<<"T">>, State}) ->
    parse_contentspec_EMPT(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_contentspec_EMPT({<<"Y", Rest/bitstring>> = Stream, State}) ->
    {empty, Rest, Stream, 1, State};
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_contentspec_A({<<"NY", Rest/bitstring>> = Stream, State}) ->
    {any, Rest, Stream, 2, State};
parse_contentspec_A({<<"N">>, State}) ->
    parse_contentspec_AN(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_contentspec_AN({<<"Y", Rest/bitstring>> = Stream, State}) ->
    {any, Rest, Stream, 1, State};
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_Mixed_P({<<"CDATA", Rest/bitstring>> = Stream, State}, DTD, External) ->
    parse_Mixed_(Rest, Stream, 5, State, DTD, External);
parse_Mixed_P({<<"CDAT">>, State}, DTD, External) ->
    parse_Mixed_PCDAT(cf(State), DTD, External);
parse_Mixed_P({<<"CDA">>, State}, DTD, External) ->
    parse_Mixed_PCDA(cf(State), DTD, External);
parse_Mixed_P({<<"CD">>, State}, DTD, External) ->
    parse_Mixed_PCD(cf(State), DTD, External);
parse_Mixed_P({<<"C">>, State}, DTD, External) ->
    parse_Mixed_PC(cf(State), DTD, External);
?FUNCTION_NAME({<<>>, State}, DTD, External) ->
    ?FUNCTION_NAME(cf(State), DTD, External).

parse_Mixed_PC({<<"DATA", Rest/bitstring>> = Stream, State}, DTD, External) ->
    parse_Mixed_(Rest, Stream, 4, State, DTD, External);
parse_Mixed_PC({<<"DAT">>, State}, DTD, External) ->
    parse_Mixed_PCDAT(cf(State), DTD, External);
parse_Mixed_PC({<<"DA">>, State}, DTD, External) ->
    parse_Mixed_PCDA(cf(State), DTD, External);
parse_Mixed_PC({<<"D">>, State}, DTD, External) ->
    parse_Mixed_PCD(cf(State), DTD, External);
?FUNCTION_NAME({<<>>, State}, DTD, External) ->
    ?FUNCTION_NAME(cf(State), DTD, External).

parse_Mixed_PCD({<<"ATA", Rest/bitstring>> = Stream, State}, DTD, External) ->
    parse_Mixed_(Rest, Stream, 3, State, DTD, External);
parse_Mixed_PCD({<<"AT">>, State}, DTD, External) ->
    parse_Mixed_PCDAT(cf(State), DTD, External);
parse_Mixed_PCD({<<"A">>, State}, DTD, External) ->
    parse_Mixed_PCDA(cf(State), DTD, External);
?FUNCTION_NAME({<<>>, State}, DTD, External) ->
    ?FUNCTION_NAME(cf(State), DTD, External).

parse_Mixed_PCDA({<<"TA", Rest/bitstring>> = Stream, State}, DTD, External) ->
    parse_Mixed_(Rest, Stream, 2, State, DTD, External);
parse_Mixed_PCDA({<<"T">>, State}, DTD, External) ->
    parse_Mixed_PCDAT(cf(State), DTD, External);
?FUNCTION_NAME({<<>>, State}, DTD, External) ->
    ?FUNCTION_NAME(cf(State), DTD, External).

parse_Mixed_PCDAT({<<"A", Rest/bitstring>> = Stream, State}, DTD, External) ->
    parse_Mixed_(Rest, Stream, 1, State, DTD, External);
?FUNCTION_NAME({<<>>, State}, DTD, External) ->
    ?FUNCTION_NAME(cf(State), DTD, External).

parse_AttType_C({<<"DATA", Rest/bitstring>> = Stream, State}) -> {cdata, Rest, Stream, 4, State};
parse_AttType_C({<<"DAT">>, State}) -> parse_AttType_CDAT(cf(State));
parse_AttType_C({<<"DA">>, State}) -> parse_AttType_CDA(cf(State));
parse_AttType_C({<<"D">>, State}) -> parse_AttType_CD(cf(State));
?FUNCTION_NAME({<<>>, State}) -> ?FUNCTION_NAME(cf(State)).

parse_AttType_CD({<<"ATA", Rest/bitstring>> = Stream, State}) -> {cdata, Rest, Stream, 3, State};
parse_AttType_CD({<<"AT">>, State}) -> parse_AttType_CDAT(cf(State));
parse_AttType_CD({<<"A">>, State}) -> parse_AttType_CDA(cf(State));
?FUNCTION_NAME({<<>>, State}) -> ?FUNCTION_NAME(cf(State)).

parse_AttType_CDA({<<"TA", Rest/bitstring>> = Stream, State}) -> {cdata, Rest, Stream, 2, State};
parse_AttType_CDA({<<"T">>, State}) -> parse_AttType_CDAT(cf(State));
?FUNCTION_NAME({<<>>, State}) -> ?FUNCTION_NAME(cf(State)).

parse_AttType_CDAT({<<"A", Rest/bitstring>> = Stream, State}) -> {cdata, Rest, Stream, 1, State};
?FUNCTION_NAME({<<>>, State}) -> ?FUNCTION_NAME(cf(State)).

parse_AttType_N({<<"OTATION", Rest/bitstring>> = Stream, State}) ->
    parse_AttType_NOTATION(Rest, Stream, 7, State);
parse_AttType_N({<<"OTATIO">>, State}) ->
    parse_AttType_NOTATIO(cf(State));
parse_AttType_N({<<"OTATI">>, State}) ->
    parse_AttType_NOTATI(cf(State));
parse_AttType_N({<<"OTAT">>, State}) ->
    parse_AttType_NOTAT(cf(State));
parse_AttType_N({<<"OTA">>, State}) ->
    parse_AttType_NOTA(cf(State));
parse_AttType_N({<<"OT">>, State}) ->
    parse_AttType_NOT(cf(State));
parse_AttType_N({<<"O">>, State}) ->
    parse_AttType_NO(cf(State));
parse_AttType_N({<<"MTOKENS", Rest/bitstring>> = Stream, State}) ->
    {nmtokens, Rest, Stream, 7, State};
parse_AttType_N({<<"MTOKEN">>, State}) ->
    parse_AttType_NMTOKEN(cf(State));
parse_AttType_N({<<"MTOKEN", Rest/bitstring>> = Stream, State}) ->
    {nmtoken, Rest, Stream, 6, State};
parse_AttType_N({<<"MTOKE">>, State}) ->
    parse_AttType_NMTOKE(cf(State));
parse_AttType_N({<<"MTOK">>, State}) ->
    parse_AttType_NMTOK(cf(State));
parse_AttType_N({<<"MTO">>, State}) ->
    parse_AttType_NMTO(cf(State));
parse_AttType_N({<<"MT">>, State}) ->
    parse_AttType_NMT(cf(State));
parse_AttType_N({<<"M">>, State}) ->
    parse_AttType_NM(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NO({<<"TATION", Rest/bitstring>> = Stream, State}) ->
    parse_AttType_NOTATION(Rest, Stream, 6, State);
parse_AttType_NO({<<"TATIO">>, State}) ->
    parse_AttType_NOTATIO(cf(State));
parse_AttType_NO({<<"TATI">>, State}) ->
    parse_AttType_NOTATI(cf(State));
parse_AttType_NO({<<"TAT">>, State}) ->
    parse_AttType_NOTAT(cf(State));
parse_AttType_NO({<<"TA">>, State}) ->
    parse_AttType_NOTA(cf(State));
parse_AttType_NO({<<"T">>, State}) ->
    parse_AttType_NOT(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NOT({<<"ATION", Rest/bitstring>> = Stream, State}) ->
    parse_AttType_NOTATION(Rest, Stream, 5, State);
parse_AttType_NOT({<<"ATIO">>, State}) ->
    parse_AttType_NOTATIO(cf(State));
parse_AttType_NOT({<<"ATI">>, State}) ->
    parse_AttType_NOTATI(cf(State));
parse_AttType_NOT({<<"AT">>, State}) ->
    parse_AttType_NOTAT(cf(State));
parse_AttType_NOT({<<"A">>, State}) ->
    parse_AttType_NOTA(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NOTA({<<"TION", Rest/bitstring>> = Stream, State}) ->
    parse_AttType_NOTATION(Rest, Stream, 4, State);
parse_AttType_NOTA({<<"TIO">>, State}) ->
    parse_AttType_NOTATIO(cf(State));
parse_AttType_NOTA({<<"TI">>, State}) ->
    parse_AttType_NOTATI(cf(State));
parse_AttType_NOTA({<<"T">>, State}) ->
    parse_AttType_NOTAT(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NOTAT({<<"ION", Rest/bitstring>> = Stream, State}) ->
    parse_AttType_NOTATION(Rest, Stream, 3, State);
parse_AttType_NOTAT({<<"IO">>, State}) ->
    parse_AttType_NOTATIO(cf(State));
parse_AttType_NOTAT({<<"I">>, State}) ->
    parse_AttType_NOTATI(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NOTATI({<<"ON", Rest/bitstring>> = Stream, State}) ->
    parse_AttType_NOTATION(Rest, Stream, 2, State);
parse_AttType_NOTATI({<<"O">>, State}) ->
    parse_AttType_NOTATIO(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NOTATIO({<<"N", Rest/bitstring>> = Stream, State}) ->
    parse_AttType_NOTATION(Rest, Stream, 1, State);
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NM({<<"TOKENS", Rest/bitstring>> = Stream, State}) ->
    {nmtokens, Rest, Stream, 6, State};
parse_AttType_NM({<<"TOKEN">>, State}) ->
    parse_AttType_NMTOKEN(cf(State));
parse_AttType_NM({<<"TOKEN", Rest/bitstring>> = Stream, State}) ->
    {nmtoken, Rest, Stream, 5, State};
parse_AttType_NM({<<"TOKE">>, State}) ->
    parse_AttType_NMTOKE(cf(State));
parse_AttType_NM({<<"TOK">>, State}) ->
    parse_AttType_NMTOK(cf(State));
parse_AttType_NM({<<"TO">>, State}) ->
    parse_AttType_NMTO(cf(State));
parse_AttType_NM({<<"T">>, State}) ->
    parse_AttType_NMT(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NMT({<<"OKENS", Rest/bitstring>> = Stream, State}) ->
    {nmtokens, Rest, Stream, 5, State};
parse_AttType_NMT({<<"OKEN">>, State}) ->
    parse_AttType_NMTOKEN(cf(State));
parse_AttType_NMT({<<"OKEN", Rest/bitstring>> = Stream, State}) ->
    {nmtoken, Rest, Stream, 4, State};
parse_AttType_NMT({<<"OKE">>, State}) ->
    parse_AttType_NMTOKE(cf(State));
parse_AttType_NMT({<<"OK">>, State}) ->
    parse_AttType_NMTOK(cf(State));
parse_AttType_NMT({<<"O">>, State}) ->
    parse_AttType_NMTO(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NMTO({<<"KENS", Rest/bitstring>> = Stream, State}) ->
    {nmtokens, Rest, Stream, 4, State};
parse_AttType_NMTO({<<"KEN">>, State}) ->
    parse_AttType_NMTOKEN(cf(State));
parse_AttType_NMTO({<<"KEN", Rest/bitstring>> = Stream, State}) ->
    {nmtoken, Rest, Stream, 3, State};
parse_AttType_NMTO({<<"KE">>, State}) ->
    parse_AttType_NMTOKE(cf(State));
parse_AttType_NMTO({<<"K">>, State}) ->
    parse_AttType_NMTOK(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NMTOK({<<"ENS", Rest/bitstring>> = Stream, State}) ->
    {nmtokens, Rest, Stream, 3, State};
parse_AttType_NMTOK({<<"EN">>, State}) ->
    parse_AttType_NMTOKEN(cf(State));
parse_AttType_NMTOK({<<"EN", Rest/bitstring>> = Stream, State}) ->
    {nmtoken, Rest, Stream, 2, State};
parse_AttType_NMTOK({<<"E">>, State}) ->
    parse_AttType_NMTOKE(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NMTOKE({<<"NS", Rest/bitstring>> = Stream, State}) ->
    {nmtokens, Rest, Stream, 2, State};
parse_AttType_NMTOKE({<<"N">>, State}) ->
    parse_AttType_NMTOKEN(cf(State));
parse_AttType_NMTOKE({<<"N", Rest/bitstring>> = Stream, State}) ->
    {nmtoken, Rest, Stream, 1, State};
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_NMTOKEN({<<"S", Rest/bitstring>> = Stream, State}) ->
    {nmtokens, Rest, Stream, 1, State};
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_AttType_NMTOKEN({Stream, State}) ->
    {nmtoken, Stream, Stream, 0, State}.

parse_AttType_E({<<"NTITIES", Rest/bitstring>> = Stream, State}) ->
    {entities, Rest, Stream, 7, State};
parse_AttType_E({<<"NTITY", Rest/bitstring>> = Stream, State}) ->
    {entity, Rest, Stream, 5, State};
parse_AttType_E({<<"NTITIE">>, State}) ->
    parse_AttType_ENTITIE(cf(State));
parse_AttType_E({<<"NTITI">>, State}) ->
    parse_AttType_ENTITI(cf(State));
parse_AttType_E({<<"NTIT">>, State}) ->
    parse_AttType_ENTIT(cf(State));
parse_AttType_E({<<"NTI">>, State}) ->
    parse_AttType_ENTI(cf(State));
parse_AttType_E({<<"NT">>, State}) ->
    parse_AttType_ENT(cf(State));
parse_AttType_E({<<"N">>, State}) ->
    parse_AttType_EN(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_EN({<<"TITIES", Rest/bitstring>> = Stream, State}) ->
    {entities, Rest, Stream, 6, State};
parse_AttType_EN({<<"TITY", Rest/bitstring>> = Stream, State}) ->
    {entity, Rest, Stream, 4, State};
parse_AttType_EN({<<"TITIE">>, State}) ->
    parse_AttType_ENTITIE(cf(State));
parse_AttType_EN({<<"TITI">>, State}) ->
    parse_AttType_ENTITI(cf(State));
parse_AttType_EN({<<"TIT">>, State}) ->
    parse_AttType_ENTIT(cf(State));
parse_AttType_EN({<<"TI">>, State}) ->
    parse_AttType_ENTI(cf(State));
parse_AttType_EN({<<"T">>, State}) ->
    parse_AttType_ENT(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_ENT({<<"ITIES", Rest/bitstring>> = Stream, State}) ->
    {entities, Rest, Stream, 5, State};
parse_AttType_ENT({<<"ITY", Rest/bitstring>> = Stream, State}) ->
    {entity, Rest, Stream, 3, State};
parse_AttType_ENT({<<"ITIE">>, State}) ->
    parse_AttType_ENTITIE(cf(State));
parse_AttType_ENT({<<"ITI">>, State}) ->
    parse_AttType_ENTITI(cf(State));
parse_AttType_ENT({<<"IT">>, State}) ->
    parse_AttType_ENTIT(cf(State));
parse_AttType_ENT({<<"I">>, State}) ->
    parse_AttType_ENTI(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_ENTI({<<"TIES", Rest/bitstring>> = Stream, State}) ->
    {entities, Rest, Stream, 4, State};
parse_AttType_ENTI({<<"TY", Rest/bitstring>> = Stream, State}) ->
    {entity, Rest, Stream, 2, State};
parse_AttType_ENTI({<<"TIE">>, State}) ->
    parse_AttType_ENTITIE(cf(State));
parse_AttType_ENTI({<<"TI">>, State}) ->
    parse_AttType_ENTITI(cf(State));
parse_AttType_ENTI({<<"T">>, State}) ->
    parse_AttType_ENTIT(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_ENTIT({<<"IES", Rest/bitstring>> = Stream, State}) ->
    {entities, Rest, Stream, 3, State};
parse_AttType_ENTIT({<<"Y", Rest/bitstring>> = Stream, State}) ->
    {entity, Rest, Stream, 1, State};
parse_AttType_ENTIT({<<"IE">>, State}) ->
    parse_AttType_ENTITIE(cf(State));
parse_AttType_ENTIT({<<"I">>, State}) ->
    parse_AttType_ENTITI(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_ENTITI({<<"ES", Rest/bitstring>> = Stream, State}) ->
    {entities, Rest, Stream, 2, State};
parse_AttType_ENTITI({<<"E">>, State}) ->
    parse_AttType_ENTITIE(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_ENTITIE({<<"S", Rest/bitstring>> = Stream, State}) ->
    {entities, Rest, Stream, 1, State};
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_I({<<"DREFS", Rest/bitstring>> = Stream, State}) ->
    {idrefs, Rest, Stream, 5, State};
parse_AttType_I({<<"DREF">>, State}) ->
    parse_AttType_IDREF(cf(State));
parse_AttType_I({<<"DREF", Rest/bitstring>> = Stream, State}) ->
    {idref, Rest, Stream, 4, State};
parse_AttType_I({<<"DRE">>, State}) ->
    parse_AttType_IDRE(cf(State));
parse_AttType_I({<<"DR">>, State}) ->
    parse_AttType_IDR(cf(State));
parse_AttType_I({<<"D">>, State}) ->
    parse_AttType_ID(cf(State));
parse_AttType_I({<<"D", Bytes/bitstring>> = Stream, State}) ->
    {id, Bytes, Stream, 1, State};
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_ID({<<"REFS", Rest/bitstring>> = Stream, State}) ->
    {idrefs, Rest, Stream, 4, State};
parse_AttType_ID({<<"REF">>, State}) ->
    parse_AttType_IDREF(cf(State));
parse_AttType_ID({<<"REF", Rest/bitstring>> = Stream, State}) ->
    {idref, Rest, Stream, 3, State};
parse_AttType_ID({<<"RE">>, State}) ->
    parse_AttType_IDRE(cf(State));
parse_AttType_ID({<<"R">>, State}) ->
    parse_AttType_IDR(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_AttType_ID({Bytes, State}) ->
    {id, Bytes, Bytes, 0, State}.

parse_AttType_IDR({<<"EFS", Rest/bitstring>> = Stream, State}) ->
    {idrefs, Rest, Stream, 3, State};
parse_AttType_IDR({<<"EF">>, State}) ->
    parse_AttType_IDREF(cf(State));
parse_AttType_IDR({<<"EF", Rest/bitstring>> = Stream, State}) ->
    {idref, Rest, Stream, 2, State};
parse_AttType_IDR({<<"E">>, State}) ->
    parse_AttType_IDRE(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_IDRE({<<"FS", Rest/bitstring>> = Stream, State}) ->
    {idrefs, Rest, Stream, 2, State};
parse_AttType_IDRE({<<"F">>, State}) ->
    parse_AttType_IDREF(cf(State));
parse_AttType_IDRE({<<"F", Rest/bitstring>> = Stream, State}) ->
    {idref, Rest, Stream, 1, State};
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_AttType_IDREF({<<"S", Rest/bitstring>> = Stream, State}) ->
    {idrefs, Rest, Stream, 1, State};
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State));
parse_AttType_IDREF({Stream, State}) ->
    {idref, Stream, Stream, 0, State}.

parse_DefaultDecl_h({<<"REQUIRED", Rest/bitstring>> = Stream, State}, _) ->
    parse_DefaultDecl_hREQUIRED(Rest, Stream, 8, State);
parse_DefaultDecl_h({<<"REQUIRE">>, State}, _) ->
    parse_DefaultDecl_hREQUIRE(cf(State));
parse_DefaultDecl_h({<<"REQUIR">>, State}, _) ->
    parse_DefaultDecl_hREQUIR(cf(State));
parse_DefaultDecl_h({<<"REQUI">>, State}, _) ->
    parse_DefaultDecl_hREQUI(cf(State));
parse_DefaultDecl_h({<<"REQU">>, State}, _) ->
    parse_DefaultDecl_hREQU(cf(State));
parse_DefaultDecl_h({<<"REQ">>, State}, _) ->
    parse_DefaultDecl_hREQ(cf(State));
parse_DefaultDecl_h({<<"RE">>, State}, _) ->
    parse_DefaultDecl_hRE(cf(State));
parse_DefaultDecl_h({<<"R">>, State}, _) ->
    parse_DefaultDecl_hR(cf(State));
parse_DefaultDecl_h({<<"IMPLIED", Rest/bitstring>> = Stream, State}, _) ->
    parse_DefaultDecl_hIMPLIED(Rest, Stream, 7, State);
parse_DefaultDecl_h({<<"IMPLIE">>, State}, _) ->
    parse_DefaultDecl_hIMPLIE(cf(State));
parse_DefaultDecl_h({<<"IMPLI">>, State}, _) ->
    parse_DefaultDecl_hIMPLI(cf(State));
parse_DefaultDecl_h({<<"IMPL">>, State}, _) ->
    parse_DefaultDecl_hIMPL(cf(State));
parse_DefaultDecl_h({<<"IMP">>, State}, _) ->
    parse_DefaultDecl_hIMP(cf(State));
parse_DefaultDecl_h({<<"IM">>, State}, _) ->
    parse_DefaultDecl_hIM(cf(State));
parse_DefaultDecl_h({<<"I">>, State}, _) ->
    parse_DefaultDecl_hI(cf(State));
parse_DefaultDecl_h({<<"FIXED", Rest/bitstring>> = Stream, State}, DTD) ->
    parse_DefaultDecl_hFIXED(Rest, Stream, 5, State, DTD, false);
parse_DefaultDecl_h({<<"FIXE">>, State}, DTD) ->
    parse_DefaultDecl_hFIXE(cf(State), DTD);
parse_DefaultDecl_h({<<"FIX">>, State}, DTD) ->
    parse_DefaultDecl_hFIX(cf(State), DTD);
parse_DefaultDecl_h({<<"FI">>, State}, DTD) ->
    parse_DefaultDecl_hFI(cf(State), DTD);
parse_DefaultDecl_h({<<"F">>, State}, DTD) ->
    parse_DefaultDecl_hF(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD).

parse_DefaultDecl_hR({<<"EQUIRED", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hREQUIRED(Rest, Stream, 7, State);
parse_DefaultDecl_hR({<<"EQUIRE">>, State}) ->
    parse_DefaultDecl_hREQUIRE(cf(State));
parse_DefaultDecl_hR({<<"EQUIR">>, State}) ->
    parse_DefaultDecl_hREQUIR(cf(State));
parse_DefaultDecl_hR({<<"EQUI">>, State}) ->
    parse_DefaultDecl_hREQUI(cf(State));
parse_DefaultDecl_hR({<<"EQU">>, State}) ->
    parse_DefaultDecl_hREQU(cf(State));
parse_DefaultDecl_hR({<<"EQ">>, State}) ->
    parse_DefaultDecl_hREQ(cf(State));
parse_DefaultDecl_hR({<<"E">>, State}) ->
    parse_DefaultDecl_hRE(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hRE({<<"QUIRED", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hREQUIRED(Rest, Stream, 6, State);
parse_DefaultDecl_hRE({<<"QUIRE">>, State}) ->
    parse_DefaultDecl_hREQUIRE(cf(State));
parse_DefaultDecl_hRE({<<"QUIR">>, State}) ->
    parse_DefaultDecl_hREQUIR(cf(State));
parse_DefaultDecl_hRE({<<"QUI">>, State}) ->
    parse_DefaultDecl_hREQUI(cf(State));
parse_DefaultDecl_hRE({<<"QU">>, State}) ->
    parse_DefaultDecl_hREQU(cf(State));
parse_DefaultDecl_hRE({<<"Q">>, State}) ->
    parse_DefaultDecl_hREQ(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hREQ({<<"UIRED", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hREQUIRED(Rest, Stream, 5, State);
parse_DefaultDecl_hREQ({<<"UIRE">>, State}) ->
    parse_DefaultDecl_hREQUIRE(cf(State));
parse_DefaultDecl_hREQ({<<"UIR">>, State}) ->
    parse_DefaultDecl_hREQUIR(cf(State));
parse_DefaultDecl_hREQ({<<"UI">>, State}) ->
    parse_DefaultDecl_hREQUI(cf(State));
parse_DefaultDecl_hREQ({<<"U">>, State}) ->
    parse_DefaultDecl_hREQU(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hREQU({<<"IRED", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hREQUIRED(Rest, Stream, 4, State);
parse_DefaultDecl_hREQU({<<"IRE">>, State}) ->
    parse_DefaultDecl_hREQUIRE(cf(State));
parse_DefaultDecl_hREQU({<<"IR">>, State}) ->
    parse_DefaultDecl_hREQUIR(cf(State));
parse_DefaultDecl_hREQU({<<"I">>, State}) ->
    parse_DefaultDecl_hREQUI(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hREQUI({<<"RED", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hREQUIRED(Rest, Stream, 3, State);
parse_DefaultDecl_hREQUI({<<"RE">>, State}) ->
    parse_DefaultDecl_hREQUIRE(cf(State));
parse_DefaultDecl_hREQUI({<<"R">>, State}) ->
    parse_DefaultDecl_hREQUIR(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hREQUIR({<<"ED", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hREQUIRED(Rest, Stream, 2, State);
parse_DefaultDecl_hREQUIR({<<"E">>, State}) ->
    parse_DefaultDecl_hREQUIRE(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hREQUIRE({<<"D", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hREQUIRED(Rest, Stream, 1, State);
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hI({<<"MPLIED", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hIMPLIED(Rest, Stream, 6, State);
parse_DefaultDecl_hI({<<"MPLIE">>, State}) ->
    parse_DefaultDecl_hIMPLIE(cf(State));
parse_DefaultDecl_hI({<<"MPLI">>, State}) ->
    parse_DefaultDecl_hIMPLI(cf(State));
parse_DefaultDecl_hI({<<"MPL">>, State}) ->
    parse_DefaultDecl_hIMPL(cf(State));
parse_DefaultDecl_hI({<<"MP">>, State}) ->
    parse_DefaultDecl_hIMP(cf(State));
parse_DefaultDecl_hI({<<"M">>, State}) ->
    parse_DefaultDecl_hIM(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hIM({<<"PLIED", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hIMPLIED(Rest, Stream, 5, State);
parse_DefaultDecl_hIM({<<"PLIE">>, State}) ->
    parse_DefaultDecl_hIMPLIE(cf(State));
parse_DefaultDecl_hIM({<<"PLI">>, State}) ->
    parse_DefaultDecl_hIMPLI(cf(State));
parse_DefaultDecl_hIM({<<"PL">>, State}) ->
    parse_DefaultDecl_hIMPL(cf(State));
parse_DefaultDecl_hIM({<<"P">>, State}) ->
    parse_DefaultDecl_hIMP(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hIMP({<<"LIED", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hIMPLIED(Rest, Stream, 4, State);
parse_DefaultDecl_hIMP({<<"LIE">>, State}) ->
    parse_DefaultDecl_hIMPLIE(cf(State));
parse_DefaultDecl_hIMP({<<"LI">>, State}) ->
    parse_DefaultDecl_hIMPLI(cf(State));
parse_DefaultDecl_hIMP({<<"L">>, State}) ->
    parse_DefaultDecl_hIMPL(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hIMPL({<<"IED", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hIMPLIED(Rest, Stream, 3, State);
parse_DefaultDecl_hIMPL({<<"IE">>, State}) ->
    parse_DefaultDecl_hIMPLIE(cf(State));
parse_DefaultDecl_hIMPL({<<"I">>, State}) ->
    parse_DefaultDecl_hIMPLI(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hIMPLI({<<"ED", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hIMPLIED(Rest, Stream, 2, State);
parse_DefaultDecl_hIMPLI({<<"E">>, State}) ->
    parse_DefaultDecl_hIMPLIE(cf(State));
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hIMPLIE({<<"D", Rest/bitstring>> = Stream, State}) ->
    parse_DefaultDecl_hIMPLIED(Rest, Stream, 1, State);
?FUNCTION_NAME({<<>>, State}) ->
    ?FUNCTION_NAME(cf(State)).

parse_DefaultDecl_hF({<<"IXED", Rest/bitstring>> = Stream, State}, DTD) ->
    parse_DefaultDecl_hFIXED(Rest, Stream, 4, State, DTD, false);
parse_DefaultDecl_hF({<<"IXE">>, State}, DTD) ->
    parse_DefaultDecl_hFIXE(cf(State), DTD);
parse_DefaultDecl_hF({<<"IX">>, State}, DTD) ->
    parse_DefaultDecl_hFIX(cf(State), DTD);
parse_DefaultDecl_hF({<<"I">>, State}, DTD) ->
    parse_DefaultDecl_hFI(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD).

parse_DefaultDecl_hFI({<<"XED", Rest/bitstring>> = Stream, State}, DTD) ->
    parse_DefaultDecl_hFIXED(Rest, Stream, 3, State, DTD, false);
parse_DefaultDecl_hFI({<<"XE">>, State}, DTD) ->
    parse_DefaultDecl_hFIXE(cf(State), DTD);
parse_DefaultDecl_hFI({<<"X">>, State}, DTD) ->
    parse_DefaultDecl_hFIX(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD).

parse_DefaultDecl_hFIX({<<"ED", Rest/bitstring>> = Stream, State}, DTD) ->
    parse_DefaultDecl_hFIXED(Rest, Stream, 2, State, DTD, false);
parse_DefaultDecl_hFIX({<<"E">>, State}, DTD) ->
    parse_DefaultDecl_hFIXE(cf(State), DTD);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD).

parse_DefaultDecl_hFIXE({<<"D", Rest/bitstring>> = Stream, State}, DTD) ->
    parse_DefaultDecl_hFIXED(Rest, Stream, 1, State, DTD, false);
?FUNCTION_NAME({<<>>, State}, DTD) ->
    ?FUNCTION_NAME(cf(State), DTD).

add_element_to_dtd({Name, Elem}, #{elems := Elems} = DTD) ->
    DTD#{elems := Elems#{Name => Elem}}.

add_attlist_to_dtd({ElemName, AttDefs}, #{atts := Atts} = DTD) ->
    case Atts of
        #{ElemName := OldAttDefs} ->
            Merged = maps:merge(AttDefs, OldAttDefs),
            DTD#{atts := Atts#{ElemName => Merged}};
        _ ->
            DTD#{atts := Atts#{ElemName => AttDefs}}
    end.

add_notation_to_dtd({Name, Pub, Sys}, #{nots := Nots} = DTD) ->
    DTD#{nots := Nots#{Name => {Pub, Sys}}}.

%{Name, {general|parameter, internal|external|unparsed, Value}}
add_entity_to_dtd({Name, {general, Type, Value}}, #{gen_ents := Ents} = DTD) ->
    case is_map_key(Name, Ents) of
        true -> DTD;
        false -> DTD#{gen_ents := Ents#{Name => {Type, Value}}}
    end;
add_entity_to_dtd({Name, {parameter, Type, Value}}, #{par_ents := Ents} = DTD) ->
    case is_map_key(Name, Ents) of
        true -> DTD;
        false -> DTD#{par_ents := Ents#{Name => {Type, Value}}}
    end.

add_pi_comment_to_dtd(CommentPi, #{pi_comments := CmPis} = DTD) ->
    DTD#{pi_comments := [CommentPi | CmPis]}.

set_dtd_name(DTD, Name) -> DTD#{name := Name}.

set_dtd_external_id(DTD, ExternalId) -> DTD#{external_id := ExternalId}.

resolve_parameter_entity(
    PERef,
    #{par_ents := Params} = DTD,
    #ys_state{external = ExtResolver, base = Base, standalone = Standalone} = State,
    External,
    AsText
) ->
    % Replacement text in DTDs needs leading and trailing spaces added to ensure
    % proper nesting.
    case Params of
        #{PERef := {external, _PubSys}} when Standalone == true ->
            fatal_error(external_entity_in_standalone, State);
        #{PERef := {external, _PubSys}} when ExtResolver == undefined ->
            {replacement_text, <<>>};
        #{PERef := {external, PubSys}} when AsText == true ->
            {NewBase, Stream} = ExtResolver(PubSys, Base),
            {_, Bytes1, _Stream1, _Pos1, _State1} = parse_TextDecl(Stream, State#ys_state{
                continuation = undefined, base = NewBase
            }),
            Stream2 =
                if
                    External -> <<" ", Bytes1/bitstring, " ">>;
                    true -> Bytes1
                end,
            {replacement_text, Stream2};
        #{PERef := {external, PubSys}} ->
            {NewBase, Stream} = ExtResolver(PubSys, Base),
            {_, Bytes1, _Stream1, _Pos1, State1} = parse_TextDecl(Stream, State#ys_state{
                continuation = undefined, base = NewBase
            }),
            Stream2 =
                if
                    External -> <<" ", Bytes1/bitstring, " ">>;
                    true -> Bytes1
                end,
            {DTD1, _, _, _, _State3} = parse_extSubsetDecl(Stream2, Stream2, 0, State1, DTD),
            {dtd, DTD1};
        #{PERef := {internal, Value}} when External ->
            {replacement_text, <<" ", Value/bitstring, " ">>};
        #{PERef := {internal, Value}} ->
            {replacement_text, Value};
        _ ->
            fatal_error(unknown_parameter_entity, PERef)
    end.

resolve_general_entity(<<"amp">>, _, _) ->
    {gen, <<"&">>};
resolve_general_entity(<<"lt">>, _, _) ->
    {gen, <<"<">>};
resolve_general_entity(<<"gt">>, _, _) ->
    {gen, <<">">>};
resolve_general_entity(<<"apos">>, _, _) ->
    {gen, <<"'">>};
resolve_general_entity(<<"quot">>, _, _) ->
    {gen, <<"\"">>};
resolve_general_entity(Name, #ys_state{dtd = undefined}, _) ->
    {Name, <<$&, Name/binary, $;>>};
resolve_general_entity(
    Name, #ys_state{external = ExtResolver, dtd = #{gen_ents := Ents}} = State, Type
) ->
    case Ents of
        #{Name := {internal, {_, _}}} ->
            {Name, <<>>};
        #{Name := {internal, Value}} when Type == attribute ->
            ExpValue = expand_att_char_refs(Value, Value, 0, 0, State, []),
            {Name, {replacement_text, ExpValue}};
        #{Name := {internal, Value}} ->
            ExpValue = expand_char_refs(Value, Value, 0, 0, State, []),
            {Name, {replacement_text, ExpValue}};
        #{Name := {external, {_, _, _}}} when Type =/= entity ->
            fatal_error(unparsed_entity_outside_entity, Name);
        #{Name := {external, _}} when Type == attribute ->
            fatal_error(external_entity_in_attribute, Name);
        #{Name := {external, {Pub, Sys, _Name}}} when Type == entity ->
            ExtResolver = State#ys_state.external,
            {NewBase, Stream} = ExtResolver({Pub, Sys}, State#ys_state.base),
            {_, Bytes1, _, _, _} = parse_TextDecl(Stream, State#ys_state{base = NewBase}),
            {Name, {replacement_text, Bytes1}};
        #{Name := {external, {Pub, Sys}}} when
            Type == content andalso ExtResolver =/= undefined;
            Type == text andalso ExtResolver =/= undefined;
            Type == entity andalso ExtResolver =/= undefined
        ->
            ExtResolver = State#ys_state.external,
            {NewBase, Stream} = ExtResolver({Pub, Sys}, State#ys_state.base),
            {_, Bytes1, _, _, _} = parse_TextDecl(Stream, State#ys_state{base = NewBase}),
            {Name, {replacement_text, normalize_eol_characters(Bytes1)}};
        %% TODO: resolve
        _ when is_map_key(Name, Ents) ->
            {Name, <<>>};
        _ when Type == entity ->
            {Name, <<$&, Name/binary, $;>>};
        _ when Type == attribute; Type == text; Type == content ->
            #ys_state{dtd = #{par_ents := PEnts}} = State,
            case maps:size(PEnts) of
                0 ->
                    fatal_error(unknown_entity_in_entity, Name);
                _ ->
                    % Validity error
                    {gen, <<$&, Name/binary, $;>>}
            end;
        _ ->
            {gen, <<$&, Name/binary, $;>>}
    end.

expand_char_refs(<<$\r, $\n, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
?FUNCTION_NAME(<<$\r>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    case cf(State) of
        {<<$\n, Bytes1/bitstring>> = Stream1, State1} ->
            ?FUNCTION_NAME(Bytes1, Stream1, 1, 0, State1, Acc2);
        {Stream1, State1} ->
            ?FUNCTION_NAME(Stream1, Stream1, 0, 0, State1, Acc2)
    end;
expand_char_refs(<<$\r, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\n>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
expand_char_refs(<<$&, $#, $x, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {{hex, Ref}, ?MATCH1} = parse_Reference_hex(Rest, Stream, Pos + Len + 3, 0, State, []),
    Acc2 =
        case Ref of
            <<16#D>> -> ?APPEND(<<$&, $#, $x, $D, $;>>, Acc1);
            _ -> ?APPEND(Ref, Acc1)
        end,
    ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
expand_char_refs(<<$&, $#, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {{dec, Ref}, ?MATCH1} = parse_Reference_dec(Rest, Stream, Pos + Len + 2, 0, State, []),
    Acc2 =
        case Ref of
            <<16#D>> -> ?APPEND(<<$&, $#, $1, $3, $;>>, Acc1);
            _ -> ?APPEND(Ref, Acc1)
        end,
    ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
expand_char_refs(<<>>, Stream, Pos, Len, _State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    to_binary(Acc1);
?ONECHAR.

expand_att_char_refs(<<$\r, $\n, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 2, 0, State, Acc2);
expand_att_char_refs(<<$\t, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
expand_att_char_refs(<<$\n, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
expand_att_char_refs(<<$\r, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    Acc2 = ?APPEND(<<$\s>>, Acc1),
    ?FUNCTION_NAME(Rest, Stream, Pos + Len + 1, 0, State, Acc2);
expand_att_char_refs(<<$&, $#, $x, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {{hex, Ref}, ?MATCH1} = parse_Reference_hex(Rest, Stream, Pos + Len + 3, 0, State, []),
    Acc2 = ?APPEND(Ref, Acc1),
    ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
expand_att_char_refs(<<$&, $#, Rest/bitstring>>, Stream, Pos, Len, State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    {{dec, Ref}, ?MATCH1} = parse_Reference_dec(Rest, Stream, Pos + Len + 2, 0, State, []),
    Acc2 = ?APPEND(Ref, Acc1),
    ?FUNCTION_NAME(Bytes1, Stream1, Pos1, 0, State1, Acc2);
expand_att_char_refs(<<>>, Stream, Pos, Len, _State, Acc) ->
    Acc1 = ?ACC(Stream, Pos, Len, Acc),
    to_binary(Acc1);
?ONECHAR.

empty_proc_dtd() ->
    #{
        % Root element name
        name => undefined,
        % External DTD IDs
        external_id => undefined,
        % Element declarations
        elems => #{},
        % Attribute List declarations
        atts => #{},
        % Notation declarations
        nots => #{},
        % Entities used in the document content
        gen_ents => #{},
        % Entities used in the DTD
        par_ents => #{},
        % Stack of named references
        ref_stack => [],
        % Processing Instructions and comments from the DTD
        pi_comments => []
    }.

replacement_text_state(Bytes, #ys_state{dtd = #{ref_stack := RefStack} = DTD} = State, RefName) ->
    case
        lists:any(
            fun
                (A) when is_atom(A) -> false;
                (I) -> I == RefName
            end,
            RefStack
        )
    of
        true ->
            fatal_error(recursive_reference, {RefName, State});
        false ->
            DTD1 = DTD#{ref_stack := [RefName | RefStack]},
            State#ys_state{
                in_replacement = true,
                continuation = {fun(_) -> {Bytes, State} end, replacement},
                dtd = DTD1
            }
    end.

replacement_text_state(Bytes, #ys_state{in_replacement = InRepl} = State) ->
    State#ys_state{
        in_replacement = true,
        continuation = {fun(_) -> {Bytes, State#ys_state{in_replacement = InRepl}} end, replacement}
    }.

to_binary(Bin) when is_binary(Bin) -> Bin;
to_binary(IoList) -> iolist_to_binary(IoList).

%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%
%%                                                                                                                   %%
%%                                         External DTD Stuff                                                        %%
%%                                           NOT STREAMING                                                           %%
%%                                                                                                                   %%
%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%

% [78]   extParsedEnt        ::=       TextDecl? content
% [30]   extSubset           ::=       TextDecl? extSubsetDecl
% [77]   TextDecl            ::=       '<?xml' VersionInfo? EncodingDecl S? '?>'
parse_TextDecl(Stream, State) -> parse_TextDecl(Stream, Stream, 0, State).

parse_TextDecl(<<"<?xml"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    parse_TextDecl_ltqxml(Rest, Stream, Pos + 5, State);
parse_TextDecl(?MATCH) ->
    % default declaration
    {{<<"1.0">>, <<"UTF-8">>}, ?MATCH}.

parse_TextDecl_ltqxml(?MATCH) ->
    {{Version, _}, ?MATCH1} = parse_VersionInfo(?MATCH),
    {_, ?MATCH2} = maybe_consume_s(?MATCH1),
    {{Encoding, true}, ?MATCH3} = parse_EncodingDecl(?MATCH2),
    {_, ?MATCH4} = maybe_consume_s(?MATCH3),
    {?MATCH5} = parse_TextDecl_end(?MATCH4),
    {{Version, Encoding}, ?MATCH5}.

parse_TextDecl_end(<<"?>"/utf8, Rest/bitstring>>, Stream, Pos, State) ->
    {Rest, Stream, Pos + 2, State};
parse_TextDecl_end(Bytes, _, _, State) ->
    fatal_error(bad_textdecl, {Bytes, State}).

% [31]   extSubsetDecl       ::=       ( markupdecl | conditionalSect | DeclSep)*
% [61]   conditionalSect     ::=       includeSect | ignoreSect
% [62]   includeSect         ::=       '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'     [VC: Proper Conditional Section/PE Nesting]
% [63]   ignoreSect          ::=       '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'    [VC: Proper Conditional Section/PE Nesting]
% [64]   ignoreSectContents  ::=       Ignore ('<![' ignoreSectContents ']]>' Ignore)*
% [65]   Ignore              ::=       Char* - (Char* ('<![' | ']]>') Char*)
% [28a]  DeclSep             ::=       PEReference | S     [WFC: PE Between Declarations]
parse_ignoreSect(<<"]]>", Bytes/bitstring>>, Stream, Pos, State) ->
    {Bytes, Stream, Pos + 3, State};
parse_ignoreSect(<<"<![", Bytes/bitstring>>, Stream, Pos, State) ->
    {?MATCH1} = parse_ignoreSect(Bytes, Stream, Pos + 3, State),
    parse_ignoreSect(?MATCH1);
parse_ignoreSect(<<_/utf8, Bytes/bitstring>>, Stream, Pos, State) ->
    parse_ignoreSect(Bytes, Stream, Pos + 1, State);
parse_ignoreSect(<<>>, _, _, State) ->
    {Bytes1, State1} = cf(State),
    parse_ignoreSect(Bytes1, Bytes1, 0, State1).

parse_extSubsetDecl(<<"<![", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {_, ?MATCH1} = maybe_consume_s(Bytes, Stream, Pos + 3, State),
    case Bytes1 of
        <<"IGNORE", Bytes2/bitstring>> ->
            {_, <<"[", Bytes3/bitstring>>, Stream3, Pos3, State3} = maybe_consume_s(
                Bytes2, Stream1, Pos1 + 6, State1
            ),
            {?MATCH4} = parse_ignoreSect(Bytes3, Stream3, Pos3 + 1, State3),
            parse_extSubsetDecl(?MATCH4, DTD);
        <<"INCLUDE", Bytes2/bitstring>> ->
            {_, <<"[", Bytes3/bitstring>>, Stream3, Pos3, State3} = maybe_consume_s(
                Bytes2, Stream1, Pos1 + 7, State1
            ),
            {DTD1, ?MATCH4} = parse_extSubsetDecl(Bytes3, Stream3, Pos3 + 1, State3, DTD),
            case Bytes4 of
                <<"]]>", Bytes5/bitstring>> ->
                    parse_extSubsetDecl(Bytes5, Stream4, Pos4 + 3, State4, DTD1);
                _ ->
                    fatal_error(unbalanced_include, State4)
            end;
        <<"%", Bytes2/bitstring>> ->
            {PERef, Bytes3, _Stream3, _Pos3, State3} = parse_PEReference(
                Bytes2, Stream1, Pos1 + 1, State1
            ),
            case resolve_parameter_entity(PERef, DTD, State1, true, true) of
                {replacement_text, ReplacementText} ->
                    RTState = replacement_text_state(Bytes3, State3),
                    ReplacementText1 = <<"<![", ReplacementText/bitstring>>,
                    parse_extSubsetDecl(ReplacementText1, ReplacementText1, 0, RTState, DTD)
            end;
        _ ->
            fatal_error(bad_dtd, State)
    end;
parse_extSubsetDecl(<<"<!ELEMENT", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {DTD1, ?MATCH1} = parse_elementdecl(Bytes, Stream, Pos + 9, State, DTD, true),
    parse_extSubsetDecl(?MATCH1, DTD1);
parse_extSubsetDecl(<<"<!ATTLIST", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {DTD1, ?MATCH1} = parse_AttlistDecl(Bytes, Stream, Pos + 9, State, DTD, true),
    parse_extSubsetDecl(?MATCH1, DTD1);
parse_extSubsetDecl(<<"<!ENTITY", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {DTD1, ?MATCH1} = parse_EntityDecl(Bytes, Stream, Pos + 8, State, DTD, true),
    parse_extSubsetDecl(?MATCH1, DTD1);
parse_extSubsetDecl(<<"<!NOTATION", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {DTD1, ?MATCH1} = parse_NotationDecl(Bytes, Stream, Pos + 10, State, DTD),
    parse_extSubsetDecl(?MATCH1, DTD1);
parse_extSubsetDecl(<<"%", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {PERef, ?MATCH1} = parse_PEReference(Bytes, Stream, Pos + 1, State),
    case resolve_parameter_entity(PERef, DTD, State1, true, false) of
        {replacement_text, ReplacementText} ->
            RTState = replacement_text_state(Bytes1, State1),
            parse_extSubsetDecl(ReplacementText, ReplacementText, 0, RTState, DTD);
        {dtd, DTD1} ->
            parse_extSubsetDecl(?MATCH1, DTD1)
    end;
parse_extSubsetDecl(<<"]>", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {DTD, Bytes, Stream, Pos + 2, State};
parse_extSubsetDecl(<<Char/utf8, Bytes/bitstring>>, Stream, Pos, State, DTD) when
    Char == 16#20; Char == 16#9; Char == 16#A; Char == 16#D
->
    {_, ?MATCH1} = maybe_consume_s(Bytes, Stream, Pos + 1, State),
    parse_extSubsetDecl(?MATCH1, DTD);
parse_extSubsetDecl(<<"<!--", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {Comment, ?MATCH1} = parse_Comment(Bytes, Stream, Pos + 4, State),
    DTD1 = add_pi_comment_to_dtd(Comment, DTD),
    parse_extSubsetDecl(?MATCH1, DTD1);
parse_extSubsetDecl(<<"<?", Bytes/bitstring>>, Stream, Pos, State, DTD) ->
    {PI, ?MATCH1} = parse_PI(Bytes, Stream, Pos + 2, State),
    DTD1 = add_pi_comment_to_dtd(PI, DTD),
    parse_extSubsetDecl(?MATCH1, DTD1);
parse_extSubsetDecl(<<>>, Stream, Pos, State, DTD) ->
    {DTD, <<>>, Stream, Pos, State};
parse_extSubsetDecl(?MATCH, DTD) ->
    {DTD, ?MATCH}.

normalize_eol_characters(<<$\r, $\n, Rest/bitstring>>) ->
    <<$\n, (normalize_eol_characters(Rest))/bitstring>>;
normalize_eol_characters(<<$\r, Rest/bitstring>>) ->
    <<$\n, (normalize_eol_characters(Rest))/bitstring>>;
normalize_eol_characters(<<C, Rest/bitstring>>) ->
    <<C, (normalize_eol_characters(Rest))/bitstring>>;
normalize_eol_characters(<<>>) ->
    <<>>.

% Trim leading and trailing whitespace and shrink all consecutive whitespaces to a single space character.
% TODO: Trim trailing.
normalize_PubidLiteral(<<Char/utf8, Bytes/bitstring>>) when
    Char == 16#20; Char == 16#9; Char == 16#A; Char == 16#D
->
    normalize_PubidLiteral(Bytes);
normalize_PubidLiteral(<<>>) ->
    <<>>;
normalize_PubidLiteral(Bytes) when is_list(Bytes) ->
    normalize_PubidLiteral(iolist_to_binary(Bytes));
normalize_PubidLiteral(Bytes) ->
    normalize_PubidLiteral_1(Bytes).

normalize_PubidLiteral_1(<<Char1, Char2, Bytes/bitstring>>) when
    Char1 == 16#20 orelse Char1 == 16#9 orelse Char1 == 16#A orelse Char1 == 16#D,
    Char2 == 16#20 orelse Char2 == 16#9 orelse Char2 == 16#A orelse Char2 == 16#D
->
    normalize_PubidLiteral_1(<<" ", Bytes/bitstring>>);
normalize_PubidLiteral_1(<<Char1, Bytes/bitstring>>) when
    Char1 == 16#9 orelse Char1 == 16#A orelse Char1 == 16#D
->
    <<" ", (normalize_PubidLiteral_1(Bytes))/bitstring>>;
normalize_PubidLiteral_1(<<Char1, Bytes/bitstring>>) ->
    <<Char1, (normalize_PubidLiteral_1(Bytes))/bitstring>>;
normalize_PubidLiteral_1(<<>>) ->
    <<>>.