/elec/propeller-clock

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/istream

  • Committer: edam
  • Date: 2011-12-02 19:57:07 UTC
  • Revision ID: edam@waxworlds.org-20111202195707-lko4ap3pfe1jrgd9
renamed code directories and updated the comments in the code

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*      Copyright (C) 2004 Garrett A. Kajmowicz
2
 
 
3
 
        This file is part of the uClibc C++ Library.  This library is free
4
 
        software; you can redistribute it and/or modify it under the
5
 
        terms of the GNU General Public License as published by the
6
 
        Free Software Foundation; either version 2, or (at your option)
7
 
        any later version.
8
 
 
9
 
        This library is distributed in the hope that it will be useful,
10
 
        but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
        GNU General Public License for more details.
13
 
 
14
 
        You should have received a copy of the GNU General Public License along
15
 
        with this library; see the file COPYING.  If not, write to the Free
16
 
        Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17
 
        USA.
18
 
*/
19
 
 
20
 
#include <ios>
21
 
#include <cctype>
22
 
#include <streambuf>
23
 
#include <istream_helpers>
24
 
#include <ostream>
25
 
 
26
 
#ifndef __STD_HEADER_ISTREAM
27
 
#define __STD_HEADER_ISTREAM 1
28
 
 
29
 
#pragma GCC visibility push(default)
30
 
 
31
 
namespace std{
32
 
 
33
 
        typedef basic_istream<char> istream;
34
 
 
35
 
#ifdef __UCLIBCXX_HAS_WCHAR__
36
 
        typedef basic_istream<wchar_t> wistream;
37
 
#endif
38
 
 
39
 
        template <class charT, class traits> basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);
40
 
 
41
 
        template <class charT, class traits> class _UCXXEXPORT basic_istream :
42
 
                virtual public basic_ios<charT,traits>
43
 
        {
44
 
        public:
45
 
        
46
 
                typedef charT                     char_type;
47
 
                typedef typename traits::int_type int_type;
48
 
                typedef typename traits::pos_type pos_type;
49
 
                typedef typename traits::off_type off_type;
50
 
                typedef basic_streambuf<charT,traits>  streambuf_type;
51
 
                typedef traits                    traits_type;
52
 
        
53
 
                explicit basic_istream(basic_streambuf<charT,traits>* sb)
54
 
                        : basic_ios<charT, traits>(sb), count_last_ufmt_input(0)
55
 
                {
56
 
                        basic_ios<charT, traits>::init(sb);
57
 
                }
58
 
                virtual ~basic_istream() { }
59
 
        
60
 
                class sentry;
61
 
        
62
 
                basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&));
63
 
                basic_istream<charT,traits>& operator>>(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
64
 
                basic_istream<charT,traits>& operator>>(ios_base& (*pf)(ios_base&));
65
 
                basic_istream<charT,traits>& operator>>(bool& n);
66
 
                basic_istream<charT,traits>& operator>>(short& n);
67
 
                basic_istream<charT,traits>& operator>>(unsigned short& n);
68
 
                basic_istream<charT,traits>& operator>>(int& n);
69
 
                basic_istream<charT,traits>& operator>>(unsigned int& n);
70
 
                basic_istream<charT,traits>& operator>>(long& n);
71
 
                basic_istream<charT,traits>& operator>>(unsigned long& n);
72
 
                basic_istream<charT,traits>& operator>>(void*& p);
73
 
                basic_istream<charT,traits>& operator>>(basic_streambuf<char_type,traits>* sb);
74
 
 
75
 
#ifdef __UCLIBCXX_HAS_FLOATS__
76
 
                basic_istream<charT,traits>& operator>>(float& f);
77
 
                basic_istream<charT,traits>& operator>>(double& f);
78
 
                basic_istream<charT,traits>& operator>>(long double& f);
79
 
#endif
80
 
        
81
 
                _UCXXEXPORT streamsize gcount() const{
82
 
                        return count_last_ufmt_input;
83
 
                }
84
 
                
85
 
                _UCXXEXPORT int_type get();             //below
86
 
                _UCXXEXPORT basic_istream<charT,traits>& get(char_type& c);     //Below
87
 
                
88
 
                _UCXXEXPORT basic_istream<charT,traits>& get(char_type* s, streamsize n){
89
 
                        return get(s, n, basic_ios<charT,traits>::widen('\n'));
90
 
                }
91
 
                
92
 
                _UCXXEXPORT basic_istream<charT,traits>& get(char_type* s, streamsize n, char_type delim){
93
 
                        sentry(*this, true);
94
 
                        streamsize i = 0;
95
 
                        int_type c;
96
 
                        for(i=0;i<n-1;++i){
97
 
                                c = basic_ios<charT, traits>::mstreambuf->sgetc();
98
 
                                basic_ios<charT, traits>::mstreambuf->sbumpc();
99
 
                                if(c == traits::eof() ){
100
 
                                        if(i==0){
101
 
                                                basic_ios<charT,traits>::setstate(ios_base::failbit);
102
 
                                        }else{
103
 
                                                basic_ios<charT,traits>::setstate(ios_base::eofbit);
104
 
                                        }
105
 
                                        break;
106
 
                                }
107
 
                                if(c == delim){
108
 
                                        if(i==0){
109
 
                                                basic_ios<charT,traits>::setstate(ios_base::failbit);
110
 
                                        }
111
 
                                        basic_ios<charT, traits>::mstreambuf->sputbackc(c);
112
 
                                        break;
113
 
                                }
114
 
                                s[i] = c;
115
 
                        }
116
 
                        s[i] = traits::eos();
117
 
                        count_last_ufmt_input = i;
118
 
                        return *this;
119
 
                }
120
 
                
121
 
                _UCXXEXPORT basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb){
122
 
                        return get(sb, basic_ios<charT,traits>::widen('\n'));
123
 
                }
