Merge branch 'hb/parsetools/remove_dialyzer_warnings/OTP-8318' into dev

* hb/parsetools/remove_dialyzer_warnings/OTP-8318:
  Remove Dialyzer warnings

1 files changed, 49 insertions, 48 deletions

diff --git a/lib/parsetools/src/leex.erl b/lib/parsetools/src/leex.erl
index e49032ebe4..942e9928b1 100644
--- a/lib/parsetools/src/leex.erl
+++ b/lib/parsetools/src/leex.erl
@@ -35,7 +35,7 @@
 -export([compile/3,file/1,file/2,format_error/1]).
 
 -import(lists, [member/2,reverse/1,sort/1,delete/2,
-                keysort/2,keydelete/3,keyfind/3,
+                keysort/2,keydelete/3,
                 map/2,foldl/3,foreach/2,flatmap/2]).
 -import(string, [substr/2,substr/3,span/2]).
 -import(ordsets, [is_element/2,add_element/2,union/2]).
@@ -58,7 +58,7 @@
                gfile=[],        % Graph file
                module,          % Module name
                opts=[],         % Options
-               posix=false,     % POSIX regular expressions
+               % posix=false,   % POSIX regular expressions
                errors=[],
                warnings=[]
               }).
@@ -136,8 +136,8 @@ format_error({regexp,E})->
                  "unterminated " ++ Cs;
              {illegal_char,Cs} ->
                  "illegal character " ++ Cs;
-             {posix_cc,What} ->
-                 ["illegal POSIX character class ",io_lib:write_string(What)];
+%%           {posix_cc,What} ->
+%%               ["illegal POSIX character class ",io_lib:write_string(What)];
              {char_class,What} ->
                  ["illegal character class ",io_lib:write_string(What)]
          end,
