Chameleon

Chameleon Commit Details

Date:2012-10-27 07:24:14 (7 years 3 months ago)
Author:Evan Lojewski
Commit:2088
Parents: 2087
Message:Update uClibcxx to support clang
Changes:
M/trunk/i386/modules/uClibcxx/include/iterator
M/trunk/i386/modules/uClibcxx/include/bitset
M/trunk/i386/modules/uClibcxx/include/iosfwd
M/trunk/i386/modules/uClibcxx/include/ostream_helpers
M/trunk/i386/modules/uClibcxx/include/iomanip
M/trunk/i386/modules/uClibcxx/include/limits
M/trunk/i386/modules/uClibcxx/include/numeric
M/trunk/i386/modules/uClibcxx/include/functional
M/trunk/i386/modules/uClibcxx/include/deque
M/trunk/i386/modules/uClibcxx/include/stdexcept
M/trunk/i386/modules/uClibcxx/include/utility
M/trunk/i386/modules/uClibcxx/include/associative_base
M/trunk/i386/modules/uClibcxx/include/string
M/trunk/i386/modules/uClibcxx/include/type_traits
M/trunk/i386/modules/uClibcxx/include/func_exception
M/trunk/i386/modules/uClibcxx/include/basic_definitions
M/trunk/i386/modules/uClibcxx/include/cstddef
M/trunk/i386/modules/uClibcxx/include/map
M/trunk/i386/modules/uClibcxx/include/cwctype
M/trunk/i386/modules/uClibcxx/include/valarray
M/trunk/i386/modules/uClibcxx/include/iostream
M/trunk/i386/modules/uClibcxx/include/queue
M/trunk/i386/modules/uClibcxx/include/streambuf
M/trunk/i386/modules/uClibcxx/include/new
M/trunk/i386/modules/uClibcxx/include/unwind-cxx.h
M/trunk/i386/modules/uClibcxx/include/ios
M/trunk/i386/modules/uClibcxx/include/set
M/trunk/i386/modules/uClibcxx/include/locale
M/trunk/i386/modules/uClibcxx/include/fstream
M/trunk/i386/modules/uClibcxx/include/ctime
M/trunk/i386/modules/uClibcxx/include/vector
M/trunk/i386/modules/uClibcxx/include/char_traits
M/trunk/i386/modules/uClibcxx/string.cpp
M/trunk/i386/modules/uClibcxx/include/istream
M/trunk/i386/modules/uClibcxx/include/stack
M/trunk/i386/modules/uClibcxx/include/memory
M/trunk/i386/modules/uClibcxx/include/string_iostream
M/trunk/i386/modules/uClibcxx/include/ostream
M/trunk/i386/modules/uClibcxx/include/list
M/trunk/i386/modules/uClibcxx/include/sstream
M/trunk/i386/modules/uClibcxx/include/csignal
M/trunk/i386/modules/uClibcxx/include/iterator_base
M/trunk/i386/modules/uClibcxx/include/istream_helpers
M/trunk/i386/modules/uClibcxx/include/algorithm
M/trunk/i386/modules/uClibcxx/include/cstdarg

File differences

