boost/exception/exception.hpp

   1 //Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
   2
   3 //Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 //file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #ifndef UUID_274DA366004E11DCB1DDFE2E56D89593
   7 #define UUID_274DA366004E11DCB1DDFE2E56D89593
   8 #if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
   9 #pragma GCC system_header
  10 #endif
  11 #if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
  12 #pragma warning(push,1)
  13 #endif
  14
  15 namespace
  16 boost
  17     {
  18     namespace
  19     exception_detail
  20         {
  21         template <class T>
  22         class
  23         refcount_ptr
  24             {
  25             public:
  26
  27             refcount_ptr():
  28                 px_(0)
  29                 {
  30                 }
  31
  32             ~refcount_ptr()
  33                 {
  34                 release();
  35                 }
  36
  37             refcount_ptr( refcount_ptr const & x ):
  38                 px_(x.px_)
  39                 {
  40                 add_ref();
  41                 }
  42
  43             refcount_ptr &
  44             operator=( refcount_ptr const & x )
  45                 {
  46                 adopt(x.px_);
  47                 return *this;
  48                 }
  49
  50             void
  51             adopt( T * px )
  52                 {
  53                 release();
  54                 px_=px;
  55                 add_ref();
  56                 }
  57
  58             T *
  59             get() const
  60                 {
  61                 return px_;
  62                 }
  63
  64             private:
  65
  66             T * px_;
  67
  68             void
  69             add_ref()
  70                 {
  71                 if( px_ )
  72                     px_->add_ref();
  73                 }
  74
  75             void
  76             release()
  77                 {
  78                 if( px_ && px_->release() )
  79                     px_=0;
  80                 }
  81             };
  82         }
  83
  84     ////////////////////////////////////////////////////////////////////////
  85
  86     template <class Tag,class T>
  87     class error_info;
  88
  89     typedef error_info<struct throw_function_,char const *> throw_function;
  90     typedef error_info<struct throw_file_,char const *> throw_file;
  91     typedef error_info<struct throw_line_,int> throw_line;
  92
  93     template <>
  94     class
  95     error_info<throw_function_,char const *>
  96         {
  97         public:
  98         typedef char const * value_type;
  99         value_type v_;
 100         explicit
 101         error_info( value_type v ):
 102             v_(v)
 103             {
 104             }
 105         };
 106
 107     template <>
 108     class
 109     error_info<throw_file_,char const *>
 110         {
 111         public:
 112         typedef char const * value_type;
 113         value_type v_;
 114         explicit
 115         error_info( value_type v ):
 116             v_(v)
 117             {
 118             }
 119         };
 120
 121     template <>
 122     class
 123     error_info<throw_line_,int>
 124         {
 125         public:
 126         typedef int value_type;
 127         value_type v_;
 128         explicit
 129         error_info( value_type v ):
 130             v_(v)
 131             {
 132             }
 133         };
 134
 135 #if defined(__GNUC__)
 136 # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 137 #  pragma GCC visibility push (default)
 138 # endif
 139 #endif
 140     class exception;
 141 #if defined(__GNUC__)
 142 # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 143 #  pragma GCC visibility pop
 144 # endif
 145 #endif
 146
 147     template <class T>
 148     class shared_ptr;
 149
 150     namespace
 151     exception_detail
 152         {
 153         class error_info_base;
 154         struct type_info_;
 155
 156         struct
 157         error_info_container
 158             {
 159             virtual char const * diagnostic_information( char const * ) const = 0;
 160             virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
 161             virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
 162             virtual void add_ref() const = 0;
 163             virtual bool release() const = 0;
 164             virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
 165
 166             protected:
 167
 168             ~error_info_container() throw()
 169                 {
 170                 }
 171             };
 172
 173         template <class>
 174         struct get_info;
 175
 176         template <>
 177         struct get_info<throw_function>;
 178
 179         template <>
 180         struct get_info<throw_file>;
 181
 182         template <>
 183         struct get_info<throw_line>;
 184
 185         char const * get_diagnostic_information( exception const &, char const * );
 186
 187         void copy_boost_exception( exception *, exception const * );
 188
 189         template <class E,class Tag,class T>
 190         E const & set_info( E const &, error_info<Tag,T> const & );
 191
 192         template <class E>
 193         E const & set_info( E const &, throw_function const & );
 194
 195         template <class E>
 196         E const & set_info( E const &, throw_file const & );
 197
 198         template <class E>
 199         E const & set_info( E const &, throw_line const & );
 200         }
 201
 202 #if defined(__GNUC__)
 203 # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 204 #  pragma GCC visibility push (default)
 205 # endif
 206 #endif
 207     class
 208     exception
 209         {
 210         protected:
 211
 212         exception():
 213             throw_function_(0),
 214             throw_file_(0),
 215             throw_line_(-1)
 216             {
 217             }
 218
 219 #ifdef __HP_aCC
 220         //On HP aCC, this protected copy constructor prevents throwing boost::exception.
 221         //On all other platforms, the same effect is achieved by the pure virtual destructor.
 222         exception( exception const & x ) throw():
 223             data_(x.data_),
 224             throw_function_(x.throw_function_),
 225             throw_file_(x.throw_file_),
 226             throw_line_(x.throw_line_)
 227             {
 228             }
 229 #endif
 230
 231         virtual ~exception() throw()
 232 #ifndef __HP_aCC
 233             = 0 //Workaround for HP aCC, =0 incorrectly leads to link errors.
 234 #endif
 235             ;
 236
 237 #if (defined(__MWERKS__) && __MWERKS__<=0x3207) || (defined(_MSC_VER) && _MSC_VER<=1310)
 238         public:
 239 #else
 240         private:
 241
 242         template <class E>
 243         friend E const & exception_detail::set_info( E const &, throw_function const & );
 244
 245         template <class E>
 246         friend E const & exception_detail::set_info( E const &, throw_file const & );
 247
 248         template <class E>
 249         friend E const & exception_detail::set_info( E const &, throw_line const & );
 250
 251         template <class E,class Tag,class T>
 252         friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
 253
 254         friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
 255
 256         template <class>
 257         friend struct exception_detail::get_info;
 258         friend struct exception_detail::get_info<throw_function>;
 259         friend struct exception_detail::get_info<throw_file>;
 260         friend struct exception_detail::get_info<throw_line>;
 261         friend void exception_detail::copy_boost_exception( exception *, exception const * );
 262 #endif
 263         mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
 264         mutable char const * throw_function_;
 265         mutable char const * throw_file_;
 266         mutable int throw_line_;
 267         };
 268 #if defined(__GNUC__)
 269 # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 270 #  pragma GCC visibility pop
 271 # endif
 272 #endif
 273
 274     inline
 275     exception::
 276     ~exception() throw()
 277         {
 278         }
 279
 280     namespace
 281     exception_detail
 282         {
 283         template <class E>
 284         E const &
 285         set_info( E const & x, throw_function const & y )
 286             {
 287             x.throw_function_=y.v_;
 288             return x;
 289             }
 290
 291         template <class E>
 292         E const &
 293         set_info( E const & x, throw_file const & y )
 294             {
 295             x.throw_file_=y.v_;
 296             return x;
 297             }
 298
 299         template <class E>
 300         E const &
 301         set_info( E const & x, throw_line const & y )
 302             {
 303             x.throw_line_=y.v_;
 304             return x;
 305             }
 306         }
 307
 308     ////////////////////////////////////////////////////////////////////////
 309
 310     namespace
 311     exception_detail
 312         {
 313 #if defined(__GNUC__)
 314 # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 315 #  pragma GCC visibility push (default)
 316 # endif
 317 #endif
 318         template <class T>
 319         struct
 320         error_info_injector:
 321             public T,
 322             public exception
 323             {
 324             explicit
 325             error_info_injector( T const & x ):
 326                 T(x)
 327                 {
 328                 }
 329
 330             ~error_info_injector() throw()
 331                 {
 332                 }
 333             };
 334 #if defined(__GNUC__)
 335 # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 336 #  pragma GCC visibility pop
 337 # endif
 338 #endif
 339
 340         struct large_size { char c[256]; };
 341         large_size dispatch_boost_exception( exception const * );
 342
 343         struct small_size { };
 344         small_size dispatch_boost_exception( void const * );
 345
 346         template <class,int>
 347         struct enable_error_info_helper;
 348
 349         template <class T>
 350         struct
 351         enable_error_info_helper<T,sizeof(large_size)>
 352             {
 353             typedef T type;
 354             };
 355
 356         template <class T>
 357         struct
 358         enable_error_info_helper<T,sizeof(small_size)>
 359             {
 360             typedef error_info_injector<T> type;
 361             };
 362
 363         template <class T>
 364         struct
 365         enable_error_info_return_type
 366             {
 367             typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
 368             };
 369         }
 370
 371     template <class T>
 372     inline
 373     typename
 374     exception_detail::enable_error_info_return_type<T>::type
 375     enable_error_info( T const & x )
 376         {
 377         typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
 378         return rt(x);
 379         }
 380
 381     ////////////////////////////////////////////////////////////////////////
 382
 383     namespace
 384     exception_detail
 385         {
 386 #if defined(__GNUC__)
 387 # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 388 #  pragma GCC visibility push (default)
 389 # endif
 390 #endif
 391         class
 392         clone_base
 393             {
 394             public:
 395
 396             virtual clone_base const * clone() const = 0;
 397             virtual void rethrow() const = 0;
 398
 399             virtual
 400             ~clone_base() throw()
 401                 {
 402                 }
 403             };
 404 #if defined(__GNUC__)
 405 # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 406 #  pragma GCC visibility pop
 407 # endif
 408 #endif
 409
 410         inline
 411         void
 412         copy_boost_exception( exception * a, exception const * b )
 413             {
 414             refcount_ptr<error_info_container> data;
 415             if( error_info_container * d=b->data_.get() )
 416                 data = d->clone();
 417             a->throw_file_ = b->throw_file_;
 418             a->throw_line_ = b->throw_line_;
 419             a->throw_function_ = b->throw_function_;
 420             a->data_ = data;
 421             }
 422
 423         inline
 424         void
 425         copy_boost_exception( void *, void const * )
 426             {
 427             }
 428
 429         template <class T>
 430         class
 431         clone_impl:
 432             public T,
 433             public virtual clone_base
 434             {
 435             struct clone_tag { };
 436             clone_impl( clone_impl const & x, clone_tag ):
 437                 T(x)
 438                 {
 439                 copy_boost_exception(this,&x);
 440                 }
 441
 442             public:
 443
 444             explicit
 445             clone_impl( T const & x ):
 446                 T(x)
 447                 {
 448                 copy_boost_exception(this,&x);
 449                 }
 450
 451             ~clone_impl() throw()
 452                 {
 453                 }
 454
 455             private:
 456
 457             clone_base const *
 458             clone() const
 459                 {
 460                 return new clone_impl(*this,clone_tag());
 461                 }
 462
 463             void
 464             rethrow() const
 465                 {
 466                 throw*this;
 467                 }
 468             };
 469         }
 470
 471     template <class T>
 472     inline
 473     exception_detail::clone_impl<T>
 474     enable_current_exception( T const & x )
 475         {
 476         return exception_detail::clone_impl<T>(x);
 477         }
 478     }
 479
 480 #if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 481 #pragma warning(pop)
 482 #endif
 483 #endif