%%% Do not modify this file, it is automatically generated by abnfc.
%%% All changes will be lost when it is regenerated.
%%% Generated by abnfc_gen on 2020-12-22 12:15:37

-module(email_validator_abnf).

-export(['ALPHA'/0,
         'DIGIT'/0,
         'DQUOTE'/0,
         'H16'/0,
         'HEXDIG'/0,
         'IPv4-address-literal'/0,
         'IPv6-addr'/0,
         'IPv6-address-literal'/0,
         'LS32'/0,
         'U-Label'/0,
         'UTF8-2'/0,
         'UTF8-3'/0,
         'UTF8-4'/0,
         'UTF8-non-ascii'/0,
         'UTF8-tail'/0,
         'address-literal'/0,
         atext/0,
         atom/0,
         'dec-octet'/0,
         decode/2,
         domain/0,
         'domain-name'/0,
         'dot-string'/0,
         'hyphen-let-dig'/0,
         'ldh-str'/0,
         'let-dig'/0,
         'local-part'/0,
         mailbox/0,
         qcontentSMTP/0,
         qtextSMTP/0,
         'quoted-pairSMTP'/0,
         'quoted-string'/0,
         'sub-domain'/0]).

-include("email_validator_abnf.hrl").

decode(mailbox, Str) -> (mailbox())(Str);
decode(domain, Str) -> (domain())(Str);
decode('domain-name', Str) -> ('domain-name'())(Str);
decode('sub-domain', Str) -> ('sub-domain'())(Str);
decode('U-Label', Str) -> ('U-Label'())(Str);
decode('let-dig', Str) -> ('let-dig'())(Str);
decode('hyphen-let-dig', Str) ->
    ('hyphen-let-dig'())(Str);
decode('ldh-str', Str) -> ('ldh-str'())(Str);
decode('address-literal', Str) ->
    ('address-literal'())(Str);
decode('local-part', Str) -> ('local-part'())(Str);
decode('dot-string', Str) -> ('dot-string'())(Str);
decode('quoted-string', Str) ->
    ('quoted-string'())(Str);
decode(qcontentSMTP, Str) -> (qcontentSMTP())(Str);
decode('quoted-pairSMTP', Str) ->
    ('quoted-pairSMTP'())(Str);
decode(qtextSMTP, Str) -> (qtextSMTP())(Str);
decode(atext, Str) -> (atext())(Str);
decode(atom, Str) -> (atom())(Str);
decode('UTF8-non-ascii', Str) ->
    ('UTF8-non-ascii'())(Str);
decode('UTF8-2', Str) -> ('UTF8-2'())(Str);
decode('UTF8-3', Str) -> ('UTF8-3'())(Str);
decode('UTF8-4', Str) -> ('UTF8-4'())(Str);
decode('UTF8-tail', Str) -> ('UTF8-tail'())(Str);
decode('IPv4-address-literal', Str) ->
    ('IPv4-address-literal'())(Str);
decode('dec-octet', Str) -> ('dec-octet'())(Str);
decode('IPv6-address-literal', Str) ->
    ('IPv6-address-literal'())(Str);
decode('IPv6-addr', Str) -> ('IPv6-addr'())(Str);
decode('H16', Str) -> ('H16'())(Str);
decode('LS32', Str) -> ('LS32'())(Str);
decode('ALPHA', Str) -> ('ALPHA'())(Str);
decode('DIGIT', Str) -> ('DIGIT'())(Str);
decode('DQUOTE', Str) -> ('DQUOTE'())(Str);
decode('HEXDIG', Str) -> ('HEXDIG'())(Str).

mailbox() ->
    fun (T) ->
            __P = '__seq'(['local-part'(),
                           fun (<<64, Tl/binary>>) -> {ok, 64, Tl};
                               (_) -> fail
                           end,
                           domain()]),
            __P(T)
    end.

domain() ->
    fun (T) ->
            __P = '__alt'(['domain-name'(), 'address-literal'()]),
            __P(T)
    end.

