Remove Dialyzer warnings

The code that deals with the POSIX version of regexps has been
commented out. Robert will add an option as well as some way to set
the option in the source file later.

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)).