[systools] Fix return value for warnings_as_errors + silent

When both options 'warnings_as_errors' and 'silent' were given to
systools:make_script or systools:make_relup, no error reason would be
returned if warnings occured. Instead only the atom 'error' was
returned. This is now corrected.

Options 'warnings_as_errors' and 'no_warn_sasl' are now also allowed
for systools:make_tar.

2 files changed, 146 insertions, 172 deletions

diff --git a/lib/sasl/src/systools_make.erl b/lib/sasl/src/systools_make.erl
index efe6cc9eb4..3a188e95ee 100644
--- a/lib/sasl/src/systools_make.erl
+++ b/lib/sasl/src/systools_make.erl
@@ -94,7 +94,11 @@ make_script(RelName, Output, Flags) when is_list(RelName),
 		    Warnings = wsasl(Flags, Warnings0),
 		    case systools_lib:werror(Flags, Warnings) of
 			true ->
-			    return(ok,Warnings,Flags);
+                            Warnings1 = [W || {warning,W}<-Warnings],
+			    return({error,?MODULE,
+                                    {warnings_treated_as_errors,Warnings1}},
+                                   Warnings,
+                                   Flags);
 			false ->
 			    case generate_script(Output,Release,Appls,Flags) of
 				ok ->
@@ -115,7 +119,6 @@ make_script(RelName, _Output, Flags) when is_list(Flags) ->
 make_script(RelName, _Output, Flags) ->
     badarg(Flags,[RelName, Flags]).
 
-
 wsasl(Options, Warnings) ->
     case lists:member(no_warn_sasl,Options) of
 	true -> lists:delete({warning,missing_sasl},Warnings);
@@ -148,21 +151,10 @@ get_outdir(Flags) ->
 return(ok,Warnings,Flags) ->
     case member(silent,Flags) of
 	true ->
-	    case systools_lib:werror(Flags, Warnings) of
-		true ->
-		    error;
-		false ->
-		    {ok,?MODULE,Warnings}
-	    end;
+            {ok,?MODULE,Warnings};
 	_ ->
-	    case member(warnings_as_errors,Flags) of
-		true ->
-		    io:format("~ts",[format_warning(Warnings, true)]),
-		    error;
-		false ->
-		    io:format("~ts",[format_warning(Warnings)]),
-		    ok
-	    end
+            io:format("~ts",[format_warning(Warnings)]),
+            ok
     end;
 return({error,Mod,Error},_,Flags) ->
     case member(silent,Flags) of
@@ -300,6 +292,8 @@ add_apply_upgrade(Script,Args) ->
 %%              {variables,[{Name,AbsString}]}
 %%              {machine, jam | beam | vee}
 %%              {var_tar, include | ownfile | omit}
+%%              no_warn_sasl
+%%              warnings_as_errors
 %%
 %% The tar file contains:
 %%         lib/App-Vsn/ebin
@@ -332,13 +326,23 @@ make_tar(RelName, Flags) when is_list(RelName), is_list(Flags) ->
 	    Path  = make_set(Path1 ++ code:get_path()),
 	    ModTestP = {member(src_tests, Flags),xref_p(Flags)},
 	    case get_release(RelName, Path, ModTestP, machine(Flags)) of
-		{ok, Release, Appls, Warnings} ->
-		    case catch mk_tar(RelName, Release, Appls, Flags, Path1) of
-			ok ->
-			    return(ok,Warnings,Flags);
-			Error ->
-			    return(Error,Warnings,Flags)
-		    end;
+		{ok, Release, Appls, Warnings0} ->
+		    Warnings = wsasl(Flags, Warnings0),
+		    case systools_lib:werror(Flags, Warnings) of
+			true ->
+                            Warnings1 = [W || {warning,W}<-Warnings],
+			    return({error,?MODULE,
+                                    {warnings_treated_as_errors,Warnings1}},
+                                   Warnings,
+                                   Flags);
+			false ->
+                            case catch mk_tar(RelName, Release, Appls, Flags, Path1) of
+                                ok ->
+                                    return(ok,Warnings,Flags);
+                                Error ->
+                                    return(Error,Warnings,Flags)
+                            end
+                    end;
 		Error ->
 		    return(Error,[],Flags)
 	    end;
@@ -2109,90 +2113,80 @@ cas([Y | Args], X) ->
 
 %% Check Options for make_tar
 check_args_tar(Args) ->
