1 // Debug-mode error formatting implementation -*- C++ -*- 2 3 // Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 2, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // You should have received a copy of the GNU General Public License along 17 // with this library; see the file COPYING. If not, write to the Free 18 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 19 // USA. 20 21 // As a special exception, you may use this file as part of a free software 22 // library without restriction. Specifically, if other files instantiate 23 // templates or use macros or inline functions from this file, or you compile 24 // this file and link it with other files to produce an executable, this 25 // file does not by itself cause the resulting executable to be covered by 26 // the GNU General Public License. This exception does not however 27 // invalidate any other reasons why the executable file might be covered by 28 // the GNU General Public License. 29 30 /** @file debug/formatter.h 31 * This file is a GNU debug extension to the Standard C++ Library. 32 */ 33 34 #ifndef _GLIBCXX_DEBUG_FORMATTER_H 35 #define _GLIBCXX_DEBUG_FORMATTER_H 1 36 37 #include <typeinfo> 38 #include <debug/debug.h> 39 40 namespace __gnu_debug 41 { 42 using std::type_info; 43 44 /** Determine if the two types are the same. */ 45 template<typename _Type1, typename _Type2> 46 struct __is_same 47 { 48 static const bool value = false; 49 }; 50 51 template<typename _Type> 52 struct __is_same<_Type, _Type> 53 { 54 static const bool value = true; 55 }; 56 57 template<bool> struct __truth { }; 58 59 class _Safe_sequence_base; 60 61 template<typename _Iterator, typename _Sequence> 62 class _Safe_iterator; 63 64 template<typename _Sequence> 65 class _Safe_sequence; 66 67 enum _Debug_msg_id 68 { 69 // General checks 70 __msg_valid_range, 71 __msg_insert_singular, 72 __msg_insert_different, 73 __msg_erase_bad, 74 __msg_erase_different, 75 __msg_subscript_oob, 76 __msg_empty, 77 __msg_unpartitioned, 78 __msg_unpartitioned_pred, 79 __msg_unsorted, 80 __msg_unsorted_pred, 81 __msg_not_heap, 82 __msg_not_heap_pred, 83 // std::bitset checks 84 __msg_bad_bitset_write, 85 __msg_bad_bitset_read, 86 __msg_bad_bitset_flip, 87 // std::list checks 88 __msg_self_splice, 89 __msg_splice_alloc, 90 __msg_splice_bad, 91 __msg_splice_other, 92 __msg_splice_overlap, 93 // iterator checks 94 __msg_init_singular, 95 __msg_init_copy_singular, 96 __msg_init_const_singular, 97 __msg_copy_singular, 98 __msg_bad_deref, 99 __msg_bad_inc, 100 __msg_bad_dec, 101 __msg_iter_subscript_oob, 102 __msg_advance_oob, 103 __msg_retreat_oob, 104 __msg_iter_compare_bad, 105 __msg_compare_different, 106 __msg_iter_order_bad, 107 __msg_order_different, 108 __msg_distance_bad, 109 __msg_distance_different, 110 // istream_iterator 111 __msg_deref_istream, 112 __msg_inc_istream, 113 // ostream_iterator 114 __msg_output_ostream, 115 // istreambuf_iterator 116 __msg_deref_istreambuf, 117 __msg_inc_istreambuf 118 }; 119 120 class _Error_formatter 121 { 122 /// Whether an iterator is constant, mutable, or unknown 123 enum _Constness 124 { 125 __unknown_constness, 126 __const_iterator, 127 __mutable_iterator, 128 __last_constness 129 }; 130 131 // The state of the iterator (fine-grained), if we know it. 132 enum _Iterator_state 133 { 134 __unknown_state, 135 __singular, // singular, may still be attached to a sequence 136 __begin, // dereferenceable, and at the beginning 137 __middle, // dereferenceable, not at the beginning 138 __end, // past-the-end, may be at beginning if sequence empty 139 __last_state 140 }; 141 142 // Tags denoting the type of parameter for construction 143 struct _Is_iterator { }; 144 struct _Is_sequence { }; 145 146 // A parameter that may be referenced by an error message 147 struct _Parameter 148 { 149 enum 150 { 151 __unused_param, 152 __iterator, 153 __sequence, 154 __integer, 155 __string 156 } _M_kind; 157 158 union 159 { 160 // When _M_kind == __iterator 161 struct 162 { 163 const char* _M_name; 164 const void* _M_address; 165 const type_info* _M_type; 166 _Constness _M_constness; 167 _Iterator_state _M_state; 168 const void* _M_sequence; 169 const type_info* _M_seq_type; 170 } _M_iterator; 171 172 // When _M_kind == __sequence 173 struct 174 { 175 const char* _M_name; 176 const void* _M_address; 177 const type_info* _M_type; 178 } _M_sequence; 179 180 // When _M_kind == __integer 181 struct 182 { 183 const char* _M_name; 184 long _M_value; 185 } _M_integer; 186 187 // When _M_kind == __string 188 struct 189 { 190 const char* _M_name; 191 const char* _M_value; 192 } _M_string; 193 } _M_variant; 194 195 _Parameter() : _M_kind(__unused_param), _M_variant() { } 196 197 _Parameter(long __value, const char* __name) 198 : _M_kind(__integer), _M_variant() 199 { 200 _M_variant._M_integer._M_name = __name; 201 _M_variant._M_integer._M_value = __value; 202 } 203 204 _Parameter(const char* __value, const char* __name) 205 : _M_kind(__string), _M_variant() 206 { 207 _M_variant._M_string._M_name = __name; 208 _M_variant._M_string._M_value = __value; 209 } 210 211 template<typename _Iterator, typename _Sequence> 212 _Parameter(const _Safe_iterator<_Iterator, _Sequence>& __it, 213 const char* __name, _Is_iterator) 214 : _M_kind(__iterator), _M_variant() 215 { 216 _M_variant._M_iterator._M_name = __name; 217 _M_variant._M_iterator._M_address = &__it; 218 _M_variant._M_iterator._M_type = &typeid(__it); 219 _M_variant._M_iterator._M_constness = 220 __is_same<_Safe_iterator<_Iterator, _Sequence>, 221 typename _Sequence::iterator>:: 222 value? __mutable_iterator : __const_iterator; 223 _M_variant._M_iterator._M_sequence = __it._M_get_sequence(); 224 _M_variant._M_iterator._M_seq_type = &typeid(_Sequence); 225 226 if (__it._M_singular()) 227 _M_variant._M_iterator._M_state = __singular; 228 else 229 { 230 bool __is_begin = __it._M_is_begin(); 231 bool __is_end = __it._M_is_end(); 232 if (__is_end) 233 _M_variant._M_iterator._M_state = __end; 234 else if (__is_begin) 235 _M_variant._M_iterator._M_state = __begin; 236 else 237 _M_variant._M_iterator._M_state = __middle; 238 } 239 } 240 241 template<typename _Type> 242 _Parameter(const _Type*& __it, const char* __name, _Is_iterator) 243 : _M_kind(__iterator), _M_variant() 244 { 245 _M_variant._M_iterator._M_name = __name; 246 _M_variant._M_iterator._M_address = &__it; 247 _M_variant._M_iterator._M_type = &typeid(__it); 248 _M_variant._M_iterator._M_constness = __mutable_iterator; 249 _M_variant._M_iterator._M_state = __it? __unknown_state : __singular; 250 _M_variant._M_iterator._M_sequence = 0; 251 _M_variant._M_iterator._M_seq_type = 0; 252 } 253 254 template<typename _Type> 255 _Parameter(_Type*& __it, const char* __name, _Is_iterator) 256 : _M_kind(__iterator), _M_variant() 257 { 258 _M_variant._M_iterator._M_name = __name; 259 _M_variant._M_iterator._M_address = &__it; 260 _M_variant._M_iterator._M_type = &typeid(__it); 261 _M_variant._M_iterator._M_constness = __const_iterator; 262 _M_variant._M_iterator._M_state = __it? __unknown_state : __singular; 263 _M_variant._M_iterator._M_sequence = 0; 264 _M_variant._M_iterator._M_seq_type = 0; 265 } 266 267 template<typename _Iterator> 268 _Parameter(const _Iterator& __it, const char* __name, _Is_iterator) 269 : _M_kind(__iterator), _M_variant() 270 { 271 _M_variant._M_iterator._M_name = __name; 272 _M_variant._M_iterator._M_address = &__it; 273 _M_variant._M_iterator._M_type = &typeid(__it); 274 _M_variant._M_iterator._M_constness = __unknown_constness; 275 _M_variant._M_iterator._M_state = 276 __gnu_debug::__check_singular(__it)? __singular : __unknown_state; 277 _M_variant._M_iterator._M_sequence = 0; 278 _M_variant._M_iterator._M_seq_type = 0; 279 } 280 281 template<typename _Sequence> 282 _Parameter(const _Safe_sequence<_Sequence>& __seq, 283 const char* __name, _Is_sequence) 284 : _M_kind(__sequence), _M_variant() 285 { 286 _M_variant._M_sequence._M_name = __name; 287 _M_variant._M_sequence._M_address = 288 static_cast<const _Sequence*>(&__seq); 289 _M_variant._M_sequence._M_type = &typeid(_Sequence); 290 } 291 292 template<typename _Sequence> 293 _Parameter(const _Sequence& __seq, const char* __name, _Is_sequence) 294 : _M_kind(__sequence), _M_variant() 295 { 296 _M_variant._M_sequence._M_name = __name; 297 _M_variant._M_sequence._M_address = &__seq; 298 _M_variant._M_sequence._M_type = &typeid(_Sequence); 299 } 300 301 void 302 _M_print_field(const _Error_formatter* __formatter, 303 const char* __name) const; 304 305 void 306 _M_print_description(const _Error_formatter* __formatter) const; 307 }; 308 309 friend struct _Parameter; 310 311 public: 312 template<typename _Iterator> 313 const _Error_formatter& 314 _M_iterator(const _Iterator& __it, const char* __name = 0) const 315 { 316 if (_M_num_parameters < size_t(__max_parameters)) 317 _M_parameters[_M_num_parameters++] = _Parameter(__it, __name, 318 _Is_iterator()); 319 return *this; 320 } 321 322 const _Error_formatter& 323 _M_integer(long __value, const char* __name = 0) const 324 { 325 if (_M_num_parameters < size_t(__max_parameters)) 326 _M_parameters[_M_num_parameters++] = _Parameter(__value, __name); 327 return *this; 328 } 329 330 const _Error_formatter& 331 _M_string(const char* __value, const char* __name = 0) const 332 { 333 if (_M_num_parameters < size_t(__max_parameters)) 334 _M_parameters[_M_num_parameters++] = _Parameter(__value, __name); 335 return *this; 336 } 337 338 template<typename _Sequence> 339 const _Error_formatter& 340 _M_sequence(const _Sequence& __seq, const char* __name = 0) const 341 { 342 if (_M_num_parameters < size_t(__max_parameters)) 343 _M_parameters[_M_num_parameters++] = _Parameter(__seq, __name, 344 _Is_sequence()); 345 return *this; 346 } 347 348 const _Error_formatter& 349 _M_message(const char* __text) const 350 { _M_text = __text; return *this; } 351 352 const _Error_formatter& 353 _M_message(_Debug_msg_id __id) const; 354 355 void 356 _M_error() const; 357 358 private: 359 _Error_formatter(const char* __file, size_t __line) 360 : _M_file(__file), _M_line(__line), _M_num_parameters(0), _M_text(0), 361 _M_max_length(78), _M_column(1), _M_first_line(true), _M_wordwrap(false) 362 { } 363 364 template<typename _Tp> 365 void 366 _M_format_word(char*, int, const char*, _Tp) const; 367 368 void 369 _M_print_word(const char* __word) const; 370 371 void 372 _M_print_string(const char* __string) const; 373 374 enum { __max_parameters = 9 }; 375 376 const char* _M_file; 377 size_t _M_line; 378 mutable _Parameter _M_parameters[__max_parameters]; 379 mutable size_t _M_num_parameters; 380 mutable const char* _M_text; 381 mutable size_t _M_max_length; 382 enum { _M_indent = 4 } ; 383 mutable size_t _M_column; 384 mutable bool _M_first_line; 385 mutable bool _M_wordwrap; 386 387 public: 388 static _Error_formatter 389 _M_at(const char* __file, size_t __line) 390 { return _Error_formatter(__file, __line); } 391 }; 392 } // namespace __gnu_debug 393 394 #endif 395