124
 
                
125
 
                _UCXXEXPORT basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb, char_type delim){
126
 
                        sentry(*this, true);
127
 
                        streamsize i = 0;
128
 
                        int_type c;
129
 
                        while(1){               //We will exit internally based upon error conditions
130
 
                                c = basic_ios<charT, traits>::mstreambuf->sgetc();
131
 
                                if(c == traits::eof()){
132
 
                                        if(i==0){
133
 
                                                basic_ios<charT,traits>::setstate(ios_base::failbit);
134
 
                                        }else{
135
 
                                                basic_ios<charT,traits>::setstate(ios_base::eofbit);
136
 
                                        }
137
 
                                        count_last_ufmt_input = i;
138
 
                                        return *this;
139
 
                                }
140
 
                                if(c == delim){
141
 
                                        if(i==0){
142
 
                                                basic_ios<charT,traits>::setstate(ios_base::failbit);
143
 
                                        }
144
 
                                        count_last_ufmt_input = i;
145
 
                                        return *this;
146
 
                                }
147
 
                                if(sb.sputc(c) != c){   //Error doing output
148
 
                                        count_last_ufmt_input = i;
149
 
                                        return *this;
150
 
                                }
151
 
                                ++i;
152
 
                                basic_ios<charT, traits>::mstreambuf->sbumpc();
153
 
                        }               
154
 
                }
155
 
                
156
 
                _UCXXEXPORT basic_istream<charT,traits>& getline(char_type* s, streamsize n){
157
 
                        return getline(s, n, basic_ios<charT,traits>::widen('\n'));
158
 
                }
159
 
                
160
 
                _UCXXEXPORT basic_istream<charT,traits>& getline(char_type* s, streamsize n, char_type delim){
161
 
                        sentry(*this, true);
162
 
                        streamsize i = 0;
163
 
                        int_type c;
164
 
                        for(i=0;i<n-1;++i){
165
 
                                c = basic_ios<charT, traits>::mstreambuf->sgetc();
166
 
                                if(c == traits::eof() ){
167
 
                                        if( basic_ios<charT,traits>::eof() ){
168
 
                                                basic_ios<charT,traits>::setstate(ios_base::failbit);
169
 
                                        }else{
170
 
                                                basic_ios<charT,traits>::setstate(ios_base::eofbit);
171
 
                                        }
172
 
                                        count_last_ufmt_input = i;
173
 
                                        s[i] = traits::eos();
174
 
                                        return *this;
175
 
                                }
176
 
                                if(basic_ios<charT, traits>::mstreambuf->sbumpc()==traits::eof() ){
177
 
                                        basic_ios<charT,traits>::setstate(ios_base::eofbit);
178
 
                                }
179
 
                                if(c == delim){
180
 
                                        count_last_ufmt_input = i+1;
181
 
                                        s[i] = traits::eos();
182
 
                                        return *this;
183
 
                                }
184
 
                                s[i] = c;
185
 
                        }
186
 
                        s[n-1] = traits::eos();
187
 
                        return *this;
188
 
                }