'domain-name'() ->
    fun (T) ->
            __P = '__seq'(['sub-domain'(),
                           '__repeat'(0,
                                      infinity,
                                      '__seq'([fun (<<46, Tl/binary>>) -> {ok, 46, Tl};
                                                   (_) -> fail
                                               end,
                                               'sub-domain'()]))]),
            __P(T)
    end.

'sub-domain'() ->
    fun (T) ->
            __P = '__alt'(['__seq'(['let-dig'(),
                                    '__repeat'(0, 1, 'ldh-str'())]),
                           'U-Label'()]),
            __P(T)
    end.

'U-Label'() ->
    fun (T) ->
            __P = '__repeat'(1, infinity, 'UTF8-non-ascii'()),
            __P(T)
    end.

'let-dig'() ->
    fun (T) ->
            __P = '__alt'(['ALPHA'(), 'DIGIT'()]),
            __P(T)
    end.

'hyphen-let-dig'() ->
    fun (T) ->
            __P = '__seq'(['__repeat'(0,
                                      infinity,
                                      fun (<<45, Tl/binary>>) -> {ok, 45, Tl};
                                          (_) -> fail
                                      end),
                           'let-dig'()]),
            __P(T)
    end.

'ldh-str'() ->
    fun (T) ->
            __P = '__repeat'(1,
                             infinity,
                             '__alt'(['hyphen-let-dig'(), 'let-dig'()])),
            __P(T)
    end.

'address-literal'() ->
    fun (T) ->
            __P = '__alt'(['__seq'([fun (<<91, Tl/binary>>) ->
                                            {ok, 91, Tl};
                                        (_) -> fail
                                    end,
                                    'IPv4-address-literal'(),
                                    fun (<<93, Tl/binary>>) -> {ok, 93, Tl};
                                        (_) -> fail
                                    end]),
                           '__seq'([fun (<<91, Tl/binary>>) -> {ok, 91, Tl};
                                        (_) -> fail
                                    end,
                                    'IPv6-address-literal'(),
                                    fun (<<93, Tl/binary>>) -> {ok, 93, Tl};
                                        (_) -> fail
                                    end])]),
            __P(T)
    end.

'local-part'() ->
    fun (T) ->
            __P = '__alt'(['dot-string'(), 'quoted-string'()]),
            __P(T)
    end.

'dot-string'() ->
    fun (T) ->
            __P = '__seq'([atom(),
                           '__repeat'(0,
                                      infinity,
                                      '__seq'([fun (<<46, Tl/binary>>) -> {ok, 46, Tl};
                                                   (_) -> fail
                                               end,
                                               atom()]))]),
            __P(T)
    end.

'quoted-string'() ->
    fun (T) ->
            __P = '__seq'(['DQUOTE'(),
                           '__repeat'(0, infinity, qcontentSMTP()),
                           'DQUOTE'()]),
            __P(T)
    end.

qcontentSMTP() ->
    fun (T) ->
            __P = '__alt'([qtextSMTP(), 'quoted-pairSMTP'()]),
            __P(T)
    end.

'quoted-pairSMTP'() ->
    fun (T) ->
            __P = '__seq'([fun (<<92, Tl/binary>>) -> {ok, 92, Tl};
                               (_) -> fail
                           end,
                           fun (<<C, Tl/binary>>) when (C >= 32) and (C =< 126) ->
                                   {ok, C, Tl};
                               (_) -> fail
                           end]),
            __P(T)
    end.

qtextSMTP() ->
    fun (T) ->
            __P = '__alt'([fun (<<C, Tl/binary>>)
                                   when (C >= 32) and (C =< 33) ->
                                   {ok, C, Tl};
                               (<<C, Tl/binary>>) when (C >= 35) and (C =< 91) ->
                                   {ok, C, Tl};
                               (<<C, Tl/binary>>) when (C >= 93) and (C =< 126) ->
                                   {ok, C, Tl};
                               (_) -> fail
                           end,
                           'UTF8-non-ascii'()]),
            __P(T)
    end.