-    cat(Args, {undef, undef, undef, undef, undef, undef, undef, undef, undef, undef, []}). 
+    cat(Args, []).
 
-cat([], {_Path,_Sil,_Dirs,_Erts,_Test,_Var,_VarTar,_Mach,_Xref,_XrefApps, X}) ->
+cat([], X) ->
     X;
 %%% path ---------------------------------------------------------------
-cat([{path, P} | Args], {Path, Sil, Dirs, Erts, Test, 
-			 Var, VarTar, Mach, Xref, XrefApps, X}) when is_list(P) -> 
+cat([{path, P} | Args], X) when is_list(P) ->
     case check_path(P) of
 	ok ->
-	    cat(Args, {P, Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X});
+	    cat(Args, X);
 	error ->
-	    cat(Args, {Path, Sil, Dirs, Erts, Test, 
-		       Var, VarTar, Mach, Xref, XrefApps, X++[{path,P}]})
+	    cat(Args, X++[{path,P}])
     end;
 %%% silent -------------------------------------------------------------
-cat([silent | Args], {Path, _Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X}) ->
-    cat(Args, {Path, silent, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X});
+cat([silent | Args], X) ->
+    cat(Args, X);
 %%% dirs ---------------------------------------------------------------
-cat([{dirs, D} | Args], {Path, Sil, Dirs, Erts, Test, 
-			    Var, VarTar, Mach, Xref, XrefApps, X}) ->
+cat([{dirs, D} | Args], X) ->
     case check_dirs(D) of
 	ok ->
-	    cat(Args, {Path, Sil, D, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X});
+	    cat(Args, X);
 	error ->
-	    cat(Args, {Path, Sil, Dirs, Erts, Test, 
-		       Var, VarTar, Mach, Xref, XrefApps, X++[{dirs, D}]})
+	    cat(Args, X++[{dirs, D}])
     end;
 %%% erts ---------------------------------------------------------------
-cat([{erts, E} | Args], {Path, Sil, Dirs, _Erts, Test, 
-			 Var, VarTar, Mach, Xref, XrefApps, X}) when is_list(E)->
-    cat(Args, {Path, Sil, Dirs, E, Test, Var, VarTar, Mach, Xref, XrefApps, X});
+cat([{erts, E} | Args], X) when is_list(E)->
+    cat(Args, X);
 %%% src_tests ----------------------------------------------------
-cat([src_tests | Args], {Path, Sil, Dirs, Erts, _Test, Var, VarTar, Mach, Xref, XrefApps, X}) ->
-    cat(Args, {Path, Sil, Dirs, Erts, src_tests, Var, VarTar, Mach, 
-	       Xref, XrefApps, X});
+cat([src_tests | Args], X) ->
+    cat(Args, X);
 %%% variables ----------------------------------------------------------
-cat([{variables, V} | Args], {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X}) when is_list(V) ->
+cat([{variables, V} | Args], X) when is_list(V) ->
     case check_vars(V) of
 	ok ->
-	    cat(Args, {Path, Sil, Dirs, Erts, Test, V, VarTar, Mach, Xref, XrefApps, X});
+	    cat(Args, X);
 	error ->
-	    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, 
-			     Xref, XrefApps, X++[{variables, V}]})
+	    cat(Args, X++[{variables, V}])
     end;
 %%% var_tar ------------------------------------------------------------
-cat([{var_tar, VT} | Args], {Path, Sil, Dirs, Erts, Test, 
-			    Var, _VarTar, Mach, Xref, XrefApps, X}) when VT == include ->
-    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, include, Mach, Xref, XrefApps, X});
-cat([{var_tar, VT} | Args], {Path, Sil, Dirs, Erts, Test, 
-			    Var, _VarTar, Mach, Xref, XrefApps, X}) when VT == ownfile ->
-    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, ownfile, Mach, Xref, XrefApps, X});
-cat([{var_tar, VT} | Args], {Path, Sil, Dirs, Erts, Test, 
-			    Var, _VarTar, Mach, Xref, XrefApps, X}) when VT == omit ->
-    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, omit, Mach, Xref, XrefApps, X});
+cat([{var_tar, VT} | Args], X) when VT == include;
+                                    VT == ownfile;
+                                    VT == omit ->
+    cat(Args, X);
 %%% machine ------------------------------------------------------------
