1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
// -*- c++ -*-
/* $Id$ */
/* exceptionhandler.cc
*
* Copyright 2002 The gtkmm Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <glib.h>
#include <exception>
#include <list>
#include <glibmmconfig.h>
#include <glibmm/error.h>
#include <glibmm/exceptionhandler.h>
#include <glibmm/thread.h>
GLIBMM_USING_STD(exception)
GLIBMM_USING_STD(list)
namespace
{
typedef sigc::signal<void> HandlerList;
// Each thread has its own list of exception handlers
// to avoid thread synchronization problems.
static Glib::StaticPrivate<HandlerList> thread_specific_handler_list = GLIBMM_STATIC_PRIVATE_INIT;
static void glibmm_exception_warning(const GError* error)
{
g_assert(error != 0);
g_critical("\n"
"unhandled exception (type Glib::Error) in signal handler:\n"
"domain: %s\n"
"code : %d\n"
"what : %s\n",
g_quark_to_string(error->domain), error->code,
(error->message) ? error->message : "(null)");
}
static void glibmm_unexpected_exception()
{
try
{
throw; // re-throw current exception
}
catch(const Glib::Error& error)
{
// Access the GError directly, to avoid possible exceptions from C++ code.
glibmm_exception_warning(error.gobj());
// For most failures that cause a Glib::Error exception, aborting the
// program seems too harsh. Instead, give control back to the main loop.
return;
}
catch(const std::exception& except)
{
g_error("\n"
"unhandled exception (type std::exception) in signal handler:\n"
"what: %s\n", except.what());
}
catch(...)
{
g_error("\nunhandled exception (type unknown) in signal handler\n");
}
}
} // anonymous namespace
namespace Glib
{
sigc::connection add_exception_handler(const sigc::slot<void>& slot)
{
HandlerList* handler_list = thread_specific_handler_list.get();
if(!handler_list)
{
handler_list = new HandlerList();
thread_specific_handler_list.set(handler_list);
}
handler_list->slots().push_front(slot);
return handler_list->slots().begin();
}
// internal
void exception_handlers_invoke() throw()
{
// This function will be called from our GLib signal handler proxies
// if an exception has been caught. It's not possible to throw C++
// exceptions through C signal handlers. To handle this situation, the
// programmer can install slots to global Reusable Exception Handlers.
//
// A handler has to re-throw the current exception in a try block, and then
// catch the exceptions it knows about. Any unknown exceptions should just
// fall through, i.e. the handler must not do catch(...).
//
// We now invoke each of the installed slots until the exception has been
// handled. If there are no more handlers in the list and the exception
// is still unhandled, call glibmm_unexpected_exception().
if(HandlerList *const handler_list = thread_specific_handler_list.get())
{
HandlerList::iterator pslot = handler_list->slots().begin();
while(pslot != handler_list->slots().end())
{
// Calling an empty slot would mean ignoring the exception,
// thus we have to check for dead slots explicitly.
if(pslot->empty())
{
pslot = handler_list->slots().erase(pslot);
continue;
}
// Call the Reusable Exception Handler, which should re-throw
// the exception that's currently on the stack.
try
{
(*pslot)();
}
catch(...) // unhandled, try next slot
{
++pslot;
continue;
}
// The exception has either been handled or ignored.
// Give control back to the GLib main loop.
return;
}
}
// Critical: The exception is still unhandled.
glibmm_unexpected_exception();
}
} // namespace Glib
|
