generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

libcxx initial import

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@103490 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant
2010-05-11 19:42:16 +00:00
commit bc8d3f97eb
3893 changed files with 1209942 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
src/algorithm.cpp Normal file
View File

@@ -0,0 +1,48 @@
//===----------------------- algorithm.cpp --------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "algorithm"
_LIBCPP_BEGIN_NAMESPACE_STD
template void __sort<__less<char>&, char*>(char*, char*, __less<char>&);
template void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&);
template void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&);
template void __sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&);
template void __sort<__less<short>&, short*>(short*, short*, __less<short>&);
template void __sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&);
template void __sort<__less<int>&, int*>(int*, int*, __less<int>&);
template void __sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&);
template void __sort<__less<long>&, long*>(long*, long*, __less<long>&);
template void __sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&);
template void __sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&);
template void __sort<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&);
template void __sort<__less<float>&, float*>(float*, float*, __less<float>&);
template void __sort<__less<double>&, double*>(double*, double*, __less<double>&);
template void __sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&);
template bool __insertion_sort_incomplete<__less<char>&, char*>(char*, char*, __less<char>&);
template bool __insertion_sort_incomplete<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&);
template bool __insertion_sort_incomplete<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&);
template bool __insertion_sort_incomplete<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&);
template bool __insertion_sort_incomplete<__less<short>&, short*>(short*, short*, __less<short>&);
template bool __insertion_sort_incomplete<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&);
template bool __insertion_sort_incomplete<__less<int>&, int*>(int*, int*, __less<int>&);
template bool __insertion_sort_incomplete<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&);
template bool __insertion_sort_incomplete<__less<long>&, long*>(long*, long*, __less<long>&);
template bool __insertion_sort_incomplete<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&);
template bool __insertion_sort_incomplete<__less<long long>&, long long*>(long long*, long long*, __less<long long>&);
template bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&);
template bool __insertion_sort_incomplete<__less<float>&, float*>(float*, float*, __less<float>&);
template bool __insertion_sort_incomplete<__less<double>&, double*>(double*, double*, __less<double>&);
template bool __insertion_sort_incomplete<__less<long double>&, long double*>(long double*, long double*, __less<long double>&);
template unsigned __sort5<__less<long double>&, long double*>(long double*, long double*, long double*, long double*, long double*, __less<long double>&);
_LIBCPP_END_NAMESPACE_STD

31
src/bind.cpp Normal file
View File

@@ -0,0 +1,31 @@
//===-------------------------- bind.cpp ----------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "functional"
_LIBCPP_BEGIN_NAMESPACE_STD
namespace placeholders
{
__ph<1> _1;
__ph<2> _2;
__ph<3> _3;
__ph<4> _4;
__ph<5> _5;
__ph<6> _6;
__ph<7> _7;
__ph<8> _8;
__ph<9> _9;
__ph<10> _10;
} // placeholders
_LIBCPP_END_NAMESPACE_STD

101
src/chrono.cpp Normal file
View File

@@ -0,0 +1,101 @@
//===------------------------- chrono.cpp ---------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "chrono"
#include <sys/time.h> //for gettimeofday and timeval
#include <mach/mach_time.h> // mach_absolute_time, mach_timebase_info_data_t
_LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono
{
// system_clock
system_clock::time_point
system_clock::now()
{
timeval tv;
gettimeofday(&tv, 0);
return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
}
time_t
system_clock::to_time_t(const time_point& t)
{
return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
}
system_clock::time_point
system_clock::from_time_t(time_t t)
{
return system_clock::time_point(seconds(t));
}
// monotonic_clock
// mach_absolute_time() * MachInfo.numer / MachInfo.denom is the number of
// nanoseconds since the computer booted up. MachInfo.numer and MachInfo.denom
// are run time constants supplied by the OS. This clock has no relationship
// to the Gregorian calendar. It's main use is as a high resolution timer.
// MachInfo.numer / MachInfo.denom is often 1 on the latest equipment. Specialize
// for that case as an optimization.
#pragma GCC visibility push(hidden)
static
monotonic_clock::rep
monotonic_simplified()
{
return mach_absolute_time();
}
static
double
compute_monotonic_factor()
{
mach_timebase_info_data_t MachInfo;
mach_timebase_info(&MachInfo);
return static_cast<double>(MachInfo.numer) / MachInfo.denom;
}
static
monotonic_clock::rep
monotonic_full()
{
static const double factor = compute_monotonic_factor();
return static_cast<monotonic_clock::rep>(mach_absolute_time() * factor);
}
typedef monotonic_clock::rep (*FP)();
static
FP
init_monotonic_clock()
{
mach_timebase_info_data_t MachInfo;
mach_timebase_info(&MachInfo);
if (MachInfo.numer == MachInfo.denom)
return &monotonic_simplified;
return &monotonic_full;
}
#pragma GCC visiblity pop
monotonic_clock::time_point
monotonic_clock::now()
{
static FP fp = init_monotonic_clock();
return time_point(duration(fp()));
}
}
_LIBCPP_END_NAMESPACE_STD

64
src/condition_variable.cpp Normal file
View File

@@ -0,0 +1,64 @@
//===-------------------- condition_variable.cpp --------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "condition_variable"
#include "thread"
#include "system_error"
#include "cassert"
_LIBCPP_BEGIN_NAMESPACE_STD
condition_variable::~condition_variable()
{
int e = pthread_cond_destroy(&__cv_);
// assert(e == 0);
}
void
condition_variable::notify_one()
{
pthread_cond_signal(&__cv_);
}
void
condition_variable::notify_all()
{
pthread_cond_broadcast(&__cv_);
}
void
condition_variable::wait(unique_lock<mutex>& lk)
{
if (!lk.owns_lock())
__throw_system_error(EPERM,
"condition_variable::wait: mutex not locked");
int ec = pthread_cond_wait(&__cv_, lk.mutex()->native_handle());
if (ec)
__throw_system_error(ec, "condition_variable wait failed");
}
void
condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
{
using namespace chrono;
if (!lk.owns_lock())
__throw_system_error(EPERM,
"condition_variable::timed wait: mutex not locked");
nanoseconds d = tp.time_since_epoch();
timespec ts;
seconds s = duration_cast<seconds>(d);
ts.tv_sec = static_cast<decltype(ts.tv_sec)>(s.count());
ts.tv_nsec = static_cast<decltype(ts.tv_nsec)>((d - s).count());
int ec = pthread_cond_timedwait(&__cv_, lk.mutex()->native_handle(), &ts);
if (ec != 0 && ec != ETIMEDOUT)
__throw_system_error(ec, "condition_variable timed_wait failed");
}
_LIBCPP_END_NAMESPACE_STD

485
src/hash.cpp Normal file
View File