atext() ->
    fun (T) ->
            __P = '__alt'([fun (<<C, Tl/binary>>) when C == 33 ->
                                   {ok, C, Tl};
                               (<<C, Tl/binary>>) when (C >= 35) and (C =< 39) ->
                                   {ok, C, Tl};
                               (<<C, Tl/binary>>) when (C >= 42) and (C =< 43) ->
                                   {ok, C, Tl};
                               (<<C, Tl/binary>>) when C == 45 -> {ok, C, Tl};
                               (<<C, Tl/binary>>) when C == 47 -> {ok, C, Tl};
                               (<<C, Tl/binary>>) when C == 61 -> {ok, C, Tl};
                               (<<C, Tl/binary>>) when C == 63 -> {ok, C, Tl};
                               (<<C, Tl/binary>>) when (C >= 94) and (C =< 96) ->
                                   {ok, C, Tl};
                               (<<C, Tl/binary>>) when (C >= 123) and (C =< 126) ->
                                   {ok, C, Tl};
                               (_) -> fail
                           end,
                           'ALPHA'(),
                           'DIGIT'(),
                           'UTF8-non-ascii'()]),
            __P(T)
    end.

atom() ->
    fun (T) ->
            __P = '__repeat'(1, infinity, atext()),
            __P(T)
    end.

'UTF8-non-ascii'() ->
    fun (T) ->
            __P = '__alt'(['UTF8-2'(), 'UTF8-3'(), 'UTF8-4'()]),
            __P(T)
    end.

'UTF8-2'() ->
    fun (T) ->
            __P = '__seq'([fun (<<C, Tl/binary>>)
                                   when (C >= 194) and (C =< 223) ->
                                   {ok, C, Tl};
                               (_) -> fail
                           end,
                           'UTF8-tail'()]),
            __P(T)
    end.

'UTF8-3'() ->
    fun (T) ->
            __P = '__alt'(['__seq'([fun (<<224, Tl/binary>>) ->
                                            {ok, 224, Tl};
                                        (_) -> fail
                                    end,
                                    fun (<<C, Tl/binary>>) when (C >= 160) and (C =< 191) ->
                                            {ok, C, Tl};
                                        (_) -> fail
                                    end,
                                    'UTF8-tail'()]),
                           '__seq'([fun (<<C, Tl/binary>>)
                                            when (C >= 225) and (C =< 236) ->
                                            {ok, C, Tl};
                                        (_) -> fail
                                    end,
                                    '__repeat'(2, 2, 'UTF8-tail'())]),
                           '__seq'([fun (<<237, Tl/binary>>) -> {ok, 237, Tl};
                                        (_) -> fail
                                    end,
                                    fun (<<C, Tl/binary>>) when (C >= 128) and (C =< 159) ->
                                            {ok, C, Tl};
                                        (_) -> fail
                                    end,
                                    'UTF8-tail'()]),
                           '__seq'([fun (<<C, Tl/binary>>)
                                            when (C >= 238) and (C =< 239) ->
                                            {ok, C, Tl};
                                        (_) -> fail
                                    end,
                                    '__repeat'(2, 2, 'UTF8-tail'())])]),
            __P(T)
    end.

'UTF8-4'() ->
    fun (T) ->
            __P = '__alt'(['__seq'([fun (<<240, Tl/binary>>) ->
                                            {ok, 240, Tl};
                                        (_) -> fail
                                    end,
                                    fun (<<C, Tl/binary>>) when (C >= 144) and (C =< 191) ->
                                            {ok, C, Tl};
                                        (_) -> fail
                                    end,
                                    '__repeat'(2, 2, 'UTF8-tail'())]),
                           '__seq'([fun (<<C, Tl/binary>>)
                                            when (C >= 241) and (C =< 243) ->
                                            {ok, C, Tl};
                                        (_) -> fail
                                    end,
                                    '__repeat'(3, 3, 'UTF8-tail'())]),
                           '__seq'([fun (<<244, Tl/binary>>) -> {ok, 244, Tl};
                                        (_) -> fail
                                    end,
                                    fun (<<C, Tl/binary>>) when (C >= 128) and (C =< 143) ->
                                            {ok, C, Tl};
                                        (_) -> fail
                                    end,
                                    '__repeat'(2, 2, 'UTF8-tail'())])]),
            __P(T)
    end.

