source: ntrip/branches/BNC_2.12/newmat/myexcept.h@ 8142

Last change on this file since 8142 was 2013, checked in by mervart, 13 years ago

* empty log message *

File size: 11.7 KB
Line 
1/// \ingroup rbd_common
2///@{
3
4/// \file myexcept.h
5/// Exception handler.
6/// The low level classes for
7/// - my exception class hierarchy
8/// - the functions needed for my simulated exceptions
9/// - the Tracer mechanism
10/// - routines for checking whether new and delete calls are balanced
11///
12
13
14// A set of classes to simulate exceptions in C++
15//
16// Partially copied from Carlos Vidal s article in the C users journal
17// September 1992, pp 19-28
18//
19// Operations defined
20// Try { }
21// Throw ( exception object )
22// ReThrow
23// Catch ( exception class ) { }
24// CatchAll { }
25// CatchAndThrow
26//
27// All catch lists must end with a CatchAll or CatchAndThrow statement
28// but not both.
29//
30// When exceptions are finally implemented replace Try, Throw(E), Rethrow,
31// Catch, CatchAll, CatchAndThrow by try, throw E, throw, catch,
32// catch(...), and {}.
33//
34// All exception classes must be derived from BaseException, have no
35// non-static variables and must include the statement
36//
37// static unsigned long Select;
38//
39// Any constructor in one of these exception classes must include
40//
41// Select = BaseException::Select;
42//
43// For each exceptions class, EX_1, some .cpp file must include
44//
45// unsigned long EX_1::Select;
46//
47
48
49#ifndef EXCEPTION_LIB
50#define EXCEPTION_LIB
51
52#include "include.h"
53
54#ifdef use_namespace
55namespace RBD_COMMON {
56#endif
57
58
59void Terminate();
60
61
62//********** classes for setting up exceptions and reporting ************//
63
64class BaseException;
65
66class Tracer // linked list showing how
67{ // we got here
68 const char* entry;
69 Tracer* previous;
70public:
71 Tracer(const char*);
72 ~Tracer();
73 void ReName(const char*);
74 static void PrintTrace(); // for printing trace
75 static void AddTrace(); // insert trace in exception record
76 static Tracer* last; // points to Tracer list
77 friend class BaseException;
78};
79
80
81class BaseException // The base exception class
82{
83protected:
84 static char* what_error; // error message
85 static int SoFar; // no. characters already entered
86 static int LastOne; // last location in error buffer
87public:
88 static void AddMessage(const char* a_what);
89 // messages about exception
90 static void AddInt(int value); // integer to error message
91 static unsigned long Select; // for identifying exception
92 BaseException(const char* a_what = 0);
93 static const char* what() { return what_error; }
94 // for getting error message
95};
96
97#ifdef TypeDefException
98typedef BaseException Exception; // for compatibility with my older libraries
99#endif
100
101inline Tracer::Tracer(const char* e)
102 : entry(e), previous(last) { last = this; }
103
104inline Tracer::~Tracer() { last = previous; }
105
106inline void Tracer::ReName(const char* e) { entry=e; }
107
108#ifdef SimulateExceptions // SimulateExceptions
109
110#include <setjmp.h>
111
112
113//************* the definitions of Try, Throw and Catch *****************//
114
115
116class JumpItem;
117class Janitor;
118
119class JumpBase // pointer to a linked list of jmp_buf s
120{
121public:
122 static JumpItem *jl;
123 static jmp_buf env;
124};
125
126class JumpItem // an item in a linked list of jmp_buf s
127{
128public:
129 JumpItem *ji;
130 jmp_buf env;
131 Tracer* trace; // to keep check on Tracer items
132 Janitor* janitor; // list of items for cleanup
133 JumpItem() : ji(JumpBase::jl), trace(0), janitor(0)
134 { JumpBase::jl = this; }
135 ~JumpItem() { JumpBase::jl = ji; }
136};
137
138void Throw();
139
140inline void Throw(const BaseException&) { Throw(); }
141
142#define Try \
143 if (!setjmp( JumpBase::jl->env )) { \
144 JumpBase::jl->trace = Tracer::last; \
145 JumpItem JI387256156;
146
147#define ReThrow Throw()
148
149#define Catch(EXCEPTION) \
150 } else if (BaseException::Select == EXCEPTION::Select) {
151
152#define CatchAll } else
153
154#define CatchAndThrow } else Throw();
155
156
157//****************** cleanup heap following Throw ***********************//
158
159class Janitor
160{
161protected:
162 static bool do_not_link; // set when new is called
163 bool OnStack; // false if created by new
164public:
165 Janitor* NextJanitor;
166 virtual void CleanUp() {}
167 Janitor();
168 virtual ~Janitor();
169};
170
171
172// The tiresome old trick for initializing the Janitor class
173// this is needed for classes derived from Janitor which have objects
174// declared globally
175
176class JanitorInitializer
177{
178public:
179 JanitorInitializer();
180private:
181 static int ref_count;
182};
183
184static JanitorInitializer JanInit;
185
186#endif // end of SimulateExceptions
187
188#ifdef UseExceptions
189
190#define Try try
191#define Throw(E) throw E
192#define ReThrow throw
193#define Catch catch
194#define CatchAll catch(...)
195#define CatchAndThrow {}
196
197#endif // end of UseExceptions
198
199
200#ifdef DisableExceptions // Disable exceptions
201
202#define Try {
203#define ReThrow Throw()
204#define Catch(EXCEPTION) } if (false) {
205#define CatchAll } if (false)
206#define CatchAndThrow }
207
208inline void Throw() { Terminate(); }
209inline void Throw(const BaseException&) { Terminate(); }
210
211
212#endif // end of DisableExceptions
213
214#ifndef SimulateExceptions // ! SimulateExceptions
215
216class Janitor // a dummy version
217{
218public:
219 virtual void CleanUp() {}
220 Janitor() {}
221 virtual ~Janitor() {}
222};
223
224#endif // end of ! SimulateExceptions
225
226
227//******************** FREE_CHECK and NEW_DELETE ***********************//
228
229#ifdef DO_FREE_CHECK // DO_FREE_CHECK
230// Routines for tracing whether new and delete calls are balanced
231
232class FreeCheck;
233
234class FreeCheckLink
235{
236protected:
237 FreeCheckLink* next;
238 void* ClassStore;
239 FreeCheckLink();
240 virtual void Report()=0; // print details of link
241 friend class FreeCheck;
242};
243
244class FCLClass : public FreeCheckLink // for registering objects
245{
246 char* ClassName;
247 FCLClass(void* t, char* name);
248 void Report();
249 friend class FreeCheck;
250};
251
252class FCLRealArray : public FreeCheckLink // for registering real arrays
253{
254 char* Operation;
255 int size;
256 FCLRealArray(void* t, char* o, int s);
257 void Report();
258 friend class FreeCheck;
259};
260
261class FCLIntArray : public FreeCheckLink // for registering int arrays
262{
263 char* Operation;
264 int size;
265 FCLIntArray(void* t, char* o, int s);
266 void Report();
267 friend class FreeCheck;
268};
269
270
271class FreeCheck
272{
273 static FreeCheckLink* next;
274 static int BadDelete;
275public:
276 static void Register(void*, char*);
277 static void DeRegister(void*, char*);
278 static void RegisterR(void*, char*, int);
279 static void DeRegisterR(void*, char*, int);
280 static void RegisterI(void*, char*, int);
281 static void DeRegisterI(void*, char*, int);
282 static void Status();
283 friend class FreeCheckLink;
284 friend class FCLClass;
285 friend class FCLRealArray;
286 friend class FCLIntArray;
287};
288
289#define FREE_CHECK(Class) \
290public: \
291 void* operator new(size_t size) \
292 { \
293 void* t = ::operator new(size); FreeCheck::Register(t,#Class); \
294 return t; \
295 } \
296 void operator delete(void* t) \
297 { FreeCheck::DeRegister(t,#Class); ::operator delete(t); }
298
299
300#ifdef SimulateExceptions // SimulateExceptions
301
302#define NEW_DELETE(Class) \
303public: \
304 void* operator new(size_t size) \
305 { \
306 do_not_link=true; \
307 void* t = ::operator new(size); FreeCheck::Register(t,#Class); \
308 return t; \
309 } \
310 void operator delete(void* t) \
311 { FreeCheck::DeRegister(t,#Class); ::operator delete(t); }
312
313
314#endif // end of SimulateExceptions
315
316
317#define MONITOR_REAL_NEW(Operation, Size, Pointer) \
318 FreeCheck::RegisterR(Pointer, Operation, Size);
319#define MONITOR_INT_NEW(Operation, Size, Pointer) \
320 FreeCheck::RegisterI(Pointer, Operation, Size);
321#define MONITOR_REAL_DELETE(Operation, Size, Pointer) \
322 FreeCheck::DeRegisterR(Pointer, Operation, Size);
323#define MONITOR_INT_DELETE(Operation, Size, Pointer) \
324 FreeCheck::DeRegisterI(Pointer, Operation, Size);
325
326#else // DO_FREE_CHECK not defined
327
328#define FREE_CHECK(Class) public:
329#define MONITOR_REAL_NEW(Operation, Size, Pointer) {}
330#define MONITOR_INT_NEW(Operation, Size, Pointer) {}
331#define MONITOR_REAL_DELETE(Operation, Size, Pointer) {}
332#define MONITOR_INT_DELETE(Operation, Size, Pointer) {}
333
334
335#ifdef SimulateExceptions // SimulateExceptions
336
337
338#define NEW_DELETE(Class) \
339public: \
340 void* operator new(size_t size) \
341 { do_not_link=true; void* t = ::operator new(size); return t; } \
342 void operator delete(void* t) { ::operator delete(t); }
343
344#endif // end of SimulateExceptions
345
346#endif // end of ! DO_FREE_CHECK
347
348#ifndef SimulateExceptions // ! SimulateExceptions
349
350#define NEW_DELETE(Class) FREE_CHECK(Class)
351
352#endif // end of ! SimulateExceptions
353
354
355//********************* derived exceptions ******************************//
356
357class Logic_error : public BaseException
358{
359public:
360 static unsigned long Select;
361 Logic_error(const char* a_what = 0);
362};
363
364class Runtime_error : public BaseException
365{
366public:
367 static unsigned long Select;
368 Runtime_error(const char* a_what = 0);
369};
370
371class Domain_error : public Logic_error
372{
373public:
374 static unsigned long Select;
375 Domain_error(const char* a_what = 0);
376};
377
378class Invalid_argument : public Logic_error
379{
380public:
381 static unsigned long Select;
382 Invalid_argument(const char* a_what = 0);
383};
384
385class Length_error : public Logic_error
386{
387public:
388 static unsigned long Select;
389 Length_error(const char* a_what = 0);
390};
391
392class Out_of_range : public Logic_error
393{
394public:
395 static unsigned long Select;
396 Out_of_range(const char* a_what = 0);
397};
398
399//class Bad_cast : public Logic_error
400//{
401//public:
402// static unsigned long Select;
403// Bad_cast(const char* a_what = 0);
404//};
405
406//class Bad_typeid : public Logic_error
407//{
408//public:
409// static unsigned long Select;
410// Bad_typeid(const char* a_what = 0);
411//};
412
413class Range_error : public Runtime_error
414{
415public:
416 static unsigned long Select;
417 Range_error(const char* a_what = 0);
418};
419
420class Overflow_error : public Runtime_error
421{
422public:
423 static unsigned long Select;
424 Overflow_error(const char* a_what = 0);
425};
426
427class Bad_alloc : public BaseException
428{
429public:
430 static unsigned long Select;
431 Bad_alloc(const char* a_what = 0);
432};
433
434#ifdef use_namespace
435}
436#endif
437
438
439#endif // end of EXCEPTION_LIB
440
441
442// body file: myexcept.cpp
443
444
445///@}
446
Note: See TracBrowser for help on using the repository browser.