@@ -0,0 +1,485 @@
//===-------------------------- hash.cpp ----------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "__hash_table"
#include "algorithm"
_LIBCPP_BEGIN_NAMESPACE_STD
namespace {
// handle all next_prime(i) for i in [1, 210), special case 0
const unsigned small_primes[] =
{
0,
2,
3,
5,
7,
11,
13,
17,
19,
23,
29,
31,
37,
41,
43,
47,
53,
59,
61,
67,
71,
73,
79,
83,
89,
97,
101,
103,
107,
109,
113,
127,
131,
137,
139,
149,
151,
157,
163,
167,
173,
179,
181,
191,
193,
197,
199,
211
};
// potential primes = 210*k + indices[i], k >= 1
// these numbers are not divisible by 2, 3, 5 or 7
// (or any integer 2 <= j <= 10 for that matter).
const unsigned indices[] =
{
1,
11,
13,
17,
19,
23,
29,
31,
37,
41,
43,
47,
53,
59,
61,
67,
71,
73,
79,
83,
89,
97,
101,
103,
107,
109,
113,
121,
127,
131,
137,
139,
143,
149,
151,
157,
163,
167,
169,
173,
179,
181,
187,
191,
193,
197,
199,
209
};
}
// Returns: If n == 0, returns 0. Else returns the lowest prime number that
// is greater than or equal to n.
//
// The algorithm creates a list of small primes, plus an open-ended list of
// potential primes. All prime numbers are potential prime numbers. However
// some potential prime numbers are not prime. In an ideal world, all potential
// prime numbers would be prime. Candiate prime numbers are chosen as the next
// highest potential prime. Then this number is tested for prime by dividing it
// by all potential prime numbers less than the sqrt of the candidate.
//
// This implementation defines potential primes as those numbers not divisible
// by 2, 3, 5, and 7. Other (common) implementations define potential primes
// as those not divisible by 2. A few other implementations define potential
// primes as those not divisible by 2 or 3. By raising the number of small
// primes which the potential prime is not divisible by, the set of potential
// primes more closely approximates the set of prime numbers. And thus there
// are fewer potential primes to search, and fewer potential primes to divide
// against.
size_t
__next_prime(size_t n)
{
const size_t L = 210;
const size_t N = sizeof(small_primes) / sizeof(small_primes[0]);
// If n is small enough, search in small_primes
if (n <= small_primes[N-1])
return *std::lower_bound(small_primes, small_primes + N, n);
// Else n > largest small_primes
// Start searching list of potential primes: L * k0 + indices[in]
const size_t M = sizeof(indices) / sizeof(indices[0]);
// Select first potential prime >= n
// Known a-priori n >= L
size_t k0 = n / L;
size_t in = std::lower_bound(indices, indices + M, n % L) - indices;
n = L * k0 + indices[in];
while (true)
{
// Divide n by all primes or potential primes (i) until:
// 1. The division is even, so try next potential prime.
// 2. The i > sqrt(n), in which case n is prime.
// It is known a-priori that n is not divisible by 2, 3, 5 or 7,
// so don't test those (j == 5 -> divide by 11 first). And the
// potential primes start with 211, so don't test against the last
// small prime.
for (size_t j = 5; j < N - 1; ++j)
{
if (n % small_primes[j] == 0)
goto next;
if (n / small_primes[j] < small_primes[j])
return n;
}
// n wasn't divisible by small primes, try potential primes
{
size_t i = 211;
while (true)
{
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 10;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 8;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 8;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 6;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 4;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 2;
if (n % i == 0)
break;
if (n / i < i)
return n;
i += 10;
if (n % i == 0)
break;
if (n / i < i)
return n;
// This will loop i to the next "plane" of potential primes
i += 2;
}
}
next:
// n is not prime. Increment n to next potential prime.
if (++in == M)
{
++k0;
in = 0;
}
n = L * k0 + indices[in];
}
}
_LIBCPP_END_NAMESPACE_STD

492
src/ios.cpp Normal file
View File