'UTF8-tail'() ->
    fun (T) ->
            __P = fun (<<C, Tl/binary>>)
                          when (C >= 128) and (C =< 191) ->
                          {ok, C, Tl};
                      (_) -> fail
                  end,
            __P(T)
    end.

'IPv4-address-literal'() ->
    fun (T) ->
            __P = '__seq'(['dec-octet'(),
                           '__repeat'(3,
                                      3,
                                      '__seq'([fun (<<46, Tl/binary>>) -> {ok, 46, Tl};
                                                   (_) -> fail
                                               end,
                                               'dec-octet'()]))]),
            __P(T)
    end.

'dec-octet'() ->
    fun (T) ->
            __P = '__alt'(['__seq'([fun (<<C1, C2, Tl/binary>>)
                                            when C1 == 50, C2 == 53 ->
                                            {ok, [C1, C2], Tl};
                                        (_) -> fail
                                    end,
                                    fun (<<C, Tl/binary>>) when (C >= 48) and (C =< 53) ->
                                            {ok, C, Tl};
                                        (_) -> fail
                                    end]),
                           '__seq'([fun (<<50, Tl/binary>>) -> {ok, 50, Tl};
                                        (_) -> fail
                                    end,
                                    fun (<<C, Tl/binary>>) when (C >= 48) and (C =< 52) ->
                                            {ok, C, Tl};
                                        (_) -> fail
                                    end,
                                    'DIGIT'()]),
                           '__seq'([fun (<<49, Tl/binary>>) -> {ok, 49, Tl};
                                        (_) -> fail
                                    end,
                                    '__repeat'(2, 2, 'DIGIT'())]),
                           '__seq'([fun (<<C, Tl/binary>>)
                                            when (C >= 49) and (C =< 57) ->
                                            {ok, C, Tl};
                                        (_) -> fail
                                    end,
                                    'DIGIT'()]),
                           'DIGIT'()]),
            __P(T)
    end.

'IPv6-address-literal'() ->
    fun (T) ->
            __P = '__seq'([fun (<<C1, C2, C3, C4, C5, Tl/binary>>)
                                   when (C1 == 105) or (C1 == 73),
                                        (C2 == 112) or (C2 == 80), (C3 == 118) or (C3 == 86),
                                        C4 == 54, C5 == 58 ->
                                   {ok, [C1, C2, C3, C4, C5], Tl};
                               (_) -> fail
                           end,
                           'IPv6-addr'()]),
            __P(T)
    end.

