OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [tools/] [src/] [infra/] [cyg_ass.h] - Blame information for rev 174

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 26 unneback
#ifndef CYGONCE_INFRA_CYG_ASS_H
2
#define CYGONCE_INFRA_CYG_ASS_H
3
 
4
//==========================================================================
5
//
6
//      cyg_ass.h
7
//
8
//      Macros and prototypes for the assert system
9
//
10
//==========================================================================
11
//####COPYRIGHTBEGIN####
12
//                                                                          
13
// ----------------------------------------------------------------------------
14
// Copyright (C) 1997, 1998, 1999, 2000 Red Hat, Inc.
15
//
16
// This file is part of the eCos host tools.
17
//
18
// This program is free software; you can redistribute it and/or modify it 
19
// under the terms of the GNU General Public License as published by the Free 
20
// Software Foundation; either version 2 of the License, or (at your option) 
21
// any later version.
22
// 
23
// This program is distributed in the hope that it will be useful, but WITHOUT 
24
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
25
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
26
// more details.
27
// 
28
// You should have received a copy of the GNU General Public License along with
29
// this program; if not, write to the Free Software Foundation, Inc., 
30
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
31
//
32
// ----------------------------------------------------------------------------
33
//                                                                          
34
//####COPYRIGHTEND####
35
//==========================================================================
36
//#####DESCRIPTIONBEGIN####
37
//
38
// Author(s):   nickg from an original by hmt
39
// Contributors:        nickg
40
// Date:        1997-09-08
41
// Purpose:     Use asserts to avoid writing duff code.
42
// Description: Runtime tests that compile to nothing in
43
//              release versions of the code, to allow
44
//              as-you-go testing of alternate builds.
45
// Usage:       #include <cyg/infra/cyg_ass.h>
46
//              ...
47
//              CYG_ASSERT( pcount > 0, "Number of probes should be > 0!" );
48
//
49
//      which can result, for example, in a message of the form:
50
//      ASSERT FAILED: probemgr.cxx:1340, scan_probes() :
51
//                     number of probes should be > 0!
52
//      if the boolean "pcount > 0" is false.
53
//
54
//####DESCRIPTIONEND####
55
//
56
//==========================================================================
57
 
58
#include <pkgconf/infra.h>
59
 
60
#include <cyg/infra/cyg_type.h>         // for CYGBLD_ATTRIB_NORET
61
 
62
// -------------------------------------------------------------------------
63
// If we do not have a function name macro, define it ourselves
64
 
65
#ifndef CYGDBG_INFRA_DEBUG_FUNCTION_PSEUDOMACRO
66
                                        // __PRETTY_FUNCTION__ does not work
67
# ifndef __PRETTY_FUNCTION__            // And it is not already defined
68
#  define __PRETTY_FUNCTION__ NULL
69
# endif
70
#endif
71
 
72
// -------------------------------------------------------------------------
73
// this is executed to deal with failure - breakpoint it first!
74
 
75
externC void
76
cyg_assert_fail( const char* /* psz_func */, const char* /* psz_file */,
77
                 cyg_uint32 /* linenum */, const char* /* psz_msg */ )
78
    CYGBLD_ATTRIB_NORET;
79
 
80
// -------------------------------------------------------------------------
81
 
82
#ifdef CYGDBG_USE_ASSERTS
83
 
84
// -------------------------------------------------------------------------
85
// We define macros and appropriate prototypes for the assert/fail
86
// system.  These are:
87
//      CYG_FAIL        - unconditional panic
88
//      CYG_ASSERT      - panic if boolean expression is false
89
//      CYG_ASSERTC     - compact version of CYG_ASSERT
90
 
91
# ifdef CYGDBG_INFRA_DEBUG_ASSERT_MESSAGE
92
#  define CYG_ASSERT_DOCALL( _msg_ ) \
93
        cyg_assert_fail( __PRETTY_FUNCTION__, __FILE__, __LINE__, _msg_ );
94
# else
95
#   define CYG_ASSERT_DOCALL( _msg_ )    \
96
        CYG_MACRO_START                 \
97
        const char* _tmp1_ = _msg_;     \
98
        _tmp1_ = _tmp1_;                \
99
        cyg_assert_fail( __PRETTY_FUNCTION__, __FILE__, __LINE__, NULL ); \