@@ -0,0 +1,492 @@
//===-------------------------- ios.cpp -----------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "ios"
#include "streambuf"
#include "istream"
#include "string"
#include "__locale"
#include "algorithm"
#include "memory"
#include "new"
#include "limits"
#include <stdlib.h>
_LIBCPP_BEGIN_NAMESPACE_STD
template class __basic_string_common<true>;
template class basic_string<char>;
template class basic_string<wchar_t>;
template enable_if<__is_forward_iterator<char const*>::value, void>::type
basic_string<char, char_traits<char>, allocator<char> >
::__init<char const*>(char const*, char const*);
template enable_if<__is_forward_iterator<wchar_t const*>::value, void>::type
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >
::__init<wchar_t const*>(wchar_t const*, wchar_t const*);
template
enable_if<__is_forward_iterator<char*>::value,
basic_string<char, char_traits<char>, allocator<char> >&>::type
basic_string<char, char_traits<char>, allocator<char> >::
append<char*>(char*, char*);
template
enable_if<__is_forward_iterator<wchar_t*>::value,
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&>::type
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >::
append<wchar_t*>(wchar_t*, wchar_t*);
template
enable_if<__is_forward_iterator<char const*>::value,
string::iterator>::type
string::
insert<char const*>(string::const_iterator, char const*, char const*);
template
enable_if<__is_forward_iterator<wchar_t const*>::value,
wstring::iterator>::type
wstring::
insert<wchar_t const*>(wstring::const_iterator, wchar_t const*, wchar_t const*);
template
enable_if<__is_input_iterator<char const*>::value, string&>::type
string::
replace<char const*>(string::iterator, string::iterator, char const*, char const*);
template
enable_if<__is_input_iterator<wchar_t const*>::value, wstring&>::type
wstring::
replace<wchar_t const*>(wstring::iterator, wstring::iterator, wchar_t const*, wchar_t const*);
template
enable_if<__is_forward_iterator<wchar_t*>::value, wstring&>::type
wstring::assign<wchar_t*>(wchar_t*, wchar_t*);
template
string
operator+<char, char_traits<char>, allocator<char> >(char const*, string const&);
template class basic_ios<char>;
template class basic_ios<wchar_t>;
template class basic_streambuf<char>;
template class basic_streambuf<wchar_t>;
template class basic_istream<char>;
template class basic_istream<wchar_t>;
template class basic_ostream<char>;
template class basic_ostream<wchar_t>;
template class basic_iostream<char>;
class _LIBCPP_HIDDEN __iostream_category
: public __do_message
{
public:
virtual const char* name() const;
virtual string message(int ev) const;
};
const char*
__iostream_category::name() const
{
return "iostream";
}
string
__iostream_category::message(int ev) const
{
if (ev != static_cast<int>(io_errc::stream) && ev <= ELAST)
return __do_message::message(ev);
return string("unspecified iostream_category error");
}
const error_category&
iostream_category()
{
static __iostream_category s;
return s;
}
// ios_base::failure
ios_base::failure::failure(const string& msg, const error_code& ec)
: system_error(ec, msg)
{
}
ios_base::failure::failure(const char* msg, const error_code& ec)
: system_error(ec, msg)
{
}
ios_base::failure::~failure() throw()
{
}
// ios_base locale
const ios_base::fmtflags ios_base::boolalpha;
const ios_base::fmtflags ios_base::dec;
const ios_base::fmtflags ios_base::fixed;
const ios_base::fmtflags ios_base::hex;
const ios_base::fmtflags ios_base::internal;
const ios_base::fmtflags ios_base::left;
const ios_base::fmtflags ios_base::oct;
const ios_base::fmtflags ios_base::right;
const ios_base::fmtflags ios_base::scientific;
const ios_base::fmtflags ios_base::showbase;
const ios_base::fmtflags ios_base::showpoint;
const ios_base::fmtflags ios_base::showpos;
const ios_base::fmtflags ios_base::skipws;
const ios_base::fmtflags ios_base::unitbuf;
const ios_base::fmtflags ios_base::uppercase;
const ios_base::fmtflags ios_base::adjustfield;
const ios_base::fmtflags ios_base::basefield;
const ios_base::fmtflags ios_base::floatfield;
const ios_base::iostate ios_base::badbit;
const ios_base::iostate ios_base::eofbit;
const ios_base::iostate ios_base::failbit;
const ios_base::iostate ios_base::goodbit;
const ios_base::openmode ios_base::app;
const ios_base::openmode ios_base::ate;
const ios_base::openmode ios_base::binary;
const ios_base::openmode ios_base::in;
const ios_base::openmode ios_base::out;
const ios_base::openmode ios_base::trunc;
void
ios_base::__call_callbacks(event ev)
{
for (size_t i = __event_size_; i;)
{
--i;
__fn_[i](ev, *this, __index_[i]);
}
}
// locale
locale
ios_base::imbue(const locale& newloc)
{
static_assert(sizeof(locale) == sizeof(__loc_), "");
locale& loc_storage = *(locale*)&__loc_;
locale oldloc = loc_storage;
loc_storage = newloc;
__call_callbacks(imbue_event);
return oldloc;
}
locale
ios_base::getloc() const
{
const locale& loc_storage = *(locale*)&__loc_;
return loc_storage;
}
// xalloc
int ios_base::__xindex_ = 0;
int
ios_base::xalloc()
{
return __xindex_++;
}
long&
ios_base::iword(int index)
{
size_t req_size = static_cast<size_t>(index)+1;
if (req_size > __iarray_cap_)
{
size_t newcap;
const size_t mx = std::numeric_limits<size_t>::max();
if (req_size < mx/2)
newcap = max(2 * __iarray_cap_, req_size);
else
newcap = mx;
long* iarray = (long*)realloc(__iarray_, newcap * sizeof(long));
if (iarray == 0)
{
setstate(badbit);
static long error;
error = 0;
return error;
}
__iarray_ = iarray;
for (long* p = __iarray_ + __iarray_size_; __iarray_cap_ < newcap; ++__iarray_cap_, ++p)
*p = 0;
}
__iarray_size_ = max<size_t>(__iarray_size_, req_size);
return __iarray_[index];
}
void*&
ios_base::pword(int index)
{
size_t req_size = static_cast<size_t>(index)+1;
if (req_size > __parray_cap_)
{
size_t newcap;
const size_t mx = std::numeric_limits<size_t>::max();
if (req_size < mx/2)
newcap = max(2 * __parray_cap_, req_size);
else
newcap = mx;
void** parray = (void**)realloc(__parray_, newcap * sizeof(void*));
if (parray == 0)
{
setstate(badbit);
static void* error;
error = 0;
return error;
}
__parray_ = parray;
for (void** p = __parray_ + __parray_size_; __parray_cap_ < newcap; ++__parray_cap_, ++p)
*p = 0;
}
__parray_size_ = max<size_t>(__parray_size_, req_size);
return __parray_[index];
}
// register_callback
void
ios_base::register_callback(event_callback fn, int index)
{
size_t req_size = __event_size_ + 1;
if (req_size > __event_cap_)
{
size_t newcap;
const size_t mx = std::numeric_limits<size_t>::max();
if (req_size < mx/2)
newcap = max(2 * __event_cap_, req_size);
else
newcap = mx;
event_callback* fns = (event_callback*)realloc(__fn_, newcap * sizeof(event_callback));
if (fns == 0)
setstate(badbit);
__fn_ = fns;
int* indxs = (int*)realloc(__index_, newcap * sizeof(int));
if (indxs == 0)
setstate(badbit);
__index_ = indxs;
}
__fn_[__event_size_] = fn;
__index_[__event_size_] = index;
++__event_size_;
}
ios_base::~ios_base()
{
__call_callbacks(erase_event);
locale& loc_storage = *(locale*)&__loc_;
loc_storage.~locale();
free(__fn_);
free(__index_);
free(__iarray_);
free(__parray_);
}
// iostate
void
ios_base::clear(iostate state)
{
if (__rdbuf_)
__rdstate_ = state;
else
__rdstate_ = state | badbit;
if (((state | (__rdbuf_ ? goodbit : badbit)) & __exceptions_) != 0)
throw failure("ios_base::clear");
}
// init
void
ios_base::init(void* sb)
{
__rdbuf_ = sb;
__rdstate_ = __rdbuf_ ? goodbit : badbit;
__exceptions_ = goodbit;
__fmtflags_ = skipws | dec;
__width_ = 0;
__precision_ = 6;
__fn_ = 0;
__index_ = 0;
__event_size_ = 0;
__event_cap_ = 0;
__iarray_ = 0;
__iarray_size_ = 0;
__iarray_cap_ = 0;
__parray_ = 0;
__parray_size_ = 0;
__parray_cap_ = 0;
::new(&__loc_) locale;
}
void
ios_base::copyfmt(const ios_base& rhs)
{
// If we can't acquire the needed resources, throw bad_alloc (can't set badbit)
// Don't alter *this until all needed resources are aquired
unique_ptr<event_callback, void (*)(void*)> new_callbacks(0, free);
unique_ptr<int, void (*)(void*)> new_ints(0, free);
unique_ptr<long, void (*)(void*)> new_longs(0, free);
unique_ptr<void*, void (*)(void*)> new_pointers(0, free);
if (__event_cap_ < rhs.__event_size_)
{
new_callbacks.reset((event_callback*)malloc(sizeof(event_callback) * rhs.__event_size_));
if (!new_callbacks)
throw bad_alloc();
new_ints.reset((int*)malloc(sizeof(int) * rhs.__event_size_));
if (!new_ints)
throw bad_alloc();
}
if (__iarray_cap_ < rhs.__iarray_size_)
{
new_longs.reset((long*)malloc(sizeof(long) * rhs.__iarray_size_));
if (!new_longs)
throw bad_alloc();
}
if (__parray_cap_ < rhs.__parray_size_)
{
new_pointers.reset((void**)malloc(sizeof(void*) * rhs.__parray_size_));
if (!new_pointers)
throw bad_alloc();
}
// Got everything we need. Copy everything but __rdstate_, __rdbuf_ and __exceptions_
__fmtflags_ = rhs.__fmtflags_;
__precision_ = rhs.__precision_;
__width_ = rhs.__width_;
locale& lhs_loc = *(locale*)&__loc_;
locale& rhs_loc = *(locale*)&rhs.__loc_;
lhs_loc = rhs_loc;
if (__event_cap_ < rhs.__event_size_)
{
free(__fn_);
__fn_ = new_callbacks.release();
free(__index_);
__index_ = new_ints.release();
__event_cap_ = rhs.__event_size_;
}
for (__event_size_ = 0; __event_size_ < rhs.__event_size_; ++__event_size_)
{
__fn_[__event_size_] = rhs.__fn_[__event_size_];
__index_[__event_size_] = rhs.__index_[__event_size_];
}
if (__iarray_cap_ < rhs.__iarray_size_)
{
free(__iarray_);
__iarray_ = new_longs.release();
__iarray_cap_ = rhs.__iarray_size_;
}
for (__iarray_size_ = 0; __iarray_size_ < rhs.__iarray_size_; ++__iarray_size_)
__iarray_[__iarray_size_] = rhs.__iarray_[__iarray_size_];
if (__parray_cap_ < rhs.__parray_size_)
{
free(__parray_);
__parray_ = new_pointers.release();
__parray_cap_ = rhs.__parray_size_;
}
for (__parray_size_ = 0; __parray_size_ < rhs.__parray_size_; ++__parray_size_)
__parray_[__parray_size_] = rhs.__parray_[__parray_size_];
}
void
ios_base::move(ios_base& rhs)
{
// *this is uninitialized
__fmtflags_ = rhs.__fmtflags_;
__precision_ = rhs.__precision_;
__width_ = rhs.__width_;
__rdstate_ = rhs.__rdstate_;
__exceptions_ = rhs.__exceptions_;
__rdbuf_ = 0;
locale& rhs_loc = *(locale*)&rhs.__loc_;
::new(&__loc_) locale(rhs_loc);
__fn_ = rhs.__fn_;
rhs.__fn_ = 0;
__index_ = rhs.__index_;
rhs.__index_ = 0;
__event_size_ = rhs.__event_size_;
rhs.__event_size_ = 0;
__event_cap_ = rhs.__event_cap_;
rhs.__event_cap_ = 0;
__iarray_ = rhs.__iarray_;
rhs.__iarray_ = 0;
__iarray_size_ = rhs.__iarray_size_;
rhs.__iarray_size_ = 0;
__iarray_cap_ = rhs.__iarray_cap_;
rhs.__iarray_cap_ = 0;
__parray_ = rhs.__parray_;
rhs.__parray_ = 0;
__parray_size_ = rhs.__parray_size_;
rhs.__parray_size_ = 0;
__parray_cap_ = rhs.__parray_cap_;
rhs.__parray_cap_ = 0;
}
void
ios_base::swap(ios_base& rhs)
{
_STD::swap(__fmtflags_, rhs.__fmtflags_);
_STD::swap(__precision_, rhs.__precision_);
_STD::swap(__width_, rhs.__width_);
_STD::swap(__rdstate_, rhs.__rdstate_);
_STD::swap(__exceptions_, rhs.__exceptions_);
locale& lhs_loc = *(locale*)&__loc_;
locale& rhs_loc = *(locale*)&rhs.__loc_;
_STD::swap(lhs_loc, rhs_loc);
_STD::swap(__fn_, rhs.__fn_);
_STD::swap(__index_, rhs.__index_);
_STD::swap(__event_size_, rhs.__event_size_);
_STD::swap(__event_cap_, rhs.__event_cap_);
_STD::swap(__iarray_, rhs.__iarray_);
_STD::swap(__iarray_size_, rhs.__iarray_size_);
_STD::swap(__iarray_cap_, rhs.__iarray_cap_);
_STD::swap(__parray_, rhs.__parray_);
_STD::swap(__parray_size_, rhs.__parray_size_);
_STD::swap(__parray_cap_, rhs.__parray_cap_);
}
void
ios_base::__set_badbit_and_consider_rethrow()
{
__rdstate_ |= badbit;
if (__exceptions_ & badbit)
throw;
}
void
ios_base::__set_failbit_and_consider_rethrow()
{
__rdstate_ |= failbit;
if (__exceptions_ & failbit)
throw;
}
bool
ios_base::sync_with_stdio(bool sync)
{
static bool previous_state = true;
bool r = previous_state;
previous_state = sync;
return r;
}
_LIBCPP_END_NAMESPACE_STD