'IPv6-addr'() ->
    fun (T) ->
            __P = '__alt'(['__seq'(['__repeat'(6,
                                               6,
                                               '__seq'(['H16'(),
                                                        fun (<<58, Tl/binary>>) ->
                                                                {ok, 58, Tl};
                                                            (_) -> fail
                                                        end])),
                                    'LS32'()]),
                           '__seq'([fun (<<C1, C2, Tl/binary>>)
                                            when C1 == 58, C2 == 58 ->
                                            {ok, [C1, C2], Tl};
                                        (_) -> fail
                                    end,
                                    '__repeat'(5,
                                               5,
                                               '__seq'(['H16'(),
                                                        fun (<<58, Tl/binary>>) ->
                                                                {ok, 58, Tl};
                                                            (_) -> fail
                                                        end])),
                                    'LS32'()]),
                           '__seq'(['__repeat'(0, 1, 'H16'()),
                                    fun (<<C1, C2, Tl/binary>>) when C1 == 58, C2 == 58 ->
                                            {ok, [C1, C2], Tl};
                                        (_) -> fail
                                    end,
                                    '__repeat'(4,
                                               4,
                                               '__seq'(['H16'(),
                                                        fun (<<58, Tl/binary>>) ->
                                                                {ok, 58, Tl};
                                                            (_) -> fail
                                                        end])),
                                    'LS32'()]),
                           '__seq'(['__repeat'(0,
                                               1,
                                               '__seq'(['H16'(),
                                                        '__repeat'(0,
                                                                   1,
                                                                   '__seq'([fun (<<58,
                                                                                   Tl/binary>>) ->
                                                                                    {ok,
                                                                                     58,
                                                                                     Tl};
                                                                                (_) -> fail
                                                                            end,
                                                                            'H16'()]))])),
                                    fun (<<C1, C2, Tl/binary>>) when C1 == 58, C2 == 58 ->
                                            {ok, [C1, C2], Tl};
                                        (_) -> fail
                                    end,
                                    '__repeat'(3,
                                               3,
                                               '__seq'(['H16'(),
                                                        fun (<<58, Tl/binary>>) ->
                                                                {ok, 58, Tl};
                                                            (_) -> fail
                                                        end])),
                                    'LS32'()]),
                           '__seq'(['__repeat'(0,
                                               1,
                                               '__seq'(['H16'(),
                                                        '__repeat'(0,
                                                                   2,
                                                                   '__seq'([fun (<<58,
                                                                                   Tl/binary>>) ->
                                                                                    {ok,
                                                                                     58,
                                                                                     Tl};
                                                                                (_) -> fail
                                                                            end,
                                                                            'H16'()]))])),
                                    fun (<<C1, C2, Tl/binary>>) when C1 == 58, C2 == 58 ->
                                            {ok, [C1, C2], Tl};
                                        (_) -> fail
                                    end,
                                    '__repeat'(2,
                                               2,
                                               '__seq'(['H16'(),
                                                        fun (<<58, Tl/binary>>) ->
                                                                {ok, 58, Tl};
                                                            (_) -> fail
                                                        end])),
                                    'LS32'()]),
                           '__seq'(['__repeat'(0,
                                               1,
                                               '__seq'(['H16'(),
                                                        '__repeat'(0,
                                                                   3,
                                                                   '__seq'([fun (<<58,
                                                                                   Tl/binary>>) ->
                                                                                    {ok,
                                                                                     58,
                                                                                     Tl};
                                                                                (_) -> fail
                                                                            end,
                                                                            'H16'()]))])),
                                    fun (<<C1, C2, Tl/binary>>) when C1 == 58, C2 == 58 ->
                                            {ok, [C1, C2], Tl};
                                        (_) -> fail
                                    end,
                                    'H16'(),
                                    fun (<<58, Tl/binary>>) -> {ok, 58, Tl};
                                        (_) -> fail
                                    end,
                                    'LS32'()]),
                           '__seq'(['__repeat'(0,
                                               1,
                                               '__seq'(['H16'(),
                                                        '__repeat'(0,
                                                                   4,
                                                                   '__seq'([fun (<<58,
                                                                                   Tl/binary>>) ->
                                                                                    {ok,
                                                                                     58,
                                                                                     Tl};
                                                                                (_) -> fail
                                                                            end,
                                                                            'H16'()]))])),
                                    fun (<<C1, C2, Tl/binary>>) when C1 == 58, C2 == 58 ->
                                            {ok, [C1, C2], Tl};
                                        (_) -> fail
                                    end,
                                    'LS32'()]),
                           '__seq'(['__repeat'(0,
                                               1,
                                               '__seq'(['H16'(),
                                                        '__repeat'(0,
                                                                   5,
                                                                   '__seq'([fun (<<58,
                                                                                   Tl/binary>>) ->
                                                                                    {ok,
                                                                                     58,
                                                                                     Tl};
                                                                                (_) -> fail
                                                                            end,
                                                                            'H16'()]))])),
                                    fun (<<C1, C2, Tl/binary>>) when C1 == 58, C2 == 58 ->
                                            {ok, [C1, C2], Tl};
                                        (_) -> fail
                                    end,
                                    'H16'()]),
                           '__seq'(['__repeat'(0,
                                               1,
                                               '__seq'(['H16'(),
                                                        '__repeat'(0,
                                                                   6,
                                                                   '__seq'([fun (<<58,
                                                                                   Tl/binary>>) ->
                                                                                    {ok,
                                                                                     58,
                                                                                     Tl};
                                                                                (_) -> fail
                                                                            end,
                                                                            'H16'()]))])),
                                    fun (<<C1, C2, Tl/binary>>) when C1 == 58, C2 == 58 ->
                                            {ok, [C1, C2], Tl};
                                        (_) -> fail
                                    end])]),
            __P(T)
    end.

