/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: 2012-02-25 14:54:33 UTC
  • Revision ID: edam@waxworlds.org-20120225145433-kih8qs45x05cum46
removed Bounce library and updated/fixed new 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