53
src/iostream.cpp Normal file
View File

@@ -0,0 +1,53 @@
//===------------------------ iostream.cpp --------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "__std_stream"
#include "string"
_LIBCPP_BEGIN_NAMESPACE_STD
static __stdinbuf<char> __cin(stdin);
static __stdoutbuf<char> __cout(stdout);
static __stdoutbuf<char> __cerr(stderr);
static __stdinbuf<wchar_t> __wcin(stdin);
static __stdoutbuf<wchar_t> __wcout(stdout);
static __stdoutbuf<wchar_t> __wcerr(stderr);
istream cin(&__cin);
ostream cout(&__cout);
ostream cerr(&__cerr);
ostream clog(&__cerr);
wistream wcin(&__wcin);
wostream wcout(&__wcout);
wostream wcerr(&__wcerr);
wostream wclog(&__wcerr);
ios_base::Init __start_std_streams;
ios_base::Init::Init()
{
cin.tie(&cout);
_STD::unitbuf(cerr);
cerr.tie(&cout);
wcin.tie(&wcout);
_STD::unitbuf(wcerr);
wcerr.tie(&wcout);
}
ios_base::Init::~Init()
{
cout.flush();
clog.flush();
wcout.flush();
wclog.flush();
}
_LIBCPP_END_NAMESPACE_STD

3680
src/locale.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

201
src/memory.cpp Normal file
View File