189
 
                
190
 
                _UCXXEXPORT basic_istream<charT,traits>& ignore (streamsize n = 1, int_type delim = traits::eof()){
191
 
                        sentry(*this, true);
192
 
                        streamsize i;
193
 
                        int_type c;
194
 
                        for(i=0;i<n;++i){
195
 
                                c = basic_ios<charT, traits>::mstreambuf->sgetc();
196
 
                                if(c == traits::eof()){
197
 
                                        basic_ios<charT,traits>::setstate(ios_base::eofbit);
198
 
                                        return *this;
199
 
                                }
200
 
                                basic_ios<charT, traits>::mstreambuf->sbumpc();
201
 
                                if(c == delim){
202
 
                                        return *this;
203
 
                                }
204
 
                        }
205
 
                        return *this;
206
 
                }
207
 
                
208
 
                _UCXXEXPORT int_type peek(){
209
 
                        if(basic_ios<charT,traits>::good() == false){
210
 
                                return traits::eof();
211
 
                        }else{
212
 
                                int_type c = basic_ios<charT, traits>::mstreambuf->sgetc();
213
 
                                if(c == traits::eof()){
214
 
                                        basic_ios<charT,traits>::setstate(ios_base::eofbit);
215
 
                                }
216
 
                                return basic_ios<charT, traits>::mstreambuf->sgetc();
217
 
                        }
218
 
                }
219
 
                
220
 
                _UCXXEXPORT basic_istream<charT,traits>& read (char_type* s, streamsize n){
221
 
                        sentry(*this, true);
222
 
                        streamsize i;
223
 
                        int_type c;
224
 
                        for(i=0;i<n;++i){
225
 
                                c = basic_ios<charT, traits>::mstreambuf->sgetc();
226
 
 
227
 
                                if(c == traits::eof()){
228
 
                                        basic_ios<charT,traits>::setstate(ios_base::failbit);
229
 
                                        basic_ios<charT,traits>::setstate(ios_base::eofbit);
230
 
                                        count_last_ufmt_input = i;
231
 
                                        return *this;
232
 
                                }
233
 
                                basic_ios<charT, traits>::mstreambuf->sbumpc();
234
 
                                s[i] = c;
235
 
                        }
236
 
                        count_last_ufmt_input = n;
237
 
                        return *this;
238
 
                }
239
 
                
240
 
                _UCXXEXPORT streamsize readsome(char_type* s, streamsize n){
241
 
                        sentry(*this, true);
242
 
                        if(!basic_ios<charT,traits>::good()){
243
 
                                count_last_ufmt_input = 0;
244
 
                                basic_ios<charT,traits>::setstate(ios_base::failbit);
245
 
                                return 0;
246
 
                        }
247
 
                        
248
 
                        if( basic_ios<charT, traits>::mstreambuf->in_avail()  ==  -1){
249
 
                                count_last_ufmt_input=0;
250
 
                                basic_ios<charT,traits>::setstate(ios_base::eofbit);
251
 
                                return 0;
252
 
                        }
253
 
                        
254
 
                        if(n > basic_ios<charT, traits>::mstreambuf->in_avail() ){
255
 
                                n = basic_ios<charT, traits>::mstreambuf->in_avail();
256
 
                        }
257
 
                        
258
 
                        streamsize i;
259
 
                        int_type c;
260
 
                        
261
 
                        for(i=0;i<n;++i){
262
 
                                c = basic_ios<charT, traits>::mstreambuf->sgetc();
263
 
                                basic_ios<charT, traits>::mstreambuf->sbumpc();
264
 
                                s[i] = c;
265
 
                        }
266
 
                        count_last_ufmt_input = n;
267
 
                        return n;
268
 
                }
269
 
                
270
 
                _UCXXEXPORT basic_istream<charT,traits>& putback(char_type c){
271
 
                        sentry(*this, true);
272
 
                        if(!basic_ios<charT,traits>::good()){
273
 
                                basic_ios<charT,traits>::setstate(ios_base::failbit);
274
 
                                return *this;
275
 
                        }
276
 
                        if(basic_ios<charT, traits>::mstreambuf == 0){
277
 
                                basic_ios<charT,traits>::setstate(ios_base::badbit);
278
 
                                return *this;
279
 
                        }
280
 
                        if(basic_ios<charT, traits>::mstreambuf->sputbackc(c) == traits::eof()){
281
 
                                basic_ios<charT,traits>::setstate(ios_base::badbit);
282
 
                                return *this;
283
 
                        }
284
 
                        return *this;
285
 
                }
