ios_base.h

Go to the documentation of this file.
00001 // Iostreams base classes -*- C++ -*- 00002 00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 00004 // Free Software Foundation, Inc. 00005 // 00006 // This file is part of the GNU ISO C++ Library. This library is free 00007 // software; you can redistribute it and/or modify it under the 00008 // terms of the GNU General Public License as published by the 00009 // Free Software Foundation; either version 2, or (at your option) 00010 // any later version. 00011 00012 // This library is distributed in the hope that it will be useful, 00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00015 // GNU General Public License for more details. 00016 00017 // You should have received a copy of the GNU General Public License along 00018 // with this library; see the file COPYING. If not, write to the Free 00019 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 00020 // USA. 00021 00022 // As a special exception, you may use this file as part of a free software 00023 // library without restriction. Specifically, if other files instantiate 00024 // templates or use macros or inline functions from this file, or you compile 00025 // this file and link it with other files to produce an executable, this 00026 // file does not by itself cause the resulting executable to be covered by 00027 // the GNU General Public License. This exception does not however 00028 // invalidate any other reasons why the executable file might be covered by 00029 // the GNU General Public License. 00030 00031 // 00032 // ISO C++ 14882: 27.4 Iostreams base classes 00033 // 00034 00035 /** @file ios_base.h 00036 * This is an internal header file, included by other library headers. 00037 * You should not attempt to use it directly. 00038 */ 00039 00040 #ifndef _IOS_BASE_H 00041 #define _IOS_BASE_H 1 00042 00043 #pragma GCC system_header 00044 00045 #include <bits/atomicity.h> 00046 #include <bits/localefwd.h> 00047 #include <bits/locale_classes.h> 00048 00049 namespace std 00050 { 00051 // The following definitions of bitmask types are enums, not ints, 00052 // as permitted (but not required) in the standard, in order to provide 00053 // better type safety in iostream calls. A side effect is that 00054 // expressions involving them are no longer compile-time constants. 00055 enum _Ios_Fmtflags { _S_ios_fmtflags_end = 1L << 16 }; 00056 00057 inline _Ios_Fmtflags 00058 operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) 00059 { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); } 00060 00061 inline _Ios_Fmtflags 00062 operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) 00063 { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); } 00064 00065 inline _Ios_Fmtflags 00066 operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) 00067 { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); } 00068 00069 inline _Ios_Fmtflags 00070 operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) 00071 { return __a = __a | __b; } 00072 00073 inline _Ios_Fmtflags 00074 operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) 00075 { return __a = __a & __b; } 00076 00077 inline _Ios_Fmtflags 00078 operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) 00079 { return __a = __a ^ __b; } 00080 00081 inline _Ios_Fmtflags 00082 operator~(_Ios_Fmtflags __a) 00083 { return _Ios_Fmtflags(~static_cast<int>(__a)); } 00084 00085 00086 enum _Ios_Openmode { _S_ios_openmode_end = 1L << 16 }; 00087 00088 inline _Ios_Openmode 00089 operator&(_Ios_Openmode __a, _Ios_Openmode __b) 00090 { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); } 00091 00092 inline _Ios_Openmode 00093 operator|(_Ios_Openmode __a, _Ios_Openmode __b) 00094 { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); } 00095 00096 inline _Ios_Openmode 00097 operator^(_Ios_Openmode __a, _Ios_Openmode __b) 00098 { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); } 00099 00100 inline _Ios_Openmode 00101 operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) 00102 { return __a = __a | __b; } 00103 00104 inline _Ios_Openmode 00105 operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) 00106 { return __a = __a & __b; } 00107 00108 inline _Ios_Openmode 00109 operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) 00110 { return __a = __a ^ __b; } 00111 00112 inline _Ios_Openmode 00113 operator~(_Ios_Openmode __a) 00114 { return _Ios_Openmode(~static_cast<int>(__a)); } 00115 00116 00117 enum _Ios_Iostate { _S_ios_iostate_end = 1L << 16 }; 00118 00119 inline _Ios_Iostate 00120 operator&(_Ios_Iostate __a, _Ios_Iostate __b) 00121 { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); } 00122 00123 inline _Ios_Iostate 00124 operator|(_Ios_Iostate __a, _Ios_Iostate __b) 00125 { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); } 00126 00127 inline _Ios_Iostate 00128 operator^(_Ios_Iostate __a, _Ios_Iostate __b) 00129 { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); } 00130 00131 inline _Ios_Iostate 00132 operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) 00133 { return __a = __a | __b; } 00134 00135 inline _Ios_Iostate 00136 operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) 00137 { return __a = __a & __b; } 00138 00139 inline _Ios_Iostate 00140 operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) 00141 { return __a = __a ^ __b; } 00142 00143 inline _Ios_Iostate 00144 operator~(_Ios_Iostate __a) 00145 { return _Ios_Iostate(~static_cast<int>(__a)); } 00146 00147 enum _Ios_Seekdir { _S_ios_seekdir_end = 1L << 16 }; 00148 00149 // 27.4.2 Class ios_base 00150 /** 00151 * @brief The very top of the I/O class hierarchy. 00152 * 00153 * This class defines everything that can be defined about I/O that does 00154 * not depend on the type of characters being input or output. Most 00155 * people will only see @c ios_base when they need to specify the full 00156 * name of the various I/O flags (e.g., the openmodes). 00157 */ 00158 class ios_base 00159 { 00160 public: 00161 00162 // 27.4.2.1.1 Class ios_base::failure 00163 /// These are thrown to indicate problems. Doc me. 00164 class failure : public exception 00165 { 00166 public: 00167 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00168 // 48. Use of non-existent exception constructor 00169 explicit 00170 failure(const string& __str) throw(); 00171 00172 // This declaration is not useless: 00173 // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118 00174 virtual 00175 ~failure() throw(); 00176 00177 virtual const char* 00178 what() const throw(); 00179 00180 private: 00181 string _M_msg; 00182 }; 00183 00184 // 27.4.2.1.2 Type ios_base::fmtflags 00185 /** 00186 * @brief This is a bitmask type. 00187 * 00188 * @c "_Ios_Fmtflags" is implementation-defined, but it is valid to 00189 * perform bitwise operations on these values and expect the Right 00190 * Thing to happen. Defined objects of type fmtflags are: 00191 * - boolalpha 00192 * - dec 00193 * - fixed 00194 * - hex 00195 * - internal 00196 * - left 00197 * - oct 00198 * - right 00199 * - scientific 00200 * - showbase 00201 * - showpoint 00202 * - showpos 00203 * - skipws 00204 * - unitbuf 00205 * - uppercase 00206 * - adjustfield 00207 * - basefield 00208 * - floatfield 00209 */ 00210 typedef _Ios_Fmtflags fmtflags; 00211 00212 /// Insert/extract @c bool in alphabetic rather than numeric format. 00213 static const fmtflags boolalpha = fmtflags(__ios_flags::_S_boolalpha); 00214 00215 /// Converts integer input or generates integer output in decimal base. 00216 static const fmtflags dec = fmtflags(__ios_flags::_S_dec); 00217 00218 /// Generate floating-point output in fixed-point notation. 00219 static const fmtflags fixed = fmtflags(__ios_flags::_S_fixed); 00220 00221 /// Converts integer input or generates integer output in hexadecimal base. 00222 static const fmtflags hex = fmtflags(__ios_flags::_S_hex); 00223 00224 /// Adds fill characters at a designated internal point in certain 00225 /// generated output, or identical to @c right if no such point is 00226 /// designated. 00227 static const fmtflags internal = fmtflags(__ios_flags::_S_internal); 00228 00229 /// Adds fill characters on the right (final positions) of certain 00230 /// generated output. (I.e., the thing you print is flush left.) 00231 static const fmtflags left = fmtflags(__ios_flags::_S_left); 00232 00233 /// Converts integer input or generates integer output in octal base. 00234 static const fmtflags oct = fmtflags(__ios_flags::_S_oct); 00235 00236 /// Adds fill characters on the left (initial positions) of certain 00237 /// generated output. (I.e., the thing you print is flush right.) 00238 static const fmtflags right = fmtflags(__ios_flags::_S_right); 00239 00240 /// Generates floating-point output in scientific notation. 00241 static const fmtflags scientific = fmtflags(__ios_flags::_S_scientific); 00242 00243 /// Generates a prefix indicating the numeric base of generated integer 00244 /// output. 00245 static const fmtflags showbase = fmtflags(__ios_flags::_S_showbase); 00246 00247 /// Generates a decimal-point character unconditionally in generated 00248 /// floating-point output. 00249 static const fmtflags showpoint = fmtflags(__ios_flags::_S_showpoint); 00250 00251 /// Generates a + sign in non-negative generated numeric output. 00252 static const fmtflags showpos = fmtflags(__ios_flags::_S_showpos); 00253 00254 /// Skips leading white space before certain input operations. 00255 static const fmtflags skipws = fmtflags(__ios_flags::_S_skipws); 00256 00257 /// Flushes output after each output operation. 00258 static const fmtflags unitbuf = fmtflags(__ios_flags::_S_unitbuf); 00259 00260 /// Replaces certain lowercase letters with their uppercase equivalents 00261 /// in generated output. 00262 static const fmtflags uppercase = fmtflags(__ios_flags::_S_uppercase); 00263 00264 /// A mask of left|right|internal. Useful for the 2-arg form of @c setf. 00265 static const fmtflags adjustfield = fmtflags(__ios_flags::_S_adjustfield); 00266 00267 /// A mask of dec|oct|hex. Useful for the 2-arg form of @c setf. 00268 static const fmtflags basefield = fmtflags(__ios_flags::_S_basefield); 00269 00270 /// A mask of scientific|fixed. Useful for the 2-arg form of @c setf. 00271 static const fmtflags floatfield = fmtflags(__ios_flags::_S_floatfield); 00272 00273 // 27.4.2.1.3 Type ios_base::iostate 00274 /** 00275 * @brief This is a bitmask type. 00276 * 00277 * @c "_Ios_Iostate" is implementation-defined, but it is valid to 00278 * perform bitwise operations on these values and expect the Right 00279 * Thing to happen. Defined objects of type iostate are: 00280 * - badbit 00281 * - eofbit 00282 * - failbit 00283 * - goodbit 00284 */ 00285 typedef _Ios_Iostate iostate; 00286 00287 /// Indicates a loss of integrity in an input or output sequence (such 00288 /// as an irrecoverable read error from a file). 00289 static const iostate badbit = iostate(__ios_flags::_S_badbit); 00290 00291 /// Indicates that an input operation reached the end of an input sequence. 00292 static const iostate eofbit = iostate(__ios_flags::_S_eofbit); 00293 00294 /// Indicates that an input operation failed to read the expected 00295 /// characters, or that an output operation failed to generate the 00296 /// desired characters. 00297 static const iostate failbit = iostate(__ios_flags::_S_failbit); 00298 00299 /// Indicates all is well. 00300 static const iostate goodbit = iostate(0); 00301 00302 // 27.4.2.1.4 Type ios_base::openmode 00303 /** 00304 * @brief This is a bitmask type. 00305 * 00306 * @c "_Ios_Openmode" is implementation-defined, but it is valid to 00307 * perform bitwise operations on these values and expect the Right 00308 * Thing to happen. Defined objects of type openmode are: 00309 * - app 00310 * - ate 00311 * - binary 00312 * - in 00313 * - out 00314 * - trunc 00315 */ 00316 typedef _Ios_Openmode openmode; 00317 00318 /// Seek to end before each write. 00319 static const openmode app = openmode(__ios_flags::_S_app); 00320 00321 /// Open and seek to end immediately after opening. 00322 static const openmode ate = openmode(__ios_flags::_S_ate); 00323 00324 /// Perform input and output in binary mode (as opposed to text mode). 00325 /// This is probably not what you think it is; see 00326 /// http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#3 and 00327 /// http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#7 for more. 00328 static const openmode binary = openmode(__ios_flags::_S_bin); 00329 00330 /// Open for input. Default for @c ifstream and fstream. 00331 static const openmode in = openmode(__ios_flags::_S_in); 00332 00333 /// Open for output. Default for @c ofstream and fstream. 00334 static const openmode out = openmode(__ios_flags::_S_out); 00335 00336 /// Open for input. Default for @c ofstream. 00337 static const openmode trunc = openmode(__ios_flags::_S_trunc); 00338 00339 // 27.4.2.1.5 Type ios_base::seekdir 00340 /** 00341 * @brief This is an enumerated type. 00342 * 00343 * @c "_Ios_Seekdir" is implementation-defined. Defined values 00344 * of type seekdir are: 00345 * - beg 00346 * - cur, equivalent to @c SEEK_CUR in the C standard library. 00347 * - end, equivalent to @c SEEK_END in the C standard library. 00348 */ 00349 typedef _Ios_Seekdir seekdir; 00350 00351 /// Request a seek relative to the beginning of the stream. 00352 static const seekdir beg = seekdir(0); 00353 00354 /// Request a seek relative to the current position within the sequence. 00355 static const seekdir cur = seekdir(SEEK_CUR); 00356 00357 /// Request a seek relative to the current end of the sequence. 00358 static const seekdir end = seekdir(SEEK_END); 00359 00360 // Annex D.6 00361 typedef int io_state; 00362 typedef int open_mode; 00363 typedef int seek_dir; 00364 00365 typedef std::streampos streampos; 00366 typedef std::streamoff streamoff; 00367 00368 // Callbacks; 00369 /** 00370 * @brief The set of events that may be passed to an event callback. 00371 * 00372 * erase_event is used during ~ios() and copyfmt(). imbue_event is used 00373 * during imbue(). copyfmt_event is used during copyfmt(). 00374 */ 00375 enum event 00376 { 00377 erase_event, 00378 imbue_event, 00379 copyfmt_event 00380 }; 00381 00382 /** 00383 * @brief The type of an event callback function. 00384 * @param event One of the members of the event enum. 00385 * @param ios_base Reference to the ios_base object. 00386 * @param int The integer provided when the callback was registered. 00387 * 00388 * Event callbacks are user defined functions that get called during 00389 * several ios_base and basic_ios functions, specifically imbue(), 00390 * copyfmt(), and ~ios(). 00391 */ 00392 typedef void (*event_callback) (event, ios_base&, int); 00393 00394 /** 00395 * @brief Add the callback __fn with parameter __index. 00396 * @param __fn The function to add. 00397 * @param __index The integer to pass to the function when invoked. 00398 * 00399 * Registers a function as an event callback with an integer parameter to 00400 * be passed to the function when invoked. Multiple copies of the 00401 * function are allowed. If there are multiple callbacks, they are 00402 * invoked in the order they were registered. 00403 */ 00404 void 00405 register_callback(event_callback __fn, int __index); 00406 00407 protected: 00408 //@{ 00409 /** 00410 * @if maint 00411 * ios_base data members (doc me) 00412 * @endif 00413 */ 00414 streamsize _M_precision; 00415 streamsize _M_width; 00416 fmtflags _M_flags; 00417 iostate _M_exception; 00418 iostate _M_streambuf_state; 00419 //@} 00420 00421 // 27.4.2.6 Members for callbacks 00422 // 27.4.2.6 ios_base callbacks 00423 struct _Callback_list 00424 { 00425 // Data Members 00426 _Callback_list* _M_next; 00427 ios_base::event_callback _M_fn; 00428 int _M_index; 00429 _Atomic_word _M_refcount; // 0 means one reference. 00430 00431 _Callback_list(ios_base::event_callback __fn, int __index, 00432 _Callback_list* __cb) 00433 : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { } 00434 00435 void 00436 _M_add_reference() { __gnu_cxx::__atomic_add(&_M_refcount, 1); } 00437 00438 // 0 => OK to delete. 00439 int 00440 _M_remove_reference() 00441 { return __gnu_cxx::__exchange_and_add(&_M_refcount, -1); } 00442 }; 00443 00444 _Callback_list* _M_callbacks; 00445 00446 void 00447 _M_call_callbacks(event __ev) throw(); 00448 00449 void 00450 _M_dispose_callbacks(void); 00451 00452 // 27.4.2.5 Members for iword/pword storage 00453 struct _Words 00454 { 00455 void* _M_pword; 00456 long _M_iword; 00457 _Words() : _M_pword(0), _M_iword(0) { } 00458 }; 00459 00460 // Only for failed iword/pword calls. 00461 _Words _M_word_zero; 00462 00463 // Guaranteed storage. 00464 // The first 5 iword and pword slots are reserved for internal use. 00465 static const int _S_local_word_size = 8; 00466 _Words _M_local_word[_S_local_word_size]; 00467 00468 // Allocated storage. 00469 int _M_word_size; 00470 _Words* _M_word; 00471 00472 _Words& 00473 _M_grow_words(int __index, bool __iword); 00474 00475 // Members for locale and locale caching. 00476 locale _M_ios_locale; 00477 00478 void 00479 _M_init(); 00480 00481 public: 00482 00483 // 27.4.2.1.6 Class ios_base::Init 00484 // Used to initialize standard streams. In theory, g++ could use 00485 // -finit-priority to order this stuff correctly without going 00486 // through these machinations. 00487 class Init 00488 { 00489 friend class ios_base; 00490 public: 00491 Init(); 00492 ~Init(); 00493 00494 private: 00495 static _Atomic_word _S_refcount; 00496 static bool _S_synced_with_stdio; 00497 }; 00498 00499 // [27.4.2.2] fmtflags state functions 00500 /** 00501 * @brief Access to format flags. 00502 * @return The format control flags for both input and output. 00503 */ 00504 inline fmtflags 00505 flags() const { return _M_flags; } 00506 00507 /** 00508 * @brief Setting new format flags all at once. 00509 * @param fmtfl The new flags to set. 00510 * @return The previous format control flags. 00511 * 00512 * This function overwrites all the format flags with @a fmtfl. 00513 */ 00514 inline fmtflags 00515 flags(fmtflags __fmtfl) 00516 { 00517 fmtflags __old = _M_flags; 00518 _M_flags = __fmtfl; 00519 return __old; 00520 } 00521 00522 /** 00523 * @brief Setting new format flags. 00524 * @param fmtfl Additional flags to set. 00525 * @return The previous format control flags. 00526 * 00527 * This function sets additional flags in format control. Flags that 00528 * were previously set remain set. 00529 */ 00530 inline fmtflags 00531 setf(fmtflags __fmtfl) 00532 { 00533 fmtflags __old = _M_flags; 00534 _M_flags |= __fmtfl; 00535 return __old; 00536 } 00537 00538 /** 00539 * @brief Setting new format flags. 00540 * @param fmtfl Additional flags to set. 00541 * @param mask The flags mask for @a fmtfl. 00542 * @return The previous format control flags. 00543 * 00544 * This function clears @a mask in the format flags, then sets 00545 * @a fmtfl @c & @a mask. An example mask is @c ios_base::adjustfield. 00546 */ 00547 inline fmtflags 00548 setf(fmtflags __fmtfl, fmtflags __mask) 00549 { 00550 fmtflags __old = _M_flags; 00551 _M_flags &= ~__mask; 00552 _M_flags |= (__fmtfl & __mask); 00553 return __old; 00554 } 00555 00556 /** 00557 * @brief Clearing format flags. 00558 * @param mask The flags to unset. 00559 * 00560 * This function clears @a mask in the format flags. 00561 */ 00562 inline void 00563 unsetf(fmtflags __mask) { _M_flags &= ~__mask; } 00564 00565 /** 00566 * @brief Flags access. 00567 * @return The precision to generate on certain output operations. 00568 * 00569 * @if maint 00570 * Be careful if you try to give a definition of "precision" here; see 00571 * DR 189. 00572 * @endif 00573 */ 00574 inline streamsize 00575 precision() const { return _M_precision; } 00576 00577 /** 00578 * @brief Changing flags. 00579 * @param prec The new precision value. 00580 * @return The previous value of precision(). 00581 */ 00582 inline streamsize 00583 precision(streamsize __prec) 00584 { 00585 streamsize __old = _M_precision; 00586 _M_precision = __prec; 00587 return __old; 00588 } 00589 00590 /** 00591 * @brief Flags access. 00592 * @return The minimum field width to generate on output operations. 00593 * 00594 * "Minimum field width" refers to the number of characters. 00595 */ 00596 inline streamsize 00597 width() const { return _M_width; } 00598 00599 /** 00600 * @brief Changing flags. 00601 * @param wide The new width value. 00602 * @return The previous value of width(). 00603 */ 00604 inline streamsize 00605 width(streamsize __wide) 00606 { 00607 streamsize __old = _M_width; 00608 _M_width = __wide; 00609 return __old; 00610 } 00611 00612 // [27.4.2.4] ios_base static members 00613 /** 00614 * @brief Interaction with the standard C I/O objects. 00615 * @param sync Whether to synchronize or not. 00616 * @return True if the standard streams were previously synchronized. 00617 * 00618 * The synchronization referred to is @e only that between the standard 00619 * C facilities (e.g., stdout) and the standard C++ objects (e.g., 00620 * cout). User-declared streams are unaffected. See 00621 * http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#8 for more. 00622 */ 00623 static bool 00624 sync_with_stdio(bool __sync = true); 00625 00626 // [27.4.2.3] ios_base locale functions 00627 /** 00628 * @brief Setting a new locale. 00629 * @param loc The new locale. 00630 * @return The previous locale. 00631 * 00632 * Sets the new locale for this stream, and then invokes each callback 00633 * with imbue_event. 00634 */ 00635 locale 00636 imbue(const locale& __loc); 00637 00638 /** 00639 * @brief Locale access 00640 * @return A copy of the current locale. 00641 * 00642 * If @c imbue(loc) has previously been called, then this function 00643 * returns @c loc. Otherwise, it returns a copy of @c std::locale(), 00644 * the global C++ locale. 00645 */ 00646 inline locale 00647 getloc() const { return _M_ios_locale; } 00648 00649 /** 00650 * @brief Locale access 00651 * @return A reference to the current locale. 00652 * 00653 * Like getloc above, but returns a reference instead of 00654 * generating a copy. 00655 */ 00656 inline const locale& 00657 _M_getloc() const { return _M_ios_locale; } 00658 00659 // [27.4.2.5] ios_base storage functions 00660 /** 00661 * @brief Access to unique indices. 00662 * @return An integer different from all previous calls. 00663 * 00664 * This function returns a unique integer every time it is called. It 00665 * can be used for any purpose, but is primarily intended to be a unique 00666 * index for the iword and pword functions. The expectation is that an 00667 * application calls xalloc in order to obtain an index in the iword and 00668 * pword arrays that can be used without fear of conflict. 00669 * 00670 * The implementation maintains a static variable that is incremented and 00671 * returned on each invocation. xalloc is guaranteed to return an index 00672 * that is safe to use in the iword and pword arrays. 00673 */ 00674 static int 00675 xalloc() throw(); 00676 00677 /** 00678 * @brief Access to integer array. 00679 * @param __ix Index into the array. 00680 * @return A reference to an integer associated with the index. 00681 * 00682 * The iword function provides access to an array of integers that can be 00683 * used for any purpose. The array grows as required to hold the 00684 * supplied index. All integers in the array are initialized to 0. 00685 * 00686 * The implementation reserves several indices. You should use xalloc to 00687 * obtain an index that is safe to use. Also note that since the array 00688 * can grow dynamically, it is not safe to hold onto the reference. 00689 */ 00690 inline long& 00691 iword(int __ix) 00692 { 00693 _Words& __word = (__ix < _M_word_size) 00694 ? _M_word[__ix] : _M_grow_words(__ix, true); 00695 return __word._M_iword; 00696 } 00697 00698 /** 00699 * @brief Access to void pointer array. 00700 * @param __ix Index into the array. 00701 * @return A reference to a void* associated with the index. 00702 * 00703 * The pword function provides access to an array of pointers that can be 00704 * used for any purpose. The array grows as required to hold the 00705 * supplied index. All pointers in the array are initialized to 0. 00706 * 00707 * The implementation reserves several indices. You should use xalloc to 00708 * obtain an index that is safe to use. Also note that since the array 00709 * can grow dynamically, it is not safe to hold onto the reference. 00710 */ 00711 inline void*& 00712 pword(int __ix) 00713 { 00714 _Words& __word = (__ix < _M_word_size) 00715 ? _M_word[__ix] : _M_grow_words(__ix, false); 00716 return __word._M_pword; 00717 } 00718 00719 // Destructor 00720 /** 00721 * Invokes each callback with erase_event. Destroys local storage. 00722 * 00723 * Note that the ios_base object for the standard streams never gets 00724 * destroyed. As a result, any callbacks registered with the standard 00725 * streams will not get invoked with erase_event (unless copyfmt is 00726 * used). 00727 */ 00728 virtual ~ios_base(); 00729 00730 protected: 00731 ios_base(); 00732 00733 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00734 // 50. Copy constructor and assignment operator of ios_base 00735 private: 00736 ios_base(const ios_base&); 00737 00738 ios_base& 00739 operator=(const ios_base&); 00740 }; 00741 00742 // [27.4.5.1] fmtflags manipulators 00743 /// Calls base.setf(ios_base::boolalpha). 00744 inline ios_base& 00745 boolalpha(ios_base& __base) 00746 { 00747 __base.setf(ios_base::boolalpha); 00748 return __base; 00749 } 00750 00751 /// Calls base.unsetf(ios_base::boolalpha). 00752 inline ios_base& 00753 noboolalpha(ios_base& __base) 00754 { 00755 __base.unsetf(ios_base::boolalpha); 00756 return __base; 00757 } 00758 00759 /// Calls base.setf(ios_base::showbase). 00760 inline ios_base& 00761 showbase(ios_base& __base) 00762 { 00763 __base.setf(ios_base::showbase); 00764 return __base; 00765 } 00766 00767 /// Calls base.unsetf(ios_base::showbase). 00768 inline ios_base& 00769 noshowbase(ios_base& __base) 00770 { 00771 __base.unsetf(ios_base::showbase); 00772 return __base; 00773 } 00774 00775 /// Calls base.setf(ios_base::showpoint). 00776 inline ios_base& 00777 showpoint(ios_base& __base) 00778 { 00779 __base.setf(ios_base::showpoint); 00780 return __base; 00781 } 00782 00783 /// Calls base.unsetf(ios_base::showpoint). 00784 inline ios_base& 00785 noshowpoint(ios_base& __base) 00786 { 00787 __base.unsetf(ios_base::showpoint); 00788 return __base; 00789 } 00790 00791 /// Calls base.setf(ios_base::showpos). 00792 inline ios_base& 00793 showpos(ios_base& __base) 00794 { 00795 __base.setf(ios_base::showpos); 00796 return __base; 00797 } 00798 00799 /// Calls base.unsetf(ios_base::showpos). 00800 inline ios_base& 00801 noshowpos(ios_base& __base) 00802 { 00803 __base.unsetf(ios_base::showpos); 00804 return __base; 00805 } 00806 00807 /// Calls base.setf(ios_base::skipws). 00808 inline ios_base& 00809 skipws(ios_base& __base) 00810 { 00811 __base.setf(ios_base::skipws); 00812 return __base; 00813 } 00814 00815 /// Calls base.unsetf(ios_base::skipws). 00816 inline ios_base& 00817 noskipws(ios_base& __base) 00818 { 00819 __base.unsetf(ios_base::skipws); 00820 return __base; 00821 } 00822 00823 /// Calls base.setf(ios_base::uppercase). 00824 inline ios_base& 00825 uppercase(ios_base& __base) 00826 { 00827 __base.setf(ios_base::uppercase); 00828 return __base; 00829 } 00830 00831 /// Calls base.unsetf(ios_base::uppercase). 00832 inline ios_base& 00833 nouppercase(ios_base& __base) 00834 { 00835 __base.unsetf(ios_base::uppercase); 00836 return __base; 00837 } 00838 00839 /// Calls base.setf(ios_base::unitbuf). 00840 inline ios_base& 00841 unitbuf(ios_base& __base) 00842 { 00843 __base.setf(ios_base::unitbuf); 00844 return __base; 00845 } 00846 00847 /// Calls base.unsetf(ios_base::unitbuf). 00848 inline ios_base& 00849 nounitbuf(ios_base& __base) 00850 { 00851 __base.unsetf(ios_base::unitbuf); 00852 return __base; 00853 } 00854 00855 // [27.4.5.2] adjustfield anipulators 00856 /// Calls base.setf(ios_base::internal, ios_base::adjustfield). 00857 inline ios_base& 00858 internal(ios_base& __base) 00859 { 00860 __base.setf(ios_base::internal, ios_base::adjustfield); 00861 return __base; 00862 } 00863 00864 /// Calls base.setf(ios_base::left, ios_base::adjustfield). 00865 inline ios_base& 00866 left(ios_base& __base) 00867 { 00868 __base.setf(ios_base::left, ios_base::adjustfield); 00869 return __base; 00870 } 00871 00872 /// Calls base.setf(ios_base::right, ios_base::adjustfield). 00873 inline ios_base& 00874 right(ios_base& __base) 00875 { 00876 __base.setf(ios_base::right, ios_base::adjustfield); 00877 return __base; 00878 } 00879 00880 // [27.4.5.3] basefield anipulators 00881 /// Calls base.setf(ios_base::dec, ios_base::basefield). 00882 inline ios_base& 00883 dec(ios_base& __base) 00884 { 00885 __base.setf(ios_base::dec, ios_base::basefield); 00886 return __base; 00887 } 00888 00889 /// Calls base.setf(ios_base::hex, ios_base::basefield). 00890 inline ios_base& 00891 hex(ios_base& __base) 00892 { 00893 __base.setf(ios_base::hex, ios_base::basefield); 00894 return __base; 00895 } 00896 00897 /// Calls base.setf(ios_base::oct, ios_base::basefield). 00898 inline ios_base& 00899 oct(ios_base& __base) 00900 { 00901 __base.setf(ios_base::oct, ios_base::basefield); 00902 return __base; 00903 } 00904 00905 // [27.4.5.4] floatfield anipulators 00906 /// Calls base.setf(ios_base::fixed, ios_base::floatfield). 00907 inline ios_base& 00908 fixed(ios_base& __base) 00909 { 00910 __base.setf(ios_base::fixed, ios_base::floatfield); 00911 return __base; 00912 } 00913 00914 /// Calls base.setf(ios_base::scientific, ios_base::floatfield). 00915 inline ios_base& 00916 scientific(ios_base& __base) 00917 { 00918 __base.setf(ios_base::scientific, ios_base::floatfield); 00919 return __base; 00920 } 00921 } // namespace std 00922 00923 #endif /* _IOS_BASE_H */ 00924

Generated on Sun Sep 12 15:49:57 2004 for libstdc++ source by doxygen 1.3.8