@@ -0,0 +1,201 @@
//===------------------------ memory.cpp ----------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "memory"
#include <libkern/OSAtomic.h>
_LIBCPP_BEGIN_NAMESPACE_STD
namespace
{
template <class T>
inline
typename enable_if
<
sizeof(T) * __CHAR_BIT__ == 32,
T
>::type
increment(T& t)
{
return OSAtomicIncrement32Barrier((volatile int32_t*)&t);
}
template <class T>
inline
typename enable_if
<
sizeof(T) * __CHAR_BIT__ == 32,
T
>::type
decrement(T& t)
{
return OSAtomicDecrement32Barrier((volatile int32_t*)&t);
}
#ifndef __ppc__
template <class T>
inline
typename enable_if
<
sizeof(T) * __CHAR_BIT__ == 64,
T
>::type
increment(T& t)
{
return OSAtomicIncrement64Barrier((volatile int64_t*)&t);
}
template <class T>
inline
typename enable_if
<
sizeof(T) * __CHAR_BIT__ == 64,
T
>::type
decrement(T& t)
{
return OSAtomicDecrement64Barrier((volatile int64_t*)&t);
}
#endif
} // namespace
const allocator_arg_t allocator_arg = allocator_arg_t();
bad_weak_ptr::~bad_weak_ptr() throw() {}
const char*
bad_weak_ptr::what() const throw()
{
return "bad_weak_ptr";
}
__shared_count::~__shared_count()
{
}
void
__shared_count::__add_shared()
{
increment(__shared_owners_);
}
void
__shared_count::__release_shared()
{
if (decrement(__shared_owners_) == -1)
__on_zero_shared();
}
__shared_weak_count::~__shared_weak_count()
{
}
void
__shared_weak_count::__add_shared()
{
__shared_count::__add_shared();
__add_weak();
}
void
__shared_weak_count::__add_weak()
{
increment(__shared_weak_owners_);
}
void
__shared_weak_count::__release_shared()
{
__shared_count::__release_shared();
__release_weak();
}
void
__shared_weak_count::__release_weak()
{
if (decrement(__shared_weak_owners_) == -1)
__on_zero_shared_weak();
}
__shared_weak_count*
__shared_weak_count::lock()
{
long object_owners = __shared_owners_;
while (object_owners != -1)
{
if (OSAtomicCompareAndSwapLongBarrier(object_owners,
object_owners+1,
&__shared_owners_))
{
__add_weak();
return this;
}
object_owners = __shared_owners_;
}
return 0;
}
const void*
__shared_weak_count::__get_deleter(const type_info&) const
{
return 0;
}
void
declare_reachable(void*)
{
}
void
declare_no_pointers(char*, size_t)
{
}
void
undeclare_no_pointers(char*, size_t)
{
}
pointer_safety
get_pointer_safety()
{
return pointer_safety::relaxed;
}
void*
__undeclare_reachable(void* p)
{
return p;
}
void*
align(size_t alignment, size_t size, void*& ptr, size_t& space)
{
void* r = nullptr;
if (size <= space)
{
char* p1 = static_cast<char*>(ptr);
char* p2 = (char*)((size_t)(p1 + (alignment - 1)) & -alignment);
ptrdiff_t d = p2 - p1;
if (d <= space - size)
{
r = p2;
ptr = r;
space -= d;
}
}
return r;
}
_LIBCPP_END_NAMESPACE_STD

246
src/mutex.cpp Normal file
View File

@@ -0,0 +1,246 @@
//===------------------------- mutex.cpp ----------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "mutex"
#include "limits"
#include "system_error"
#include "cassert"
_LIBCPP_BEGIN_NAMESPACE_STD
const defer_lock_t defer_lock = {};
const try_to_lock_t try_to_lock = {};
const adopt_lock_t adopt_lock = {};
mutex::~mutex()
{
int e = pthread_mutex_destroy(&__m_);
// assert(e == 0);
}
void
mutex::lock()
{
int ec = pthread_mutex_lock(&__m_);
if (ec)
__throw_system_error(ec, "mutex lock failed");
}
bool
mutex::try_lock()
{
return pthread_mutex_trylock(&__m_) == 0;
}
void
mutex::unlock()
{
int ec = pthread_mutex_unlock(&__m_);
assert(ec == 0);
}
// recursive_mutex
recursive_mutex::recursive_mutex()
{
pthread_mutexattr_t attr;
int ec = pthread_mutexattr_init(&attr);
if (ec)
goto fail;
ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
if (ec)
{
pthread_mutexattr_destroy(&attr);
goto fail;
}
ec = pthread_mutex_init(&__m_, &attr);
if (ec)
{
pthread_mutexattr_destroy(&attr);
goto fail;
}
ec = pthread_mutexattr_destroy(&attr);
if (ec)
{
pthread_mutex_destroy(&__m_);
goto fail;
}
return;
fail:
__throw_system_error(ec, "recursive_mutex constructor failed");
}
recursive_mutex::~recursive_mutex()
{
int e = pthread_mutex_destroy(&__m_);
assert(e == 0);
}
void
recursive_mutex::lock()
{
int ec = pthread_mutex_lock(&__m_);
if (ec)
__throw_system_error(ec, "recursive_mutex lock failed");
}
void
recursive_mutex::unlock()
{
int e = pthread_mutex_unlock(&__m_);
assert(e == 0);
}
bool
recursive_mutex::try_lock()
{
return pthread_mutex_trylock(&__m_) == 0;
}
// timed_mutex
timed_mutex::timed_mutex()
: __locked_(false)
{
}
timed_mutex::~timed_mutex()
{
lock_guard<mutex> _(__m_);
}
void
timed_mutex::lock()
{
unique_lock<mutex> lk(__m_);
while (__locked_)
__cv_.wait(lk);
__locked_ = true;
}
bool
timed_mutex::try_lock()
{
unique_lock<mutex> lk(__m_, try_to_lock);
if (lk.owns_lock() && !__locked_)
{
__locked_ = true;
return true;
}
return false;
}
void
timed_mutex::unlock()
{
lock_guard<mutex> _(__m_);
__locked_ = false;
__cv_.notify_one();
}
// recursive_timed_mutex
recursive_timed_mutex::recursive_timed_mutex()
: __count_(0),
__id_(nullptr)
{
}
recursive_timed_mutex::~recursive_timed_mutex()
{
lock_guard<mutex> _(__m_);
}
void
recursive_timed_mutex::lock()
{
pthread_t id = pthread_self();
unique_lock<mutex> lk(__m_);
if (pthread_equal(id, __id_))
{
if (__count_ == numeric_limits<size_t>::max())
__throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
++__count_;
return;
}
while (__count_ != 0)
__cv_.wait(lk);
__count_ = 1;
__id_ = id;
}
bool
recursive_timed_mutex::try_lock()
{
pthread_t id = pthread_self();
unique_lock<mutex> lk(__m_, try_to_lock);
if (lk.owns_lock() && (__count_ == 0 || pthread_equal(id, __id_)))
{
if (__count_ == numeric_limits<size_t>::max())
return false;
++__count_;
__id_ = id;
return true;
}
return false;
}
void
recursive_timed_mutex::unlock()
{
unique_lock<mutex> lk(__m_);
if (--__count_ == 0)
{
__id_ = nullptr;
lk.unlock();
__cv_.notify_one();
}
}
// If dispatch_once_f ever handles C++ exceptions, and if one can get to it
// without illegal macros (unexpected macros not beginning with _UpperCase or
// __lowercase), and if it stops spinning waiting threads, then call_once should
// call into dispatch_once_f instead of here. Relevant radar this code needs to
// keep in sync with: 7741191.
static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
void
__call_once(volatile unsigned long& flag, void* arg, void(*func)(void*))
{
pthread_mutex_lock(&mut);
while (flag == 1)
pthread_cond_wait(&cv, &mut);
if (flag == 0)
{
try
{
flag = 1;
pthread_mutex_unlock(&mut);
func(arg);
pthread_mutex_lock(&mut);
flag = ~0ul;
pthread_mutex_unlock(&mut);
pthread_cond_broadcast(&cv);
}
catch (...)
{
pthread_mutex_lock(&mut);
flag = 0ul;
pthread_mutex_unlock(&mut);
pthread_cond_signal(&cv);
throw;
}
}
else
pthread_mutex_unlock(&mut);
}
_LIBCPP_END_NAMESPACE_STD

