From a46f196c0ea955354e71c242d2ca5039a726989a Mon Sep 17 00:00:00 2001
From: Lars Thorsen <lars@erlang.org>
Date: Tue, 18 Feb 2025 08:32:12 +0100
Subject: [PATCH] Fix a tail recursion bug in sax parser

- Rewrote some recursion when calling continuation fun
  in xmerl_sax_parser_base.
- Remove all old style catch calls in xmerl
---
 lib/xmerl/src/xmerl_eventp.erl             |  19 +-
 lib/xmerl/src/xmerl_regexp.erl             |  11 +-
 lib/xmerl/src/xmerl_sax_parser_base.erlsrc | 303 +++++++++------------
 lib/xmerl/src/xmerl_scan.erl               |  31 +--
 lib/xmerl/src/xmerl_simple.erl             |   9 +-
 lib/xmerl/src/xmerl_validate.erl           |  27 +-
 lib/xmerl/src/xmerl_xpath_pred.erl         |  42 +--
 lib/xmerl/src/xmerl_xsd.erl                | 199 +++++++++-----
 lib/xmerl/src/xmerl_xsd_type.erl           |  79 ++++--
 9 files changed, 393 insertions(+), 327 deletions(-)

diff --git a/lib/xmerl/src/xmerl_eventp.erl b/lib/xmerl/src/xmerl_eventp.erl
index 4f259370bf43..85cdad053567 100644
--- a/lib/xmerl/src/xmerl_eventp.erl
+++ b/lib/xmerl/src/xmerl_eventp.erl
@@ -314,16 +314,16 @@ cont(F, Exception, S) ->
 
 
 cont2(F, Exception, Sofar, Fd, Fname, T, S) ->