286
 
                
287
 
                _UCXXEXPORT basic_istream<charT,traits>& unget(){
288
 
                        sentry(*this, true);
289
 
                        if(!basic_ios<charT,traits>::good()){
290
 
                                basic_ios<charT,traits>::setstate(ios_base::failbit);
291
 
                                return *this;
292
 
                        }
293
 
                        if(basic_ios<charT, traits>::mstreambuf == 0){
294
 
                                basic_ios<charT,traits>::setstate(ios_base::failbit);
295
 
                                return *this;
296
 
                        }
297
 
                        if(basic_ios<charT, traits>::mstreambuf->sungetc() == traits::eof()){
298
 
                                basic_ios<charT,traits>::setstate(ios_base::failbit);
299
 
                        }
300
 
                        return *this;
301
 
                }
302
 
                
303
 
                _UCXXEXPORT int sync(){
304
 
                        sentry(*this, true);
305
 
                        if(basic_ios<charT, traits>::mstreambuf == 0){
306
 
                                return -1;
307
 
                        }
308
 
                        if(basic_ios<charT, traits>::mstreambuf->pubsync() == -1){
309
 
                                basic_ios<charT,traits>::setstate(ios_base::badbit);
310
 
                                return traits::eof();
311
 
                        }
312
 
                        return 0;
313
 
                }
314
 
        
315
 
                _UCXXEXPORT pos_type tellg(){
316
 
                        if(basic_ios<charT,traits>::fail() !=false){
317
 
                                return pos_type(-1);
318
 
                        }
319
 
                        return basic_ios<charT, traits>::mstreambuf->pubseekoff(0, ios_base::cur, ios_base::in);
320
 
                }
321
 
                
322
 
                _UCXXEXPORT basic_istream<charT,traits>& seekg(pos_type pos){
323
 
                         if(basic_ios<charT,traits>::fail() !=true){
324
 
                                basic_ios<charT, traits>::mstreambuf->pubseekpos(pos);
325
 
                         }
326
 
                        return *this;           
327
 
                }
328
 
                
329
 
                _UCXXEXPORT basic_istream<charT,traits>& seekg(off_type off, ios_base::seekdir dir){
330
 
                        if(basic_ios<charT,traits>::fail() !=true){
331
 
                                basic_ios<charT, traits>::mstreambuf->pubseekoff(off, dir);
332
 
                        }
333
 
                        return *this;
334
 
                }
335
 
                
336
 
        protected:
337
 
                _UCXXEXPORT basic_istream(const basic_istream<charT,traits> &): basic_ios<charT, traits>() { }
338
 
                _UCXXEXPORT basic_istream<charT,traits> & operator=(const basic_istream<charT,traits> &){ return *this; }
339
 
                streamsize count_last_ufmt_input;
340
 
 
341
 
        };
342
 
        
343
 
        template <class charT,class traits = char_traits<charT> > class _UCXXEXPORT basic_istream<charT,traits>::sentry {
344
 
                bool ok;
345
 
        public:
346
 
                explicit _UCXXEXPORT sentry(basic_istream<charT,traits>& os, bool noskipws = false){
347
 
                        if(os.good() !=0){              //Prepare for output
348
 
                        }
349
 
 
350
 
                        //Flush any tied buffer
351
 
                        if(os.tie() != 0){
352
 
                                os.tie()->flush();
353
 
                        }
354
 
                        if(!noskipws){
355
 
                                __skipws(os);
356
 
                        }
357
 
 
358
 
                        ok = true;
359
 
                }
360
 
                _UCXXEXPORT ~sentry() { }
361
 
                _UCXXEXPORT operator bool() {
362
 
                        return ok;
363
 
                }
364
 
        };
365
 
        
366
 
        //Template implementations of basic_istream functions which may be partially specialized
367
 
        //For code reduction
368
 
 
369
 
        template <class charT, class traits>
370
 
        _UCXXEXPORT typename basic_istream<charT,traits>::int_type basic_istream<charT,traits>::get(){
371
 
                sentry(*this, true);
372
 
                int_type retval = basic_ios<charT, traits>::mstreambuf->sgetc();
373
 
                if(retval == traits::eof()){
374
 
                        count_last_ufmt_input = 0;
375
 
                        basic_ios<charT,traits>::setstate(ios_base::eofbit);
376
 
                }else{
377
 
                        count_last_ufmt_input = 1;
378
 
                        basic_ios<charT, traits>::mstreambuf->sbumpc();
379
 
                }
380
 
                return retval;
381
 
        }
