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/ostream
- browse files at revision 48
- compare with another revision
- download diff
- download tarball
- view history from revision 48
- Committer: edam
- Date: 2012-02-16 00:08:37 UTC
- Revision ID: edam@waxworlds.org-20120216000837-ozbyl61w2n2thwa0
update arduino.mk
- files removed:
- src/analogue_clock_mode.cc
- src/utility
- files modified:
- arduino.mk
added
removed
src/utility/ostream
1
/* Copyright (C) 2004-2008 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
22
#ifndef STD_HEADER_OSTREAM
23
#define STD_HEADER_OSTREAM 1
24
25
#include <iosfwd>
26
#include <streambuf>
27
#include <cstdio>
28
#include <ostream_helpers>
29
30
#if defined( __AVR__ )
31
#include <avr/pgmspace.h>
32
class __FlashStringHelper;
33
#endif
34
35
#pragma GCC visibility push(default)
36
37
namespace std {
38
template <class charT, class traits > class basic_ostream;
39
typedef basic_ostream<char> ostream;
40
41
#ifdef __UCLIBCXX_HAS_WCHAR__
42
typedef basic_ostream<wchar_t> wostream;
43
#endif
44
45
template <class charT, class traits> basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
46
template <class charT, class traits> basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
47
template <class charT, class traits> basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
48
49
template <class charT, class traits > class _UCXXEXPORT basic_ostream
50
: virtual public basic_ios<charT,traits>
51
{
52
public:
53
54
typedef charT char_type;
55
typedef typename traits::int_type int_type;
56
typedef typename traits::pos_type pos_type;
57
typedef typename traits::off_type off_type;
58
typedef traits traits_type;
59
60
61
_UCXXEXPORT basic_ostream(basic_streambuf<charT,traits>* sb)
62
: basic_ios<charT, traits>(sb)
63
{
64
basic_ios<charT,traits>::init(sb);
65
}
66
virtual _UCXXEXPORT ~basic_ostream();
67
68
class sentry;
69
70
_UCXXEXPORT basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&)){
71
return pf(*this);
72
}
73
_UCXXEXPORT basic_ostream<charT,traits>& operator<<(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&)){
74
pf(*this);
75
return *this;
76
}
77
_UCXXEXPORT basic_ostream<charT,traits>& operator<<(ios_base& (*pf)(ios_base&)){
78
pf(*this);
79
return *this;
80
}
81
basic_ostream<charT,traits>& operator<<(bool n);
82
basic_ostream<charT,traits>& operator<<(short n);
83
basic_ostream<charT,traits>& operator<<(unsigned short n);
84
basic_ostream<charT,traits>& operator<<(int n);
85
basic_ostream<charT,traits>& operator<<(unsigned int n);
86
basic_ostream<charT,traits>& operator<<(long n);
87
basic_ostream<charT,traits>& operator<<(unsigned long n);
88
basic_ostream<charT,traits>& operator<<(float f);
89
basic_ostream<charT,traits>& operator<<(double f);
90
basic_ostream<charT,traits>& operator<<(long double f);
91
basic_ostream<charT,traits>& operator<<(void* p);
92
basic_ostream<charT,traits>& operator<<(basic_streambuf<char_type,traits>* sb);
93
#if defined( __AVR__ )
94
basic_ostream<charT,traits>& operator<<(const __FlashStringHelper* p);
95
#endif
96
97
_UCXXEXPORT basic_ostream<charT,traits>& put(char_type c){
98
if(basic_ostream<charT,traits>::traits_type::eq_int_type(
99
basic_ios<charT, traits>::mstreambuf->sputc(c),
100
basic_ostream<charT,traits>::traits_type::eof()))
101
{
102
basic_ios<charT,traits>::setstate(ios_base::eofbit);
103
}
104
return *this;
105
}
106
_UCXXEXPORT basic_ostream<charT,traits>& write(const char_type* s, streamsize n){
107
if(basic_ostream<charT,traits>::traits_type::eq_int_type(
108
basic_ios<charT, traits>::mstreambuf->sputn(s, n),
109
basic_ostream<charT,traits>::traits_type::eof())
110
){
111
basic_ios<charT,traits>::setstate(ios_base::eofbit);
112
}
113
return *this;
114
}
115
_UCXXEXPORT basic_ostream<charT,traits>& flush(){
116
if(basic_ios<charT, traits>::mstreambuf->pubsync() == -1){
117
basic_ios<charT,traits>::setstate(ios_base::badbit);
118
}
119
return *this;
120
}
121
_UCXXEXPORT pos_type tellp(){
122
if(basic_ios<charT,traits>::fail() != false){
123
return pos_type(-1);
124
}
125
return basic_ios<charT,traits>::rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
126
}
127
_UCXXEXPORT basic_ostream<charT,traits>& seekp(pos_type pos){
128
if( basic_ios<charT,traits>::fail() != true ){
129
basic_ios<charT,traits>::rdbuf()->pubseekpos(pos);
130
}
131
return *this;
132
}
133
_UCXXEXPORT basic_ostream<charT,traits>& seekp(off_type off, ios_base::seekdir dir){
134
if( basic_ios<charT,traits>::fail() != true){
135
basic_ios<charT,traits>::rdbuf()->pubseekoff(off, dir);
136
}
137
return *this;
138
}
139
140
_UCXXEXPORT void printout(const char_type* s, streamsize n){
141
streamsize extra = ios::width() - n;
142
if ((ios::flags()&ios::adjustfield) == ios::right){
143
while (extra > 0) {
144
--extra;
145
put(ios::fill());
146
}
147
}
148
write(s, n);
149
if ((ios::flags()&ios::adjustfield) == ios::left) {
150
while (extra > 0) {
151
--extra;
152
put(ios::fill());
153
}
154
}
155
// Width value only applies for the next output operation. Reset to zero.
156
ios::width(0);
157
}
158
159
protected:
160
basic_ostream(const basic_ostream<charT,traits> &){ }
161
basic_ostream<charT,traits> & operator=(const basic_ostream<charT,traits> &){ return *this; }
162
};
163
164
//Implementations of template functions. To allow for partial specialization
165
166
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>::~basic_ostream(){ }
167
168
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(bool n){
169
sentry s(*this);
170
if( basic_ios<charT,traits>::flags() & ios_base::boolalpha){
171
if(n){
172
printout("true", 4);
173
}else{
174
printout("false", 5);
175
}
176
}else{
177
if(n){
178
printout("1", 1);
179
}else{
180
printout("0", 1);
181
}
182
}
183
if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
184
flush();
185
}
186
return *this;
187
}
188
189
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
190
basic_ostream<charT, traits>::operator<<(unsigned short n){
191
sentry s(*this);
192
__ostream_printout<traits, charT, unsigned long int>::printout(*this, n);
193
return *this;
194
}
195
196
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(short n){
197
sentry s(*this);
198
__ostream_printout<traits, charT, long int>::printout(*this, n);
199
return *this;
200
}
201
202
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(int n){
203
sentry s(*this);
204
__ostream_printout<traits, charT, long int>::printout(*this, n);
205
return *this;
206
}
207
208
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(unsigned int n){
209
sentry s(*this);
210
__ostream_printout<traits, charT, unsigned long int>::printout(*this, n);
211
return *this;
212
}
213
214
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(long n){
215
sentry s(*this);
216
__ostream_printout<traits, charT, long >::printout(*this, n);
217
return *this;
218
}
219
220
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
221
basic_ostream<charT, traits>::operator<<(unsigned long n)
222
{
223
sentry s(*this);
224
__ostream_printout<traits, charT, unsigned long >::printout(*this, n);
225
return *this;
226
}
227
228
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(float f){
229
sentry s(*this);
230
__ostream_printout<traits, charT, double >::printout(*this, f);
231
return *this;
232
}
233
234
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(double f){
235
sentry s(*this);
236
__ostream_printout<traits, charT, double >::printout(*this, f);
237
return *this;
238
}
239
240
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(long double f){
241
sentry s(*this);
242
__ostream_printout<traits, charT, long double >::printout(*this, f);
243
return *this;
244
}
245
246
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(void* p){
247
sentry s(*this);
248
char buffer[20];
249
printout(buffer, snprintf(buffer, 20, "%p", p) );
250
if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
251
flush();
252
}
253
return *this;
254
}
255
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
256
basic_ostream<charT, traits>::operator<<(basic_streambuf<charT,traits>* sb)
257
{
258
sentry s(*this);
259
if(sb == 0){
260
basic_ios<charT,traits>::setstate(ios_base::badbit);
261
return *this;
262
}
263
264
typename traits::int_type c;
265
266
while(basic_ios<charT,traits>::good() && (c = sb->sbumpc()) != traits::eof() ){
267
put(c);
268
}
269
270
if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
271
flush();
272
}
273
return *this;
274
}
275
#if defined( __AVR__ )
276
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(const __FlashStringHelper* p ){
277
sentry s(*this);
278
char buffer[64];
279
size_t p_len = strlcpy_P(buffer,reinterpret_cast<const char*>(p),sizeof(buffer));
280
printout(buffer, (p_len>=sizeof(buffer)) ? sizeof(buffer) - 1 : p_len );
281
if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
282
flush();
283
}
284
return *this;
285
}
286
#endif
287
288
289
/*Template Specializations*/
290
291
#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
292
#ifndef __UCLIBCXX_COMPILE_OSTREAM__
293
294
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
295
296
template <> _UCXXEXPORT ostream::~basic_ostream();
297
298
#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
299
300
template <> _UCXXEXPORT ostream & ostream::flush();
301
302
template <> _UCXXEXPORT ostream & ostream::operator<<(bool n);
303
template <> _UCXXEXPORT ostream & ostream::operator<<(short int n);
304
template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned short int n);
305
template <> _UCXXEXPORT ostream & ostream::operator<<(int n);
306
template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned int n);
307
template <> _UCXXEXPORT ostream & ostream::operator<<(long n);
308
template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned long n);
309
template <> _UCXXEXPORT ostream & ostream::operator<<(float f);
310
template <> _UCXXEXPORT ostream & ostream::operator<<(double f);
311
template <> _UCXXEXPORT ostream & ostream::operator<<(long double f);
312
template <> _UCXXEXPORT ostream & ostream::operator<<(void* p);
313
template <> _UCXXEXPORT ostream & ostream::operator<<(basic_streambuf<char, char_traits<char> >* sb);
314
#endif
315
#endif
316
317
template <class charT,class traits = char_traits<charT> >
318
class _UCXXEXPORT basic_ostream<charT,traits>::sentry
319
{
320
bool ok;
321
public:
322
explicit _UCXXEXPORT sentry(basic_ostream<charT,traits>& os): ok(true){
323
if(os.good() !=0){ //Prepare for output
324
}
325
326
//Flush any tied buffer
327
if(os.tie() !=0 ){
328
os.tie()->flush();
329
}
330
}
331
_UCXXEXPORT ~sentry() { }
332
_UCXXEXPORT operator bool() {
333
return ok;
334
}
335
};
336
337
338
#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
339
#ifndef __UCLIBCXX_COMPILE_OSTREAM__
340
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
341
342
template <> _UCXXEXPORT ostream::sentry::sentry(ostream & os);
343
template <> _UCXXEXPORT ostream::sentry::~sentry();
344
345
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
346
#endif
347
#endif
348
349
350
//Non - class functions
351
352
353
template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
354
operator<<(basic_ostream<charT,traits>& out, charT c)
355
{
356
typename basic_ostream<charT,traits>::sentry s(out);
357
out.put(c);
358
return out;
359
}
360
361
template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
362
operator<<(basic_ostream<charT,traits>& out, char c)
363
{
364
typename basic_ostream<charT,traits>::sentry s(out);
365
out.put(c);
366
return out;
367
}
368
369
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
370
operator<<(basic_ostream<char,traits>& out, char c)
371
{
372
typename basic_ostream<char,traits>::sentry s(out);
373
out.put(c);
374
return out;
375
}
376
377
// signed and unsigned
378
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
379
operator<<(basic_ostream<char,traits>& out, signed char c)
380
{
381
typename basic_ostream<char,traits>::sentry s(out);
382
out.put(c);
383
return out;
384
}
385
386
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
387
operator<<(basic_ostream<char,traits>& out, unsigned char c)
388
{
389
typename basic_ostream<char,traits>::sentry s(out);
390
out.put(c);
391
return out;
392
}
393
394
template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
395
operator<<(basic_ostream<charT,traits>& out, const charT* c)
396
{
397
typename basic_ostream<charT,traits>::sentry s(out);
398
out.printout(c, traits::length(c) );
399
return out;
400
}
401
402
template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
403
operator<<(basic_ostream<charT,traits>& out, const char* c)
404
{
405
typename basic_ostream<charT,traits>::sentry s(out);
406
out.printout(c, char_traits<char>::length(c) );
407
return out;
408
}
409
410
// partial specializations
411
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
412
operator<<(basic_ostream<char,traits>& out, const char* c)
413
{
414
typename basic_ostream<char,traits>::sentry s(out);
415
out.printout(c, traits::length(c));
416
return out;
417
}
418
419
#ifdef __UCLIBCXX_HAS_WCHAR__
420
template<class traits> _UCXXEXPORT basic_ostream<wchar_t,traits>&
421
operator<<(basic_ostream<wchar_t,traits>& out, const char* c)
422
{
423
typename basic_ostream<wchar_t, traits>::sentry s(out);
424
size_t numChars = char_traits<char>::length(c);
425
wchar_t * temp = new wchar_t[numChars];
426
427
for(size_t i=0; i < numChars; ++i){
428
temp[i] = out.widen(c[i]);
429
}
430
431
out.printout(temp, numChars);
432
return out;
433
}
434
#endif
435
436
// signed and unsigned
437
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
438
operator<<(basic_ostream<char,traits>& out, const signed char* c)
439
{
440
typename basic_ostream<char,traits>::sentry s(out);
441
out.printout(reinterpret_cast<const char *>(c), traits::length( reinterpret_cast<const char *>(c)));
442
return out;
443
}
444
445
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
446
operator<<(basic_ostream<char,traits>& out, const unsigned char* c)
447
{
448
typename basic_ostream<char,traits>::sentry s(out);
449
out.printout(reinterpret_cast<const char *>(c), traits::length( reinterpret_cast<const char *>(c)));
450
return out;
451
}
452
453
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
454
endl(basic_ostream<charT,traits>& os)
455
{
456
typename basic_ostream<charT,traits>::sentry s(os);
457
os.put('\n');
458
os.flush();
459
return os;
460
}
461
462
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
463
ends(basic_ostream<charT,traits>& os)
464
{
465
typename basic_ostream<charT,traits>::sentry s(os);
466
os.put(traits::eos());
467
return os;
468
}
469
470
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os){
471
typename basic_ostream<charT,traits>::sentry s(os);
472
os.flush();
473
return os;
474
}
475
476
477
#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
478
#ifndef __UCLIBCXX_COMPILE_OSTREAM__
479
template <> _UCXXEXPORT ostream & endl(ostream & os);
480
template <> _UCXXEXPORT ostream & flush(ostream & os);
481
template <> _UCXXEXPORT ostream & operator<<(ostream & out, char c);
482
template <> _UCXXEXPORT ostream & operator<<(ostream & out, const char* c);
483
template <> _UCXXEXPORT ostream & operator<<(ostream & out, unsigned char c);
484
template <> _UCXXEXPORT ostream & operator<<(ostream & out, unsigned const char* c);
485
486
#endif
487
#endif
488
489
490
#ifndef __STRICT_ANSI__
491
492
//Support for output of long long data types
493
494
template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
495
operator<<(basic_ostream<Ch, Tr>& os, signed long long int i)
496
{
497
typename basic_ostream<Ch, Tr>::sentry s(os);
498
__ostream_printout<Tr, Ch, signed long long int>::printout(os, i);
499
return os;
500
}
501
502
503
template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
504
operator<<(basic_ostream<Ch, Tr>& os, unsigned long long int i)
505
{
506
typename basic_ostream<Ch, Tr>::sentry s(os);
507
__ostream_printout<Tr, Ch, unsigned long long int>::printout(os, i);
508
return os;
509
}
510
511
512
#endif //__STRICT_ANSI__
513
514
515
516
517
}
518
519
#pragma GCC visibility pop
520
521
#endif
522
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0