epoc32/include/tools/stlport/stl/debug/_debug.c
branchSymbian2
changeset 3 e1b950c65cb4
parent 2 2fe1408b6811
child 4 837f303aceeb
     1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/epoc32/include/tools/stlport/stl/debug/_debug.c	Wed Mar 31 12:27:01 2010 +0100
     1.3 @@ -0,0 +1,496 @@
     1.4 +/*
     1.5 + * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.
     1.6 + *
     1.7 + * Copyright (c) 1997
     1.8 + * Moscow Center for SPARC Technology
     1.9 + *
    1.10 + * Copyright (c) 1999 
    1.11 + * Boris Fomitchev
    1.12 + *
    1.13 + * This material is provided "as is", with absolutely no warranty expressed
    1.14 + * or implied. Any use is at your own risk.
    1.15 + *
    1.16 + * Permission to use or copy this software for any purpose is hereby granted 
    1.17 + * without fee, provided the above notices are retained on all copies.
    1.18 + * Permission to modify the code and to distribute modified code is granted,
    1.19 + * provided the above notices are retained, and a notice that the code was
    1.20 + * modified is included with the above copyright notice.
    1.21 + *
    1.22 + */
    1.23 +
    1.24 +# ifndef _STLP_DEBUG_C
    1.25 +#  define  _STLP_DEBUG_C
    1.26 +
    1.27 +#if defined ( _STLP_DEBUG )
    1.28 +
    1.29 +# ifdef _STLP_THREADS
    1.30 +#  ifndef _STLP_NEED_MUTABLE 
    1.31 +#   define _STLP_ACQUIRE_LOCK(_Lock) _Lock._M_acquire_lock();
    1.32 +#   define _STLP_RELEASE_LOCK(_Lock) _Lock._M_release_lock();
    1.33 +#  else
    1.34 +#   define _STLP_ACQUIRE_LOCK(_Lock) ((_STLP_mutex&)_Lock)._M_acquire_lock();
    1.35 +#   define _STLP_RELEASE_LOCK(_Lock) ((_STLP_mutex&)_Lock)._M_release_lock();
    1.36 +#  endif /* _STLP_NEED_MUTABLE */
    1.37 +# else
    1.38 +#  define _STLP_ACQUIRE_LOCK(_Lock)
    1.39 +#  define _STLP_RELEASE_LOCK(_Lock)
    1.40 +# endif /* _STLP_THREADS */
    1.41 +
    1.42 +_STLP_BEGIN_NAMESPACE
    1.43 +
    1.44 +//==========================================================
    1.45 +//  global non-inline functions
    1.46 +//==========================================================
    1.47 +
    1.48 +// [ i1, i2)
    1.49 +template <class _Iterator>
    1.50 +inline bool  _STLP_CALL
    1.51 +__in_range_aux(const _Iterator& __it, const _Iterator& __first,
    1.52 +               const _Iterator& __last, const random_access_iterator_tag &) {
    1.53 +    return ( __it >= __first && 
    1.54 +             __it < __last);
    1.55 +}
    1.56 +
    1.57 +template <class _Iterator1, class _Iterator>
    1.58 +# if defined (_STLP_MSVC) && (_STLP_MSVC >= 1100)
    1.59 +inline bool _STLP_CALL  __in_range_aux(_Iterator1 __it, const _Iterator& __first,
    1.60 +# else
    1.61 +inline bool _STLP_CALL  __in_range_aux(const _Iterator1& __it, const _Iterator& __first,
    1.62 +# endif
    1.63 +                                       const _Iterator& __last, const forward_iterator_tag &) {
    1.64 +    _Iterator1 __i(__first);
    1.65 +    for (;  __i != __last && __i != __it; ++__i);
    1.66 +    return (__i!=__last);
    1.67 +}
    1.68 +
    1.69 +# if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
    1.70 +template <class _Iterator1, class _Iterator>
    1.71 +inline bool  _STLP_CALL
    1.72 +__in_range_aux(const _Iterator1& __it, const _Iterator& __first,
    1.73 +               const _Iterator& __last, const bidirectional_iterator_tag &) {
    1.74 +    _Iterator1 __i(__first);
    1.75 +    for (;  __i != __last && __i != __it; ++__i);
    1.76 +    return (__i !=__last);
    1.77 +}
    1.78 +# endif
    1.79 +
    1.80 +template <class _Iterator>
    1.81 +bool _STLP_CALL  __check_range(const _Iterator& __first, const _Iterator& __last) {
    1.82 +    _STLP_VERBOSE_RETURN(__valid_range(__first,__last), _StlMsg_INVALID_RANGE )
    1.83 +    return true;
    1.84 +}
    1.85 +
    1.86 +template <class _Iterator>
    1.87 +bool _STLP_CALL  __check_range(const _Iterator& __it, 
    1.88 +                               const _Iterator& __start, const _Iterator& __finish) {
    1.89 +    _STLP_VERBOSE_RETURN(__in_range(__it,__start, __finish), 
    1.90 +                         _StlMsg_NOT_IN_RANGE_1)
    1.91 +    return true;
    1.92 +}
    1.93 +
    1.94 +template <class _Iterator>
    1.95 +bool _STLP_CALL  __check_range(const _Iterator& __first, const _Iterator& __last, 
    1.96 +                               const _Iterator& __start, const _Iterator& __finish) {
    1.97 +    _STLP_VERBOSE_RETURN(__in_range(__first, __last, __start, __finish), 
    1.98 +                         _StlMsg_NOT_IN_RANGE_2)
    1.99 +    return true;
   1.100 +}
   1.101 +
   1.102 +//===============================================================
   1.103 +
   1.104 +template <class _Iterator>
   1.105 +void  _STLP_CALL __invalidate_range(const __owned_list* __base, 
   1.106 +                                    const _Iterator& __first,
   1.107 +                                    const _Iterator& __last)
   1.108 +{
   1.109 +    typedef _Iterator* _Safe_iterator_ptr;
   1.110 +    typedef __owned_link _L_type;
   1.111 +    _STLP_ACQUIRE_LOCK(__base->_M_lock)
   1.112 +    _L_type* __pos;
   1.113 +    _L_type* __prev;
   1.114 +
   1.115 +    for (__prev = (_L_type*)&__base->_M_node, __pos= (_L_type*)__prev->_M_next; 
   1.116 +         __pos!=0;) {	    
   1.117 +        if ((!(&__first == (_Iterator*)__pos || &__last == (_Iterator*)__pos))
   1.118 +            &&  __in_range_aux(
   1.119 +			       ((_Iterator*)__pos)->_M_iterator,
   1.120 +			       __first._M_iterator,
   1.121 +			       __last._M_iterator,
   1.122 +			       _STLP_ITERATOR_CATEGORY(__first, _Iterator))) {
   1.123 +	  __pos->_M_owner = 0;
   1.124 +	  __pos = (_L_type*) (__prev->_M_next = __pos->_M_next);
   1.125 +	}
   1.126 +	else {
   1.127 +	  __prev = __pos;
   1.128 +	  __pos=(_L_type*)__pos->_M_next;
   1.129 +	}
   1.130 +    }
   1.131 +    _STLP_RELEASE_LOCK(__base->_M_lock)    
   1.132 +}
   1.133 +
   1.134 +template <class _Iterator>
   1.135 +void  _STLP_CALL __invalidate_iterator(const __owned_list* __base, 
   1.136 +                                       const _Iterator& __it)
   1.137 +{
   1.138 +    typedef __owned_link   _L_type;
   1.139 +    _L_type*  __position, *__prev;
   1.140 +    _STLP_ACQUIRE_LOCK(__base->_M_lock)
   1.141 +    for (__prev = (_L_type*)&__base->_M_node, __position = (_L_type*)__prev->_M_next; 
   1.142 +         __position!= 0;) {
   1.143 +      // this requires safe iterators to be derived from __owned_link
   1.144 +       if ((__position != (_L_type*)&__it) && ((_Iterator*)__position)->_M_iterator ==__it._M_iterator) {
   1.145 +	    __position->_M_owner = 0;
   1.146 +	    __position = (_L_type*) (__prev->_M_next = __position->_M_next);
   1.147 +        }
   1.148 +       else {
   1.149 +	 __prev = __position;
   1.150 +	 __position=(_L_type*)__position->_M_next;
   1.151 +       }
   1.152 +    }
   1.153 +    _STLP_RELEASE_LOCK(__base->_M_lock)
   1.154 +}
   1.155 +
   1.156 +_STLP_END_NAMESPACE
   1.157 +
   1.158 +# endif /* _STLP_DEBUG */
   1.159 +
   1.160 +# if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
   1.161 +
   1.162 +// dwa 12/26/99 -- for abort
   1.163 +#  if defined (_STLP_USE_NEW_C_HEADERS)
   1.164 +#   include <cstdlib>
   1.165 +#  else
   1.166 +#   include <stdlib.h>
   1.167 +#  endif
   1.168 +
   1.169 +# if defined (_STLP_WIN32)
   1.170 +#  include <stl/_threads.h>
   1.171 +# endif
   1.172 +
   1.173 +//==========================================================
   1.174 +// .c section
   1.175 +//  owned_list non-inline methods and global functions 
   1.176 +//==========================================================
   1.177 +
   1.178 +#if defined ( _STLP_ASSERTIONS )
   1.179 +
   1.180 +_STLP_BEGIN_NAMESPACE
   1.181 +
   1.182 +# ifndef _STLP_STRING_LITERAL
   1.183 +# define _STLP_STRING_LITERAL(__x) __x
   1.184 +# endif
   1.185 +
   1.186 +# ifdef _STLP_WINCE
   1.187 +#  define _STLP_PERCENT_S "%hs" 
   1.188 +# else
   1.189 +#  define _STLP_PERCENT_S "%s" 
   1.190 +# endif
   1.191 +
   1.192 +# define _STLP_MESSAGE_TABLE_BODY = { \
   1.193 +_STLP_STRING_LITERAL("\n" _STLP_PERCENT_S "(%d): STL error: %s\n"), \
   1.194 +_STLP_STRING_LITERAL(_STLP_PERCENT_S "(%d): STL assertion failure : " _STLP_PERCENT_S "\n" _STLP_ASSERT_MSG_TRAILER), \
   1.195 +_STLP_STRING_LITERAL("\n" _STLP_PERCENT_S "(%d): STL error : " _STLP_PERCENT_S "\n" _STLP_PERCENT_S "(%d): STL assertion failure:     " _STLP_PERCENT_S " \n" _STLP_ASSERT_MSG_TRAILER), \
   1.196 +_STLP_STRING_LITERAL("Invalid argument to operation (see operation documentation)"),                  \
   1.197 +_STLP_STRING_LITERAL("Taking an iterator out of destroyed (or otherwise corrupted) container"),       \
   1.198 +_STLP_STRING_LITERAL("Trying to extract an object out from empty container"),\
   1.199 +_STLP_STRING_LITERAL("Past-the-end iterator could not be erased"),  \
   1.200 +_STLP_STRING_LITERAL("Index out of bounds"),  \
   1.201 +_STLP_STRING_LITERAL("Container doesn't own the iterator"),  \
   1.202 +_STLP_STRING_LITERAL("Uninitialized or invalidated (by mutating operation) iterator used"),  \
   1.203 +_STLP_STRING_LITERAL("Uninitialized or invalidated (by mutating operation) lefthand iterator in expression"),  \
   1.204 +_STLP_STRING_LITERAL("Uninitialized or invalidated (by mutating operation) righthand iterator in expression"),  \
   1.205 +_STLP_STRING_LITERAL("Iterators used in expression are from different owners"),  \
   1.206 +_STLP_STRING_LITERAL("Iterator could not be dereferenced (past-the-end ?)"),  \
   1.207 +_STLP_STRING_LITERAL("Range [first,last) is invalid"),  \
   1.208 +_STLP_STRING_LITERAL("Iterator is not in range [first,last)"),  \
   1.209 +_STLP_STRING_LITERAL("Range [first,last) is not in range [start,finish)"),  \
   1.210 +_STLP_STRING_LITERAL("The advance would produce invalid iterator"),  \
   1.211 +_STLP_STRING_LITERAL("Iterator is singular (advanced beyond the bounds ?)"),  \
   1.212 +_STLP_STRING_LITERAL("Memory block deallocated twice"),  \
   1.213 +_STLP_STRING_LITERAL("Deallocating a block that was never allocated"),  \
   1.214 +_STLP_STRING_LITERAL("Deallocating a memory block allocated for another type"),  \
   1.215 +_STLP_STRING_LITERAL("Size of block passed to deallocate() doesn't match block size"),  \
   1.216 +_STLP_STRING_LITERAL("Pointer underrun - safety margin at front of memory block overwritten"),  \
   1.217 +_STLP_STRING_LITERAL("Pointer overrrun - safety margin at back of memory block overwritten"),   \
   1.218 +_STLP_STRING_LITERAL("Attempt to dereference null pointer returned by auto_ptr::get()"),   \
   1.219 +_STLP_STRING_LITERAL("Unknown problem") \
   1.220 +  }
   1.221 +
   1.222 +# if ( _STLP_STATIC_TEMPLATE_DATA > 0 )
   1.223 +#ifdef __SYMBIAN32__
   1.224 +template <class _Dummy>
   1.225 +const char* __stl_debug_engine<_Dummy>::_Message_table[_StlMsg_MAX];//  _STLP_MESSAGE_TABLE_BODY;
   1.226 +#else
   1.227 +template <class _Dummy>
   1.228 +const char* __stl_debug_engine<_Dummy>::_Message_table[_StlMsg_MAX]  _STLP_MESSAGE_TABLE_BODY;
   1.229 +#endif
   1.230 +
   1.231 +# else
   1.232 +__DECLARE_INSTANCE(const char*, __stl_debug_engine<bool>::_Message_table[_StlMsg_MAX],
   1.233 +		   _STLP_MESSAGE_TABLE_BODY);
   1.234 +
   1.235 +# endif
   1.236 +
   1.237 +# undef _STLP_STRING_LITERAL
   1.238 +# undef _STLP_PERCENT_S
   1.239 +_STLP_END_NAMESPACE
   1.240 +
   1.241 +// abort()
   1.242 +#    include <cstdlib>
   1.243 +
   1.244 +#  if !defined( _STLP_DEBUG_MESSAGE )
   1.245 +
   1.246 +#    include <cstdarg>
   1.247 +#    include <cstdio>
   1.248 +
   1.249 +_STLP_BEGIN_NAMESPACE
   1.250 +
   1.251 +template <class _Dummy>
   1.252 +void _STLP_CALL  
   1.253 +__stl_debug_engine<_Dummy>::_Message(const char * __format_str, ...)
   1.254 +{
   1.255 +	STLPORT_CSTD::va_list __args;
   1.256 +	va_start( __args, __format_str );
   1.257 +
   1.258 +# if defined (_STLP_WINCE)
   1.259 +	TCHAR __buffer[512];
   1.260 +	int _convert = strlen(__format_str) + 1;
   1.261 +	LPWSTR _lpw = (LPWSTR)alloca(_convert*sizeof(wchar_t));
   1.262 +	_lpw[0] = '\0';
   1.263 +	MultiByteToWideChar(GetACP(), 0, __format_str, -1, _lpw, _convert);
   1.264 +	wvsprintf(__buffer, _lpw, __args);
   1.265 +	//	wvsprintf(__buffer, __format_str, __args);
   1.266 +	_STLP_WINCE_TRACE(__buffer);
   1.267 +# elif defined (_STLP_WIN32) && ( defined(_STLP_MSVC) || defined (__ICL) || defined (__BORLANDC__)) && ! defined (__WINS__)
   1.268 +    char __buffer [4096];
   1.269 +    _vsnprintf(__buffer, sizeof(__buffer) / sizeof(char),
   1.270 +               __format_str, __args);
   1.271 +    OutputDebugStringA(__buffer);
   1.272 +# elif defined (__amigaos__)
   1.273 +    STLPORT_CSTD::vfprintf(stderr, __format_str, (char *)__args);
   1.274 +# else
   1.275 +    STLPORT_CSTD::vfprintf(stderr, __format_str, __args);
   1.276 +# endif /* WINCE */
   1.277 +
   1.278 +# ifdef _STLP_DEBUG_MESSAGE_POST
   1.279 +	_STLP_DEBUG_MESSAGE_POST
   1.280 +# endif
   1.281 +
   1.282 +    va_end(__args);
   1.283 +
   1.284 +}
   1.285 +
   1.286 +_STLP_END_NAMESPACE
   1.287 +
   1.288 +#  endif /* _STLP_DEBUG_MESSAGE */
   1.289 +
   1.290 +
   1.291 +_STLP_BEGIN_NAMESPACE
   1.292 +
   1.293 +
   1.294 +template <class _Dummy>
   1.295 +void _STLP_CALL  
   1.296 +__stl_debug_engine<_Dummy>::_IndexedError(int __error_ind, const char* __f, int __l)
   1.297 +{
   1.298 +  __stl_debug_message(_Message_table[_StlFormat_ERROR_RETURN], 
   1.299 +		      __f, __l, _Message_table[__error_ind]);
   1.300 +}
   1.301 +
   1.302 +template <class _Dummy>
   1.303 +void _STLP_CALL  
   1.304 +__stl_debug_engine<_Dummy>::_VerboseAssert(const char* __expr, int __error_ind, const char* __f, int __l)
   1.305 +{
   1.306 +  __stl_debug_message(_Message_table[_StlFormat_VERBOSE_ASSERTION_FAILURE],
   1.307 +		      __f, __l, _Message_table[__error_ind], __f, __l, __expr);
   1.308 +  __stl_debug_terminate();
   1.309 +}
   1.310 +
   1.311 +template <class _Dummy>
   1.312 +void _STLP_CALL 
   1.313 +__stl_debug_engine<_Dummy>::_Assert(const char* __expr, const char* __f, int __l)
   1.314 +{
   1.315 +  __stl_debug_message(_Message_table[_StlFormat_ASSERTION_FAILURE],__f, __l, __expr);
   1.316 +  __stl_debug_terminate();
   1.317 +}
   1.318 +
   1.319 +// if exceptions are present, sends unique exception
   1.320 +// if not, calls abort() to terminate
   1.321 +template <class _Dummy>
   1.322 +void _STLP_CALL 
   1.323 +__stl_debug_engine<_Dummy>::_Terminate()
   1.324 +{
   1.325 +# ifdef _STLP_USE_NAMESPACES
   1.326 +  using namespace _STLP_STD;
   1.327 +# endif
   1.328 +# if defined (_STLP_USE_EXCEPTIONS) && ! defined (_STLP_NO_DEBUG_EXCEPTIONS)
   1.329 +  throw __stl_debug_exception();
   1.330 +# else
   1.331 +  _STLP_ABORT();
   1.332 +# endif
   1.333 +}
   1.334 +
   1.335 +_STLP_END_NAMESPACE
   1.336 +
   1.337 +# endif /* _STLP_ASSERTIONS */
   1.338 +
   1.339 +#ifdef _STLP_DEBUG
   1.340 +
   1.341 +_STLP_BEGIN_NAMESPACE
   1.342 +
   1.343 +//==========================================================
   1.344 +//  owned_list non-inline methods 
   1.345 +//==========================================================
   1.346 +
   1.347 +template <class _Dummy>
   1.348 +void  _STLP_CALL
   1.349 +__stl_debug_engine<_Dummy>::_Invalidate_all(__owned_list* __l) {
   1.350 +  _STLP_ACQUIRE_LOCK(__l->_M_lock);
   1.351 +  _Stamp_all(__l, 0);
   1.352 +  __l->_M_node._M_next =0;
   1.353 +  _STLP_RELEASE_LOCK(__l->_M_lock);
   1.354 +}
   1.355 +
   1.356 +// boris : this is unasafe routine; should be used from within critical section only !
   1.357 +template <class _Dummy>
   1.358 +void  _STLP_CALL
   1.359 +__stl_debug_engine<_Dummy>::_Stamp_all(__owned_list* __l, __owned_list* __o) {
   1.360 +  // crucial
   1.361 +  if (__l->_M_node._M_owner) {
   1.362 +    for (__owned_link*  __position = (__owned_link*)__l->_M_node._M_next; 
   1.363 +	 __position != 0; __position= (__owned_link*)__position->_M_next) {
   1.364 +      _STLP_ASSERT(__position->_Owner()== __l)
   1.365 +      __position->_M_owner=__o;
   1.366 +    }
   1.367 +  }
   1.368 +}
   1.369 +
   1.370 +template <class _Dummy>
   1.371 +void  _STLP_CALL
   1.372 +__stl_debug_engine<_Dummy>::_Verify(const __owned_list* __l) {
   1.373 +  _STLP_ACQUIRE_LOCK(__l->_M_lock);
   1.374 +  if (__l) {
   1.375 +    _STLP_ASSERT(__l->_M_node._Owner() != 0)
   1.376 +    for (__owned_link* __position = (__owned_link*)__l->_M_node._M_next; 
   1.377 +         __position != 0; __position= (__owned_link*)__position->_M_next) {
   1.378 +      _STLP_ASSERT(__position->_Owner()== __l)
   1.379 +    }
   1.380 +  }
   1.381 +  _STLP_RELEASE_LOCK(__l->_M_lock);
   1.382 +}
   1.383 +
   1.384 +template <class _Dummy>
   1.385 +void _STLP_CALL  
   1.386 +__stl_debug_engine<_Dummy>::_Swap_owners(__owned_list& __x, __owned_list& __y) {
   1.387 +
   1.388 +  //  according to the standard : --no swap() function invalidates any references, 
   1.389 +  //  pointers,  or  iterators referring to the elements of the containers being swapped.
   1.390 +
   1.391 +  __owned_link* __tmp;
   1.392 +
   1.393 +  // boris : there is a deadlock potential situation here if we lock two containers sequentially.
   1.394 +  // As user is supposed to provide its own synchronization around swap() ( it is unsafe to do any container/iterator access
   1.395 +  // in parallel with swap()), we just do not use any locking at all -- that behaviour is closer to non-debug version
   1.396 +
   1.397 +  __tmp = __x._M_node._M_next;
   1.398 +
   1.399 +  _Stamp_all(&__x, &__y);
   1.400 +  _Stamp_all(&__y, &__x);
   1.401 +
   1.402 +  __x._M_node._M_next = __y._M_node._M_next;
   1.403 +  __y._M_node._M_next = __tmp;  
   1.404 +
   1.405 +}
   1.406 +
   1.407 +template <class _Dummy>
   1.408 +void _STLP_CALL 
   1.409 +__stl_debug_engine<_Dummy>::_M_detach(__owned_list* __l, __owned_link* __c_node) {
   1.410 +  if (__l  != 0) {
   1.411 +
   1.412 +    _STLP_VERBOSE_ASSERT(__l->_Owner()!=0, _StlMsg_INVALID_CONTAINER)
   1.413 +
   1.414 +    _STLP_ACQUIRE_LOCK(__l->_M_lock)
   1.415 +      // boris : re-test the condition in case someone else already deleted us
   1.416 +      if(__c_node->_M_owner != 0) {
   1.417 +        __owned_link* __prev, *__next;
   1.418 +        
   1.419 +        for (__prev = &__l->_M_node; (__next = __prev->_M_next) != __c_node; 
   1.420 +             __prev = __next) {
   1.421 +          _STLP_ASSERT(__next && __next->_Owner() == __l)
   1.422 +            }
   1.423 +        
   1.424 +        __prev->_M_next = __c_node->_M_next;
   1.425 +        __c_node->_M_owner=0;
   1.426 +      }
   1.427 +    _STLP_RELEASE_LOCK(__l->_M_lock)
   1.428 +  }
   1.429 +}
   1.430 +
   1.431 +template <class _Dummy>
   1.432 +void _STLP_CALL 
   1.433 +__stl_debug_engine<_Dummy>::_M_attach(__owned_list* __l, __owned_link* __c_node) {
   1.434 +  if (__l ==0) {
   1.435 +    (__c_node)->_M_owner = 0;    
   1.436 +  } else {
   1.437 +    _STLP_VERBOSE_ASSERT(__l->_Owner()!=0, _StlMsg_INVALID_CONTAINER)
   1.438 +    _STLP_ACQUIRE_LOCK(__l->_M_lock)
   1.439 +    __c_node->_M_owner = __l;
   1.440 +    __c_node->_M_next = __l->_M_node._M_next;
   1.441 +    __l->_M_node._M_next = __c_node;
   1.442 +    _STLP_RELEASE_LOCK(__l->_M_lock)
   1.443 +  }
   1.444 +}
   1.445 +
   1.446 +
   1.447 +template <class _Dummy>
   1.448 +void* _STLP_CALL
   1.449 +__stl_debug_engine<_Dummy>::_Get_container_ptr(const __owned_link* __l) {
   1.450 +  const __owned_list* __owner    = __l->_Owner();
   1.451 +  _STLP_VERBOSE_RETURN_0(__owner != 0, _StlMsg_INVALID_ITERATOR)
   1.452 +  void* __ret = __CONST_CAST(void*,__owner->_Owner());
   1.453 +  _STLP_VERBOSE_RETURN_0(__ret !=0, _StlMsg_INVALID_CONTAINER)
   1.454 +  return __ret;
   1.455 +}
   1.456 +
   1.457 +template <class _Dummy>
   1.458 +bool _STLP_CALL
   1.459 +__stl_debug_engine<_Dummy>::_Check_same_owner( const __owned_link& __i1, 
   1.460 +                                               const __owned_link& __i2)
   1.461 +{
   1.462 +  _STLP_VERBOSE_RETURN(__i1._Valid(), _StlMsg_INVALID_LEFTHAND_ITERATOR)
   1.463 +  _STLP_VERBOSE_RETURN(__i2._Valid(), _StlMsg_INVALID_RIGHTHAND_ITERATOR)
   1.464 +  _STLP_VERBOSE_RETURN((__i1._Owner()==__i2._Owner()), _StlMsg_DIFFERENT_OWNERS)
   1.465 +  return true;
   1.466 +}
   1.467 +
   1.468 +template <class _Dummy>
   1.469 +bool  _STLP_CALL
   1.470 +__stl_debug_engine<_Dummy>::_Check_same_owner_or_null( const __owned_link& __i1, 
   1.471 +						       const __owned_link& __i2)
   1.472 +{
   1.473 +  _STLP_VERBOSE_RETURN(__i1._Owner()==__i2._Owner(), _StlMsg_DIFFERENT_OWNERS)
   1.474 +  return true;
   1.475 +}
   1.476 +
   1.477 +template <class _Dummy>
   1.478 +bool _STLP_CALL
   1.479 +__stl_debug_engine<_Dummy>::_Check_if_owner( const __owned_list * __l, const __owned_link& __it)
   1.480 +{
   1.481 +  const __owned_list* __owner_ptr = __it._Owner();
   1.482 +  _STLP_VERBOSE_RETURN(__owner_ptr!=0, _StlMsg_INVALID_ITERATOR)
   1.483 +  _STLP_VERBOSE_RETURN(__l==__owner_ptr, _StlMsg_NOT_OWNER)
   1.484 +  return true;
   1.485 +}
   1.486 +
   1.487 +
   1.488 +_STLP_END_NAMESPACE
   1.489 +
   1.490 +#endif /* _STLP_DEBUG */
   1.491 +
   1.492 +#endif /* if defined (EXPOSE_GLOBALS_IMPLEMENTATION) */
   1.493 +
   1.494 +#endif /* header guard */
   1.495 +
   1.496 +// Local Variables:
   1.497 +// mode:C++
   1.498 +// End:
   1.499 +