trunk/i386/modules/uClibcxx/include/iostream
2929
3030
3131
32
33
34
35
3632
3733
3834
......
9894
9995
10096
101
102
10397
104
105
#include <fstream>
#include <string_iostream>
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
#ifdef __UCLIBCXX_SUPPORT_CIN__
extern istream cin;
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/cstdarg
4343
4444
4545
46
47
4846
4947
5048
#ifndef _CPP_CSTDARG
#define _CPP_CSTDARG 1
#pragma GCC system_header
#include <stdarg.h>
// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
trunk/i386/modules/uClibcxx/include/unwind-cxx.h
3838
3939
4040
41
41
4242
43
44
45
46
4743
4844
4945
......
137133
138134
139135
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164136
165137
166138
......
179151
180152
181153
182
183
184
185
186154
#include <typeinfo>
#include <exception>
#include <cstddef>
#include "unwind.h"
//#include <unwind.h>
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace __cxxabiv1
{
// The current installed user handlers.
extern std::terminate_handler __terminate_handler;
extern std::unexpected_handler __unexpected_handler;
// These are explicitly GNU C++ specific.
// This is the exception class we report -- "GNUCC++\0".
const _Unwind_Exception_Class __gxx_exception_class
= ((((((((_Unwind_Exception_Class) 'G'
<< 8 | (_Unwind_Exception_Class) 'N')
<< 8 | (_Unwind_Exception_Class) 'U')
<< 8 | (_Unwind_Exception_Class) 'C')
<< 8 | (_Unwind_Exception_Class) 'C')
<< 8 | (_Unwind_Exception_Class) '+')
<< 8 | (_Unwind_Exception_Class) '+')
<< 8 | (_Unwind_Exception_Class) '\0');
// GNU C++ personality routine, Version 0.
extern "C" _Unwind_Reason_Code __gxx_personality_v0
(int, _Unwind_Action, _Unwind_Exception_Class,
struct _Unwind_Exception *, struct _Unwind_Context *);
// GNU C++ sjlj personality routine, Version 0.
extern "C" _Unwind_Reason_Code __gxx_personality_sj0
(int, _Unwind_Action, _Unwind_Exception_Class,
struct _Unwind_Exception *, struct _Unwind_Context *);
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
// Acquire the C++ exception header from the C++ object.
#endif
} /* namespace __cxxabiv1 */
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif // _UNWIND_CXX_H
trunk/i386/modules/uClibcxx/include/iomanip
2323
2424
2525
26
27
28
29
3026
3127
3228
......
166162
167163
168164
169
170
171165
172166
173
174
#ifndef __STD_IOMANIP
#define __STD_IOMANIP 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
// These are the helper classes which we are going to be using to
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/numeric
2323
2424
2525
26
27
28
29
3026
3127
3228
......
157153
158154
159155
160
161
162156
163157
164
165
#ifndef __STD_NUMERIC_HEADER
#define __STD_NUMERIC_HEADER 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
template <class InputIterator, class T> _UCXXEXPORT
T accumulate(InputIterator first, InputIterator last, T init)
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/utility
2424
2525
2626
27
28
29
30
3127
3228
3329
......
8581
8682
8783
88
89
90
91
9284
#ifndef __STD_HEADER_UTILITY
#define __STD_HEADER_UTILITY 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
namespace rel_ops {
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif//__STD_HEADER_UTILITY
trunk/i386/modules/uClibcxx/include/type_traits
2525
2626
2727
28
29
30
31
3228
3329
3430
......
8884
8985
9086
91
92
9387
9488
95
96
#ifndef __HEADER_TYPE_TRAITS
#define __HEADER_TYPE_TRAITS 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
struct _UCXXEXPORT __true_type{};
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/memory
2727
2828
2929
30
31
32
33
3430
3531
3632
......
192188
193189
194190
195
196
197191
198192
199
200
#ifndef HEADER_STD_MEMORY
#define HEADER_STD_MEMORY 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
template <class T> class allocator;
}//namespace std
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/cstddef
4343
4444
4545
46
47
48
49
5046
5147
5248
#ifndef _CPP_CSTDDEF
#define _CPP_CSTDDEF 1
#ifdef __GCC__
#pragma GCC system_header
#endif
#include <stddef.h>
namespace std
trunk/i386/modules/uClibcxx/include/map
2929
3030
3131
32
33
34
35
3632
3733
3834
......
256252
257253
258254
259
260
261255
262256
263
264
265257
#ifndef __STD_HEADER_MAP
#define __STD_HEADER_MAP
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/iterator
2828
2929
3030
31
32
33
34
3531
3632
3733
......
166162
167163
168164
169
165
170166
171167
172168
......
224220
225221
226222
227
228
229223
230224
231
232225
233
#ifndef __STD_HEADER_ITERATOR
#define __STD_HEADER_ITERATOR 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
// subclause _lib.stream.iterators_, stream iterators:
}
bool equal(const istreambuf_iterator& b) const{
return sbuf == b.sbuf || is_eof() && b.is_eof();
return sbuf == b.sbuf || (is_eof() && b.is_eof());
}
private:
streambuf_type* sbuf;
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/bitset
2727
2828
2929
30
31
32
33
3430
3531
3632
......
419415
420416
421417
422
423
424418
425419
426
427
#ifndef __STD_BITSET_HEADER
#define __STD_BITSET_HEADER 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
template <size_t N> class bitset;
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/set
2828
2929
3030
31
32
33
34
3531
3632
3733
......
402398
403399
404400
405
406
407401
408402
409
410
411403
#ifndef __STD_HEADER_SET
#define __STD_HEADER_SET
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/iosfwd
2525
2626
2727
28
29
30
31
3228
3329
34
30
3531
3632
3733
......
111107
112108
113109
114
115
116110
117
118
#ifndef __HEADER_STD_IOSFWD
#define __HEADER_STD_IOSFWD 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std {
class ios_base;
template<> class char_traits<char>;
template<> struct char_traits<char>;
#ifdef __UCLIBCXX_HAS_WCHAR__
template<> class char_traits<wchar_t>;
#endif
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/limits
2323
2424
2525
26
27
28
29
3026
3127
3228
......
612608
613609
614610
615
616
617611
618
619
//#warning limits header is nowhere complete or accurate
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
enum float_round_style{
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/functional
2121
2222
2323
24
25
26
27
2824
2925
3026
......
4844
4945
5046
51
47
5248
53
49
5450
5551
5652
......
433429
434430
435431
436
437
438432
439433
440
441434
442435
443
#include <basic_definitions>
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
template <class Arg, class Result> struct unary_function;
template <class T> struct logical_or;
template <class T> struct logical_not;
template <class Predicate> struct unary_negate;
template <class Predicate> class unary_negate;
template <class Predicate> unary_negate<Predicate> not1(const Predicate&);
template <class Predicate> struct binary_negate;
template <class Predicate> class binary_negate;
template <class Predicate> binary_negate<Predicate> not2(const Predicate&);
return binary_compose<Op1, Op2, Op3>(fn1, fn2, fn3);
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/istream
2626
2727
2828
29
30
31
32
3329
3430
3531
......
10096
10197
10298
103
99
104100
105
101
106102
107103
108104
109105
110106
111
107
112108
113109
114110
......
132128
133129
134130
135
131
136132
137
133
138134
139135
140136
141137
142138
143139
144
140
145141
146142
147143
......
167163
168164
169165
170
166
171167
172
168
173169
174170
175171
176172
177173
178174
179
175
180176
181177
182178
......
196192
197193
198194
199
195
200196
201197
202198
......
213209
214210
215211
216
212
217213
218214
219215
......
227223
228224
229225
230
231
226
227
232228
233229
234230
......
243239
244240
245241
246
242
247243
248244
249245
250246
251247
252
248
253249
254250
255251
......
272268
273269
274270
275
271
276272
277273
278274
279
275
280276
281277
282278
283
279
284280
285281
286282
......
289285
290286
291287
292
288
293289
294290
295291
296
292
297293
298294
299295
300
296
301297
302298
303299
......
308304
309305
310306
311
307
312308
313309
314310
......
342338
343339
344340
345
341
346342
347343
348344
......
374370
375371
376372
377
373
378374
379375
380376
......
388384
389385
390386
391
392
387
388
393389
394390
395391
......
597593
598594
599595
600
601
602596
603597
604
605
#ifndef __STD_HEADER_ISTREAM
#define __STD_HEADER_ISTREAM 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
typedef basic_istream<char> istream;
basic_ios<charT, traits>::mstreambuf->sbumpc();
if(c == traits::eof() ){
if(i==0){
basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
}else{
basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
}
break;
}
if(c == delim){
if(i==0){
basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
}
basic_ios<charT, traits>::mstreambuf->sputbackc(c);
break;
c = basic_ios<charT, traits>::mstreambuf->sgetc();
if(c == traits::eof()){
if(i==0){
basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
}else{
basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
}
count_last_ufmt_input = i;
return *this;
}
if(c == delim){
if(i==0){
basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
}
count_last_ufmt_input = i;
return *this;
c = basic_ios<charT, traits>::mstreambuf->sgetc();
if(c == traits::eof() ){
if( basic_ios<charT,traits>::eof() ){
basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
}else{
basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
}
count_last_ufmt_input = i;
s[i] = traits::eos();
return *this;
}
if(basic_ios<charT, traits>::mstreambuf->sbumpc()==traits::eof() ){
basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
}
if(c == delim){
count_last_ufmt_input = i+1;
for(i=0;i<n;++i){
c = basic_ios<charT, traits>::mstreambuf->sgetc();
if(c == traits::eof()){
basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
return *this;
}
basic_ios<charT, traits>::mstreambuf->sbumpc();
}else{
int_type c = basic_ios<charT, traits>::mstreambuf->sgetc();
if(c == traits::eof()){
basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
}
return basic_ios<charT, traits>::mstreambuf->sgetc();
}
c = basic_ios<charT, traits>::mstreambuf->sgetc();
if(c == traits::eof()){
basic_ios<charT,traits>::setstate(ios_base::failbit);
basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
count_last_ufmt_input = i;
return *this;
}
sentry(*this, true);
if(!basic_ios<charT,traits>::good()){
count_last_ufmt_input = 0;
basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
return 0;
}
if( basic_ios<charT, traits>::mstreambuf->in_avail() == -1){
count_last_ufmt_input=0;
basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
return 0;
}
_UCXXEXPORT basic_istream<charT,traits>& putback(char_type c){
sentry(*this, true);
if(!basic_ios<charT,traits>::good()){
basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
return *this;
}
if(basic_ios<charT, traits>::mstreambuf == 0){
basic_ios<charT,traits>::setstate(ios_base::badbit);
//basic_ios<charT,traits>::setstate(ios_base::badbit);
return *this;
}
if(basic_ios<charT, traits>::mstreambuf->sputbackc(c) == traits::eof()){
basic_ios<charT,traits>::setstate(ios_base::badbit);
//basic_ios<charT,traits>::setstate(ios_base::badbit);
return *this;
}
return *this;
_UCXXEXPORT basic_istream<charT,traits>& unget(){
sentry(*this, true);
if(!basic_ios<charT,traits>::good()){
basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
return *this;
}
if(basic_ios<charT, traits>::mstreambuf == 0){
basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
return *this;
}
if(basic_ios<charT, traits>::mstreambuf->sungetc() == traits::eof()){
basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
}
return *this;
}
return -1;
}
if(basic_ios<charT, traits>::mstreambuf->pubsync() == -1){
basic_ios<charT,traits>::setstate(ios_base::badbit);
//basic_ios<charT,traits>::setstate(ios_base::badbit);
return traits::eof();
}
return 0;
};
template <class charT,class traits = char_traits<charT> > class _UCXXEXPORT basic_istream<charT,traits>::sentry {
template <class charT,class traits /*= char_traits<charT>*/ > class _UCXXEXPORT basic_istream<charT,traits>::sentry {
bool ok;
public:
explicit _UCXXEXPORT sentry(basic_istream<charT,traits>& os, bool noskipws = false){
int_type retval = basic_ios<charT, traits>::mstreambuf->sgetc();
if(retval == traits::eof()){
count_last_ufmt_input = 0;
basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
}else{
count_last_ufmt_input = 1;
basic_ios<charT, traits>::mstreambuf->sbumpc();
int_type retval = basic_ios<charT, traits>::mstreambuf->sgetc();
if(retval == traits::eof()){
count_last_ufmt_input = 0;
basic_ios<charT,traits>::setstate(ios_base::eofbit);
basic_ios<charT,traits>::setstate(ios_base::failbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::failbit);
}else{
count_last_ufmt_input = 1;
c = traits::to_char_type(retval);
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/stack
2121
2222
2323
24
25
26
27
2824
2925
3026
......
7975
8076
8177
82
83
8478
8579
86
8780
88
#ifndef __HEADER_STD_STACK
#define __HEADER_STD_STACK 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
template <class T, class Container = deque<T> > class _UCXXEXPORT stack{
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/string
3333
3434
3535
36
37
38
39
4036
4137
4238
......
428424
429425
430426
431
427
432428
433429
434430
......
458454
459455
460456
461
457
462458
463459
464460
......
474470
475471
476472
477
473
478474
479475
480476
......
487483
488484
489485
490
486
491487
492488
493489
......
505501
506502
507503
508
504
509505
510506
511507
......
517513
518514
519515
520
516
521517
522518
523519
......
536532
537533
538534
539
535
540536
541537
542538
......
10191015
10201016
10211017
1022
1018
10231019
10241020
10251021
1026
1022
10271023
10281024
10291025
......
10391035
10401036
10411037
1042
1043
10441038
1045
1046
#ifndef __HEADER_STD_STRING
#define __HEADER_STD_STRING 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
//Basic basic_string
}
_UCXXEXPORT size_type find (Ch c, size_type pos = 0) const{
for(size_type i = pos; i < length(); ++i){
if(operator[](i) == c){
if(this->operator[](i) == c){
return i;
}
}
_UCXXEXPORT size_type find_first_of(const basic_string& str, size_type pos = 0) const{
for(size_type i = pos; i < length(); ++i){
for(size_type j = 0; j < str.length() ; ++j){
if( Tr::eq(str[j], operator[](i)) ){
if( Tr::eq(str[j], this->operator[](i)) ){
return i;
}
}
}
_UCXXEXPORT size_type find_first_of(Ch c, size_type pos = 0) const{
for(size_type i = pos; i< length(); ++i){
if( Tr::eq(operator[](i), c) ){
if( Tr::eq(this->operator[](i), c) ){
return i;
}
}
}
for(size_type i = pos; i >0 ; --i){
for(size_type j = 0 ; j < str.length(); ++j){
if( Tr::eq(operator[](i-1), str[j]) ){
if( Tr::eq(this->operator[](i-1), str[j]) ){
return i-1;
}
}
pos = length();
}
for(size_type i = pos; i >0 ; --i){
if( Tr::eq(operator[](i-1), c) ){
if( Tr::eq(this->operator[](i-1), c) ){
return i-1;
}
}
for(size_type i = pos; i < length(); ++i){
foundCharacter = false;
for(size_type j = 0; j < str.length() ; ++j){
if( Tr::eq(str[j], operator[](i)) ){
if( Tr::eq(str[j], this->operator[](i)) ){
foundCharacter = true;
}
}
}
_UCXXEXPORT size_type find_first_not_of(Ch c, size_type pos = 0) const{
for(size_type i = pos; i < length() ; ++i){
if(operator[](i) != c){
if(this->operator[](i) != c){
return i;
}
}
template <> _UCXXEXPORT bool operator==(const string & lhs, const string & rhs);
template <> _UCXXEXPORT bool operator==(const char * lhs, const string & rhs);
template <> _UCXXEXPORT bool operator==(const string & rhs, const char * rhs);
template <> _UCXXEXPORT bool operator==(const string & lhs, const char * rhs);
template <> _UCXXEXPORT bool operator!=(const string & lhs, const string & rhs);
template <> _UCXXEXPORT bool operator!=(const char * lhs, const string & rhs);
template <> _UCXXEXPORT bool operator!=(const string & rhs, const char * rhs);
template <> _UCXXEXPORT bool operator!=(const string & lhs, const char * rhs);
template <> _UCXXEXPORT string operator+(const string & lhs, const char* rhs);
template <> _UCXXEXPORT string operator+(const char* lhs, const string & rhs);
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/ostream
2727
2828
2929
30
31
32
33
3430
3531
3632
......
9389
9490
9591
96
92
9793
9894
9995
......
10298
10399
104100
105
101
106102
107103
108104
109105
110106
111
107
112108
113109
114110
......
233229
234230
235231
236
232
237233
238234
239235
......
277273
278274
279275
280
276
281277
282278
283279
......
479475
480476
481477
482
483
484478
485479
486
487
#include <cstdio>
#include <ostream_helpers>
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std {
template <class charT, class traits > class basic_ostream;
typedef basic_ostream<char> ostream;
basic_ios<charT, traits>::mstreambuf->sputc(c),
basic_ostream<charT,traits>::traits_type::eof()))
{
basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
}
return *this;
}
basic_ios<charT, traits>::mstreambuf->sputn(s, n),
basic_ostream<charT,traits>::traits_type::eof())
){
basic_ios<charT,traits>::setstate(ios_base::eofbit);
//basic_ios<charT,traits>::setstate(ios_base::eofbit);
}
return *this;
}
_UCXXEXPORT basic_ostream<charT,traits>& flush(){
if(basic_ios<charT, traits>::mstreambuf->pubsync() == -1){
basic_ios<charT,traits>::setstate(ios_base::badbit);
//basic_ios<charT,traits>::setstate(ios_base::badbit);
}
return *this;
}
{
sentry s(*this);
if(sb == 0){
basic_ios<charT,traits>::setstate(ios_base::badbit);
//basic_ios<charT,traits>::setstate(ios_base::badbit);
return *this;
}
#endif
#endif
template <class charT,class traits = char_traits<charT> >
template <class charT,class traits/* = char_traits<charT>*/ >
class _UCXXEXPORT basic_ostream<charT,traits>::sentry
{
bool ok;
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/sstream
2929
3030
3131
32
33
3432
3533
3634
......
376374
377375
378376
379
380
381377
382378
383379
#include <iostream>
#include <string>
#pragma GCC visibility push(default)
namespace std{
template <class charT, class traits, class Allocator>
#endif
#endif
#pragma GCC visibility pop
}
trunk/i386/modules/uClibcxx/include/csignal
4444
4545
4646
47
48
4947
5048
5149
#ifndef _CPP_CSIGNAL
#define _CPP_CSIGNAL 1
#pragma GCC system_header
#include <signal.h>
// Get rid of those macros defined in <signal.h> in lieu of real functions.
trunk/i386/modules/uClibcxx/include/valarray
2525
2626
2727
28
29
30
31
3228
3329
3430
......
993989
994990
995991
996
997
998992
999
1000
#include <cstddef>
#include <cmath>
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
template<class T> class valarray;
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/iterator_base
2222
2323
2424
25
26
27
28
2925
3026
3127
......
300296
301297
302298
303
304
305299
306300
307
308301
309
#ifndef __STD_HEADER_ITERATOR_BASE
#define __STD_HEADER_ITERATOR_BASE 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
template<class Iterator> struct iterator_traits;
template<class T> struct iterator_traits<T*>;
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/algorithm
2727
2828
2929
30
31
32
33
3430
3531
3632
......
16891685
16901686
16911687
1692
1693
16941688
16951689
1696
16971690
16981691
1699
#undef min
#undef max
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
// subclause _lib.alg.nonmodifying_, non-modifying sequence operations:
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/istream_helpers
2525
2626
2727
28
29
30
31
3228
3329
3430
......
5854
5955
6056
61
62
57
58
6359
6460
6561
......
7874
7975
8076
81
82
77
78
8379
8480
8581
......
333329
334330
335331
336
332
337333
338334
339335
340336
341
342
343337
344338
345
346339
347340
348
#ifndef __STD_HEADER_ISTREAM_HELPERS
#define __STD_HEADER_ISTREAM_HELPERS 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
break;
}
}
if (temp.size() == 0)
stream.setstate(ios_base::eofbit|ios_base::failbit);
//if (temp.size() == 0)
//stream.setstate(ios_base::eofbit|ios_base::failbit);
return temp;
}
break;
}
}
if (temp.size() == 0)
stream.setstate(ios_base::eofbit|ios_base::failbit);
//if (temp.size() == 0)
//stream.setstate(ios_base::eofbit|ios_base::failbit);
return temp;
}
is.rdbuf()->sbumpc();
}
if(traits::eq_int_type(c, eof)){
is.setstate(ios_base::eofbit);
//is.setstate(ios_base::eofbit);
}
}
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/ostream_helpers
2121
2222
2323
24
2425
2526
2627
2728
2829
29
30
31
32
3330
3431
3532
......
484481
485482
486483
487
488
489484
490485
491
492486
493487
494
#include <cstddef>
#include <ios>
#include <cctype>
#include <cstdio>
#include <string>
#ifndef __STD_HEADER_OSTREAM_HELPERS
#define __STD_HEADER_OSTREAM_HELPERS 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
/* We are making the following template class for serveral reasons. Firstly,
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/locale
2424
2525
2626
27
28
29
30
3127
3228
3329
......
8076
8177
8278
83
84
8579
86
87
#ifndef __HEADER_STD_LOCALE
#define __HEADER_STD_LOCALE 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
class _UCXXEXPORT locale {
public:
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/vector
2929
3030
3131
32
33
34
35
3632
3733
3834
......
513509
514510
515511
516
517
518512
519513
520
521
#ifndef __STD_HEADER_VECTOR
#define __STD_HEADER_VECTOR
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
template <class T, class Allocator = allocator<T> > class vector;
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/deque
2121
2222
2323
24
25
26
27
2824
2925
3026
......
804800
805801
806802
807
808
809803
810804
811
812805
813806
814807
815
#include <iterator>
#include <stdexcept>
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
#ifndef __STD_HEADER_DEQUE
#define __STD_HEADER_DEQUE
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/stdexcept
2727
2828
2929
30
31
3230
3331
3432
......
111109
112110
113111
114
115
116112
117113
//Don't include support if not needed
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
#pragma GCC visibility push(default)
namespace std{
//typedef basic_string<char> string;
}
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/list
2424
2525
2626
27
28
29
30
3127
3228
3329
......
6460
6561
6662
67
68
69
70
71
72
73
74
75
76
77
78
63
7964
8065
8166
......
549534
550535
551536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
552551
553552
554553
......
922921
923922
924923
925
926
927924
928925
929
930926
931
#ifndef __STD_HEADER_LIST
#define __STD_HEADER_LIST 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
template <class T, class Allocator = allocator<T> > class _UCXXEXPORT list {
list(const list<T,Allocator>& x);
~list();
list<T,Allocator>& operator=(const list<T,Allocator>& x){
if(&x == this){
return *this;
}
clear();
iterator i = x.begin();
while(i != x.end()){
push_back(*i);
++i;
}
return *this;
}
list<T,Allocator>& operator=(const list<T,Allocator>& x);
template <class InputIterator> void assign(InputIterator first, InputIterator last);
template <class Size, class U> void assign(Size n, const U& u = U());
}
}
template<class T, class Allocator> list<T,Allocator>& list<T, Allocator>:: operator=(const list<T,Allocator>& x){
if(&x == this){
return *this;
}
clear();
iterator i = x.begin();
while(i != x.end()){
push_back(*i);
++i;
}
return *this;
}
template<class T, class Allocator>
void list<T, Allocator>::splice(iterator position, list<T,Allocator>& x)
{
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/basic_definitions
2020
2121
2222
23
24
25
26
2723
2824
2925
......
5652
5753
5854
59
60
6155
6256
63
6457
65
6658
6759
6860
#include <system_configuration.h>
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
//The following is used to support GCC symbol visibility patch
#ifdef GCC_HASCLASSVISIBILITY
typedef signed long int streamsize;
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
#ifdef __DODEBUG__
#define UCLIBCXX_DEBUG 1
#else
trunk/i386/modules/uClibcxx/include/cwctype
4444
4545
4646
47
48
4947
5048
5149
#ifndef _CPP_CWCTYPE
#define _CPP_CWCTYPE 1
#pragma GCC system_header
//#include <bits/c++config.h>
#ifdef __UCLIBCXX_HAS_WCHAR__
trunk/i386/modules/uClibcxx/include/queue
2323
2424
2525
26
27
28
29
3026
3127
3228
......
121117
122118
123119
124
125
126120
127121
128
129122
130
#ifndef __HEADER_STD_QUEUE
#define __HEADER_STD_QUEUE 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
template <class T, class Container = deque<T> > class _UCXXEXPORT queue{
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/streambuf
2727
2828
2929
30
31
32
33
3430
3531
3632
......
326322
327323
328324
329
330
331325
332
333
#include <ios>
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
template <class charT, class traits> class _UCXXEXPORT basic_streambuf{
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/new
2424
2525
2626
27
28
29
30
3127
3228
3329
......
6056
6157
6258
63
64
6559
6660
67
68
#ifndef __STD_NEW_OPERATOR
#define __STD_NEW_OPERATOR 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
class _UCXXEXPORT bad_alloc : public exception {};
inline void* operator new[](std::size_t, void *p) throw() { return p; }
inline void operator delete[](void* , void *) throw() {}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/ios
2525
2626
2727
28
29
30
31
3228
3329
3430
......
497493
498494
499495
500
501
502496
503497
504
505
#ifndef __HEADER_STD_IOS
#define __HEADER_STD_IOS 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
typedef signed long int streamoff;
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/fstream
3939
4040
4141
42
43
4442
4543
4644
......
671669
672670
673671
674
675
676672
677673
678674
#include <cwctype>
#endif //__UCLIBCXX_HAS_WCHAR__
#pragma GCC visibility push(default)
namespace std{
template <class C, class T> class basic_filebuf;
}
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/ctime
4444
4545
4646
47
48
4947
5048
5149
#ifndef _CPP_CTIME
#define _CPP_CTIME 1
#pragma GCC system_header
#include <cstddef>
#include <time.h>
trunk/i386/modules/uClibcxx/include/char_traits
2121
2222
2323
24
25
26
27
2824
2925
3026
......
105101
106102
107103
108
109
104
105
110106
111107
112108
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195109
196110
197111
#include <exception>
#include <memory>
#ifdef __UCLIBCXX_HAS_WCHAR__
#include <cwchar>
#include <cwctype>
#endif
#ifndef __HEADER_CHAR_TRAITS
#define __HEADER_CHAR_TRAITS 1
}
}
static state_type get_state(pos_type p){
p = p;
state_type a;
//p = p;
state_type a = 0;
return a;
}
};
#ifdef __UCLIBCXX_HAS_WCHAR__
template<> struct _UCXXEXPORT char_traits<wchar_t> {
typedef wchar_t char_type;
typedef wint_t int_type;
typedef char_traits_off_type off_type;
typedef char_traits_off_type pos_type;
typedef mbstate_t state_type;
static void assign(char_type & c, const char_type & d){ c=d; }
static char_type to_char_type(const int_type & i){
return i;
}
static int_type to_int_type(const char_type & c){
return c;
}
inline static bool eq_int_type(const int_type & a, const int_type & b){
if(a==b){
return true;
}
return false;
}
inline static bool eq(const char_type& c1, const char_type& c2){
if(wcsncmp(&c1, &c2, 1) == 0){
return true;
}
return false;
}
inline static bool lt(const char_type& c1, const char_type& c2){
if(wcsncmp(&c1, &c2, 1) < 0){
return true;
}
return false;
}
inline static char_type* move(char_type* s1, const char_type* s2, size_t n){
return (char_type*) memmove(s1, s2, n * sizeof(char_type));
}
inline static char_type* copy(char_type* s1, const char_type* s2, size_t n){
for(unsigned long int i=0; i< n; ++i){
assign(s1[i], s2[i]);
}
return s1 + n;
}
inline static char_type* assign(char_type* s, size_t n, char_type a){
return (char_type *)memset(s, a, n);/*FIXME*/
}
inline static int compare(const char_type* s1, const char_type* s2, size_t n){
return wcsncmp(s1, s2, n);
}
inline static size_t length(const char_type* s){
return wcslen(s);
}
static const char_type* find(const char_type* s, int n, const char_type& a);
inline static char_type eos() { return 0; }
inline static int_type eof() { return WEOF; }
inline static int_type not_eof(const int_type & i) {
if(i == WEOF){
return (int_type)0;
} else {
return i;
}
}
static state_type get_state(pos_type){
state_type a;
return a;
}
};
#endif
}
#endif
trunk/i386/modules/uClibcxx/include/associative_base
2828
2929
3030
31
32
33
34
3531
3632
3733
......
515511
516512
517513
518
514
519515
520516
521517
......
524520
525521
526522
527
523
528524
529525
530526
......
638634
639635
640636
641
642
643
644
645637
646638
647639
#ifndef __STD_HEADER_ASSOCIATIVE_BASE
#define __STD_HEADER_ASSOCIATIVE_BASE
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
pair<iterator, bool> insert(const value_type& x){
pair<iterator, bool> retval;
iterator location = lower_bound(value_to_key(x));
iterator location = lower_bound(this->value_to_key(x));
retval.second = true;
//Empty list or need to insert at end
if(end() == location){
return retval;
}
//Something in the list
if(c(value_to_key(x), value_to_key(*location))){
if(c(this->value_to_key(x), this->value_to_key(*location))){
location = backing.insert(location.base_iterator(), x);
retval.first = location;
}else{
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif//__STD_HEADER_ASSOCIATIVE_BASE
trunk/i386/modules/uClibcxx/include/func_exception
2424
2525
2626
27
28
29
30
3127
3228
3329
......
3733
3834
3935
40
41
4236
4337
44
45
#ifndef HEADER_IMPLEMENTATION_FUNC_EXCEPTION
#define HEADER_IMPLEMENTATION_FUNC_EXCEPTION
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
_UCXXEXPORT void __throw_bad_alloc();
_UCXXEXPORT void __throw_invalid_argument(const char * message = 0);
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/include/string_iostream
2929
3030
3131
32
33
34
35
3632
3733
3834
......
142138
143139
144140
145
146
147141
148142
149
150
#ifndef __HEADER_STD_STRING_IOSTREAM
#define __HEADER_STD_STRING_IOSTREAM 1
#ifdef __GCC__
#pragma GCC visibility push(default)
#endif
namespace std{
}
#ifdef __GCC__
#pragma GCC visibility pop
#endif
#endif
trunk/i386/modules/uClibcxx/string.cpp
7676
7777
7878
79
79
8080
8181
8282
83
83
8484
8585
8686
template _UCXXEXPORT bool operator==(const string & lhs, const string & rhs);
template _UCXXEXPORT bool operator==(const char * lhs, const string & rhs);
template _UCXXEXPORT bool operator==(const string & rhs, const char * rhs);
template _UCXXEXPORT bool operator==(const string & lhs, const char * rhs);
template _UCXXEXPORT bool operator!=(const string & lhs, const string & rhs);
template _UCXXEXPORT bool operator!=(const char * lhs, const string & rhs);
template _UCXXEXPORT bool operator!=(const string & rhs, const char * rhs);
template _UCXXEXPORT bool operator!=(const string & lhs, const char * rhs);
template _UCXXEXPORT string operator+(const string & lhs, const char* rhs);
template _UCXXEXPORT string operator+(const char* lhs, const string & rhs);

Archive Download the corresponding diff file

Revision: 2088