382
 
 
383
 
        template <class charT, class traits>
384
 
        _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::get(char_type& c){
385
 
                sentry(*this, true);
386
 
                int_type retval = basic_ios<charT, traits>::mstreambuf->sgetc();
387
 
                if(retval == traits::eof()){
388
 
                        count_last_ufmt_input = 0;
389
 
                        basic_ios<charT,traits>::setstate(ios_base::eofbit);
390
 
                        basic_ios<charT,traits>::setstate(ios_base::failbit);
391
 
                }else{
392
 
                        count_last_ufmt_input = 1;
393
 
                        c = traits::to_char_type(retval);
394
 
                        basic_ios<charT, traits>::mstreambuf->sbumpc();
395
 
                }
396
 
                return *this;
397
 
        }
398
 
                
399
 
 
400
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& 
401
 
                basic_istream<charT,traits>::operator>>(bool& n)
402
 
        {
403
 
                sentry(*this);
404
 
                __istream_readin<traits, charT, bool>::readin(*this, n);
405
 
                return *this;
406
 
        }
407
 
 
408
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& 
409
 
                basic_istream<charT,traits>::operator>>(short& n)
410
 
        {
411
 
                sentry(*this);
412
 
                __istream_readin<traits, charT, short>::readin(*this, n);
413
 
                return *this;
414
 
        }
415
 
 
416
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& 
417
 
                basic_istream<charT,traits>::operator>>(unsigned short& n)
418
 
        {
419
 
                sentry(*this);
420
 
                __istream_readin<traits, charT, unsigned short>::readin(*this, n);
421
 
                return *this;
422
 
        }
423
 
 
424
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(int& n){
425
 
                sentry(*this);
426
 
                __istream_readin<traits, charT, int>::readin(*this, n);
427
 
                return *this;
428
 
        }
429
 
 
430
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(unsigned int& n){
431
 
                sentry(*this);
432
 
                __istream_readin<traits, charT, unsigned int>::readin(*this, n);
433
 
                return *this;
434
 
        }
435
 
 
436
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(long int& n){
437
 
                sentry(*this);
438
 
                __istream_readin<traits, charT, long int>::readin(*this, n);
439
 
                return *this;
440
 
        }
441
 
 
442
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& 
443
 
                basic_istream<charT,traits>::operator>>(unsigned long int& n)
444
 
        {
445
 
                sentry(*this);
446
 
                __istream_readin<traits, charT, unsigned long int>::readin(*this, n);
447
 
                return *this;
448
 
        }
449
 
 
450
 
#ifdef __UCLIBCXX_HAS_FLOATS__
451
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& 
452
 
                basic_istream<charT,traits>::operator>>(float& n)
453
 
        {
454
 
                sentry(*this);
455
 
                __istream_readin<traits, charT, float>::readin(*this, n);
456
 
                return *this;
457
 
        }
458
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& 
459
 
                basic_istream<charT,traits>::operator>>(double& n)
460
 
        {
461
 
                sentry(*this);
462
 
                __istream_readin<traits, charT, double>::readin(*this, n);
463
 
                return *this;
464
 
        }
465
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& 
466
 
                basic_istream<charT,traits>::operator>>(long double& n)
467
 
        {
468
 
                sentry(*this);
469
 
                __istream_readin<traits, charT, long double>::readin(*this, n);
470
 
                return *this;
471
 
        }
472
 
#endif
473
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& 
474
 
                basic_istream<charT,traits>::operator>>(void *& n)
475
 
        {
476
 
                sentry(*this);
477
 
                __istream_readin<traits, charT, void*>::readin(*this, n);
478
 
                return *this;
479
 
        }
480
 
 
481
 
        template<class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
482
 
                operator>>(basic_istream<charT,traits>& is, charT& c)
483
 
        {
484
 
                typename basic_istream<charT,traits>::sentry s(is);
485
 
                is.get(c);
486
 
                return is;
487
 
        }
488
 
 
489
 
        template<class traits> _UCXXEXPORT basic_istream<char,traits>&
490
 
                operator>>(basic_istream<char,traits>& is, unsigned char& c)
