← Back to branch summary

~ubuntu-branches/ubuntu/raring/clucene-core/raring-proposed

« back to all changes in this revision

Viewing changes to src/ext/boost/detail/catch_exceptions.hpp

  • Committer: Package Import Robot
  • Author(s): Fathi Boudra
  • Date: 2012-08-11 09:33:38 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120811093338-fgrx41ftqew3qt6a
Tags: 2.3.3.4-1
http://bugs.debian.org/661703
* New upstream release (Closes: #661703).
* Convert package to multiarch.
* Drop obsolete patches:
  - 01_add_missing_include_bug505667.diff
  - 02_posixness_fix_bug530308.diff
* Add patches:
  - Fixing_ZLIB_configuration_in_shared_CMakeLists.patch
  - Fix-pkgconfig-file-by-adding-clucene-shared-library.patch
  - Install-contribs-lib.patch
  - multiarch.patch
* Update debian/compat: bump to 8.
* Update debian/control:
  - update build dependencies (add cmake, libboost-dev and libz-dev).
  - bump Standards-Version to 3.9.3.
  - rename packages due to ABI bump: libclucene0ldbl -> libclucene-core1.
  - add libclucene-contribs1 package.
* Update debian/rules:
  - rewrite to use CMake.
  - add multiarch support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ext/boost/detail/catch_exceptions.hpp
 
1
//  boost/catch_exceptions.hpp -----------------------------------------------//
 
2
 
 
3
//  Copyright Beman Dawes 1995-2001.  Distributed under the Boost
 
4
//  Software License, Version 1.0. (See accompanying file
 
5
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
6
 
 
7
//  See http://www.boost.org/libs/test for documentation.
 
8
 
 
9
//  Revision History
 
10
//   13 Jun 01 report_exception() made inline. (John Maddock, Jesse Jones)
 
11
//   26 Feb 01 Numerous changes suggested during formal review. (Beman)
 
12
//   25 Jan 01 catch_exceptions.hpp code factored out of cpp_main.cpp.
 
13
//   22 Jan 01 Remove test_tools dependencies to reduce coupling.
 
14
//    5 Nov 00 Initial boost version (Beman Dawes)
 
15
 
 
16
#ifndef BOOST_CATCH_EXCEPTIONS_HPP
 
17
#define BOOST_CATCH_EXCEPTIONS_HPP
 
18
 
 
19
//  header dependencies are deliberately restricted to the standard library
 
20
//  to reduce coupling to other boost libraries.
 
21
#include <string>             // for string
 
22
#include <new>                // for bad_alloc
 
23
#include <typeinfo>           // for bad_cast, bad_typeid
 
24
#include <exception>          // for exception, bad_exception
 
25
#include <stdexcept>          // for std exception hierarchy
 
26
#include <boost/cstdlib.hpp>  // for exit codes
 
27
# if __GNUC__ != 2 || __GNUC_MINOR__ > 96
 
28
#   include <ostream>         // for ostream
 
29
# else
 
30
#   include <iostream> // workaround GNU missing ostream header
 
31
# endif
 
32
 
 
33
# if defined(__BORLANDC__) && (__BORLANDC__ <= 0x0551)
 
34
#   define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT 
 
35
# endif
 
36
 
 
37
#if defined(MPW_CPLUS) && (MPW_CPLUS <= 0x890)
 
38
#   define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT 
 
39
    namespace std { class bad_typeid { }; }
 
40
# endif
 
41
 
 
42
namespace boost
 
43
{
 
44
 
 
45
  namespace detail
 
46
  {
 
47
    //  A separate reporting function was requested during formal review.
 
48
    inline void report_exception( std::ostream & os, 
 
49
                                  const char * name, const char * info )
 
50
      { os << "\n** uncaught exception: " << name << " " << info << std::endl; }
 
51
  }
 
52
 
 
53
  //  catch_exceptions  ------------------------------------------------------//
 
54
 
 
55
  template< class Generator >  // Generator is function object returning int
 
56
  int catch_exceptions( Generator function_object,
 
57
                        std::ostream & out, std::ostream & err )
 
58
  {
 
59
    int result = 0;               // quiet compiler warnings
 
60
    bool exception_thrown = true; // avoid setting result for each excptn type
 
61
 
 
62
#ifndef BOOST_NO_EXCEPTIONS
 
63
    try
 
64
    {
 
65
#endif
 
66
      result = function_object();
 
67
      exception_thrown = false;
 
68
#ifndef BOOST_NO_EXCEPTIONS
 
69
    }
 
70
 
 
71
    //  As a result of hard experience with strangely interleaved output
 
72
    //  under some compilers, there is a lot of use of endl in the code below
 
73
    //  where a simple '\n' might appear to do.
 
74
 
 
75
    //  The rules for catch & arguments are a bit different from function 
 
76
    //  arguments (ISO 15.3 paragraphs 18 & 19). Apparently const isn't
 
77
    //  required, but it doesn't hurt and some programmers ask for it.
 
78
 
 
79
    catch ( const char * ex )
 
80
      { detail::report_exception( out, "", ex ); }
 
81
    catch ( const std::string & ex )
 
82
      { detail::report_exception( out, "", ex.c_str() ); }
 
83
 
 
84
    //  std:: exceptions
 
85
    catch ( const std::bad_alloc & ex )
 
86
      { detail::report_exception( out, "std::bad_alloc:", ex.what() ); }
 
87
 
 
88
# ifndef BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT
 
89
    catch ( const std::bad_cast & ex )
 
90
      { detail::report_exception( out, "std::bad_cast:", ex.what() ); }
 
91
    catch ( const std::bad_typeid & ex )
 
92
      { detail::report_exception( out, "std::bad_typeid:", ex.what() ); }
 
93
# else
 
94
    catch ( const std::bad_cast & )
 
95
      { detail::report_exception( out, "std::bad_cast", "" ); }
 
96
    catch ( const std::bad_typeid & )
 
97
      { detail::report_exception( out, "std::bad_typeid", "" ); }
 
98
# endif
 
99
 
 
100
    catch ( const std::bad_exception & ex )
 
101
      { detail::report_exception( out, "std::bad_exception:", ex.what() ); }
 
102
    catch ( const std::domain_error & ex )
 
103
      { detail::report_exception( out, "std::domain_error:", ex.what() ); }
 
104
    catch ( const std::invalid_argument & ex )
 
105
      { detail::report_exception( out, "std::invalid_argument:", ex.what() ); }
 
106
    catch ( const std::length_error & ex )
 
107
      { detail::report_exception( out, "std::length_error:", ex.what() ); }
 
108
    catch ( const std::out_of_range & ex )
 
109
      { detail::report_exception( out, "std::out_of_range:", ex.what() ); }
 
110
    catch ( const std::range_error & ex )
 
111
      { detail::report_exception( out, "std::range_error:", ex.what() ); }
 
112
    catch ( const std::overflow_error & ex )
 
113
      { detail::report_exception( out, "std::overflow_error:", ex.what() ); }
 
114
    catch ( const std::underflow_error & ex )
 
115
      { detail::report_exception( out, "std::underflow_error:", ex.what() ); }
 
116
    catch ( const std::logic_error & ex )
 
117
      { detail::report_exception( out, "std::logic_error:", ex.what() ); }
 
118
    catch ( const std::runtime_error & ex )
 
119
      { detail::report_exception( out, "std::runtime_error:", ex.what() ); }
 
120
    catch ( const std::exception & ex )
 
121
      { detail::report_exception( out, "std::exception:", ex.what() ); }
 
122
 
 
123
    catch ( ... )
 
124
      { detail::report_exception( out, "unknown exception", "" ); }
 
125
#endif // BOOST_NO_EXCEPTIONS
 
126
 
 
127
    if ( exception_thrown ) result = boost::exit_exception_failure;
 
128
 
 
129
    if ( result != 0 && result != exit_success )
 
130
    {
 
131
      out << std::endl << "**** returning with error code "
 
132
                << result << std::endl;
 
133
      err
 
134
        << "**********  errors detected; see stdout for details  ***********"
 
135
        << std::endl;
 
136
    }
 
137
#if !defined(BOOST_NO_CPP_MAIN_SUCCESS_MESSAGE)
 
138
    else { out << std::flush << "no errors detected" << std::endl; }
 
139
#endif
 
140
    return result;
 
141
  } // catch_exceptions
 
142
 
 
143
} // boost
 
144
 
 
145
#endif  // BOOST_CATCH_EXCEPTIONS_HPP
 
146