31
src/new.cpp Normal file
View File

@@ -0,0 +1,31 @@
//===--------------------------- new.cpp ----------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "new"
namespace std
{
bad_array_new_length::~bad_array_new_length() throw()
{
}
const char*
bad_array_new_length::what() const throw()
{
return "bad_array_new_length";
}
void
__throw_bad_alloc()
{
throw bad_alloc();
}
} // std

46
src/random.cpp Normal file
View File

@@ -0,0 +1,46 @@
//===-------------------------- random.cpp --------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "random"
#include "system_error"
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
_LIBCPP_BEGIN_NAMESPACE_STD
random_device::random_device(const string& __token)
: __f_(open(__token.c_str(), O_RDONLY))
{
if (__f_ <= 0)
__throw_system_error(errno, ("random_device failed to open " + __token).c_str());
}
random_device::~random_device()
{
close(__f_);
}
unsigned
random_device::operator()()
{
unsigned r;
read(__f_, &r, sizeof(r));
return r;
}
double
random_device::entropy() const
{
return 0;
}
_LIBCPP_END_NAMESPACE_STD

179
src/stdexcept.cpp Normal file
View File

@@ -0,0 +1,179 @@
//===------------------------ stdexcept.cpp -------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "stdexcept"
#include "new"
#include "string"
#include <cstdlib>
#include <cstring>
#include <cstdint>
#include <cstddef>
#include "system_error"
#include <libkern/OSAtomic.h>
// Note: optimize for size
#pragma GCC visibility push(hidden)
namespace
{
class __libcpp_nmstr
{
private:
const char* str_;
typedef std::size_t unused_t;
typedef std::int32_t count_t;
static const std::ptrdiff_t offset = static_cast<std::ptrdiff_t>(2*sizeof(unused_t) +
sizeof(count_t));
count_t& count() const throw() {return (count_t&)(*(str_ - sizeof(count_t)));}
public:
explicit __libcpp_nmstr(const char* msg);
__libcpp_nmstr(const __libcpp_nmstr& s) _LIBCPP_CANTTHROW;
__libcpp_nmstr& operator=(const __libcpp_nmstr& s) _LIBCPP_CANTTHROW;
~__libcpp_nmstr() _LIBCPP_CANTTHROW;
const char* c_str() const throw() {return str_;}
};
__libcpp_nmstr::__libcpp_nmstr(const char* msg)
{
std::size_t len = strlen(msg);
str_ = new char[len + 1 + offset];
unused_t* c = (unused_t*)str_;
c[0] = c[1] = len;
str_ += offset;
count() = 0;
std::strcpy(const_cast<char*>(c_str()), msg);
}
inline
__libcpp_nmstr::__libcpp_nmstr(const __libcpp_nmstr& s)
: str_(s.str_)
{
OSAtomicIncrement32Barrier(&count());
}
__libcpp_nmstr&
__libcpp_nmstr::operator=(const __libcpp_nmstr& s)
{
const char* p = str_;
str_ = s.str_;
OSAtomicIncrement32Barrier(&count());
if (OSAtomicDecrement32((count_t*)(p-sizeof(count_t))) < 0)
delete [] (p-offset);
return *this;
}
inline
__libcpp_nmstr::~__libcpp_nmstr()
{
if (OSAtomicDecrement32(&count()) < 0)
delete [] (str_ - offset);
}
}
#pragma GCC visiblity pop
namespace std // purposefully not using versioning namespace
{
logic_error::logic_error(const string& msg)
{
__libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
::new(&s) __libcpp_nmstr(msg.c_str());
}
logic_error::logic_error(const char* msg)
{
__libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
::new(&s) __libcpp_nmstr(msg);
}
logic_error::logic_error(const logic_error& le) throw()
{
__libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
::new(&s) __libcpp_nmstr((const __libcpp_nmstr&)le.__imp_);
}
logic_error&
logic_error::operator=(const logic_error& le) throw()
{
__libcpp_nmstr& s1 = (__libcpp_nmstr&)__imp_;
const __libcpp_nmstr& s2 = (const __libcpp_nmstr&)le.__imp_;
s1 = s2;
return *this;
}
logic_error::~logic_error() throw()
{
__libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
s.~__libcpp_nmstr();
}
const char*
logic_error::what() const throw()
{
__libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
return s.c_str();
}
runtime_error::runtime_error(const string& msg)
{
__libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
::new(&s) __libcpp_nmstr(msg.c_str());
}
runtime_error::runtime_error(const char* msg)
{
__libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
::new(&s) __libcpp_nmstr(msg);
}
runtime_error::runtime_error(const runtime_error& le) throw()
{
__libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
::new(&s) __libcpp_nmstr((const __libcpp_nmstr&)le.__imp_);
}
runtime_error&
runtime_error::operator=(const runtime_error& le) throw()
{
__libcpp_nmstr& s1 = (__libcpp_nmstr&)__imp_;
const __libcpp_nmstr& s2 = (const __libcpp_nmstr&)le.__imp_;
s1 = s2;
return *this;
}
runtime_error::~runtime_error() throw()
{
__libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
s.~__libcpp_nmstr();
}
const char*
runtime_error::what() const throw()
{
__libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
return s.c_str();
}
domain_error::~domain_error() throw() {}
invalid_argument::~invalid_argument() throw() {}
length_error::~length_error() throw() {}
out_of_range::~out_of_range() throw() {}
range_error::~range_error() throw() {}
overflow_error::~overflow_error() throw() {}
underflow_error::~underflow_error() throw() {}
} // std

363
src/strstream.cpp Normal file
View File