100
        CYG_MACRO_END
101
# endif
102
 
103
// unconditional failure; use like panic(), coredump() &c.
104
# define CYG_FAIL( _msg_ )              \
105
        CYG_MACRO_START                 \
106
        CYG_ASSERT_DOCALL( _msg_ );      \
107
        CYG_MACRO_END
108
 
109
// conditioned assert; if the condition is false, fail.
110
# define CYG_ASSERT( _bool_, _msg_ )    \
111
        CYG_MACRO_START                 \
112
        if ( ! ( _bool_ ) )             \
113
            CYG_ASSERT_DOCALL( _msg_ );  \
114
        CYG_MACRO_END
115
 
116
# define CYG_ASSERTC( _bool_ )          \
117
       CYG_MACRO_START                  \
118
       if ( ! ( _bool_ ) )              \
119
           CYG_ASSERT_DOCALL( #_bool_ );\
120
       CYG_MACRO_END
121
 
122
#else // ! CYGDBG_USE_ASSERTS
123
 
124
// -------------------------------------------------------------------------
125
// No asserts: we define empty statements for assert & fail.
126
 
127
# define CYG_FAIL( _msg_ )           CYG_EMPTY_STATEMENT
128
# define CYG_ASSERT( _bool_, _msg_ ) CYG_EMPTY_STATEMENT
129
# define CYG_ASSERTC( _bool_ )       CYG_EMPTY_STATEMENT
130
 
131
#endif // ! CYGDBG_USE_ASSERTS
132
 
133
// -------------------------------------------------------------------------
134
// Pointer integrity checks.
135
// These check not only for NULL pointer, but can also check for pointers
136
// that are outside to defined memory areas of the platform or executable.
137
// We differentiate between data and function pointers, so that we can cope
138
// with different formats, and so we can check them against different memory
139
// regions.
140
 
141
externC cyg_bool cyg_check_data_ptr(void *ptr);
142
externC cyg_bool cyg_check_func_ptr(void (*ptr)(void));
143
 
144
#ifdef CYGDBG_USE_ASSERTS
145
 
146
# define CYG_CHECK_DATA_PTR( _ptr_, _msg_ )             \
147
        CYG_MACRO_START                                 \
148
        if( !cyg_check_data_ptr((void *)(_ptr_)))       \
149
           CYG_ASSERT_DOCALL( _msg_ );                   \
150
        CYG_MACRO_END
151
 
152
# define CYG_CHECK_FUNC_PTR( _ptr_, _msg_ )             \
153
        CYG_MACRO_START                                 \
154
        if( !cyg_check_func_ptr((void (*)(void))(_ptr_))) \
155
           CYG_ASSERT_DOCALL( _msg_ );                   \
156
        CYG_MACRO_END
157
 
158
# define CYG_CHECK_DATA_PTRC( _ptr_ )                   \
159
         CYG_MACRO_START                                \
160
         if ( !cyg_check_data_ptr((void *)(_ptr_)))     \
161
             CYG_ASSERT_DOCALL("data pointer (" #_ptr_ ") is valid");\
162
         CYG_MACRO_END
163
 
164
# define CYG_CHECK_FUNC_PTRC( _ptr_ )                       \
165
         CYG_MACRO_START                                    \
166
         if ( !cyg_check_func_ptr((void (*)(void))(_ptr_))) \
167
             CYG_ASSERT_DOCALL("function pointer (" #_ptr_ ") is valid"); \
168
         CYG_MACRO_END
169
 
170
#else // CYGDBG_USE_ASSERTS
171
 
172
# define CYG_CHECK_DATA_PTR( _ptr_, _msg_ ) CYG_EMPTY_STATEMENT
173
# define CYG_CHECK_FUNC_PTR( _ptr_, _msg_ ) CYG_EMPTY_STATEMENT
174
# define CYG_CHECK_DATA_PTRC( _ptr_ )       CYG_EMPTY_STATEMENT
175
# define CYG_CHECK_FUNC_PTRC( _ptr_ )       CYG_EMPTY_STATEMENT
176
 
177
#endif // CYGDBG_USE_ASSERTS
178
 
179
// -------------------------------------------------------------------------
180
// Unconditional definitions:
181
 
182
// Check an object for validity by calling its own checker.
183
// Usage:
184
//   ClassThing *p = &classobject;
185
//   CYG_ASSERTCLASS( p, "Object at p is broken!" );
186
 
187
// this enum gives some options as to how keenly to test; avoids cluttering
188
// the member function declaration if the implementor wants to do more
189
// zealous tests themselves.
190
 
191
enum cyg_assert_class_zeal {
192
  cyg_system_test       = -1,
193
  cyg_none              = 0,
194
  cyg_trivial,
195
  cyg_quick,
196
  cyg_thorough,
197
  cyg_extreme
198
};
199
 
200
// -------------------------------------------------------------------------
201
// Define macros for checking classes:
202
//
203
//      CYG_ASSERT_CLASS        - do proforma check on a class pointer
204
//      CYG_ASSERT_CLASSO       - do proforma check on a class object
205
//      CYG_ASSERT_ZERO_OR_CLASS- a class pointer is NULL or valid
206
//      CYG_ASSERT_THIS         - "this" is valid
207
//      + 3 compact variants and two aliases for backwards compatibility.
208
//
209
// All of these end up going via CYG_ASSERT(), which will be an empty
210
// statement if CYGDBG_USE_ASSERTS is disabled. There is no need to
211
// test CYGDBG_USE_ASSERTS again here.
212
//
213
// The idiom required is that a class have a member function called
214
// "bool check_this( cyg_assert_class_zeal ) const" that returns true
215
// iff the object is OK.  This need not be conditionally compiled against
216
// CYGDBG_USE_ASSERTS but it can be if only this macro is used to
217
// invoke it.  Alternatively it can be invoked by hand with other
218
// choices from the above enum.
219
 
220
// Assert the checker function of an object by pointer, or in hand.
221
 
222
#ifdef __cplusplus
223
 
224
# ifndef CYG_ASSERT_CLASS_ZEAL
225
#  define CYG_ASSERT_CLASS_ZEAL (cyg_quick) // can be redefined locally
226
# endif
227
 
228
# define CYG_ASSERT_CLASS( _pobj_, _msg_ ) \
229
    CYG_ASSERT( ((0 != (_pobj_)) &&        \
230
                 (_pobj_)->check_this( CYG_ASSERT_CLASS_ZEAL )), _msg_ )
231
 
232
# define CYG_ASSERTCLASS( _pobj_,_msg_) \
233
    CYG_ASSERT_CLASS( (_pobj_), _msg_ )
234
 
235
# define CYG_ASSERT_CLASSO( _obj_, _msg_ ) \
236
    CYG_ASSERT( (_obj_).check_this( CYG_ASSERT_CLASS_ZEAL ), _msg_ )
237
 
238
# define CYG_ASSERTCLASSO( _obj_, _msg_ ) \
239
    CYG_ASSERT_CLASSO( (_obj_), _msg_ )
240
 
241
# define CYG_ASSERT_ZERO_OR_CLASS( _pobj_, _msg_ ) \
242
    CYG_ASSERT( ((0 == (_pobj_)) ||                \
243
                 (_pobj_)->check_this( CYG_ASSERT_CLASS_ZEAL )), _msg_ )
244
 
245
# define CYG_ASSERT_THIS( _msg_ ) \
246
    CYG_ASSERT( this->check_this( CYG_ASSERT_CLASS_ZEAL ), _msg_ )
247
 
248
# define CYG_ASSERT_CLASSC( _pobj_ ) \
249
    CYG_ASSERT_CLASS( (_pobj_), "class pointer (" #_pobj_ ") is valid" )
250
 
251
# define CYG_ASSERT_CLASSOC( _obj_ ) \
252
    CYG_ASSERT_CLASSO( (_obj_), "object (" #_obj_ ") is valid" )
253
 
254
# define CYG_ASSERT_ZERO_OR_CLASSC( _pobj_ ) \
255
    CYG_ASSERT_ZERO_OR_CLASS((_pobj_),       \
256
        "class pointer (" #_pobj_ ") is zero or valid")
257
 
258
# define CYG_ASSERT_THISC( ) \
259
    CYG_ASSERT_THIS( "\"this\" pointer is valid" )
260
 
261
#define CYGDBG_DEFINE_CHECK_THIS \
262
    bool check_this( cyg_assert_class_zeal zeal ) const;
263
 
264
#endif // __cplusplus
265
 
266
// -------------------------------------------------------------------------
267
// Some alternative names for basic assertions that we can disable
268
// individually.
269
//
270
//      CYG_PRECONDITION        - argument checking etc
271
//      CYG_POSTCONDITION       - results etc
272
//      CYG_LOOP_INVARIANT      - for putting in loops
273
//
274
// C++ programmers have class-related variants of all of these.
275
 
276
#ifdef CYGDBG_INFRA_DEBUG_PRECONDITIONS
277
# define CYG_PRECONDITION( _bool_ , _msg_ ) CYG_ASSERT( _bool_, _msg_ )
278
# define CYG_PRECONDITIONC( _bool_ ) \
279
    CYG_ASSERT( _bool_, "precondition " #_bool_)
280
#else
281
# define CYG_PRECONDITION( _bool_ , _msg_ ) CYG_EMPTY_STATEMENT
282
# define CYG_PRECONDITIONC( _bool_ )        CYG_EMPTY_STATEMENT
283
#endif
284
 
285
#ifdef CYGDBG_INFRA_DEBUG_POSTCONDITIONS
286
# define CYG_POSTCONDITION( _bool_ , _msg_ ) CYG_ASSERT( _bool_, _msg_ )
287
# define CYG_POSTCONDITIONC( _bool_ ) \
288
    CYG_ASSERT( _bool_, "postcondition " #_bool_)
289
#else
290
# define CYG_POSTCONDITION( _bool_ , _msg_ ) CYG_EMPTY_STATEMENT
291
# define CYG_POSTCONDITIONC( _bool_ )        CYG_EMPTY_STATEMENT
292
#endif
293
 
294
#ifdef CYGDBG_INFRA_DEBUG_LOOP_INVARIANTS
295
# define CYG_LOOP_INVARIANT( _bool_ , _msg_ ) CYG_ASSERT( _bool_, _msg_ )
296
# define CYG_LOOP_INVARIANTC( _bool_ ) \
297
    CYG_ASSERT( _bool_, "loop invariant " #_bool_ )
298
#else
299
# define CYG_LOOP_INVARIANT( _bool_ , _msg_ ) CYG_EMPTY_STATEMENT
300
# define CYG_LOOP_INVARIANTC( _bool_ )        CYG_EMPTY_STATEMENT
301
#endif
302
 
303
#ifdef __cplusplus
304
 
305
// All variants of _CLASS
306
# define CYG_PRECONDITION_CLASS( _pobj_, _msg_ )  \
307
    CYG_PRECONDITION( ((0 != (_pobj_)) &&         \
308
                       (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
309
 
310
# define CYG_PRECONDITION_CLASSC( _pobj_ )        \
311
    CYG_PRECONDITION_CLASS( (_pobj_),             \
312
       "precondition, class pointer (" #_pobj_ ") is valid" )
313
 
314
# define CYG_POSTCONDITION_CLASS( _pobj_, _msg_ ) \
315
    CYG_POSTCONDITION( ((0 != (_pobj_)) &&        \
316
                        (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
317
 
318
# define CYG_POSTCONDITION_CLASSC( _pobj_ )       \
319
    CYG_POSTCONDITION_CLASS( (_pobj_),            \
320
       "postcondition, class pointer (" #_pobj_ ") is valid" )
321
 
322
# define CYG_LOOP_INVARIANT_CLASS( _pobj_, _msg_) \
323
    CYG_LOOP_INVARIANT( ((0 != (_pobj_)) &&       \
324
                         (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
325
 
326
# define CYG_LOOP_INVARIANT_CLASSC( _pobj_ )      \
327
    CYG_LOOP_INVARIANT_CLASS( (_pobj_),           \
328
       "loop invariant, class pointer (" #_pobj_ ") is valid" )
329
 
330
// All variants of _CLASSO
331
# define CYG_PRECONDITION_CLASSO( _obj_, _msg_ )  \
332
    CYG_PRECONDITION( (_obj_).check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
333
 
334
# define CYG_PRECONDITION_CLASSOC( _obj_ )        \
335
    CYG_PRECONDITION_CLASSO( (_obj_),             \
336
        "precondition, object (" #_obj_ ") is valid" )
337
 
338
# define CYG_POSTCONDITION_CLASSO( _obj_, _msg_ ) \
339
    CYG_POSTCONDITION( (_obj_).check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
340
 
341
# define CYG_POSTCONDITION_CLASSOC( _obj_ )       \
342
    CYG_POSTCONDITION_CLASSO( (_obj_),            \
343
       "postcondition, object (" #_obj_ ") is valid" )
344
 
345
# define CYG_LOOP_INVARIANT_CLASSO( _obj_, _msg_) \
346
    CYG_LOOP_INVARIANT( (_obj_).check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
347
 
348
# define CYG_LOOP_INVARIANT_CLASSOC( _obj_ )      \
349
    CYG_LOOP_INVARIANT_CLASSO( (_obj_),           \
350
       "loop invariant, object (" #_obj_ ") is valid" )
351
 
352
// All variants of _ZERO_OR_CLASS
353
# define CYG_PRECONDITION_ZERO_OR_CLASS( _pobj_, _msg_ )  \
354
    CYG_PRECONDITION( ((0 == (_pobj_)) ||                 \
355
                       (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
356
 
357
# define CYG_PRECONDITION_ZERO_OR_CLASSC( _pobj_ )        \
358
    CYG_PRECONDITION_ZERO_OR_CLASS( (_pobj_),             \
359
       "precondition, class pointer (" #_pobj_ ") is zero or valid" )
360
 
361
# define CYG_POSTCONDITION_ZERO_OR_CLASS( _pobj_, _msg_ ) \
362
    CYG_POSTCONDITION( ((0 == (_pobj_)) ||                \
363
                        (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
364
 
365
# define CYG_POSTCONDITION_ZERO_OR_CLASSC( _pobj_ )       \
366
    CYG_POSTCONDITION_ZERO_OR_CLASS( (_pobj_),            \
367
       "postcondition, class pointer (" #_pobj_ ") is zero or valid" )
368
 
369
# define CYG_LOOP_INVARIANT_ZERO_OR_CLASS( _pobj_, _msg_) \
370
    CYG_LOOP_INVARIANT( ((0 == (_pobj_)) ||               \
371
                         (_pobj_)->check_this(CYG_ASSERT_CLASS_ZEAL)), _msg_)
372
 
373
# define CYG_LOOP_INVARIANT_ZERO_OR_CLASSC( _pobj_ )      \
374
    CYG_LOOP_INVARIANT_ZERO_OR_CLASS( (_pobj_),           \
375
       "loop invariant, class pointer (" #_pobj_ ") is zero or valid" )
376
 
377
// All variants of _THIS
378
# define CYG_PRECONDITION_THIS( _msg_ )  \
379
    CYG_PRECONDITION( this->check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
380
 
381
# define CYG_PRECONDITION_THISC()        \
382
    CYG_PRECONDITION_THIS( "precondition, \"this\"  is valid" )
383
 
384
# define CYG_POSTCONDITION_THIS( _msg_ ) \
385
    CYG_POSTCONDITION( this->check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
386
 
387
# define CYG_POSTCONDITION_THISC()       \
388
    CYG_POSTCONDITION_THIS( "postcondition, \"this\" is valid" )
389
 
390
# define CYG_LOOP_INVARIANT_THIS( _msg_) \
391
    CYG_LOOP_INVARIANT( this->check_this(CYG_ASSERT_CLASS_ZEAL), _msg_)
392
 
393
# define CYG_LOOP_INVARIANT_THISC()      \
394
    CYG_LOOP_INVARIANT_THIS( "loop invariant, \"this\" is valid" )
395
 
396
#endif // __cplusplus
397
 
398
// -------------------------------------------------------------------------
399
// Invariants. These are a bit more interesting. The ordinary invariants
400
// take an arbitrary boolean expression, and C++ does not provide any way
401
// of evaluating this expression automatically on entry and exit - any
402
// attempt to use local objects leads to trying to evaluate the expression
403
// when it is not in scope. This problem does not arise with objects.
404
//
405
// For C++ objects it is possible to do a bit better. A template can be
406
// used to create a local object whose constructor will validate the
407
// target object and whose destructor will validate the target object
408
// again. Unfortunately it is necessary to pass the type as well as
409
// the object: typeof() is a gcc extension, and RTTI's typeid facility
410
// would provide the derived class and not what we actually want.            
411
 
412
#ifdef CYGDBG_INFRA_DEBUG_INVARIANTS    
413
 
414
# define CYG_INVARIANT( _bool_, _msg_ ) \
415
        CYG_MACRO_START                 \
416
        if ( ! ( _bool_ ) )             \
417
            CYG_ASSERT_DOCALL( _msg_ ); \
418
        CYG_MACRO_END
419
 
420
# define CYG_INVARIANTC( _bool_ )       \
421
        CYG_MACRO_START                 \
422
        if ( ! ( _bool_ ) )             \
423
            CYG_ASSERT_DOCALL( "invariant (" #_bool_ ")" ); \
424
        CYG_MACRO_END
425
 
426
# ifdef __cplusplus
427
// NOTE: if the compiler does not manage to inline the appropriate
428
// template functions then the impact on code size and performance becomes
429
// rather large. But there are significant performance overheads anyway
430
// simply because of the call to check_this()...            
431
//
432
template<class X> class __CygInvariantObject {
433
 
434
    const X*  rep;
435
 
436
  private:
437
    // Prevent access to the default constructors.
438
    __CygInvariantObject() { }
439
    __CygInvariantObject( const __CygInvariantObject&  arg ) { }
440
    __CygInvariantObject & operator=( const __CygInvariantObject & arg) { return *this; }
441
 
442
  public:
443
    __CygInvariantObject( X* arg, const char* msg ) : rep(arg) {
444
        if ( !rep->check_this( CYG_ASSERT_CLASS_ZEAL ) )
445
            CYG_ASSERT_DOCALL( msg );
446
    }
447
    __CygInvariantObject( X& arg, const char* msg ) : rep(&arg) {
448
        if ( !rep->check_this( CYG_ASSERT_CLASS_ZEAL ) )
449
            CYG_ASSERT_DOCALL( msg );
450
    }
451
    __CygInvariantObject( const X* arg, const char* msg ) : rep(arg) {
452
        if ( !rep->check_this( CYG_ASSERT_CLASS_ZEAL ) )
453
            CYG_ASSERT_DOCALL( msg );
454
    }
455
    __CygInvariantObject( const X& arg, const char* msg ) : rep(&arg) {
456
        if ( !rep->check_this( CYG_ASSERT_CLASS_ZEAL ) )
457
            CYG_ASSERT_DOCALL( msg );
458
    }
459
    ~__CygInvariantObject( ) {
460
        if ( !rep->check_this( CYG_ASSERT_CLASS_ZEAL ) )
461
            CYG_ASSERT_DOCALL( "invariant, object valid on exit" );
462
        rep = 0;
463
    };
464
};
465
 
466
//
467
// These macros provide sensible concatenation facilities at
468
// the C preprocessor level, getting around complications in the
469
// macro expansion rules related to __LINE__ and __FILE__.
470
 
471
# define __CYG_INVARIANT_CLASSNAME_AUX( a, b) a ## b
472
# define __CYG_INVARIANT_CLASSNAME( a, b ) \
473
              __CYG_INVARIANT_CLASSNAME_AUX( a, b )
474
 
475
 
476
// These macro definitions do not use CYG_MACRO_START because
477
// I do not want the scope of the local objects to get confused.
478
//
479
// The first line of the macro expansion specifies the type of
480
// the local object being created. The second line invents a
481
// name for this object. The third line provides command-line
482
// arguments.    
483
 
484
# define CYG_INVARIANT_CLASS( _type_, _pobj_, _msg_ )          \
485
     __CygInvariantObject<_type_>                              \
486
     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
487
              ( _pobj_, _msg_ )
488
 
489
# define CYG_INVARIANT_CLASSC( _type_, _pobj_ )                \
490
     __CygInvariantObject<_type_>                              \
491
     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
492
              ( _pobj_, "invariant, class pointer (" #_pobj_ ") is valid" )
493
 
494
# define CYG_INVARIANT_CLASSO( _type_, _obj_, _msg_ )          \
495
     __CygInvariantObject<_type_>                              \
496
     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
497
              ( _obj_, _msg_ )
498
 
499
# define CYG_INVARIANT_CLASSOC( _type_, _obj_ )                \
500
     __CygInvariantObject<_type_>                              \
501
     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
502
              ( _obj_, "invariant, object (" #_obj_ ") is valid" )
503
 
504
# define CYG_INVARIANT_THIS( _type_, _msg_ )                   \
505
     __CygInvariantObject<_type_>                              \
506
     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
507
              ( this, _msg_ )
508
 
509
# define CYG_INVARIANT_THISC( _type_ )                         \
510
     __CygInvariantObject<_type_>                              \
511
     __CYG_INVARIANT_CLASSNAME( __invariant_class_, __LINE__ ) \
512
              ( this, "invariant, \"this\" is valid" )
513
 
514
# endif // __cplusplus
515
 
516
#else  // !CYGDBG_INFRA_DEBUG_INVARIANTS
517
 
518
# define CYG_INVARIANT( _bool_, _msg_ ) CYG_EMPTY_STATEMENT
519
# define CYG_INVARIANTC( _bool_ )       CYG_EMPTY_STATEMENT
520
 
521
# ifdef __cplusplus
522
 
523
#  define CYG_INVARIANT_CLASS( _type_, _pobj_, _msg_ )
524
#  define CYG_INVARIANT_CLASSC( _type_, _pobj_ )
525
#  define CYG_INVARIANT_CLASSO( _type_, _obj_, _msg_ )
526
#  define CYG_INVARIANT_CLASSOC( _type_, _obj_ )
527
#  define CYG_INVARIANT_THIS( _type_, _msg_ )
528
#  define CYG_INVARIANT_THISC( _type_ )
529
 
530
# endif
531
 
532
#endif // CYGDBG_INFRA_DEBUG_INVARIANTS
533
 
534
// -------------------------------------------------------------------------
535
// Compile time failure; like #error but in a macro so we can use it in
536
// other definitions.
537
//
538
// Usage:
539
// #define new CYG_COMPILETIMEFAIL( "Do NOT use new!")
540
 
541
#define CYG_COMPILETIMEFAIL( _msg_ ) !!!-- _msg_ --!!!
542
 
543
 
544
// -------------------------------------------------------------------------
545
// The host-side implementation of the infrastructure provides a number
546
// of additional functions that allow applications to provide their own
547
// implementation of cyg_assert_fail(). This is not strictly necessary
548
// since the presence of cyg_assert_fail() in the application would
549
// override the one in the library anyway, but it is useful to make
550
// certain functionality more readily available.
551
//
552
// These declarations are only available if the symbol
553
// CYG_DECLARE_HOST_ASSERTION_SUPPORT is defined.
554
#ifdef CYG_DECLARE_HOST_ASSERTION_SUPPORT
555
 
556
// The default assertion handler writes its output to a file and
557
// if possible a suitable message to stdout. It is possible to
558
// install an alternative handler. If this alternative returns false
559
// then the default handler will be invoked instead, otherwise the
560
// application will exit.
561
externC void cyg_assert_install_failure_handler(
562
                bool (*)(const char* /* psz_func */,
563
                         const char* /* psz_file */,
564
                         cyg_uint32  /* linenum */,
565
                         const char* /* psz_msg */) );
566
 
567
// Register a callback that should get invoked as part of handling an
568
// assertion failure and that will typically produce some additional
569
// output. For example the trace code will install a callback to output
570
// trace information.
571
//
572
// The first argument is a string identifying the callback. The second
573
// argument is a function pointer for the callback itself, whose
574
// argument is another function that can be invoked for output.
575
externC void cyg_assert_install_failure_callback(
576
                const char* /* name */,
577
                void (*)( void (*)(const char*) ));
578
 
579
// This function can be called by assert failure handlers to invoke
580
// the installed callbacks. The three arguments are function pointers
581
// that get invoked prior to callback invocation, by the callback itself,
582
// and after each callback. In the first case the argument will be the
583
// callback name.
584
externC void cyg_assert_failure_invoke_callbacks(
585
                void (*)(const char* /* name */),
586
                void (*)(const char* /* callback data */ ),
587
                void (*)(void) );
588
 
589
// This function is intended to be called from inside gdb instead of
590
// cyg_assert_fail(),, without the need to specify a filename or
591
// anything else.
592
externC void cyg_assert_quickfail(void);
593
 
594
#endif // CYG_DECLARE_HOST_ASSERTION_SUPPORT
595
 
596
// -------------------------------------------------------------------------
597
 
598
#endif // CYGONCE_INFRA_CYG_ASS_H multiple inclusion protection
599
// EOF cyg_ass.h

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.