aboutsummaryrefslogtreecommitdiffstats
path: root/lib/stdlib/src/re.erl
diff options
context:
space:
mode:
Diffstat (limited to 'lib/stdlib/src/re.erl')
-rw-r--r--lib/stdlib/src/re.erl751
1 files changed, 751 insertions, 0 deletions
diff --git a/lib/stdlib/src/re.erl b/lib/stdlib/src/re.erl
new file mode 100644
index 0000000000..5417ac02e5
--- /dev/null
+++ b/lib/stdlib/src/re.erl
@@ -0,0 +1,751 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2008-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(re).
+-export([grun/3,urun/3,ucompile/2,replace/3,replace/4,split/2,split/3]).
+
+%% Emulator builtins in this module:
+%% re:compile/1
+%% re:compile/2
+%% re:run/2
+%% re:run/3
+
+split(Subject,RE) ->
+ split(Subject,RE,[]).
+
+split(Subject,RE,Options) ->
+ try
+ {NewOpt,Convert,Unicode,Limit,Strip,Group} =
+ process_split_params(Options,iodata,false,-1,false,false),
+ FlatSubject =
+ case is_binary(Subject) of
+ true ->
+ Subject;
+ false ->
+ case Unicode of
+ true ->
+ unicode:characters_to_binary(Subject,unicode);
+ false ->
+ iolist_to_binary(Subject)
+ end
+ end,
+ case compile_split(RE,NewOpt) of
+ {error,_Err} ->
+ throw(badre);
+ {PreCompiled, NumSub, RunOpt} ->
+ % OK, lets run
+ case re:run(FlatSubject,PreCompiled,RunOpt ++ [global]) of
+ nomatch ->
+ case Group of
+ true ->
+ convert_any_split_result([[FlatSubject]],
+ Convert, Unicode,true);
+ false ->
+ convert_any_split_result([FlatSubject],
+ Convert, Unicode,false)
+ end;
+ {match, Matches} ->
+ Res = do_split(FlatSubject, 0, Matches, NumSub,
+ Limit, Group),
+ Stripped = case Strip of
+ true ->
+ backstrip_empty(Res,Group);
+ false ->
+ Res
+ end,
+ convert_any_split_result(Stripped, Convert, Unicode, Group)
+ end
+ end
+ catch
+ throw:badopt ->
+ erlang:error(badarg,[Subject,RE,Options]);
+ throw:badre ->
+ erlang:error(badarg,[Subject,RE,Options]);
+ error:badarg ->
+ erlang:error(badarg,[Subject,RE,Options])
+ end.
+
+backstrip_empty(List,false) ->
+ do_backstrip_empty(List);
+backstrip_empty(List, true) ->
+ do_backstrip_empty_g(List).
+
+do_backstrip_empty_g([]) ->
+ [];
+do_backstrip_empty_g([H]) ->
+ case do_backstrip_empty(H) of
+ [] ->
+ [];
+ _ ->
+ [H]
+ end;
+do_backstrip_empty_g([H|T]) ->
+ case do_backstrip_empty_g(T) of
+ [] ->
+ case do_backstrip_empty(H) of
+ [] ->
+ [];
+ _ ->
+ [H]
+ end;
+ Other ->
+ [H|Other]
+ end.
+
+do_backstrip_empty([]) ->
+ [];
+do_backstrip_empty([<<>>]) ->
+ [];
+do_backstrip_empty([<<>>|T]) ->
+ case do_backstrip_empty(T) of
+ [] ->
+ [];
+ Other ->
+ [<<>>|Other]
+ end;
+do_backstrip_empty([H|T]) ->
+ [H|do_backstrip_empty(T)].
+
+convert_any_split_result(List,Type,Uni,true) ->
+ [ convert_split_result(Part,Type,Uni) || Part <- List ];
+convert_any_split_result(List,Type,Uni, false) ->
+ convert_split_result(List,Type,Uni).
+
+convert_split_result(List, iodata, _Unicode) ->
+ List;
+convert_split_result(List, binary, _Unicode) ->
+ %% As it happens, the iodata is actually binaries
+ List;
+convert_split_result(List, list, true) ->
+ [unicode:characters_to_list(Element,unicode) || Element <- List];
+convert_split_result(List, list, false) ->
+ [binary_to_list(Element) || Element <- List].
+
+do_split(Subj, Off, _, _, 0, false) ->
+ <<_:Off/binary,Rest/binary>> = Subj,
+ [Rest];
+do_split(Subj, Off, [], _, _, false) ->
+ <<_:Off/binary,Rest/binary>> = Subj,
+ [Rest];
+do_split(Subj, Off, _, _, _,false) when byte_size(Subj) =< Off ->
+ [<<>>];
+do_split(Subj, Off, _, _, 0, true) ->
+ <<_:Off/binary,Rest/binary>> = Subj,
+ [[Rest]];
+do_split(Subj, Off, [], _, _, true) ->
+ <<_:Off/binary,Rest/binary>> = Subj,
+ [[Rest]];
+do_split(Subj, Off, _, _, _,true) when byte_size(Subj) =< Off ->
+ [[<<>>]];
+do_split(Subj, Offset, [[{MainI,MainL}|Sub]|T], NumSub, Limit, Group) ->
+ NewOffset = MainI+MainL,
+ KeptLen = MainI - Offset,
+ case {KeptLen,empty_sub(Sub),MainL} of
+ {0,true,0} ->
+ do_split(Subj,NewOffset,T,NumSub,Limit,Group);
+ _ ->
+ <<_:Offset/binary,Keep:KeptLen/binary,_/binary>> = Subj,
+ ESub = extend_subpatterns(Sub,NumSub),
+ Tail = do_split(Subj, NewOffset, T, NumSub, Limit - 1,Group),
+ case Group of
+ false ->
+ [Keep | dig_subpatterns(Subj,lists:reverse(ESub),Tail)];
+ true ->
+ [[Keep | dig_subpatterns(Subj,lists:reverse(ESub),[])]|
+ Tail]
+ end
+ end.
+empty_sub([]) ->
+ true;
+empty_sub([{_,0}|T]) ->
+ empty_sub(T);
+empty_sub(_) ->
+ false.
+
+dig_subpatterns(_,[],Acc) ->
+ Acc;
+dig_subpatterns(Subj,[{-1,0}|T],Acc) ->
+ dig_subpatterns(Subj,T,[<<>>|Acc]);
+dig_subpatterns(Subj,[{I,L}|T],Acc) ->
+ <<_:I/binary,Part:L/binary,_/binary>> = Subj,
+ dig_subpatterns(Subj,T,[Part|Acc]).
+
+extend_subpatterns(_,0) ->
+ [];
+extend_subpatterns([],N) ->
+ [{0,0} | extend_subpatterns([],N-1)];
+extend_subpatterns([H|T],N) ->
+ [H | extend_subpatterns(T,N-1)].
+
+compile_split({re_pattern,N,_,_} = Comp, Options) ->
+ {Comp,N,Options};
+compile_split(Pat,Options0) when not is_tuple(Pat) ->
+ Options = lists:filter(fun(O) ->
+ (not runopt(O))
+ end, Options0),
+ case re:compile(Pat,Options) of
+ {error,Err} ->
+ {error,Err};
+ {ok, {re_pattern,N,_,_} = Comp} ->
+ NewOpt = lists:filter(fun(OO) -> (not copt(OO)) end, Options0),
+ {Comp,N,NewOpt}
+ end;
+compile_split(_,_) ->
+ throw(badre).
+
+
+
+
+replace(Subject,RE,Replacement) ->
+ replace(Subject,RE,Replacement,[]).
+replace(Subject,RE,Replacement,Options) ->
+ try
+ {NewOpt,Convert,Unicode} =
+ process_repl_params(Options,iodata,false),
+ FlatSubject =
+ case is_binary(Subject) of
+ true ->
+ Subject;
+ false ->
+ case Unicode of
+ true ->
+ unicode:characters_to_binary(Subject,unicode);
+ false ->
+ iolist_to_binary(Subject)
+ end
+ end,
+ case do_replace(FlatSubject,Subject,RE,Replacement,NewOpt) of
+ {error,_Err} ->
+ throw(badre);
+ IoList ->
+ case Convert of
+ iodata ->
+ IoList;
+ binary ->
+ iolist_to_binary(IoList);
+ list ->
+ case Unicode of
+ false ->
+ binary_to_list(iolist_to_binary(IoList));
+ true ->
+ unicode:characters_to_list(IoList,unicode)
+ end
+ end
+ end
+ catch
+ throw:badopt ->
+ erlang:error(badarg,[Subject,RE,Replacement,Options]);
+ throw:badre ->
+ erlang:error(badarg,[Subject,RE,Replacement,Options]);
+ error:badarg ->
+ erlang:error(badarg,[Subject,RE,Replacement,Options])
+ end.
+
+
+do_replace(FlatSubject,Subject,RE,Replacement,Options) ->
+ case re:run(FlatSubject,RE,Options) of
+ nomatch ->
+ Subject;
+ {match,[Mlist|T]} when is_list(Mlist) ->
+ apply_mlist(FlatSubject,Replacement,[Mlist|T]);
+ {match,Slist} ->
+ apply_mlist(FlatSubject,Replacement,[Slist])
+ end.
+
+process_repl_params([],Convert,Unicode) ->
+ {[],Convert,Unicode};
+process_repl_params([unicode|T],C,_U) ->
+ {NT,NC,NU} = process_repl_params(T,C,true),
+ {[unicode|NT],NC,NU};
+process_repl_params([{capture,_,_}|_],_,_) ->
+ throw(badopt);
+process_repl_params([{capture,_}|_],_,_) ->
+ throw(badopt);
+process_repl_params([{return,iodata}|T],_C,U) ->
+ process_repl_params(T,iodata,U);
+process_repl_params([{return,list}|T],_C,U) ->
+ process_repl_params(T,list,U);
+process_repl_params([{return,binary}|T],_C,U) ->
+ process_repl_params(T,binary,U);
+process_repl_params([{return,_}|_],_,_) ->
+ throw(badopt);
+process_repl_params([H|T],C,U) ->
+ {NT,NC,NU} = process_repl_params(T,C,U),
+ {[H|NT],NC,NU}.
+
+process_split_params([],Convert,Unicode,Limit,Strip,Group) ->
+ {[],Convert,Unicode,Limit,Strip,Group};
+process_split_params([unicode|T],C,_U,L,S,G) ->
+ {NT,NC,NU,NL,NS,NG} = process_split_params(T,C,true,L,S,G),
+ {[unicode|NT],NC,NU,NL,NS,NG};
+process_split_params([trim|T],C,U,_L,_S,G) ->
+ process_split_params(T,C,U,-1,true,G);
+process_split_params([{parts,0}|T],C,U,_L,_S,G) ->
+ process_split_params(T,C,U,-1,true,G);
+process_split_params([{parts,N}|T],C,U,_L,_S,G) when is_integer(N), N >= 1 ->
+ process_split_params(T,C,U,N-1,false,G);
+process_split_params([{parts,infinity}|T],C,U,_L,_S,G) ->
+ process_split_params(T,C,U,-1,false,G);
+process_split_params([{parts,_}|_],_,_,_,_,_) ->
+ throw(badopt);
+process_split_params([group|T],C,U,L,S,_G) ->
+ process_split_params(T,C,U,L,S,true);
+process_split_params([global|_],_,_,_,_,_) ->
+ throw(badopt);
+process_split_params([{capture,_,_}|_],_,_,_,_,_) ->
+ throw(badopt);
+process_split_params([{capture,_}|_],_,_,_,_,_) ->
+ throw(badopt);
+process_split_params([{return,iodata}|T],_C,U,L,S,G) ->
+ process_split_params(T,iodata,U,L,S,G);
+process_split_params([{return,list}|T],_C,U,L,S,G) ->
+ process_split_params(T,list,U,L,S,G);
+process_split_params([{return,binary}|T],_C,U,L,S,G) ->
+ process_split_params(T,binary,U,L,S,G);
+process_split_params([{return,_}|_],_,_,_,_,_) ->
+ throw(badopt);
+process_split_params([H|T],C,U,L,S,G) ->
+ {NT,NC,NU,NL,NS,NG} = process_split_params(T,C,U,L,S,G),
+ {[H|NT],NC,NU,NL,NS,NG}.
+
+apply_mlist(Subject,Replacement,Mlist) ->
+ do_mlist(Subject,Subject,0,precomp_repl(iolist_to_binary(Replacement)),
+ Mlist).
+
+
+precomp_repl(<<>>) ->
+ [];
+precomp_repl(<<$\\,X,Rest/binary>>) when X < $1 ; X > $9 ->
+ % Escaped character
+ case precomp_repl(Rest) of
+ [BHead | T0] when is_binary(BHead) ->
+ [<<X,BHead/binary>> | T0];
+ Other ->
+ [<<X>> | Other]
+ end;
+precomp_repl(<<$\\,Rest/binary>>) when byte_size(Rest) > 0->
+ {NS,NRest} = pick_int(Rest),
+ [list_to_integer(NS) | precomp_repl(NRest)];
+precomp_repl(<<$&,Rest/binary>>) ->
+ [0 | precomp_repl(Rest)];
+precomp_repl(<<X,Rest/binary>>) ->
+ case precomp_repl(Rest) of
+ [BHead | T0] when is_binary(BHead) ->
+ [<<X,BHead/binary>> | T0];
+ Other ->
+ [<<X>> | Other]
+ end.
+
+
+
+pick_int(<<X,R/binary>>) when X >= $0, X =< $9 ->
+ {Found,Rest} = pick_int(R),
+ {[X|Found],Rest};
+pick_int(Bin) ->
+ {[],Bin}.
+
+do_mlist(_,<<>>,_,_,[]) ->
+ []; %Avoid empty binary tail
+do_mlist(_,Subject,_,_,[]) ->
+ Subject;
+do_mlist(Whole,Subject,Pos,Repl,[[{MPos,Count} | Sub] | Tail])
+ when MPos > Pos ->
+ EatLength = MPos - Pos,
+ <<Untouched:EatLength/binary, Rest/binary>> = Subject,
+ [Untouched | do_mlist(Whole,Rest, MPos, Repl,
+ [[{MPos,Count} | Sub] | Tail])];
+do_mlist(Whole,Subject,Pos,Repl,[[{MPos,Count} | Sub] | Tail])
+ when MPos =:= Pos ->
+ EatLength = Count,
+ <<_:EatLength/binary,Rest/binary>> = Subject,
+ NewData = do_replace(Whole,Repl,[{MPos,Count} | Sub]),
+ [NewData | do_mlist(Whole,Rest,Pos+EatLength,Repl,Tail)].
+
+
+do_replace(_,[Bin],_) when is_binary(Bin) ->
+ Bin;
+do_replace(Subject,Repl,SubExprs0) ->
+ SubExprs = list_to_tuple(SubExprs0),
+ [ case Part of
+ N when is_integer(N) ->
+ if
+ tuple_size(SubExprs) =< N ->
+ <<>>;
+ true ->
+ {SPos,SLen} = element(N+1,SubExprs),
+ if
+ SPos < 0 ->
+ <<>>;
+ true ->
+ <<_:SPos/binary,Res:SLen/binary,_/binary>> =
+ Subject,
+ Res
+ end
+ end;
+ Other ->
+ Other
+ end || Part <- Repl ].
+
+
+check_for_unicode({re_pattern,_,1,_},_) ->
+ true;
+check_for_unicode({re_pattern,_,0,_},_) ->
+ false;
+check_for_unicode(_,L) ->
+ lists:member(unicode,L).
+
+% SelectReturn = false | all | stirpfirst | none
+% ConvertReturn = index | list | binary
+% {capture, all} -> all (untouchded)
+% {capture, first} -> kept in argumentt list and Select all
+% {capture, all_but_first} -> removed from argument list and selects stripfirst
+% {capture, none} -> removed from argument list and selects none
+% {capture, []} -> removed from argument list and selects none
+% {capture,[...]} -> 0 added to selection list and selects stripfirst
+% SelectReturn false is same as all in the end.
+
+% Call as process_parameters([],0,false,index,NeedClean)
+
+process_parameters([],InitialOffset, SelectReturn, ConvertReturn,_) ->
+ {[], InitialOffset, SelectReturn, ConvertReturn};
+process_parameters([{offset, N} | T],_Init0,Select0,Return0,CC) ->
+ process_parameters(T,N,Select0,Return0,CC);
+process_parameters([global | T],Init0,Select0,Return0,CC) ->
+ process_parameters(T,Init0,Select0,Return0,CC);
+process_parameters([{capture,Values,Type}|T],Init0,Select0,_Return0,CC) ->
+ process_parameters([{capture,Values}|T],Init0,Select0,Type,CC);
+process_parameters([{capture,Values}|T],Init0,Select0,Return0,CC) ->
+ % First process the rest to see if capture was already present
+ {NewTail, Init1, Select1, Return1} =
+ process_parameters(T,Init0,Select0,Return0,CC),
+ case Select1 of
+ false ->
+ case Values of
+ all ->
+ {[{capture,all} | NewTail], Init1, all, Return0};
+ first ->
+ {[{capture,first} | NewTail], Init1, all, Return0};
+ all_but_first ->
+ {[{capture,all} | NewTail], Init1, stripfirst, Return0};
+ none ->
+ {[{capture,first} | NewTail], Init1, none, Return0};
+ [] ->
+ {[{capture,first} | NewTail], Init1, none, Return0};
+ List when is_list(List) ->
+ {[{capture,[0|List]} | NewTail],
+ Init1, stripfirst, Return0};
+ _ ->
+ throw(badlist)
+ end;
+ _ ->
+ % Found overriding further down list, ignore this one
+ {NewTail, Init1, Select1, Return1}
+ end;
+process_parameters([H|T],Init0,Select0,Return0,true) ->
+ case copt(H) of
+ true ->
+ process_parameters(T,Init0,Select0,Return0,true);
+ false ->
+ {NewT,Init,Select,Return} =
+ process_parameters(T,Init0,Select0,Return0,true),
+ {[H|NewT],Init,Select,Return}
+ end;
+process_parameters([H|T],Init0,Select0,Return0,false) ->
+ {NewT,Init,Select,Return} =
+ process_parameters(T,Init0,Select0,Return0,false),
+ {[H|NewT],Init,Select,Return};
+process_parameters(_,_,_,_,_) ->
+ throw(badlist).
+
+postprocess({match,[]},_,_,_,_) ->
+ nomatch;
+postprocess({match,_},none,_,_,_) ->
+ match;
+postprocess({match,M},Any,binary,Flat,Uni) ->
+ binarify(postprocess({match,M},Any,index,Flat,Uni),Flat);
+postprocess({match,M},Any,list,Flat,Uni) ->
+ listify(postprocess({match,M},Any,index,Flat,Uni),Flat,Uni);
+postprocess({match,M},all,index,_,_) ->
+ {match,M};
+postprocess({match,M},false,index,_,_) ->
+ {match,M};
+postprocess({match,M},stripfirst,index,_,_) ->
+ {match, [ T || [_|T] <- M ]}.
+
+binarify({match,M},Flat) ->
+ {match, [ [ case {I,L} of
+ {-1,0} ->
+ <<>>;
+ {SPos,SLen} ->
+ <<_:SPos/binary,Res:SLen/binary,_/binary>> = Flat,
+ Res
+ end || {I,L} <- One ] || One <- M ]}.
+listify({match,M},Flat,Uni) ->
+ {match, [ [ case {I,L} of
+ {_,0} ->
+ [];
+ {SPos,SLen} ->
+ case Uni of
+ true ->
+ <<_:SPos/binary,Res:SLen/binary,_/binary>> = Flat,
+ unicode:characters_to_list(Res,unicode);
+ false ->
+ Start = SPos + 1,
+ End = SPos + SLen,
+ binary_to_list(Flat,Start,End)
+ end
+ end || {I,L} <- One ] || One <- M ]}.
+
+ubinarify({match,M},Flat) ->
+ {match, [ case {I,L} of
+ {-1,0} ->
+ <<>>;
+ {SPos,SLen} ->
+ <<_:SPos/binary,Res:SLen/binary,_/binary>> = Flat,
+ Res
+ end || {I,L} <- M ]};
+ubinarify(Else,_) ->
+ Else.
+ulistify({match,M},Flat) ->
+ {match, [ case {I,L} of
+ {_,0} ->
+ [];
+ {SPos,SLen} ->
+ <<_:SPos/binary,Res:SLen/binary,_/binary>> = Flat,
+ unicode:characters_to_list(Res,unicode)
+ end || {I,L} <- M ]};
+ulistify(Else,_) ->
+ Else.
+
+process_uparams([global|_T],_RetType) ->
+ throw(false);
+process_uparams([{capture,Values,Type}|T],_OldType) ->
+ process_uparams([{capture,Values}|T],Type);
+process_uparams([H|T],Type) ->
+ {NL,NType} = process_uparams(T,Type),
+ {[H|NL],NType};
+process_uparams([],Type) ->
+ {[],Type}.
+
+
+ucompile(RE,Options) ->
+ try
+ re:compile(unicode:characters_to_binary(RE,unicode))
+ catch
+ error:AnyError ->
+ {'EXIT',{new_stacktrace,[{Mod,_,L}|Rest]}} =
+ (catch erlang:error(new_stacktrace,
+ [RE,Options])),
+ erlang:raise(error,AnyError,[{Mod,compile,L}|Rest])
+ end.
+
+
+urun(Subject,RE,Options) ->
+ try
+ urun2(Subject,RE,Options)
+ catch
+ error:AnyError ->
+ {'EXIT',{new_stacktrace,[{Mod,_,L}|Rest]}} =
+ (catch erlang:error(new_stacktrace,
+ [Subject,RE,Options])),
+ erlang:raise(error,AnyError,[{Mod,run,L}|Rest])
+ end.
+urun2(Subject0,RE0,Options0) ->
+ {Options,RetType} = case (catch process_uparams(Options0,index)) of
+ {A,B} ->
+ {A,B};
+ _ ->
+ {Options0,false}
+ end,
+ Subject = unicode:characters_to_binary(Subject0,unicode),
+ RE = case RE0 of
+ BinRE when is_binary(BinRE) ->
+ BinRE;
+ {re_pattern,_,_,_} = ReCompiled ->
+ ReCompiled;
+ ListRE ->
+ unicode:characters_to_binary(ListRE,unicode)
+ end,
+ Ret = re:run(Subject,RE,Options),
+ case RetType of
+ binary ->
+ ubinarify(Ret,Subject);
+ list ->
+ ulistify(Ret,Subject);
+ _ ->
+ Ret
+ end.
+
+
+
+%% Might be called either with two-tuple (if regexp was already compiled)
+%% or with 3-tuple (saving original RE for exceptions
+grun(Subject,RE,{Options,NeedClean}) ->
+ try
+ grun2(Subject,RE,{Options,NeedClean})
+ catch
+ error:AnyError ->
+ {'EXIT',{new_stacktrace,[{Mod,_,L}|Rest]}} =
+ (catch erlang:error(new_stacktrace,
+ [Subject,RE,Options])),
+ erlang:raise(error,AnyError,[{Mod,run,L}|Rest])
+ end;
+grun(Subject,RE,{Options,NeedClean,OrigRE}) ->
+ try
+ grun2(Subject,RE,{Options,NeedClean})
+ catch
+ error:AnyError ->
+ {'EXIT',{new_stacktrace,[{Mod,_,L}|Rest]}} =
+ (catch erlang:error(new_stacktrace,
+ [Subject,OrigRE,Options])),
+ erlang:raise(error,AnyError,[{Mod,run,L}|Rest])
+ end.
+
+grun2(Subject,RE,{Options,NeedClean}) ->
+ Unicode = check_for_unicode(RE,Options),
+ FlatSubject =
+ case is_binary(Subject) of
+ true ->
+ Subject;
+ false ->
+ case Unicode of
+ true ->
+ unicode:characters_to_binary(Subject,unicode);
+ false ->
+ iolist_to_binary(Subject)
+ end
+ end,
+ do_grun(FlatSubject,Subject,Unicode,RE,{Options,NeedClean}).
+
+do_grun(FlatSubject,Subject,Unicode,RE,{Options0,NeedClean}) ->
+ {StrippedOptions, InitialOffset,
+ SelectReturn, ConvertReturn} =
+ case (catch
+ process_parameters(Options0, 0, false, index, NeedClean)) of
+ badlist ->
+ erlang:error(badarg,[Subject,RE,Options0]);
+ CorrectReturn ->
+ CorrectReturn
+ end,
+ postprocess(loopexec(FlatSubject,RE,InitialOffset,
+ byte_size(FlatSubject),
+ Unicode,StrippedOptions),
+ SelectReturn,ConvertReturn,FlatSubject,Unicode).
+
+loopexec(_,_,X,Y,_,_) when X > Y ->
+ {match,[]};
+loopexec(Subject,RE,X,Y,Unicode,Options) ->
+ case re:run(Subject,RE,[{offset,X}]++Options) of
+ nomatch ->
+ {match,[]};
+ {match,[{A,B}|More]} ->
+ {match,Rest} =
+ case B>0 of
+ true ->
+ loopexec(Subject,RE,A+B,Y,Unicode,Options);
+ false ->
+ {match,M} =
+ case re:run(Subject,RE,[{offset,X},notempty,
+ anchored]++Options) of
+ nomatch ->
+ {match,[]};
+ {match,Other} ->
+ {match,Other}
+ end,
+ NewA = case M of
+ [{_,NStep}|_] when NStep > 0 ->
+ A+NStep;
+ _ ->
+ forward(Subject,A,1,Unicode)
+ end,
+ {match,MM} = loopexec(Subject,RE,NewA,Y,
+ Unicode,Options),
+ case M of
+ [] ->
+ {match,MM};
+ _ ->
+ {match,[M | MM]}
+ end
+ end,
+ {match,[[{A,B}|More] | Rest]}
+ end.
+
+forward(_Chal,A,0,_) ->
+ A;
+forward(_Chal,A,N,false) ->
+ A+N;
+forward(Chal,A,N,true) ->
+ <<_:A/binary,Tl/binary>> = Chal,
+ Forw = case Tl of
+ <<1:1,1:1,0:1,_:5,_/binary>> ->
+ 2;
+ <<1:1,1:1,1:1,0:1,_:4,_/binary>> ->
+ 3;
+ <<1:1,1:1,1:1,1:1,0:1,_:3,_/binary>> ->
+ 4;
+ _ ->
+ 1
+ end,
+ forward(Chal,A+Forw,N-1,true).
+
+copt(caseless) ->
+ true;
+copt(dollar_endonly) ->
+ true;
+copt(dotall) ->
+ true;
+copt(extended) ->
+ true;
+copt(firstline) ->
+ true;
+copt(multiline) ->
+ true;
+copt(no_auto_capture) ->
+ true;
+copt(dupnames) ->
+ true;
+copt(ungreedy) ->
+ true;
+copt(unicode) ->
+ true;
+copt(_) ->
+ false.
+
+%bothopt({newline,_}) ->
+% true;
+%bothopt(anchored) ->
+% true;
+%bothopt(_) ->
+% false.
+
+runopt(notempty) ->
+ true;
+runopt(notbol) ->
+ true;
+runopt(noteol) ->
+ true;
+runopt({offset,_}) ->
+ true;
+runopt({capture,_,_}) ->
+ true;
+runopt({capture,_}) ->
+ true;
+runopt(global) ->
+ true;
+runopt(_) ->
+ false.