-    case catch read_chunk(Fd, Fname, Sofar) of
-	{ok, Bin} ->
-	    find_good_split(list_to_binary([Sofar,Bin]),
+    case read_chunk(Fd, Fname, Sofar) of
+        {ok, Bin} ->
+            find_good_split(list_to_binary([Sofar,Bin]),
 			    F,Exception,Fd,Fname,T,S);
 	eof ->
 	    ok = file:close(Fd),
 	    NewS = xmerl_scan:cont_state([{Fname, eof}|T], S),
 	    F(binary_to_list(Sofar), NewS);
-	Error ->
-	    exit(Error)
+        Error ->
+            exit(Error)
     end.
 
 read_chunk(Fd, _Fname, _Sofar) ->
@@ -468,11 +468,12 @@ rules_read(Context, Name, #xmerl_scanner{rules = T}) ->
 %%% Generic helper functions
 
 scanner_options([H|T], Opts) ->
-    case catch keyreplace(H, 1, Opts) of
-	false ->
-	    scanner_options(T, [H|Opts]);
-	NewOpts ->
+    try keyreplace(H, 1, Opts) of
+        NewOpts ->
 	    scanner_options(T, NewOpts)
+    catch
+        throw:false ->
+            scanner_options(T, [H|Opts])
     end;
 scanner_options([], Opts) ->
     Opts.
diff --git a/lib/xmerl/src/xmerl_regexp.erl b/lib/xmerl/src/xmerl_regexp.erl
index 8b91f973aaa2..2df4fa45830b 100644
--- a/lib/xmerl/src/xmerl_regexp.erl
+++ b/lib/xmerl/src/xmerl_regexp.erl
@@ -241,10 +241,13 @@ sh_special_char(_C) -> false.
 %%  Parse the regexp described in the string RegExp.
 
 parse(S) ->
-    case catch reg(S, 0) of
-	{R,Sc,[]} -> {ok,{regexp,{R,Sc}}};
-	{_R,_Sc,[C|_]} -> {error,{illegal,[C]}};
-	{error,E} -> {error,E}
+    try reg(S, 0) of
+	{R,Sc,[]} ->
+            {ok,{regexp,{R,Sc}}};
+	{_R,_Sc,[C|_]} ->
+            {error,{illegal,[C]}}
+    catch
+	throw:{error,E} -> {error,E}
     end.
 
 %% format_error(Error) -> String.
diff --git a/lib/xmerl/src/xmerl_sax_parser_base.erlsrc b/lib/xmerl/src/xmerl_sax_parser_base.erlsrc
index 9c38b3f4074c..3b98218f7ad3 100644
--- a/lib/xmerl/src/xmerl_sax_parser_base.erlsrc
+++ b/lib/xmerl/src/xmerl_sax_parser_base.erlsrc
@@ -77,29 +77,6 @@ parse(Xml, State) ->
             handle_end_document({other, OtherError, State})
     end.
 
-    % case catch parse_document(Xml, State1#xmerl_sax_parser_state{ref_table=RefTable}) of
-    %     {ok, Rest, State2} ->
-    %         State3 =  event_callback(endDocument, State2),
-    %         case check_if_rest_ok(State3#xmerl_sax_parser_state.input_type, Rest) of
-    %             true ->
-    %                 {ok, State3#xmerl_sax_parser_state.event_state, Rest}; 
-    %             false ->
-    %                 format_error(fatal_error, State3, "Input found after legal document")
-    %         end;
-    %     {fatal_error, {State2, Reason}} ->
-    %         State3 =  event_callback(endDocument, State2),
-    %         format_error(fatal_error, State3, Reason);
-    %     {event_receiver_error, State2, {Tag, Reason}} -> 
-    %         State3 =  event_callback(endDocument, State2),
-    %         format_error(Tag, State3, Reason);
-    %     {endDocument, Rest, State2} ->
-    %         State3 =  event_callback(endDocument, State2),
-    %         {ok, State3#xmerl_sax_parser_state.event_state, Rest}; 
-    %     Other ->
-    %         _State2 = event_callback(endDocument, State1),
-    %         {fatal_error, Other}
-    % end.
-
 %%----------------------------------------------------------------------
 %% Function: parse_dtd(Xml, State) -> Result
 %% Input:    Xml = string() | binary()
@@ -122,26 +99,6 @@ parse_dtd(Xml, State) ->
              handle_end_document({other, OtherError, State})
     end.
 
-
-    % case catch parse_external_entity_1(Xml, State1#xmerl_sax_parser_state{ref_table=RefTable}) of
-    %     {fatal_error, {State2, Reason}} ->
-    %         State3 =  event_callback(endDocument, State2),
-    %         format_error(fatal_error, State3, Reason);
-    %     {event_receiver_error, State2, {Tag, Reason}} -> 
-    %         State3 =  event_callback(endDocument, State2),
-    %         format_error(Tag, State3, Reason);
-    %     {Rest, State2} when is_record(State2, xmerl_sax_parser_state) ->
-    %         State3 =  event_callback(endDocument, State2),
-    %         {ok, State3#xmerl_sax_parser_state.event_state, Rest}; 
-    %     {endDocument, Rest, State2} when is_record(State2, xmerl_sax_parser_state) ->
-    %         State3 =  event_callback(endDocument, State2),
-    %         {ok, State3#xmerl_sax_parser_state.event_state, Rest}; 
-    %     Other ->
-    %         _State2 = event_callback(endDocument, State1),
-    %         {fatal_error, Other}
-    % end.
-
-
 %%======================================================================
 %% Internal functions
 %%======================================================================
@@ -1311,36 +1268,30 @@ parse_etag_1(Bytes, State, Tag) ->
 %%              [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
 %%----------------------------------------------------------------------
 parse_content(?STRING_EMPTY, #xmerl_sax_parser_state{end_tags = ET} = State, Acc, IgnorableWS) ->
-    case catch cf(?STRING_EMPTY, State, Acc, IgnorableWS, fun parse_content/4) of
-        {fatal_error, {State1, "No more bytes"}} when ET == [] ->
+    try cf(?STRING_EMPTY, State) of
+        {NewBytes, NewState} ->
+            parse_content(NewBytes, NewState, Acc, IgnorableWS)
+    catch
+        throw:{fatal_error, {State1, "No more bytes"}} when ET == [] ->
             State2 = send_character_event(length(Acc), IgnorableWS, lists:reverse(Acc), State1),
             {?STRING_EMPTY, State2};
-        {fatal_error, {State1, "Continuation function undefined"}} when ET == [] ->
+        throw:{fatal_error, {State1, "Continuation function undefined"}} when ET == [] ->
             State2 = send_character_event(length(Acc), IgnorableWS, lists:reverse(Acc), State1),
-            {?STRING_EMPTY, State2};
-        {fatal_error, {State1, Msg}} ->
-            ?fatal_error(State1, Msg);
-        {Rest, State1} when is_record(State1, xmerl_sax_parser_state) ->
-            {Rest, State1};
-        Other ->
-            throw(Other)
+            {?STRING_EMPTY, State2}
     end;
 parse_content(?STRING("\r") = Bytes, #xmerl_sax_parser_state{end_tags = ET} = State, Acc, IgnorableWS) ->
-    case catch cf(Bytes, State, Acc, IgnorableWS, fun parse_content/4) of
-        {fatal_error, {State1, "No more bytes"}} when ET == [] ->
+    try cf(Bytes, State) of
+        {NewBytes, NewState} ->
+            parse_content(NewBytes, NewState, Acc, IgnorableWS)
+    catch
+        throw:{fatal_error, {State1, "No more bytes"}} when ET == [] ->
             Acc1 = [?lf |Acc],
             State2 = send_character_event(length(Acc1), IgnorableWS, lists:reverse(Acc1), State1),
             {?STRING_EMPTY, State2};
-        {fatal_error, {State1, "Continuation function undefined"}} when ET == [] ->
+        throw:{fatal_error, {State1, "Continuation function undefined"}} when ET == [] ->
             Acc1 = [?lf |Acc],
             State2 = send_character_event(length(Acc1), IgnorableWS, lists:reverse(Acc1), State1),
-            {?STRING_EMPTY, State2};
-        {fatal_error, {State1, Msg}} ->
-            ?fatal_error(State1, Msg);
-        {Rest, State1} when is_record(State1, xmerl_sax_parser_state) ->
-            {Rest, State1};
-        Other ->
-            throw(Other)
+            {?STRING_EMPTY, State2}
     end;
 parse_content(?STRING("<") = Bytes, State, Acc, IgnorableWS) ->	
     cf(Bytes, State, Acc, IgnorableWS, fun parse_content/4);
@@ -1472,15 +1423,14 @@ parse_content(Bytes, State, Acc, IgnorableWS)   ->
 parse_entity_content(Bytes, #xmerl_sax_parser_state{file_type = text} = State, Acc, _IgnorableWS) ->
     parse_entity_content_1(Bytes, State, Acc);
 parse_entity_content(?STRING_EMPTY, State, Acc, IgnorableWS) ->
-    case catch cf(?STRING_EMPTY, State, Acc, IgnorableWS, fun parse_entity_content/4) of
-        {Acc1, Rest, State1} when is_record(State1, xmerl_sax_parser_state) ->
-            {Acc1, Rest, State1};
-        {fatal_error, {State1, "No more bytes"}} ->
-            {Acc, ?STRING_EMPTY, State1};
-        {fatal_error, {State1, "Continuation function undefined"}} ->
+    try cf(?STRING_EMPTY, State) of
+        {NewBytes, NewState} ->
+            parse_entity_content(NewBytes, NewState, Acc, IgnorableWS)
+    catch
+        throw:{fatal_error, {State1, "No more bytes"}} ->
             {Acc, ?STRING_EMPTY, State1};
-        {fatal_error, {State1, Message}} ->
-            ?fatal_error(State1, Message)
+        throw:{fatal_error, {State1, "Continuation function undefined"}} ->
+            {Acc, ?STRING_EMPTY, State1}
     end;
 parse_entity_content(?STRING("<") = Bytes, State, Acc, IgnorableWS) ->
     cf(Bytes, State, Acc, IgnorableWS, fun parse_entity_content/4);
@@ -1490,13 +1440,12 @@ parse_entity_content(?STRING("<!-") = Bytes, State, Acc, IgnorableWS) ->
     cf(Bytes, State, Acc, IgnorableWS, fun parse_entity_content/4);
 parse_entity_content(?STRING_REST("<!--", Rest), State, Acc, IgnorableWS) ->
     State1 = send_character_event(length(Acc), IgnorableWS, lists:reverse(Acc), State),
-    case catch parse_comment(Rest, State1, Acc) of
-        {Rest1, State2} when is_record(State2, xmerl_sax_parser_state) ->
-            parse_entity_content(Rest1, State2, [], true);
-        {fatal_error, {State2, "No more bytes"}} ->
-            ?fatal_error(State2, "Expected end comment");
-        {fatal_error, {State2, Message}} ->
-            ?fatal_error(State2, Message)
+    try parse_comment(Rest, State1, Acc) of
+        {Rest1, State2} ->
+            parse_entity_content(Rest1, State2, [], true)
+    catch
+        throw:{fatal_error, {State2, "No more bytes"}} ->
+            ?fatal_error(State2, "Expected end comment")
     end;
 parse_entity_content(?STRING_REST("<?", Rest), State, Acc, IgnorableWS) ->
     State1 = send_character_event(length(Acc), IgnorableWS, lists:reverse(Acc), State),
@@ -1511,7 +1460,7 @@ parse_entity_content(?STRING_REST("</", _), #xmerl_sax_parser_state{end_tags = [
     ?fatal_error(State, "Unbalanced tags");
 parse_entity_content(?STRING_REST("</", Rest1), State, Acc, IgnorableWS) ->
     State1 = send_character_event(length(Acc), IgnorableWS, lists:reverse(Acc), State),
-    case parse_etag(Rest1, State1) of
+    case parse_etag(Rest1, State1) of %??????
         {?STRING_EMPTY, State2} ->
             {[], ?STRING_EMPTY, State2};
         {Rest2, State2} when is_record(State2, xmerl_sax_parser_state) ->
@@ -1531,12 +1480,8 @@ parse_entity_content(?STRING_REST("<!", Rest1), State, Acc, IgnorableWS) ->
     end;
 parse_entity_content(?STRING_REST("<", Rest1), State, Acc, IgnorableWS) ->
     State1 = send_character_event(length(Acc), IgnorableWS, lists:reverse(Acc), State),
-    case catch parse_stag(Rest1, State1) of
-        {Rest2, State2} when is_record(State2, xmerl_sax_parser_state) ->
-            parse_entity_content(Rest2, State2, [], true);
-        {fatal_error, {State2, Message}} ->
-            ?fatal_error(State2, Message)
-    end;
+    {Rest2, State2} = parse_stag(Rest1, State1),
+    parse_entity_content(Rest2, State2, [], true);
 parse_entity_content(?STRING_REST("\n", Rest), State, Acc, IgnorableWS) ->
     N = State#xmerl_sax_parser_state.line_no,
     case IgnorableWS of
@@ -1611,13 +1556,12 @@ parse_entity_content(Bytes, State, Acc, IgnorableWS)   ->
 
 % reads an external entity as replacement text
 parse_entity_content_1(?STRING_EMPTY, State, Acc) ->
-    case catch cf(?STRING_EMPTY, State, Acc, fun parse_entity_content_1/3) of
-        {fatal_error, {State1, "No more bytes"}} ->
-            {Acc, ?STRING_EMPTY, State1};
-        {fatal_error, {State1, Message}} ->
-            ?fatal_error(State1, Message);
-        {Acc1, ?STRING_EMPTY, State1} ->
-            {Acc1, ?STRING_EMPTY, State1}
+    try cf(?STRING_EMPTY, State) of
+        {NewBytes, NewState} ->
+            parse_entity_content_1(NewBytes, NewState, Acc)
+    catch
+        throw:{fatal_error, {State1, "No more bytes"}} ->
+            {Acc, ?STRING_EMPTY, State1}
     end;
 parse_entity_content_1(?STRING_UNBOUND_REST(C, Rest), State, Acc) ->
     if 
@@ -2118,12 +2062,10 @@ parse_doctype_2(Bytes, State) ->
 parse_external_entity(State, _PubId, SysId, Acc) -> 
     
     ExtRef = check_uri(SysId, State#xmerl_sax_parser_state.current_location),
-    
     SaveState =  event_callback({startEntity, SysId}, State),
-
     EntityState =
-        SaveState#xmerl_sax_parser_state{line_no=1,
-                                         end_tags = []},
+        SaveState#xmerl_sax_parser_state{line_no=1, 
+                                     end_tags = []},
     
     {Acc1, EventState, EventRefTab, AttVals} = handle_external_entity(ExtRef, EntityState, Acc),
 
@@ -2137,7 +2079,6 @@ parse_external_entity(State, _PubId, SysId, Acc) ->
             {Acc1, NewState#xmerl_sax_parser_state{attribute_values = AttVals}}
     end.
 
-
 %%----------------------------------------------------------------------
 %% Function  : handle_external_entity(ExtRef, State, Acc) -> Result
 %% Parameters: ExtRef = {file, string()} | {http, string()}
@@ -2223,16 +2164,18 @@ handle_external_entity({Tag, _Url}, State, _Acc) ->
 %% Description: Parse the external entity.
 %%----------------------------------------------------------------------
 parse_external_entity_1(?STRING_EMPTY, State, Acc) ->
-    case catch cf(?STRING_EMPTY, State, Acc, fun parse_external_entity_1/3) of
-        {fatal_error, {State1, "No more bytes"}} ->
-            {Acc, ?STRING_EMPTY, State1};
-        {fatal_error, {State1, Msg}} ->
-            ?fatal_error(State1, Msg);
-        {Acc1, ?STRING_EMPTY, State1} when is_record(State1, xmerl_sax_parser_state) ->
-            {Acc1, ?STRING_EMPTY, State1};
-        {_, _, State1} when is_record(State1, xmerl_sax_parser_state) ->
-            ?fatal_error(State1, "Not well-formed entity")
-    end;    
+    try cf(?STRING_EMPTY, State) of
+        {NewBytes, NewState} ->
+            case parse_external_entity_1(NewBytes, NewState, Acc) of
+                {_Acc1, ?STRING_EMPTY, _State1} = Result ->
+                    Result;
+                {_, _, State1} ->
+                    ?fatal_error(State1, "Not well-formed entity")
+            end
+    catch
+        throw:{fatal_error, {State1, "No more bytes"}} ->
+            {Acc, ?STRING_EMPTY, State1}
+    end;
 parse_external_entity_1(?STRING("<") = Bytes, State, Acc) ->
     cf(Bytes, State, Acc, fun parse_external_entity_1/3);
 parse_external_entity_1(?STRING("<?") = Bytes, State, Acc) ->
@@ -2255,41 +2198,40 @@ parse_external_entity_1(?STRING_REST("<?xml", Rest) = Bytes,
         end,
     case Type of
         dtd ->
-            case catch parse_doctype_decl(Rest1, State1)  of
+            try parse_doctype_decl(Rest1, State1) of
                 {?STRING_EMPTY, State2} when is_record(State2, xmerl_sax_parser_state) ->
                     % this my not truly be empty. the file may have 
                     % more unbalanced stuff, but not have been read yet
                     {[], ?STRING_EMPTY, State2};
-                {_, State1} when is_record(State1, xmerl_sax_parser_state) ->
-                    ?fatal_error(State1, "Not well-formed DTD");
-                {fatal_error, {State2, "No more bytes"}} ->
-                    {[], ?STRING_EMPTY, State2};
-                {fatal_error, {State2, Message}} ->
-                    ?fatal_error(State2, Message)
+                {_, State2} when is_record(State2, xmerl_sax_parser_state) ->
+                    ?fatal_error(State2, "Not well-formed DTD")
+            catch
+                throw:{fatal_error, {State2, "No more bytes"}} ->
+                    {[], ?STRING_EMPTY, State2}
             end;
-    _ -> % Type is normal or entity
-        {Acc1, Rest3, State3} = parse_entity_content(Rest1, State1#xmerl_sax_parser_state{end_tags = []}, Acc, true),
-        {Acc1, Rest3, State3#xmerl_sax_parser_state{end_tags = ET}}
+        _ -> % Type is normal or entity
+            {Acc1, Rest3, State3} =
+                parse_entity_content(Rest1, State1#xmerl_sax_parser_state{end_tags = []}, Acc, true),
+            {Acc1, Rest3, State3#xmerl_sax_parser_state{end_tags = ET}}
     end;
 parse_external_entity_1(?STRING_UNBOUND_REST(_C, _) = Bytes, 
             #xmerl_sax_parser_state{file_type = Type,
                                     end_tags = ET} = State, Acc) ->
     case Type of
         dtd ->
-            case catch parse_doctype_decl(Bytes, State)  of
-                {?STRING_EMPTY, State2} when is_record(State2, xmerl_sax_parser_state) ->
-                    {[], ?STRING_EMPTY, State2};
+            try parse_doctype_decl(Bytes, State) of
+                {?STRING_EMPTY, State1} when is_record(State1, xmerl_sax_parser_state) ->
+                    {[], ?STRING_EMPTY, State1};
                 {_, State1} when is_record(State1, xmerl_sax_parser_state) ->
-                    ?fatal_error(State1, "Not well-formed DTD");
-                {fatal_error, {State2, "No more bytes"}} ->
-                    {[], ?STRING_EMPTY, State2};
-                {fatal_error, {State2, Message}} ->
-                    ?fatal_error(State2, Message)
+                    ?fatal_error(State1, "Not well-formed DTD")
+            catch
+                throw:{fatal_error, {State1, "No more bytes"}} ->
+                    {[], ?STRING_EMPTY, State1}
             end;
         _ ->
-            {Acc1, Rest1, State1} = parse_entity_content(Bytes, State#xmerl_sax_parser_state{end_tags = []}, Acc, true),
+            {Acc1, Rest1, State1} =
+                parse_entity_content(Bytes, State#xmerl_sax_parser_state{end_tags = []}, Acc, true),
             {Acc1, Rest1, State1#xmerl_sax_parser_state{end_tags = ET}}
-        
     end;
 parse_external_entity_1(Bytes, State, Acc) ->
     unicode_incomplete_check([Bytes, State, Acc, fun parse_external_entity_1/3], 
@@ -2451,15 +2393,14 @@ parse_doctype_decl(?STRING_REST("%", Rest), #xmerl_sax_parser_state{file_type =
         {internal_parameter, _, RefValue} ->
             IValue = ?TO_INPUT_FORMAT(" " ++ RefValue ++ " "),
             {Ctx, State2} = strip_context(State1),
-            case catch parse_doctype_decl(IValue, State2) of
-                {fatal_error, {State3, "No more bytes"}} ->
+            try parse_doctype_decl(IValue, State2) of
+                {_, State3} ->
+                    parse_doctype_decl(Rest1, add_context_back(Ctx, State3))
+            catch
+                throw:{fatal_error, {State3, "No more bytes"}} ->
                     parse_doctype_decl(Rest1, add_context_back(Ctx, State3));
-                {fatal_error, {State3, "Continuation function undefined"}} ->
-                    parse_doctype_decl(Rest1, add_context_back(Ctx, State3));
-                {_, State3} when is_record(State3, xmerl_sax_parser_state) ->
-                    parse_doctype_decl(Rest1, add_context_back(Ctx, State3));
-                {fatal_error, {State3, Mess}} ->
-                    ?fatal_error(State3, Mess)
+                throw:{fatal_error, {State3, "Continuation function undefined"}} ->
+                    parse_doctype_decl(Rest1, add_context_back(Ctx, State3))
             end;
         {external_parameter, _, {PubId, SysId}} ->
             {_, State2} = parse_external_entity(State1#xmerl_sax_parser_state{file_type = dtd}, PubId, SysId, []),
@@ -3696,13 +3637,12 @@ parse_pe_def(Bytes, State, Name) ->
 %%              [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
 %%----------------------------------------------------------------------
 parse_include_sect(?STRING_EMPTY, State) ->
-    case catch cf(?STRING_EMPTY, State, fun parse_include_sect/2) of
-        {Rest, State1} when is_record(State1, xmerl_sax_parser_state) ->
-            {Rest, State1};
-        {fatal_error, {State1, "No more bytes"}} ->
-            ?fatal_error(State1, "Unexpected EOF.");
-        {fatal_error, {State1, Mess}} ->
-            ?fatal_error(State1, Mess)
+    try cf(?STRING_EMPTY, State) of
+        {NewBytes, NewState} ->
+            parse_include_sect(NewBytes, NewState)
+    catch
+        throw:{fatal_error, {State1, "No more bytes"}} ->
+            ?fatal_error(State1, "Unexpected EOF.")
     end;
 parse_include_sect(?STRING("]") = Bytes, State) ->
     cf(Bytes, State, fun parse_include_sect/2);
@@ -3723,13 +3663,12 @@ parse_include_sect(Bytes, State) ->
                  "subset declaration expected"). 
 
 parse_include_sect_1(?STRING_EMPTY, State) ->
-    case catch cf(?STRING_EMPTY, State, fun parse_include_sect_1/2) of
-        {Rest, State1} when is_record(State1, xmerl_sax_parser_state) ->
-            {Rest, State1};
-        {fatal_error, {State1, "No more bytes"}} ->
-            ?fatal_error(State1, "Unexpected EOF.");
-        {fatal_error, {State1, Mess}} ->
-            ?fatal_error(State1, Mess)
+    try cf(?STRING_EMPTY, State) of
+        {NewBytes, NewState} ->
+            parse_include_sect_1(NewBytes, NewState)
+    catch
+        throw:{fatal_error, {State1, "No more bytes"}} ->
+            ?fatal_error(State1, "Unexpected EOF.")
     end;
 parse_include_sect_1(?STRING("]") = Bytes, State) ->
     cf(Bytes, State, fun parse_include_sect_1/2);
@@ -3737,13 +3676,12 @@ parse_include_sect_1(?STRING_REST("]>", Rest), State) ->
     {Rest, State};
 parse_include_sect_1(?STRING_UNBOUND_REST(_, _) = Bytes, State) ->
     {Rest1, State1} = parse_text_decl(Bytes, State),
-    case catch parse_doctype_decl(Rest1, State1) of
-        {Rest2, State2} when is_record(State2, xmerl_sax_parser_state) ->
-            parse_include_sect_1(Rest2, State2);
-        {fatal_error, {State2, "No more bytes"}} ->
-            ?fatal_error(State2, "Unexpected EOF.");
-        {fatal_error, {State2, Message}} ->
-            ?fatal_error(State2, Message)
+    try parse_doctype_decl(Rest1, State1) of
+        {Rest2, State2} ->
+            parse_include_sect_1(Rest2, State2)
+    catch
+        throw:{fatal_error, {State2, "No more bytes"}} ->
+            ?fatal_error(State2, "Unexpected EOF.")
     end;
 parse_include_sect_1(Bytes, State) ->
     unicode_incomplete_check([Bytes, State, fun parse_include_sect_1/2], 
@@ -3771,13 +3709,12 @@ parse_ignore_sect(Bytes, State) ->
                  "whitespace expected"). 
 
 parse_ignore_sect_1(?STRING_EMPTY, State, Depth) ->
-    case catch cf(?STRING_EMPTY, State, Depth, fun parse_ignore_sect_1/3) of
-        {Rest, State1} when is_record(State1, xmerl_sax_parser_state) ->
-            {Rest, State1};
-        {fatal_error, {State1, "No more bytes"}} ->
-            ?fatal_error(State1, "Unexpected EOF.");
-        {fatal_error, {State1, Message}} ->
-            ?fatal_error(State1, Message)
+    try cf(?STRING_EMPTY, State) of
+        {NewBytes, NewState} ->
+            parse_ignore_sect_1(NewBytes, NewState, Depth)
+    catch
+        throw:{fatal_error, {State1, "No more bytes"}} ->
+            ?fatal_error(State1, "Unexpected EOF.")
     end;
 parse_ignore_sect_1(?STRING("<") = Bytes, State, Depth) ->
     cf(Bytes, State, Depth, fun parse_ignore_sect_1/3);
@@ -4410,6 +4347,33 @@ event_callback(Event,
 	  exit:Reason ->
 	    throw({event_receiver_error, State, {'EXIT', Reason}})
     end.
+%%----------------------------------------------------------------------
+%% Function  : cf(Rest, State) -> Result
+%% Parameters: Rest = string() | binary()
+%%             State = #xmerl_sax_parser_state{}
+%% Result    : {Rest, State}
+%% Description: Function that uses provided fun to read another chunk from
+%%              input stream and calls the fun in NextCall.
+%%----------------------------------------------------------------------
+cf(_Rest, #xmerl_sax_parser_state{continuation_fun = undefined} = State) ->
+    ?fatal_error(State, "Continuation function undefined");
+cf(Rest, #xmerl_sax_parser_state{continuation_fun = CFun, continuation_state = CState} = State) ->
+    Result =
+	try
+	    CFun(CState)
+	catch
+	    throw:ErrorTerm ->
+		?fatal_error(State, ErrorTerm);
+            exit:Reason ->
+		?fatal_error(State, {'EXIT', Reason})
+	end,
+    case Result of
+	{?STRING_EMPTY, _} ->
+	    ?fatal_error(State, "No more bytes");
+	{NewBytes, NewContState} ->
+            {?APPEND_STRING(Rest, NewBytes),
+             State#xmerl_sax_parser_state{continuation_state = NewContState}}
+    end.
 
 %%----------------------------------------------------------------------
 %% Function  : cf(Rest, State, NextCall) -> Result
@@ -4473,7 +4437,6 @@ cf(Rest, #xmerl_sax_parser_state{continuation_fun = CFun, continuation_state = C
 		     P)
     end.
 
-
 %%----------------------------------------------------------------------
 %% Function  : cf(Rest, State, P1, P2, NextCall) -> Result
 %% Parameters: Rest = string() | binary()
@@ -4508,8 +4471,6 @@ cf(Rest, #xmerl_sax_parser_state{continuation_fun = CFun, continuation_state = C
 		     P1, P2)
     end.
 
-
-
 %%----------------------------------------------------------------------
 %% Function  : unicode_incomplete_check(Args, ErrString) -> Result
 %% Parameters: Args = [Bytes, State | RestOfArgs]
@@ -4532,7 +4493,6 @@ unicode_incomplete_check([Bytes, #xmerl_sax_parser_state{encoding=Enc} = State |
 unicode_incomplete_check([Bytes,State | _], ErrString) when is_list(Bytes), ErrString =/= undefined ->
     ?fatal_error(State, ErrString).
 
-
 %%----------------------------------------------------------------------
 %% Function  : check_uri(Uri, CL) -> Result
 %% Parameters: Uri = string()
@@ -4684,10 +4644,11 @@ http("http://" ++ Address) ->
 	[Host, Rest] ->
 	    %% At his stage we know that address contains a Port number.
 	    {Port, Key} = split_to_slash(Rest, []),
-	    case catch list_to_integer(Port) of
-		PortInt when is_integer(PortInt) ->
-		    {Host, PortInt, Key};
-		_ ->
+	    try 
+                PortInt = list_to_integer(Port),
+                {Host, PortInt, Key}
+            catch
+                _:_ ->
 		    throw({error, "Malformed key; port not an integer, should be http://Host:Port/path or http://Host/path"})
 	    end;
 	[Address] ->
diff --git a/lib/xmerl/src/xmerl_scan.erl b/lib/xmerl/src/xmerl_scan.erl
index aec6767312c8..e3642232f1ce 100644
--- a/lib/xmerl/src/xmerl_scan.erl
+++ b/lib/xmerl/src/xmerl_scan.erl
@@ -1510,7 +1510,7 @@ check_notations(Tab,S) ->
     end.
 
 check_elements(Tab,S) ->
-    case catch ets:match(Tab,{{elem_def,'_'},'$2'},10) of
+    try ets:match(Tab,{{elem_def,'_'},'$2'},10) of
 	{_,_}=M ->
 	    Fun = fun({Match,'$end_of_table'},_F) ->
 			  lists:foreach(fun(X)->check_elements2(X,S) end,
@@ -1524,8 +1524,9 @@ check_elements(Tab,S) ->
 			  F(ets:match(Cont),F)
 		  end,
 	    Fun(M,Fun);
-	'$end_of_table' -> ok;
-	Err -> ?fatal({error_missing_declaration_in_DTD,Err},S)
+	'$end_of_table' -> ok
+    catch
+	_:Err -> ?fatal({error_missing_declaration_in_DTD,Err},S)
     end.
 
 % it is not an error to declare attributes for an element that is not
@@ -2881,11 +2882,11 @@ scan_reference("#" ++ T, S0) ->
 	    ?fatal(invalid_char_ref, S)
     end;
 scan_reference(T, S) ->
-    case catch scan_entity_ref(T, S) of
-	{'EXIT', _} ->
-	    ?fatal(error_scanning_entity_ref,S);
-	Other ->
-	    Other
+    try
+        scan_entity_ref(T, S)
+    catch
+	exit:_ ->
+	    ?fatal(error_scanning_entity_ref,S)
     end.
 
 
@@ -3939,17 +3940,15 @@ predefined_entity(_) ->    false.
 check_entity_recursion(EName,
 		       S=#xmerl_scanner{entity_references=EntityRefList}) ->
     Set = sofs:family(EntityRefList),
-    case catch sofs:family_to_digraph(Set, [acyclic]) of
-	{'EXIT',{cyclic,_}} ->
-	    ?fatal({illegal_recursion_in_Entity, EName}, S);
-	DG ->
+    try sofs:family_to_digraph(Set, [acyclic]) of
+        DG ->
 	    digraph:delete(DG),
-	    ok
+            ok
+    catch
+        error:{cyclic,_} ->
+	    ?fatal({illegal_recursion_in_Entity, EName}, S)
     end.
 
-
-
-
 %%%%%%% [15] Comment
 scan_comment(Str, S) ->
     scan_comment(Str, S, _Pos = undefined, _Parents = [], _Lang = []).
diff --git a/lib/xmerl/src/xmerl_simple.erl b/lib/xmerl/src/xmerl_simple.erl
index 3f3ce5b9fbb9..0635d468f2a9 100644
--- a/lib/xmerl/src/xmerl_simple.erl
+++ b/lib/xmerl/src/xmerl_simple.erl
@@ -51,11 +51,12 @@ scanner_options(Opts) ->
 		     {close_fun, fun close/1}]).
 
 scanner_options([H|T], Opts) ->
-    case catch keyreplace(H, 1, Opts) of
-	false ->
-	    scanner_options(T, [H|Opts]);
-	NewOpts ->
+    try keyreplace(H, 1, Opts) of
+        NewOpts ->
 	    scanner_options(T, NewOpts)
+    catch
+	throw:false ->
+	    scanner_options(T, [H|Opts])
     end;
 scanner_options([], Opts) ->
     Opts.
diff --git a/lib/xmerl/src/xmerl_validate.erl b/lib/xmerl/src/xmerl_validate.erl
index 1204b68c1038..670a00f90017 100644
--- a/lib/xmerl/src/xmerl_validate.erl
+++ b/lib/xmerl/src/xmerl_validate.erl
@@ -36,7 +36,13 @@ validate(#xmerl_scanner{doctype_name=DTName,doctype_DTD=OpProv},
     {error, {mismatched_root_element,Name,DTName}};
 validate(#xmerl_scanner{rules=Rules}=S,
 	 XML=#xmlElement{name=Name})->
-    catch do_validation(read_rules(Rules,Name),XML,Rules,S);
+    try
+        do_validation(read_rules(Rules,Name),XML,Rules,S)
+    catch
+        %% Just to make it compatible with old catch result
+        error:Reason:StackTrace -> {'EXIT', {Reason,StackTrace}};
+        exit:Reason -> {'EXIT', Reason}
+    end;
 validate(_, XML) ->
     {error, {no_xml_element, XML}}.
 
@@ -47,12 +53,8 @@ validate(_, XML) ->
 do_validation(undefined,#xmlElement{name=Name}, _Rules,_S) ->
     {error,{unknown_element,Name}};
 do_validation(El_Rule,XML,Rules,S)->
-    case catch valid_attributes(El_Rule#xmlElement.attributes,
-			  XML#xmlElement.attributes,S) of
-	{'EXIT',Reason} ->
-	    {error,Reason};
-	{error,Reason} ->
-	    {error,Reason};
+    try valid_attributes(El_Rule#xmlElement.attributes,
+                         XML#xmlElement.attributes,S) of
 	Attr_2->
 %	    XML_=XML#xmlElement{attributes=Attr_2},
 	    El_Rule_Cont = El_Rule#xmlElement.content,
@@ -69,6 +71,11 @@ do_validation(El_Rule,XML,Rules,S)->
 		XMLS ->
 		    XML#xmlElement{attributes=Attr_2,content=XMLS}
 	    end
+    catch
+        exit:Reason ->
+	    {error,Reason};
+        throw:{error,Reason} ->
+	    {error,Reason}
     end.
 
 check_direct_ws_SDD(XML,always_preserve) ->
@@ -451,9 +458,11 @@ parse(El_Name, [#xmlElement{name=El_Name} = XML |T], Rules, _WSaction, S)
 	    {[XML_], T}
     end;
 parse(any, Cont, Rules, _WSaction, S) ->
-    case catch parse_any(Cont, Rules, S) of
-	Err = {error, _} -> Err;
+    try parse_any(Cont, Rules, S) of
 	ValidContents -> {ValidContents, []}
+    catch
+	throw:{error, _} = Err ->
+            Err
     end;
 parse(El_Name, [#xmlElement{name=Name} |_T] = XMLS, _Rules, _WSa, _S) when is_atom(El_Name) ->
     {error,
diff --git a/lib/xmerl/src/xmerl_xpath_pred.erl b/lib/xmerl/src/xmerl_xpath_pred.erl
index 2423a22d436f..9a3508bfa82b 100644
--- a/lib/xmerl/src/xmerl_xpath_pred.erl
+++ b/lib/xmerl/src/xmerl_xpath_pred.erl
@@ -788,28 +788,30 @@ normalize([], _S, Acc) ->
 scan_number([H|T]) when ?whitespace(H) ->
     scan_number(T);
 scan_number("-" ++ T) ->
-    case catch xmerl_xpath_scan:scan_number(T) of
-	{{number, N}, Tail} ->
-	    case is_all_white(Tail) of
-		true ->
-		    N;
-		false ->
-		    'NaN'
-	    end;
-	_Other ->
-	    'NaN'
+    try 
+        {{number, _, N}, Tail} = xmerl_xpath_scan:scan_number(T),
+        case is_all_white(Tail) of
+            true ->
+                N;
+            false ->
+                'NaN'
+	    end
+    catch
+        _:_ ->
+            'NaN'
     end;
 scan_number(T) ->
-    case catch xmerl_xpath_scan:scan_number(T) of
-	{{number, N}, Tail} ->
-	    case is_all_white(Tail) of
-		true ->
-		    N;
-		false ->
-		    'NaN'
-	    end;
-	_Other ->
-	    'NaN'
+    try 
+        {{number, _, N}, Tail} = xmerl_xpath_scan:scan_number(T),
+        case is_all_white(Tail) of
+            true ->
+                N;
+            false ->
+                'NaN'
+        end
+    catch
+        _:_ ->
+            'NaN'        
     end.
 
 is_all_white([H|T]) when ?whitespace(H) ->
diff --git a/lib/xmerl/src/xmerl_xsd.erl b/lib/xmerl/src/xmerl_xsd.erl
index ee7143a8e605..4d6eeb24ce4f 100644
--- a/lib/xmerl/src/xmerl_xsd.erl
+++ b/lib/xmerl/src/xmerl_xsd.erl
@@ -172,10 +172,11 @@ You can provide the file name for the saved state. FileName is saved with the
       Reason :: term().
 state2file(S,FileName) when is_record(S,xsd_state) ->
     save_xsd_state(S),
-    case catch ets:tab2file(S#xsd_state.table,lists:append(FileName,".xss")) of
-	{'EXIT',Reason} ->
-	    {error,{[],?MODULE,Reason}};
-	Ret -> Ret
+    try
+        ets:tab2file(S#xsd_state.table,lists:append(FileName,".xss"))
+    catch
+	error:Reason:StackTrace ->
+	    {error,{[],?MODULE,{Reason, StackTrace}}}
     end.
 
 
@@ -191,7 +192,7 @@ The state can then be used validating an XML document.
       State  :: global_state(),
       Reason :: term().
 file2state(FileName) ->
-    case catch ets:file2tab(FileName) of
+    try ets:file2tab(FileName) of
 	{ok,Tab} ->
 	    case load_xsd_state(Tab) of
 		[{state,S}] when is_record(S,xsd_state) ->
@@ -201,16 +202,25 @@ file2state(FileName) ->
 		    {error,{[],?MODULE,{incomplete_file,FileName,Other}}}
 	    end;
 	{error,Reason} ->
-	    {error,{[],?MODULE,Reason}};
-	Other ->
-	    {error,{[],?MODULE,Other}}
+	    {error,{[],?MODULE,Reason}}
+    catch
+        error:Reason:StackTrace ->
+	    {error,{[],?MODULE,{'EXIT', {Reason, StackTrace}}}}
     end.
 
 save_xsd_state(S) ->
-    catch ets:insert(S#xsd_state.table,{state,S}).
+    try
+        ets:insert(S#xsd_state.table,{state,S})
+    catch
+        _:_ -> ok
+    end.
 load_xsd_state(Table) ->
-    catch ets:lookup(Table,state).
-
+    try
+        ets:lookup(Table,state)
+    catch
+        error:Reason:StackTrace -> {'EXIT', {Reason, StackTrace}}
+    end.
+   
 xmerl_xsd_vsn() ->
     case lists:keysearch(vsn,1,xmerl_xsd:module_info(attributes)) of
 	{value,{_,MD5_VSN}} ->
@@ -281,14 +291,11 @@ process_validate2({SE,_},Schema,Xml,Opts) ->
     S4 = validation_options(S3,Opts),
     validate3(Schema,Xml,S4).
 
-validate3(Schema, Xml,S =#xsd_state{errors=[]}) ->
-    Ret = {_, S2} =
-	case catch validate_xml(Xml, S) of
+validate3(Schema, Xml,S =#xsd_state{errors=[]}) -> 
+    Ret = {_, S2} = 
+	try validate_xml(Xml, S) of
 	    _Err = {error, Reason} ->
 		{Xml, acc_errs(S, Reason)};
-	    {'EXIT', Reason} ->
-		{Xml, acc_errs(S, {error_path(Xml, Xml#xmlElement.name), ?MODULE,
-				 {undefined, {internal_error, Reason}}})};
 	    {XML2, Rest, Sx} ->
 		case lists:dropwhile(fun(X) when is_record(X, xmlComment) -> true; (_) -> false end, Rest) of
 		    [] ->
@@ -302,6 +309,13 @@ validate3(Schema, Xml,S =#xsd_state{errors=[]}) ->
 			{Xml,acc_errs(Sx,{error_path(UnValidated,Xml#xmlElement.name),?MODULE,
 					  {unvalidated_rest,UnValidated}})}
 		end
+        catch
+            error:Reason:StackTrace -> 
+                {Xml, acc_errs(S, {error_path(Xml, Xml#xmlElement.name), ?MODULE,
+                                   {undefined, {internal_error, {Reason, StackTrace}}}})};
+	    exit:Reason ->
+		{Xml, acc_errs(S, {error_path(Xml, Xml#xmlElement.name), ?MODULE,
+                                   {undefined, {internal_error, Reason}}})}            
 	end,
     save_to_file(S2,filename:rootname(Schema)++".tab2"),
     case S2#xsd_state.errors of
@@ -357,7 +371,7 @@ process_schema2({SE,_},State,_Schema) ->
 	S3 = #xsd_state{errors=[]} ->
 	    {ok,S3};
 	S3 ->
-	    delete_table(S3),
+	    _ = delete_table(S3),
 	    return_error(S3#xsd_state.errors)
     end.
 
@@ -1676,11 +1690,23 @@ optional(#chain{occurrence={0,_}}) ->
 optional(#alternative{occurrence={0,_}}) ->
     true;
 optional(#chain{content=Content}) ->
-    catch is_optional_content(Content);
+    try
+        is_optional_content(Content)
+    catch
+        throw:false -> false
+    end;
 optional(#alternative{content=Content}) ->
-    catch is_optional_content(Content);
+    try
+        is_optional_content(Content)
+    catch
+        throw:false -> false
+    end;
 optional({all,{Content,_}}) ->
-    catch is_optional_content(Content);
+    try
+        is_optional_content(Content)
+    catch
+        throw:false -> false
+    end;
 optional(_) ->
     false.
 
@@ -2322,13 +2348,14 @@ set_num_el(S=#xsd_state{},#xsd_state{num_el=I}) ->
 
 
 occurrence(El=#xmlElement{attributes=Atts},{Min,Max},S) ->
-    AttVal=fun(#xmlAttribute{value=V},Sin) ->
-		   case catch mk_int_or_atom(V) of
-		       {'EXIT',_} ->
+    AttVal=fun(#xmlAttribute{value=V},Sin) -> 
+		   try mk_int_or_atom(V) of
+		       IAV -> {IAV,Sin}
+                   catch
+		       error:_ ->
 			   Err = {error_path(El,schema),?MODULE,
 				  {illegal_occurance_value,V}},
-			   {V,acc_errs(Sin,Err)};
-		       IAV -> {IAV,Sin}
+			   {V,acc_errs(Sin,Err)}
 		   end;
 	      (V1,Sin) -> {V1,Sin}
 	   end,
@@ -2941,7 +2968,7 @@ check_all([],CM,_Occ,_,S,Checked,_PrevXML) ->
     end.
 
 check_any(E,Any,_Env,S) ->
-    case catch validate_xml(E,S#xsd_state{scope=[]}) of
+    try validate_xml(E,S#xsd_state{scope=[]}) of
 	{[Result],[],S2} ->
 	    {Result,S2#xsd_state{scope=S#xsd_state.scope}};
 	{Result,[],S2} ->
@@ -2950,9 +2977,14 @@ check_any(E,Any,_Env,S) ->
 	    Err = {error_path(E,undefined),?MODULE,{failed_validating,E,Any}},
 	    {E,acc_errs(S2#xsd_state{scope=S#xsd_state.scope},Err)};
 	{error,Reason} ->
-	    {E,acc_errs(S,Reason)};
-	{'EXIT',Reason} ->
-%%	    {E,acc_errs(S,format_error({internal_error,Reason},E,Any,Env))}
+	    {E,acc_errs(S,Reason)}
+    catch
+	error:Reason:StackTrace ->
+            %% {E,acc_errs(S,format_error({internal_error,Reason},E,Any,Env))}
+	    Err = {error_path(E,undefined),?MODULE,{internal_error,{Reason, StackTrace}}},
+	    {E,acc_errs(S,Err)};
+        exit:Reason ->
+            %% {E,acc_errs(S,format_error({internal_error,Reason},E,Any,Env))}
 	    Err = {error_path(E,undefined),?MODULE,{internal_error,Reason}},
 	    {E,acc_errs(S,Err)}
     end.
@@ -3697,12 +3729,13 @@ check_substitutionGroups(SGs,S) ->
     save_substitutionGroup(SGs,S3).
 check_substGr_acyclic(SGs,S) ->
     Set = sofs:family(SGs),
-    case catch sofs:family_to_digraph(Set, [acyclic]) of
-	{'EXIT',{cyclic,_}} ->
-	    acc_errs(S,{[],?MODULE,{cyclic_substitutionGroup,SGs}});
+    try sofs:family_to_digraph(Set, [acyclic]) of
 	DG ->
 	    digraph:delete(DG),
 	    S
+    catch
+        error:cyclic ->
+            acc_errs(S,{[],?MODULE,{cyclic_substitutionGroup,SGs}})
     end.
 check_substGr_type_structure([SG|SGs],S) ->
     check_substGr_type_structure(SGs,check_substGr_type_structure2(SG,S));
@@ -3711,36 +3744,41 @@ check_substGr_type_structure([],S) ->
 check_substGr_type_structure2({Head,SGMembers},S) ->
     TypeCheck =
 	fun(SG,S_in) ->
-		case catch cmp_substGr_types(Head,SG,S_in) of
-		    {'EXIT',_} ->
-			acc_errs(S_in,{[],?MODULE,
+                try
+                    cmp_substGr_types(Head,SG,S_in)
+                catch
+                    error:_ ->
+                        acc_errs(S_in,{[],?MODULE,
 				       {substitutionGroup_error,Head,SG}});
-		    S_out -> S_out
-		end
+                    exit:_ ->
+                        acc_errs(S_in,{[],?MODULE,
+				       {substitutionGroup_error,Head,SG}})
+                end
 	end,
     foldl(TypeCheck,S,SGMembers).
 cmp_substGr_types(Head,SG,S) ->
     {HeadElement,S2} = load_object({element,Head},S),
     {MemberElement,S3} = load_object({element,SG},S2),
-    case catch derived_or_equal(MemberElement#schema_element.type,
-				HeadElement#schema_element.type,
-				[],S3) of
-	S4=#xsd_state{} ->
-	    S4;
-	_ ->
+    try
+        derived_or_equal(MemberElement#schema_element.type,
+                         HeadElement#schema_element.type,
+                         [],S3)
+    catch
+	_:_ ->
 	    acc_errs(S3,{[],?MODULE,{internal_error,derived_or_equal,
 				     MemberElement#schema_element.type,
 				     HeadElement#schema_element.type}})
     end.
 check_cyclic_defs(S=#xsd_state{circularity_disallowed=CA}) ->
     Set = sofs:relation_to_family(sofs:relation(CA)),
-    case catch sofs:family_to_digraph(Set, [acyclic]) of
-	{'EXIT',{cyclic,_}} ->
-	    acc_errs(S,{[],?MODULE,{cyclic_definition,CA}});
+    try sofs:family_to_digraph(Set, [acyclic]) of
 	DG ->
 	    digraph:delete(DG),
 	    S
-    end.
+    catch
+        error:cyclic ->
+	    acc_errs(S,{[],?MODULE,{cyclic_definition,CA}})
+        end.
 
 
 
@@ -4052,14 +4090,17 @@ merge_derived_types(Type1,Type2,Mode,S) ->
 merge_derived_types(Type,Type,_Blocks,_Mode,S) ->
     {Type,S};
 merge_derived_types(XSDType,InstType,Blocks,Mode,S) ->
-    case catch merge_derived_types2(XSDType,InstType,Blocks,Mode,S) of
-	{'EXIT',Reason} ->
-	    {InstType,acc_errs(S,{[],?MODULE,{internal_error,merge_derived_types,Reason}})};
+    try merge_derived_types2(XSDType,InstType,Blocks,Mode,S) of
 	{error,S2} ->
 	    {InstType,S2};
 	{MergedType,S2} ->
 	    _ = save_merged_type(MergedType,S2),
 	    {MergedType,S2}
+    catch
+	error:Reason:StackTrace ->
+	    {InstType,acc_errs(S,{[],?MODULE,{internal_error,merge_derived_types,{Reason, StackTrace}}})};
+	exit:Reason ->
+	    {InstType,acc_errs(S,{[],?MODULE,{internal_error,merge_derived_types,Reason}})}
     end.
 
 merge_derived_types2(XSDType=#schema_complex_type{},
@@ -4864,12 +4905,13 @@ qualified_name(Name,NS,Default,Scope) ->
     end.
 
 atom_if_shortasciilist(N) when is_list(N) ->
-    case catch list_to_atom(N) of
-	{'EXIT',_Reason} ->
+    try
+        list_to_atom(N)
+    catch
+	error:_ ->
 	    %% Reason may be system_limit if N is very long, it may be
 	    %% badarg ifN is a list of UTF characters.
-	    N;
-	AN -> AN
+	    N
     end;
 atom_if_shortasciilist(N) ->
     N.
@@ -4937,15 +4979,20 @@ create_tables(S) ->
     S.
 
 delete_table(#xsd_state{table=Tab}) ->
-    catch ets:delete(Tab).
+    try
+        ets:delete(Tab)
+    catch
+        error:Reason:StackTrace -> {'EXIT', {Reason, StackTrace}};
+        exit:Reason -> {'EXIT', Reason}
+    end.
 
 -doc hidden.
 print_table(#xsd_state{table=Tab}) ->
-    case catch ets:tab2list(Tab) of
-	Res when is_list(Res) ->
-	    Res;
-	{'EXIT',Reason} ->
-	    {error,{?MODULE,[],Reason}}
+    try
+        ets:tab2list(Tab)
+    catch
+	error:Reason:StackTrace ->
+	    {error,{?MODULE,[],{Reason, StackTrace}}}
     end;
 print_table(_) ->
     ok.
@@ -5049,13 +5096,27 @@ save_to_file(S=#xsd_state{tab2file=TF}) ->
 	true ->
 	    {ok,IO}=file:open(filename:rootname(S#xsd_state.schema_name)++".tab",
 			      [write]),
-	    io:format(IO,"~p~n",[catch ets:tab2list(S#xsd_state.table)]),
+            try
+                List = ets:tab2list(S#xsd_state.table),
+                io:format(IO,"~p~n",[List])
+            catch
+                E:Reason:Stacktrace ->
+                    logger:info("~p:save_to_file: ~p\n~p\n~p\n\n", [?MODULE, E, Reason, Stacktrace]),
+                    ok
+            end,
 	    ok = file:close(IO);
 	false ->
 	    ok;
 	IOFile ->
 	    {ok,IO}=file:open(IOFile,[write]),
-	    io:format(IO,"~p~n",[catch ets:tab2list(S#xsd_state.table)]),
+            try
+                List = ets:tab2list(S#xsd_state.table),
+                io:format(IO,"~p~n",[List])
+            catch
+                E:Reason:Stacktrace ->
+                    logger:info("~p:save_to_file: ~p\n~p\n~p\n\n", [?MODULE, E, Reason, Stacktrace]),
+                    ok
+            end,
 	    ok = file:close(IO)
     end.
 
@@ -5067,8 +5128,12 @@ resave_object({Kind,Obj},S) ->
     save_in_table({Kind,object_name(Obj)},Obj,S).
 
 save_in_table(Name,ElDef,S=#xsd_state{table=Tab}) ->
-    catch ets:insert(Tab,{Name,ElDef}),
-    S.
+    try
+        ets:insert(Tab,{Name,ElDef}),
+        S
+    catch
+        _:_ -> S
+    end.
 
 save_idc(key,IDConstr,S) ->
     save_key(IDConstr,S);
@@ -5217,11 +5282,13 @@ get_schema_cm(Tab,Namespace) ->
     NSC = Schema#schema.content,
     Schema#schema{content=NSC++[X||X<-NoNamespaceC,member(X,NSC)==false]}.
 get_schema_cm1(Tab,Namespace) ->
-    case catch ets:lookup(Tab,{schema,Namespace}) of
+    try ets:lookup(Tab,{schema,Namespace}) of
 	[{_,H}] ->
 	    H;
 	_ ->
 	    #schema{}
+    catch
+        _:_ ->  #schema{}
     end.
 get_no_namespace_content(Tab) ->
     case get_schema_cm1(Tab,[]) of
diff --git a/lib/xmerl/src/xmerl_xsd_type.erl b/lib/xmerl/src/xmerl_xsd_type.erl
index 95623b6c9731..ea9d32a82e69 100644
--- a/lib/xmerl/src/xmerl_xsd_type.erl
+++ b/lib/xmerl/src/xmerl_xsd_type.erl
@@ -36,18 +36,22 @@
 
 
 -define(catch_exit(_Call_,_Value_,_ErrorCause_),
-	case catch (_Call_) of
-	    {'EXIT',_} ->
-		{error,{type,_ErrorCause_,_Value_}};
-	    {error,_} ->
-		{error,{_ErrorCause_,_Value_}};
-	    _ ->
-		{ok,_Value_}
+	try (_Call_) of
+            _Result_ ->
+                catch_exit_result(_Result_,_Value_,_ErrorCause_)
+        catch
+            error:_ ->
+                {error,{type,_ErrorCause_,_Value_}};
+            exit:_ ->
+		{error,{type,_ErrorCause_,_Value_}}
 	end).
 
 -define(is_whitespace(__WS__),
 	__WS__==16#20; __WS__==16#9;__WS__==16#a; __WS__==16#d).
 
+catch_exit_result({error,_},Value,ErrorCause) -> {error,{ErrorCause,Value}};
+catch_exit_result(_,Value,_ErrorCause) -> {ok,Value}.
+
 check_simpleType(Name,Value,S) when is_list(Name) ->
     ?debug("simpleType name a list: "++Name++"~n",[]),
     check_simpleType(list_to_atom(Name),Value,S);
@@ -131,11 +135,14 @@ check_simpleType(anyURI,Value,S) ->
     case xmerl_uri:parse(Value) of
 	{error,_} ->
 	    %% might be a relative uri, then it has to be a path in the context
-	    case catch file:read_file_info(filename:join(S#xsd_state.xsd_base,Value)) of
+	    try file:read_file_info(filename:join(S#xsd_state.xsd_base,Value)) of
 		{ok,_} ->
 		    {ok,Value};
 		_ ->
 		    {error,{value_not_anyURI,Value}}
+            catch
+                _:_ ->
+                    {error,{value_not_anyURI,Value}}
 	    end;
 	_ ->
 	    {ok,Value}
@@ -213,10 +220,11 @@ check_decimal(Value) ->
 %%     I=string:chr(Value,$.),
 %%     {NumberDot,Decimal}=lists:split(I,Value),
 %%     Number=string:strip(NumberDot,right,$.),
-%%     case catch {list_to_integer(Number),list_to_integer(Decimal)} of
-%% 	{'EXIT',_} ->
-%% 	    {error,{value_not_decimal,Value}};
-%% 	_ -> {ok,Value}
+%%     try {list_to_integer(Number),list_to_integer(Decimal)} of
+%%        _ -> {ok,Value}
+%%     catch
+%% 	  error:_ ->
+%% 	     {error,{value_not_decimal,Value}}
 %%     end.
 
 check_float(V="-INF") ->
@@ -297,14 +305,16 @@ check_duration_time(Time,[H|T]) ->
     end.
 
 check_positive_integer(Value) ->
-    case catch list_to_integer(Value) of
+    try list_to_integer(Value) of
 	Int when is_integer(Int),Int>=0 ->
 	    {ok,Int};
 	_ ->
 	    {error,{value_not_integer,Value}}
+    catch
+        _:_ ->
+            {error,{value_not_integer,Value}}
     end.
 
-
 %% check_integer and thereof derived types
 check_integer(Value) ->
     {ok,list_to_integer(Value)}.
@@ -552,15 +562,16 @@ check_gMonth("--"++Value) ->
     end.
 
 check_base64Binary(Value) ->
-    case catch xmerl_b64Bin:parse(xmerl_b64Bin_scan:scan(Value)) of
+    try xmerl_b64Bin:parse(xmerl_b64Bin_scan:scan(Value)) of
 	{ok,_} ->
 	    {ok,Value};
 	Err = {error,_} ->
-	    Err;
-	{'EXIT',{error,Reason}} -> %% scanner failed on character
+	    Err
+    catch
+	exit:{error,Reason} -> %% scanner failed on character
 	    {error,Reason};
-	{'EXIT',Reason} ->
-	    {error,{internal_error,Reason}}
+	error:Reason:Stacktrace ->
+	    {error,{internal_error,{Reason,Stacktrace}}}
     end.
 
 %% tokens may not contain the carriage return (#xD), line feed (#xA)
@@ -841,11 +852,14 @@ maxInclusive_fun(T,V)
        T==unsignedLong;T==int;T==unsignedInt;T==short;
        T==unsignedShort;T==byte;T==unsignedByte ->
     fun(Val) ->
-	    case (catch list_to_integer(Val) =< list_to_integer(V)) of
+	    try list_to_integer(Val) =< list_to_integer(V) of
 		true ->
 		    {ok,Val};
-		_ -> 
+		false ->
 		    {error,{maxInclusive,Val,should_be_less_than_or_equal_with,V}}
+            catch
+                _:_ ->
+                    {error,{maxInclusive,Val,should_be_less_than_or_equal_with,V}}
 	    end
     end;
 maxInclusive_fun(T,V) when T==decimal;T==float;T==double ->
@@ -887,11 +901,14 @@ maxExclusive_fun(T,V)
        T==unsignedLong;T==int;T==unsignedInt;T==short;
        T==unsignedShort;T==byte;T==unsignedByte ->
     fun(Val) ->
-	    case (catch list_to_integer(Val) < list_to_integer(V)) of
+	    try list_to_integer(Val) < list_to_integer(V) of
 		true ->
 		    {ok,Val};
-		_ -> 
+		false -> 
 		    {error,{maxExclusive,Val,not_less_than,V}}
+            catch
+                _:_ ->
+                    {error,{maxExclusive,Val,not_less_than,V}}
 	    end
     end;
 maxExclusive_fun(T,V) when T==decimal;T==float;T==double ->
@@ -931,11 +948,14 @@ minExclusive_fun(T,V)
        T==unsignedLong;T==int;T==unsignedInt;T==short;
        T==unsignedShort;T==byte;T==unsignedByte ->
     fun(Val) ->
-	    case (catch list_to_integer(Val) > list_to_integer(V)) of
+	    try list_to_integer(Val) > list_to_integer(V) of
 		true ->
 		    {ok,Val};
-		_ -> 
-		    {error,{minExclusive,Val,not_greater_than,V}}
+		false -> 
+                    {error,{minExclusive,Val,not_greater_than,V}}
+            catch
+                _:_ ->
+                    {error,{minExclusive,Val,not_greater_than,V}}
 	    end
     end;
 minExclusive_fun(T,V) when T==decimal;T==float;T==double ->
@@ -975,11 +995,14 @@ minInclusive_fun(T,V)
        T==unsignedLong;T==int;T==unsignedInt;T==short;
        T==unsignedShort;T==byte;T==unsignedByte ->
     fun(Val) ->
-	    case (catch list_to_integer(Val) >= list_to_integer(V)) of
+	    try list_to_integer(Val) >= list_to_integer(V) of
 		true ->
 		    {ok,Val};
-		_ -> 
+		false -> 
 		    {error,{minInclusive,Val,not_greater_than_or_equal_with,V}}
+            catch
+                _:_ ->
+                    {error,{minInclusive,Val,not_greater_than_or_equal_with,V}}
 	    end
     end;
 minInclusive_fun(T,V) when T==decimal;T==float;T==double ->