@@ -0,0 +1,363 @@
//===------------------------ strstream.cpp -------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "strstream"
#include "algorithm"
#include "climits"
#include "cstring"
_LIBCPP_BEGIN_NAMESPACE_STD
strstreambuf::strstreambuf(streamsize __alsize)
: __strmode_(__dynamic),
__alsize_(__alsize),
__palloc_(nullptr),
__pfree_(nullptr)
{
}
strstreambuf::strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*))
: __strmode_(__dynamic),
__alsize_(__default_alsize),
__palloc_(__palloc),
__pfree_(__pfree)
{
}
void
strstreambuf::__init(char* __gnext, streamsize __n, char* __pbeg)
{
if (__n == 0)
__n = strlen(__gnext);
else if (__n < 0)
__n = INT_MAX;
if (__pbeg == nullptr)
setg(__gnext, __gnext, __gnext + __n);
else
{
setg(__gnext, __gnext, __pbeg);
setp(__pbeg, __pbeg + __n);
}
}
strstreambuf::strstreambuf(char* __gnext, streamsize __n, char* __pbeg)
: __strmode_(),
__alsize_(__default_alsize),
__palloc_(nullptr),
__pfree_(nullptr)
{
__init(__gnext, __n, __pbeg);
}
strstreambuf::strstreambuf(const char* __gnext, streamsize __n)
: __strmode_(__constant),
__alsize_(__default_alsize),
__palloc_(nullptr),
__pfree_(nullptr)
{
__init((char*)__gnext, __n, nullptr);
}
strstreambuf::strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg)
: __strmode_(),
__alsize_(__default_alsize),
__palloc_(nullptr),
__pfree_(nullptr)
{
__init((char*)__gnext, __n, (char*)__pbeg);
}
strstreambuf::strstreambuf(const signed char* __gnext, streamsize __n)
: __strmode_(__constant),
__alsize_(__default_alsize),
__palloc_(nullptr),
__pfree_(nullptr)
{
__init((char*)__gnext, __n, nullptr);
}
strstreambuf::strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg)
: __strmode_(),
__alsize_(__default_alsize),
__palloc_(nullptr),
__pfree_(nullptr)
{
__init((char*)__gnext, __n, (char*)__pbeg);
}
strstreambuf::strstreambuf(const unsigned char* __gnext, streamsize __n)
: __strmode_(__constant),
__alsize_(__default_alsize),
__palloc_(nullptr),
__pfree_(nullptr)
{
__init((char*)__gnext, __n, nullptr);
}
#ifdef _LIBCPP_MOVE
strstreambuf::strstreambuf(strstreambuf&& __rhs)
: streambuf(__rhs),
__strmode_(__rhs.__strmode_),
__alsize_(__rhs.__alsize_),
__palloc_(__rhs.__palloc_),
__pfree_(__rhs.__pfree_)
{
__rhs.setg(nullptr, nullptr, nullptr);
__rhs.setp(nullptr, nullptr);
}
strstreambuf&
strstreambuf::operator=(strstreambuf&& __rhs)
{
if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
{
if (__pfree_)
__pfree_(eback());
else
delete [] eback();
}
streambuf::operator=(__rhs);
__strmode_ = __rhs.__strmode_;
__alsize_ = __rhs.__alsize_;
__palloc_ = __rhs.__palloc_;
__pfree_ = __rhs.__pfree_;
__rhs.setg(nullptr, nullptr, nullptr);
__rhs.setp(nullptr, nullptr);
}
#endif
strstreambuf::~strstreambuf()
{
if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
{
if (__pfree_)
__pfree_(eback());
else
delete [] eback();
}
}
void
strstreambuf::swap(strstreambuf& __rhs)
{
streambuf::swap(__rhs);
_STD::swap(__strmode_, __rhs.__strmode_);
_STD::swap(__alsize_, __rhs.__alsize_);
_STD::swap(__palloc_, __rhs.__palloc_);
_STD::swap(__pfree_, __rhs.__pfree_);
}
void
strstreambuf::freeze(bool __freezefl)
{
if (__strmode_ & __dynamic)
{
if (__freezefl)
__strmode_ |= __frozen;
else
__strmode_ &= ~__frozen;
}
}
char*
strstreambuf::str()
{
if (__strmode_ & __dynamic)
__strmode_ |= __frozen;
return eback();
}
int
strstreambuf::pcount() const
{
return static_cast<int>(pptr() - pbase());
}
strstreambuf::int_type
strstreambuf::overflow(int_type __c)
{
if (__c == EOF)
return int_type(0);
if (pptr() == epptr())
{
if ((__strmode_ & __dynamic) == 0 || (__strmode_ & __frozen) != 0)
return int_type(EOF);
streamsize old_size = (epptr() ? epptr() : egptr()) - eback();
streamsize new_size = max<streamsize>(__alsize_, 2*old_size);
char* buf = nullptr;
if (__palloc_)
buf = static_cast<char*>(__palloc_(new_size));
else
buf = new char[new_size];
if (buf == nullptr)
return int_type(EOF);
memcpy(buf, eback(), old_size);
ptrdiff_t ninp = gptr() - eback();
ptrdiff_t einp = egptr() - eback();
ptrdiff_t nout = pptr() - pbase();
ptrdiff_t eout = epptr() - pbase();
if (__strmode_ & __allocated)
{
if (__pfree_)
__pfree_(eback());
else
delete [] eback();
}
setg(buf, buf + ninp, buf + einp);
setp(buf + einp, buf + einp + eout);
pbump(nout);
__strmode_ |= __allocated;
}
*pptr() = static_cast<char>(__c);
pbump(1);
return int_type((unsigned char)__c);
}
strstreambuf::int_type
strstreambuf::pbackfail(int_type __c)
{
if (eback() == gptr())
return EOF;
if (__c == EOF)
{
gbump(-1);
return int_type(0);
}
if (__strmode_ & __constant)
{
if (gptr()[-1] == static_cast<char>(__c))
{
gbump(-1);
return __c;
}
return EOF;
}
gbump(-1);
*gptr() = static_cast<char>(__c);
return __c;
}
strstreambuf::int_type
strstreambuf::underflow()
{
if (gptr() == egptr())
{
if (egptr() >= pptr())
return EOF;
setg(eback(), gptr(), pptr());
}
return int_type((unsigned char)*gptr());
}
strstreambuf::pos_type
strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which)
{
off_type __p(-1);
bool pos_in = __which & ios::in;
bool pos_out = __which & ios::out;
bool legal = false;
switch (__way)
{
case ios::beg:
case ios::end:
if (pos_in || pos_out)
legal = true;
break;
case ios::cur:
if (pos_in != pos_out)
legal = true;
break;
}
if (pos_in && gptr() == nullptr)
legal = false;
if (pos_out && pptr() == nullptr)
legal = false;
if (legal)
{
off_type newoff;
char* seekhigh = epptr() ? epptr() : egptr();
switch (__way)
{
case ios::beg:
newoff = 0;
break;
case ios::cur:
newoff = (pos_in ? gptr() : pptr()) - eback();
break;
case ios::end:
newoff = seekhigh - eback();
break;
}
newoff += __off;
if (0 <= newoff && newoff <= seekhigh - eback())
{
char* newpos = eback() + newoff;
if (pos_in)
setg(eback(), newpos, max(newpos, egptr()));
if (pos_out)
{
// min(pbase, newpos), newpos, epptr()
__off = epptr() - newpos;
setp(min(pbase(), newpos), epptr());
pbump(static_cast<int>((epptr() - pbase()) - __off));
}
__p = newoff;
}
}
return pos_type(__p);
}
strstreambuf::pos_type
strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which)
{
off_type __p(-1);
bool pos_in = __which & ios::in;
bool pos_out = __which & ios::out;
if (pos_in || pos_out)
{
if (!((pos_in && gptr() == nullptr) || (pos_out && pptr() == nullptr)))
{
off_type newoff = __sp;
char* seekhigh = epptr() ? epptr() : egptr();
if (0 <= newoff && newoff <= seekhigh - eback())
{
char* newpos = eback() + newoff;
if (pos_in)
setg(eback(), newpos, max(newpos, egptr()));
if (pos_out)
{
// min(pbase, newpos), newpos, epptr()
off_type temp = epptr() - newpos;
setp(min(pbase(), newpos), epptr());
pbump(static_cast<int>((epptr() - pbase()) - temp));
}
__p = newoff;
}
}
}
return pos_type(__p);
}
istrstream::~istrstream()
{
}
ostrstream::~ostrstream()
{
}
strstream::~strstream()
{
}
_LIBCPP_END_NAMESPACE_STD

