To get this branch, use:
bzr branch
http://bzr.ed.am/elec/propeller-clock
« back to all changes in this revision
Viewing changes to src/utility/ios
- browse files at revision 57
- compare with another revision
- compare with revision 37
- download diff
- download tarball
- view history from revision 57
- Committer: edam
- Date: 2012-02-25 01:31:43 UTC
- Revision ID: tim@ed.am-20120225013143-9fet2y2d3fjlrwez
added ulibc
- files added:
- src/utility
added
removed
src/utility/ios
1
/* Copyright (C) 2004 Garrett A. Kajmowicz
2
3
This file is part of the uClibc++ Library.
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
This library is distributed in the hope that it will be useful,
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
14
15
You should have received a copy of the GNU Lesser General Public
16
License along with this library; if not, write to the Free Software
17
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
*/
19
20
#include <basic_definitions>
21
#include <cstddef>
22
#include <locale>
23
#include <iosfwd>
24
25
#ifndef __HEADER_STD_IOS
26
#define __HEADER_STD_IOS 1
27
28
#pragma GCC visibility push(default)
29
30
namespace std{
31
typedef signed long int streamoff;
32
33
template <class stateT> class fpos;
34
35
class _UCXXEXPORT ios_base {
36
public:
37
class failure;
38
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
39
class failure : public exception {
40
public:
41
explicit failure(const std::string& msg) { }
42
explicit failure() { }
43
virtual const char* what() const throw() {
44
return "std::ios_base failure exception";
45
}
46
};
47
#endif
48
#ifdef __UCLIBCXX_SUPPORT_CDIR__
49
class _UCXXLOCAL Init{
50
public:
51
_UCXXEXPORT Init();
52
_UCXXEXPORT ~Init();
53
private:
54
static int init_cnt;
55
};
56
#endif
57
58
public:
59
60
typedef unsigned short int fmtflags;
61
62
static const fmtflags skipws = 0x0001;
63
64
static const fmtflags left = 0x0002;
65
static const fmtflags right = 0x0004;
66
static const fmtflags internal = 0x0008;
67
68
static const fmtflags boolalpha = 0x0010;
69
70
static const fmtflags dec = 0x0020;
71
static const fmtflags oct = 0x0040;
72
static const fmtflags hex = 0x0080;
73
74
static const fmtflags scientific = 0x0100;
75
static const fmtflags fixed = 0x0200;
76
77
static const fmtflags showbase = 0x0400;
78
static const fmtflags showpoint = 0x0800;
79
static const fmtflags showpos = 0x1000;
80
static const fmtflags uppercase = 0x2000;
81
82
static const fmtflags adjustfield = left | right | internal;
83
static const fmtflags basefield = dec | oct | hex;
84
static const fmtflags floatfield = fixed | scientific;
85
86
static const fmtflags unitbuf = 0x4000;
87
88
typedef unsigned char iostate;
89
static const iostate goodbit = 0x00;
90
static const iostate badbit = 0x01;
91
static const iostate eofbit = 0x02;
92
static const iostate failbit = 0x04;
93
94
typedef unsigned char openmode;
95
static const openmode app = 0x01;
96
static const openmode ate = 0x02;
97
static const openmode binary = 0x04;
98
static const openmode in = 0x08;
99
static const openmode out = 0x10;
100
static const openmode trunc = 0x20;
101
102
typedef unsigned char seekdir;
103
static const seekdir beg = 0x01;
104
static const seekdir cur = 0x02;
105
static const seekdir end = 0x04;
106
107
_UCXXEXPORT fmtflags flags() const{
108
return mformat;
109
}
110
_UCXXEXPORT fmtflags flags(fmtflags fmtfl);
111
112
fmtflags setf(fmtflags fmtfl);
113
fmtflags setf(fmtflags fmtfl, fmtflags mask );
114
115
_UCXXEXPORT void unsetf(fmtflags mask){
116
mformat&= ~mask;
117
}
118
119
_UCXXEXPORT streamsize precision() const{
120
return mprecision;
121
}
122
123
_UCXXEXPORT streamsize precision(streamsize prec);
124
125
_UCXXEXPORT streamsize width() const{
126
return mwidth;
127
}
128
129
_UCXXEXPORT streamsize width(streamsize wide);
130
131
_UCXXEXPORT locale imbue(const locale& loc);
132
133
_UCXXEXPORT locale getloc() const{
134
return mLocale;
135
}
136
137
// FIXME - These need to be implemented
138
// static int xalloc();
139
// long& iword(int index);
140
// void*& pword(int index);
141
142
_UCXXEXPORT ~ios_base() { }
143
144
enum event { erase_event, imbue_event, copyfmt_event };
145
146
typedef void (*event_callback)(event, ios_base&, int index);
147
// void register_callback(event_call_back fn, int index);
148
149
//We are going to wrap stdio so we don't need implementation of the following:
150
inline static bool sync_with_stdio(bool = true) { return true; }
151
152
protected:
153
_UCXXEXPORT ios_base() : mLocale(), mformat(dec | skipws ), mstate(goodbit),
154
mmode(), mdir(), mprecision(6), mwidth(0)
155
#ifdef __UCLIBCXX_SUPPORT_CDIR__
156
,mInit()
157
#endif
158
{
159
160
}
161
locale mLocale;
162
fmtflags mformat;
163
iostate mstate;
164
openmode mmode;
165
seekdir mdir;
166
streamsize mprecision;
167
streamsize mwidth;
168
#ifdef __UCLIBCXX_SUPPORT_CDIR__
169
Init mInit;
170
#endif
171
};
172
173
174
//ios_base manipulators
175
176
177
inline ios_base& boolalpha (ios_base& str){
178
str.setf(ios_base::boolalpha);
179
return str;
180
}
181
inline ios_base& noboolalpha(ios_base& str){
182
str.unsetf(ios_base::boolalpha);
183
return str;
184
}
185
inline ios_base& showbase (ios_base& str){
186
str.setf(ios_base::showbase);
187
return str;
188
}
189
inline ios_base& noshowbase (ios_base& str){
190
str.unsetf(ios_base::showbase);
191
return str;
192
}
193
inline ios_base& showpoint (ios_base& str){
194
str.setf(ios_base::showpoint);
195
return str;
196
}
197
inline ios_base& noshowpoint(ios_base& str){
198
str.unsetf(ios_base::showpoint);
199
return str;
200
}
201
inline ios_base& showpos (ios_base& str){
202
str.setf(ios_base::showpos);
203
return str;
204
}
205
inline ios_base& noshowpos (ios_base& str){
206
str.unsetf(ios_base::showpos);
207
return str;
208
}
209
inline ios_base& skipws (ios_base& str){
210
str.setf(ios_base::skipws);
211
return str;
212
}
213
inline ios_base& noskipws (ios_base& str){
214
str.unsetf(ios_base::skipws);
215
return str;
216
}
217
inline ios_base& uppercase (ios_base& str){
218
str.setf(ios_base::uppercase);
219
return str;
220
}
221
inline ios_base& nouppercase(ios_base& str){
222
str.unsetf(ios_base::uppercase);
223
return str;
224
}
225
226
inline ios_base& unitbuf (ios_base& str){
227
str.setf(ios_base::unitbuf);
228
return str;
229
}
230
inline ios_base& nounitbuf (ios_base& str){
231
str.unsetf(ios_base::unitbuf);
232
return str;
233
}
234
inline ios_base& internal (ios_base& str){
235
str.setf(ios_base::internal, ios_base::adjustfield);
236
return str;
237
}
238
inline ios_base& left (ios_base& str){
239
str.setf(ios_base::left, ios_base::adjustfield);
240
return str;
241
}
242
inline ios_base& right (ios_base& str){
243
str.setf(ios_base::right, ios_base::adjustfield);
244
return str;
245
}
246
247
inline ios_base& dec (ios_base& str){
248
str.setf(ios_base::dec, ios_base::basefield);
249
return str;
250
}
251
inline ios_base& hex (ios_base& str){
252
str.setf(ios_base::hex, ios_base::basefield);
253
return str;
254
}
255
inline ios_base& oct (ios_base& str){
256
str.setf(ios_base::oct, ios_base::basefield);
257
return str;
258
}
259
260
inline ios_base& fixed (ios_base& str){
261
str.setf(ios_base::fixed, ios_base::floatfield);
262
return str;
263
}
264
inline ios_base& scientific (ios_base& str){
265
str.setf(ios_base::scientific, ios_base::floatfield);
266
return str;
267
}
268
269
270
//basic_ios class definition
271
272
273
template <class charT, class traits > class _UCXXEXPORT basic_ios
274
: public ios_base
275
{
276
public:
277
// Types:
278
typedef charT char_type;
279
typedef typename traits::int_type int_type;
280
typedef typename traits::pos_type pos_type;
281
typedef typename traits::off_type off_type;
282
typedef traits traits_type;
283
284
_UCXXEXPORT operator void*() const{
285
if(fail() ){
286
return 0;
287
}
288
return (void *)(1); //Must return a non-NULL pointer (though it can be *any* pointer)
289
}
290
291
_UCXXEXPORT bool operator!() const{
292
return fail();
293
}
294
_UCXXEXPORT iostate rdstate() const{
295
return mstate;
296
}
297
_UCXXEXPORT void clear(iostate state = goodbit){
298
if(rdbuf()!=0){
299
mstate = state;
300
}else{
301
mstate = state|ios_base::badbit;
302
}
303
}
304
_UCXXEXPORT void setstate(iostate state) {
305
clear(rdstate() | state);
306
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
307
if(rdstate() & throw_mask){
308
throw failure();
309
}
310
#endif
311
}
312
313
_UCXXEXPORT bool good() const{
314
return (rdstate() == 0);
315
}
316
_UCXXEXPORT bool eof() const{
317
if(rdstate() & eofbit){
318
return true;
319
}
320
return false;
321
}
322
_UCXXEXPORT bool fail() const{
323
if( mstate & (failbit | badbit) ){
324
return true;
325
}
326
return false;
327
}
328
329
_UCXXEXPORT bool bad() const{
330
if(mstate & badbit){
331
return true;
332
}
333
return false;
334
}
335
336
_UCXXEXPORT iostate exceptions() const{
337
return throw_mask;
338
}
339
_UCXXEXPORT void exceptions(iostate except){
340
throw_mask = except;
341
}
342
343
explicit _UCXXEXPORT basic_ios(basic_streambuf<charT,traits>* sb) : fill_char(' '), mtied(0), mstreambuf(0){
344
init(sb);
345
}
346
347
basic_ios() : mtied(0), mstreambuf(0){ }
348
349
virtual _UCXXEXPORT ~basic_ios(){
350
}
351
352
_UCXXEXPORT basic_ostream<charT,traits>* tie() const{
353
return mtied;
354
}
355
_UCXXEXPORT basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr){
356
basic_ostream<charT,traits>* retval= mtied;
357
mtied = tiestr;
358
return retval;
359
}
360
_UCXXEXPORT basic_streambuf<charT,traits>* rdbuf() const{
361
return mstreambuf;
362
}
363
_UCXXEXPORT basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb){
364
basic_streambuf<charT,traits>* retval = mstreambuf;
365
mstreambuf = sb;
366
return retval;
367
}
368
_UCXXEXPORT basic_ios& copyfmt(const basic_ios& rhs);
369
_UCXXEXPORT char_type fill() const{
370
return fill_char;
371
}
372
_UCXXEXPORT char_type fill(char_type ch){
373
char_type temp = fill_char;
374
fill_char = ch;
375
return temp;
376
}
377
378
_UCXXEXPORT locale imbue(const locale& loc){
379
return ios_base::imbue(loc);
380
}
381
_UCXXEXPORT char narrow(char_type c, char dfault) const;
382
_UCXXEXPORT char_type widen(char c) const;
383
384
protected:
385
char_type fill_char;
386
basic_ostream<charT,traits>* mtied;
387
basic_streambuf<charT,traits>* mstreambuf;
388
iostate throw_mask;
389
_UCXXEXPORT basic_ios(const basic_ios<charT,traits> &){ }
390
_UCXXEXPORT basic_ios<charT,traits> & operator=(const basic_ios<charT,traits> &){ return *this; }
391
_UCXXEXPORT void init(basic_streambuf<charT,traits>* sb){
392
ios_base::mformat = skipws|dec;
393
mstreambuf = sb;
394
mstate = goodbit;
395
throw_mask = goodbit;
396
}
397
};
398
399
#ifdef __UCLIBCXX_EXPAND_IOS_CHAR__
400
#ifndef __UCLIBCXX_COMPILE_IOS__
401
402
template <> _UCXXEXPORT void basic_ios<char, char_traits<char> >::clear(iostate state);
403
template <> _UCXXEXPORT void basic_ios<char, char_traits<char> >::setstate(iostate state);
404
405
#endif
406
#endif
407
408
409
template <class charT, class traits>
410
inline char basic_ios<charT, traits>::narrow(char_type c, char dfault) const
411
{
412
return dfault;
413
}
414
415
template <>
416
inline char basic_ios<char, char_traits<char> >::narrow(char_type c, char) const
417
{
418
return c;
419
}
420
421
#ifdef __UCLIBCXX_HAS_WCHAR__
422
423
template <>
424
inline char basic_ios<wchar_t, char_traits<wchar_t> >::narrow(char_type c, char dfault) const
425
{
426
char retval = wctob (c);
427
if(retval == EOF){
428
retval = dfault;
429
}
430
return retval;
431
}
432
433
#endif //__UCLIBCXX_HAS_WCHAR__
434
435
template <class charT, class traits>
436
inline typename basic_ios<charT, traits>::char_type
437
basic_ios<charT, traits>::widen(char c) const
438
{
439
return c;
440
}
441
442
template <>
443
inline basic_ios<char, char_traits<char> >::char_type
444
basic_ios<char, char_traits<char> >::widen(char c) const
445
{
446
return c;
447
}
448
449
#ifdef __UCLIBCXX_HAS_WCHAR__
450
451
template <>
452
inline basic_ios<wchar_t, char_traits<wchar_t> >::char_type
453
basic_ios<wchar_t, char_traits<wchar_t> >::widen(char c) const
454
{
455
return btowc(c);
456
}
457
458
#endif //__UCLIBCXX_HAS_WCHAR__
459
460
461
template <class stateT> class _UCXXEXPORT fpos{
462
public:
463
_UCXXEXPORT fpos(stateT s){
464
st = s;
465
}
466
_UCXXEXPORT stateT state() const{
467
return st;
468
}
469
_UCXXEXPORT void state(stateT s){
470
st = s;
471
}
472
_UCXXEXPORT bool operator==(const fpos &rhs){
473
return st == rhs.st;
474
}
475
_UCXXEXPORT bool operator!=(const fpos &rhs){
476
return st == rhs.st;
477
}
478
_UCXXEXPORT fpos & operator+(const streamoff & o){
479
st += o;
480
return *this;
481
}
482
_UCXXEXPORT fpos & operator-(const streamoff & o){
483
st -= o;
484
return *this;
485
}
486
_UCXXEXPORT streamoff operator-(const fpos & rhs){
487
return st - rhs.st;
488
}
489
490
491
private:
492
stateT st;
493
};
494
495
496
}
497
498
#pragma GCC visibility pop
499
500
#endif
501
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0