-cat([{machine, M} | Args], {Path, Sil, Dirs, Erts, Test, 
-			    Var, VarTar, Mach, Xref, XrefApps, X}) when is_atom(M) ->
-    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X});
+cat([{machine, M} | Args], X) when is_atom(M) ->
+    cat(Args, X);
 %%% exref --------------------------------------------------------------
-cat([exref | Args], {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, _Xref, XrefApps, X})  ->
-    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, exref, XrefApps, X});
+cat([exref | Args], X)  ->
+    cat(Args, X);
 %%% exref Apps ---------------------------------------------------------
-cat([{exref, Apps} | Args], {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X}) when is_list(Apps) ->
+cat([{exref, Apps} | Args], X) when is_list(Apps) ->
     case check_apps(Apps) of 
 	ok ->
-	    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, 
-			     Xref, Apps, X});
+	    cat(Args, X);
 	error ->
-	    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, 
-			     Xref, XrefApps, X++[{exref, Apps}]})
+	    cat(Args, X++[{exref, Apps}])
     end;
 %%% outdir Dir ---------------------------------------------------------
-cat([{outdir, Dir} | Args], {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X}) when is_list(Dir) ->
-    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach,
-	       Xref, XrefApps, X});
+cat([{outdir, Dir} | Args], X) when is_list(Dir) ->
+    cat(Args, X);
 %%% otp_build (secret, not documented) ---------------------------------
-cat([otp_build | Args], {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X})  ->
-    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X});
+cat([otp_build | Args], X)  ->
+    cat(Args, X);
+%%% warnings_as_errors ----
+cat([warnings_as_errors | Args], X) ->
+    cat(Args, X);
+%%% no_warn_sasl ----
+cat([no_warn_sasl | Args], X) ->
+    cat(Args, X);
 %%% no_module_tests (kept for backwards compatibility, but ignored) ----
-cat([no_module_tests | Args], {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X}) ->
-    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X});
+cat([no_module_tests | Args], X) ->
+    cat(Args, X);
 %%% ERROR --------------------------------------------------------------
-cat([Y | Args], {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X}) ->
-    cat(Args, {Path, Sil, Dirs, Erts, Test, Var, VarTar, Mach, Xref, XrefApps, X++[Y]}).
+cat([Y | Args], X) ->
+    cat(Args, X++[Y]).
 
 check_path([]) ->
     ok;
@@ -2292,6 +2286,9 @@ format_error({delete,File,Error}) ->
 		  [File,file:format_error(Error)]);
 format_error({tar_error,What}) ->
     form_tar_err(What);
+format_error({warnings_treated_as_errors,Warnings}) ->
+    io_lib:format("Warnings being treated as errors:~n~ts",
+                  [map(fun(W) -> form_warn("",W) end, Warnings)]);
 format_error(ListOfErrors) when is_list(ListOfErrors) ->
     format_errors(ListOfErrors);
 format_error(E) -> io_lib:format("~p~n",[E]).
@@ -2348,24 +2345,15 @@ form_tar_err({add, File, Error}) ->
 %% Format warning
 
 format_warning(Warnings) ->
-    format_warning(Warnings, false).
-
-format_warning(Warnings, Werror) ->
-    Prefix = case Werror of
-		 true ->
-		     "";
-		 false ->
-		     "*WARNING* "
-	     end,
-    map(fun({warning,W}) -> form_warn(Prefix, W) end, Warnings).
-
-form_warn(Prefix, {source_not_found,{Mod,_,App,_,_}}) ->
+    map(fun({warning,W}) -> form_warn("*WARNING* ", W) end, Warnings).
+
+form_warn(Prefix, {source_not_found,{Mod,App,_}}) ->
     io_lib:format("~ts~w: Source code not found: ~w.erl~n",
 		  [Prefix,App,Mod]);
 form_warn(Prefix, {{parse_error, File},{_,_,App,_,_}}) ->
     io_lib:format("~ts~w: Parse error: ~p~n",
 		  [Prefix,App,File]);
-form_warn(Prefix, {obj_out_of_date,{Mod,_,App,_,_}}) ->
+form_warn(Prefix, {obj_out_of_date,{Mod,App,_}}) ->
     io_lib:format("~ts~w: Object code (~w) out of date~n",
 		  [Prefix,App,Mod]);
 form_warn(Prefix, {exref_undef, Undef}) ->