193
src/system_error.cpp Normal file
View File

@@ -0,0 +1,193 @@
//===---------------------- system_error.cpp ------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "system_error"
#include "string"
#include "cstring"
_LIBCPP_BEGIN_NAMESPACE_STD
// class error_category
error_category::error_category()
{
}
error_category::~error_category()
{
}
error_condition
error_category::default_error_condition(int ev) const
{
return error_condition(ev, *this);
}
bool
error_category::equivalent(int code, const error_condition& condition) const
{
return default_error_condition(code) == condition;
}
bool
error_category::equivalent(const error_code& code, int condition) const
{
return *this == code.category() && code.value() == condition;
}
string
__do_message::message(int ev) const
{
return string(strerror(ev));
}
class _LIBCPP_HIDDEN __generic_error_category
: public __do_message
{
public:
virtual const char* name() const;
virtual string message(int ev) const;
};
const char*
__generic_error_category::name() const
{
return "generic";
}
string
__generic_error_category::message(int ev) const
{
if (ev <= ELAST)
return __do_message::message(ev);
return string("unspecified generic_category error");
}
const error_category&
generic_category()
{
static __generic_error_category s;
return s;
}
class _LIBCPP_HIDDEN __system_error_category
: public __do_message
{
public:
virtual const char* name() const;
virtual string message(int ev) const;
virtual error_condition default_error_condition(int ev) const;
};
const char*
__system_error_category::name() const
{
return "system";
}
string
__system_error_category::message(int ev) const
{
if (ev <= ELAST)
return __do_message::message(ev);
return string("unspecified system_category error");
}
error_condition
__system_error_category::default_error_condition(int ev) const
{
if (ev <= ELAST)
return error_condition(ev, generic_category());
return error_condition(ev, system_category());
}
const error_category&
system_category()
{
static __system_error_category s;
return s;
}
// error_condition
string
error_condition::message() const
{
return __cat_->message(__val_);
}
// error_code
string
error_code::message() const
{
return __cat_->message(__val_);
}
// system_error
string
system_error::__init(const error_code& ec, string what_arg)
{
if (ec)
{
if (!what_arg.empty())
what_arg += ": ";
what_arg += ec.message();
}
return _STD::move(what_arg);
}
system_error::system_error(error_code ec, const string& what_arg)
: runtime_error(__init(ec, what_arg)),
__ec_(ec)
{
}
system_error::system_error(error_code ec, const char* what_arg)
: runtime_error(__init(ec, what_arg)),
__ec_(ec)
{
}
system_error::system_error(error_code ec)
: runtime_error(__init(ec, "")),
__ec_(ec)
{
}
system_error::system_error(int ev, const error_category& ecat, const string& what_arg)
: runtime_error(__init(error_code(ev, ecat), what_arg)),
__ec_(error_code(ev, ecat))
{
}
system_error::system_error(int ev, const error_category& ecat, const char* what_arg)
: runtime_error(__init(error_code(ev, ecat), what_arg)),
__ec_(error_code(ev, ecat))
{
}
system_error::system_error(int ev, const error_category& ecat)
: runtime_error(__init(error_code(ev, ecat), "")),
__ec_(error_code(ev, ecat))
{
}
system_error::~system_error() throw()
{
}
void
__throw_system_error(int ev, const char* what_arg)
{
throw system_error(error_code(ev, system_category()), what_arg);
}
_LIBCPP_END_NAMESPACE_STD

73
src/thread.cpp Normal file
View File

@@ -0,0 +1,73 @@
//===------------------------- thread.cpp----------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "thread"
#include "exception"
#include <sys/sysctl.h>
_LIBCPP_BEGIN_NAMESPACE_STD
thread::~thread()
{
if (__t_ != nullptr)
terminate();
}
void
thread::join()
{
int ec = pthread_join(__t_, 0);
if (ec)
throw system_error(error_code(ec, system_category()), "thread::join failed");
__t_ = nullptr;
}
void
thread::detach()
{
int ec = EINVAL;
if (__t_ != 0)
{
ec = pthread_detach(__t_);
if (ec == 0)
__t_ = 0;
}
if (ec)
throw system_error(error_code(ec, system_category()), "thread::detach failed");
}
unsigned
thread::hardware_concurrency()
{
int n;
int mib[2] = {CTL_HW, HW_NCPU};
std::size_t s = sizeof(n);
sysctl(mib, 2, &n, &s, 0, 0);
return n;
}
namespace this_thread
{
void
sleep_for(const chrono::nanoseconds& ns)
{
using namespace chrono;
if (ns >= nanoseconds::zero())
{
timespec ts;
ts.tv_sec = static_cast<decltype(ts.tv_sec)>(duration_cast<seconds>(ns).count());
ts.tv_nsec = static_cast<decltype(ts.tv_nsec)>((ns - seconds(ts.tv_sec)).count());
nanosleep(&ts, 0);
}
}
} // this_thread
_LIBCPP_END_NAMESPACE_STD

16
src/utility.cpp Normal file
View File

@@ -0,0 +1,16 @@
//===------------------------ utility.cpp ---------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "utility"
_LIBCPP_BEGIN_NAMESPACE_STD
const piecewise_construct_t piecewise_construct = {};
_LIBCPP_END_NAMESPACE_STD

54
src/valarray.cpp Normal file
View File

@@ -0,0 +1,54 @@
//===------------------------ valarray.cpp --------------------------------===//
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "valarray"
_LIBCPP_BEGIN_NAMESPACE_STD
template valarray<size_t>::valarray(size_t);
template valarray<size_t>::~valarray();
template void valarray<size_t>::resize(size_t, size_t);
void
gslice::__init(size_t __start)
{
valarray<size_t> __indices(__size_.size());
size_t __k = __size_.size() != 0;
for (size_t __i = 0; __i < __size_.size(); ++__i)
__k *= __size_[__i];
__1d_.resize(__k);
if (__1d_.size())
{
__k = 0;
__1d_[__k] = __start;
while (true)
{
size_t __i = __indices.size() - 1;
while (true)
{
if (++__indices[__i] < __size_[__i])
{
++__k;
__1d_[__k] = __1d_[__k-1] + __stride_[__i];
for (size_t __j = __i + 1; __j != __indices.size(); ++__j)
__1d_[__k] -= __stride_[__j] * (__size_[__j] - 1);
break;
}
else
{
if (__i == 0)
return;
__indices[__i--] = 0;
}
}
}
}
}
_LIBCPP_END_NAMESPACE_STD