@@ -314,6 +314,7 @@ report_warnings(St) ->
                              end, sort(St#leex.warnings))
              end, report_warnings, St#leex.opts).
 
+-spec add_error(_, #leex{}) -> no_return().
 add_error(E, St) ->
     add_error(St#leex.xfile, E, St).
 
@@ -662,14 +663,14 @@ re_repeat1([$*|Cs], Sn, S, St) -> re_repeat1(Cs, Sn, {kclosure,S}, St);
 re_repeat1([$+|Cs], Sn, S, St) -> re_repeat1(Cs, Sn, {pclosure,S}, St);
 re_repeat1([$?|Cs], Sn, S, St) -> re_repeat1(Cs, Sn, {optional,S}, St);
 %% { only starts interval when ere is true, otherwise normal character.
-re_repeat1([${|Cs0], Sn, S, #leex{posix=true}=St) ->    % $}
-    case re_interval_range(Cs0) of
-        {Min,Max,[$}|Cs1]} when is_integer(Min), is_integer(Max), Min =< Max ->
-            re_repeat1(Cs1, Sn, {interval,S,Min,Max}, St);
-        {Min,Max,[$}|Cs1]} when is_integer(Min), is_atom(Max) ->
-            re_repeat1(Cs1, Sn, {interval,S,Min,Max}, St);
-        {_,_,Cs1} -> parse_error({interval_range,string_between([${|Cs0], Cs1)})
-    end;
+%% re_repeat1([${|Cs0], Sn, S, #leex{posix=true}=St) ->    % $}
+%%     case re_interval_range(Cs0) of
+%%         {Min,Max,[$}|Cs1]} when is_integer(Min), is_integer(Max), Min =< Max ->
+%%             re_repeat1(Cs1, Sn, {interval,S,Min,Max}, St);
+%%         {Min,Max,[$}|Cs1]} when is_integer(Min), is_atom(Max) ->
+%%             re_repeat1(Cs1, Sn, {interval,S,Min,Max}, St);
+%%         {_,_,Cs1} -> parse_error({interval_range,string_between([${|Cs0], Cs1)})
+%%     end;
 re_repeat1(Cs, Sn, S, _) -> {S,Sn,Cs}.
 
 %% re_single(Chars, SubNumber, State) -> {RegExp,SubNumber,Chars}.
@@ -751,7 +752,7 @@ special_char($|, _) -> true;
 special_char($*, _) -> true;
 special_char($+, _) -> true;
 special_char($?, _) -> true;
-special_char(${, #leex{posix=true}) -> true;    % Only when POSIX set
+%% special_char(${, #leex{posix=true}) -> true;    % Only when POSIX set
 special_char($\\, _) -> true;
 special_char(_, _) -> false.
 
@@ -762,12 +763,12 @@ re_char_class([$]|Cs], St) ->                   % Must special case this.
     re_char_class(Cs, [$]], St);
 re_char_class(Cs, St) -> re_char_class(Cs, [], St).
 
-re_char_class("[:" ++ Cs0, Cc, #leex{posix=true}=St) ->
-    %% POSIX char class only.
-    case posix_cc(Cs0) of
-        {Pcl,":]" ++ Cs1} -> re_char_class(Cs1, [{posix,Pcl}|Cc], St);
-        {_,Cs1} -> parse_error({posix_cc,string_between(Cs0, Cs1)})
-    end;
+%% re_char_class("[:" ++ Cs0, Cc, #leex{posix=true}=St) ->
+%%     %% POSIX char class only.
+%%     case posix_cc(Cs0) of
+%%         {Pcl,":]" ++ Cs1} -> re_char_class(Cs1, [{posix,Pcl}|Cc], St);
+%%         {_,Cs1} -> parse_error({posix_cc,string_between(Cs0, Cs1)})
+%%     end;
 re_char_class([C1|Cs0], Cc, St) when C1 =/= $] ->
     case re_char(C1, Cs0) of
         {Cf,[$-,C2|Cs1]} when C2 =/= $] ->
@@ -784,19 +785,19 @@ re_char_class(Cs, Cc, _) -> {reverse(Cc),Cs}.   % Preserve order
 %% posix_cc(String) -> {PosixClass,RestString}.
 %%  Handle POSIX character classes.
 
-posix_cc("alnum" ++ Cs) -> {alnum,Cs};
-posix_cc("alpha" ++ Cs) -> {alpha,Cs};
-posix_cc("blank" ++ Cs) -> {blank,Cs};
-posix_cc("cntrl" ++ Cs) -> {cntrl,Cs};
-posix_cc("digit" ++ Cs) -> {digit,Cs};
-posix_cc("graph" ++ Cs) -> {graph,Cs};
-posix_cc("lower" ++ Cs) -> {lower,Cs};
-posix_cc("print" ++ Cs) -> {print,Cs};
-posix_cc("punct" ++ Cs) -> {punct,Cs};
-posix_cc("space" ++ Cs) -> {space,Cs};
-posix_cc("upper" ++ Cs) -> {upper,Cs};
-posix_cc("xdigit" ++ Cs) -> {xdigit,Cs};
-posix_cc(Cs) -> parse_error({posix_cc,substr(Cs, 1, 5)}).
+%% posix_cc("alnum" ++ Cs) -> {alnum,Cs};
+%% posix_cc("alpha" ++ Cs) -> {alpha,Cs};
+%% posix_cc("blank" ++ Cs) -> {blank,Cs};
+%% posix_cc("cntrl" ++ Cs) -> {cntrl,Cs};
+%% posix_cc("digit" ++ Cs) -> {digit,Cs};
+%% posix_cc("graph" ++ Cs) -> {graph,Cs};
+%% posix_cc("lower" ++ Cs) -> {lower,Cs};
+%% posix_cc("print" ++ Cs) -> {print,Cs};
+%% posix_cc("punct" ++ Cs) -> {punct,Cs};
+%% posix_cc("space" ++ Cs) -> {space,Cs};
+%% posix_cc("upper" ++ Cs) -> {upper,Cs};
+%% posix_cc("xdigit" ++ Cs) -> {xdigit,Cs};
+%% posix_cc(Cs) -> parse_error({posix_cc,substr(Cs, 1, 5)}).
 
 escape_char($n) -> $\n;                         % \n = LF
 escape_char($r) -> $\r;                         % \r = CR
@@ -815,24 +816,24 @@ escape_char(C) -> C.                            % Pass it straight through
 %% Int,      -> Int,any
 %% Int1,Int2 -> Int1,Int2
 
-re_interval_range(Cs0) ->
-    case re_number(Cs0) of
-        {none,Cs1} -> {none,none,Cs1};
-        {N,[$,|Cs1]} ->
-            case re_number(Cs1) of
-                {none,Cs2} -> {N,any,Cs2};
-                {M,Cs2} -> {N,M,Cs2}
-            end;
-        {N,Cs1} -> {N,none,Cs1}
-    end.
+%% re_interval_range(Cs0) ->
+%%     case re_number(Cs0) of
+%%         {none,Cs1} -> {none,none,Cs1};
+%%         {N,[$,|Cs1]} ->
+%%             case re_number(Cs1) of
+%%                 {none,Cs2} -> {N,any,Cs2};
+%%                 {M,Cs2} -> {N,M,Cs2}
+%%             end;
+%%         {N,Cs1} -> {N,none,Cs1}
+%%     end.
 
-re_number([C|Cs]) when C >= $0, C =< $9 ->
-    re_number(Cs, C - $0);
-re_number(Cs) -> {none,Cs}.
+%% re_number([C|Cs]) when C >= $0, C =< $9 ->
+%%     re_number(Cs, C - $0);
+%% re_number(Cs) -> {none,Cs}.
 
-re_number([C|Cs], Acc) when C >= $0, C =< $9 ->
-    re_number(Cs, 10*Acc + (C - $0));
-re_number(Cs, Acc) -> {Acc,Cs}.
+%% re_number([C|Cs], Acc) when C >= $0, C =< $9 ->
+%%     re_number(Cs, 10*Acc + (C - $0));
+%% re_number(Cs, Acc) -> {Acc,Cs}.
 
 string_between(Cs1, Cs2) ->
     substr(Cs1, 1, length(Cs1)-length(Cs2)).