491
 
        {
492
 
                typename basic_istream<char,traits>::sentry s(is);
493
 
                char b;
494
 
                is.get(b);
495
 
                c = b;
496
 
                return is;
497
 
        }
498
 
        template<class traits> _UCXXEXPORT basic_istream<char,traits>&
499
 
                operator>>(basic_istream<char,traits>& is, signed char& c)
500
 
        {
501
 
                typename basic_istream<char,traits>::sentry s(is);
502
 
                is.get(c);
503
 
                return is;
504
 
        }
505
 
 
506
 
        template<class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
507
 
                operator>>(basic_istream<charT,traits>& is, charT* c)
508
 
        {
509
 
                typename basic_istream<charT,traits>::sentry s(is);
510
 
                int n = is.width();
511
 
                if(n == 0){
512
 
                        n = __STRING_MAX_UNITS;
513
 
                }
514
 
                is.get(c, n);
515
 
                return is;
516
 
 
517
 
        }
518
 
        template<class traits> _UCXXEXPORT basic_istream<char,traits>&
519
 
                operator>>(basic_istream<char,traits>& is, unsigned char* c)
520
 
        {
521
 
                typename basic_istream<char,traits>::sentry s(is);
522
 
                int n = is.width();
523
 
                if(n == 0){
524
 
                        n = __STRING_MAX_UNITS;
525
 
                }
526
 
                is.get(c, n);
527
 
                return is;
528
 
        }
529
 
        template<class traits> _UCXXEXPORT basic_istream<char,traits>&
530
 
                operator>>(basic_istream<char,traits>& is, signed char* c)
531
 
        {
532
 
                typename basic_istream<char,traits>::sentry s(is);
533
 
                int n = is.width();
534
 
                if(n == 0){
535
 
                        n = __STRING_MAX_UNITS;
536
 
                }
537
 
                is.get(c, n);
538
 
                return is;
539
 
        }
540
 
 
541
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& 
542
 
                basic_istream<charT,traits>::operator>>(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
543
 
        {
544
 
                sentry(*this);
545
 
                pf(*this);
546
 
                return *this;
547
 
        }
548
 
 
549
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& 
550
 
                basic_istream<charT,traits>::operator>>(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&))
551
 
        {
552
 
                sentry(*this);
553
 
                pf(*this);
554
 
                return *this;
555
 
        }
556
 
 
557
 
        template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
558
 
                ws(basic_istream<charT,traits>& is)
559
 
        {
560
 
                __skipws(is);
561
 
                return is;
562
 
        }
563
 
 
564
 
 
565
 
#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
566
 
#ifndef __UCLIBCXX_COMPILE_ISTREAM__
567
 
 
568
 
 
569
 
        template <> _UCXXEXPORT istream & basic_istream<char, char_traits<char> >::get(char & c);
570
 
        template <> _UCXXEXPORT istream::int_type basic_istream<char, char_traits<char> >::get();
571
 
 
572
 
        template <> _UCXXEXPORT istream & istream::operator>>(bool &n);
573
 
        template <> _UCXXEXPORT istream & istream::operator>>(short &n);
574
 
        template <> _UCXXEXPORT istream & istream::operator>>(unsigned short &n);
575
 
        template <> _UCXXEXPORT istream & istream::operator>>(int &n);
576
 
        template <> _UCXXEXPORT istream & istream::operator>>(unsigned int &n);
577
 
        template <> _UCXXEXPORT istream & istream::operator>>(long unsigned &n);
578
 
        template <> _UCXXEXPORT istream & istream::operator>>(long int &n);
579
 
        template <> _UCXXEXPORT istream & istream::operator>>(void *& p);
580
 
 
581
 
#ifdef __UCLIBCXX_HAS_FLOATS__
582
 
        template <> _UCXXEXPORT istream & istream::operator>>(float &f);
583
 
        template <> _UCXXEXPORT istream & istream::operator>>(double &f);
584
 
        template <> _UCXXEXPORT istream & istream::operator>>(long double &f);
585
 
#endif
586
 
 
587
 
        template <> _UCXXEXPORT istream & operator>>(istream & is, char & c);
588
 
 
589
 
        template <> _UCXXEXPORT void __skipws(basic_istream<char,char_traits<char> >& is);
590
 
 
591
 
#endif
592
 
#endif
593
 
        
594
 
 
595
 
 
596
 
}
597
 
 
598
 
#pragma GCC visibility pop
599
 
 
600
 
#endif
601