@@ -2375,8 +2363,8 @@ form_warn(Prefix, {exref_undef, Undef}) ->
 	end,
     map(F, Undef);
 form_warn(Prefix, missing_sasl) ->
-    io_lib:format("~ts: Missing application sasl. "
+    io_lib:format("~tsMissing application sasl. "
 		  "Can not upgrade with this release~n",
 		  [Prefix]);
 form_warn(Prefix, What) ->
-    io_lib:format("~ts ~p~n", [Prefix,What]).
+    io_lib:format("~ts~p~n", [Prefix,What]).
diff --git a/lib/sasl/src/systools_relup.erl b/lib/sasl/src/systools_relup.erl
index 28534dc0c8..7e1844b400 100644
--- a/lib/sasl/src/systools_relup.erl
+++ b/lib/sasl/src/systools_relup.erl
@@ -155,36 +155,12 @@ mk_relup(TopRelFile, BaseUpRelDcs, BaseDnRelDcs) ->
 mk_relup(TopRelFile, BaseUpRelDcs, BaseDnRelDcs, Opts) ->
     case check_opts(Opts) of
 	[] ->
-	    R = (catch do_mk_relup(TopRelFile,BaseUpRelDcs,BaseDnRelDcs,
-				   add_code_path(Opts), Opts)),
-	    case {get_opt(silent, Opts), get_opt(noexec, Opts)} of
-		{false, false} ->
-		    case R of
-			{ok, _Res, _Mod, Ws} -> 
-			    print_warnings(Ws, Opts),
-			    case systools_lib:werror(Opts, Ws) of
-				true ->
-				    error;
-				false ->
-				    ok
-			    end;
-			Other -> 
-			    print_error(Other),
-			    error
-		    end;
-		_ ->
-		    case R of
-			{ok, _Res, _Mod, Ws} ->
-			    case systools_lib:werror(Opts, Ws) of
-				true ->
-				    error;
-				false ->
-				    R
-			    end;
-			R ->
-			    R
-		    end
-	    end;
+            R = try do_mk_relup(TopRelFile,BaseUpRelDcs,BaseDnRelDcs,
+                                          add_code_path(Opts), Opts)
+                catch throw:Error ->
+                        Error
+                end,
+            done_mk_relup(Opts, R);
 	BadArg ->
 	    erlang:error({badarg, BadArg})
     end.
@@ -224,17 +200,45 @@ do_mk_relup(TopRelFile, BaseUpRelDcs, BaseDnRelDcs, Path, Opts) ->
 	    {Dn, Ws2} = foreach_baserel_dn(TopRel, TopApps, BaseDnRelDcs, 
 					  Path, Opts, Ws1),
 	    Relup = {TopRel#release.vsn, Up, Dn},
-	    case systools_lib:werror(Opts, Ws2) of
-		true ->
-		    ok;
-		false ->
-		    write_relup_file(Relup, Opts)
-	    end,
-	    {ok, Relup, ?MODULE, Ws2};
+
+            {ok, Relup, Ws2};
 	Other -> 
-	    throw(Other)
+	    Other
     end.
 
+done_mk_relup(Opts, {ok,Relup,Ws}) ->
+    WAE = get_opt(warnings_as_errors,Opts),
+    Silent = get_opt(silent,Opts),
+    Noexec = get_opt(noexec,Opts),
+
+    if WAE andalso Ws=/=[] ->
+            return_error(Silent,
+                         {error,?MODULE,{warnings_treated_as_errors, Ws}});
+       not Noexec ->
+            case write_relup_file(Relup,Opts) of
+                ok ->
+                    return_ok(Silent,Relup,Ws);
+                Error ->
+                    return_error(Silent,Error)
+            end;
+       true -> % noexec
+            return_ok(true,Relup,Ws)
+    end;
+done_mk_relup(Opts, Error) ->
+    return_error(get_opt(silent,Opts) orelse get_opt(noexec,Opts), Error).
+
+return_error(true, Error) ->
+    Error;
+return_error(false, Error) ->
+    print_error(Error),
+    error.
+
+return_ok(true,Relup,Ws) ->
+    {ok,Relup,?MODULE,Ws};
+return_ok(false,_Relup,Ws) ->
+    print_warnings(Ws),
+    ok.
+
 %%-----------------------------------------------------------------
 %% foreach_baserel_up(Rel, TopApps, BaseRelDcs, Path, Opts, Ws) -> Ret
 %% foreach_baserel_dn(Rel, TopApps, BaseRelDcs, Path, Opts, Ws) -> Ret
@@ -529,33 +533,18 @@ to_list(X) when is_list(X) -> X.
 %% Writes a relup file.
 %%
 write_relup_file(Relup, Opts) ->
-    case get_opt(noexec, Opts) of
-	true -> 
-	    ok;
-	_ ->
-	    Filename = case get_opt(outdir, Opts) of
-			   OutDir when is_list(OutDir) ->
-			       filename:join(filename:absname(OutDir),
-					     "relup");
-			   false ->
-			       "relup";
-			   Badarg ->
-			       throw({error, ?MODULE, {badarg, {outdir,Badarg}}})
-		       end,
-			   
-	    case file:open(Filename, [write]) of
-		{ok, Fd} ->
-		    io:format(Fd, "~p.~n", [Relup]),
-		    case file:close(Fd) of
-			ok -> ok;
-			{error,Reason} ->
-			    throw({error, ?MODULE,
-				   {file_problem, {"relup", {close,Reason}}}})
-		    end;
-		{error, Reason} ->
-		    throw({error, ?MODULE,
-			   {file_problem, {"relup", {open, Reason}}}})
-	    end
+    Filename = filename:join(filename:absname(get_opt(outdir,Opts)),
+                             "relup"),
+    case file:open(Filename, [write]) of
+        {ok, Fd} ->
+            io:format(Fd, "~p.~n", [Relup]),
+            case file:close(Fd) of
+                ok -> ok;
+                {error,Reason} ->
+                    {error, ?MODULE, {file_problem, {"relup", {close,Reason}}}}
+            end;
+        {error, Reason} ->
+            {error, ?MODULE, {file_problem, {"relup", {open, Reason}}}}
     end.
 
 add_code_path(Opts) ->
@@ -593,10 +582,9 @@ default(path)   -> false;
 default(noexec) -> false;
 default(silent) -> false;
 default(restart_emulator) -> false;
-default(outdir) -> false.
+default(outdir) -> ".";
+default(warnings_as_errors) -> false.
 
-print_error({'EXIT', Err}) -> 
-    print_error(Err);
 print_error({error, Mod, Error}) ->
     S = apply(Mod, format_error, [Error]),
     io:format(S, []);
@@ -614,24 +602,20 @@ format_error({missing_sasl,Release}) ->
     io_lib:format("No sasl application in release ~ts, ~ts. "
 		  "Can not be upgraded.",
 		  [Release#release.name, Release#release.vsn]);
+format_error({warnings_treated_as_errors, Warnings}) ->
+    io_lib:format("Warnings being treated as errors:~n~ts",
+                  [[format_warning("",W) || W <- Warnings]]);
 format_error(Error) ->
-    io:format("~p~n", [Error]).
+    io_lib:format("~p~n", [Error]).
 
 
-print_warnings(Ws, Opts) when is_list(Ws) ->
-    lists:foreach(fun(W) -> print_warning(W, Opts) end, Ws);
-print_warnings(W, Opts) ->
-    print_warning(W, Opts).
+print_warnings(Ws) when is_list(Ws) ->
+    lists:foreach(fun(W) -> print_warning(W) end, Ws);
+print_warnings(W) ->
+    print_warning(W).
 
-print_warning(W, Opts) ->
-    Prefix = case lists:member(warnings_as_errors, Opts) of
-		 true ->
-		     "";
-		 false ->
-		     "*WARNING* "
-	     end,
-    S = format_warning(Prefix, W),
-    io:format("~ts", [S]).
+print_warning(W) ->
+    io:format("~ts", [format_warning(W)]).
 
 format_warning(W) ->
     format_warning("*WARNING* ", W).
@@ -639,6 +623,8 @@ format_warning(W) ->
 format_warning(Prefix, {erts_vsn_changed, {Rel1, Rel2}}) ->
     io_lib:format("~tsThe ERTS version changed between ~p and ~p~n",
 		  [Prefix, Rel1, Rel2]);
+format_warning(Prefix, pre_R15_emulator_upgrade) ->
+    io_lib:format("~tsUpgrade from an OTP version earlier than R15. New code should be compiled with the old emulator.~n",[Prefix]);
 format_warning(Prefix, What) ->
     io_lib:format("~ts~p~n",[Prefix, What]).