'H16'() ->
    fun (T) ->
            __P = '__repeat'(1, 4, 'HEXDIG'()),
            __P(T)
    end.

'LS32'() ->
    fun (T) ->
            __P = '__alt'(['__seq'(['H16'(),
                                    fun (<<58, Tl/binary>>) -> {ok, 58, Tl};
                                        (_) -> fail
                                    end,
                                    'H16'()]),
                           'IPv4-address-literal'()]),
            __P(T)
    end.

'ALPHA'() ->
    fun (T) ->
            __P = fun (<<C, Tl/binary>>)
                          when (C >= 65) and (C =< 90) ->
                          {ok, C, Tl};
                      (<<C, Tl/binary>>) when (C >= 97) and (C =< 122) ->
                          {ok, C, Tl};
                      (_) -> fail
                  end,
            __P(T)
    end.

'DIGIT'() ->
    fun (T) ->
            __P = fun (<<C, Tl/binary>>)
                          when (C >= 48) and (C =< 57) ->
                          {ok, C, Tl};
                      (_) -> fail
                  end,
            __P(T)
    end.

'DQUOTE'() ->
    fun (T) ->
            __P = fun (<<34, Tl/binary>>) -> {ok, 34, Tl};
                      (_) -> fail
                  end,
            __P(T)
    end.

'HEXDIG'() ->
    fun (T) ->
            __P = '__alt'(['DIGIT'(),
                           fun (<<C, Tl/binary>>) when C == 97 -> {ok, C, Tl};
                               (<<C, Tl/binary>>) when C == 65 -> {ok, C, Tl};
                               (_) -> fail
                           end,
                           fun (<<C, Tl/binary>>) when C == 98 -> {ok, C, Tl};
                               (<<C, Tl/binary>>) when C == 66 -> {ok, C, Tl};
                               (_) -> fail
                           end,
                           fun (<<C, Tl/binary>>) when C == 99 -> {ok, C, Tl};
                               (<<C, Tl/binary>>) when C == 67 -> {ok, C, Tl};
                               (_) -> fail
                           end,
                           fun (<<C, Tl/binary>>) when C == 100 -> {ok, C, Tl};
                               (<<C, Tl/binary>>) when C == 68 -> {ok, C, Tl};
                               (_) -> fail
                           end,
                           fun (<<C, Tl/binary>>) when C == 101 -> {ok, C, Tl};
                               (<<C, Tl/binary>>) when C == 69 -> {ok, C, Tl};
                               (_) -> fail
                           end,
                           fun (<<C, Tl/binary>>) when C == 102 -> {ok, C, Tl};
                               (<<C, Tl/binary>>) when C == 70 -> {ok, C, Tl};
                               (_) -> fail
                           end]),
            __P(T)
    end.

'__alt'([P | Ps]) ->
    fun (T) ->
            case P(T) of
                {ok, _R, _T1} = Res -> Res;
                fail ->
                    case Ps of
                        [] -> fail;
                        _ -> ('__alt'(Ps))(T)
                    end
            end
    end.

'__repeat'(Min, Max, P) -> '__repeat'(Min, Max, P, 0).

'__repeat'(Min, Max, P, Found) ->
    fun (T) ->
            case P(T) of
                {ok, R1, T1} when Max == Found + 1 -> {ok, [R1], T1};
                {ok, R1, T1} ->
                    case ('__repeat'(Min, Max, P, Found + 1))(T1) of
                        {ok, R2, T2} -> {ok, [R1 | R2], T2};
                        fail when Found >= Min -> {ok, [R1], T1};
                        fail -> fail
                    end;
                fail when Found >= Min -> {ok, [], T};
                fail -> fail
            end
    end.

'__seq'([P | Ps]) ->
    fun (T) ->
            case P(T) of
                {ok, R1, T1} ->
                    case ('__seq'(Ps))(T1) of
                        {ok, R2, T2} -> {ok, [R1 | R2], T2};
                        fail -> fail
                    end;
                fail -> fail
            end
    end;
'__seq'([]) -> fun (T) -> {ok, [], T} end.