forked from Archive/PX4-Autopilot
Add misc/uClibc++ and build hooks in nuttx/
git-svn-id: http://svn.code.sf.net/p/nuttx/code/trunk@5283 42af7a65-404d-4744-a932-0658087f49c3
This commit is contained in:
patacongo
parent
a74dd08492
commit
66aae459f1
|
|
@ -0,0 +1,13 @@
|
|||
TOPDIR=../
|
||||
include $(TOPDIR)Rules.mak
|
||||
|
||||
all:
|
||||
|
||||
clean:
|
||||
|
||||
distclean:
|
||||
|
||||
HEADERS = $(filter-out .svn CVS Makefile,$(wildcard *))
|
||||
install:
|
||||
$(INSTALL) -d $(PREFIX)$(UCLIBCXX_RUNTIME_INCLUDEDIR)
|
||||
$(INSTALL) -m 644 $(HEADERS) $(PREFIX)$(UCLIBCXX_RUNTIME_INCLUDEDIR)
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,640 @@
|
|||
/* Copyright (C) 2007 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#include<memory>
|
||||
#include<utility>
|
||||
#include<iterator>
|
||||
#include<functional>
|
||||
#include<list>
|
||||
|
||||
|
||||
#ifndef __STD_HEADER_ASSOCIATIVE_BASE
|
||||
#define __STD_HEADER_ASSOCIATIVE_BASE
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
/*
|
||||
* The basic premise here is that most of the code used by map, multimap, set and
|
||||
* multiset is really common. There are a number of interface additions, and
|
||||
* considerations about how to address multiple entries with the same key.
|
||||
* The goal is that the tree/storage code should be here, and managing
|
||||
* single or multiple counts will be left to subclasses.
|
||||
* Yes, inheritence for the purpose of code sharing is usually a bad idea.
|
||||
* However, since our goal is to reduce the total amount of code written
|
||||
* and the overall binary size, this seems to be the best approach possible.
|
||||
*/
|
||||
|
||||
template<class Key, class ValueType, class Compare = less<Key>, class Allocator = allocator<ValueType> > class __base_associative;
|
||||
template<class ValueType, class Compare, class Allocator> class _associative_iter;
|
||||
template<class ValueType, class Compare, class Allocator> class _associative_citer;
|
||||
|
||||
template<class Key, class ValueType, class Compare = less<Key>, class Allocator = allocator<ValueType> > class __single_associative;
|
||||
template<class Key, class ValueType, class Compare = less<Key>, class Allocator = allocator<ValueType> > class __multi_associative;
|
||||
|
||||
template<class Key, class ValueType, class Compare, class Allocator> class _UCXXEXPORT __base_associative{
|
||||
|
||||
protected:
|
||||
|
||||
public:
|
||||
typedef Key key_type;
|
||||
typedef ValueType value_type;
|
||||
typedef Compare key_compare;
|
||||
typedef Allocator allocator_type;
|
||||
typedef typename Allocator::reference reference;
|
||||
typedef typename Allocator::const_reference const_reference;
|
||||
typedef typename Allocator::size_type size_type;
|
||||
typedef typename Allocator::difference_type difference_type;
|
||||
typedef typename Allocator::pointer pointer;
|
||||
typedef typename Allocator::const_pointer const_pointer;
|
||||
typedef __base_associative<Key, ValueType, Compare, Allocator> associative_type;
|
||||
|
||||
typedef _associative_iter<value_type, Compare, Allocator> iterator;
|
||||
typedef _associative_citer<value_type, Compare, Allocator> const_iterator;
|
||||
typedef typename std::reverse_iterator<iterator> reverse_iterator;
|
||||
typedef typename std::reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
|
||||
|
||||
explicit __base_associative(const Compare& comp, const Allocator& A, const key_type (*v_to_k)(const value_type))
|
||||
: c(comp), value_to_key(v_to_k) { }
|
||||
protected:
|
||||
__base_associative(const associative_type& x)
|
||||
: c(x.c), backing(x.backing), value_to_key(x.value_to_key) { }
|
||||
|
||||
public:
|
||||
~__base_associative(){
|
||||
}
|
||||
|
||||
bool empty() const{
|
||||
return backing.empty();
|
||||
}
|
||||
size_type size() const{
|
||||
return backing.size();
|
||||
}
|
||||
size_type max_size() const{
|
||||
return backing.max_size();
|
||||
}
|
||||
|
||||
iterator begin(){
|
||||
return iterator(backing.begin());
|
||||
}
|
||||
|
||||
const_iterator begin() const{
|
||||
return const_iterator(backing.begin());
|
||||
}
|
||||
|
||||
iterator end() {
|
||||
return iterator(backing.end());
|
||||
}
|
||||
|
||||
const_iterator end() const{
|
||||
return const_iterator(backing.end());
|
||||
}
|
||||
|
||||
reverse_iterator rbegin(){
|
||||
return reverse_iterator(end());
|
||||
}
|
||||
|
||||
const_reverse_iterator rbegin() const{
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
|
||||
reverse_iterator rend(){
|
||||
return reverse_iterator(begin());
|
||||
}
|
||||
|
||||
const_reverse_iterator rend() const{
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
|
||||
|
||||
iterator lower_bound(const key_type &x);
|
||||
const_iterator lower_bound(const key_type &x) const;
|
||||
iterator upper_bound(const key_type &x);
|
||||
const_iterator upper_bound(const key_type &x) const;
|
||||
|
||||
pair<iterator,iterator> equal_range(const key_type& x){
|
||||
pair<iterator, iterator> retval;
|
||||
retval.first = lower_bound(x);
|
||||
retval.second = retval.first;
|
||||
while(retval.second != end() && !c(x, value_to_key(*retval.second))){
|
||||
++retval.second;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
pair<const_iterator,const_iterator> equal_range(const key_type& x) const{
|
||||
pair<const_iterator, const_iterator> retval;
|
||||
retval.first = lower_bound(x);
|
||||
retval.second = retval.first;
|
||||
while(retval.second != end() && !c(x, value_to_key(*retval.second))){
|
||||
++retval.second;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
iterator find(const key_type& x){
|
||||
iterator retval = lower_bound(x);
|
||||
if(retval == end()){
|
||||
return retval;
|
||||
}
|
||||
if(c(x, value_to_key(*retval))){
|
||||
return end();
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
const_iterator find(const key_type& x) const{
|
||||
const_iterator retval = lower_bound(x);
|
||||
if(retval == end()){
|
||||
return retval;
|
||||
}
|
||||
if(c(x, value_to_key(*retval))){
|
||||
return end();
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
size_type count(const key_type& x) const{
|
||||
size_type retval(0);
|
||||
const_iterator first = lower_bound(x);
|
||||
while(first != end() && !c(x, value_to_key(*first))){
|
||||
++retval;
|
||||
++first;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
void clear(){
|
||||
backing.clear();
|
||||
}
|
||||
|
||||
void erase(iterator pos){
|
||||
backing.erase(pos.base_iterator());
|
||||
}
|
||||
size_type erase(const key_type& x){
|
||||
size_type count(0);
|
||||
iterator start = lower_bound(x);
|
||||
iterator end = upper_bound(x);
|
||||
while(start != end){
|
||||
start = backing.erase(start.base_iterator());
|
||||
++count;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
void erase(iterator first, iterator last){
|
||||
while(first != last){
|
||||
backing.erase(first.base_iterator());
|
||||
++first;
|
||||
}
|
||||
}
|
||||
|
||||
key_compare key_comp() const{
|
||||
return c;
|
||||
}
|
||||
|
||||
__base_associative &operator=(const __base_associative & x){
|
||||
c = x.c;
|
||||
backing = x.backing;
|
||||
value_to_key = x.value_to_key;
|
||||
return *this;
|
||||
}
|
||||
bool operator==(const __base_associative & x){
|
||||
return x.backing == backing;
|
||||
}
|
||||
bool operator!=(const __base_associative & x){
|
||||
return !(x.backing == backing);
|
||||
}
|
||||
|
||||
protected:
|
||||
void swap(__base_associative & x);
|
||||
|
||||
Compare c;
|
||||
std::list<value_type> backing;
|
||||
|
||||
const key_type (*value_to_key)(const value_type);
|
||||
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Tree iterators for the base associative class
|
||||
*/
|
||||
|
||||
template<class ValueType, class Compare, class Allocator> class _associative_citer
|
||||
: public std::iterator<
|
||||
bidirectional_iterator_tag,
|
||||
ValueType,
|
||||
typename Allocator::difference_type,
|
||||
ValueType*,
|
||||
ValueType&
|
||||
>
|
||||
{
|
||||
protected:
|
||||
typedef std::list<ValueType> listtype;
|
||||
|
||||
typename listtype::const_iterator base_iter;
|
||||
friend class _associative_iter<ValueType, Compare, Allocator>;
|
||||
public:
|
||||
_associative_citer() { }
|
||||
_associative_citer(const _associative_citer & m)
|
||||
: base_iter(m.base_iter) { }
|
||||
_associative_citer(const typename listtype::const_iterator & m)
|
||||
: base_iter(m) { }
|
||||
~_associative_citer() { }
|
||||
ValueType operator*() const{
|
||||
return *base_iter;
|
||||
}
|
||||
const ValueType * operator->() const{
|
||||
return &(*base_iter);
|
||||
}
|
||||
_associative_citer & operator=(const _associative_citer & m){
|
||||
base_iter = m.base_iter;
|
||||
return *this;
|
||||
}
|
||||
bool operator==(const _associative_citer & m) const{
|
||||
return m.base_iter == base_iter;
|
||||
}
|
||||
bool operator!=(const _associative_citer & m) const{
|
||||
return m.base_iter != base_iter;
|
||||
}
|
||||
_associative_citer & operator++(){
|
||||
++base_iter;
|
||||
return *this;
|
||||
}
|
||||
_associative_citer operator++(int){
|
||||
//The following approach ensures that we only need to
|
||||
//provide code for ++ in one place (above)
|
||||
_associative_citer temp(base_iter);
|
||||
++base_iter;
|
||||
return temp;
|
||||
}
|
||||
_associative_citer & operator--(){
|
||||
--base_iter;
|
||||
return *this;
|
||||
}
|
||||
_associative_citer operator--(int){
|
||||
//The following approach ensures that we only need to
|
||||
//provide code for -- in one place (above)
|
||||
_associative_citer temp(base_iter);
|
||||
--base_iter;
|
||||
return temp;
|
||||
}
|
||||
|
||||
//This is an implementation-defined function designed to make internals work correctly
|
||||
typename listtype::const_iterator base_iterator(){
|
||||
return base_iter;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<class ValueType, class Compare, class Allocator> class _associative_iter
|
||||
: public std::iterator<
|
||||
bidirectional_iterator_tag,
|
||||
ValueType,
|
||||
typename Allocator::difference_type,
|
||||
ValueType*,
|
||||
ValueType&
|
||||
>
|
||||
{
|
||||
protected:
|
||||
typedef std::list<ValueType> listtype;
|
||||
|
||||
typename listtype::iterator base_iter;
|
||||
typedef _associative_citer<ValueType, Compare, Allocator> __associative_citer;
|
||||
|
||||
public:
|
||||
_associative_iter() { }
|
||||
_associative_iter(const _associative_iter & m)
|
||||
: base_iter(m.base_iter) { }
|
||||
_associative_iter(const typename listtype::iterator & m)
|
||||
: base_iter(m) { }
|
||||
~_associative_iter() { }
|
||||
const ValueType & operator*() const{
|
||||
return *base_iter;
|
||||
}
|
||||
ValueType & operator*(){
|
||||
return *base_iter;
|
||||
}
|
||||
ValueType * operator->(){
|
||||
return &(*base_iter);
|
||||
}
|
||||
const ValueType * operator->() const{
|
||||
return &(*base_iter);
|
||||
}
|
||||
_associative_iter & operator=(const _associative_iter & m){
|
||||
base_iter = m.base_iter;
|
||||
return *this;
|
||||
}
|
||||
bool operator==(const _associative_iter & m) const{
|
||||
return m.base_iter == base_iter;
|
||||
}
|
||||
bool operator==(const __associative_citer & m) const{
|
||||
return m.base_iter == base_iter;
|
||||
}
|
||||
bool operator!=(const _associative_iter & m) const{
|
||||
return m.base_iter != base_iter;
|
||||
}
|
||||
bool operator!=(const __associative_citer & m) const{
|
||||
return m.base_iter != base_iter;
|
||||
}
|
||||
_associative_iter & operator++(){
|
||||
++base_iter;
|
||||
return *this;
|
||||
}
|
||||
_associative_iter operator++(int){
|
||||
//The following approach ensures that we only need to
|
||||
//provide code for ++ in one place (above)
|
||||
_associative_iter temp(base_iter);
|
||||
++base_iter;
|
||||
return temp;
|
||||
}
|
||||
_associative_iter & operator--(){
|
||||
--base_iter;
|
||||
return *this;
|
||||
}
|
||||
_associative_iter operator--(int){
|
||||
//The following approach ensures that we only need to
|
||||
//provide code for -- in one place (above)
|
||||
_associative_iter temp(base_iter);
|
||||
--base_iter;
|
||||
return temp;
|
||||
}
|
||||
operator __associative_citer() const{
|
||||
return __associative_citer(base_iter);
|
||||
}
|
||||
typename listtype::iterator base_iterator(){
|
||||
return base_iter;
|
||||
}
|
||||
const typename listtype::iterator base_iterator() const{
|
||||
return base_iter;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
// The lower_bound code is really crappy linear search. However, it is a dead
|
||||
// simple implementation (easy to audit). It can also be easily replaced.
|
||||
|
||||
|
||||
template <class Key, class ValueType, class Compare, class Allocator>
|
||||
typename __base_associative<Key, ValueType, Compare, Allocator>::iterator
|
||||
__base_associative<Key, ValueType, Compare, Allocator>::lower_bound(const key_type &x)
|
||||
{
|
||||
iterator retval = begin();
|
||||
while(retval != end() && c(value_to_key(*retval), x)){
|
||||
++retval;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
template <class Key, class ValueType, class Compare, class Allocator>
|
||||
typename __base_associative<Key, ValueType, Compare, Allocator>::const_iterator
|
||||
__base_associative<Key, ValueType, Compare, Allocator>::lower_bound(const key_type &x) const
|
||||
{
|
||||
const_iterator retval = begin();
|
||||
while(retval != end() && c(value_to_key(*retval), x)){
|
||||
++retval;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
// Upper bound search is linear from the point of lower_bound. This is likely the best solution
|
||||
// in all but the most pathological of cases.
|
||||
|
||||
template <class Key, class ValueType, class Compare, class Allocator>
|
||||
typename __base_associative<Key, ValueType, Compare, Allocator>::iterator
|
||||
__base_associative<Key, ValueType, Compare, Allocator>::upper_bound(const key_type &x)
|
||||
{
|
||||
iterator retval = lower_bound(x);
|
||||
while(retval != end() && !c(x, value_to_key(*retval))){
|
||||
++retval;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
template <class Key, class ValueType, class Compare, class Allocator>
|
||||
typename __base_associative<Key, ValueType, Compare, Allocator>::const_iterator
|
||||
__base_associative<Key, ValueType, Compare, Allocator>::upper_bound(const key_type &x) const
|
||||
{
|
||||
const_iterator retval = begin();
|
||||
while(retval != end() && !c(x, value_to_key(*retval))){
|
||||
++retval;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
template <class Key, class ValueType, class Compare, class Allocator>
|
||||
void __base_associative<Key, ValueType, Compare, Allocator>::swap(__base_associative<Key, ValueType, Compare, Allocator>& m)
|
||||
{
|
||||
Compare n = c;
|
||||
c = m.c;
|
||||
m.c = n;
|
||||
|
||||
m.backing.swap(backing);
|
||||
}
|
||||
|
||||
|
||||
template<class Key, class ValueType, class Compare, class Allocator> class _UCXXEXPORT __single_associative :
|
||||
public __base_associative<Key, ValueType, Compare, Allocator>
|
||||
{
|
||||
protected:
|
||||
typedef __base_associative<Key, ValueType, Compare, Allocator> base;
|
||||
using base::backing;
|
||||
|
||||
using base::c;
|
||||
|
||||
public:
|
||||
typedef typename base::key_type key_type;
|
||||
typedef typename base::value_type value_type;
|
||||
typedef typename base::key_compare key_compare;
|
||||
typedef typename base::allocator_type allocator_type;
|
||||
typedef typename base::reference reference;
|
||||
typedef typename base::const_reference const_reference;
|
||||
typedef typename base::iterator iterator;
|
||||
typedef typename base::const_iterator const_iterator;
|
||||
typedef typename base::size_type size_type;
|
||||
typedef typename base::difference_type difference_type;
|
||||
typedef typename base::pointer pointer;
|
||||
typedef typename base::const_pointer const_pointer;
|
||||
typedef typename base::reverse_iterator reverse_iterator;
|
||||
typedef typename base::const_reverse_iterator const_reverse_iterator;
|
||||
|
||||
using base::begin;
|
||||
using base::end;
|
||||
using base::rbegin;
|
||||
using base::rend;
|
||||
|
||||
using base::empty;
|
||||
using base::size;
|
||||
using base::max_size;
|
||||
|
||||
using base::find;
|
||||
using base::count;
|
||||
using base::lower_bound;
|
||||
using base::upper_bound;
|
||||
using base::equal_range;
|
||||
|
||||
using base::operator=;
|
||||
using base::operator==;
|
||||
using base::operator!=;
|
||||
|
||||
explicit __single_associative(const Compare& comp, const Allocator& A, const key_type (*v_to_k)(const value_type))
|
||||
: base(comp, A, v_to_k) { }
|
||||
|
||||
template <class InputIterator> __single_associative(
|
||||
InputIterator first,
|
||||
InputIterator last,
|
||||
const Compare& comp,
|
||||
const Allocator& A,
|
||||
const key_type (*v_to_k)(const value_type)
|
||||
) : base(comp, A, v_to_k) {
|
||||
insert(first, last);
|
||||
}
|
||||
|
||||
pair<iterator, bool> insert(const value_type& x){
|
||||
pair<iterator, bool> retval;
|
||||
iterator location = lower_bound(this->value_to_key(x));
|
||||
retval.second = true;
|
||||
//Empty list or need to insert at end
|
||||
if(end() == location){
|
||||
backing.push_back(x);
|
||||
retval.first = --(end());
|
||||
return retval;
|
||||
}
|
||||
//Something in the list
|
||||
if(c(this->value_to_key(x), this->value_to_key(*location))){
|
||||
location = backing.insert(location.base_iterator(), x);
|
||||
retval.first = location;
|
||||
}else{
|
||||
retval.second = false;
|
||||
retval.first = location;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
iterator insert(iterator position, const value_type& x){
|
||||
// FIXME - this is cheating and probably should be more efficient since we are
|
||||
// now log(n) to find for inserts
|
||||
return insert(x).first;
|
||||
}
|
||||
|
||||
template <class InputIterator> void insert(InputIterator first, InputIterator last){
|
||||
while(first != last){
|
||||
insert(*first);
|
||||
++first;
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
template<class Key, class ValueType, class Compare, class Allocator> class _UCXXEXPORT __multi_associative :
|
||||
public __base_associative<Key, ValueType, Compare, Allocator>
|
||||
{
|
||||
protected:
|
||||
typedef __base_associative<Key, ValueType, Compare, Allocator> base;
|
||||
using base::backing;
|
||||
|
||||
using base::c;
|
||||
|
||||
public:
|
||||
typedef typename base::key_type key_type;
|
||||
typedef typename base::value_type value_type;
|
||||
typedef typename base::key_compare key_compare;
|
||||
typedef typename base::allocator_type allocator_type;
|
||||
typedef typename base::reference reference;
|
||||
typedef typename base::const_reference const_reference;
|
||||
typedef typename base::iterator iterator;
|
||||
typedef typename base::const_iterator const_iterator;
|
||||
typedef typename base::size_type size_type;
|
||||
typedef typename base::difference_type difference_type;
|
||||
typedef typename base::pointer pointer;
|
||||
typedef typename base::const_pointer const_pointer;
|
||||
typedef typename base::reverse_iterator reverse_iterator;
|
||||
typedef typename base::const_reverse_iterator const_reverse_iterator;
|
||||
|
||||
using base::begin;
|
||||
using base::end;
|
||||
using base::rbegin;
|
||||
using base::rend;
|
||||
|
||||
using base::empty;
|
||||
using base::size;
|
||||
using base::max_size;
|
||||
|
||||
using base::find;
|
||||
using base::count;
|
||||
using base::lower_bound;
|
||||
using base::upper_bound;
|
||||
using base::equal_range;
|
||||
|
||||
using base::operator=;
|
||||
using base::operator==;
|
||||
|
||||
|
||||
explicit __multi_associative(const Compare& comp, const Allocator& A, const key_type (*v_to_k)(const value_type))
|
||||
: base(comp, A, v_to_k) { }
|
||||
|
||||
template <class InputIterator> __multi_associative(
|
||||
InputIterator first,
|
||||
InputIterator last,
|
||||
const Compare& comp,
|
||||
const Allocator& A,
|
||||
const key_type (*v_to_k)(const value_type)
|
||||
) : base(comp, A, v_to_k) {
|
||||
insert(first, last);
|
||||
}
|
||||
|
||||
iterator insert(const value_type& x){
|
||||
iterator location = lower_bound(this->value_to_key(x));
|
||||
|
||||
if(location == begin()){
|
||||
backing.push_front(x);
|
||||
location = begin();
|
||||
}else{
|
||||
location = backing.insert(location.base_iterator(), x);
|
||||
}
|
||||
return location;
|
||||
}
|
||||
|
||||
iterator insert(iterator position, const value_type& x){
|
||||
// FIXME - this is cheating and probably should be more efficient since we are
|
||||
// now log(n) to find for inserts
|
||||
return insert(x);
|
||||
}
|
||||
|
||||
template <class InputIterator> void insert(InputIterator first, InputIterator last){
|
||||
while(first != last){
|
||||
insert(*first);
|
||||
++first;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif //__STD_HEADER_ASSOCIATIVE_BASE
|
||||
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef __BASIC_DEFINITIONS
|
||||
#define __BASIC_DEFINITIONS 1
|
||||
|
||||
#include <system_configuration.h>
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
//The following is used to support GCC symbol visibility patch
|
||||
|
||||
#ifdef GCC_HASCLASSVISIBILITY
|
||||
#define _UCXXEXPORT __attribute__ ((visibility("default")))
|
||||
#define _UCXXLOCAL __attribute__ ((visibility("hidden")))
|
||||
#else
|
||||
#define _UCXXEXPORT
|
||||
#define _UCXXLOCAL
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __GCC__
|
||||
#define __UCLIBCXX_NORETURN __attribute__ ((__noreturn__))
|
||||
#else
|
||||
#define __UCLIBCXX_NORETURN
|
||||
#endif
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_TLS__
|
||||
#define __UCLIBCXX_TLS __thread
|
||||
#else
|
||||
#define __UCLIBCXX_TLS
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
//Testing purposes
|
||||
#define __STRING_MAX_UNITS 65535
|
||||
|
||||
namespace std{
|
||||
typedef signed long int streamsize;
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __DODEBUG__
|
||||
#define UCLIBCXX_DEBUG 1
|
||||
#else
|
||||
#define UCLIBCXX_DEBUG 0
|
||||
#endif
|
||||
|
|
@ -0,0 +1,423 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <cstddef>
|
||||
#include <climits>
|
||||
#include <func_exception>
|
||||
#include <string>
|
||||
#include <iosfwd>
|
||||
|
||||
#ifndef __STD_BITSET_HEADER
|
||||
#define __STD_BITSET_HEADER 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
template <size_t N> class bitset;
|
||||
|
||||
|
||||
template <size_t N> bitset<N> operator&(const bitset<N>&, const bitset<N>&);
|
||||
template <size_t N> bitset<N> operator|(const bitset<N>&, const bitset<N>&);
|
||||
template <size_t N> bitset<N> operator^(const bitset<N>&, const bitset<N>&);
|
||||
template <class charT, class traits, size_t N> basic_istream<charT, traits>&
|
||||
operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
|
||||
|
||||
template <class charT, class traits, size_t N> basic_ostream<charT, traits>&
|
||||
operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
|
||||
|
||||
//Actual Code
|
||||
|
||||
|
||||
template<size_t N> class _UCXXEXPORT bitset {
|
||||
private:
|
||||
//Number of characters allocated to hold the bits
|
||||
static const size_t WORD_SIZE = CHAR_BIT; //Use int maybe?
|
||||
static const size_t num_bytes = (N + WORD_SIZE - 1) / WORD_SIZE;
|
||||
|
||||
//From the bit number, figure out which byte we are working with
|
||||
size_t byte_num(size_t bit_num) const{
|
||||
if(WORD_SIZE == 8){
|
||||
return (bit_num >> 3);
|
||||
}
|
||||
if(WORD_SIZE == 16){
|
||||
return (bit_num >> 4);
|
||||
}
|
||||
if(WORD_SIZE == 32){
|
||||
return (bit_num >> 5);
|
||||
}
|
||||
if(WORD_SIZE == 64){
|
||||
return (bit_num >> 6);
|
||||
}
|
||||
return bit_num / WORD_SIZE;
|
||||
}
|
||||
//From the bit number, figure out which bit inside the byte we need
|
||||
size_t bit_num(const size_t bit_num) const{
|
||||
return bit_num % WORD_SIZE;
|
||||
}
|
||||
|
||||
|
||||
//Point to the actual data
|
||||
char data[num_bytes];
|
||||
public:
|
||||
|
||||
class _UCXXEXPORT reference {
|
||||
friend class bitset;
|
||||
reference() : bit_num(0), parent(0) { }
|
||||
size_t bit_num;
|
||||
bitset * parent;
|
||||
public:
|
||||
~reference() { }
|
||||
reference& operator=(bool x){ // for b[i] = x;
|
||||
parent->set(bit_num, x);
|
||||
return *this;
|
||||
}
|
||||
reference& operator=(const reference& x){ // for b[i] = b[j];
|
||||
parent->set(bit_num, x);
|
||||
return *this;
|
||||
}
|
||||
bool operator~() const{ // flips the bit
|
||||
return !parent->test(bit_num);
|
||||
}
|
||||
operator bool() const{ // for x = b[i];
|
||||
return parent->test(bit_num);
|
||||
}
|
||||
reference& flip(){ // for b[i].flip();
|
||||
parent->flip(bit_num);
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
bitset(){
|
||||
reset();
|
||||
}
|
||||
bitset(unsigned long val){
|
||||
reset();
|
||||
size_t count = sizeof(val) * CHAR_BIT;
|
||||
if(count > N){
|
||||
count = N;
|
||||
}
|
||||
for(size_t i = 0; i < count; ++i){
|
||||
set(i, ((val >> i) & 1));
|
||||
}
|
||||
}
|
||||
|
||||
bitset(const bitset & val){
|
||||
for(size_t i = 0; i < num_bytes; ++i){
|
||||
data[i] = val.data[i];
|
||||
}
|
||||
}
|
||||
|
||||
template<class charT, class traits, class Allocator> _UCXXEXPORT
|
||||
explicit bitset(
|
||||
const basic_string<charT,traits,Allocator>& str,
|
||||
typename basic_string<charT,traits,Allocator>::size_type pos = 0,
|
||||
typename basic_string<charT,traits,Allocator>::size_type n =
|
||||
basic_string<charT>::npos
|
||||
|
||||
){
|
||||
reset();
|
||||
if(n > str.length()){
|
||||
n = str.length();
|
||||
}
|
||||
size_t width = n;
|
||||
if (width + pos > str.length()){
|
||||
width = str.length() - pos;
|
||||
}
|
||||
|
||||
for(size_t i = 0; i < width; ++i){
|
||||
switch(str[pos + width - i - 1]){
|
||||
case '0':
|
||||
break;
|
||||
case '1':
|
||||
set(i);
|
||||
break;
|
||||
default:
|
||||
__throw_invalid_argument();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bitset<N>& operator&=(const bitset<N>& rhs){
|
||||
for(size_t i =0; i < num_bytes; ++i){
|
||||
data[i] &= rhs.data[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
bitset<N>& operator|=(const bitset<N>& rhs){
|
||||
for(size_t i =0; i < num_bytes; ++i){
|
||||
data[i] |= rhs.data[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
bitset<N>& operator^=(const bitset<N>& rhs){
|
||||
for(size_t i=0; i < num_bytes; ++i){
|
||||
data[i] ^= rhs.data[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
bitset<N>& operator<<=(size_t pos){
|
||||
for(size_t i = N-1; i >=pos; --i){
|
||||
set(i, test(i - pos));
|
||||
}
|
||||
for(size_t i = 0; i < pos; ++i){
|
||||
reset(i);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
bitset<N>& operator>>=(size_t pos){
|
||||
for(size_t i = 0; i < (N - pos); ++i){
|
||||
set(i, test(i + pos));
|
||||
}
|
||||
for(size_t i = pos; i > 0; --i){
|
||||
reset(N - i);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
bitset<N>& set(){
|
||||
size_t i;
|
||||
for(i = 0; i < N ; ++i){
|
||||
data[byte_num(i)] |= (1<<bit_num(i));
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
bitset<N>& set(size_t pos, int val = true){
|
||||
if(val == true){
|
||||
data[byte_num(pos)] |= (1<<bit_num(pos));
|
||||
}else{
|
||||
data[byte_num(pos)] &= ~(1<<bit_num(pos));
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
bitset<N>& reset(){
|
||||
for(size_t i = 0; i < num_bytes; ++i){
|
||||
data[i] = 0;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
bitset<N>& reset(size_t pos){
|
||||
data[byte_num(pos)] &= ~(1<<bit_num(pos));
|
||||
return *this;
|
||||
}
|
||||
bitset<N> operator~() const{
|
||||
bitset<N> retval(*this);
|
||||
retval.flip();
|
||||
return retval;
|
||||
}
|
||||
|
||||
bitset<N>& flip(){
|
||||
for(size_t i = 0; i < num_bytes; ++i){
|
||||
data[i] = ~data[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
bitset<N>& flip(size_t pos){
|
||||
char temp = data[byte_num(pos)] & (1 << bit_num(pos));
|
||||
if(temp == 0){ //Bit was 0
|
||||
data[byte_num(pos)] |= (1 << bit_num(pos));
|
||||
}else{ //Bit was 1
|
||||
data[byte_num(pos)] &= ~(1<<bit_num(pos));
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
reference operator[](size_t pos){ // for b[i];
|
||||
reference retval;
|
||||
retval.parent = this;
|
||||
retval.bit_num = pos;
|
||||
return retval;
|
||||
}
|
||||
|
||||
unsigned long to_ulong() const{
|
||||
if(N > sizeof(unsigned long) * CHAR_BIT){
|
||||
__throw_overflow_error();
|
||||
}
|
||||
unsigned long retval = 0;
|
||||
size_t count = N;
|
||||
for(size_t i = count; i > 0; --i){
|
||||
if(test(i)){
|
||||
retval +=1;
|
||||
}
|
||||
retval<<=1;
|
||||
}
|
||||
if(test(0)){
|
||||
retval +=1;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string<charT, traits, Allocator> to_string() const
|
||||
{
|
||||
basic_string<charT, traits, Allocator> retval;
|
||||
retval.reserve(N);
|
||||
for(size_t i = N ; i > 0; --i){
|
||||
if(test(i-1) == true){
|
||||
retval.append("1");
|
||||
}else{
|
||||
retval.append("0");
|
||||
}
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
size_t count() const{
|
||||
size_t retval = 0;
|
||||
for(size_t i =0; i < N; ++i){
|
||||
if(test(i)){
|
||||
++retval;
|
||||
}
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
size_t size() const{
|
||||
return N;
|
||||
}
|
||||
|
||||
bitset<N>& operator=(const bitset<N> & rhs){
|
||||
if(&rhs == this){
|
||||
return *this;
|
||||
}
|
||||
for(size_t i = 0; i <= byte_num(N); ++i){
|
||||
data[i] = rhs.data[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
bool operator==(const bitset<N>& rhs) const{
|
||||
for(size_t i =0; i< N; ++i){
|
||||
if(test(i) != rhs.test(i)){
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool operator!=(const bitset<N>& rhs) const{
|
||||
for(size_t i =0; i< N; ++i){
|
||||
if(test(i) != rhs.test(i)){
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool test(size_t pos) const{
|
||||
return (data[byte_num(pos)] & (1<<bit_num(pos)) ) != 0;
|
||||
}
|
||||
|
||||
bool any() const{
|
||||
for(size_t i = 0; i< N; ++i){
|
||||
if(test(i)==true){
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool none() const{
|
||||
if(any() == true){
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bitset<N> operator<<(size_t pos) const{
|
||||
bitset retval(*this);
|
||||
retval<<=pos;
|
||||
return retval;
|
||||
}
|
||||
bitset<N> operator>>(size_t pos) const{
|
||||
bitset retval(*this);
|
||||
retval>>=pos;
|
||||
return retval;
|
||||
}
|
||||
};
|
||||
|
||||
//Non-member functions
|
||||
|
||||
|
||||
template <size_t N> _UCXXEXPORT bitset<N> operator&(const bitset<N>& lhs, const bitset<N>& rhs){
|
||||
bitset<N> retval(lhs);
|
||||
retval &= rhs;
|
||||
return retval;
|
||||
}
|
||||
|
||||
template <size_t N> _UCXXEXPORT bitset<N> operator|(const bitset<N>& lhs, const bitset<N>& rhs){
|
||||
bitset<N> retval(lhs);
|
||||
retval |= rhs;
|
||||
return retval;
|
||||
}
|
||||
|
||||
template <size_t N> _UCXXEXPORT bitset<N> operator^(const bitset<N>& lhs, const bitset<N>& rhs){
|
||||
bitset<N> retval(lhs);
|
||||
retval ^= rhs;
|
||||
return retval;
|
||||
}
|
||||
|
||||
template <class charT, class traits, size_t N> _UCXXEXPORT basic_istream<charT, traits>&
|
||||
operator>>(basic_istream<charT, traits>& is, bitset<N>& x)
|
||||
{
|
||||
string s;
|
||||
charT c;
|
||||
for(size_t i = 0; i < N; ++i){
|
||||
is.get(c);
|
||||
if(!is.good()){
|
||||
break;
|
||||
}
|
||||
if(c != '1' && c !='0'){
|
||||
is.putback(c);
|
||||
break;
|
||||
}
|
||||
s+=c;
|
||||
}
|
||||
bitset<N> temp(s);
|
||||
x = temp;
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
template <class charT, class traits, size_t N> _UCXXEXPORT basic_ostream<charT, traits>&
|
||||
operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x)
|
||||
{
|
||||
for(size_t i = N ; i > 0; --i){
|
||||
if(x.test(i-1) == true){
|
||||
os << "1";
|
||||
}else{
|
||||
os << "0";
|
||||
}
|
||||
}
|
||||
return os;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <setjmp.h>
|
||||
|
||||
#ifndef __STD_HEADER_CFLOAT
|
||||
#define __STD_HEADER_CFLOAT 1
|
||||
|
||||
|
||||
#include <float.h>
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,215 @@
|
|||
//***************************************************************************
|
||||
// include/cxx/cerrno
|
||||
//
|
||||
// Copyright (C) 2009 Gregory Nutt. All rights reserved.
|
||||
// Author: Gregory Nutt <gnutt@nuttx.org>
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions
|
||||
// are met:
|
||||
//
|
||||
// 1. Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// 2. Redistributions in binary form must reproduce the above copyright
|
||||
// notice, this list of conditions and the following disclaimer in
|
||||
// the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// 3. Neither the name NuttX nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
//***************************************************************************
|
||||
//#ifndef __INCLUDE_CXX_CHAR1_TRAITS
|
||||
//#define __INCLUDE_CXX_CHAR1_TRAITS
|
||||
#include <basic_definitions>
|
||||
#include <string.h>
|
||||
#include <exception>
|
||||
#include <memory>
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
#include <cwchar>
|
||||
#include <cwctype>
|
||||
#endif
|
||||
|
||||
#ifndef __HEADER_CHAR_TRAITS
|
||||
#define __HEADER_CHAR_TRAITS 1
|
||||
|
||||
namespace std{
|
||||
/* Inlining all wrapped function calls to shrink the amount of code generated*/
|
||||
//Typedefs to use for stuff
|
||||
typedef signed int char_traits_off_type;
|
||||
|
||||
//Generic char_traits
|
||||
template<class charT> struct _UCXXEXPORT char_traits { };
|
||||
|
||||
//Specialize for char
|
||||
template<> struct _UCXXEXPORT char_traits<char> {
|
||||
typedef char char_type;
|
||||
typedef short int int_type;
|
||||
typedef char_traits_off_type off_type;
|
||||
typedef char_traits_off_type pos_type;
|
||||
typedef char state_type;
|
||||
|
||||
inline static void assign(char_type & c, const char_type & d) { c = d; }
|
||||
|
||||
static bool eq(const char_type& c1, const char_type& c2);
|
||||
|
||||
static char_type to_char_type(const int_type & i);
|
||||
|
||||
inline static int_type to_int_type(const char_type & c){
|
||||
return (short int)(unsigned char)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 lt(const char_type& c1, const char_type& c2){
|
||||
if(strncmp(&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*) memmove(s1, s2, n);
|
||||
}
|
||||
|
||||
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 *)memset(s, a, n);
|
||||
}
|
||||
|
||||
inline static int compare(const char_type* s1, const char_type* s2, size_t n){
|
||||
return strncmp(s1, s2, n);
|
||||
}
|
||||
|
||||
inline static size_t length(const char_type* s){
|
||||
return wstrlen(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 -1; }
|
||||
inline static int_type not_eof(const int_type & i) {
|
||||
if(i == -1){
|
||||
return 0;
|
||||
} else {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
static state_type get_state(pos_type p){
|
||||
p = p;
|
||||
state_type a;
|
||||
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
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
/* Copyright (C) 2005 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef __STD_HEADER_CLOCALE
|
||||
#define __STD_HEADER_CLOCALE 1
|
||||
|
||||
#include <locale.h>
|
||||
|
||||
namespace std {
|
||||
using ::lconv;
|
||||
using ::setlocale;
|
||||
using ::localeconv;
|
||||
}
|
||||
|
||||
#endif // __STD_HEADER_CLOCALE
|
||||
|
|
@ -0,0 +1,327 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
|
||||
#ifndef __STD_HEADER_COMPLEX
|
||||
#define __STD_HEADER_COMPLEX 1
|
||||
|
||||
|
||||
namespace std {
|
||||
// class complex<float>;
|
||||
// class complex<double>;
|
||||
// class complex<long double>;
|
||||
|
||||
template<class T> class _UCXXEXPORT complex{
|
||||
public:
|
||||
typedef T value_type;
|
||||
|
||||
complex(const T& re = T(), const T& im = T()) : r(re), i(im) { }
|
||||
complex(const complex& c): r(c.r), i(c.i){ }
|
||||
template<class X> complex(const complex<X>& c): r(c.r), i(c.i){ }
|
||||
|
||||
inline T real() const{
|
||||
return r;
|
||||
}
|
||||
inline T imag() const{
|
||||
return i;
|
||||
}
|
||||
|
||||
complex<T>& operator= (const T& v){
|
||||
r = v;
|
||||
i = 0;
|
||||
return *this;
|
||||
}
|
||||
complex<T>& operator+=(const T& v){
|
||||
r +=v;
|
||||
return *this;
|
||||
}
|
||||
complex<T>& operator-=(const T& v){
|
||||
r -=v;
|
||||
return *this;
|
||||
}
|
||||
complex<T>& operator*=(const T& v){
|
||||
r*=v;
|
||||
i*=v;
|
||||
return *this;
|
||||
}
|
||||
complex<T>& operator/=(const T& v){
|
||||
r/=v;
|
||||
i/=v;
|
||||
return *this;
|
||||
}
|
||||
complex& operator=(const complex& v){
|
||||
if(&v != this){
|
||||
r = v.r;
|
||||
i = v.i;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
template<class X> complex<T>& operator= (const complex<X>& v){
|
||||
r = v.r;
|
||||
i = v.i;
|
||||
return *this;
|
||||
}
|
||||
template<class X> complex<T>& operator+=(const complex<X>& v){
|
||||
r+=v.r;
|
||||
i+=v.i;
|
||||
return *this;
|
||||
}
|
||||
template<class X> complex<T>& operator-=(const complex<X>& v){
|
||||
r-=v.r;
|
||||
i-=v.i;
|
||||
return *this;
|
||||
}
|
||||
template<class X> complex<T>& operator*=(const complex<X>& v){
|
||||
T tempr = r*v.r - i*v.i;
|
||||
T tempi = r*v.i + i*v.r;
|
||||
r = tempr;
|
||||
i = tempi;
|
||||
return *this;
|
||||
}
|
||||
template<class X> complex<T>& operator/=(const complex<X>& v){
|
||||
T tempr = (r*v.r + i*v.i) / (v.r*v.r + v.i*v.i);
|
||||
T tempi = (i*v.r - r*v.i) / (v.r*v.r + v.i*v.i);
|
||||
r = tempr;
|
||||
i = tempi;
|
||||
return *this;
|
||||
}
|
||||
private:
|
||||
T r;
|
||||
T i;
|
||||
};
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> operator+(const complex<T>& ls, const complex<T>& rs){
|
||||
complex<T> retval(ls);
|
||||
retval += rs;
|
||||
return retval;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator+(const complex<T>& ls, const T& rs){
|
||||
complex<T> retval(ls);
|
||||
ls += rs;
|
||||
return retval;
|
||||
}
|
||||
template<class T> _UCXXEXPORT inline complex<T> operator+(const T& ls, const complex<T>& rs){
|
||||
return rs + ls;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator-(const complex<T>& ls, const complex<T>& rs){
|
||||
complex<T> retval(ls);
|
||||
retval -= rs;
|
||||
return retval;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator-(const complex<T>& ls, const T& rs){
|
||||
complex<T> retval(ls);
|
||||
retval -= rs;
|
||||
return retval;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator-(const T& ls, const complex<T>& rs){
|
||||
complex<T> retval(ls);
|
||||
retval -= rs;
|
||||
return retval;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator*(const complex<T>& ls, const complex<T>& rs){
|
||||
complex<T> retval(ls);
|
||||
retval *= rs;
|
||||
return retval;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator*(const complex<T>& ls, const T& rs){
|
||||
complex<T> retval(ls);
|
||||
retval *= rs;
|
||||
return retval;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator*(const T& ls, const complex<T>& rs){
|
||||
complex<T> retval(ls);
|
||||
retval *=rs;
|
||||
return retval;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator/(const complex<T>& ls, const complex<T>& rs){
|
||||
complex<T> retval(ls);
|
||||
retval/=rs;
|
||||
return retval;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator/(const complex<T>& ls, const T& rs){
|
||||
complex<T> retval(ls);
|
||||
retval/=rs;
|
||||
return retval;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator/(const T& ls, const complex<T>& rs){
|
||||
complex<T> retval(ls);
|
||||
retval/=rs;
|
||||
return retval;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator+(const complex<T>& v){
|
||||
return v;
|
||||
}
|
||||
template<class T> _UCXXEXPORT complex<T> operator-(const complex<T>& v){
|
||||
return complex<T> (-v.real(), -v.imag());
|
||||
}
|
||||
template<class T> _UCXXEXPORT bool operator==(const complex<T>& ls, const complex<T>& rs){
|
||||
if( ls.real() == rs.real() && ls.imag() == rs.image()){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
template<class T> _UCXXEXPORT bool operator==(const complex<T>& ls, const T& rs){
|
||||
if(ls.real() == rs && ls.imag() == T()){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
template<class T> _UCXXEXPORT bool operator==(const T& ls, const complex<T>& rs){
|
||||
if(ls == rs.real() && rs.imag() == T()){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
template<class T> _UCXXEXPORT bool operator!=(const complex<T>& ls, const complex<T>& rs){
|
||||
if(ls == rs){
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
template<class T> _UCXXEXPORT bool operator!=(const complex<T>& ls, const T& rs){
|
||||
if(ls == rs){
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
template<class T> _UCXXEXPORT bool operator!=(const T& ls, const complex<T>& rs){
|
||||
if(ls == rs){
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
template<class T, class charT, class traits> _UCXXEXPORT basic_istream<charT, traits>&
|
||||
operator>>(basic_istream<charT, traits>& is, complex<T>& v)
|
||||
{
|
||||
T tempr;
|
||||
T tempi;
|
||||
is >> tempr;
|
||||
is.get();
|
||||
is >> tempi;
|
||||
v = complex<T>(tempr, tempi);
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class T, class charT, class traits> _UCXXEXPORT basic_ostream<charT, traits>&
|
||||
operator<<(basic_ostream<charT, traits>& os, const complex<T>&v)
|
||||
{
|
||||
os << v.real() << ", " << v.imag();
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT T real(const complex<T>& v){
|
||||
return v.real();
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT T imag(const complex<T>& v){
|
||||
return v.imag();
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT T norm(const complex<T>& v){
|
||||
return (v.real() * v.real() + v.imag() * v.imag());
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> conj(const complex<T>& v){
|
||||
return complex<T>(v.real(), -v.imag());
|
||||
}
|
||||
|
||||
#ifdef __UCLIBCXX_SUPPORT_MATH__ //Can we link with libm?
|
||||
|
||||
template<class T> _UCXXEXPORT T abs(const complex<T>& v){
|
||||
return sqrt(v.real() * v.real() + v.imag() * v.imag());
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT T arg(const complex<T>& v){
|
||||
return atan2(v.imag(), v.real());
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> polar(const T& rho, const T& theta){
|
||||
return complex<T>(rho * cos(theta), rho * sin(theta));
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> cos (const complex<T>& v){
|
||||
return complex<T>(cos(v.real()) * cosh(v.imag()), -sin(v.real()) * sinh(v.imag()));
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> cosh (const complex<T>& v){
|
||||
return complex<T>(cosh(v.real()) * cos(v.imag()), sinh(v.real()) * sin(v.imag()));
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> exp (const complex<T>& v){
|
||||
return polar(exp(v.real()), v.imag());
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> log (const complex<T>& v){
|
||||
return complex<T>(log(abs(v)), arg(v));
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> log10(const complex<T>& v){
|
||||
return (log(v) / log(T(10.0)));
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> pow(const complex<T>& v, int p){
|
||||
T rho = pow(abs(v), p);
|
||||
T theta = arg(v);
|
||||
return complex<T>(rho * cos(p * theta), rho * sin(p * theta) );
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> pow(const complex<T>& v, const T& p){
|
||||
return polar( pow(abs(v),p), arg(v)*p );
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> pow(const complex<T>& v, const complex<T>& p){
|
||||
if(v == T()){
|
||||
//We are using "0" as the value
|
||||
return T();
|
||||
}
|
||||
return exp(p * log(v));
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> pow(const T& v, const complex<T>& p){
|
||||
if(v == T()){
|
||||
return T();
|
||||
}
|
||||
return polar(pow(v,p.real()), y.imag() * log(x) );
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> sin (const complex<T>& v){
|
||||
return complex<T>(sin(v.real()) * cosh(v.imag()), cosh(v.real()) * sin(v.imag()));
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> sinh (const complex<T>& v){
|
||||
return complext<T>(sinh(v.real()) * cos(v.imag()), cosh(v.real()) * sin(v.imag()) );
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> sqrt (const complex<T>&);
|
||||
template<class T> _UCXXEXPORT complex<T> tan (const complex<T>& v){
|
||||
return sin(v) / cos(v);
|
||||
}
|
||||
|
||||
template<class T> _UCXXEXPORT complex<T> tanh (const complex<T>& v){
|
||||
return sinh(v) / cosh(v);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <setjmp.h>
|
||||
|
||||
#ifndef __STD_HEADER_CSETJMP
|
||||
#define __STD_HEADER_CSETJMP 1
|
||||
|
||||
|
||||
//From GCC Header files
|
||||
#undef longjmp
|
||||
|
||||
// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
|
||||
#ifndef setjmp
|
||||
#define setjmp(env) setjmp (env)
|
||||
#endif
|
||||
|
||||
//Mine again
|
||||
|
||||
|
||||
namespace std{
|
||||
using ::longjmp;
|
||||
using ::jmp_buf;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,86 @@
|
|||
/* Copyright (C) 2006 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation version 2.1
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <wchar.h>
|
||||
#include <basic_definitions>
|
||||
|
||||
#ifndef __HEADER_CWCHAR
|
||||
#define __HEADER_CWCHAR 1
|
||||
|
||||
|
||||
namespace std{
|
||||
using ::mbstate_t;
|
||||
using ::wint_t;
|
||||
|
||||
using ::btowc;
|
||||
using ::fgetwc;
|
||||
using ::fgetws;
|
||||
using ::fputwc;
|
||||
using ::fputws;
|
||||
using ::fwide;
|
||||
using ::fwprintf;
|
||||
using ::fwscanf;
|
||||
using ::getwc;
|
||||
using ::getwchar;
|
||||
using ::mbrlen;
|
||||
using ::mbrtowc;
|
||||
using ::mbsinit;
|
||||
using ::mbsrtowcs;
|
||||
using ::putwc;
|
||||
using ::putwchar;
|
||||
using ::swprintf;
|
||||
using ::swscanf;
|
||||
using ::ungetwc;
|
||||
using ::vfwprintf;
|
||||
using ::vswprintf;
|
||||
using ::vwprintf;
|
||||
using ::wcrtomb;
|
||||
using ::wcscat;
|
||||
using ::wcschr;
|
||||
using ::wcscmp;
|
||||
using ::wcscoll;
|
||||
using ::wcscpy;
|
||||
using ::wcscspn;
|
||||
using ::wcsftime;
|
||||
using ::wcslen;
|
||||
using ::wcsncat;
|
||||
using ::wcsncmp;
|
||||
using ::wcsncpy;
|
||||
using ::wcspbrk;
|
||||
using ::wcsrchr;
|
||||
using ::wcsrtombs;
|
||||
using ::wcsspn;
|
||||
using ::wcsstr;
|
||||
using ::wcstod;
|
||||
using ::wcstok;
|
||||
using ::wcstol;
|
||||
using ::wcstoul;
|
||||
using ::wcsxfrm;
|
||||
using ::wctob;
|
||||
using ::wmemchr;
|
||||
using ::wmemcmp;
|
||||
using ::wmemcpy;
|
||||
using ::wmemmove;
|
||||
using ::wmemset;
|
||||
using ::wprintf;
|
||||
using ::wscanf;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,106 @@
|
|||
// -*- C++ -*- forwarding header.
|
||||
|
||||
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
|
||||
// Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
//
|
||||
// ISO C++ 14882: <cwctype>
|
||||
//
|
||||
|
||||
/** @file cwctype
|
||||
* This is a Standard C++ Library file. You should @c #include this file
|
||||
* in your programs, rather than any of the "*.h" implementation files.
|
||||
*
|
||||
* This is the C++ version of the Standard C Library header @c wctype.h,
|
||||
* and its contents are (mostly) the same as that header, but are all
|
||||
* contained in the namespace @c std.
|
||||
*/
|
||||
|
||||
#ifndef _CPP_CWCTYPE
|
||||
#define _CPP_CWCTYPE 1
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
//#include <bits/c++config.h>
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
#include <wctype.h>
|
||||
#endif
|
||||
|
||||
// Get rid of those macros defined in <wctype.h> in lieu of real functions.
|
||||
#undef iswalnum
|
||||
#undef iswalpha
|
||||
#undef iswblank
|
||||
#undef iswcntrl
|
||||
#undef iswdigit
|
||||
#undef iswgraph
|
||||
#undef iswlower
|
||||
#undef iswprint
|
||||
#undef iswprint
|
||||
#undef iswpunct
|
||||
#undef iswspace
|
||||
#undef iswupper
|
||||
#undef iswxdigit
|
||||
#undef iswctype
|
||||
#undef towlower
|
||||
#undef towupper
|
||||
#undef towctrans
|
||||
#undef wctrans
|
||||
#undef wctype
|
||||
|
||||
#if __UCLIBCXX_HAS_WCHAR__
|
||||
namespace std
|
||||
{
|
||||
using ::wint_t; // cwchar
|
||||
|
||||
using ::wctype_t;
|
||||
using ::wctrans_t;
|
||||
|
||||
using ::iswalnum;
|
||||
using ::iswalpha;
|
||||
using ::iswblank;
|
||||
using ::iswcntrl;
|
||||
using ::iswdigit;
|
||||
using ::iswgraph;
|
||||
using ::iswlower;
|
||||
using ::iswprint;
|
||||
using ::iswprint;
|
||||
using ::iswpunct;
|
||||
using ::iswspace;
|
||||
using ::iswupper;
|
||||
using ::iswxdigit;
|
||||
using ::iswctype;
|
||||
using ::towlower;
|
||||
using ::towupper;
|
||||
using ::towctrans;
|
||||
using ::wctrans;
|
||||
using ::wctype;
|
||||
}
|
||||
#endif //__ULIBCXX_HAS_WCHAR__
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,884 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
|
||||
#include <memory>
|
||||
#include <iterator>
|
||||
#include <stdexcept>
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
#ifndef __STD_HEADER_DEQUE
|
||||
#define __STD_HEADER_DEQUE
|
||||
|
||||
|
||||
namespace std{
|
||||
template <class T, class Allocator = allocator<T> > class deque;
|
||||
template <class T, class Allocator> bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
|
||||
template <class T, class Allocator> void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
|
||||
|
||||
template <class T, class Allocator> class _UCXXEXPORT deque {
|
||||
public:
|
||||
friend bool operator==<>(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
|
||||
friend class deque_iter;
|
||||
friend class deque_citer;
|
||||
class deque_iter;
|
||||
class deque_citer;
|
||||
|
||||
typedef typename Allocator::reference reference;
|
||||
typedef typename Allocator::const_reference const_reference;
|
||||
typedef deque_iter iterator;
|
||||
typedef deque_citer const_iterator;
|
||||
typedef typename Allocator::size_type size_type;
|
||||
typedef typename Allocator::difference_type difference_type;
|
||||
typedef T value_type;
|
||||
typedef Allocator allocator_type;
|
||||
typedef typename Allocator::pointer pointer;
|
||||
typedef typename Allocator::const_pointer const_pointer;
|
||||
typedef std::reverse_iterator<iterator> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
|
||||
explicit deque(const Allocator& al = Allocator());
|
||||
explicit deque(size_type n, const T& value = T(), const Allocator& al = Allocator());
|
||||
template <class InputIterator> deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
|
||||
deque(const deque<T,Allocator>& x);
|
||||
~deque();
|
||||
|
||||
deque<T,Allocator>& operator=(const deque<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());
|
||||
allocator_type get_allocator() const;
|
||||
|
||||
iterator begin();
|
||||
const_iterator begin() const;
|
||||
iterator end();
|
||||
const_iterator end() const;
|
||||
reverse_iterator rbegin();
|
||||
const_reverse_iterator rbegin() const;
|
||||
reverse_iterator rend();
|
||||
const_reverse_iterator rend() const;
|
||||
|
||||
size_type size() const;
|
||||
size_type max_size() const;
|
||||
void resize(size_type sz, T c = T());
|
||||
bool empty() const;
|
||||
|
||||
reference operator[](size_type n);
|
||||
const_reference operator[](size_type n) const;
|
||||
reference at(size_type n);
|
||||
const_reference at(size_type n) const;
|
||||
reference front();
|
||||
const_reference front() const;
|
||||
reference back();
|
||||
const_reference back() const;
|
||||
|
||||
void push_front(const T& x);
|
||||
void push_back(const T& x);
|
||||
iterator insert(iterator position, const T& x = T());
|
||||
void insert(iterator position, size_type n, const T& x);
|
||||
template <class InputIterator> void insert (iterator position, InputIterator first, InputIterator last);
|
||||
void pop_front();
|
||||
void pop_back();
|
||||
|
||||
iterator erase(iterator position);
|
||||
iterator erase(iterator first, iterator last);
|
||||
void swap(deque<T,Allocator>&);
|
||||
void clear();
|
||||
|
||||
protected:
|
||||
void reserve(size_type n);
|
||||
inline size_type array_element(size_type deque_element) const{
|
||||
if(deque_element < (data_size - first_element)){
|
||||
return first_element + deque_element;
|
||||
}
|
||||
return deque_element - (data_size - first_element);
|
||||
}
|
||||
inline size_type first_subtract(size_type sub_size) const{
|
||||
if(sub_size > first_element){
|
||||
return (data_size - first_element) - sub_size;
|
||||
}
|
||||
return first_element - sub_size;
|
||||
}
|
||||
|
||||
T * data;
|
||||
size_type data_size; //Physical size of array
|
||||
size_type elements; //Elements in array
|
||||
size_type first_element; //Element number of array 0..n
|
||||
size_type last_element; //Element number of array 0..n
|
||||
Allocator a;
|
||||
|
||||
};
|
||||
|
||||
|
||||
template<class T, class Allocator> class _UCXXEXPORT deque<T, Allocator>::deque_iter
|
||||
: public std::iterator<
|
||||
random_access_iterator_tag,
|
||||
T,
|
||||
typename Allocator::difference_type,
|
||||
typename Allocator::pointer,
|
||||
typename Allocator::reference
|
||||
>
|
||||
{
|
||||
friend class deque<T, Allocator>;
|
||||
protected:
|
||||
deque<T, Allocator> * container;
|
||||
typename Allocator::size_type element;
|
||||
|
||||
public:
|
||||
deque_iter() : container(0), element(0) { }
|
||||
deque_iter(const deque_iter & d) : container (d.container), element(d.element) { }
|
||||
deque_iter(deque<T, Allocator> * c, typename Allocator::size_type e)
|
||||
: container(c), element(e)
|
||||
{
|
||||
return;
|
||||
}
|
||||
~deque_iter() { }
|
||||
deque_iter & operator=(const deque_iter & d){
|
||||
container = d.container;
|
||||
element = d.element;
|
||||
return *this;
|
||||
}
|
||||
T & operator*(){
|
||||
return container->data[container->array_element(element)];
|
||||
}
|
||||
T * operator->(){
|
||||
return container->data + container->array_element(element);
|
||||
}
|
||||
const T & operator*() const{
|
||||
return container->data[container->array_element(element)];
|
||||
}
|
||||
const T * operator->() const{
|
||||
return container->data + container->array_element(element);
|
||||
}
|
||||
bool operator==(const deque_iter & d) const{
|
||||
if(container == d.container && element == d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator==(const deque_citer & d) const{
|
||||
if(container == d.container && element == d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator!=(const deque_iter & d) const{
|
||||
if(container != d.container || element != d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator!=(const deque_citer & d) const{
|
||||
if(container != d.container || element != d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator<(const deque_iter & d) const{
|
||||
if(element < d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator<(const deque_citer & d) const{
|
||||
if(element < d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator<=(const deque_iter & d) const{
|
||||
if(element <= d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator<=(const deque_citer & d) const{
|
||||
if(element <= d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator>(const deque_iter & d) const{
|
||||
if(element > d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator>(const deque_citer & d) const{
|
||||
if(element > d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator>=(const deque_iter & d) const{
|
||||
if(element >= d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator>=(const deque_citer & d) const{
|
||||
if(element >= d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
deque_iter & operator++(){
|
||||
++element;
|
||||
return *this;
|
||||
}
|
||||
deque_iter operator++(int){
|
||||
deque_iter temp(container, element);
|
||||
++element;
|
||||
return temp;
|
||||
}
|
||||
deque_iter operator+(typename Allocator::size_type n){
|
||||
deque_iter temp(container, element + n);
|
||||
return temp;
|
||||
}
|
||||
deque_iter & operator+=(typename Allocator::size_type n){
|
||||
element += n;
|
||||
return *this;
|
||||
}
|
||||
deque_iter & operator--(){
|
||||
--element;
|
||||
return *this;
|
||||
}
|
||||
deque_iter operator--(int){
|
||||
deque_iter temp(container, element);
|
||||
--element;
|
||||
return temp;
|
||||
}
|
||||
deque_iter operator-(typename Allocator::size_type n){
|
||||
deque_iter temp(container, element - n);
|
||||
return temp;
|
||||
}
|
||||
deque_iter & operator-=(typename Allocator::size_type n){
|
||||
element -= n;
|
||||
return *this;
|
||||
}
|
||||
typename Allocator::size_type operator-(const deque_iter & d){
|
||||
return element - d.element;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
template<class T, class Allocator> class _UCXXEXPORT deque<T, Allocator>::deque_citer
|
||||
: public std::iterator<
|
||||
random_access_iterator_tag,
|
||||
T,
|
||||
typename Allocator::difference_type,
|
||||
typename Allocator::const_pointer,
|
||||
typename Allocator::const_reference
|
||||
>
|
||||
{
|
||||
friend class deque<T, Allocator>;
|
||||
protected:
|
||||
const deque<T, Allocator> * container;
|
||||
typename Allocator::size_type element;
|
||||
|
||||
public:
|
||||
deque_citer() : container(0), element(0) { }
|
||||
deque_citer(const deque_citer & d) : container (d.container), element(d.element) { }
|
||||
deque_citer(const deque_iter & d) : container (d.container), element(d.element) { }
|
||||
deque_citer(const deque<T, Allocator> * c, typename Allocator::size_type e)
|
||||
: container(c), element(e)
|
||||
{
|
||||
return;
|
||||
}
|
||||
~deque_citer() { }
|
||||
deque_citer & operator=(const deque_iter & d){
|
||||
container = d.container;
|
||||
element = d.element;
|
||||
return *this;
|
||||
}
|
||||
const T & operator*() const{
|
||||
return container->data[container->array_element(element)];
|
||||
}
|
||||
const T * operator->() const{
|
||||
return container->data + container->array_element(element);
|
||||
}
|
||||
bool operator==(const deque_citer & d) const{
|
||||
if(container == d.container && element == d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator==(const deque_iter & d) const{
|
||||
if(container == d.container && element == d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator!=(const deque_citer & d) const{
|
||||
if(container != d.container || element != d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator!=(const deque_iter & d) const{
|
||||
if(container != d.container || element != d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator<(const deque_citer & d) const{
|
||||
if(element < d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator<(const deque_iter & d) const{
|
||||
if(element < d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator<=(const deque_citer & d) const{
|
||||
if(element <= d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator<=(const deque_iter & d) const{
|
||||
if(element <= d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator>(const deque_citer & d) const{
|
||||
if(element > d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator>(const deque_iter & d) const{
|
||||
if(element > d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator>=(const deque_citer & d){
|
||||
if(element >= d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool operator>=(const deque_iter & d){
|
||||
if(element >= d.element){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
deque_citer & operator++(){
|
||||
++element;
|
||||
return *this;
|
||||
}
|
||||
deque_citer operator++(int){
|
||||
deque_citer temp(container, element);
|
||||
++element;
|
||||
return temp;
|
||||
}
|
||||
deque_citer operator+(typename Allocator::size_type n){
|
||||
deque_citer temp(container, element + n);
|
||||
return temp;
|
||||
}
|
||||
deque_citer & operator+=(typename Allocator::size_type n){
|
||||
element += n;
|
||||
return *this;
|
||||
}
|
||||
deque_citer & operator--(){
|
||||
--element;
|
||||
return *this;
|
||||
}
|
||||
deque_citer operator--(int){
|
||||
deque_citer temp(container, element);
|
||||
--element;
|
||||
return temp;
|
||||
}
|
||||
deque_citer operator-(typename Allocator::size_type n){
|
||||
deque_citer temp(container, element - n);
|
||||
return temp;
|
||||
}
|
||||
deque_citer & operator-=(typename Allocator::size_type n){
|
||||
element -= n;
|
||||
return *this;
|
||||
}
|
||||
typename Allocator::size_type operator-(const deque_citer & d){
|
||||
return element - d.element;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
template<class T, class Allocator> deque<T, Allocator>::deque(const Allocator& al)
|
||||
: data(0),
|
||||
data_size(0), elements(0), first_element(0), last_element(0), a(al)
|
||||
{
|
||||
data_size = __UCLIBCXX_STL_BUFFER_SIZE__;
|
||||
data = a.allocate(data_size);
|
||||
first_element = data_size /2;
|
||||
last_element = first_element;
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> deque<T, Allocator>::deque(
|
||||
size_type n, const T& value, const Allocator& al)
|
||||
: data(0),
|
||||
elements(n), first_element(0), last_element(0), a(al)
|
||||
{
|
||||
data_size = elements + __UCLIBCXX_STL_BUFFER_SIZE__;
|
||||
data = a.allocate(data_size);
|
||||
first_element = (data_size - elements) / 2;
|
||||
last_element = first_element;
|
||||
|
||||
for(n=first_element ; n < last_element; ++n ){
|
||||
a.construct(data+n, value);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> template <class InputIterator>
|
||||
deque<T, Allocator>::deque(InputIterator first, InputIterator last, const Allocator& al)
|
||||
: data(0),
|
||||
data_size(0), elements(0), first_element(0), last_element(0), a(al)
|
||||
{
|
||||
data_size = __UCLIBCXX_STL_BUFFER_SIZE__;
|
||||
data = a.allocate(data_size);
|
||||
first_element = data_size / 4; //Note sure how big, but let's add a little space...
|
||||
last_element = first_element;
|
||||
while(first != last){
|
||||
push_back(*first);
|
||||
++first;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> deque<T, Allocator>::deque(const deque<T,Allocator>& x)
|
||||
: data(0),
|
||||
elements(0), first_element(0), last_element(0), a(x.a)
|
||||
{
|
||||
data_size = x.elements + __UCLIBCXX_STL_BUFFER_SIZE__;
|
||||
data = a.allocate(data_size);
|
||||
first_element = (data_size - x.elements) / 2;
|
||||
last_element = first_element;
|
||||
for(size_type i=0; i < x.elements; ++i){
|
||||
push_back(x[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> deque<T, Allocator>::~deque(){
|
||||
clear();
|
||||
a.deallocate(data, data_size);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> deque<T,Allocator>& deque<T, Allocator>::
|
||||
operator=(const deque<T,Allocator>& x)
|
||||
{
|
||||
if(&x == this){
|
||||
return *this;
|
||||
}
|
||||
resize(x.elements);
|
||||
for(size_t i = 0; i < elements; ++i){
|
||||
data[array_element(i)] = x[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> template <class InputIterator> void
|
||||
deque<T, Allocator>::assign(InputIterator first, InputIterator last)
|
||||
{
|
||||
clear();
|
||||
while(first !=last){
|
||||
push_back(*first);
|
||||
++first;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> template <class Size, class U> void
|
||||
deque<T, Allocator>::assign(Size n, const U& u)
|
||||
{
|
||||
if(&u == this){
|
||||
return;
|
||||
}
|
||||
clear();
|
||||
for(size_type i = 0; i < n; ++i){
|
||||
push_back(u);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> typename deque<T, Allocator>::allocator_type
|
||||
deque<T, Allocator>::get_allocator() const
|
||||
{
|
||||
return a;
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::iterator deque<T, Allocator>::begin()
|
||||
{
|
||||
return deque_iter(this, 0);
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> typename deque<T, Allocator>::const_iterator
|
||||
deque<T, Allocator>::begin() const
|
||||
{
|
||||
return deque_citer(this, 0);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::iterator deque<T, Allocator>::end()
|
||||
{
|
||||
return deque_iter(this, elements);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::const_iterator deque<T, Allocator>::end() const
|
||||
{
|
||||
return deque_citer(this, elements);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::reverse_iterator deque<T, Allocator>::rbegin()
|
||||
{
|
||||
return reverse_iterator(end());
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::const_reverse_iterator deque<T, Allocator>::rbegin() const
|
||||
{
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::reverse_iterator deque<T, Allocator>::rend()
|
||||
{
|
||||
return reverse_iterator(begin());
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::const_reverse_iterator deque<T, Allocator>::rend() const
|
||||
{
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::size_type deque<T, Allocator>::size() const
|
||||
{
|
||||
return elements;
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::size_type deque<T, Allocator>::max_size() const
|
||||
{
|
||||
return ((size_type)(-1)) / sizeof(T);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void deque<T, Allocator>::resize(size_type sz, T c){
|
||||
reserve(sz);
|
||||
while(sz > size()){
|
||||
push_back(c);
|
||||
}
|
||||
while(sz < size()){
|
||||
pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> bool deque<T, Allocator>::empty() const{
|
||||
return (elements == 0);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::reference deque<T, Allocator>::operator[](size_type n)
|
||||
{
|
||||
return data[array_element(n)];
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::const_reference deque<T, Allocator>::operator[](size_type n) const
|
||||
{
|
||||
return data[array_element(n)];
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::reference deque<T, Allocator>::at(size_type n)
|
||||
{
|
||||
if(n > elements){
|
||||
__throw_out_of_range("Out of deque range");
|
||||
}
|
||||
return data[array_element(n)];
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::const_reference deque<T, Allocator>::at(size_type n) const
|
||||
{
|
||||
if(n > elements){
|
||||
__throw_out_of_range("Out of deque range");
|
||||
}
|
||||
return data[array_element(n)];
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::reference deque<T, Allocator>::front()
|
||||
{
|
||||
return data[first_element];
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::const_reference deque<T, Allocator>::front() const
|
||||
{
|
||||
return data[first_element];
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::reference deque<T, Allocator>::back()
|
||||
{
|
||||
return data[array_element(elements-1)];
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::const_reference deque<T, Allocator>::back() const
|
||||
{
|
||||
return data[array_element(elements-1)];
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void deque<T, Allocator>::push_front(const T& x){
|
||||
reserve(elements + 1);
|
||||
first_element = first_subtract(1);
|
||||
a.construct(data + first_element, x);
|
||||
++elements;
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void deque<T, Allocator>::push_back(const T& x){
|
||||
reserve(elements + 1);
|
||||
a.construct(data + last_element, x);
|
||||
++elements;
|
||||
last_element = array_element(elements);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::iterator deque<T, Allocator>::insert(iterator position, const T& x)
|
||||
{
|
||||
reserve(elements+1);
|
||||
if(position.element > (elements/2)){
|
||||
//Push all elements back 1
|
||||
push_back(x);
|
||||
for(size_type i = elements-1; i > position.element; --i){
|
||||
at(i) = at(i-1);
|
||||
}
|
||||
}else{
|
||||
//Push all elements forward 1
|
||||
push_front(x);
|
||||
for(size_type i = 0; i < position.element; ++i){
|
||||
at(i) = at(i+1);
|
||||
}
|
||||
}
|
||||
at(position.element) = x;
|
||||
return deque_iter(this, position.element);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void deque<T, Allocator>::
|
||||
insert(typename deque<T, Allocator>::iterator position, size_type n, const T& x)
|
||||
{
|
||||
reserve(elements + n);
|
||||
for(size_t i =0; i < n; ++i){
|
||||
position = insert(position, x);
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> template <class InputIterator>
|
||||
void deque<T, Allocator>::insert (iterator position, InputIterator first, InputIterator last)
|
||||
{
|
||||
while(first != last){
|
||||
position = insert(position, *first);
|
||||
++first;
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void deque<T, Allocator>::pop_front(){
|
||||
if(elements == 0){
|
||||
__throw_out_of_range("deque pop_front");
|
||||
}
|
||||
a.destroy(data + first_element);
|
||||
first_element = array_element(1);
|
||||
--elements;
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void deque<T, Allocator>::pop_back(){
|
||||
last_element = array_element(elements - 1);
|
||||
a.destroy(data + last_element);
|
||||
--elements;
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename
|
||||
deque<T, Allocator>::iterator deque<T, Allocator>::erase(typename deque<T, Allocator>::iterator position)
|
||||
{
|
||||
if(position.element > (elements /2)){
|
||||
for(size_type i = position.element; i < elements - 1; ++i){
|
||||
at(i) = at(i+1);
|
||||
}
|
||||
pop_back();
|
||||
}else{
|
||||
for(size_type i = position.element; i > 0; --i){
|
||||
at(i) = at(i-1);
|
||||
}
|
||||
pop_front();
|
||||
}
|
||||
return deque_iter(this, position.element);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename deque<T, Allocator>::iterator
|
||||
deque<T, Allocator>::
|
||||
erase(typename deque<T, Allocator>::iterator first, typename deque<T, Allocator>::iterator last)
|
||||
{
|
||||
//Shift backwards
|
||||
size_type num_move = last.element - first.element;
|
||||
if( first.element > (elements - last.element) ){
|
||||
for(size_type i = last.element; i < elements ; ++i){
|
||||
at(i-num_move) = at(i);
|
||||
}
|
||||
for(size_type i = 0; i < num_move ; ++i){
|
||||
pop_back();
|
||||
}
|
||||
}else{
|
||||
for(size_type i = 0; i < first.element ; ++i){
|
||||
at(last.element - i - 1) = at(first.element - i - 1);
|
||||
}
|
||||
for(size_type i = 0; i < num_move ; ++i){
|
||||
pop_front();
|
||||
}
|
||||
}
|
||||
return deque_iter(this, first.element);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void deque<T, Allocator>::swap(deque<T,Allocator>& x)
|
||||
{
|
||||
T * temp_data;
|
||||
typename deque<T,Allocator>::size_type temp_size;
|
||||
|
||||
//Swap data pointers
|
||||
temp_data = x.data;
|
||||
x.data = data;
|
||||
data = temp_data;
|
||||
|
||||
//Swap array sizes
|
||||
temp_size = x.data_size;
|
||||
x.data_size = data_size;
|
||||
data_size = temp_size;
|
||||
|
||||
//Swap num array elements
|
||||
temp_size = x.elements;
|
||||
x.elements = elements;
|
||||
elements = temp_size;
|
||||
|
||||
//Swap first_pointer
|
||||
temp_size = x.first_element;
|
||||
x.first_element = first_element;
|
||||
first_element = temp_size;
|
||||
|
||||
//Swap last_pointer
|
||||
temp_size = x.last_element;
|
||||
x.last_element = last_element;
|
||||
last_element = temp_size;
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void deque<T, Allocator>::clear()
|
||||
{
|
||||
while(elements > 0 ){
|
||||
pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> void deque<T, Allocator>::reserve(typename deque<T, Allocator>::size_type n)
|
||||
{
|
||||
if(data_size >= n){
|
||||
return;
|
||||
}
|
||||
|
||||
size_type size_temp;
|
||||
size_type first_temp;
|
||||
T * data_temp;
|
||||
size_temp = n + __UCLIBCXX_STL_BUFFER_SIZE__; //Reserve extra 'cause we can
|
||||
data_temp = a.allocate(size_temp);
|
||||
|
||||
first_temp = (size_temp - elements) / 2;
|
||||
for(size_type i = 0; i < elements; ++i){
|
||||
a.construct(data_temp + first_temp + i, data[array_element(i)]);
|
||||
a.destroy(data + array_element(i));
|
||||
}
|
||||
|
||||
//Now shuffle pointers
|
||||
a.deallocate(data, data_size);
|
||||
data = data_temp;
|
||||
data_size = size_temp;
|
||||
first_element = first_temp;
|
||||
last_element = first_element + elements;
|
||||
}
|
||||
|
||||
|
||||
template <class T, class Allocator> _UCXXEXPORT
|
||||
bool
|
||||
operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y)
|
||||
{
|
||||
if(x.elements != y.elements){
|
||||
return false;
|
||||
}
|
||||
for(typename deque<T,Allocator>::size_type i = 0; i < x.elements; ++i){
|
||||
if(x[i] < y[i] || y[i] < x[i]){
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class T, class Allocator> bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
|
||||
template <class T, class Allocator> _UCXXEXPORT
|
||||
bool
|
||||
operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y)
|
||||
{
|
||||
if(x == y){
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
template <class T, class Allocator> bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
|
||||
template <class T, class Allocator> _UCXXEXPORT void swap(deque<T,Allocator>& x, deque<T,Allocator>& y){
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
// Exception Handling support header for -*- C++ -*-
|
||||
|
||||
// Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2002
|
||||
// Free Software Foundation
|
||||
//
|
||||
// This file is part of GNU CC.
|
||||
//
|
||||
// GNU CC is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
//
|
||||
// GNU CC is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with GNU CC; see the file COPYING. If not, write to
|
||||
// the Free Software Foundation, 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/** @file exception
|
||||
* This header defines several types and functions relating to the
|
||||
* handling of exceptions in a C++ program.
|
||||
*/
|
||||
|
||||
#ifndef __EXCEPTION__
|
||||
#define __EXCEPTION__
|
||||
|
||||
#include <basic_definitions>
|
||||
|
||||
extern "C++" {
|
||||
|
||||
namespace std
|
||||
{
|
||||
/**
|
||||
* @brief Base class for all library exceptions.
|
||||
*
|
||||
* This is the base class for all exceptions thrown by the standard
|
||||
* library, and by certain language expressions. You are free to derive
|
||||
* your own %exception classes, or use a different hierarchy, or to
|
||||
* throw non-class data (e.g., fundamental types).
|
||||
*/
|
||||
class exception
|
||||
{
|
||||
public:
|
||||
exception() throw() { }
|
||||
virtual ~exception() throw();
|
||||
/** Returns a C-style character string describing the general cause
|
||||
* of the current error. */
|
||||
virtual const char* what() const throw();
|
||||
};
|
||||
|
||||
/** If an %exception is thrown which is not listed in a function's
|
||||
* %exception specification, one of these may be thrown. */
|
||||
class bad_exception : public exception
|
||||
{
|
||||
public:
|
||||
bad_exception() throw() { }
|
||||
// This declaration is not useless:
|
||||
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
|
||||
virtual ~bad_exception() throw();
|
||||
};
|
||||
|
||||
/// If you write a replacement %terminate handler, it must be of this type.
|
||||
typedef void (*terminate_handler) ();
|
||||
/// If you write a replacement %unexpected handler, it must be of this type.
|
||||
typedef void (*unexpected_handler) ();
|
||||
|
||||
/// Takes a new handler function as an argument, returns the old function.
|
||||
terminate_handler set_terminate(terminate_handler) throw();
|
||||
/** The runtime will call this function if %exception handling must be
|
||||
* abandoned for any reason. */
|
||||
void terminate() __UCLIBCXX_NORETURN;
|
||||
|
||||
/// Takes a new handler function as an argument, returns the old function.
|
||||
unexpected_handler set_unexpected(unexpected_handler) throw();
|
||||
/** The runtime will call this function if an %exception is thrown which
|
||||
* violates the function's %exception specification. */
|
||||
void unexpected() __UCLIBCXX_NORETURN;
|
||||
|
||||
/** [18.6.4]/1: "Returns true after completing evaluation of a
|
||||
* throw-expression until either completing initialization of the
|
||||
* exception-declaration in the matching handler or entering @c unexpected()
|
||||
* due to the throw; or after entering @c terminate() for any reason
|
||||
* other than an explicit call to @c terminate(). [Note: This includes
|
||||
* stack unwinding [15.2]. end note]"
|
||||
*
|
||||
* 2: "When @c uncaught_exception() is true, throwing an %exception can
|
||||
* result in a call of @c terminate() (15.5.1)."
|
||||
*/
|
||||
bool uncaught_exception() throw();
|
||||
} // namespace std
|
||||
|
||||
namespace __gnu_cxx
|
||||
{
|
||||
/** A replacement for the standard terminate_handler which prints more
|
||||
information about the terminating exception (if any) on stderr. Call
|
||||
@code
|
||||
std::set_terminate (__gnu_cxx::__verbose_terminate_handler)
|
||||
@endcode
|
||||
to use. For more info, see
|
||||
http://gcc.gnu.org/onlinedocs/libstdc++/19_diagnostics/howto.html#4
|
||||
*/
|
||||
void __verbose_terminate_handler ();
|
||||
} // namespace __gnu_cxx
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,676 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef __STD_HEADER_FSTREAM
|
||||
#define __STD_HEADER_FSTREAM 1
|
||||
|
||||
|
||||
#include<basic_definitions>
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <streambuf>
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
#include <char_traits>
|
||||
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <errno.h>
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
#include <cwchar>
|
||||
#include <cwctype>
|
||||
#endif //__UCLIBCXX_HAS_WCHAR__
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
template <class C, class T> class basic_filebuf;
|
||||
|
||||
typedef basic_filebuf<char> filebuf;
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
typedef basic_filebuf<wchar_t> wfilebuf;
|
||||
#endif
|
||||
|
||||
|
||||
template <class charT, class traits> class _UCXXEXPORT basic_filebuf
|
||||
: public basic_streambuf<charT,traits>
|
||||
{
|
||||
#ifdef __UCLIBCXX_SUPPORT_CDIR__
|
||||
friend ios_base::Init::Init(); //Needed for cout/cin stuff
|
||||
#endif
|
||||
public:
|
||||
// Types (inherited from basic_streambuf:
|
||||
typedef typename basic_streambuf<charT, traits>::char_type char_type;
|
||||
typedef typename basic_streambuf<charT, traits>::int_type int_type;
|
||||
typedef typename basic_streambuf<charT, traits>::pos_type pos_type;
|
||||
typedef typename basic_streambuf<charT, traits>::off_type off_type;
|
||||
typedef traits traits_type;
|
||||
|
||||
//Constructors/destructor:
|
||||
|
||||
_UCXXEXPORT basic_filebuf() : basic_streambuf<charT, traits>(), fp(0), pbuffer(0), gbuffer(0)
|
||||
{
|
||||
append=false;
|
||||
pbuffer = new char_type[__UCLIBCXX_IOSTREAM_BUFSIZE__];
|
||||
gbuffer = new char_type[__UCLIBCXX_IOSTREAM_BUFSIZE__];
|
||||
|
||||
this->setp(pbuffer, pbuffer + __UCLIBCXX_IOSTREAM_BUFSIZE__);
|
||||
//Position get buffer so that there is no data available
|
||||
this->setg(gbuffer, gbuffer + __UCLIBCXX_IOSTREAM_BUFSIZE__,
|
||||
gbuffer + __UCLIBCXX_IOSTREAM_BUFSIZE__);
|
||||
}
|
||||
|
||||
|
||||
_UCXXEXPORT virtual ~basic_filebuf(){
|
||||
sync();
|
||||
close();
|
||||
delete [] pbuffer;
|
||||
delete [] gbuffer;
|
||||
pbuffer = 0;
|
||||
gbuffer = 0;
|
||||
}
|
||||
|
||||
|
||||
//Members:
|
||||
|
||||
_UCXXEXPORT bool is_open() const{
|
||||
if(fp == 0){
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_filebuf<charT,traits>* open(const char* s, ios_base::openmode mode){
|
||||
bool move_end = (mode & ios_base::ate) != 0;
|
||||
if(is_open() !=false){ //Must call close() first
|
||||
return 0;
|
||||
}
|
||||
basic_streambuf<charT,traits>::openedFor = mode;
|
||||
mode = mode & ~ios_base::ate;
|
||||
|
||||
if(mode == ios_base::out || mode == (ios_base::out | ios_base::trunc)){
|
||||
fp = fopen(s, "w" );
|
||||
}else if((mode & ios_base::app) && ! (mode & ios_base::trunc)){
|
||||
if(mode & ios_base::binary){
|
||||
if(mode & ios_base::in){
|
||||
fp = fopen(s, "a+b");
|
||||
}else{
|
||||
fp = fopen(s, "ab");
|
||||
}
|
||||
}else{
|
||||
if(mode & ios_base::in){
|
||||
fp = fopen(s, "a+");
|
||||
}else{
|
||||
fp = fopen(s, "a");
|
||||
}
|
||||
}
|
||||
}else if(mode == ios_base::in){
|
||||
fp = fopen(s, "r");
|
||||
}else if(mode == (ios_base::in | ios_base::out)){
|
||||
fp = fopen(s, "r+");
|
||||
}else if(mode == (ios_base::in | ios_base::out | ios_base::trunc)){
|
||||
fp = fopen(s, "w+");
|
||||
}else if(mode == (ios_base::binary | ios_base::out)){
|
||||
fp = fopen(s, "wb");
|
||||
}else if(mode == (ios_base::in | ios_base::binary)){
|
||||
fp = fopen(s, "rb");
|
||||
}else if(mode == (ios_base::in | ios_base::binary | ios_base::out)){
|
||||
fp = fopen(s, "r+b");
|
||||
}else if(mode==(ios_base::binary | ios_base::out | ios_base::trunc)){
|
||||
fp = fopen(s, "w+b");
|
||||
}else if(mode == (ios_base::in | ios_base::binary | ios_base::out | ios_base::trunc)){
|
||||
fp = fopen(s, "w+b");
|
||||
}
|
||||
|
||||
if(fp == 0){
|
||||
return 0;
|
||||
}
|
||||
if(ferror(fp)){
|
||||
fclose(fp);
|
||||
fp=0;
|
||||
return 0;
|
||||
}
|
||||
int retval = 0;
|
||||
|
||||
//Check to make sure the stream is good
|
||||
if(move_end == true){
|
||||
retval = fseek(fp, 0, SEEK_END);
|
||||
}else{
|
||||
retval = fseek(fp, 0, SEEK_SET);
|
||||
}
|
||||
if(retval!=0){ //Seek error
|
||||
fclose(fp);
|
||||
fp=0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
basic_streambuf<charT,traits>::mgnext = basic_streambuf<charT,traits>::mgend;
|
||||
|
||||
return this;
|
||||
}
|
||||
_UCXXEXPORT basic_filebuf<charT,traits>* close(){
|
||||
if(fp != 0 && fp != stdin && fp != stdout && fp !=stderr ){
|
||||
overflow();
|
||||
sync();
|
||||
int retval = fclose(fp);
|
||||
if(retval !=0){ //Error of some sort
|
||||
return 0;
|
||||
}
|
||||
fp=0;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
protected:
|
||||
_UCXXEXPORT basic_filebuf(const basic_filebuf<charT,traits> &){ }
|
||||
_UCXXEXPORT basic_filebuf<charT,traits> & operator=(const basic_filebuf<charT,traits> &){ return *this; }
|
||||
|
||||
//Overridden virtual functions:
|
||||
|
||||
virtual _UCXXEXPORT int showmanyc(){
|
||||
return basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr();
|
||||
}
|
||||
virtual _UCXXEXPORT int_type underflow(){
|
||||
/* Some variables used internally:
|
||||
Buffer pointers:
|
||||
charT * mgbeg;
|
||||
charT * mgnext;
|
||||
charT * mgend;
|
||||
|
||||
eback() returns mgbeg
|
||||
gptr() returns mgnext
|
||||
egptr() returns mgend
|
||||
|
||||
gbump(int n) mgnext+=n
|
||||
|
||||
*/
|
||||
|
||||
if(!is_open()){
|
||||
return traits::eof();
|
||||
}
|
||||
|
||||
if(basic_streambuf<charT,traits>::eback() == 0){
|
||||
//No buffer, so...
|
||||
charT c;
|
||||
int retval;
|
||||
retval = fread(&c, sizeof(charT), 1, fp);
|
||||
|
||||
if(retval == 0 || feof(fp) || ferror(fp) ){
|
||||
return traits::eof();
|
||||
}
|
||||
return traits::to_int_type(c);
|
||||
}
|
||||
|
||||
if(basic_streambuf<charT,traits>::eback() == basic_streambuf<charT,traits>::gptr()){ //Buffer is full
|
||||
return traits::to_int_type(*basic_streambuf<charT,traits>::gptr());
|
||||
}
|
||||
//Shift entire buffer back to the begining
|
||||
size_t offset = basic_streambuf<charT,traits>::gptr() - basic_streambuf<charT,traits>::eback();
|
||||
size_t amountData = basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr();
|
||||
|
||||
for(charT * i = basic_streambuf<charT,traits>::gptr(); i < basic_streambuf<charT,traits>::egptr(); ++i){
|
||||
*(i-offset) = *i;
|
||||
}
|
||||
|
||||
size_t retval = 0;
|
||||
//Save operating flags from file descriptor
|
||||
int fcntl_flags = fcntl(fileno(fp), F_GETFL);
|
||||
retval = 0;
|
||||
|
||||
//Set to non_blocking mode
|
||||
fcntl(fileno(fp), F_SETFL, fcntl_flags | O_NONBLOCK);
|
||||
|
||||
//Fill rest of buffer
|
||||
retval = fread(basic_streambuf<charT,traits>::egptr() -
|
||||
basic_streambuf<charT,traits>::gptr() + basic_streambuf<charT,traits>::eback(),
|
||||
sizeof(charT),
|
||||
offset,
|
||||
fp
|
||||
);
|
||||
|
||||
//Clear problems where we didn't read in enough characters
|
||||
if(EAGAIN == errno){
|
||||
clearerr(fp);
|
||||
}
|
||||
|
||||
//Restore file descriptor clase
|
||||
fcntl(fileno(fp), F_SETFL, fcntl_flags);
|
||||
|
||||
//Now we are going to make sure that we read in at least one character. The hard way.
|
||||
if(retval == 0){
|
||||
fcntl_flags = fcntl(fileno(fp), F_GETFL);
|
||||
//Set to blocking mode
|
||||
fcntl(fileno(fp), F_SETFL, fcntl_flags & ~O_NONBLOCK);
|
||||
|
||||
retval = fread(basic_streambuf<charT,traits>::egptr() -
|
||||
basic_streambuf<charT,traits>::gptr() + basic_streambuf<charT,traits>::eback(),
|
||||
sizeof(charT),
|
||||
1,
|
||||
fp
|
||||
);
|
||||
|
||||
//Restore file descriptor clase
|
||||
fcntl(fileno(fp), F_SETFL, fcntl_flags);
|
||||
|
||||
}
|
||||
|
||||
if(retval !=offset){ //Slide buffer forward again
|
||||
for(size_t i = 0; i < amountData + retval; ++i){
|
||||
*(basic_streambuf<charT,traits>::egptr() - i - 1) =
|
||||
*(basic_streambuf<charT,traits>::eback() + amountData + retval - i - 1);
|
||||
}
|
||||
}
|
||||
|
||||
basic_streambuf<charT,traits>::mgnext -= retval;
|
||||
|
||||
if( (retval <= 0 && feof(fp)) || ferror(fp) ){
|
||||
return traits::eof();
|
||||
}
|
||||
|
||||
return traits::to_int_type(*basic_streambuf<charT,traits>::gptr());
|
||||
}
|
||||
virtual _UCXXEXPORT int_type uflow(){
|
||||
bool dobump = (basic_streambuf<charT,traits>::gptr() != 0);
|
||||
int_type retval = underflow();
|
||||
if(dobump){
|
||||
basic_streambuf<charT,traits>::gbump(1);
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
virtual _UCXXEXPORT int_type pbackfail(int_type c = traits::eof()){
|
||||
if(is_open() == false ||
|
||||
basic_streambuf<charT,traits>::gptr() == basic_streambuf<charT,traits>::eback())
|
||||
{
|
||||
return traits::eof();
|
||||
}
|
||||
if(traits::eq_int_type(c,traits::eof()) == false){
|
||||
if(traits::eq(traits::to_char_type(c), basic_streambuf<charT,traits>::gptr()[-1]) == true){
|
||||
basic_streambuf<charT,traits>::gbump(-1);
|
||||
}else{
|
||||
basic_streambuf<charT,traits>::gbump(-1);
|
||||
basic_streambuf<charT,traits>::gptr()[0] = c;
|
||||
}
|
||||
return c;
|
||||
}else{
|
||||
basic_streambuf<charT,traits>::gbump(-1);
|
||||
return traits::not_eof(c);
|
||||
}
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT int_type overflow(int_type c = traits::eof()){
|
||||
if(is_open() == false){
|
||||
//Can't do much
|
||||
return traits::eof();
|
||||
}
|
||||
if(basic_streambuf<charT,traits>::pbase() == 0){ //Unbuffered - elliminate dupe code below
|
||||
if(fputc(c, fp) == EOF){
|
||||
return traits::eof();
|
||||
}
|
||||
return c;
|
||||
}
|
||||
if(basic_streambuf<charT,traits>::pbase() == 0 && traits::eq_int_type(c,traits::eof()) ){
|
||||
//Nothing to flush
|
||||
return traits::not_eof(c);
|
||||
}
|
||||
size_t r = basic_streambuf<charT,traits>::pptr() - basic_streambuf<charT,traits>::pbase();
|
||||
|
||||
if( r == 0 && traits::eq_int_type(c,traits::eof()) ){
|
||||
return traits::not_eof(c);
|
||||
}else if (r == 0 ){
|
||||
if(fputc(c, fp) == EOF){
|
||||
return traits::eof();
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
size_t totalChars = r;
|
||||
|
||||
char_type *buffer = 0;
|
||||
if(traits::eq_int_type(c,traits::eof())){
|
||||
buffer = new char_type[r];
|
||||
}else{
|
||||
buffer = new char_type[r+1];
|
||||
buffer[r] = c;
|
||||
totalChars++;
|
||||
}
|
||||
|
||||
traits::copy(buffer, basic_streambuf<charT,traits>::pbase(), r);
|
||||
// memcpy(buffer, basic_streambuf<charT,traits>::pbase(), r);
|
||||
|
||||
size_t retval = fwrite(buffer, sizeof(charT), totalChars, fp);
|
||||
if(retval !=totalChars){
|
||||
if(retval == 0){
|
||||
delete [] buffer;
|
||||
return traits::eof();
|
||||
}
|
||||
basic_streambuf<charT,traits>::pbump(-retval);
|
||||
fprintf(stderr, "***** Did not write the full buffer out. Should be: %d, actually: %d\n",
|
||||
totalChars, retval);
|
||||
}else{
|
||||
basic_streambuf<charT,traits>::pbump(-r);
|
||||
}
|
||||
|
||||
delete [] buffer;
|
||||
return traits::not_eof(c);
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT basic_streambuf<charT,traits>* setbuf(char_type* s, streamsize n){
|
||||
if(s == 0 && n == 0){ //Unbuffered
|
||||
if(pbuffer !=0){
|
||||
delete [] pbuffer;
|
||||
}
|
||||
if(gbuffer !=0){
|
||||
delete [] gbuffer;
|
||||
}
|
||||
pbuffer = 0;
|
||||
gbuffer = 0;
|
||||
}else if(basic_streambuf<charT,traits>::gptr() !=0 &&
|
||||
basic_streambuf<charT,traits>::gptr()==basic_streambuf<charT,traits>::egptr())
|
||||
{
|
||||
delete [] pbuffer;
|
||||
pbuffer = s;
|
||||
}
|
||||
return this;
|
||||
}
|
||||
virtual _UCXXEXPORT pos_type seekoff(off_type off, ios_base::seekdir way,
|
||||
ios_base::openmode = ios_base::in | ios_base::out)
|
||||
{
|
||||
if(is_open() == false){
|
||||
return -1;
|
||||
}
|
||||
int whence = SEEK_SET; // if(way == basic_ios<charT>::beg)
|
||||
off_type position = off;
|
||||
|
||||
if(way == basic_ios<charT>::cur){
|
||||
whence = SEEK_CUR;
|
||||
position -= (basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr());
|
||||
}else if(way == basic_ios<charT>::end){
|
||||
whence = SEEK_END;
|
||||
}
|
||||
|
||||
sync();
|
||||
|
||||
int retval = fseek(
|
||||
fp,
|
||||
sizeof(charT)*(position),
|
||||
whence
|
||||
);
|
||||
|
||||
//Invalidate read buffer
|
||||
basic_streambuf<charT,traits>::gbump(
|
||||
basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr()
|
||||
);
|
||||
|
||||
if(-1 != retval){
|
||||
retval = ftell(fp);
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
virtual _UCXXEXPORT pos_type seekpos(pos_type sp, ios_base::openmode = ios_base::in | ios_base::out){
|
||||
if(is_open() == false){
|
||||
return -1;
|
||||
}
|
||||
sync();
|
||||
|
||||
int retval = fseek(fp,sizeof(charT)* sp, SEEK_SET);
|
||||
|
||||
//Invalidate read buffer
|
||||
basic_streambuf<charT,traits>::gbump(basic_streambuf<charT,traits>::egptr() - basic_streambuf<charT,traits>::gptr());
|
||||
if(retval > -1){
|
||||
return sp;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
virtual _UCXXEXPORT int sync(){
|
||||
if(pbuffer !=0){
|
||||
if(overflow() == traits::eof()){
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
if(0 != fp && 0 != fflush(fp)){
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
virtual _UCXXEXPORT void imbue(const locale&){
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
virtual _UCXXEXPORT streamsize xsputn(const char_type* s, streamsize n){
|
||||
if(is_open() == false){
|
||||
return 0;
|
||||
}
|
||||
//Check to see if buffered
|
||||
|
||||
//Check to see if we can buffer the data
|
||||
streamsize buffer_avail = basic_streambuf<charT,traits>::epptr() - basic_streambuf<charT,traits>::pptr();
|
||||
|
||||
if(n > buffer_avail){ //Flush buffer and write directly
|
||||
overflow(); //Flush the buffer
|
||||
return fwrite(s, sizeof(charT), n, fp);
|
||||
}
|
||||
|
||||
//Add to buffer to be written later
|
||||
|
||||
traits::copy(basic_streambuf<charT,traits>::pptr(), s, n);
|
||||
basic_streambuf<charT,traits>::pbump(n);
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
FILE * fp;
|
||||
char_type * pbuffer;
|
||||
char_type * gbuffer;
|
||||
bool append;
|
||||
};
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
|
||||
template <> _UCXXEXPORT basic_filebuf<wchar_t, char_traits<wchar_t> >::int_type
|
||||
basic_filebuf<wchar_t, char_traits<wchar_t> >::overflow(int_type c);
|
||||
|
||||
template <> _UCXXEXPORT basic_filebuf<wchar_t, char_traits<wchar_t> >::int_type
|
||||
basic_filebuf<wchar_t, char_traits<wchar_t> >::underflow();
|
||||
|
||||
#endif //__UCLIBCXX_HAS_WCHAR__
|
||||
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_FSTREAM_CHAR__
|
||||
#ifndef __UCLIBCXX_COMPILE_FSTREAM__
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template <> _UCXXEXPORT filebuf::basic_filebuf();
|
||||
template <> _UCXXEXPORT filebuf::~basic_filebuf();
|
||||
|
||||
#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template <> _UCXXEXPORT filebuf::int_type filebuf::pbackfail(filebuf::int_type c);
|
||||
template <> _UCXXEXPORT filebuf * filebuf::open(const char* s, ios_base::openmode mode);
|
||||
template <> _UCXXEXPORT filebuf * filebuf::close();
|
||||
template <> _UCXXEXPORT filebuf::int_type filebuf::overflow(filebuf::int_type c);
|
||||
template <> _UCXXEXPORT filebuf::int_type filebuf::underflow ();
|
||||
|
||||
template <> _UCXXEXPORT basic_streambuf<char, char_traits<char> > * filebuf::setbuf(char * s, streamsize n);
|
||||
template <> _UCXXEXPORT streamsize filebuf::xsputn(const char* s, streamsize n);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
template <class charT, class traits> class _UCXXEXPORT basic_ifstream
|
||||
: public basic_istream<charT,traits>
|
||||
{
|
||||
public:
|
||||
typedef charT char_type;
|
||||
typedef typename traits::int_type int_type;
|
||||
typedef typename traits::pos_type pos_type;
|
||||
typedef typename traits::off_type off_type;
|
||||
|
||||
_UCXXEXPORT basic_ifstream(): basic_ios<charT, traits>(&sb), basic_istream<charT,traits>(&sb){
|
||||
//Passing the address of sb
|
||||
}
|
||||
explicit _UCXXEXPORT basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in)
|
||||
: basic_ios<charT, traits>(&sb), basic_istream<charT,traits>(&sb)
|
||||
{
|
||||
if(sb.open(s, mode) == 0){
|
||||
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
||||
}
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT ~basic_ifstream(){
|
||||
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_filebuf<charT,traits>* rdbuf() const{
|
||||
return (basic_filebuf<charT,traits>*)&sb;
|
||||
}
|
||||
_UCXXEXPORT bool is_open() const{
|
||||
return sb.is_open();
|
||||
}
|
||||
_UCXXEXPORT void open(const char* s, ios_base::openmode mode = ios_base::in){
|
||||
if(sb.open(s, mode) == 0){
|
||||
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
||||
}
|
||||
}
|
||||
_UCXXEXPORT void close(){
|
||||
sb.close();
|
||||
}
|
||||
private:
|
||||
basic_filebuf<charT,traits> sb;
|
||||
};
|
||||
|
||||
|
||||
template <class charT, class traits> class _UCXXEXPORT basic_ofstream
|
||||
: public basic_ostream<charT,traits>
|
||||
{
|
||||
public:
|
||||
typedef charT char_type;
|
||||
typedef typename traits::int_type int_type;
|
||||
typedef typename traits::pos_type pos_type;
|
||||
typedef typename traits::off_type off_type;
|
||||
|
||||
_UCXXEXPORT basic_ofstream() : basic_ios<charT, traits>(&sb), basic_ostream<charT,traits>(&sb){
|
||||
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT ~basic_ofstream();
|
||||
|
||||
explicit _UCXXEXPORT basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out | ios_base::trunc) :
|
||||
basic_ios<charT, traits>(&sb), basic_ostream<charT,traits>(&sb)
|
||||
{
|
||||
if(sb.open(s, mode | ios_base::out ) == 0){
|
||||
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
||||
}
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_filebuf<charT,traits>* rdbuf() const{
|
||||
return (basic_filebuf<charT,traits>*)&sb;
|
||||
}
|
||||
|
||||
_UCXXEXPORT bool is_open() const{
|
||||
return sb.is_open();
|
||||
}
|
||||
_UCXXEXPORT void open(const char* s, ios_base::openmode mode = ios_base::out | ios_base::trunc){
|
||||
if(sb.open(s, mode) == 0){
|
||||
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
||||
}
|
||||
}
|
||||
_UCXXEXPORT void close(){
|
||||
sb.close();
|
||||
}
|
||||
private:
|
||||
basic_filebuf<charT,traits> sb;
|
||||
};
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ofstream<charT, traits>::~basic_ofstream(){
|
||||
basic_ostream<charT, traits>::flush();
|
||||
}
|
||||
|
||||
|
||||
template <class charT, class traits> class _UCXXEXPORT basic_fstream
|
||||
: public basic_iostream<charT,traits>
|
||||
{
|
||||
public:
|
||||
typedef charT char_type;
|
||||
typedef typename traits::int_type ins_type;
|
||||
typedef typename traits::pos_type pos_type;
|
||||
typedef typename traits::off_type off_type;
|
||||
|
||||
_UCXXEXPORT basic_fstream(): basic_ios<charT, traits>(&sb), basic_iostream<charT,traits>(&sb){ }
|
||||
|
||||
explicit _UCXXEXPORT basic_fstream(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out):
|
||||
basic_ios<charT, traits>(&sb), basic_iostream<charT,traits>(&sb)
|
||||
{
|
||||
if(sb.open(s, mode) == 0){
|
||||
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
||||
}
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_filebuf<charT,traits>* rdbuf() const{
|
||||
return (basic_filebuf<charT,traits>*)&sb;
|
||||
}
|
||||
_UCXXEXPORT bool is_open() const{
|
||||
return sb.is_open();
|
||||
}
|
||||
_UCXXEXPORT void open(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out){
|
||||
if(sb.open(s, mode) == 0){
|
||||
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
||||
}
|
||||
}
|
||||
_UCXXEXPORT void close(){
|
||||
sb.close();
|
||||
}
|
||||
private:
|
||||
basic_filebuf<charT,traits> sb;
|
||||
};
|
||||
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_FSTREAM_CHAR__
|
||||
#ifndef __UCLIBCXX_COMPILE_FSTREAM__
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template <> _UCXXEXPORT basic_ofstream<char, char_traits<char> >::basic_ofstream();
|
||||
template <> _UCXXEXPORT basic_ofstream<char, char_traits<char> >::basic_ofstream(const char* s, ios_base::openmode mode);
|
||||
template <> _UCXXEXPORT basic_ofstream<char, char_traits<char> >::~basic_ofstream();
|
||||
|
||||
template <> _UCXXEXPORT basic_ifstream<char, char_traits<char> >::basic_ifstream();
|
||||
template <> _UCXXEXPORT basic_ifstream<char, char_traits<char> >::basic_ifstream(const char* s, ios_base::openmode mode);
|
||||
template <> _UCXXEXPORT basic_ifstream<char, char_traits<char> >::~basic_ifstream();
|
||||
|
||||
#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <exception>
|
||||
|
||||
|
||||
#ifndef HEADER_IMPLEMENTATION_FUNC_EXCEPTION
|
||||
#define HEADER_IMPLEMENTATION_FUNC_EXCEPTION
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
_UCXXEXPORT void __throw_bad_alloc();
|
||||
_UCXXEXPORT void __throw_out_of_range(const char * message = 0);
|
||||
_UCXXEXPORT void __throw_overflow_error(const char * message = 0);
|
||||
_UCXXEXPORT void __throw_length_error(const char * message = 0);
|
||||
_UCXXEXPORT void __throw_invalid_argument(const char * message = 0);
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,439 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __STD_HEADER_FUNCTIONAL
|
||||
#define __STD_HEADER_FUNCTIONAL 1
|
||||
|
||||
#include <basic_definitions>
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
template <class Arg, class Result> struct unary_function;
|
||||
template <class Arg1, class Arg2, class Result> struct binary_function;
|
||||
|
||||
template <class T> struct plus;
|
||||
template <class T> struct minus;
|
||||
template <class T> struct multiplies;
|
||||
template <class T> struct divides;
|
||||
template <class T> struct modulus;
|
||||
template <class T> struct negate;
|
||||
|
||||
template <class T> struct equal_to;
|
||||
template <class T> struct not_equal_to;
|
||||
template <class T> struct greater;
|
||||
template <class T> struct less;
|
||||
template <class T> struct greater_equal;
|
||||
template <class T> struct less_equal;
|
||||
|
||||
template <class T> struct logical_and;
|
||||
template <class T> struct logical_or;
|
||||
template <class T> struct logical_not;
|
||||
|
||||
template <class Predicate> struct unary_negate;
|
||||
template <class Predicate> unary_negate<Predicate> not1(const Predicate&);
|
||||
template <class Predicate> struct binary_negate;
|
||||
template <class Predicate> binary_negate<Predicate> not2(const Predicate&);
|
||||
|
||||
|
||||
template <class Operation> class binder1st;
|
||||
template <class Operation, class T> binder1st<Operation> bind1st(const Operation&, const T&);
|
||||
template <class Operation> class binder2nd;
|
||||
template <class Operation, class T> binder2nd<Operation> bind2nd(const Operation&, const T&);
|
||||
|
||||
template <class Arg, class Result> class pointer_to_unary_function;
|
||||
template <class Arg, class Result> pointer_to_unary_function<Arg,Result> ptr_fun(Result (*)(Arg));
|
||||
template <class Arg1, class Arg2, class Result> class pointer_to_binary_function;
|
||||
template <class Arg1, class Arg2, class Result>
|
||||
pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*)(Arg1,Arg2));
|
||||
|
||||
template<class S, class T> class mem_fun_t;
|
||||
template<class S, class T, class A> class mem_fun1_t;
|
||||
template<class S, class T> class const_mem_fun_t;
|
||||
template<class S, class T, class A> class const_mem_fun1_t;
|
||||
template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)());
|
||||
template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
|
||||
template<class S, class T> class mem_fun_ref_t;
|
||||
template<class S, class T, class A> class mem_fun1_ref_t;
|
||||
template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)());
|
||||
template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun1_ref(S (T::*f)(A));
|
||||
|
||||
//Implementation
|
||||
|
||||
template <class Arg, class Result> struct _UCXXEXPORT unary_function{
|
||||
typedef Arg argument_type;
|
||||
typedef Result result_type;
|
||||
};
|
||||
|
||||
|
||||
template <class Arg1, class Arg2, class Result> struct _UCXXEXPORT binary_function{
|
||||
typedef Arg1 first_argument_type;
|
||||
typedef Arg2 second_argument_type;
|
||||
typedef Result result_type;
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT plus : binary_function<T,T,T>{
|
||||
T operator()(const T& x, const T& y) const{
|
||||
return x + y;
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT minus : binary_function<T,T,T>{
|
||||
T operator()(const T& x, const T& y) const{
|
||||
return x - y;
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT multiplies : binary_function<T,T,T>{
|
||||
T operator()(const T& x, const T& y) const{
|
||||
return x * y;
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT divides : binary_function<T,T,T>{
|
||||
T operator()(const T& x, const T& y) const{
|
||||
return x / y;
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT modulus : binary_function<T,T,T>{
|
||||
T operator()(const T& x, const T& y) const{
|
||||
return x % y;
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT negate : unary_function<T,T>{
|
||||
T operator()(const T& x) const{
|
||||
return -x;
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT equal_to : binary_function<T,T,bool>{
|
||||
bool operator()(const T& x, const T& y) const{
|
||||
return (x == y);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT not_equal_to : binary_function<T,T,bool>{
|
||||
bool operator()(const T& x, const T& y) const{
|
||||
return (x != y);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT greater : binary_function<T,T,bool>{
|
||||
bool operator()(const T& x, const T& y) const{
|
||||
return (x > y);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT less : binary_function<T,T,bool>{
|
||||
bool operator()(const T& x, const T& y) const{
|
||||
return (x < y);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT greater_equal : binary_function<T,T,bool>{
|
||||
bool operator()(const T& x, const T& y) const{
|
||||
return (x >= y);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT less_equal : binary_function<T,T,bool>{
|
||||
bool operator()(const T& x, const T& y) const{
|
||||
return (x <= y);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT logical_and : binary_function<T,T,bool> {
|
||||
bool operator()(const T& x, const T& y) const{
|
||||
return (x && y);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT logical_or : binary_function<T,T,bool> {
|
||||
bool operator()(const T& x, const T& y) const{
|
||||
return (x || y);
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> struct _UCXXEXPORT logical_not : unary_function<T,bool> {
|
||||
bool operator()(const T& x) const{
|
||||
return !x;
|
||||
}
|
||||
};
|
||||
|
||||
template <class Predicate> class _UCXXEXPORT unary_negate
|
||||
: public unary_function<typename Predicate::argument_type,bool>
|
||||
{
|
||||
public:
|
||||
explicit unary_negate(const Predicate& pred) : p(pred) { }
|
||||
bool operator()(const typename Predicate::argument_type& x) const{
|
||||
return !p(x);
|
||||
}
|
||||
private:
|
||||
Predicate p;
|
||||
};
|
||||
|
||||
|
||||
template <class Predicate> _UCXXEXPORT unary_negate<Predicate> not1(const Predicate& pred){
|
||||
return unary_negate<Predicate>(pred);
|
||||
}
|
||||
|
||||
|
||||
template <class Predicate> class _UCXXEXPORT binary_negate : public
|
||||
binary_function<typename Predicate::first_argument_type,
|
||||
typename Predicate::second_argument_type, bool>
|
||||
{
|
||||
public:
|
||||
explicit binary_negate(const Predicate& pred) : p(pred) { }
|
||||
bool operator()(const typename Predicate::first_argument_type& x,
|
||||
const typename Predicate::second_argument_type& y) const
|
||||
{
|
||||
return !p(x, y);
|
||||
}
|
||||
private:
|
||||
Predicate p;
|
||||
};
|
||||
|
||||
|
||||
template <class Predicate> _UCXXEXPORT binary_negate<Predicate> not2(const Predicate& pred){
|
||||
return binary_negate<Predicate>(pred);
|
||||
}
|
||||
|
||||
|
||||
template <class Operation> class _UCXXEXPORT binder1st
|
||||
: public unary_function<typename Operation::second_argument_type,
|
||||
typename Operation::result_type>
|
||||
{
|
||||
protected:
|
||||
Operation op;
|
||||
typename Operation::first_argument_type value;
|
||||
public:
|
||||
binder1st(const Operation& x, const typename Operation::first_argument_type& y) : op(x), value(y){ }
|
||||
typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const{
|
||||
return op(value,x);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <class Operation, class T> _UCXXEXPORT binder1st<Operation> bind1st(const Operation& op, const T& x){
|
||||
return binder1st<Operation>(op, typename Operation::first_argument_type(x));
|
||||
}
|
||||
|
||||
|
||||
template <class Operation> class _UCXXEXPORT binder2nd
|
||||
: public unary_function<typename Operation::first_argument_type,
|
||||
typename Operation::result_type>
|
||||
{
|
||||
protected:
|
||||
Operation op;
|
||||
typename Operation::second_argument_type value;
|
||||
public:
|
||||
binder2nd(const Operation& x, const typename Operation::second_argument_type& y) : op(x), value(y) { }
|
||||
typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const{
|
||||
return op(x,value);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <class Operation, class T> _UCXXEXPORT
|
||||
binder2nd<Operation> bind2nd(const Operation& op, const T& x)
|
||||
{
|
||||
return binder2nd<Operation>(op, typename Operation::second_argument_type(x));
|
||||
}
|
||||
|
||||
|
||||
template <class Arg, class Result> class _UCXXEXPORT
|
||||
pointer_to_unary_function : public unary_function<Arg, Result>
|
||||
{
|
||||
protected:
|
||||
Result (*func)(Arg);
|
||||
public:
|
||||
explicit pointer_to_unary_function(Result (*f)(Arg)) : func(f) { }
|
||||
Result operator()(Arg x) const{
|
||||
return func(x);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <class Arg, class Result> _UCXXEXPORT pointer_to_unary_function<Arg, Result> ptr_fun(Result (*f)(Arg)){
|
||||
return pointer_to_unary_function<Arg, Result>(f);
|
||||
}
|
||||
|
||||
|
||||
template <class Arg1, class Arg2, class Result> class _UCXXEXPORT
|
||||
pointer_to_binary_function : public binary_function<Arg1,Arg2,Result>
|
||||
{
|
||||
protected:
|
||||
Result (*func)(Arg1, Arg2);
|
||||
public:
|
||||
explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2)) : func(f) { }
|
||||
Result operator()(Arg1 x, Arg2 y) const{
|
||||
return func(x, y);
|
||||
}
|
||||
};
|
||||
|
||||
template <class Arg1, class Arg2, class Result> _UCXXEXPORT
|
||||
pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1, Arg2))
|
||||
{
|
||||
return pointer_to_binary_function<Arg1,Arg2,Result>(f);
|
||||
}
|
||||
|
||||
|
||||
template <class S, class T> class _UCXXEXPORT mem_fun_t
|
||||
: public unary_function<T*, S>
|
||||
{
|
||||
public:
|
||||
explicit mem_fun_t(S (T::*p)()) : m(p) { }
|
||||
S operator()(T* p) const { return (p->*m)(); }
|
||||
private:
|
||||
S (T::*m)();
|
||||
};
|
||||
|
||||
|
||||
template <class S, class T, class A> class _UCXXEXPORT mem_fun1_t
|
||||
: public binary_function<T*, A, S>
|
||||
{
|
||||
public:
|
||||
explicit mem_fun1_t(S (T::*p)(A)) : m(p) { }
|
||||
S operator()(T* p, A x) const { return (p->*m)(x); }
|
||||
private:
|
||||
S (T::*m)(A);
|
||||
};
|
||||
|
||||
|
||||
template <class S, class T> class _UCXXEXPORT const_mem_fun_t
|
||||
: public unary_function<const T*, S>
|
||||
{
|
||||
public:
|
||||
explicit const_mem_fun_t(S (T::*p)() const) : m(p) { }
|
||||
S operator()(const T* p) const { return (p->*m)(); }
|
||||
private:
|
||||
S (T::*m)() const;
|
||||
};
|
||||
|
||||
|
||||
template <class S, class T, class A> class _UCXXEXPORT const_mem_fun1_t
|
||||
: public binary_function<T*, A, S>
|
||||
{
|
||||
public:
|
||||
explicit const_mem_fun1_t(S (T::*p)(A) const) : m(p) { }
|
||||
S operator()(const T* p, A x) const { return (p->*m)(x); }
|
||||
private:
|
||||
S (T::*m)(A) const;
|
||||
};
|
||||
|
||||
|
||||
template<class S, class T> _UCXXEXPORT mem_fun_t<S,T> mem_fun(S (T::*f)()){
|
||||
return mem_fun_t<S, T>(f);
|
||||
}
|
||||
|
||||
template<class S, class T> _UCXXEXPORT const_mem_fun_t<S,T> mem_fun(S (T::*f)() const){
|
||||
return const_mem_fun_t<S, T>(f);
|
||||
}
|
||||
|
||||
template<class S, class T, class A> _UCXXEXPORT mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)){
|
||||
return mem_fun1_t<S, T, A>(f);
|
||||
}
|
||||
|
||||
template<class S, class T, class A> _UCXXEXPORT const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const){
|
||||
return const_mem_fun1_t<S, T, A>(f);
|
||||
}
|
||||
|
||||
template <class S, class T> class _UCXXEXPORT mem_fun_ref_t
|
||||
: public unary_function<T, S>
|
||||
{
|
||||
public:
|
||||
explicit mem_fun_ref_t(S (T::*p)()) : mf(p) { }
|
||||
S operator()(T& p) { return (p.*mf)(); }
|
||||
private:
|
||||
S (T::*mf)();
|
||||
};
|
||||
|
||||
template <class S, class T, class A> class _UCXXEXPORT mem_fun1_ref_t
|
||||
: public binary_function<T, A, S>
|
||||
{
|
||||
public:
|
||||
explicit mem_fun1_ref_t(S (T::*p)(A)) : mf(p) { }
|
||||
S operator()(T& p, A x) { return (p.*mf)(x); }
|
||||
private:
|
||||
S (T::*mf)(A);
|
||||
};
|
||||
|
||||
template<class S, class T> _UCXXEXPORT mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()){
|
||||
return mem_fun_ref_t<S,T>(f);
|
||||
}
|
||||
|
||||
template<class S, class T, class A> _UCXXEXPORT mem_fun1_ref_t<S,T,A> mem_fun1_ref(S (T::*f)(A)){
|
||||
return mem_fun1_ref_t<S,T,A>(f);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
//These are SGI extensions which are checked for by some conformance checks. They
|
||||
// are *NOT* part of the C++ standard, however
|
||||
|
||||
template <class Op1, class Op2> class _UCXXEXPORT unary_compose :
|
||||
public std::unary_function<typename Op2::argument_type,
|
||||
typename Op1::result_type>
|
||||
{
|
||||
protected:
|
||||
Op1 mf1;
|
||||
Op2 mf2;
|
||||
public:
|
||||
unary_compose(const Op1& x, const Op2& y) : mf1(x), mf2(y) { }
|
||||
typename Op1::result_type operator()(const typename Op2::argument_type& x) const {
|
||||
return mf1(mf2(x));
|
||||
}
|
||||
};
|
||||
|
||||
template <class Op1, class Op2> _UCXXEXPORT
|
||||
inline unary_compose<Op1, Op2>
|
||||
compose1(const Op1& fn1, const Op2& fn2){
|
||||
return unary_compose<Op1, Op2>(fn1, fn2);
|
||||
}
|
||||
|
||||
template <class Op1, class Op2, class Op3> class _UCXXEXPORT binary_compose :
|
||||
public std::unary_function<typename Op2::argument_type, typename Op1::result_type>
|
||||
{
|
||||
protected:
|
||||
Op1 mf1;
|
||||
Op2 mf2;
|
||||
Op3 mf3;
|
||||
public:
|
||||
binary_compose(const Op1 & x, const Op2 & y, const Op3 & z)
|
||||
: mf1(x), mf2(y), mf3(z){ }
|
||||
typename Op1::result_type operator()(const typename Op2::argument_type & x) const {
|
||||
return mf1(mf2(x), mf3(x));
|
||||
}
|
||||
};
|
||||
|
||||
template <class Op1, class Op2, class Op3> inline _UCXXEXPORT binary_compose<Op1, Op2, Op3>
|
||||
compose2(const Op1 & fn1, const Op2 & fn2, const Op3 & fn3){
|
||||
return binary_compose<Op1, Op2, Op3>(fn1, fn2, fn3);
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,170 @@
|
|||
/* Copyright (C) 2005 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <exception>
|
||||
#include <ios>
|
||||
|
||||
#ifndef __STD_IOMANIP
|
||||
#define __STD_IOMANIP 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
// These are the helper classes which we are going to be using to
|
||||
// hold the required data
|
||||
|
||||
class _UCXXEXPORT __resetiosflags{
|
||||
public:
|
||||
ios_base::fmtflags m;
|
||||
_UCXXEXPORT __resetiosflags(ios_base::fmtflags mask) : m(mask){ }
|
||||
};
|
||||
|
||||
class _UCXXEXPORT __setiosflags{
|
||||
public:
|
||||
ios_base::fmtflags m;
|
||||
_UCXXEXPORT __setiosflags(ios_base::fmtflags mask) : m(mask){ }
|
||||
};
|
||||
|
||||
class _UCXXEXPORT __setbase{
|
||||
public:
|
||||
int base;
|
||||
_UCXXEXPORT __setbase(int b) : base(b){ }
|
||||
};
|
||||
|
||||
class _UCXXEXPORT __setfill{
|
||||
public:
|
||||
int character;
|
||||
_UCXXEXPORT __setfill(int c): character(c){ }
|
||||
};
|
||||
|
||||
class _UCXXEXPORT __setprecision{
|
||||
public:
|
||||
int digits;
|
||||
_UCXXEXPORT __setprecision(int n): digits(n) { }
|
||||
};
|
||||
|
||||
class _UCXXEXPORT __setw{
|
||||
public:
|
||||
int width;
|
||||
_UCXXEXPORT __setw(int n): width(n) { }
|
||||
};
|
||||
|
||||
|
||||
//Actual manipulator functions
|
||||
|
||||
inline __resetiosflags resetiosflags(ios_base::fmtflags mask){
|
||||
return __resetiosflags(mask);
|
||||
}
|
||||
|
||||
inline __setiosflags setiosflags(ios_base::fmtflags mask){
|
||||
return __setiosflags(mask);
|
||||
}
|
||||
|
||||
inline __setbase setbase(int b){
|
||||
return __setbase(b);
|
||||
}
|
||||
|
||||
inline __setfill setfill(int c){
|
||||
return __setfill(c);
|
||||
}
|
||||
|
||||
inline __setprecision setprecision(int n){
|
||||
return __setprecision(n);
|
||||
}
|
||||
|
||||
inline __setw setw(int n){
|
||||
return __setw(n);
|
||||
}
|
||||
|
||||
|
||||
//How to handle interaction with [i|o]stream classes
|
||||
|
||||
template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
|
||||
operator<<(basic_ostream<Ch, Tr>& os, const __resetiosflags s)
|
||||
{
|
||||
os.setf(ios_base::fmtflags(0),s.m);
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class Ch, class Tr> _UCXXEXPORT basic_istream<Ch, Tr>&
|
||||
operator>>(basic_istream<Ch, Tr>& is, const __resetiosflags s)
|
||||
{
|
||||
is.setf(ios_base::fmtflags(0),s.m);
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
|
||||
operator<<(basic_ostream<Ch, Tr>& os, const __setiosflags s)
|
||||
{
|
||||
os.setf(s.m);
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
|
||||
operator<<(basic_ostream<Ch, Tr>& os, const __setbase s)
|
||||
{
|
||||
ios_base::fmtflags f(0);
|
||||
switch(s.base){
|
||||
case 8:
|
||||
f = ios_base::oct;
|
||||
break;
|
||||
case 10:
|
||||
f = ios_base::dec;
|
||||
break;
|
||||
case 16:
|
||||
f = ios_base::hex;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
||||
}
|
||||
os.setf(f, ios_base::basefield);
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
|
||||
operator<<(basic_ostream<Ch, Tr>& os, const __setfill s)
|
||||
{
|
||||
os.fill(s.character);
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
|
||||
operator<<(basic_ostream<Ch, Tr>& os, const __setprecision s)
|
||||
{
|
||||
os.precision(s.digits);
|
||||
return os;
|
||||
}
|
||||
|
||||
template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
|
||||
operator<<(basic_ostream<Ch, Tr>& os, const __setw s)
|
||||
{
|
||||
os.width(s.width);
|
||||
return os;
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,500 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <cstddef>
|
||||
#include <locale>
|
||||
#include <iosfwd>
|
||||
|
||||
#ifndef __HEADER_STD_IOS
|
||||
#define __HEADER_STD_IOS 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
typedef signed long int streamoff;
|
||||
|
||||
template <class stateT> class fpos;
|
||||
|
||||
class _UCXXEXPORT ios_base {
|
||||
public:
|
||||
class failure;
|
||||
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
|
||||
class failure : public exception {
|
||||
public:
|
||||
explicit failure(const std::string&) { }
|
||||
explicit failure() { }
|
||||
virtual const char* what() const throw() {
|
||||
return "std::ios_base failure exception";
|
||||
}
|
||||
};
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CDIR__
|
||||
class _UCXXLOCAL Init{
|
||||
public:
|
||||
_UCXXEXPORT Init();
|
||||
_UCXXEXPORT ~Init();
|
||||
private:
|
||||
static int init_cnt;
|
||||
};
|
||||
#endif
|
||||
|
||||
public:
|
||||
|
||||
typedef unsigned short int fmtflags;
|
||||
|
||||
static const fmtflags skipws = 0x0001;
|
||||
|
||||
static const fmtflags left = 0x0002;
|
||||
static const fmtflags right = 0x0004;
|
||||
static const fmtflags internal = 0x0008;
|
||||
|
||||
static const fmtflags boolalpha = 0x0010;
|
||||
|
||||
static const fmtflags dec = 0x0020;
|
||||
static const fmtflags oct = 0x0040;
|
||||
static const fmtflags hex = 0x0080;
|
||||
|
||||
static const fmtflags scientific = 0x0100;
|
||||
static const fmtflags fixed = 0x0200;
|
||||
|
||||
static const fmtflags showbase = 0x0400;
|
||||
static const fmtflags showpoint = 0x0800;
|
||||
static const fmtflags showpos = 0x1000;
|
||||
static const fmtflags uppercase = 0x2000;
|
||||
|
||||
static const fmtflags adjustfield = left | right | internal;
|
||||
static const fmtflags basefield = dec | oct | hex;
|
||||
static const fmtflags floatfield = fixed | scientific;
|
||||
|
||||
static const fmtflags unitbuf = 0x4000;
|
||||
|
||||
typedef unsigned char iostate;
|
||||
static const iostate goodbit = 0x00;
|
||||
static const iostate badbit = 0x01;
|
||||
static const iostate eofbit = 0x02;
|
||||
static const iostate failbit = 0x04;
|
||||
|
||||
typedef unsigned char openmode;
|
||||
static const openmode app = 0x01;
|
||||
static const openmode ate = 0x02;
|
||||
static const openmode binary = 0x04;
|
||||
static const openmode in = 0x08;
|
||||
static const openmode out = 0x10;
|
||||
static const openmode trunc = 0x20;
|
||||
|
||||
typedef unsigned char seekdir;
|
||||
static const seekdir beg = 0x01;
|
||||
static const seekdir cur = 0x02;
|
||||
static const seekdir end = 0x04;
|
||||
|
||||
_UCXXEXPORT fmtflags flags() const{
|
||||
return mformat;
|
||||
}
|
||||
_UCXXEXPORT fmtflags flags(fmtflags fmtfl);
|
||||
|
||||
fmtflags setf(fmtflags fmtfl);
|
||||
fmtflags setf(fmtflags fmtfl, fmtflags mask );
|
||||
|
||||
_UCXXEXPORT void unsetf(fmtflags mask){
|
||||
mformat&= ~mask;
|
||||
}
|
||||
|
||||
_UCXXEXPORT streamsize precision() const{
|
||||
return mprecision;
|
||||
}
|
||||
|
||||
_UCXXEXPORT streamsize precision(streamsize prec);
|
||||
|
||||
_UCXXEXPORT streamsize width() const{
|
||||
return mwidth;
|
||||
}
|
||||
|
||||
_UCXXEXPORT streamsize width(streamsize wide);
|
||||
|
||||
_UCXXEXPORT locale imbue(const locale& loc);
|
||||
|
||||
_UCXXEXPORT locale getloc() const{
|
||||
return mLocale;
|
||||
}
|
||||
|
||||
// FIXME - These need to be implemented
|
||||
// static int xalloc();
|
||||
// long& iword(int index);
|
||||
// void*& pword(int index);
|
||||
|
||||
_UCXXEXPORT ~ios_base() { }
|
||||
|
||||
enum event { erase_event, imbue_event, copyfmt_event };
|
||||
|
||||
typedef void (*event_callback)(event, ios_base&, int index);
|
||||
// void register_callback(event_call_back fn, int index);
|
||||
|
||||
//We are going to wrap stdio so we don't need implementation of the following:
|
||||
inline static bool sync_with_stdio(bool = true) { return true; }
|
||||
|
||||
protected:
|
||||
_UCXXEXPORT ios_base() : mLocale(), mformat(dec | skipws ), mstate(goodbit),
|
||||
mmode(), mdir(), mprecision(6), mwidth(0)
|
||||
#ifdef __UCLIBCXX_SUPPORT_CDIR__
|
||||
,mInit()
|
||||
#endif
|
||||
{
|
||||
|
||||
}
|
||||
locale mLocale;
|
||||
fmtflags mformat;
|
||||
iostate mstate;
|
||||
openmode mmode;
|
||||
seekdir mdir;
|
||||
streamsize mprecision;
|
||||
streamsize mwidth;
|
||||
#ifdef __UCLIBCXX_SUPPORT_CDIR__
|
||||
Init mInit;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
//ios_base manipulators
|
||||
|
||||
|
||||
inline ios_base& boolalpha (ios_base& str){
|
||||
str.setf(ios_base::boolalpha);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& noboolalpha(ios_base& str){
|
||||
str.unsetf(ios_base::boolalpha);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& showbase (ios_base& str){
|
||||
str.setf(ios_base::showbase);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& noshowbase (ios_base& str){
|
||||
str.unsetf(ios_base::showbase);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& showpoint (ios_base& str){
|
||||
str.setf(ios_base::showpoint);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& noshowpoint(ios_base& str){
|
||||
str.unsetf(ios_base::showpoint);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& showpos (ios_base& str){
|
||||
str.setf(ios_base::showpos);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& noshowpos (ios_base& str){
|
||||
str.unsetf(ios_base::showpos);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& skipws (ios_base& str){
|
||||
str.setf(ios_base::skipws);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& noskipws (ios_base& str){
|
||||
str.unsetf(ios_base::skipws);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& uppercase (ios_base& str){
|
||||
str.setf(ios_base::uppercase);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& nouppercase(ios_base& str){
|
||||
str.unsetf(ios_base::uppercase);
|
||||
return str;
|
||||
}
|
||||
|
||||
inline ios_base& unitbuf (ios_base& str){
|
||||
str.setf(ios_base::unitbuf);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& nounitbuf (ios_base& str){
|
||||
str.unsetf(ios_base::unitbuf);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& internal (ios_base& str){
|
||||
str.setf(ios_base::internal, ios_base::adjustfield);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& left (ios_base& str){
|
||||
str.setf(ios_base::left, ios_base::adjustfield);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& right (ios_base& str){
|
||||
str.setf(ios_base::right, ios_base::adjustfield);
|
||||
return str;
|
||||
}
|
||||
|
||||
inline ios_base& dec (ios_base& str){
|
||||
str.setf(ios_base::dec, ios_base::basefield);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& hex (ios_base& str){
|
||||
str.setf(ios_base::hex, ios_base::basefield);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& oct (ios_base& str){
|
||||
str.setf(ios_base::oct, ios_base::basefield);
|
||||
return str;
|
||||
}
|
||||
|
||||
inline ios_base& fixed (ios_base& str){
|
||||
str.setf(ios_base::fixed, ios_base::floatfield);
|
||||
return str;
|
||||
}
|
||||
inline ios_base& scientific (ios_base& str){
|
||||
str.setf(ios_base::scientific, ios_base::floatfield);
|
||||
return str;
|
||||
}
|
||||
|
||||
|
||||
//basic_ios class definition
|
||||
|
||||
|
||||
template <class charT, class traits > class _UCXXEXPORT basic_ios
|
||||
: public ios_base
|
||||
{
|
||||
public:
|
||||
// Types:
|
||||
typedef charT char_type;
|
||||
typedef typename traits::int_type int_type;
|
||||
typedef typename traits::pos_type pos_type;
|
||||
typedef typename traits::off_type off_type;
|
||||
typedef traits traits_type;
|
||||
|
||||
_UCXXEXPORT operator void*() const{
|
||||
if(fail() ){
|
||||
return 0;
|
||||
}
|
||||
return (void *)(1); //Must return a non-NULL pointer (though it can be *any* pointer)
|
||||
}
|
||||
|
||||
_UCXXEXPORT bool operator!() const{
|
||||
return fail();
|
||||
}
|
||||
_UCXXEXPORT iostate rdstate() const{
|
||||
return mstate;
|
||||
}
|
||||
_UCXXEXPORT void clear(iostate state = goodbit){
|
||||
if(rdbuf()!=0){
|
||||
mstate = state;
|
||||
}else{
|
||||
mstate = state|ios_base::badbit;
|
||||
}
|
||||
}
|
||||
_UCXXEXPORT void setstate(iostate state) {
|
||||
clear(rdstate() | state);
|
||||
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
|
||||
if(rdstate() & throw_mask){
|
||||
throw failure();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
_UCXXEXPORT bool good() const{
|
||||
return (rdstate() == 0);
|
||||
}
|
||||
_UCXXEXPORT bool eof() const{
|
||||
if(rdstate() & eofbit){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
_UCXXEXPORT bool fail() const{
|
||||
if( mstate & (failbit | badbit) ){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
_UCXXEXPORT bool bad() const{
|
||||
if(mstate & badbit){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
_UCXXEXPORT iostate exceptions() const{
|
||||
return throw_mask;
|
||||
}
|
||||
_UCXXEXPORT void exceptions(iostate except){
|
||||
throw_mask = except;
|
||||
}
|
||||
|
||||
explicit _UCXXEXPORT basic_ios(basic_streambuf<charT,traits>* sb) : fill_char(' '), mtied(0), mstreambuf(0){
|
||||
init(sb);
|
||||
}
|
||||
|
||||
basic_ios() : mtied(0), mstreambuf(0){ }
|
||||
|
||||
virtual _UCXXEXPORT ~basic_ios(){
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_ostream<charT,traits>* tie() const{
|
||||
return mtied;
|
||||
}
|
||||
_UCXXEXPORT basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr){
|
||||
basic_ostream<charT,traits>* retval= mtied;
|
||||
mtied = tiestr;
|
||||
return retval;
|
||||
}
|
||||
_UCXXEXPORT basic_streambuf<charT,traits>* rdbuf() const{
|
||||
return mstreambuf;
|
||||
}
|
||||
_UCXXEXPORT basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb){
|
||||
basic_streambuf<charT,traits>* retval = mstreambuf;
|
||||
mstreambuf = sb;
|
||||
return retval;
|
||||
}
|
||||
_UCXXEXPORT basic_ios& copyfmt(const basic_ios& rhs);
|
||||
_UCXXEXPORT char_type fill() const{
|
||||
return fill_char;
|
||||
}
|
||||
_UCXXEXPORT char_type fill(char_type ch){
|
||||
char_type temp = fill_char;
|
||||
fill_char = ch;
|
||||
return temp;
|
||||
}
|
||||
|
||||
_UCXXEXPORT locale imbue(const locale& loc){
|
||||
return ios_base::imbue(loc);
|
||||
}
|
||||
_UCXXEXPORT char narrow(char_type c, char dfault) const;
|
||||
_UCXXEXPORT char_type widen(char c) const;
|
||||
|
||||
protected:
|
||||
char_type fill_char;
|
||||
basic_ostream<charT,traits>* mtied;
|
||||
basic_streambuf<charT,traits>* mstreambuf;
|
||||
iostate throw_mask;
|
||||
_UCXXEXPORT basic_ios(const basic_ios<charT,traits> &){ }
|
||||
_UCXXEXPORT basic_ios<charT,traits> & operator=(const basic_ios<charT,traits> &){ return *this; }
|
||||
_UCXXEXPORT void init(basic_streambuf<charT,traits>* sb){
|
||||
ios_base::mformat = skipws|dec;
|
||||
mstreambuf = sb;
|
||||
mstate = goodbit;
|
||||
throw_mask = goodbit;
|
||||
}
|
||||
};
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_IOS_CHAR__
|
||||
#ifndef __UCLIBCXX_COMPILE_IOS__
|
||||
|
||||
template <> _UCXXEXPORT void basic_ios<char, char_traits<char> >::clear(iostate state);
|
||||
template <> _UCXXEXPORT void basic_ios<char, char_traits<char> >::setstate(iostate state);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
template <class charT, class traits>
|
||||
inline char basic_ios<charT, traits>::narrow(char_type c, char dfault) const
|
||||
{
|
||||
return dfault;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline char basic_ios<char, char_traits<char> >::narrow(char_type c, char) const
|
||||
{
|
||||
return c;
|
||||
}
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
|
||||
template <>
|
||||
inline char basic_ios<wchar_t, char_traits<wchar_t> >::narrow(char_type c, char dfault) const
|
||||
{
|
||||
char retval = wctob (c);
|
||||
if(retval == EOF){
|
||||
retval = dfault;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
#endif //__UCLIBCXX_HAS_WCHAR__
|
||||
|
||||
template <class charT, class traits>
|
||||
inline typename basic_ios<charT, traits>::char_type
|
||||
basic_ios<charT, traits>::widen(char c) const
|
||||
{
|
||||
return c;
|
||||
}
|
||||
|
||||
template <>
|
||||
inline basic_ios<char, char_traits<char> >::char_type
|
||||
basic_ios<char, char_traits<char> >::widen(char c) const
|
||||
{
|
||||
return c;
|
||||
}
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
|
||||
template <>
|
||||
inline basic_ios<wchar_t, char_traits<wchar_t> >::char_type
|
||||
basic_ios<wchar_t, char_traits<wchar_t> >::widen(char c) const
|
||||
{
|
||||
return btowc(c);
|
||||
}
|
||||
|
||||
#endif //__UCLIBCXX_HAS_WCHAR__
|
||||
|
||||
|
||||
template <class stateT> class _UCXXEXPORT fpos{
|
||||
public:
|
||||
_UCXXEXPORT fpos(stateT s){
|
||||
st = s;
|
||||
}
|
||||
_UCXXEXPORT stateT state() const{
|
||||
return st;
|
||||
}
|
||||
_UCXXEXPORT void state(stateT s){
|
||||
st = s;
|
||||
}
|
||||
_UCXXEXPORT bool operator==(const fpos &rhs){
|
||||
return st == rhs.st;
|
||||
}
|
||||
_UCXXEXPORT bool operator!=(const fpos &rhs){
|
||||
return st != rhs.st;
|
||||
}
|
||||
_UCXXEXPORT fpos & operator+(const streamoff & o){
|
||||
st += o;
|
||||
return *this;
|
||||
}
|
||||
_UCXXEXPORT fpos & operator-(const streamoff & o){
|
||||
st -= o;
|
||||
return *this;
|
||||
}
|
||||
_UCXXEXPORT streamoff operator-(const fpos & rhs){
|
||||
return st - rhs.st;
|
||||
}
|
||||
|
||||
private:
|
||||
stateT st;
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <char_traits>
|
||||
#include <memory>
|
||||
|
||||
|
||||
#ifndef __HEADER_STD_IOSFWD
|
||||
#define __HEADER_STD_IOSFWD 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std {
|
||||
class ios_base;
|
||||
template<> class char_traits<char>;
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
template<> class char_traits<wchar_t>;
|
||||
#endif
|
||||
|
||||
template <class charT, class traits = char_traits<charT> > class basic_ios;
|
||||
|
||||
template <class charT, class traits = char_traits<charT> > class basic_streambuf;
|
||||
template <class charT, class traits = char_traits<charT> > class basic_istream;
|
||||
template <class charT, class traits = char_traits<charT> > class basic_ostream;
|
||||
template <class charT, class traits = char_traits<charT> > class basic_iostream;
|
||||
|
||||
template <class charT, class traits = char_traits<charT>,
|
||||
class Allocator = allocator<charT> > class basic_stringbuf;
|
||||
|
||||
template <class charT, class traits = char_traits<charT>,
|
||||
class Allocator = allocator<charT> > class basic_istringstream;
|
||||
|
||||
template <class charT, class traits = char_traits<charT>,
|
||||
class Allocator = allocator<charT> > class basic_ostringstream;
|
||||
|
||||
template <class charT, class traits = char_traits<charT>,
|
||||
class Allocator = allocator<charT> > class basic_stringstream;
|
||||
|
||||
template <class charT, class traits = char_traits<charT> > class basic_filebuf;
|
||||
|
||||
template <class charT, class traits = char_traits<charT> > class basic_ifstream;
|
||||
|
||||
template <class charT, class traits = char_traits<charT> > class basic_ofstream;
|
||||
|
||||
template <class charT, class traits = char_traits<charT> > class basic_fstream;
|
||||
|
||||
template <class charT, class traits = char_traits<charT> > class basic_istreambuf_iterator;
|
||||
|
||||
template <class charT, class traits = char_traits<charT> > class basic_ostreambuf_iterator;
|
||||
|
||||
typedef basic_ios<char> ios;
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
typedef basic_ios<wchar_t> wios;
|
||||
#endif
|
||||
|
||||
typedef basic_streambuf<char> streambuf;
|
||||
typedef basic_istream<char> istream;
|
||||
typedef basic_ostream<char> ostream;
|
||||
typedef basic_iostream<char> iostream;
|
||||
|
||||
typedef basic_stringbuf<char> stringbuf;
|
||||
typedef basic_istringstream<char> istringstream;
|
||||
typedef basic_ostringstream<char> ostringstream;
|
||||
typedef basic_stringstream<char> stringstream;
|
||||
|
||||
typedef basic_filebuf<char> filebuf;
|
||||
typedef basic_ifstream<char> ifstream;
|
||||
typedef basic_ofstream<char> ofstream;
|
||||
typedef basic_fstream<char> fstream;
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
typedef basic_streambuf<wchar_t> wstreambuf;
|
||||
typedef basic_istream<wchar_t> wistream;
|
||||
typedef basic_ostream<wchar_t> wostream;
|
||||
typedef basic_iostream<wchar_t> wiostream;
|
||||
|
||||
typedef basic_stringbuf<wchar_t> wstringbuf;
|
||||
typedef basic_istringstream<wchar_t> wistringstream;
|
||||
typedef basic_ostringstream<wchar_t> wostringstream;
|
||||
typedef basic_stringstream<wchar_t> wstringstream;
|
||||
|
||||
typedef basic_filebuf<wchar_t> wfilebuf;
|
||||
typedef basic_ifstream<wchar_t> wifstream;
|
||||
typedef basic_ofstream<wchar_t> wofstream;
|
||||
typedef basic_fstream<wchar_t> wfstream;
|
||||
#endif
|
||||
|
||||
template <class state> class fpos;
|
||||
typedef fpos<char_traits<char>::state_type> streampos;
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
typedef fpos<char_traits<wchar_t>::state_type> wstreampos;
|
||||
#endif
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
|
||||
#ifndef __HEADER_STD_IOSTREAM
|
||||
#define __HEADER_STD_IOSTREAM 1
|
||||
|
||||
#include <iosfwd>
|
||||
#include <ios>
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
#include <fstream>
|
||||
#include <string_iostream>
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
#ifdef __UCLIBCXX_SUPPORT_CIN__
|
||||
extern istream cin;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_COUT__
|
||||
extern ostream cout;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CERR__
|
||||
extern ostream cerr;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CLOG__
|
||||
extern ostream clog;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCIN__
|
||||
extern wistream wcin;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCOUT__
|
||||
extern wostream wcout;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCERR__
|
||||
extern wostream wcerr;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCLOG__
|
||||
extern wostream wclog;
|
||||
#endif
|
||||
|
||||
|
||||
template <class charT, class traits> class _UCXXEXPORT basic_iostream :
|
||||
public basic_istream<charT,traits>, public basic_ostream<charT,traits>
|
||||
{
|
||||
public:
|
||||
// constructor/destructor
|
||||
explicit _UCXXEXPORT basic_iostream(basic_streambuf<charT,traits>* sb);
|
||||
virtual _UCXXEXPORT ~basic_iostream(); //Below
|
||||
};
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT
|
||||
basic_iostream<charT, traits>:: basic_iostream(basic_streambuf<charT,traits>* sb)
|
||||
: basic_ios<charT, traits>(sb), basic_istream<charT,traits>(sb), basic_ostream<charT,traits>(sb)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_iostream<charT, traits>::~basic_iostream(){
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
|
||||
#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
|
||||
#ifndef __UCLIBCXX_COMPILE_IOSTREAM__
|
||||
|
||||
template <> _UCXXEXPORT basic_iostream<char, char_traits<char> >::
|
||||
basic_iostream(basic_streambuf<char, char_traits<char> >* sb);
|
||||
template <> _UCXXEXPORT basic_iostream<char, char_traits<char> >::~basic_iostream();
|
||||
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,599 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc C++ Library. This library is free
|
||||
software; you can redistribute it and/or modify it under the
|
||||
terms of the GNU General Public License as published by the
|
||||
Free Software Foundation; either version 2, or (at your option)
|
||||
any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License along
|
||||
with this library; see the file COPYING. If not, write to the Free
|
||||
Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
USA.
|
||||
*/
|
||||
|
||||
#include <ios>
|
||||
#include <cctype>
|
||||
#include <streambuf>
|
||||
#include <istream_helpers>
|
||||
#include <ostream>
|
||||
|
||||
#ifndef __STD_HEADER_ISTREAM
|
||||
#define __STD_HEADER_ISTREAM 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
typedef basic_istream<char> istream;
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
typedef basic_istream<wchar_t> wistream;
|
||||
#endif
|
||||
|
||||
template <class charT, class traits> basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is);
|
||||
|
||||
template <class charT, class traits> class _UCXXEXPORT basic_istream :
|
||||
virtual public basic_ios<charT,traits>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef charT char_type;
|
||||
typedef typename traits::int_type int_type;
|
||||
typedef typename traits::pos_type pos_type;
|
||||
typedef typename traits::off_type off_type;
|
||||
typedef basic_streambuf<charT,traits> streambuf_type;
|
||||
typedef traits traits_type;
|
||||
|
||||
explicit basic_istream(basic_streambuf<charT,traits>* sb)
|
||||
: basic_ios<charT, traits>(sb), count_last_ufmt_input(0)
|
||||
{
|
||||
basic_ios<charT, traits>::init(sb);
|
||||
}
|
||||
virtual ~basic_istream() { }
|
||||
|
||||
class sentry;
|
||||
|
||||
basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&));
|
||||
basic_istream<charT,traits>& operator>>(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
|
||||
basic_istream<charT,traits>& operator>>(ios_base& (*pf)(ios_base&));
|
||||
basic_istream<charT,traits>& operator>>(bool& n);
|
||||
basic_istream<charT,traits>& operator>>(short& n);
|
||||
basic_istream<charT,traits>& operator>>(unsigned short& n);
|
||||
basic_istream<charT,traits>& operator>>(int& n);
|
||||
basic_istream<charT,traits>& operator>>(unsigned int& n);
|
||||
basic_istream<charT,traits>& operator>>(long& n);
|
||||
basic_istream<charT,traits>& operator>>(unsigned long& n);
|
||||
basic_istream<charT,traits>& operator>>(void*& p);
|
||||
basic_istream<charT,traits>& operator>>(basic_streambuf<char_type,traits>* sb);
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_FLOATS__
|
||||
basic_istream<charT,traits>& operator>>(float& f);
|
||||
basic_istream<charT,traits>& operator>>(double& f);
|
||||
basic_istream<charT,traits>& operator>>(long double& f);
|
||||
#endif
|
||||
|
||||
_UCXXEXPORT streamsize gcount() const{
|
||||
return count_last_ufmt_input;
|
||||
}
|
||||
|
||||
_UCXXEXPORT int_type get(); //below
|
||||
_UCXXEXPORT basic_istream<charT,traits>& get(char_type& c); //Below
|
||||
|
||||
_UCXXEXPORT basic_istream<charT,traits>& get(char_type* s, streamsize n){
|
||||
return get(s, n, basic_ios<charT,traits>::widen('\n'));
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_istream<charT,traits>& get(char_type* s, streamsize n, char_type delim){
|
||||
sentry(*this, true);
|
||||
streamsize i = 0;
|
||||
int_type c;
|
||||
for(i=0;i<n-1;++i){
|
||||
c = basic_ios<charT, traits>::mstreambuf->sgetc();
|
||||
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
||||
if(c == traits::eof() ){
|
||||
if(i==0){
|
||||
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
||||
}else{
|
||||
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>::mstreambuf->sputbackc(c);
|
||||
break;
|
||||
}
|
||||
s[i] = c;
|
||||
}
|
||||
s[i] = traits::eos();
|
||||
count_last_ufmt_input = i;
|
||||
return *this;
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb){
|
||||
return get(sb, basic_ios<charT,traits>::widen('\n'));
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb, char_type delim){
|
||||
sentry(*this, true);
|
||||
streamsize i = 0;
|
||||
int_type c;
|
||||
while(1){ //We will exit internally based upon error conditions
|
||||
c = basic_ios<charT, traits>::mstreambuf->sgetc();
|
||||
if(c == traits::eof()){
|
||||
if(i==0){
|
||||
basic_ios<charT,traits>::setstate(ios_base::failbit);
|
||||
}else{
|
||||
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);
|
||||
}
|
||||
count_last_ufmt_input = i;
|
||||
return *this;
|
||||
}
|
||||
if(sb.sputc(c) != c){ //Error doing output
|
||||
count_last_ufmt_input = i;
|
||||
return *this;
|
||||
}
|
||||
++i;
|
||||
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
||||
}
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_istream<charT,traits>& getline(char_type* s, streamsize n){
|
||||
return getline(s, n, basic_ios<charT,traits>::widen('\n'));
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_istream<charT,traits>& getline(char_type* s, streamsize n, char_type delim){
|
||||
sentry(*this, true);
|
||||
streamsize i = 0;
|
||||
int_type c;
|
||||
for(i=0;i<n-1;++i){
|
||||
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);
|
||||
}else{
|
||||
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);
|
||||
}
|
||||
if(c == delim){
|
||||
count_last_ufmt_input = i+1;
|
||||
s[i] = traits::eos();
|
||||
return *this;
|
||||
}
|
||||
s[i] = c;
|
||||
}
|
||||
s[n-1] = traits::eos();
|
||||
return *this;
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_istream<charT,traits>& ignore (streamsize n = 1, int_type delim = traits::eof()){
|
||||
sentry(*this, true);
|
||||
streamsize i;
|
||||
int_type c;
|
||||
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);
|
||||
return *this;
|
||||
}
|
||||
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
||||
if(c == delim){
|
||||
return *this;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
_UCXXEXPORT int_type peek(){
|
||||
if(basic_ios<charT,traits>::good() == false){
|
||||
return traits::eof();
|
||||
}else{
|
||||
int_type c = basic_ios<charT, traits>::mstreambuf->sgetc();
|
||||
if(c == traits::eof()){
|
||||
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
||||
}
|
||||
return basic_ios<charT, traits>::mstreambuf->sgetc();
|
||||
}
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_istream<charT,traits>& read (char_type* s, streamsize n){
|
||||
sentry(*this, true);
|
||||
streamsize i;
|
||||
int_type c;
|
||||
for(i=0;i<n;++i){
|
||||
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);
|
||||
count_last_ufmt_input = i;
|
||||
return *this;
|
||||
}
|
||||
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
||||
s[i] = c;
|
||||
}
|
||||
count_last_ufmt_input = n;
|
||||
return *this;
|
||||
}
|
||||
|
||||
_UCXXEXPORT streamsize readsome(char_type* s, streamsize n){
|
||||
sentry(*this, true);
|
||||
if(!basic_ios<charT,traits>::good()){
|
||||
count_last_ufmt_input = 0;
|
||||
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);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if(n > basic_ios<charT, traits>::mstreambuf->in_avail() ){
|
||||
n = basic_ios<charT, traits>::mstreambuf->in_avail();
|
||||
}
|
||||
|
||||
streamsize i;
|
||||
int_type c;
|
||||
|
||||
for(i=0;i<n;++i){
|
||||
c = basic_ios<charT, traits>::mstreambuf->sgetc();
|
||||
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
||||
s[i] = c;
|
||||
}
|
||||
count_last_ufmt_input = n;
|
||||
return n;
|
||||
}
|
||||
|
||||
_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);
|
||||
return *this;
|
||||
}
|
||||
if(basic_ios<charT, traits>::mstreambuf == 0){
|
||||
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);
|
||||
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);
|
||||
return *this;
|
||||
}
|
||||
if(basic_ios<charT, traits>::mstreambuf == 0){
|
||||
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);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
_UCXXEXPORT int sync(){
|
||||
sentry(*this, true);
|
||||
if(basic_ios<charT, traits>::mstreambuf == 0){
|
||||
return -1;
|
||||
}
|
||||
if(basic_ios<charT, traits>::mstreambuf->pubsync() == -1){
|
||||
basic_ios<charT,traits>::setstate(ios_base::badbit);
|
||||
return traits::eof();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
_UCXXEXPORT pos_type tellg(){
|
||||
if(basic_ios<charT,traits>::fail() !=false){
|
||||
return pos_type(-1);
|
||||
}
|
||||
return basic_ios<charT, traits>::mstreambuf->pubseekoff(0, ios_base::cur, ios_base::in);
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_istream<charT,traits>& seekg(pos_type pos){
|
||||
if(basic_ios<charT,traits>::fail() !=true){
|
||||
basic_ios<charT, traits>::mstreambuf->pubseekpos(pos);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
_UCXXEXPORT basic_istream<charT,traits>& seekg(off_type off, ios_base::seekdir dir){
|
||||
if(basic_ios<charT,traits>::fail() !=true){
|
||||
basic_ios<charT, traits>::mstreambuf->pubseekoff(off, dir);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
protected:
|
||||
_UCXXEXPORT basic_istream(const basic_istream<charT,traits> &): basic_ios<charT, traits>() { }
|
||||
_UCXXEXPORT basic_istream<charT,traits> & operator=(const basic_istream<charT,traits> &){ return *this; }
|
||||
streamsize count_last_ufmt_input;
|
||||
|
||||
};
|
||||
|
||||
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){
|
||||
if(os.good() !=0){ //Prepare for output
|
||||
}
|
||||
|
||||
//Flush any tied buffer
|
||||
if(os.tie() != 0){
|
||||
os.tie()->flush();
|
||||
}
|
||||
if(!noskipws){
|
||||
__skipws(os);
|
||||
}
|
||||
|
||||
ok = true;
|
||||
}
|
||||
_UCXXEXPORT ~sentry() { }
|
||||
_UCXXEXPORT operator bool() {
|
||||
return ok;
|
||||
}
|
||||
};
|
||||
|
||||
//Template implementations of basic_istream functions which may be partially specialized
|
||||
//For code reduction
|
||||
|
||||
template <class charT, class traits>
|
||||
_UCXXEXPORT typename basic_istream<charT,traits>::int_type basic_istream<charT,traits>::get(){
|
||||
sentry(*this, true);
|
||||
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);
|
||||
}else{
|
||||
count_last_ufmt_input = 1;
|
||||
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
template <class charT, class traits>
|
||||
_UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::get(char_type& c){
|
||||
sentry(*this, true);
|
||||
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);
|
||||
}else{
|
||||
count_last_ufmt_input = 1;
|
||||
c = traits::to_char_type(retval);
|
||||
basic_ios<charT, traits>::mstreambuf->sbumpc();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
basic_istream<charT,traits>::operator>>(bool& n)
|
||||
{
|
||||
sentry(*this);
|
||||
__istream_readin<traits, charT, bool>::readin(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
basic_istream<charT,traits>::operator>>(short& n)
|
||||
{
|
||||
sentry(*this);
|
||||
__istream_readin<traits, charT, short>::readin(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
basic_istream<charT,traits>::operator>>(unsigned short& n)
|
||||
{
|
||||
sentry(*this);
|
||||
__istream_readin<traits, charT, unsigned short>::readin(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(int& n){
|
||||
sentry(*this);
|
||||
__istream_readin<traits, charT, int>::readin(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(unsigned int& n){
|
||||
sentry(*this);
|
||||
__istream_readin<traits, charT, unsigned int>::readin(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>& basic_istream<charT,traits>::operator>>(long int& n){
|
||||
sentry(*this);
|
||||
__istream_readin<traits, charT, long int>::readin(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
basic_istream<charT,traits>::operator>>(unsigned long int& n)
|
||||
{
|
||||
sentry(*this);
|
||||
__istream_readin<traits, charT, unsigned long int>::readin(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_FLOATS__
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
basic_istream<charT,traits>::operator>>(float& n)
|
||||
{
|
||||
sentry(*this);
|
||||
__istream_readin<traits, charT, float>::readin(*this, n);
|
||||
return *this;
|
||||
}
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
basic_istream<charT,traits>::operator>>(double& n)
|
||||
{
|
||||
sentry(*this);
|
||||
__istream_readin<traits, charT, double>::readin(*this, n);
|
||||
return *this;
|
||||
}
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
basic_istream<charT,traits>::operator>>(long double& n)
|
||||
{
|
||||
sentry(*this);
|
||||
__istream_readin<traits, charT, long double>::readin(*this, n);
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
basic_istream<charT,traits>::operator>>(void *& n)
|
||||
{
|
||||
sentry(*this);
|
||||
__istream_readin<traits, charT, void*>::readin(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
operator>>(basic_istream<charT,traits>& is, charT& c)
|
||||
{
|
||||
typename basic_istream<charT,traits>::sentry s(is);
|
||||
is.get(c);
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class traits> _UCXXEXPORT basic_istream<char,traits>&
|
||||
operator>>(basic_istream<char,traits>& is, unsigned char& c)
|
||||
{
|
||||
typename basic_istream<char,traits>::sentry s(is);
|
||||
char b;
|
||||
is.get(b);
|
||||
c = b;
|
||||
return is;
|
||||
}
|
||||
template<class traits> _UCXXEXPORT basic_istream<char,traits>&
|
||||
operator>>(basic_istream<char,traits>& is, signed char& c)
|
||||
{
|
||||
typename basic_istream<char,traits>::sentry s(is);
|
||||
is.get(c);
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
operator>>(basic_istream<charT,traits>& is, charT* c)
|
||||
{
|
||||
typename basic_istream<charT,traits>::sentry s(is);
|
||||
int n = is.width();
|
||||
if(n == 0){
|
||||
n = __STRING_MAX_UNITS;
|
||||
}
|
||||
is.get(c, n);
|
||||
return is;
|
||||
|
||||
}
|
||||
template<class traits> _UCXXEXPORT basic_istream<char,traits>&
|
||||
operator>>(basic_istream<char,traits>& is, unsigned char* c)
|
||||
{
|
||||
typename basic_istream<char,traits>::sentry s(is);
|
||||
int n = is.width();
|
||||
if(n == 0){
|
||||
n = __STRING_MAX_UNITS;
|
||||
}
|
||||
is.get(c, n);
|
||||
return is;
|
||||
}
|
||||
template<class traits> _UCXXEXPORT basic_istream<char,traits>&
|
||||
operator>>(basic_istream<char,traits>& is, signed char* c)
|
||||
{
|
||||
typename basic_istream<char,traits>::sentry s(is);
|
||||
int n = is.width();
|
||||
if(n == 0){
|
||||
n = __STRING_MAX_UNITS;
|
||||
}
|
||||
is.get(c, n);
|
||||
return is;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
basic_istream<charT,traits>::operator>>(basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
|
||||
{
|
||||
sentry(*this);
|
||||
pf(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
basic_istream<charT,traits>::operator>>(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&))
|
||||
{
|
||||
sentry(*this);
|
||||
pf(*this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
ws(basic_istream<charT,traits>& is)
|
||||
{
|
||||
__skipws(is);
|
||||
return is;
|
||||
}
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
|
||||
#ifndef __UCLIBCXX_COMPILE_ISTREAM__
|
||||
|
||||
|
||||
template <> _UCXXEXPORT istream & basic_istream<char, char_traits<char> >::get(char & c);
|
||||
template <> _UCXXEXPORT istream::int_type basic_istream<char, char_traits<char> >::get();
|
||||
|
||||
template <> _UCXXEXPORT istream & istream::operator>>(bool &n);
|
||||
template <> _UCXXEXPORT istream & istream::operator>>(short &n);
|
||||
template <> _UCXXEXPORT istream & istream::operator>>(unsigned short &n);
|
||||
template <> _UCXXEXPORT istream & istream::operator>>(int &n);
|
||||
template <> _UCXXEXPORT istream & istream::operator>>(unsigned int &n);
|
||||
template <> _UCXXEXPORT istream & istream::operator>>(long unsigned &n);
|
||||
template <> _UCXXEXPORT istream & istream::operator>>(long int &n);
|
||||
template <> _UCXXEXPORT istream & istream::operator>>(void *& p);
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_FLOATS__
|
||||
template <> _UCXXEXPORT istream & istream::operator>>(float &f);
|
||||
template <> _UCXXEXPORT istream & istream::operator>>(double &f);
|
||||
template <> _UCXXEXPORT istream & istream::operator>>(long double &f);
|
||||
#endif
|
||||
|
||||
template <> _UCXXEXPORT istream & operator>>(istream & is, char & c);
|
||||
|
||||
template <> _UCXXEXPORT void __skipws(basic_istream<char,char_traits<char> >& is);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,374 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <ios>
|
||||
#include <cctype>
|
||||
#include <ctype.h>
|
||||
|
||||
#include <string>
|
||||
|
||||
#ifndef __STD_HEADER_ISTREAM_HELPERS
|
||||
#define __STD_HEADER_ISTREAM_HELPERS 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
/* We are making the following template class for serveral reasons. Firstly,
|
||||
* we want to keep the main istream code neat and tidy. Secondly, we want it
|
||||
* to be easy to do partial specialization of the istream code so that it can
|
||||
* be expanded and put into the library. This will allow us to make application
|
||||
* code smaller at the expense of increased library size. This is a fair
|
||||
* trade-off when there are multiple applications being compiled. Also, this
|
||||
* feature will be used optionally via configuration options. It will also
|
||||
* allow us to keep the code bases in sync, dramatically simplifying the
|
||||
* maintenance required. We specialized for char because wchar and others
|
||||
* require different scanf functions
|
||||
*/
|
||||
|
||||
template <class C, class traits> _UCXXEXPORT
|
||||
basic_string<C, traits> _readToken(basic_istream<C, traits>& stream)
|
||||
{
|
||||
basic_string<C, traits> temp;
|
||||
typename traits::int_type c;
|
||||
while(true){
|
||||
c = stream.rdbuf()->sgetc();
|
||||
if(c != traits::eof() && isspace(c) == false){
|
||||
stream.rdbuf()->sbumpc();
|
||||
temp.append(1, traits::to_char_type(c));
|
||||
}else{
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (temp.size() == 0)
|
||||
stream.setstate(ios_base::eofbit|ios_base::failbit);
|
||||
|
||||
return temp;
|
||||
}
|
||||
|
||||
template <class C, class traits> _UCXXEXPORT
|
||||
basic_string<C, traits> _readTokenDecimal(basic_istream<C, traits>& stream)
|
||||
{
|
||||
basic_string<C, traits> temp;
|
||||
typename traits::int_type c;
|
||||
while(true){
|
||||
c = stream.rdbuf()->sgetc();
|
||||
if(c != traits::eof() && isspace(c) == false && (
|
||||
isdigit(c) ||
|
||||
c == '.' ||
|
||||
c == ',' ||
|
||||
((c == '-' || c == '+') && temp.size() == 0) )
|
||||
){
|
||||
stream.rdbuf()->sbumpc();
|
||||
temp.append(1, traits::to_char_type(c));
|
||||
}else{
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (temp.size() == 0)
|
||||
stream.setstate(ios_base::eofbit|ios_base::failbit);
|
||||
|
||||
return temp;
|
||||
}
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
|
||||
|
||||
template <> _UCXXEXPORT string _readToken<char, char_traits<char> >(istream & stream);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
template <class traits, class charT, class dataType> class _UCXXEXPORT __istream_readin{
|
||||
public:
|
||||
static void readin(basic_istream<charT,traits>& stream, dataType & var);
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __istream_readin<traits, char, bool>{
|
||||
public:
|
||||
inline static void readin(basic_istream<char, traits >& stream, bool & var)
|
||||
{
|
||||
/* 22.4.2.1.2.4 */
|
||||
basic_string<char, traits > temp;
|
||||
temp = _readToken( stream);
|
||||
if (stream.flags() & ios_base::boolalpha) {
|
||||
if (temp == "true") // truename()
|
||||
var = true;
|
||||
else {
|
||||
var = false;
|
||||
if (temp != "false") // falsename()
|
||||
stream.setstate(ios_base::failbit);
|
||||
}
|
||||
} else {
|
||||
long int i = 0;
|
||||
int ret;
|
||||
if (stream.flags() & ios_base::dec) {
|
||||
ret = sscanf(temp.c_str(), "%ld", &i );
|
||||
} else {
|
||||
if (stream.flags() & ios_base::oct) {
|
||||
ret = sscanf(temp.c_str(), "%lo", (unsigned long int *)(&i));
|
||||
} else if (stream.flags() & ios_base::hex) {
|
||||
if (stream.flags() & ios_base::uppercase) {
|
||||
ret = sscanf(temp.c_str(), "%lX", (unsigned long int *)(&i));
|
||||
} else {
|
||||
ret = sscanf(temp.c_str(), "%lx", (unsigned long int *)(&i));
|
||||
}
|
||||
} else {
|
||||
ret = sscanf(temp.c_str(), "%li", &i);
|
||||
}
|
||||
}
|
||||
if (ret != 1 || i >> 1)
|
||||
stream.setstate(ios_base::failbit);
|
||||
var = ret == 1 && bool(i);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <class traits> class _UCXXEXPORT __istream_readin<traits, char, short>{
|
||||
public:
|
||||
inline static void readin(basic_istream<char, traits >& stream, short & var)
|
||||
{
|
||||
basic_string<char, traits > temp;
|
||||
|
||||
if(stream.flags() & ios_base::dec){
|
||||
temp = _readTokenDecimal( stream);
|
||||
sscanf(temp.c_str(), "%hd", &var );
|
||||
}else{
|
||||
temp = _readToken( stream);
|
||||
if( stream.flags() & ios_base::oct){
|
||||
sscanf(temp.c_str(), "%ho", (unsigned short int *)(&var) );
|
||||
}else if(stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
sscanf(temp.c_str(), "%hX", (unsigned short int *)(&var) );
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%hx", (unsigned short int *)(&var) );
|
||||
}
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%hi", &var);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned short>{
|
||||
public:
|
||||
inline static void readin(basic_istream<char, traits >& stream, unsigned short & var)
|
||||
{
|
||||
basic_string<char, traits > temp;
|
||||
|
||||
if(stream.flags() & ios_base::dec){
|
||||
temp = _readTokenDecimal( stream);
|
||||
sscanf(temp.c_str(), "%hu", &var );
|
||||
}else{
|
||||
temp = _readToken( stream);
|
||||
if( stream.flags() & ios_base::oct){
|
||||
sscanf(temp.c_str(), "%ho", &var);
|
||||
}else if(stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
sscanf(temp.c_str(), "%hX", &var );
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%hx", &var);
|
||||
}
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%hi", (signed short int*)(&var) );
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __istream_readin<traits, char, int>{
|
||||
public:
|
||||
inline static void readin(basic_istream<char, traits >& stream, int & var)
|
||||
{
|
||||
basic_string<char, traits > temp;
|
||||
|
||||
if(stream.flags() & ios_base::dec){
|
||||
temp = _readTokenDecimal( stream);
|
||||
sscanf(temp.c_str(), "%d", &var );
|
||||
}else{
|
||||
temp = _readToken( stream);
|
||||
if( stream.flags() & ios_base::oct){
|
||||
sscanf(temp.c_str(), "%o", (unsigned int *)(&var) );
|
||||
}else if(stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
sscanf(temp.c_str(), "%X", (unsigned int *)(&var) );
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%x", (unsigned int *)(&var) );
|
||||
}
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%i", &var);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned int>{
|
||||
public:
|
||||
inline static void readin(basic_istream<char, traits >& stream, unsigned int & var)
|
||||
{
|
||||
basic_string<char, traits > temp;
|
||||
|
||||
if(stream.flags() & ios_base::dec){
|
||||
temp = _readTokenDecimal( stream);
|
||||
sscanf(temp.c_str(), "%u", &var );
|
||||
}else{
|
||||
temp = _readToken( stream);
|
||||
if( stream.flags() & ios_base::oct){
|
||||
sscanf(temp.c_str(), "%o", (unsigned int *)(&var) );
|
||||
}else if(stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
sscanf(temp.c_str(), "%X", (unsigned int *)(&var) );
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%x", (unsigned int *)(&var) );
|
||||
}
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%i", (int *)(&var) );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <class traits> class _UCXXEXPORT __istream_readin<traits, char, long int>{
|
||||
public:
|
||||
inline static void readin(basic_istream<char, traits >& stream, long int & var)
|
||||
{
|
||||
basic_string<char, traits > temp;
|
||||
|
||||
if(stream.flags() & ios_base::dec){
|
||||
temp = _readTokenDecimal( stream);
|
||||
sscanf(temp.c_str(), "%ld", &var );
|
||||
}else{
|
||||
temp = _readToken( stream);
|
||||
if( stream.flags() & ios_base::oct){
|
||||
sscanf(temp.c_str(), "%lo", (unsigned long int *)(&var) );
|
||||
}else if(stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
sscanf(temp.c_str(), "%lX", (unsigned long int *)(&var) );
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%lx", (unsigned long int *)(&var) );
|
||||
}
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%li", (long int *)(&var) );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <class traits> class _UCXXEXPORT __istream_readin<traits, char, unsigned long int>{
|
||||
public:
|
||||
inline static void readin(basic_istream<char, traits >& stream, unsigned long int & var)
|
||||
{
|
||||
basic_string<char, traits > temp;
|
||||
|
||||
if(stream.flags() & ios_base::dec){
|
||||
temp = _readTokenDecimal( stream);
|
||||
sscanf(temp.c_str(), "%lu", &var );
|
||||
}else{
|
||||
temp = _readToken( stream);
|
||||
if( stream.flags() & ios_base::oct){
|
||||
sscanf(temp.c_str(), "%lo", &var );
|
||||
}else if(stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
sscanf(temp.c_str(), "%lX", &var );
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%lx", &var);
|
||||
}
|
||||
}else{
|
||||
sscanf(temp.c_str(), "%li", (long int *)(&var) );
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_FLOATS__
|
||||
|
||||
template <class traits> class _UCXXEXPORT __istream_readin<traits, char, float>{
|
||||
public:
|
||||
inline static void readin(basic_istream<char, traits >& stream, float & var)
|
||||
{
|
||||
basic_string<char, traits > temp;
|
||||
temp = _readTokenDecimal( stream);
|
||||
|
||||
sscanf(temp.c_str(), "%g", &var);
|
||||
}
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __istream_readin<traits, char, double>{
|
||||
public:
|
||||
inline static void readin(basic_istream<char, traits >& stream, double & var)
|
||||
{
|
||||
basic_string<char, traits > temp;
|
||||
temp = _readTokenDecimal( stream);
|
||||
sscanf(temp.c_str(), "%lg", &var);
|
||||
}
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __istream_readin<traits, char, long double>{
|
||||
public:
|
||||
inline static void readin(basic_istream<char, traits >& stream, long double & var)
|
||||
{
|
||||
basic_string<char, traits > temp;
|
||||
temp = _readTokenDecimal( stream);
|
||||
sscanf(temp.c_str(), "%Lg", &var);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // ifdef __UCLIBCXX_HAS_FLOATS__
|
||||
|
||||
template <class traits> class _UCXXEXPORT __istream_readin<traits, char, void*>{
|
||||
public:
|
||||
inline static void readin(basic_istream<char, traits >& stream, void* & var)
|
||||
{
|
||||
basic_string<char, traits > temp;
|
||||
temp = _readToken( stream);
|
||||
sscanf(temp.c_str(), "%p", &var);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<class charT, class traits> void __skipws(basic_istream<charT,traits>& is){
|
||||
const typename basic_istream<charT,traits>::int_type eof = traits::eof();
|
||||
typename basic_istream<charT,traits>::int_type c;
|
||||
//While the next character normally read doesn't equal eof
|
||||
//and that character is a space, advance to the next read position
|
||||
//Thus itterating through all whitespace until we get to the meaty stuff
|
||||
while (
|
||||
!traits::eq_int_type((c = is.rdbuf()->sgetc()), eof)
|
||||
&& isspace(c)
|
||||
) {
|
||||
is.rdbuf()->sbumpc();
|
||||
}
|
||||
if(traits::eq_int_type(c, eof)){
|
||||
is.setstate(ios_base::eofbit);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,229 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <iosfwd>
|
||||
#include <cstddef>
|
||||
#include <char_traits>
|
||||
#include <iterator_base>
|
||||
|
||||
|
||||
|
||||
#ifndef __STD_HEADER_ITERATOR
|
||||
#define __STD_HEADER_ITERATOR 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
// subclause _lib.stream.iterators_, stream iterators:
|
||||
template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> class istream_iterator;
|
||||
template <class T, class charT, class traits, class Distance> bool
|
||||
operator==(const istream_iterator<T,charT,traits,Distance>& x, const istream_iterator<T,charT,traits,Distance>& y);
|
||||
template <class T, class charT, class traits, class Distance> bool
|
||||
operator!=(const istream_iterator<T,charT,traits,Distance>& x, const istream_iterator<T,charT,traits,Distance>& y);
|
||||
template <class T, class charT = char, class traits = char_traits<charT> > class ostream_iterator;
|
||||
template<class charT, class traits = char_traits<charT> > class istreambuf_iterator;
|
||||
template <class charT, class traits> bool
|
||||
operator==(const istreambuf_iterator<charT,traits>& a, const istreambuf_iterator<charT,traits>& b);
|
||||
template <class charT, class traits> bool
|
||||
operator!=(const istreambuf_iterator<charT,traits>& a, const istreambuf_iterator<charT,traits>& b);
|
||||
template <class charT, class traits = char_traits<charT> > class ostreambuf_iterator;
|
||||
|
||||
|
||||
template < class T, class charT, class traits, class Distance > class _UCXXEXPORT istream_iterator
|
||||
: public iterator<input_iterator_tag,T,Distance,const T*, const T&>
|
||||
{
|
||||
public:
|
||||
typedef charT char_type;
|
||||
typedef traits traits_type;
|
||||
typedef basic_istream<charT,traits> istream_type;
|
||||
istream_iterator() : in_stream(0), value(0) {}
|
||||
istream_iterator(istream_type& s) : in_stream(&s), value() {
|
||||
*in_stream >> value;
|
||||
}
|
||||
istream_iterator(const istream_iterator<T,charT,traits,Distance>& x)
|
||||
: in_stream(x.in_stream), value(x.value)
|
||||
{ }
|
||||
~istream_iterator() { }
|
||||
const T& operator*() const{
|
||||
return value;
|
||||
}
|
||||
const T* operator->() const{
|
||||
return &value;
|
||||
}
|
||||
istream_iterator<T,charT,traits,Distance>& operator++() {
|
||||
*in_stream >> value;
|
||||
return *this;
|
||||
}
|
||||
istream_iterator<T,charT,traits,Distance> operator++(int){
|
||||
istream_iterator<T,charT,traits,Distance> tmp = *this;
|
||||
*in_stream >> value;
|
||||
return (tmp);
|
||||
}
|
||||
bool m_equal(const istream_iterator<T,charT,traits,Distance>& x) const{
|
||||
return (in_stream == x.in_stream);
|
||||
}
|
||||
private:
|
||||
basic_istream<charT,traits>* in_stream;
|
||||
T value;
|
||||
};
|
||||
|
||||
template <class T, class charT, class traits, class Distance> _UCXXEXPORT
|
||||
bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
|
||||
const istream_iterator<T,charT,traits,Distance>& y)
|
||||
{
|
||||
return x.m_equal(y);
|
||||
}
|
||||
|
||||
template <class T, class charT, class traits, class Distance> _UCXXEXPORT
|
||||
bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
|
||||
const istream_iterator<T,charT,traits,Distance>& y)
|
||||
{
|
||||
return !(x == y);
|
||||
}
|
||||
|
||||
template <class T, class charT, class traits> class _UCXXEXPORT ostream_iterator
|
||||
: public iterator<output_iterator_tag,void,void,void,void>
|
||||
{
|
||||
public:
|
||||
typedef charT char_type;
|
||||
typedef traits traits_type;
|
||||
typedef basic_ostream<charT,traits> ostream_type;
|
||||
|
||||
ostream_iterator(ostream_type& s) : out_stream(&s), delim(0) { }
|
||||
ostream_iterator(ostream_type& s, const charT* delimiter) : out_stream(&s), delim(delimiter) { }
|
||||
ostream_iterator(const ostream_iterator<T,charT,traits>& x) : out_stream(x.out_stream), delim(x.delim) { }
|
||||
~ostream_iterator() { }
|
||||
ostream_iterator<T,charT,traits>& operator=(const T& value){
|
||||
*out_stream << value;
|
||||
if(delim != 0){
|
||||
*out_stream << delim;
|
||||
}
|
||||
return (*this);
|
||||
}
|
||||
ostream_iterator<T,charT,traits>& operator*(){ return *this; }
|
||||
ostream_iterator<T,charT,traits>& operator++() { return *this; }
|
||||
ostream_iterator<T,charT,traits> operator++(int) { return *this; }
|
||||
private:
|
||||
basic_ostream<charT,traits>* out_stream;
|
||||
const char* delim;
|
||||
};
|
||||
|
||||
template<class charT, class traits > class _UCXXEXPORT istreambuf_iterator :
|
||||
public iterator<input_iterator_tag, charT, typename traits::off_type, charT*, charT&>
|
||||
{
|
||||
public:
|
||||
typedef charT char_type;
|
||||
typedef traits traits_type;
|
||||
typedef typename traits::int_type int_type;
|
||||
typedef basic_streambuf<charT,traits> streambuf_type;
|
||||
typedef basic_istream<charT,traits> istream_type;
|
||||
|
||||
class _UCXXEXPORT proxy{
|
||||
charT val;
|
||||
basic_streambuf<charT, traits> * buf;
|
||||
|
||||
proxy(charT v, basic_streambuf<charT, traits> * b) : val(v), buf(b) { }
|
||||
public:
|
||||
charT operator*() { return val; }
|
||||
};
|
||||
|
||||
istreambuf_iterator() throw() : sbuf(0) { }
|
||||
istreambuf_iterator(istream_type& s) throw() : sbuf(s.rdbuf()) { }
|
||||
istreambuf_iterator(streambuf_type* s) throw() : sbuf(s) { }
|
||||
istreambuf_iterator(const proxy& p) throw() : sbuf(&p.buf) { }
|
||||
|
||||
charT operator*() const{
|
||||
return sbuf->sgetc();
|
||||
}
|
||||
istreambuf_iterator<charT,traits>& operator++(){
|
||||
sbuf->sbumpc();
|
||||
return *this;
|
||||
}
|
||||
proxy operator++(int){
|
||||
istreambuf_iterator<charT,traits> tmp = *this;
|
||||
sbuf->sbumpc();
|
||||
return(tmp);
|
||||
}
|
||||
|
||||
bool equal(const istreambuf_iterator& b) const{
|
||||
return sbuf == b.sbuf || is_eof() && b.is_eof();
|
||||
}
|
||||
private:
|
||||
streambuf_type* sbuf;
|
||||
inline bool is_eof() const{
|
||||
return sbuf == 0 || sbuf->sgetc() == traits_type::eof();
|
||||
}
|
||||
};
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT bool
|
||||
operator==(const istreambuf_iterator<charT,traits>& a,
|
||||
const istreambuf_iterator<charT,traits>& b)
|
||||
{
|
||||
return a.equal(b);
|
||||
}
|
||||
|
||||
template <class charT, class traits> bool _UCXXEXPORT
|
||||
operator!=(const istreambuf_iterator<charT,traits>& a,
|
||||
const istreambuf_iterator<charT,traits>& b)
|
||||
{
|
||||
return !a.equal(b);
|
||||
}
|
||||
|
||||
template <class charT, class traits> class _UCXXEXPORT ostreambuf_iterator
|
||||
: iterator<output_iterator_tag,void,void,void,void>
|
||||
{
|
||||
public:
|
||||
typedef charT char_type;
|
||||
typedef traits traits_type;
|
||||
typedef basic_streambuf<charT,traits> streambuf_type;
|
||||
typedef basic_ostream<charT,traits> ostream_type;
|
||||
public:
|
||||
ostreambuf_iterator(ostream_type& s) throw() : sbuf(s.rdbuf()), f(false) { }
|
||||
ostreambuf_iterator(streambuf_type* s) throw() : sbuf(s), f(false) { }
|
||||
ostreambuf_iterator& operator=(charT c){
|
||||
if(failed() == false){
|
||||
if(sbuf->sputc(c) == traits::eof()){
|
||||
f = true;
|
||||
}
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
ostreambuf_iterator& operator*(){
|
||||
return *this;
|
||||
}
|
||||
ostreambuf_iterator& operator++() { return *this; }
|
||||
ostreambuf_iterator operator++(int) { return *this; }
|
||||
bool failed() const throw(){
|
||||
return f;
|
||||
}
|
||||
|
||||
private:
|
||||
streambuf_type* sbuf;
|
||||
bool f;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,305 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
|
||||
#ifndef __STD_HEADER_ITERATOR_BASE
|
||||
#define __STD_HEADER_ITERATOR_BASE 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
template<class Iterator> struct iterator_traits;
|
||||
template<class T> struct iterator_traits<T*>;
|
||||
|
||||
template<class Category, class T, class Distance = ptrdiff_t, class Pointer = T*, class Reference = T&> struct iterator;
|
||||
|
||||
struct _UCXXEXPORT input_iterator_tag {};
|
||||
struct _UCXXEXPORT output_iterator_tag {};
|
||||
struct _UCXXEXPORT forward_iterator_tag: public input_iterator_tag {};
|
||||
struct _UCXXEXPORT bidirectional_iterator_tag: public forward_iterator_tag {};
|
||||
struct _UCXXEXPORT random_access_iterator_tag: public bidirectional_iterator_tag {};
|
||||
|
||||
template <class InputIterator, class Distance> _UCXXEXPORT void advance(InputIterator& i, Distance n){
|
||||
while(n > 0){
|
||||
--n;
|
||||
++i;
|
||||
}
|
||||
}
|
||||
|
||||
template <class InputIterator> _UCXXEXPORT typename iterator_traits<InputIterator>::difference_type
|
||||
distance(InputIterator first, InputIterator last)
|
||||
{
|
||||
typename iterator_traits<InputIterator>::difference_type d = 0;
|
||||
while(first++ !=last){
|
||||
d++;
|
||||
}
|
||||
return d;
|
||||
}
|
||||
|
||||
// subclause _lib.predef.iterators_, predefined iterators:
|
||||
template <class Iterator> class reverse_iterator;
|
||||
template <class Iterator> bool operator==(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
|
||||
template <class Iterator> bool operator<(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
|
||||
template <class Iterator> bool operator!=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
|
||||
template <class Iterator> bool operator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
|
||||
template <class Iterator> bool operator>=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
|
||||
template <class Iterator> bool operator<=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
|
||||
template <class Iterator> typename reverse_iterator<Iterator>::difference_type
|
||||
operator-( const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
|
||||
template <class Iterator> reverse_iterator<Iterator>
|
||||
operator+( typename reverse_iterator<Iterator>::difference_type n, const reverse_iterator<Iterator>& x);
|
||||
template <class Container> class back_insert_iterator;
|
||||
template <class Container> back_insert_iterator<Container> back_inserter(Container& x);
|
||||
template <class Container> class front_insert_iterator;
|
||||
template <class Container> front_insert_iterator<Container> front_inserter(Container& x);
|
||||
template <class Container> class insert_iterator;
|
||||
template <class Container, class Iterator>
|
||||
insert_iterator<Container> inserter(Container& x, Iterator i);
|
||||
|
||||
//Actual Template definitions
|
||||
|
||||
template<class Iterator> struct _UCXXEXPORT iterator_traits {
|
||||
typedef typename Iterator::difference_type difference_type;
|
||||
typedef typename Iterator::value_type value_type;
|
||||
typedef typename Iterator::pointer pointer;
|
||||
typedef typename Iterator::reference reference;
|
||||
typedef typename Iterator::iterator_category iterator_category;
|
||||
};
|
||||
|
||||
//Pointer specialization - required by standard
|
||||
template<class T> struct _UCXXEXPORT iterator_traits<T*> {
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef T value_type;
|
||||
typedef T* pointer;
|
||||
typedef T& reference;
|
||||
typedef random_access_iterator_tag iterator_category;
|
||||
};
|
||||
|
||||
//Specialization recomended by standard
|
||||
/* template<class T> struct _UCXXEXPORT iterator_traits<T __far*> {
|
||||
typedef long difference_type;
|
||||
typedef T value_type;
|
||||
typedef T __far* pointer;
|
||||
typedef T __far& reference;
|
||||
typedef random_access_iterator_tag iterator_category;
|
||||
};*/
|
||||
|
||||
/* template <class BidirectionalIterator> _UCXXEXPORT void
|
||||
reverse(BidirectionalIterator first, BidirectionalIterator last)
|
||||
{
|
||||
typename iterator_traits<BidirectionalIterator>::difference_type n = distance(first, last);
|
||||
--n;
|
||||
while(n > 0){
|
||||
typename iterator_traits<BidirectionalIterator>::value_type tmp = *first;
|
||||
*first++ = * --last;
|
||||
*last = tmp;
|
||||
n -= 2;
|
||||
}
|
||||
};*/
|
||||
|
||||
|
||||
template <class Category, class T, class Distance, class Pointer, class Reference>
|
||||
struct _UCXXEXPORT iterator
|
||||
{
|
||||
typedef T value_type;
|
||||
typedef Distance difference_type;
|
||||
typedef Pointer pointer;
|
||||
typedef Reference reference;
|
||||
typedef Category iterator_category;
|
||||
};
|
||||
|
||||
|
||||
template <class Iterator> class _UCXXEXPORT reverse_iterator
|
||||
: public iterator<typename iterator_traits<Iterator>::iterator_category,
|
||||
typename iterator_traits<Iterator>::value_type, typename iterator_traits<Iterator>::difference_type,
|
||||
typename iterator_traits<Iterator>::pointer, typename iterator_traits<Iterator>::reference>
|
||||
{
|
||||
protected:
|
||||
Iterator current;
|
||||
friend bool operator== <Iterator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
|
||||
friend bool operator< <Iterator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y);
|
||||
|
||||
public:
|
||||
typedef Iterator iterator_type;
|
||||
|
||||
reverse_iterator() : current(){};
|
||||
explicit reverse_iterator(Iterator x) : current(x) { }
|
||||
template<class U> reverse_iterator(const reverse_iterator<U> &x) : current(x.base()){}
|
||||
|
||||
Iterator base() const { return current; } // explicit
|
||||
|
||||
typename iterator_traits<Iterator>::reference operator*() const { Iterator tmp = current; return *--tmp; }
|
||||
typename iterator_traits<Iterator>::pointer operator->() const { return &(operator*()); }
|
||||
typename iterator_traits<Iterator>::reference operator[](typename iterator_traits<Iterator>::difference_type n) const{
|
||||
return current[-n-1];
|
||||
}
|
||||
|
||||
reverse_iterator& operator++(){ --current; return *this; }
|
||||
reverse_iterator operator++(int) {reverse_iterator tmp = *this; --current; return tmp; }
|
||||
reverse_iterator& operator--() { ++ current; return *this; }
|
||||
reverse_iterator operator--(int) {reverse_iterator tmp = *this; ++current; return tmp; }
|
||||
|
||||
reverse_iterator operator+ (typename iterator_traits<Iterator>::difference_type n) const{
|
||||
reverse_iterator retval( *this );
|
||||
retval+=n;
|
||||
return retval;
|
||||
}
|
||||
reverse_iterator& operator+=(typename iterator_traits<Iterator>::difference_type n){
|
||||
current -= n;
|
||||
return *this;
|
||||
}
|
||||
reverse_iterator operator- (typename iterator_traits<Iterator>::difference_type n) const{
|
||||
reverse_iterator retval( *this );
|
||||
retval-=n;
|
||||
return retval;
|
||||
}
|
||||
reverse_iterator& operator-=(typename iterator_traits<Iterator>::difference_type n){
|
||||
current += n;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <class Iterator> _UCXXEXPORT bool
|
||||
operator==(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
|
||||
{
|
||||
return x.base() == y.base();
|
||||
}
|
||||
template <class Iterator> _UCXXEXPORT bool
|
||||
operator<(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
|
||||
{
|
||||
return x.base() < y.base();
|
||||
}
|
||||
template <class Iterator> _UCXXEXPORT bool
|
||||
operator!=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
|
||||
{
|
||||
return x.base() != y.base();
|
||||
}
|
||||
template <class Iterator> _UCXXEXPORT bool
|
||||
operator>(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
|
||||
{
|
||||
return x.base() > y.base();
|
||||
}
|
||||
template <class Iterator> _UCXXEXPORT bool
|
||||
operator>=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
|
||||
{
|
||||
return x.base() >= y.base();
|
||||
}
|
||||
template <class Iterator> _UCXXEXPORT bool
|
||||
operator<=(const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
|
||||
{
|
||||
return x.base() <= y.base();
|
||||
}
|
||||
template <class Iterator> _UCXXEXPORT typename reverse_iterator<Iterator>::difference_type
|
||||
operator-( const reverse_iterator<Iterator>& x, const reverse_iterator<Iterator>& y)
|
||||
{
|
||||
return y.base() - x.base();
|
||||
}
|
||||
template <class Iterator> _UCXXEXPORT reverse_iterator<Iterator>
|
||||
operator+(typename reverse_iterator<Iterator>::difference_type n, const reverse_iterator<Iterator>& x)
|
||||
{
|
||||
return reverse_iterator<Iterator> (x.base() - n);
|
||||
}
|
||||
|
||||
template <class Container> class _UCXXEXPORT back_insert_iterator :
|
||||
public iterator<output_iterator_tag,void,void,void,void>
|
||||
{
|
||||
protected:
|
||||
Container& container;
|
||||
public:
|
||||
typedef Container container_type;
|
||||
explicit back_insert_iterator(Container& x):container(x) {};
|
||||
back_insert_iterator<Container>& operator=(const typename Container::value_type& value){
|
||||
container.push_back(value);
|
||||
return *this;
|
||||
}
|
||||
back_insert_iterator<Container>& operator*(){
|
||||
return *this;
|
||||
}
|
||||
back_insert_iterator<Container>& operator++(){
|
||||
return *this;
|
||||
}
|
||||
back_insert_iterator<Container> operator++(int){
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
template <class Container> _UCXXEXPORT back_insert_iterator<Container>
|
||||
back_inserter(Container& x)
|
||||
{
|
||||
return back_insert_iterator<Container>(x);
|
||||
}
|
||||
|
||||
template <class Container> class _UCXXEXPORT front_insert_iterator
|
||||
: public iterator<output_iterator_tag,void,void,void,void>
|
||||
{
|
||||
protected:
|
||||
Container& container;
|
||||
public:
|
||||
typedef Container container_type;
|
||||
explicit front_insert_iterator(Container& x): container(x) {}
|
||||
front_insert_iterator<Container>& operator=(const typename Container::value_type& value){
|
||||
container.push_front(value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
front_insert_iterator<Container>& operator*() { return *this; }
|
||||
front_insert_iterator<Container>& operator++() { return *this; }
|
||||
front_insert_iterator<Container> operator++(int) { return *this; }
|
||||
};
|
||||
|
||||
template <class Container> _UCXXEXPORT front_insert_iterator<Container>
|
||||
front_inserter(Container& x)
|
||||
{
|
||||
return front_insert_iterator<Container>(x);
|
||||
}
|
||||
|
||||
template <class Container> class _UCXXEXPORT insert_iterator
|
||||
: public iterator<output_iterator_tag,void,void,void,void>
|
||||
{
|
||||
protected:
|
||||
Container& container;
|
||||
typename Container::iterator iter;
|
||||
public:
|
||||
typedef Container container_type;
|
||||
insert_iterator(Container& x, typename Container::iterator i) : container(x), iter(i) {}
|
||||
insert_iterator<Container>& operator=(const typename Container::value_type& value){
|
||||
iter = container.insert(iter, value);
|
||||
++iter;
|
||||
return *this;
|
||||
}
|
||||
insert_iterator<Container>& operator*() { return *this; }
|
||||
insert_iterator<Container>& operator++() { return *this; }
|
||||
insert_iterator<Container> operator++(int) { return *this; }
|
||||
};
|
||||
|
||||
template <class Container, class Iterator> _UCXXEXPORT insert_iterator<Container>
|
||||
inserter(Container& x, Iterator i)
|
||||
{
|
||||
return insert_iterator<Container>(x,typename Container::iterator(i));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,663 @@
|
|||
/* Copyright (C) 2006 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <climits>
|
||||
|
||||
#ifndef __STD_HEADER_LIMITS
|
||||
#define __STD_HEADER_LIMITS 1
|
||||
|
||||
#warning limits header is nowhere complete or accurate
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
enum float_round_style{
|
||||
round_indeterminate =-1,
|
||||
round_toward_zero = 0,
|
||||
round_to_nearest = 1,
|
||||
round_toward_infinity = 2,
|
||||
round_toward_neg_infinity = 3
|
||||
};
|
||||
|
||||
template <int bitsize> struct __bits_to_base_10{
|
||||
static const int size = -1;
|
||||
};
|
||||
template <> struct __bits_to_base_10<7>{
|
||||
static const int size = 2;
|
||||
};
|
||||
template <> struct __bits_to_base_10<8>{
|
||||
static const int size = 2;
|
||||
};
|
||||
template <> struct __bits_to_base_10<9>{
|
||||
static const int size = 2;
|
||||
};
|
||||
template <> struct __bits_to_base_10<10>{
|
||||
static const int size = 3;
|
||||
};
|
||||
template <> struct __bits_to_base_10<15>{
|
||||
static const int size = 4;
|
||||
};
|
||||
template <> struct __bits_to_base_10<16>{
|
||||
static const int size = 4;
|
||||
};
|
||||
template <> struct __bits_to_base_10<17>{
|
||||
static const int size = 5;
|
||||
};
|
||||
template <> struct __bits_to_base_10<18>{
|
||||
static const int size = 5;
|
||||
};
|
||||
template <> struct __bits_to_base_10<31>{
|
||||
static const int size = 9;
|
||||
};
|
||||
template <> struct __bits_to_base_10<32>{
|
||||
static const int size = 9;
|
||||
};
|
||||
template <> struct __bits_to_base_10<35>{
|
||||
static const int size = 10;
|
||||
};
|
||||
template <> struct __bits_to_base_10<36>{
|
||||
static const int size = 10;
|
||||
};
|
||||
template <> struct __bits_to_base_10<63>{
|
||||
static const int size = 18;
|
||||
};
|
||||
template <> struct __bits_to_base_10<64>{
|
||||
static const int size = 19;
|
||||
};
|
||||
template <> struct __bits_to_base_10<71>{
|
||||
static const int size = 21;
|
||||
};
|
||||
template <> struct __bits_to_base_10<72>{
|
||||
static const int size = 21;
|
||||
};
|
||||
template <> struct __bits_to_base_10<79>{
|
||||
static const int size = 23;
|
||||
};
|
||||
template <> struct __bits_to_base_10<80>{
|
||||
static const int size = 24;
|
||||
};
|
||||
template <> struct __bits_to_base_10<127>{
|
||||
static const int size = 38;
|
||||
};
|
||||
template <> struct __bits_to_base_10<128>{
|
||||
static const int size = 38;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <class T> class numeric_limits {
|
||||
public:
|
||||
// General -- meaningful for all specializations.
|
||||
|
||||
static const bool is_specialized = false;
|
||||
static T min();
|
||||
static T max();
|
||||
static const int radix;
|
||||
static const int digits;
|
||||
static const int digits10;
|
||||
static const bool is_signed;
|
||||
static const bool is_integer;
|
||||
static const bool is_exact;
|
||||
static const bool traps;
|
||||
static const bool is_modulo;
|
||||
static const bool is_bounded;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static T epsilon();
|
||||
static T round_error();
|
||||
static const int min_exponent10;
|
||||
static const int max_exponent10;
|
||||
static const int min_exponent;
|
||||
|
||||
static const int max_exponent;
|
||||
static const bool has_infinity;
|
||||
static const bool has_quiet_NaN;
|
||||
static const bool has_signaling_NaN;
|
||||
static const bool is_iec559;
|
||||
static const bool has_denorm;
|
||||
static const bool tinyness_before;
|
||||
static const float_round_style round_style;
|
||||
static T denorm_min();
|
||||
static T infinity();
|
||||
static T quiet_NaN();
|
||||
static T signaling_NaN();
|
||||
};
|
||||
|
||||
template <> class numeric_limits<bool> {
|
||||
public:
|
||||
typedef bool T;
|
||||
// General -- meaningful for all specializations.
|
||||
static const bool is_specialized = true;
|
||||
static T min(){
|
||||
return false;
|
||||
}
|
||||
static T max(){
|
||||
return true;
|
||||
}
|
||||
static const int radix = 2;
|
||||
static const int digits = 1;
|
||||
static const int digits10 = 0;
|
||||
static const bool is_signed = false;
|
||||
static const bool is_integer = true;
|
||||
static const bool is_exact = true;
|
||||
static const bool traps = false;
|
||||
static const bool is_modulo = false;
|
||||
static const bool is_bounded = true;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static T epsilon(){
|
||||
return 0;
|
||||
}
|
||||
static T round_error(){
|
||||
return 0;
|
||||
}
|
||||
static const int min_exponent10 = 0;
|
||||
static const int max_exponent10 = 0;
|
||||
static const int min_exponent = 0;
|
||||
|
||||
static const int max_exponent = 0;
|
||||
static const bool has_infinity = false;
|
||||
static const bool has_quiet_NaN = false;
|
||||
static const bool has_signaling_NaN = false;
|
||||
static const bool is_iec559 = false;
|
||||
static const bool has_denorm = false;
|
||||
static const bool tinyness_before = false;
|
||||
static const float_round_style round_style = round_indeterminate;
|
||||
static T denorm_min();
|
||||
static T infinity();
|
||||
static T quiet_NaN();
|
||||
static T signaling_NaN();
|
||||
};
|
||||
|
||||
template <> class numeric_limits<unsigned char> {
|
||||
public:
|
||||
typedef unsigned char T;
|
||||
// General -- meaningful for all specializations.
|
||||
static const bool is_specialized = true;
|
||||
static T min(){
|
||||
return 0;
|
||||
}
|
||||
static T max(){
|
||||
return UCHAR_MAX;
|
||||
}
|
||||
static const int radix = 2;
|
||||
static const int digits = CHAR_BIT;
|
||||
static const int digits10 = __bits_to_base_10<digits>::size;
|
||||
static const bool is_signed = false;
|
||||
static const bool is_integer = true;
|
||||
static const bool is_exact = true;
|
||||
static const bool traps = false;
|
||||
static const bool is_modulo = true;
|
||||
static const bool is_bounded = true;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static T epsilon(){
|
||||
return 0;
|
||||
}
|
||||
static T round_error(){
|
||||
return 0;
|
||||
}
|
||||
static const int min_exponent10 = 0;
|
||||
static const int max_exponent10 = 0;
|
||||
static const int min_exponent = 0;
|
||||
|
||||
static const int max_exponent = 0;
|
||||
static const bool has_infinity = false;
|
||||
static const bool has_quiet_NaN = false;
|
||||
static const bool has_signaling_NaN = false;
|
||||
static const bool is_iec559 = false;
|
||||
static const bool has_denorm = false;
|
||||
static const bool tinyness_before = false;
|
||||
static const float_round_style round_style = round_indeterminate;
|
||||
static T denorm_min();
|
||||
static T infinity();
|
||||
static T quiet_NaN();
|
||||
static T signaling_NaN();
|
||||
};
|
||||
|
||||
template <> class numeric_limits<signed char> {
|
||||
public:
|
||||
typedef signed char T;
|
||||
// General -- meaningful for all specializations.
|
||||
static const bool is_specialized = true;
|
||||
static T min(){
|
||||
return SCHAR_MIN;
|
||||
}
|
||||
static T max(){
|
||||
return SCHAR_MAX;
|
||||
}
|
||||
static const int radix = 2;
|
||||
static const int digits = CHAR_BIT - 1;
|
||||
static const int digits10 = __bits_to_base_10<digits>::size;
|
||||
static const bool is_signed = true;
|
||||
static const bool is_integer = true;
|
||||
static const bool is_exact = true;
|
||||
static const bool traps = false;
|
||||
static const bool is_modulo = true;
|
||||
static const bool is_bounded = true;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static T epsilon(){
|
||||
return 0;
|
||||
}
|
||||
static T round_error(){
|
||||
return 0;
|
||||
}
|
||||
static const int min_exponent10 = 0;
|
||||
static const int max_exponent10 = 0;
|
||||
static const int min_exponent = 0;
|
||||
|
||||
static const int max_exponent = 0;
|
||||
static const bool has_infinity = false;
|
||||
static const bool has_quiet_NaN = false;
|
||||
static const bool has_signaling_NaN = false;
|
||||
static const bool is_iec559 = false;
|
||||
static const bool has_denorm = false;
|
||||
static const bool tinyness_before = false;
|
||||
static const float_round_style round_style = round_indeterminate;
|
||||
static T denorm_min();
|
||||
static T infinity();
|
||||
static T quiet_NaN();
|
||||
static T signaling_NaN();
|
||||
};
|
||||
|
||||
template <> class numeric_limits<char> {
|
||||
public:
|
||||
typedef char T;
|
||||
// General -- meaningful for all specializations.
|
||||
static const bool is_specialized = true;
|
||||
static T min(){
|
||||
return CHAR_MIN;
|
||||
}
|
||||
static T max(){
|
||||
return CHAR_MAX;
|
||||
}
|
||||
static const int radix = 2;
|
||||
static const int digits = (CHAR_MIN != 0) ? CHAR_BIT - 1 : CHAR_BIT;
|
||||
static const int digits10 = __bits_to_base_10<digits>::size;
|
||||
static const bool is_signed = (CHAR_MIN != 0);
|
||||
static const bool is_integer = true;
|
||||
static const bool is_exact = true;
|
||||
static const bool traps = false;
|
||||
static const bool is_modulo = true;
|
||||
static const bool is_bounded = true;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static T epsilon(){
|
||||
return 0;
|
||||
}
|
||||
static T round_error(){
|
||||
return 0;
|
||||
}
|
||||
static const int min_exponent10 = 0;
|
||||
static const int max_exponent10 = 0;
|
||||
static const int min_exponent = 0;
|
||||
|
||||
static const int max_exponent = 0;
|
||||
static const bool has_infinity = false;
|
||||
static const bool has_quiet_NaN = false;
|
||||
static const bool has_signaling_NaN = false;
|
||||
static const bool is_iec559 = false;
|
||||
static const bool has_denorm = false;
|
||||
static const bool tinyness_before = false;
|
||||
static const float_round_style round_style = round_indeterminate;
|
||||
static T denorm_min();
|
||||
static T infinity();
|
||||
static T quiet_NaN();
|
||||
static T signaling_NaN();
|
||||
};
|
||||
|
||||
template <> class numeric_limits<unsigned short> {
|
||||
public:
|
||||
typedef unsigned short T;
|
||||
// General -- meaningful for all specializations.
|
||||
static const bool is_specialized = true;
|
||||
static T min(){
|
||||
return 0;
|
||||
}
|
||||
static T max(){
|
||||
return USHRT_MAX;
|
||||
}
|
||||
static const int radix = 2;
|
||||
static const int digits = CHAR_BIT * sizeof(T);
|
||||
static const int digits10 = __bits_to_base_10<digits>::size;
|
||||
static const bool is_signed = false;
|
||||
static const bool is_integer = true;
|
||||
static const bool is_exact = true;
|
||||
static const bool traps = false;
|
||||
static const bool is_modulo = true;
|
||||
static const bool is_bounded = true;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static T epsilon(){
|
||||
return 0;
|
||||
}
|
||||
static T round_error(){
|
||||
return 0;
|
||||
}
|
||||
static const int min_exponent10 = 0;
|
||||
static const int max_exponent10 = 0;
|
||||
static const int min_exponent = 0;
|
||||
|
||||
static const int max_exponent = 0;
|
||||
static const bool has_infinity = false;
|
||||
static const bool has_quiet_NaN = false;
|
||||
static const bool has_signaling_NaN = false;
|
||||
static const bool is_iec559 = false;
|
||||
static const bool has_denorm = false;
|
||||
static const bool tinyness_before = false;
|
||||
static const float_round_style round_style = round_indeterminate;
|
||||
static T denorm_min();
|
||||
static T infinity();
|
||||
static T quiet_NaN();
|
||||
static T signaling_NaN();
|
||||
};
|
||||
|
||||
template <> class numeric_limits<signed short> {
|
||||
public:
|
||||
typedef signed short T;
|
||||
// General -- meaningful for all specializations.
|
||||
static const bool is_specialized = true;
|
||||
static T min(){
|
||||
return SHRT_MIN;
|
||||
}
|
||||
static T max(){
|
||||
return SHRT_MAX;
|
||||
}
|
||||
static const int radix = 2;
|
||||
static const int digits = CHAR_BIT * sizeof(T);
|
||||
static const int digits10 = __bits_to_base_10<digits>::size;
|
||||
static const bool is_signed = true;
|
||||
static const bool is_integer = true;
|
||||
static const bool is_exact = true;
|
||||
static const bool traps = false;
|
||||
static const bool is_modulo = true;
|
||||
static const bool is_bounded = true;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static T epsilon(){
|
||||
return 0;
|
||||
}
|
||||
static T round_error(){
|
||||
return 0;
|
||||
}
|
||||
static const int min_exponent10 = 0;
|
||||
static const int max_exponent10 = 0;
|
||||
static const int min_exponent = 0;
|
||||
|
||||
static const int max_exponent = 0;
|
||||
static const bool has_infinity = false;
|
||||
static const bool has_quiet_NaN = false;
|
||||
static const bool has_signaling_NaN = false;
|
||||
static const bool is_iec559 = false;
|
||||
static const bool has_denorm = false;
|
||||
static const bool tinyness_before = false;
|
||||
static const float_round_style round_style = round_indeterminate;
|
||||
static T denorm_min();
|
||||
static T infinity();
|
||||
static T quiet_NaN();
|
||||
static T signaling_NaN();
|
||||
};
|
||||
|
||||
template <> class numeric_limits<unsigned int> {
|
||||
public:
|
||||
typedef unsigned int T;
|
||||
// General -- meaningful for all specializations.
|
||||
static const bool is_specialized = true;
|
||||
static T min(){
|
||||
return 0;
|
||||
}
|
||||
static T max(){
|
||||
return UINT_MAX;
|
||||
}
|
||||
static const int radix = 2;
|
||||
static const int digits = CHAR_BIT * sizeof(T);
|
||||
static const int digits10 = __bits_to_base_10<digits>::size;
|
||||
static const bool is_signed = false;
|
||||
static const bool is_integer = true;
|
||||
static const bool is_exact = true;
|
||||
static const bool traps = false;
|
||||
static const bool is_modulo = true;
|
||||
static const bool is_bounded = true;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static T epsilon(){
|
||||
return 0;
|
||||
}
|
||||
static T round_error(){
|
||||
return 0;
|
||||
}
|
||||
static const int min_exponent10 = 0;
|
||||
static const int max_exponent10 = 0;
|
||||
static const int min_exponent = 0;
|
||||
|
||||
static const int max_exponent = 0;
|
||||
static const bool has_infinity = false;
|
||||
static const bool has_quiet_NaN = false;
|
||||
static const bool has_signaling_NaN = false;
|
||||
static const bool is_iec559 = false;
|
||||
static const bool has_denorm = false;
|
||||
static const bool tinyness_before = false;
|
||||
static const float_round_style round_style = round_indeterminate;
|
||||
static T denorm_min();
|
||||
static T infinity();
|
||||
static T quiet_NaN();
|
||||
static T signaling_NaN();
|
||||
};
|
||||
|
||||
template <> class numeric_limits<signed int> {
|
||||
public:
|
||||
typedef signed int T;
|
||||
// General -- meaningful for all specializations.
|
||||
static const bool is_specialized = true;
|
||||
static T min(){
|
||||
return INT_MIN;
|
||||
}
|
||||
static T max(){
|
||||
return INT_MAX;
|
||||
}
|
||||
static const int radix = 2;
|
||||
static const int digits = CHAR_BIT * sizeof(T);
|
||||
static const int digits10 = __bits_to_base_10<digits>::size;
|
||||
static const bool is_signed = true;
|
||||
static const bool is_integer = true;
|
||||
static const bool is_exact = true;
|
||||
static const bool traps = false;
|
||||
static const bool is_modulo = true;
|
||||
static const bool is_bounded = true;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static T epsilon(){
|
||||
return 0;
|
||||
}
|
||||
static T round_error(){
|
||||
return 0;
|
||||
}
|
||||
static const int min_exponent10 = 0;
|
||||
static const int max_exponent10 = 0;
|
||||
static const int min_exponent = 0;
|
||||
|
||||
static const int max_exponent = 0;
|
||||
static const bool has_infinity = false;
|
||||
static const bool has_quiet_NaN = false;
|
||||
static const bool has_signaling_NaN = false;
|
||||
static const bool is_iec559 = false;
|
||||
static const bool has_denorm = false;
|
||||
static const bool tinyness_before = false;
|
||||
static const float_round_style round_style = round_indeterminate;
|
||||
static T denorm_min();
|
||||
static T infinity();
|
||||
static T quiet_NaN();
|
||||
static T signaling_NaN();
|
||||
};
|
||||
|
||||
template <> class numeric_limits<unsigned long int> {
|
||||
public:
|
||||
typedef unsigned long int T;
|
||||
// General -- meaningful for all specializations.
|
||||
static const bool is_specialized = true;
|
||||
static T min(){
|
||||
return 0;
|
||||
}
|
||||
static T max(){
|
||||
return ULONG_MAX;
|
||||
}
|
||||
static const int radix = 2;
|
||||
static const int digits = CHAR_BIT * sizeof(T);
|
||||
static const int digits10 = __bits_to_base_10<digits>::size;
|
||||
static const bool is_signed = false;
|
||||
static const bool is_integer = true;
|
||||
static const bool is_exact = true;
|
||||
static const bool traps = false;
|
||||
static const bool is_modulo = true;
|
||||
static const bool is_bounded = true;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static T epsilon(){
|
||||
return 0;
|
||||
}
|
||||
static T round_error(){
|
||||
return 0;
|
||||
}
|
||||
static const int min_exponent10 = 0;
|
||||
static const int max_exponent10 = 0;
|
||||
static const int min_exponent = 0;
|
||||
|
||||
static const int max_exponent = 0;
|
||||
static const bool has_infinity = false;
|
||||
static const bool has_quiet_NaN = false;
|
||||
static const bool has_signaling_NaN = false;
|
||||
static const bool is_iec559 = false;
|
||||
static const bool has_denorm = false;
|
||||
static const bool tinyness_before = false;
|
||||
static const float_round_style round_style = round_indeterminate;
|
||||
static T denorm_min();
|
||||
static T infinity();
|
||||
static T quiet_NaN();
|
||||
static T signaling_NaN();
|
||||
};
|
||||
|
||||
template <> class numeric_limits<signed long int> {
|
||||
public:
|
||||
typedef signed long int T;
|
||||
// General -- meaningful for all specializations.
|
||||
static const bool is_specialized = true;
|
||||
static T min(){
|
||||
return LONG_MIN;
|
||||
}
|
||||
static T max(){
|
||||
return LONG_MAX;
|
||||
}
|
||||
static const int radix = 2;
|
||||
static const int digits = CHAR_BIT * sizeof(T);
|
||||
static const int digits10 = __bits_to_base_10<digits>::size;
|
||||
static const bool is_signed = true;
|
||||
static const bool is_integer = true;
|
||||
static const bool is_exact = true;
|
||||
static const bool traps = false;
|
||||
static const bool is_modulo = true;
|
||||
static const bool is_bounded = true;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static T epsilon(){
|
||||
return 0;
|
||||
}
|
||||
static T round_error(){
|
||||
return 0;
|
||||
}
|
||||
static const int min_exponent10 = 0;
|
||||
static const int max_exponent10 = 0;
|
||||
static const int min_exponent = 0;
|
||||
|
||||
static const int max_exponent = 0;
|
||||
static const bool has_infinity = false;
|
||||
static const bool has_quiet_NaN = false;
|
||||
static const bool has_signaling_NaN = false;
|
||||
static const bool is_iec559 = false;
|
||||
static const bool has_denorm = false;
|
||||
static const bool tinyness_before = false;
|
||||
static const float_round_style round_style = round_indeterminate;
|
||||
static T denorm_min();
|
||||
static T infinity();
|
||||
static T quiet_NaN();
|
||||
static T signaling_NaN();
|
||||
};
|
||||
|
||||
template <> class numeric_limits<double> {
|
||||
public:
|
||||
typedef double numeric_type;
|
||||
|
||||
static const bool is_specialized = true;
|
||||
static numeric_type min () { return __DBL_MIN__; }
|
||||
static numeric_type max () { return __DBL_MAX__; }
|
||||
static const int radix = __FLT_RADIX__;
|
||||
static const int digits = __DBL_MANT_DIG__;
|
||||
static const int digits10 = __DBL_DIG__;
|
||||
static const bool is_signed = true;
|
||||
static const bool is_integer = false;
|
||||
static const bool is_exact = false;
|
||||
static const bool traps = false; // this is a guess
|
||||
static const bool is_modulo = false;
|
||||
static const bool is_bounded = true;
|
||||
|
||||
// Floating point specific.
|
||||
|
||||
static numeric_type epsilon () { return __DBL_EPSILON__; }
|
||||
static numeric_type round_error () { return 0.5; }
|
||||
static const int min_exponent10 = -1; //How do I properly get this?
|
||||
static const int max_exponent10 = -1; //How do I properly get this?
|
||||
static const int min_exponent = -1; //How do I properly get this?
|
||||
static const int max_exponent = -1; //How do I properly get this?
|
||||
static const bool has_infinity = false; //I don't know, so until I can find out, I'm saying no
|
||||
static const bool has_quiet_NaN = false; //I don't know, so until I can find out, I'm saying no
|
||||
static const bool has_signaling_NaN = false; //I don't know, so until I can find out, I'm saying no
|
||||
static const bool has_denorm = false; //I don't know, so until I can find out, I'm saying no
|
||||
|
||||
static const bool is_iec559 = false; //I don't know, so until I can find out, I'm saying no
|
||||
static const bool tinyness_before = false; // more questions
|
||||
static const float_round_style round_style = round_to_nearest; // more questions
|
||||
static numeric_type denorm_min () { return -1; } //How do I properly get this?
|
||||
static numeric_type infinity () { return -1; } //How do I properly get this?
|
||||
static numeric_type quiet_NaN () { return -1; } //How do I properly get this?
|
||||
static numeric_type signaling_NaN () { return -1; } //How do I properly get this?
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,926 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <memory>
|
||||
#include <iterator>
|
||||
#include <algorithm>
|
||||
|
||||
#ifndef __STD_HEADER_LIST
|
||||
#define __STD_HEADER_LIST 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
template <class T, class Allocator = allocator<T> > class _UCXXEXPORT list {
|
||||
public:
|
||||
typedef typename Allocator::reference reference;
|
||||
typedef typename Allocator::const_reference const_reference;
|
||||
typedef typename Allocator::size_type size_type;
|
||||
typedef typename Allocator::difference_type difference_type;
|
||||
typedef T value_type;
|
||||
typedef Allocator allocator_type;
|
||||
typedef typename Allocator::pointer pointer;
|
||||
typedef typename Allocator::const_pointer const_pointer;
|
||||
|
||||
protected:
|
||||
class node;
|
||||
class iter_list;
|
||||
|
||||
node * list_start;
|
||||
node * list_end;
|
||||
size_type elements;
|
||||
Allocator a;
|
||||
|
||||
public:
|
||||
|
||||
typedef iter_list iterator;
|
||||
typedef iter_list const_iterator;
|
||||
typedef std::reverse_iterator<iterator> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
|
||||
explicit list(const Allocator& = Allocator());
|
||||
explicit list(size_type n, const T& value = T(), const Allocator& = Allocator());
|
||||
template <class InputIterator> list(InputIterator first, InputIterator last,
|
||||
const Allocator& al= Allocator());
|
||||
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;
|
||||
}
|
||||
|
||||
template <class InputIterator> void assign(InputIterator first, InputIterator last);
|
||||
template <class Size, class U> void assign(Size n, const U& u = U());
|
||||
allocator_type get_allocator() const;
|
||||
|
||||
iterator begin();
|
||||
const_iterator begin() const;
|
||||
iterator end();
|
||||
const_iterator end() const;
|
||||
reverse_iterator rbegin();
|
||||
const_reverse_iterator rbegin() const;
|
||||
reverse_iterator rend();
|
||||
const_reverse_iterator rend() const;
|
||||
|
||||
bool empty() const;
|
||||
size_type size() const;
|
||||
size_type max_size() const;
|
||||
void resize(size_type sz, T c = T());
|
||||
|
||||
reference front();
|
||||
const_reference front() const;
|
||||
reference back();
|
||||
const_reference back() const;
|
||||
|
||||
void push_front(const T& x);
|
||||
void pop_front();
|
||||
void push_back(const T& x);
|
||||
void pop_back();
|
||||
iterator insert(iterator position, const T& x = T());
|
||||
void insert(iterator position, size_type n, const T& x);
|
||||
template <class InputIterator> void insert(iterator position, InputIterator first, InputIterator last);
|
||||
iterator erase(iterator position);
|
||||
iterator erase(iterator position, iterator last);
|
||||
void swap(list<T,Allocator>&);
|
||||
void clear();
|
||||
|
||||
void splice(iterator position, list<T,Allocator>& x);
|
||||
void splice(iterator position, list<T,Allocator>& x, iterator i);
|
||||
void splice(iterator position, list<T,Allocator>& x, iterator first, iterator last);
|
||||
void remove(const T& value);
|
||||
template <class Predicate> void remove_if(Predicate pred);
|
||||
void unique();
|
||||
template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);
|
||||
void merge(list<T,Allocator>& x);
|
||||
template <class Compare> void merge(list<T,Allocator>& x, Compare comp);
|
||||
void sort();
|
||||
template <class Compare> void sort(Compare comp);
|
||||
void reverse();
|
||||
protected:
|
||||
void swap_nodes(node * x, node * y);
|
||||
};
|
||||
|
||||
|
||||
//Implementations of List
|
||||
|
||||
//List node
|
||||
template <class T, class Allocator> class _UCXXEXPORT list<T, Allocator>::node{
|
||||
public:
|
||||
node * previous;
|
||||
node * next;
|
||||
T * val;
|
||||
|
||||
node(): previous(0), next(0), val(0){ }
|
||||
node(const T & t ): previous(0), next(0), val(0) {
|
||||
val = new T(t);
|
||||
//FIXME use allocator somehow but only call constructor once
|
||||
}
|
||||
node(const T & t, node * p, node * n): previous(p), next(n), val(0) {
|
||||
val = new T(t);
|
||||
}
|
||||
~node(){ }
|
||||
};
|
||||
|
||||
//List iterator
|
||||
template <class T, class Allocator> class _UCXXEXPORT list<T, Allocator>::iter_list
|
||||
: public std::iterator<
|
||||
bidirectional_iterator_tag,
|
||||
T,
|
||||
typename Allocator::difference_type,
|
||||
typename Allocator::pointer,
|
||||
typename Allocator::reference
|
||||
>
|
||||
{
|
||||
private:
|
||||
node * current;
|
||||
public:
|
||||
iter_list():current(0) { }
|
||||
iter_list( typename list<T, Allocator>::node * n): current(n) { }
|
||||
iter_list(const list<T, Allocator>::iter_list & l): current(l.current) { }
|
||||
~iter_list(){ }
|
||||
|
||||
iter_list & operator=(const list<T, Allocator>::iter_list & right ){
|
||||
current = right.current;
|
||||
return *this;
|
||||
}
|
||||
|
||||
T & operator*(){
|
||||
return *(current->val);
|
||||
}
|
||||
T * operator->(){
|
||||
return current->val;
|
||||
}
|
||||
const T & operator*() const{
|
||||
return *current->val;
|
||||
}
|
||||
const T * operator->() const{
|
||||
return current->val;
|
||||
}
|
||||
|
||||
bool operator==(const list<T, Allocator>::iter_list & right) const {
|
||||
return (current == right.current);
|
||||
}
|
||||
|
||||
bool operator!=(const list<T, Allocator>::iter_list & right) const {
|
||||
return (current != right.current);
|
||||
}
|
||||
|
||||
iter_list & operator++(){
|
||||
current = current->next;
|
||||
return *this;
|
||||
}
|
||||
|
||||
iter_list operator++(int){
|
||||
iter_list temp(current);
|
||||
current = current->next;
|
||||
return temp;
|
||||
}
|
||||
iter_list & operator--(){
|
||||
current = current->previous;
|
||||
return *this;
|
||||
}
|
||||
|
||||
iter_list operator--(int){
|
||||
iter_list temp(current);
|
||||
current = current->previous;
|
||||
return temp;
|
||||
}
|
||||
node * link_struct(){
|
||||
return current;
|
||||
}
|
||||
iter_list & operator+=(unsigned int n){
|
||||
for(unsigned int i = 0; i < n; ++i){
|
||||
current = current->next;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
iter_list & operator-=(unsigned int n){
|
||||
for(unsigned int i = 0; i < n; ++i){
|
||||
current = current->previous;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<class T, class Allocator> list<T, Allocator>::list(const Allocator& al)
|
||||
:list_start(0), list_end(0), elements(0), a(al)
|
||||
{
|
||||
//End node
|
||||
list_start = new node();
|
||||
list_end = list_start;
|
||||
return;
|
||||
}
|
||||
|
||||
template<class T, class Allocator> list<T, Allocator>::list
|
||||
(typename Allocator::size_type n, const T& value, const Allocator& al)
|
||||
:list_start(0), list_end(0), elements(0), a(al)
|
||||
{
|
||||
//End node
|
||||
list_start = new node();
|
||||
list_end = list_start;
|
||||
|
||||
for(typename Allocator::size_type i = 0; i < n ; ++i){
|
||||
push_back(value);
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> template <class InputIterator>
|
||||
list<T, Allocator>::list
|
||||
(InputIterator first, InputIterator last, const Allocator& al)
|
||||
: list_start(0), list_end(0), elements(0), a(al)
|
||||
{
|
||||
list_start = new node();
|
||||
list_end = list_start;
|
||||
while(first != last){
|
||||
push_back(*first);
|
||||
++first;
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> list<T, Allocator>::list(const list<T,Allocator>& x)
|
||||
: list_start(0), list_end(0), elements(0), a(x.a)
|
||||
{
|
||||
list_start = new node();
|
||||
list_end = list_start;
|
||||
|
||||
iterator i = x.begin();
|
||||
while(i != x.end()){
|
||||
push_back( *i);
|
||||
++i;
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> list<T, Allocator>::~list(){
|
||||
while(elements > 0){
|
||||
pop_front();
|
||||
}
|
||||
delete list_start->val;
|
||||
#if UCLIBCXX_DEBUG
|
||||
list_start->val = 0;
|
||||
#endif
|
||||
delete list_start;
|
||||
#if UCLIBCXX_DEBUG
|
||||
list_start = 0;
|
||||
list_end = 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> void list<T, Allocator>::swap_nodes(node * x, node * y){
|
||||
T * v = x->val;
|
||||
x->val = y->val;
|
||||
y->val = v;
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename list<T, Allocator>::iterator
|
||||
list<T, Allocator>::begin()
|
||||
{
|
||||
return iterator(list_start);
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> typename list<T, Allocator>::const_iterator
|
||||
list<T, Allocator>::begin() const
|
||||
{
|
||||
return const_iterator(list_start);
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> typename list<T, Allocator>::iterator
|
||||
list<T, Allocator>::end()
|
||||
{
|
||||
return iterator(list_end);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename list<T, Allocator>::const_iterator
|
||||
list<T, Allocator>::end() const
|
||||
{
|
||||
return const_iterator(list_end);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename list<T, Allocator>::reverse_iterator
|
||||
list<T, Allocator>::rbegin()
|
||||
{
|
||||
return reverse_iterator(end());
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename list<T, Allocator>::const_reverse_iterator
|
||||
list<T, Allocator>::rbegin() const
|
||||
{
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename list<T, Allocator>::reverse_iterator
|
||||
list<T, Allocator>::rend()
|
||||
{
|
||||
return reverse_iterator(begin());
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename list<T, Allocator>::const_reverse_iterator
|
||||
list<T, Allocator>::rend() const
|
||||
{
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
|
||||
template<class T, class Allocator> bool list<T, Allocator>::empty() const{
|
||||
return (elements == 0);
|
||||
}
|
||||
template<class T, class Allocator> typename list<T, Allocator>::size_type list<T, Allocator>::size() const{
|
||||
return elements;
|
||||
}
|
||||
template<class T, class Allocator> typename list<T, Allocator>::size_type list<T, Allocator>::max_size() const{
|
||||
return ((size_type)(-1)) / (sizeof(T) + sizeof(node));
|
||||
}
|
||||
template<class T, class Allocator> void list<T, Allocator>::resize(typename Allocator::size_type sz, T c){
|
||||
// if(sz > elements){
|
||||
for(typename Allocator::size_type i = elements; i < sz; ++i){
|
||||
push_back(c);
|
||||
}
|
||||
// }
|
||||
// if(sz < elements){
|
||||
for(typename Allocator::size_type i = elements; i > sz; --i){
|
||||
pop_back();
|
||||
}
|
||||
// }
|
||||
}
|
||||
|
||||
template<class T, class Allocator> typename list<T, Allocator>::reference list<T, Allocator>::front(){
|
||||
return *(list_start->val);
|
||||
}
|
||||
template<class T, class Allocator> typename list<T, Allocator>::const_reference list<T, Allocator>::front() const{
|
||||
return *(list_start->val);
|
||||
}
|
||||
template<class T, class Allocator> typename list<T, Allocator>::reference list<T, Allocator>::back(){
|
||||
return *(list_end->previous->val);
|
||||
}
|
||||
template<class T, class Allocator> typename list<T, Allocator>::const_reference list<T, Allocator>::back() const{
|
||||
return *(list_end->previous->val);
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> void list<T, Allocator>::push_front(const T& x){
|
||||
node * temp = new node(x);
|
||||
list_start->previous = temp;
|
||||
temp->previous = 0;
|
||||
temp->next = list_start;
|
||||
list_start = temp;
|
||||
++elements;
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void list<T, Allocator>::pop_front(){
|
||||
if(elements > 0){
|
||||
list_start = list_start->next;
|
||||
delete list_start->previous->val;
|
||||
#if UCLIBCXX_DEBUG
|
||||
list_start->previous->val = 0;
|
||||
list_start->previous->next = 0;
|
||||
list_start->previous->previous = 0;
|
||||
#endif
|
||||
delete list_start->previous;
|
||||
list_start->previous = 0;
|
||||
--elements;
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void list<T, Allocator>::push_back(const T& x){
|
||||
if(elements == 0){
|
||||
//The list is completely empty
|
||||
list_start = new node(x);
|
||||
list_end->previous = list_start;
|
||||
list_start->previous = 0;
|
||||
list_start->next = list_end;
|
||||
elements = 1;
|
||||
}else{
|
||||
node * temp = new node(x);
|
||||
temp->previous = list_end->previous;
|
||||
temp->next = list_end;
|
||||
list_end->previous->next = temp;
|
||||
list_end->previous = temp;
|
||||
++elements;
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void list<T, Allocator>::pop_back(){
|
||||
if(elements > 0){
|
||||
node * temp = list_end->previous;
|
||||
if(temp == list_start){
|
||||
list_end->previous = 0;
|
||||
list_start = list_end;
|
||||
}else{
|
||||
temp->previous->next = temp->next;
|
||||
list_end->previous = temp->previous;
|
||||
}
|
||||
delete temp->val;
|
||||
#if UCLIBCXX_DEBUG
|
||||
temp->val = 0;
|
||||
temp->next = 0;
|
||||
temp->previous = 0;
|
||||
#endif
|
||||
delete temp;
|
||||
#if UCLIBCXX_DEBUG
|
||||
temp = 0;
|
||||
#endif
|
||||
--elements;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> typename list<T, Allocator>::iterator
|
||||
list<T, Allocator>::insert(iterator position, const T& x)
|
||||
{
|
||||
node * temp = new node(x);
|
||||
|
||||
temp->previous = position.link_struct()->previous;
|
||||
temp->next = position.link_struct();
|
||||
|
||||
if(temp->previous == 0){
|
||||
list_start = temp;
|
||||
}else{
|
||||
position.link_struct()->previous->next = temp;
|
||||
}
|
||||
|
||||
position.link_struct()->previous = temp;
|
||||
|
||||
++elements;
|
||||
--position;
|
||||
return position;
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void list<T, Allocator>::insert(iterator position, size_type n, const T& x){
|
||||
for(typename list<T, Allocator>::size_type i = 0; i < n; ++i){
|
||||
position = insert(position, x);
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> template <class InputIterator> void
|
||||
list<T, Allocator>::insert(iterator position, InputIterator first, InputIterator last)
|
||||
{
|
||||
while(first !=last){
|
||||
insert(position, *first);
|
||||
++first;
|
||||
}
|
||||
}
|
||||
template<class T, class Allocator> typename list<T, Allocator>::iterator
|
||||
list<T, Allocator>::erase(iterator position)
|
||||
{
|
||||
if(position != end() ){
|
||||
node * temp = position.link_struct();
|
||||
if(temp == list_start){
|
||||
++position;
|
||||
temp->next->previous = 0;
|
||||
list_start = temp->next;
|
||||
}else{
|
||||
--position;
|
||||
temp->next->previous = temp->previous;
|
||||
temp->previous->next = temp->next;
|
||||
++position;
|
||||
}
|
||||
delete temp->val;
|
||||
#if UCLIBCXX_DEBUG
|
||||
temp->next = 0;
|
||||
temp->previous = 0;
|
||||
temp->val = 0;
|
||||
#endif
|
||||
delete temp;
|
||||
#if UCLIBCXX_DEBUG
|
||||
temp = 0;
|
||||
#endif
|
||||
--elements;
|
||||
}
|
||||
return position;
|
||||
}
|
||||
template<class T, class Allocator> typename list<T, Allocator>::iterator
|
||||
list<T, Allocator>::erase(iterator position, iterator last)
|
||||
{
|
||||
iterator temp = position;
|
||||
while(position !=last){
|
||||
position = erase(position);
|
||||
}
|
||||
return position;
|
||||
}
|
||||
template<class T, class Allocator> void list<T, Allocator>::swap(list<T,Allocator>& l){
|
||||
node * temp;
|
||||
size_type tempel;
|
||||
|
||||
temp = list_start;
|
||||
list_start = l.list_start;
|
||||
l.list_start = temp;
|
||||
|
||||
temp = list_end;
|
||||
list_end = l.list_end;
|
||||
l.list_end = temp;
|
||||
|
||||
tempel = elements;
|
||||
elements = l.elements;
|
||||
l.elements = tempel;
|
||||
}
|
||||
template<class T, class Allocator> void list<T, Allocator>::clear(){
|
||||
while(elements > 0){
|
||||
pop_front();
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator>
|
||||
void list<T, Allocator>::splice(iterator position, list<T,Allocator>& x)
|
||||
{
|
||||
|
||||
//Can't add non-existant elements
|
||||
if(x.elements == 0){
|
||||
return;
|
||||
}
|
||||
|
||||
elements += x.elements;
|
||||
x.elements = 0;
|
||||
|
||||
|
||||
//Chaining to the begining
|
||||
if(position == begin()){
|
||||
x.list_end->previous->next = list_start;
|
||||
list_start->previous = x.list_end->previous;
|
||||
|
||||
list_start = x.list_start;
|
||||
|
||||
x.list_start = x.list_end;
|
||||
x.list_end->previous = 0;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
//Link everything we need
|
||||
x.list_start->previous = position.link_struct()->previous;
|
||||
position.link_struct()->previous->next = x.list_start;
|
||||
|
||||
position.link_struct()->previous = x.list_end->previous;
|
||||
x.list_end->previous->next = position.link_struct();
|
||||
|
||||
//Clean up the other list
|
||||
|
||||
x.list_start = x.list_end;
|
||||
x.list_end->previous=0;
|
||||
|
||||
}
|
||||
|
||||
template<class T, class Allocator>
|
||||
void list<T, Allocator>::splice(iterator position, list<T,Allocator>& x, iterator i)
|
||||
{
|
||||
//Invalid conditions
|
||||
if( x.elements == 0 || i == position || position.link_struct() == i.link_struct()->next ){
|
||||
return;
|
||||
}
|
||||
|
||||
//Do we need to adjust the begining pointer?
|
||||
if(i == x.begin()){
|
||||
x.list_start = x.list_start->next;
|
||||
x.list_start->previous = 0;
|
||||
}
|
||||
|
||||
|
||||
//Insert at begining special case
|
||||
if(position == begin()){
|
||||
|
||||
i.link_struct()->previous->next = i.link_struct()->next;
|
||||
i.link_struct()->next->previous = i.link_struct()->previous;
|
||||
|
||||
i.link_struct()->previous = 0;
|
||||
i.link_struct()->next = position.link_struct();
|
||||
position.link_struct()->previous = i.link_struct();
|
||||
|
||||
list_start = i.link_struct();
|
||||
|
||||
--x.elements;
|
||||
++elements;
|
||||
return;
|
||||
}
|
||||
|
||||
if( i.link_struct()->previous != 0){
|
||||
i.link_struct()->previous->next = i.link_struct()->next;
|
||||
i.link_struct()->next->previous = i.link_struct()->previous;
|
||||
}else{
|
||||
i.link_struct()->next->previous = 0;
|
||||
x.list_start = i.link_struct()->next;
|
||||
}
|
||||
|
||||
i.link_struct()->previous = position.link_struct()->previous;
|
||||
position.link_struct()->previous->next = i.link_struct();
|
||||
|
||||
i.link_struct()->next = position.link_struct();
|
||||
position.link_struct()->previous = i.link_struct();
|
||||
|
||||
--x.elements;
|
||||
++elements;
|
||||
}
|
||||
|
||||
template<class T, class Allocator>
|
||||
void list<T, Allocator>::splice(iterator position, list<T,Allocator>& x,
|
||||
iterator first, iterator last)
|
||||
{
|
||||
if(x.elements == 0){
|
||||
return;
|
||||
}
|
||||
|
||||
iterator temp;
|
||||
while(first != last){
|
||||
temp = first;
|
||||
++first;
|
||||
splice(position, x, temp);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> void list<T, Allocator>::remove(const T& value){
|
||||
iterator temp = begin();
|
||||
while( temp != end() ){
|
||||
if(*temp == value){
|
||||
temp = erase(temp);
|
||||
}else{
|
||||
++temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> template <class Predicate> void list<T, Allocator>::remove_if(Predicate pred){
|
||||
iterator temp = begin();
|
||||
while( temp != end() ){
|
||||
if( pred(*temp) ){
|
||||
temp = erase(temp);
|
||||
}else{
|
||||
++temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> void list<T, Allocator>::unique(){
|
||||
equal_to<typename iterator_traits<iterator>::value_type> p;
|
||||
unique(p);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> template <class BinaryPredicate>
|
||||
void list<T, Allocator>::unique(BinaryPredicate binary_pred)
|
||||
{
|
||||
iterator temp1 = begin();
|
||||
iterator temp2;
|
||||
++temp1;
|
||||
while( temp1 != end() ){
|
||||
temp2 = temp1;
|
||||
--temp2;
|
||||
if( binary_pred(*temp1, *temp2) ){
|
||||
erase(temp1);
|
||||
temp1 = temp2;
|
||||
}
|
||||
++temp1;
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void list<T, Allocator>::merge(list<T,Allocator>& x){
|
||||
less<typename iterator_traits<typename list<T, Allocator>::iterator>::value_type> c;
|
||||
merge(x, c);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> template <class Compare>
|
||||
void list<T, Allocator>::merge(list<T,Allocator>& x, Compare comp)
|
||||
{
|
||||
iterator source = x.begin();
|
||||
iterator temp;
|
||||
iterator dest = begin();
|
||||
|
||||
while(source != x.end()){
|
||||
while( dest != end() && comp (*dest, *source) ){
|
||||
++dest;
|
||||
}
|
||||
++elements;
|
||||
--x.elements;
|
||||
|
||||
temp = source;
|
||||
++temp;
|
||||
|
||||
if(dest == begin()){
|
||||
dest.link_struct()->previous = source.link_struct();
|
||||
source.link_struct()->next = dest.link_struct();
|
||||
source.link_struct()->previous = 0;
|
||||
list_start = source.link_struct();
|
||||
}else{
|
||||
source.link_struct()->previous = dest.link_struct()->previous;
|
||||
dest.link_struct()->previous->next = source.link_struct();
|
||||
source.link_struct()->next = dest.link_struct();
|
||||
dest.link_struct()->previous = source.link_struct();
|
||||
}
|
||||
source = temp;
|
||||
}
|
||||
|
||||
//Fix up x;
|
||||
x.list_start = x.list_end;
|
||||
x.list_start->previous = 0;
|
||||
}
|
||||
|
||||
template<class T, class Allocator> void list<T, Allocator>::sort(){
|
||||
less<typename iterator_traits<typename list<T, Allocator>::iterator>::value_type> c;
|
||||
sort(c);
|
||||
}
|
||||
|
||||
template<class T, class Allocator> template <class Compare>
|
||||
void list<T, Allocator>::sort(Compare comp)
|
||||
{
|
||||
typename list<T, Allocator>::iterator i, j, k;
|
||||
|
||||
//FIXME - bubble sort
|
||||
|
||||
if(elements == 0){
|
||||
return;
|
||||
}
|
||||
|
||||
i = end();
|
||||
--i;
|
||||
while(i != begin()){
|
||||
j = begin();
|
||||
k = j;
|
||||
++k;
|
||||
while(j != i){
|
||||
if( comp(*k, *j) ){
|
||||
swap_nodes(k.link_struct(), j.link_struct());
|
||||
}
|
||||
++j;
|
||||
++k;
|
||||
}
|
||||
--i;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> void list<T, Allocator>::reverse(){
|
||||
if(elements == 0){
|
||||
return;
|
||||
}
|
||||
|
||||
node * current;
|
||||
node * following;
|
||||
node * temp;
|
||||
|
||||
//Need to move the list_end element to the begining
|
||||
|
||||
temp = list_end;
|
||||
list_end = temp->previous;
|
||||
list_end->next = 0;
|
||||
|
||||
list_start->previous = temp;
|
||||
temp->previous = 0;
|
||||
temp->next = list_start;
|
||||
list_start = temp;
|
||||
|
||||
current = list_start;
|
||||
|
||||
while( current != list_end ){
|
||||
following = current->next;
|
||||
|
||||
//Swap the values pointed to/at with the current node
|
||||
temp = current->next;
|
||||
current->next = current->previous;
|
||||
current->previous = temp;
|
||||
|
||||
current = following;
|
||||
}
|
||||
|
||||
//Swap pointers on the end node
|
||||
temp = list_end->next;
|
||||
list_end->next = list_end->previous;
|
||||
list_end->previous = temp;
|
||||
|
||||
|
||||
//Swap the fixed pointers
|
||||
temp = list_start;
|
||||
list_start = list_end;
|
||||
list_end = temp;
|
||||
|
||||
}
|
||||
|
||||
template <class T, class Allocator>
|
||||
bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y){
|
||||
if(x.size() != y.size()){
|
||||
return false;
|
||||
}
|
||||
typename list<T,Allocator>::const_iterator i = x.begin();
|
||||
typename list<T,Allocator>::const_iterator j = y.begin();
|
||||
|
||||
while(i != x.end()){
|
||||
if( *i != *j){
|
||||
return false;
|
||||
}
|
||||
++i;
|
||||
++j;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class T, class Allocator>
|
||||
bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y){
|
||||
typename list<T,Allocator>::const_iterator i = x.begin();
|
||||
typename list<T,Allocator>::const_iterator j = y.begin();
|
||||
while(i != x.end() && j != y.end()){
|
||||
if( *i < *j){
|
||||
return true;
|
||||
}
|
||||
if(*j < *i){
|
||||
return false;
|
||||
}
|
||||
++i;
|
||||
++j;
|
||||
}
|
||||
return (i == x.end() && j != y.end());
|
||||
}
|
||||
|
||||
template <class T, class Allocator>
|
||||
bool operator!=(const list<T,Allocator>& x, const list<T,Allocator>& y){
|
||||
return !(x == y);
|
||||
}
|
||||
|
||||
template <class T, class Allocator>
|
||||
bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y){
|
||||
typename list<T,Allocator>::const_iterator i = x.begin();
|
||||
typename list<T,Allocator>::const_iterator j = y.begin();
|
||||
while(i != x.end() && j != y.end()){
|
||||
if( *i > *j){
|
||||
return true;
|
||||
}
|
||||
if( *j > *i){
|
||||
return false;
|
||||
}
|
||||
++i;
|
||||
++j;
|
||||
}
|
||||
return (i != x.end() && j == y.end());
|
||||
}
|
||||
|
||||
template <class T, class Allocator>
|
||||
bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y){
|
||||
typename list<T,Allocator>::const_iterator i = x.begin();
|
||||
typename list<T,Allocator>::const_iterator j = y.begin();
|
||||
while(i != x.end() && j != y.end()){
|
||||
if( *i >= *j){
|
||||
return true;
|
||||
}
|
||||
if(*j >= *i){
|
||||
return false;
|
||||
}
|
||||
++i;
|
||||
++j;
|
||||
}
|
||||
return (i != x.end() && j == y.end());
|
||||
}
|
||||
|
||||
template <class T, class Allocator>
|
||||
bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y){
|
||||
typename list<T,Allocator>::const_iterator i = x.begin();
|
||||
typename list<T,Allocator>::const_iterator j = y.begin();
|
||||
while(i != x.end() && j != y.end()){
|
||||
if( *i <= *j){
|
||||
return true;
|
||||
}
|
||||
if(*j <= *i){
|
||||
return false;
|
||||
}
|
||||
++i;
|
||||
++j;
|
||||
}
|
||||
return (i == x.end());
|
||||
}
|
||||
|
||||
template <class T, class Allocator>
|
||||
void swap(list<T,Allocator>& x, list<T,Allocator>& y){
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <cstddef>
|
||||
#include <string>
|
||||
|
||||
#ifndef __HEADER_STD_LOCALE
|
||||
#define __HEADER_STD_LOCALE 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
class _UCXXEXPORT locale {
|
||||
public:
|
||||
// types:
|
||||
class facet;
|
||||
class id;
|
||||
typedef unsigned char category;
|
||||
|
||||
static const category
|
||||
none = 0,
|
||||
collate = 0x01, ctype = 0x02,
|
||||
monetary = 0x04, numeric = 0x08,
|
||||
time = 0x10, messages = 0x20,
|
||||
all = collate | ctype | monetary | numeric | time | messages;
|
||||
|
||||
// construct/copy/destroy:
|
||||
locale() throw(){
|
||||
return;
|
||||
}
|
||||
locale(const locale& other) throw(){
|
||||
(void)other;
|
||||
return;
|
||||
}
|
||||
locale(const char *) throw(){
|
||||
return;
|
||||
}
|
||||
~locale() throw(){
|
||||
return;
|
||||
}
|
||||
|
||||
const locale& operator=(const locale&) throw(){
|
||||
return *this;
|
||||
}
|
||||
std::string name() const { return "C"; }
|
||||
};
|
||||
|
||||
class _UCXXEXPORT locale::facet {
|
||||
friend class locale;
|
||||
explicit facet(size_t = 0){
|
||||
return;
|
||||
}
|
||||
virtual ~facet(){
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
class _UCXXEXPORT locale::id {
|
||||
id(){ }
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,264 @@
|
|||
/* Copyright (C) 2004-2007 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <iterator>
|
||||
#include <associative_base>
|
||||
|
||||
|
||||
#ifndef __STD_HEADER_MAP
|
||||
#define __STD_HEADER_MAP
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<T> > class map;
|
||||
template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<T> > class multimap;
|
||||
|
||||
|
||||
//Compare the keys of the two items
|
||||
/* template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT
|
||||
__base_map<Key, T, Compare, Allocator>::value_compare : public binary_function<
|
||||
typename map<Key, T, Compare, Allocator>::value_type,
|
||||
typename map<Key, T, Compare, Allocator>::value_type,
|
||||
bool>
|
||||
{
|
||||
friend class __base_map<Key, T, Compare, Allocator>;
|
||||
protected:
|
||||
Compare comp;
|
||||
value_compare(Compare c) : comp(c) { }
|
||||
~value_compare() { }
|
||||
public:
|
||||
bool operator()(const value_type& x, const value_type& y) const {
|
||||
return comp(x.first, y.first);
|
||||
}
|
||||
};
|
||||
*/
|
||||
|
||||
// value_compare value_comp() const;
|
||||
|
||||
|
||||
|
||||
/* This is the implementation for the map container. As noted above, it deviates
|
||||
* from ISO spec by deriving from a base class in order to reduce code redundancy.
|
||||
* More code could be reduced by convirting to virtual functions (thus allowing
|
||||
* much of the erase and insert code to be duplicated), but that would deviate from
|
||||
* the specifications too much to be worth the risk.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
//Implementation of map
|
||||
|
||||
|
||||
template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT map
|
||||
: public __single_associative<Key, pair<Key, T>, Compare, Allocator>
|
||||
{
|
||||
//Default value of allocator does not meet C++ standard specs, but it works for this library
|
||||
//Deal with it
|
||||
|
||||
public:
|
||||
|
||||
typedef __single_associative<Key, pair<Key, T>, Compare, Allocator> base;
|
||||
typedef T mapped_type;
|
||||
typedef typename base::key_type key_type;
|
||||
typedef typename base::value_type value_type;
|
||||
typedef typename base::key_compare key_compare;
|
||||
typedef typename base::allocator_type allocator_type;
|
||||
typedef typename base::reference reference;
|
||||
typedef typename base::const_reference const_reference;
|
||||
typedef typename base::iterator iterator;
|
||||
typedef typename base::const_iterator const_iterator;
|
||||
typedef typename base::size_type size_type;
|
||||
typedef typename base::difference_type difference_type;
|
||||
typedef typename base::pointer pointer;
|
||||
typedef typename base::const_pointer const_pointer;
|
||||
typedef typename base::reverse_iterator reverse_iterator;
|
||||
typedef typename base::const_reverse_iterator const_reverse_iterator;
|
||||
|
||||
static const key_type v_t_k(const value_type v){
|
||||
return v.first;
|
||||
}
|
||||
|
||||
// using base::value_compare;
|
||||
|
||||
explicit map(const Compare& comp = Compare(), const Allocator& al = Allocator())
|
||||
: base(comp, al, v_t_k) { }
|
||||
|
||||
template <class InputIterator> map(InputIterator first, InputIterator last,
|
||||
const Compare& comp = Compare(), const Allocator& al = Allocator())
|
||||
: base(first, last, comp, al, v_t_k) { }
|
||||
|
||||
map(const map<Key,T,Compare,Allocator>& x) : base(x) { }
|
||||
~map() { }
|
||||
|
||||
using base::operator=;
|
||||
using base::operator==;
|
||||
using base::operator!=;
|
||||
|
||||
using base::insert;
|
||||
using base::erase;
|
||||
|
||||
using base::begin;
|
||||
using base::end;
|
||||
using base::rbegin;
|
||||
using base::rend;
|
||||
|
||||
using base::empty;
|
||||
using base::size;
|
||||
using base::max_size;
|
||||
|
||||
using base::find;
|
||||
using base::count;
|
||||
using base::lower_bound;
|
||||
using base::upper_bound;
|
||||
using base::equal_range;
|
||||
using base::swap;
|
||||
|
||||
reference operator[](const key_type& k){
|
||||
iterator i = lower_bound(k);
|
||||
if (i == end() || base::c(k, i->first)) {
|
||||
i = insert(make_pair(k, T())).first;
|
||||
}
|
||||
return i->second;
|
||||
}
|
||||
|
||||
protected:
|
||||
using base::backing;
|
||||
};
|
||||
|
||||
|
||||
//Implementation of multimap
|
||||
|
||||
|
||||
template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT multimap
|
||||
: public __multi_associative<Key, pair<Key, T>, Compare, Allocator>
|
||||
|
||||
{
|
||||
//Default value of allocator does not meet C++ standard specs, but it works for this library
|
||||
//Deal with it
|
||||
public:
|
||||
|
||||
typedef __multi_associative<Key, pair<Key, T>, Compare, Allocator> base;
|
||||
typedef T mapped_type;
|
||||
typedef typename base::key_type key_type;
|
||||
typedef typename base::value_type value_type;
|
||||
typedef typename base::key_compare key_compare;
|
||||
typedef typename base::allocator_type allocator_type;
|
||||
typedef typename base::reference reference;
|
||||
typedef typename base::const_reference const_reference;
|
||||
typedef typename base::iterator iterator;
|
||||
typedef typename base::const_iterator const_iterator;
|
||||
typedef typename base::size_type size_type;
|
||||
typedef typename base::difference_type difference_type;
|
||||
typedef typename base::pointer pointer;
|
||||
typedef typename base::const_pointer const_pointer;
|
||||
typedef typename base::reverse_iterator reverse_iterator;
|
||||
typedef typename base::const_reverse_iterator const_reverse_iterator;
|
||||
|
||||
static const key_type v_t_k(const value_type v){
|
||||
return v.first;
|
||||
}
|
||||
|
||||
explicit multimap(const Compare& comp = Compare(), const Allocator& al = Allocator())
|
||||
: base(comp, al, v_t_k) { }
|
||||
|
||||
template <class InputIterator> multimap(InputIterator first, InputIterator last,
|
||||
const Compare& comp = Compare(), const Allocator& al = Allocator())
|
||||
: base(first, last, comp, al, v_t_k) { }
|
||||
|
||||
|
||||
multimap(const multimap<Key,T,Compare,Allocator>& x) : base(x) { }
|
||||
~multimap() { }
|
||||
|
||||
using base::operator=;
|
||||
using base::operator==;
|
||||
using base::operator!=;
|
||||
|
||||
using base::insert;
|
||||
using base::erase;
|
||||
|
||||
using base::begin;
|
||||
using base::end;
|
||||
using base::rbegin;
|
||||
using base::rend;
|
||||
|
||||
using base::empty;
|
||||
using base::size;
|
||||
using base::max_size;
|
||||
|
||||
using base::find;
|
||||
using base::count;
|
||||
using base::lower_bound;
|
||||
using base::upper_bound;
|
||||
using base::equal_range;
|
||||
using base::swap;
|
||||
|
||||
protected:
|
||||
|
||||
using base::c;
|
||||
|
||||
};
|
||||
|
||||
|
||||
/* Non-member functions. These are at the end because they are not associated with any
|
||||
particular class. These will be implemented as I figure out exactly what all of
|
||||
them are supposed to do, and I have time.
|
||||
*/
|
||||
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator<
|
||||
(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator!=
|
||||
(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator>
|
||||
(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator>=
|
||||
(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator<=
|
||||
(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT void swap
|
||||
(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y);
|
||||
|
||||
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator==
|
||||
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator<
|
||||
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator!=
|
||||
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator>
|
||||
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator>=
|
||||
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator<=
|
||||
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
||||
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT void swap
|
||||
(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>& y);
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,196 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <new>
|
||||
#include <cstddef>
|
||||
#include <cstdlib>
|
||||
#include <iterator_base>
|
||||
#include <utility>
|
||||
#include <cstdio>
|
||||
|
||||
#ifndef HEADER_STD_MEMORY
|
||||
#define HEADER_STD_MEMORY 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
template <class T> class allocator;
|
||||
// Specialize for void:
|
||||
|
||||
template <> class _UCXXEXPORT allocator<void> {
|
||||
public:
|
||||
typedef void* pointer;
|
||||
typedef const void* const_pointer;
|
||||
typedef void value_type;
|
||||
template <class U> struct rebind { typedef allocator<U> other; };
|
||||
};
|
||||
|
||||
template <class T> class _UCXXEXPORT allocator{
|
||||
public:
|
||||
typedef T value_type;
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
|
||||
typedef T* pointer;
|
||||
typedef const T* const_pointer;
|
||||
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
|
||||
pointer address(reference r) const { return &r; }
|
||||
const_pointer address(const_reference r) const { return &r; }
|
||||
|
||||
allocator() throw(){}
|
||||
template <class U> allocator(const allocator<U>& ) throw();
|
||||
~allocator() throw(){}
|
||||
|
||||
//Space for n Ts
|
||||
pointer allocate(size_type n, typename allocator<void>::const_pointer = 0){
|
||||
return (T*)(::operator new( n * sizeof(T) ));
|
||||
}
|
||||
void deallocate(pointer p, size_type){
|
||||
::operator delete(p);
|
||||
}
|
||||
|
||||
//Use placement new to engage the constructor
|
||||
void construct(pointer p, const T& val) { new((void*)p) T(val); }
|
||||
void destroy(pointer p){ ((T*)p)->~T(); } //Call destructor
|
||||
|
||||
size_type max_size() const throw();
|
||||
template<class U> struct rebind { typedef allocator<U> other; };
|
||||
|
||||
};
|
||||
|
||||
template <class Out, class T> class _UCXXEXPORT raw_storage_iterator
|
||||
: public iterator<output_iterator_tag, void, void, void, void>
|
||||
{
|
||||
Out p;
|
||||
|
||||
public:
|
||||
explicit raw_storage_iterator(Out pp) : p (pp) { }
|
||||
raw_storage_iterator & operator*() { return *this; }
|
||||
raw_storage_iterator & operator=(const T& val) {
|
||||
T* pp = &*p;
|
||||
new(pp) T(val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
raw_storage_iterator & operator++() { ++p; return *this; }
|
||||
raw_storage_iterator operator++(int) {
|
||||
raw_storage_iterator t = *this;
|
||||
++p;
|
||||
return t;
|
||||
}
|
||||
};
|
||||
|
||||
template <class T> _UCXXEXPORT pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t n){
|
||||
pair<T*, ptrdiff_t> retval;
|
||||
retval.first = static_cast<T*>(malloc(n * sizeof(T)));
|
||||
if(retval.first == 0){
|
||||
retval.second = 0;
|
||||
}else{
|
||||
retval.second = n;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
template <class T> _UCXXEXPORT void return_temporary_buffer(T* p){
|
||||
free(p);
|
||||
}
|
||||
|
||||
|
||||
template <class T> class _UCXXEXPORT auto_ptr{
|
||||
|
||||
private:
|
||||
T * object;
|
||||
template <class Y> struct auto_ptr_ref{
|
||||
Y * p;
|
||||
};
|
||||
|
||||
public:
|
||||
|
||||
typedef T element_type;
|
||||
|
||||
explicit auto_ptr(T* p =0) throw() : object(p){ }
|
||||
auto_ptr(auto_ptr& p) throw() : object(p.release()){ }
|
||||
auto_ptr(auto_ptr_ref<T> r) throw() : object(r.p){
|
||||
r.p = 0;
|
||||
}
|
||||
template<class Y> auto_ptr(auto_ptr<Y>& p) throw() : object(p.release()){ }
|
||||
auto_ptr& operator=(auto_ptr& p) throw(){
|
||||
if(&p == this){
|
||||
return *this;
|
||||
}
|
||||
delete object;
|
||||
object = p.release();
|
||||
return *this;
|
||||
}
|
||||
template<class Y> auto_ptr& operator=(auto_ptr<Y>& p) throw(){
|
||||
if(&p == this){
|
||||
return *this;
|
||||
}
|
||||
delete object;
|
||||
object = p.release();
|
||||
return *this;
|
||||
}
|
||||
~auto_ptr(){
|
||||
delete object;
|
||||
}
|
||||
|
||||
T& operator*() const throw(){
|
||||
return *object;
|
||||
}
|
||||
T* operator->() const throw(){
|
||||
return object;
|
||||
}
|
||||
T* get() const throw(){
|
||||
return object;
|
||||
}
|
||||
T* release() throw(){
|
||||
T * temp(object);
|
||||
object = 0;
|
||||
return temp;
|
||||
}
|
||||
void reset(T * p=0) throw(){
|
||||
if(p != object){
|
||||
delete object;
|
||||
object = p;
|
||||
}
|
||||
}
|
||||
template<class Y> operator auto_ptr_ref<Y>() throw(){
|
||||
auto_ptr_ref<Y> retval;
|
||||
retval.p = object;
|
||||
object = 0;
|
||||
return retval;
|
||||
}
|
||||
template<class Y> operator auto_ptr<Y>() throw(){
|
||||
auto_ptr<Y> retval(object);
|
||||
object = 0;
|
||||
return retval;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} //namespace std
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <exception>
|
||||
#include <cstddef>
|
||||
|
||||
#ifndef __STD_NEW_OPERATOR
|
||||
#define __STD_NEW_OPERATOR 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
class _UCXXEXPORT bad_alloc : public exception {};
|
||||
|
||||
struct _UCXXEXPORT nothrow_t {};
|
||||
extern const nothrow_t nothrow;
|
||||
|
||||
typedef void (*new_handler)();
|
||||
_UCXXEXPORT new_handler set_new_handler(new_handler new_p) throw();
|
||||
}
|
||||
|
||||
|
||||
_UCXXEXPORT void* operator new(std::size_t numBytes) throw(std::bad_alloc);
|
||||
_UCXXEXPORT void operator delete(void* ptr) throw();
|
||||
|
||||
_UCXXEXPORT void* operator new[](std::size_t numBytes) throw(std::bad_alloc);
|
||||
_UCXXEXPORT void operator delete[](void * ptr) throw();
|
||||
|
||||
#ifndef NO_NOTHROW
|
||||
_UCXXEXPORT void* operator new(std::size_t numBytes, const std::nothrow_t& ) throw();
|
||||
_UCXXEXPORT void operator delete(void* ptr, const std::nothrow_t& ) throw();
|
||||
|
||||
_UCXXEXPORT void* operator new[](std::size_t numBytes, const std::nothrow_t& ) throw();
|
||||
_UCXXEXPORT void operator delete[](void* ptr, const std::nothrow_t& ) throw();
|
||||
#endif
|
||||
|
||||
/* Placement operators */
|
||||
inline void* operator new(std::size_t, void* ptr) throw() {return ptr; }
|
||||
inline void operator delete(void* , void *) throw() { }
|
||||
|
||||
inline void* operator new[](std::size_t, void *p) throw() { return p; }
|
||||
inline void operator delete[](void* , void *) throw() {}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,161 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <exception>
|
||||
|
||||
#ifndef __STD_NUMERIC_HEADER
|
||||
#define __STD_NUMERIC_HEADER 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
template <class InputIterator, class T> _UCXXEXPORT
|
||||
T accumulate(InputIterator first, InputIterator last, T init)
|
||||
{
|
||||
while(first != last){
|
||||
init = init + *first;
|
||||
++first;
|
||||
}
|
||||
return init;
|
||||
}
|
||||
|
||||
template <class InputIterator, class T, class BinaryOperation> _UCXXEXPORT
|
||||
T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op)
|
||||
{
|
||||
while(first != last){
|
||||
init = binary_op(init, *first);
|
||||
++first;
|
||||
}
|
||||
return init;
|
||||
}
|
||||
|
||||
|
||||
template <class InputIterator1, class InputIterator2, class T> _UCXXEXPORT
|
||||
T inner_product(InputIterator1 first1, InputIterator1 last1,
|
||||
InputIterator2 first2, T init)
|
||||
{
|
||||
while(first1 != last1){
|
||||
init = init + *first1 * *first2;
|
||||
++first1;
|
||||
++first2;
|
||||
}
|
||||
return init;
|
||||
}
|
||||
|
||||
template <class InputIterator1, class InputIterator2, class T,
|
||||
class BinaryOperation1, class BinaryOperation2> _UCXXEXPORT
|
||||
T inner_product(InputIterator1 first1, InputIterator1 last1,
|
||||
InputIterator2 first2, T init,
|
||||
BinaryOperation1 binary_op1,
|
||||
BinaryOperation2 binary_op2)
|
||||
{
|
||||
while(first1 != last1){
|
||||
init = binary_op1(init, binary_op2(*first1, *first2));
|
||||
++first1;
|
||||
++first2;
|
||||
}
|
||||
return init;
|
||||
}
|
||||
|
||||
template <class InputIterator, class OutputIterator> _UCXXEXPORT
|
||||
OutputIterator partial_sum(InputIterator first, InputIterator last,
|
||||
OutputIterator result)
|
||||
{
|
||||
OutputIterator temp(result);
|
||||
*result = *first;
|
||||
++first;
|
||||
++result;
|
||||
|
||||
while(first != last){
|
||||
*result = *first + *temp;
|
||||
temp = result;
|
||||
++first;
|
||||
++result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
template <class InputIterator, class OutputIterator, class BinaryOperation> _UCXXEXPORT
|
||||
OutputIterator partial_sum(InputIterator first, InputIterator last,
|
||||
OutputIterator result, BinaryOperation binary_op)
|
||||
{
|
||||
OutputIterator temp(result);
|
||||
*result = *first;
|
||||
++first;
|
||||
++result;
|
||||
|
||||
while(first != last){
|
||||
*result = binary_op(*first, *temp);
|
||||
temp = result;
|
||||
++first;
|
||||
++result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
template <class InputIterator, class OutputIterator> _UCXXEXPORT
|
||||
OutputIterator
|
||||
adjacent_difference(InputIterator first, InputIterator last,
|
||||
OutputIterator result)
|
||||
{
|
||||
OutputIterator temp(first);
|
||||
*result = *first;
|
||||
++first;
|
||||
++result;
|
||||
|
||||
while(first != last){
|
||||
*result = *first - *temp;
|
||||
temp = first;
|
||||
++first;
|
||||
++result;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
template <class InputIterator, class OutputIterator, class BinaryOperation> _UCXXEXPORT
|
||||
OutputIterator
|
||||
adjacent_difference(InputIterator first, InputIterator last,
|
||||
OutputIterator result, BinaryOperation binary_op)
|
||||
{
|
||||
OutputIterator temp(first);
|
||||
*result = *first;
|
||||
++first;
|
||||
++result;
|
||||
|
||||
while(first != last){
|
||||
*result = binary_op(*first, *temp);
|
||||
temp = first;
|
||||
++first;
|
||||
++result;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,510 @@
|
|||
/* Copyright (C) 2004-2008 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
|
||||
#ifndef STD_HEADER_OSTREAM
|
||||
#define STD_HEADER_OSTREAM 1
|
||||
|
||||
#include <iosfwd>
|
||||
#include <streambuf>
|
||||
#include <cstdio>
|
||||
#include <ios>
|
||||
#include <ostream_helpers>
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std {
|
||||
template <class charT, class traits > class basic_ostream;
|
||||
typedef basic_ostream<char> ostream;
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
typedef basic_ostream<wchar_t> wostream;
|
||||
#endif
|
||||
|
||||
template <class charT, class traits> basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
|
||||
template <class charT, class traits> basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
|
||||
template <class charT, class traits> basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
|
||||
|
||||
template <class charT, class traits > class _UCXXEXPORT basic_ostream
|
||||
: virtual public basic_ios<charT,traits>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef charT char_type;
|
||||
typedef typename traits::int_type int_type;
|
||||
typedef typename traits::pos_type pos_type;
|
||||
typedef typename traits::off_type off_type;
|
||||
typedef traits traits_type;
|
||||
|
||||
|
||||
_UCXXEXPORT basic_ostream(basic_streambuf<charT,traits>* sb)
|
||||
: basic_ios<charT, traits>(sb)
|
||||
{
|
||||
basic_ios<charT,traits>::init(sb);
|
||||
}
|
||||
virtual _UCXXEXPORT ~basic_ostream();
|
||||
|
||||
class sentry;
|
||||
|
||||
_UCXXEXPORT basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&)){
|
||||
return pf(*this);
|
||||
}
|
||||
_UCXXEXPORT basic_ostream<charT,traits>& operator<<(basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&)){
|
||||
pf(*this);
|
||||
return *this;
|
||||
}
|
||||
_UCXXEXPORT basic_ostream<charT,traits>& operator<<(ios_base& (*pf)(ios_base&)){
|
||||
pf(*this);
|
||||
return *this;
|
||||
}
|
||||
basic_ostream<charT,traits>& operator<<(bool n);
|
||||
basic_ostream<charT,traits>& operator<<(short n);
|
||||
basic_ostream<charT,traits>& operator<<(unsigned short n);
|
||||
basic_ostream<charT,traits>& operator<<(int n);
|
||||
basic_ostream<charT,traits>& operator<<(unsigned int n);
|
||||
basic_ostream<charT,traits>& operator<<(long n);
|
||||
basic_ostream<charT,traits>& operator<<(unsigned long n);
|
||||
basic_ostream<charT,traits>& operator<<(float f);
|
||||
basic_ostream<charT,traits>& operator<<(double f);
|
||||
basic_ostream<charT,traits>& operator<<(long double f);
|
||||
basic_ostream<charT,traits>& operator<<(void* p);
|
||||
basic_ostream<charT,traits>& operator<<(basic_streambuf<char_type,traits>* sb);
|
||||
|
||||
_UCXXEXPORT basic_ostream<charT,traits>& put(char_type c){
|
||||
if(basic_ostream<charT,traits>::traits_type::eq_int_type(
|
||||
basic_ios<charT, traits>::mstreambuf->sputc(c),
|
||||
basic_ostream<charT,traits>::traits_type::eof()))
|
||||
{
|
||||
basic_ios<charT,traits>::setstate(ios_base::eofbit);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
_UCXXEXPORT basic_ostream<charT,traits>& write(const char_type* s, streamsize n){
|
||||
if(basic_ostream<charT,traits>::traits_type::eq_int_type(
|
||||
basic_ios<charT, traits>::mstreambuf->sputn(s, n),
|
||||
basic_ostream<charT,traits>::traits_type::eof())
|
||||
){
|
||||
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);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
_UCXXEXPORT pos_type tellp(){
|
||||
if(basic_ios<charT,traits>::fail() != false){
|
||||
return pos_type(-1);
|
||||
}
|
||||
return basic_ios<charT,traits>::rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
|
||||
}
|
||||
_UCXXEXPORT basic_ostream<charT,traits>& seekp(pos_type pos){
|
||||
if( basic_ios<charT,traits>::fail() != true ){
|
||||
basic_ios<charT,traits>::rdbuf()->pubseekpos(pos);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
_UCXXEXPORT basic_ostream<charT,traits>& seekp(off_type off, ios_base::seekdir dir){
|
||||
if( basic_ios<charT,traits>::fail() != true){
|
||||
basic_ios<charT,traits>::rdbuf()->pubseekoff(off, dir);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
_UCXXEXPORT void printout(const char_type* s, streamsize n){
|
||||
//david
|
||||
streamsize extra = ios::width() - n;
|
||||
if ((ios::flags()&ios::adjustfield) == ios::right){
|
||||
while (extra > 0) {
|
||||
--extra;
|
||||
put(ios::fill());
|
||||
}
|
||||
}
|
||||
write(s, n);
|
||||
if ((ios::flags()&ios::adjustfield) == ios::left) {
|
||||
while (extra > 0) {
|
||||
--extra;
|
||||
put(ios::fill());
|
||||
}
|
||||
}
|
||||
// Width value only applies for the next output operation. Reset to zero.
|
||||
ios::width(0);
|
||||
}
|
||||
|
||||
protected:
|
||||
basic_ostream(const basic_ostream<charT,traits> &){ }
|
||||
basic_ostream<charT,traits> & operator=(const basic_ostream<charT,traits> &){ return *this; }
|
||||
};
|
||||
|
||||
//Implementations of template functions. To allow for partial specialization
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>::~basic_ostream(){ }
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(bool n){
|
||||
sentry s(*this);
|
||||
if( basic_ios<charT,traits>::flags() & ios_base::boolalpha){
|
||||
if(n){
|
||||
printout("true", 4);
|
||||
}else{
|
||||
printout("false", 5);
|
||||
}
|
||||
}else{
|
||||
if(n){
|
||||
printout("1", 1);
|
||||
}else{
|
||||
printout("0", 1);
|
||||
}
|
||||
}
|
||||
if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
|
||||
flush();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
|
||||
basic_ostream<charT, traits>::operator<<(unsigned short n){
|
||||
sentry s(*this);
|
||||
__ostream_printout<traits, charT, unsigned long int>::printout(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(short n){
|
||||
sentry s(*this);
|
||||
__ostream_printout<traits, charT, long int>::printout(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(int n){
|
||||
sentry s(*this);
|
||||
__ostream_printout<traits, charT, long int>::printout(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(unsigned int n){
|
||||
sentry s(*this);
|
||||
__ostream_printout<traits, charT, unsigned long int>::printout(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(long n){
|
||||
sentry s(*this);
|
||||
__ostream_printout<traits, charT, long >::printout(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
|
||||
basic_ostream<charT, traits>::operator<<(unsigned long n)
|
||||
{
|
||||
sentry s(*this);
|
||||
__ostream_printout<traits, charT, unsigned long >::printout(*this, n);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(float f){
|
||||
sentry s(*this);
|
||||
__ostream_printout<traits, charT, double >::printout(*this, f);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(double f){
|
||||
sentry s(*this);
|
||||
__ostream_printout<traits, charT, double >::printout(*this, f);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(long double f){
|
||||
sentry s(*this);
|
||||
__ostream_printout<traits, charT, long double >::printout(*this, f);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& basic_ostream<charT, traits>::operator<<(void* p){
|
||||
sentry s(*this);
|
||||
char buffer[20];
|
||||
printout(buffer, snprintf(buffer, 20, "%p", p) );
|
||||
if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
|
||||
flush();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
|
||||
basic_ostream<charT, traits>::operator<<(basic_streambuf<charT,traits>* sb)
|
||||
{
|
||||
sentry s(*this);
|
||||
if(sb == 0){
|
||||
basic_ios<charT,traits>::setstate(ios_base::badbit);
|
||||
return *this;
|
||||
}
|
||||
|
||||
typename traits::int_type c;
|
||||
|
||||
while(basic_ios<charT,traits>::good() && (c = sb->sbumpc()) != traits::eof() ){
|
||||
put(c);
|
||||
}
|
||||
|
||||
if(basic_ios<charT,traits>::flags() & ios_base::unitbuf){
|
||||
flush();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
/*Template Specializations*/
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
|
||||
#ifndef __UCLIBCXX_COMPILE_OSTREAM__
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template <> _UCXXEXPORT ostream::~basic_ostream();
|
||||
|
||||
#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template <> _UCXXEXPORT ostream & ostream::flush();
|
||||
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(bool n);
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(short int n);
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned short int n);
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(int n);
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned int n);
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(long n);
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(unsigned long n);
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(float f);
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(double f);
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(long double f);
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(void* p);
|
||||
template <> _UCXXEXPORT ostream & ostream::operator<<(basic_streambuf<char, char_traits<char> >* sb);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
template <class charT,class traits = char_traits<charT> >
|
||||
class _UCXXEXPORT basic_ostream<charT,traits>::sentry
|
||||
{
|
||||
bool ok;
|
||||
public:
|
||||
explicit _UCXXEXPORT sentry(basic_ostream<charT,traits>& os): ok(true){
|
||||
//david
|
||||
if(os.good() !=0){ //Prepare for output
|
||||
}
|
||||
//Flush any tied buffer
|
||||
if(os.tie() !=0 ){
|
||||
os.tie()->flush();
|
||||
}
|
||||
}
|
||||
_UCXXEXPORT ~sentry() { }
|
||||
_UCXXEXPORT operator bool() {
|
||||
return ok;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
|
||||
#ifndef __UCLIBCXX_COMPILE_OSTREAM__
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template <> _UCXXEXPORT ostream::sentry::sentry(ostream & os);
|
||||
template <> _UCXXEXPORT ostream::sentry::~sentry();
|
||||
|
||||
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
//Non - class functions
|
||||
|
||||
|
||||
template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
|
||||
operator<<(basic_ostream<charT,traits>& out, charT c)
|
||||
{
|
||||
typename basic_ostream<charT,traits>::sentry s(out);
|
||||
out.put(c);
|
||||
return out;
|
||||
}
|
||||
|
||||
template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
|
||||
operator<<(basic_ostream<charT,traits>& out, char c)
|
||||
{
|
||||
typename basic_ostream<charT,traits>::sentry s(out);
|
||||
out.put(c);
|
||||
return out;
|
||||
}
|
||||
|
||||
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
|
||||
operator<<(basic_ostream<char,traits>& out, char c)
|
||||
{
|
||||
typename basic_ostream<char,traits>::sentry s(out);
|
||||
out.put(c);
|
||||
return out;
|
||||
}
|
||||
|
||||
// signed and unsigned
|
||||
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
|
||||
operator<<(basic_ostream<char,traits>& out, signed char c)
|
||||
{
|
||||
typename basic_ostream<char,traits>::sentry s(out);
|
||||
out.put(c);
|
||||
return out;
|
||||
}
|
||||
|
||||
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
|
||||
operator<<(basic_ostream<char,traits>& out, unsigned char c)
|
||||
{
|
||||
typename basic_ostream<char,traits>::sentry s(out);
|
||||
out.put(c);
|
||||
return out;
|
||||
}
|
||||
|
||||
template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
|
||||
operator<<(basic_ostream<charT,traits>& out, const charT* c)
|
||||
{
|
||||
typename basic_ostream<charT,traits>::sentry s(out);
|
||||
out.printout(c, traits::length(c) );
|
||||
return out;
|
||||
}
|
||||
|
||||
template<class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
|
||||
operator<<(basic_ostream<charT,traits>& out, const char* c)
|
||||
{
|
||||
typename basic_ostream<charT,traits>::sentry s(out);
|
||||
out.printout(c, char_traits<char>::length(c) );
|
||||
return out;
|
||||
}
|
||||
//david
|
||||
// partial specializations
|
||||
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
|
||||
operator<<(basic_ostream<char,traits>& out, const char* c)
|
||||
{
|
||||
//add by david
|
||||
/* printf("hello\n");
|
||||
int i;
|
||||
for(i=0;i<traits::length(c);i++)
|
||||
printf("%c",*(c+i));
|
||||
traits::length(c);*/
|
||||
typename basic_ostream<char,traits>::sentry s(out);
|
||||
out.printout(c, traits::length(c));
|
||||
return out;
|
||||
}
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
template<class traits> _UCXXEXPORT basic_ostream<wchar_t,traits>&
|
||||
operator<<(basic_ostream<wchar_t,traits>& out, const char* c)
|
||||
{
|
||||
typename basic_ostream<wchar_t, traits>::sentry s(out);
|
||||
size_t numChars = char_traits<char>::length(c);
|
||||
wchar_t * temp = new wchar_t[numChars];
|
||||
|
||||
for(size_t i=0; i < numChars; ++i){
|
||||
temp[i] = out.widen(c[i]);
|
||||
}
|
||||
|
||||
out.printout(temp, numChars);
|
||||
return out;
|
||||
}
|
||||
#endif
|
||||
|
||||
// signed and unsigned
|
||||
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
|
||||
operator<<(basic_ostream<char,traits>& out, const signed char* c)
|
||||
{
|
||||
typename basic_ostream<char,traits>::sentry s(out);
|
||||
out.printout(reinterpret_cast<const char *>(c), traits::length( reinterpret_cast<const char *>(c)));
|
||||
return out;
|
||||
}
|
||||
|
||||
template<class traits> _UCXXEXPORT basic_ostream<char,traits>&
|
||||
operator<<(basic_ostream<char,traits>& out, const unsigned char* c)
|
||||
{
|
||||
typename basic_ostream<char,traits>::sentry s(out);
|
||||
out.printout(reinterpret_cast<const char *>(c), traits::length( reinterpret_cast<const char *>(c)));
|
||||
return out;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
|
||||
endl(basic_ostream<charT,traits>& os)
|
||||
{
|
||||
typename basic_ostream<charT,traits>::sentry s(os);
|
||||
os.put('\n');
|
||||
os.flush();
|
||||
return os;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>&
|
||||
ends(basic_ostream<charT,traits>& os)
|
||||
{
|
||||
typename basic_ostream<charT,traits>::sentry s(os);
|
||||
os.put(traits::eos());
|
||||
return os;
|
||||
}
|
||||
|
||||
template <class charT, class traits> _UCXXEXPORT basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os){
|
||||
typename basic_ostream<charT,traits>::sentry s(os);
|
||||
os.flush();
|
||||
return os;
|
||||
}
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
|
||||
#ifndef __UCLIBCXX_COMPILE_OSTREAM__
|
||||
template <> _UCXXEXPORT ostream & endl(ostream & os);
|
||||
template <> _UCXXEXPORT ostream & flush(ostream & os);
|
||||
template <> _UCXXEXPORT ostream & operator<<(ostream & out, char c);
|
||||
template <> _UCXXEXPORT ostream & operator<<(ostream & out, const char* c);
|
||||
template <> _UCXXEXPORT ostream & operator<<(ostream & out, unsigned char c);
|
||||
template <> _UCXXEXPORT ostream & operator<<(ostream & out, unsigned const char* c);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef __STRICT_ANSI__
|
||||
|
||||
//Support for output of long long data types
|
||||
|
||||
template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
|
||||
operator<<(basic_ostream<Ch, Tr>& os, signed long long int i)
|
||||
{
|
||||
typename basic_ostream<Ch, Tr>::sentry s(os);
|
||||
__ostream_printout<Tr, Ch, signed long long int>::printout(os, i);
|
||||
return os;
|
||||
}
|
||||
|
||||
|
||||
template<class Ch, class Tr> _UCXXEXPORT basic_ostream<Ch, Tr>&
|
||||
operator<<(basic_ostream<Ch, Tr>& os, unsigned long long int i)
|
||||
{
|
||||
typename basic_ostream<Ch, Tr>::sentry s(os);
|
||||
__ostream_printout<Tr, Ch, unsigned long long int>::printout(os, i);
|
||||
return os;
|
||||
}
|
||||
|
||||
|
||||
#endif //__STRICT_ANSI__
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,491 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <cstddef>
|
||||
#include <ios>
|
||||
#include <cctype>
|
||||
#include <string>
|
||||
#include <stdio.h>
|
||||
|
||||
#ifndef __STD_HEADER_OSTREAM_HELPERS
|
||||
#define __STD_HEADER_OSTREAM_HELPERS 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
/* We are making the following template class for serveral reasons. Firstly,
|
||||
* we want to keep the main ostream code neat and tidy. Secondly, we want it
|
||||
* to be easy to do partial specialization of the ostream code so that it can
|
||||
* be expanded and put into the library. This will allow us to make application
|
||||
* code smaller at the expense of increased library size. This is a fair
|
||||
* trade-off when there are multiple applications being compiled. Also, this
|
||||
* feature will be used optionally via configuration options. It will also
|
||||
* allow us to keep the code bases in sync, dramatically simplifying the
|
||||
* maintenance required. We specialized for char because wchar and others
|
||||
* require different scanf functions
|
||||
*/
|
||||
|
||||
|
||||
|
||||
template <class traits, class charT, class dataType> class _UCXXEXPORT __ostream_printout{
|
||||
public:
|
||||
static void printout(basic_ostream<charT,traits>& stream, const dataType n);
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, signed long int>{
|
||||
public:
|
||||
static void printout(basic_ostream<char, traits >& stream, const signed long int n)
|
||||
{
|
||||
char buffer[20];
|
||||
const char * c_ld = "%ld";
|
||||
const char * c_lo = "%lo";
|
||||
const char * c_lX = "%lX";
|
||||
const char * c_lx = "%lx";
|
||||
const char * c_hashlo = "%#lo";
|
||||
const char * c_hashlX = "%#lX";
|
||||
const char * c_hashlx = "%#lx";
|
||||
|
||||
const char * formatString=0;
|
||||
|
||||
if( stream.flags() & ios_base::dec){
|
||||
formatString = c_ld;
|
||||
}else if( stream.flags() & ios_base::oct){
|
||||
if( stream.flags() & ios_base::showbase){
|
||||
formatString = c_hashlo;
|
||||
}else{
|
||||
formatString = c_lo;
|
||||
}
|
||||
}else if (stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::showbase){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
formatString = c_hashlX;
|
||||
}else{
|
||||
formatString = c_hashlx;
|
||||
}
|
||||
}else{
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
formatString = c_lX;
|
||||
}else{
|
||||
formatString = c_lx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stream.printout(buffer, snprintf(buffer, 20, formatString, n) );
|
||||
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, unsigned long int>{
|
||||
public:
|
||||
static void printout(basic_ostream<char, traits >& stream, const unsigned long int n)
|
||||
{
|
||||
char buffer[20];
|
||||
const char * c_lo = "%lo";
|
||||
const char * c_lu = "%lu";
|
||||
const char * c_lX = "%lX";
|
||||
const char * c_lx = "%lx";
|
||||
const char * c_hashlo = "%#lo";
|
||||
const char * c_hashlX = "%#lX";
|
||||
const char * c_hashlx = "%#lx";
|
||||
const char * formatString=0;
|
||||
|
||||
if( stream.flags() & ios_base::dec){
|
||||
formatString = c_lu;
|
||||
}else if( stream.flags() & ios_base::oct){
|
||||
if( stream.flags() & ios_base::showbase){
|
||||
formatString = c_hashlo;
|
||||
}else{
|
||||
formatString = c_lo;
|
||||
}
|
||||
}else if (stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::showbase){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
formatString = c_hashlX;
|
||||
}else{
|
||||
formatString = c_hashlx;
|
||||
}
|
||||
}else{
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
formatString = c_lX;
|
||||
}else{
|
||||
formatString = c_lx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stream.printout(buffer, snprintf(buffer, 20, formatString, n));
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#ifndef __STRICT_ANSI__
|
||||
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, signed long long int>{
|
||||
public:
|
||||
static void printout(basic_ostream<char, traits >& stream, const signed long long int n)
|
||||
{
|
||||
char buffer[28];
|
||||
const char * lld = "%lld";
|
||||
const char * llo = "%llo";
|
||||
const char * llX = "%llX";
|
||||
const char * llx = "%llx";
|
||||
const char * hashllo = "%#llo";
|
||||
const char * hashllX = "%#llX";
|
||||
const char * hashllx = "%#llx";
|
||||
const char * formatString=0;
|
||||
|
||||
if( stream.flags() & ios_base::dec){
|
||||
formatString = lld;
|
||||
}else if( stream.flags() & ios_base::oct){
|
||||
if( stream.flags() & ios_base::showbase){
|
||||
formatString = hashllo;
|
||||
}else{
|
||||
formatString = llo;
|
||||
}
|
||||
}else if (stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::showbase){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
formatString = hashllX;
|
||||
}else{
|
||||
formatString = hashllx;
|
||||
}
|
||||
}else{
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
formatString = llX;
|
||||
}else{
|
||||
formatString = llx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stream.printout(buffer, snprintf(buffer, 27, formatString, n) );
|
||||
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, unsigned long long int>{
|
||||
public:
|
||||
static void printout(basic_ostream<char, traits >& stream, const unsigned long long int n)
|
||||
{
|
||||
char buffer[28];
|
||||
const char * llo = "%llo";
|
||||
const char * llu = "%llu";
|
||||
const char * llX = "%llX";
|
||||
const char * llx = "%llx";
|
||||
const char * hashllo = "%#llo";
|
||||
const char * hashllX = "%#llX";
|
||||
const char * hashllx = "%#llx";
|
||||
const char * formatString=0;
|
||||
|
||||
if( stream.flags() & ios_base::dec){
|
||||
formatString = llu;
|
||||
}else if( stream.flags() & ios_base::oct){
|
||||
if( stream.flags() & ios_base::showbase){
|
||||
formatString = hashllo;
|
||||
}else{
|
||||
formatString = llo;
|
||||
}
|
||||
}else if (stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::showbase){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
formatString = hashllX;
|
||||
}else{
|
||||
formatString = hashllx;
|
||||
}
|
||||
}else{
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
formatString = llX;
|
||||
}else{
|
||||
formatString = llx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stream.printout(buffer, snprintf(buffer, 27, formatString, n) );
|
||||
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#endif //__STRICT_ANSI__
|
||||
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, double>{
|
||||
public:
|
||||
static void printout(basic_ostream<char, traits >& stream, const double f)
|
||||
{
|
||||
char buffer[32];
|
||||
int length;
|
||||
if(stream.flags() & ios_base::scientific){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
length = snprintf(buffer, 32, "%*.*E", static_cast<int>(stream.width()),static_cast<int>(stream.precision()), f);
|
||||
}else{
|
||||
length = snprintf(buffer, 32, "%*.*e", static_cast<int>(stream.width()),static_cast<int>(stream.precision()), f);
|
||||
}
|
||||
} else if(stream.flags() & ios_base::fixed){
|
||||
length = snprintf(buffer, 32, "%*.*f",static_cast<int>(stream.width()),static_cast<int>(stream.precision()), f);
|
||||
} else {
|
||||
length = snprintf(buffer, 32, "%*.*g",static_cast<int>(stream.width()),static_cast<int>(stream.precision()), f);
|
||||
}
|
||||
stream.printout(buffer, length);
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, char, long double>{
|
||||
public:
|
||||
static void printout(basic_ostream<char, traits >& stream, const long double f)
|
||||
{
|
||||
char buffer[32];
|
||||
int length;
|
||||
if(stream.flags() & ios_base::scientific){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
length = snprintf(buffer, 32, "%*.*LE", static_cast<int>(stream.width()), static_cast<int>(stream.precision()), f);
|
||||
}else{
|
||||
length = snprintf(buffer, 32, "%*.*Le", static_cast<int>(stream.width()), static_cast<int>(stream.precision()), f);
|
||||
}
|
||||
} else if(stream.flags() & ios_base::fixed){
|
||||
length = snprintf(buffer, 32, "%*.*Lf", static_cast<int>(stream.width()), static_cast<int>(stream.precision()), f);
|
||||
} else {
|
||||
length = snprintf(buffer, 32, "%*.*Lg", static_cast<int>(stream.width()), static_cast<int>(stream.precision()), f);
|
||||
}
|
||||
stream.printout(buffer, length);
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, signed long int>{
|
||||
public:
|
||||
static void printout(basic_ostream<wchar_t, traits >& stream, const signed long int n)
|
||||
{
|
||||
wchar_t buffer[20];
|
||||
if( stream.flags() & ios_base::dec){
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%ld", n));
|
||||
}else if( stream.flags() & ios_base::oct){
|
||||
if( stream.flags() & ios_base::showbase){
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%#lo", n));
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%lo", n) );
|
||||
}
|
||||
}else if (stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::showbase){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%#lX", n) );
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%#lx", n) );
|
||||
}
|
||||
}else{
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%lX", n) );
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%lx", n) );
|
||||
}
|
||||
}
|
||||
}
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, unsigned long int>{
|
||||
public:
|
||||
static void printout(basic_ostream<wchar_t, traits >& stream, const unsigned long int n)
|
||||
{
|
||||
wchar_t buffer[20];
|
||||
if( stream.flags() & ios_base::dec){
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%lu", n));
|
||||
}else if( stream.flags() & ios_base::oct){
|
||||
if( stream.flags() & ios_base::showbase){
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%#lo", n));
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%lo", n) );
|
||||
}
|
||||
}else if (stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::showbase){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%#lX", n) );
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%#lx", n) );
|
||||
}
|
||||
}else{
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%lX", n) );
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 20, L"%lx", n) );
|
||||
}
|
||||
}
|
||||
}
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#ifndef __STRICT_ANSI__
|
||||
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, signed long long int>{
|
||||
public:
|
||||
static void printout(basic_ostream<wchar_t, traits >& stream, const signed long long int n)
|
||||
{
|
||||
wchar_t buffer[28];
|
||||
if( stream.flags() & ios_base::dec){
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%lld", n));
|
||||
}else if( stream.flags() & ios_base::oct){
|
||||
if( stream.flags() & ios_base::showbase){
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%#llo", n));
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%llo", n) );
|
||||
}
|
||||
}else if (stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::showbase){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%#llX", n) );
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%#llx", n) );
|
||||
}
|
||||
}else{
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%llX", n) );
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%llx", n) );
|
||||
}
|
||||
}
|
||||
}
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, unsigned long long int>{
|
||||
public:
|
||||
static void printout(basic_ostream<wchar_t, traits >& stream, const unsigned long long int n)
|
||||
{
|
||||
wchar_t buffer[28];
|
||||
if( stream.flags() & ios_base::dec){
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%llu", n));
|
||||
}else if( stream.flags() & ios_base::oct){
|
||||
if( stream.flags() & ios_base::showbase){
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%#llo", n));
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%llo", n) );
|
||||
}
|
||||
}else if (stream.flags() & ios_base::hex){
|
||||
if(stream.flags() & ios_base::showbase){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%#llX", n) );
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%#llx", n) );
|
||||
}
|
||||
}else{
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%llX", n) );
|
||||
}else{
|
||||
stream.printout(buffer, swprintf(buffer, 27, L"%llx", n) );
|
||||
}
|
||||
}
|
||||
}
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#endif //__STRICT_ANSI__
|
||||
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, double>{
|
||||
public:
|
||||
static void printout(basic_ostream<wchar_t, traits >& stream, const double f)
|
||||
{
|
||||
wchar_t buffer[32];
|
||||
wchar_t format_string[32];
|
||||
if(stream.flags() & ios_base::scientific){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
swprintf(format_string, 32, L"%%%u.%uE", static_cast<int>(stream.width()), static_cast<unsigned int>(stream.precision()));
|
||||
}else{
|
||||
swprintf(format_string, 32, L"%%%u.%ue", static_cast<int>(stream.width()), static_cast<unsigned int>(stream.precision()));
|
||||
}
|
||||
} else if(stream.flags() & ios_base::fixed){
|
||||
swprintf(format_string, 32, L"%%%u.%uf", static_cast<int>(stream.width()), static_cast<unsigned int>(stream.precision()));
|
||||
} else {
|
||||
swprintf(format_string, 32, L"%%%u.%ug", static_cast<int>(stream.width()), static_cast<unsigned int>(stream.precision()));
|
||||
}
|
||||
stream.printout(buffer, swprintf(buffer, 32, format_string, f) );
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <class traits> class _UCXXEXPORT __ostream_printout<traits, wchar_t, long double>{
|
||||
public:
|
||||
static void printout(basic_ostream<wchar_t, traits >& stream, const long double f)
|
||||
{
|
||||
wchar_t buffer[32];
|
||||
wchar_t format_string[32];
|
||||
if(stream.flags() & ios_base::scientific){
|
||||
if(stream.flags() & ios_base::uppercase){
|
||||
swprintf(format_string, 32, L"%%%u.%uLE", static_cast<unsigned int>(stream.width()), static_cast<unsigned int>(stream.precision()));
|
||||
}else{
|
||||
swprintf(format_string, 32, L"%%%u.%uLe", static_cast<unsigned int>(stream.width()), static_cast<unsigned int>(stream.precision()));
|
||||
}
|
||||
} else if(stream.flags() & ios_base::fixed){
|
||||
swprintf(format_string, 32, L"%%%u.%uLf", static_cast<unsigned int>(stream.width()), static_cast<unsigned int>(stream.precision()));
|
||||
} else {
|
||||
swprintf(format_string, 32, L"%%%u.%uLg", static_cast<unsigned int>(stream.width()), static_cast<unsigned int>(stream.precision()));
|
||||
}
|
||||
stream.printout(buffer, swprintf(buffer, 32, format_string, f) );
|
||||
if(stream.flags() & ios_base::unitbuf){
|
||||
stream.flush();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#endif //__UCLIBCXX_HAS_WCHAR__
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,126 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <deque>
|
||||
#include <vector>
|
||||
#include <functional>
|
||||
|
||||
#ifndef __HEADER_STD_QUEUE
|
||||
#define __HEADER_STD_QUEUE 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
template <class T, class Container = deque<T> > class _UCXXEXPORT queue{
|
||||
protected:
|
||||
Container c;
|
||||
public:
|
||||
typedef typename Container::value_type value_type;
|
||||
typedef typename Container::size_type size_type;
|
||||
typedef Container container_type;
|
||||
|
||||
explicit queue(const Container& a = Container()) : c(a) { }
|
||||
|
||||
bool empty() const { return c.empty(); }
|
||||
size_type size() const { return c.size(); }
|
||||
value_type& front() { return c.front(); }
|
||||
const value_type& front() const { return c.front(); }
|
||||
value_type& back() { return c.back(); }
|
||||
const value_type& back() const { return c.back(); }
|
||||
void push(const value_type& x) { c.push_back(x); }
|
||||
void pop() { c.pop_front(); }
|
||||
};
|
||||
|
||||
|
||||
template <class T, class Container> _UCXXEXPORT bool
|
||||
operator==(const queue<T, Container>& x, const queue<T, Container>& y)
|
||||
{
|
||||
return (x.c == y.c);
|
||||
}
|
||||
template <class T, class Container> _UCXXEXPORT bool
|
||||
operator< (const queue<T, Container>& x, const queue<T, Container>& y)
|
||||
{
|
||||
return (x.c < y.c);
|
||||
}
|
||||
template <class T, class Container> _UCXXEXPORT bool
|
||||
operator!=(const queue<T, Container>& x, const queue<T, Container>& y)
|
||||
{
|
||||
return (x.c != y.c);
|
||||
}
|
||||
template <class T, class Container> _UCXXEXPORT bool
|
||||
operator> (const queue<T, Container>& x, const queue<T, Container>& y)
|
||||
{
|
||||
return (x.c > y.c);
|
||||
}
|
||||
template <class T, class Container> _UCXXEXPORT bool
|
||||
operator>=(const queue<T, Container>& x, const queue<T, Container>& y)
|
||||
{
|
||||
return (x.c >= y.c);
|
||||
}
|
||||
template <class T, class Container> _UCXXEXPORT bool
|
||||
operator<=(const queue<T, Container>& x, const queue<T, Container>& y)
|
||||
{
|
||||
return (x.c <= y.c);
|
||||
}
|
||||
|
||||
|
||||
template <class T,
|
||||
class Container = vector<T>,
|
||||
class Compare = less<typename Container::value_type>
|
||||
> class _UCXXEXPORT priority_queue {
|
||||
protected:
|
||||
Container c;
|
||||
Compare comp;
|
||||
public:
|
||||
typedef typename Container::value_type value_type;
|
||||
typedef typename Container::size_type size_type;
|
||||
typedef Container container_type;
|
||||
|
||||
explicit priority_queue(const Compare& x = Compare(), const Container& a = Container())
|
||||
: c(a), comp(x) { make_heap(c.begin(), c.end(), comp) ; }
|
||||
template <class InputIterator> priority_queue(InputIterator first,
|
||||
InputIterator last,
|
||||
const Compare& x = Compare(),
|
||||
const Container& y= Container())
|
||||
: c(y), comp(c)
|
||||
{
|
||||
c.insert(c.end(), first, last);
|
||||
make_heap(c.begin(), c.end(), comp);
|
||||
}
|
||||
|
||||
bool empty() const { return c.empty(); }
|
||||
size_type size() const { return c.size(); }
|
||||
const value_type& top() const { return c.front(); }
|
||||
void push(const value_type& x){
|
||||
c.push_back(x);
|
||||
push_heap(c.begin(), c.end(), comp);
|
||||
}
|
||||
void pop(){
|
||||
pop_heap(c.begin(), c.end(), comp);
|
||||
c.pop_back();
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,406 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#include<memory>
|
||||
#include<utility>
|
||||
#include<iterator>
|
||||
#include <deque>
|
||||
#include<functional>
|
||||
#include <associative_base>
|
||||
|
||||
#ifndef __STD_HEADER_SET
|
||||
#define __STD_HEADER_SET
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
template<class Key, class Compare = less<Key>, class Allocator = allocator<Key> > class set;
|
||||
template<class Key, class Compare = less<Key>, class Allocator = allocator<Key> > class multiset;
|
||||
|
||||
|
||||
/* This is the implementation for the set container. As noted above, it deviates
|
||||
* from ISO spec by deriving from a base class in order to reduce code redundancy.
|
||||
* More code could be reduced by convirting to virtual functions (thus allowing
|
||||
* much of the erase and insert code to be duplicated), but that would deviate from
|
||||
* the specifications too much to be worth the risk.
|
||||
*/
|
||||
|
||||
|
||||
//Implementation of set
|
||||
|
||||
|
||||
template<class Key, class Compare, class Allocator> class _UCXXEXPORT set
|
||||
: public __single_associative<Key, Key, Compare, Allocator>
|
||||
{
|
||||
//Default value of allocator does not meet C++ standard specs, but it works for this library
|
||||
//Deal with it
|
||||
public:
|
||||
|
||||
typedef __single_associative<Key, Key, Compare, Allocator> base;
|
||||
typedef typename base::key_type key_type;
|
||||
typedef typename base::value_type value_type;
|
||||
typedef typename base::key_compare key_compare;
|
||||
typedef typename base::allocator_type allocator_type;
|
||||
typedef typename base::reference reference;
|
||||
typedef typename base::const_reference const_reference;
|
||||
typedef typename base::iterator iterator;
|
||||
typedef typename base::const_iterator const_iterator;
|
||||
typedef typename base::size_type size_type;
|
||||
typedef typename base::difference_type difference_type;
|
||||
typedef typename base::pointer pointer;
|
||||
typedef typename base::const_pointer const_pointer;
|
||||
typedef typename base::reverse_iterator reverse_iterator;
|
||||
typedef typename base::const_reverse_iterator const_reverse_iterator;
|
||||
|
||||
// using base::value_compare;
|
||||
|
||||
static const key_type v_t_k(const value_type v){
|
||||
return v;
|
||||
}
|
||||
|
||||
explicit set(const Compare& comp = Compare(), const Allocator& al = Allocator())
|
||||
: base(comp, al, v_t_k) { }
|
||||
|
||||
template <class InputIterator> set(InputIterator first, InputIterator last,
|
||||
const Compare& comp = Compare(), const Allocator& al = Allocator())
|
||||
: base(first, last, comp, al, v_t_k) { }
|
||||
|
||||
set(const set<Key, Compare,Allocator>& x) : base(x) { }
|
||||
~set() { }
|
||||
|
||||
using base::operator=;
|
||||
using base::operator==;
|
||||
using base::operator!=;
|
||||
|
||||
using base::insert;
|
||||
using base::erase;
|
||||
|
||||
using base::begin;
|
||||
using base::end;
|
||||
using base::rbegin;
|
||||
using base::rend;
|
||||
|
||||
using base::empty;
|
||||
using base::size;
|
||||
using base::max_size;
|
||||
|
||||
|
||||
using base::find;
|
||||
using base::count;
|
||||
using base::lower_bound;
|
||||
using base::upper_bound;
|
||||
using base::equal_range;
|
||||
|
||||
protected:
|
||||
|
||||
};
|
||||
|
||||
|
||||
//Implementation of multiset
|
||||
|
||||
|
||||
template<class Key, class Compare, class Allocator> class _UCXXEXPORT multiset
|
||||
: public __multi_associative<Key, Key, Compare, Allocator>
|
||||
{
|
||||
//Default value of allocator does not meet C++ standard specs, but it works for this library
|
||||
//Deal with it
|
||||
public:
|
||||
|
||||
typedef __multi_associative<Key, Key, Compare, Allocator> base;
|
||||
typedef typename base::key_type key_type;
|
||||
typedef typename base::value_type value_type;
|
||||
typedef typename base::key_compare key_compare;
|
||||
typedef typename base::allocator_type allocator_type;
|
||||
typedef typename base::reference reference;
|
||||
typedef typename base::const_reference const_reference;
|
||||
typedef typename base::iterator iterator;
|
||||
typedef typename base::const_iterator const_iterator;
|
||||
typedef typename base::size_type size_type;
|
||||
typedef typename base::difference_type difference_type;
|
||||
typedef typename base::pointer pointer;
|
||||
typedef typename base::const_pointer const_pointer;
|
||||
typedef typename base::reverse_iterator reverse_iterator;
|
||||
typedef typename base::const_reverse_iterator const_reverse_iterator;
|
||||
|
||||
static const key_type v_t_k(const value_type v){
|
||||
return v;
|
||||
}
|
||||
|
||||
explicit multiset(const Compare& comp = Compare(), const Allocator& al = Allocator())
|
||||
: base(comp, al, v_t_k) { }
|
||||
|
||||
template <class InputIterator> multiset(InputIterator first, InputIterator last,
|
||||
const Compare& comp = Compare(), const Allocator& al = Allocator())
|
||||
: base(first, last, comp, al, v_t_k) { }
|
||||
|
||||
|
||||
multiset(const multiset<Key, Compare, Allocator>& x) : base(x) { }
|
||||
~multiset() { }
|
||||
|
||||
using base::operator=;
|
||||
using base::operator==;
|
||||
using base::operator!=;
|
||||
|
||||
using base::insert;
|
||||
using base::erase;
|
||||
|
||||
using base::begin;
|
||||
using base::end;
|
||||
using base::rbegin;
|
||||
using base::rend;
|
||||
|
||||
using base::empty;
|
||||
using base::size;
|
||||
using base::max_size;
|
||||
|
||||
using base::find;
|
||||
using base::count;
|
||||
using base::lower_bound;
|
||||
using base::upper_bound;
|
||||
using base::equal_range;
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
};
|
||||
|
||||
|
||||
/* Non-member functions. These are at the end because they are not associated with any
|
||||
particular class. These will be implemented as I figure out exactly what all of
|
||||
them are supposed to do, and I have time.
|
||||
*/
|
||||
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<
|
||||
(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)
|
||||
{
|
||||
typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();
|
||||
typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();
|
||||
typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();
|
||||
typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();
|
||||
|
||||
while(first1 != last1 && first2 != last2){
|
||||
if( *first1 < *first2 ){
|
||||
return true;
|
||||
}
|
||||
if( *first2 < *first1 ){
|
||||
return false;
|
||||
}
|
||||
++first1;
|
||||
++first2;
|
||||
}
|
||||
return first1==last1 && first2 != last2;
|
||||
}
|
||||
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>
|
||||
(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)
|
||||
{
|
||||
typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();
|
||||
typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();
|
||||
typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();
|
||||
typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();
|
||||
|
||||
while(first1 != last1 && first2 != last2){
|
||||
if( *first1 > *first2 ){
|
||||
return true;
|
||||
}
|
||||
if( *first2 > *first1 ){
|
||||
return false;
|
||||
}
|
||||
++first1;
|
||||
++first2;
|
||||
}
|
||||
return first1!=last1 && first2 == last2;
|
||||
}
|
||||
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>=
|
||||
(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)
|
||||
{
|
||||
typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();
|
||||
typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();
|
||||
typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();
|
||||
typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();
|
||||
|
||||
while(first1 != last1 && first2 != last2){
|
||||
if( *first1 > *first2 ){
|
||||
return true;
|
||||
}
|
||||
if( *first2 > *first1 ){
|
||||
return false;
|
||||
}
|
||||
++first1;
|
||||
++first2;
|
||||
}
|
||||
return first1!=last1;
|
||||
}
|
||||
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<=
|
||||
(const set<Key,Compare,Allocator>& x, const set<Key,Compare,Allocator>& y)
|
||||
{
|
||||
typename set<Key,Compare,Allocator>::const_iterator first1 = x.begin();
|
||||
typename set<Key,Compare,Allocator>::const_iterator first2 = y.begin();
|
||||
typename set<Key,Compare,Allocator>::const_iterator last1 = x.end();
|
||||
typename set<Key,Compare,Allocator>::const_iterator last2 = y.end();
|
||||
|
||||
while(first1 != last1 && first2 != last2){
|
||||
if( *first1 < *first2 ){
|
||||
return true;
|
||||
}
|
||||
if( *first2 < *first1 ){
|
||||
return false;
|
||||
}
|
||||
++first1;
|
||||
++first2;
|
||||
}
|
||||
return first2!=last2;
|
||||
}
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT void swap
|
||||
(set<Key,Compare,Allocator>& x, set<Key,Compare,Allocator>& y)
|
||||
{
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator==
|
||||
(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
|
||||
{
|
||||
if(x.data == y.data){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<
|
||||
(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
|
||||
{
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();
|
||||
|
||||
while(first1 != last1 && first2 != last2){
|
||||
if( *first1 < *first2 ){
|
||||
return true;
|
||||
}
|
||||
if( *first2 < *first1 ){
|
||||
return false;
|
||||
}
|
||||
++first1;
|
||||
++first2;
|
||||
}
|
||||
return first1==last1 && first2 != last2;
|
||||
}
|
||||
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator!=
|
||||
(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
|
||||
{
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();
|
||||
|
||||
while(first1 != last1 && first2 != last2){
|
||||
if( *first1 != *first2 ){
|
||||
return true;
|
||||
}
|
||||
++first1;
|
||||
++first2;
|
||||
}
|
||||
return first1!=last1 || first2 != last2;
|
||||
}
|
||||
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>
|
||||
(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
|
||||
{
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();
|
||||
|
||||
while(first1 != last1 && first2 != last2){
|
||||
if( *first1 > *first2 ){
|
||||
return true;
|
||||
}
|
||||
if( *first2 > *first1 ){
|
||||
return false;
|
||||
}
|
||||
++first1;
|
||||
++first2;
|
||||
}
|
||||
return first1!=last1 && first2 == last2;
|
||||
}
|
||||
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator>=
|
||||
(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
|
||||
{
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();
|
||||
|
||||
while(first1 != last1 && first2 != last2){
|
||||
if( *first1 > *first2 ){
|
||||
return true;
|
||||
}
|
||||
if( *first2 > *first1 ){
|
||||
return false;
|
||||
}
|
||||
++first1;
|
||||
++first2;
|
||||
}
|
||||
return first1!=last1;
|
||||
}
|
||||
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT bool operator<=
|
||||
(const multiset<Key,Compare,Allocator>& x, const multiset<Key,Compare,Allocator>& y)
|
||||
{
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator first1 = x.begin();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator first2 = y.begin();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator last1 = x.end();
|
||||
typename multiset<Key,Compare,Allocator>::const_iterator last2 = y.end();
|
||||
|
||||
while(first1 != last1 && first2 != last2){
|
||||
if( *first1 < *first2 ){
|
||||
return true;
|
||||
}
|
||||
if( *first2 < *first1 ){
|
||||
return false;
|
||||
}
|
||||
++first1;
|
||||
++first2;
|
||||
}
|
||||
return first2!=last2;
|
||||
}
|
||||
|
||||
template <class Key, class Compare, class Allocator> _UCXXEXPORT void swap
|
||||
(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>& y)
|
||||
{
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,384 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
|
||||
#ifndef HEADER_STD_SSTREAM
|
||||
#define HEADER_STD_SSTREAM 1
|
||||
|
||||
#include <iosfwd>
|
||||
#include <ios>
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
class _UCXXEXPORT basic_stringbuf : public basic_streambuf<charT,traits>
|
||||
{
|
||||
public:
|
||||
typedef charT char_type;
|
||||
typedef typename traits::int_type int_type;
|
||||
typedef typename traits::pos_type pos_type;
|
||||
typedef typename traits::off_type off_type;
|
||||
typedef typename Allocator::size_type size_type;
|
||||
|
||||
explicit _UCXXEXPORT basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out)
|
||||
: data(), ielement(0), oelement(0)
|
||||
{
|
||||
basic_streambuf<charT,traits>::openedFor = which;
|
||||
}
|
||||
|
||||
explicit _UCXXEXPORT basic_stringbuf(const basic_string<charT,traits,Allocator>& str,
|
||||
ios_base::openmode which = ios_base::in | ios_base::out)
|
||||
: data(str), ielement(0), oelement(0)
|
||||
{
|
||||
if(which & ios_base::ate){
|
||||
oelement = data.length();
|
||||
}
|
||||
basic_streambuf<charT,traits>::openedFor = which;
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT ~basic_stringbuf() { }
|
||||
|
||||
_UCXXEXPORT basic_string<charT,traits,Allocator> str() const{
|
||||
return data;
|
||||
}
|
||||
|
||||
_UCXXEXPORT void str(const basic_string<charT,traits,Allocator>& s){
|
||||
data = s;
|
||||
ielement = 0;
|
||||
if(basic_streambuf<charT,traits>::openedFor & ios_base::ate){
|
||||
oelement = data.length();
|
||||
}else{
|
||||
oelement = 0;
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual _UCXXEXPORT int sync(){
|
||||
return 0;
|
||||
}
|
||||
virtual _UCXXEXPORT int_type underflow(){
|
||||
if(ielement >= data.length()){
|
||||
return traits::eof();
|
||||
}
|
||||
return traits::to_int_type(data[ielement]);
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT int_type uflow(){
|
||||
int_type retval = underflow();
|
||||
if(retval != traits::eof()){
|
||||
++ielement;
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT int_type pbackfail(int_type c = traits::eof()){
|
||||
//Error possibilities
|
||||
if(ielement == 0){
|
||||
return traits::eof();
|
||||
}
|
||||
if(ielement > data.length()){
|
||||
ielement = data.length();
|
||||
return traits::eof();
|
||||
}
|
||||
//eof passed in
|
||||
if(traits::eq_int_type(c,traits::eof())==true){
|
||||
--ielement;
|
||||
return traits::not_eof(c);
|
||||
}
|
||||
if(traits::eq(traits::to_char_type(c),data[ielement-1]) == true){
|
||||
--ielement;
|
||||
return c;
|
||||
}
|
||||
if(basic_streambuf<charT,traits>::openedFor & ios_base::out){
|
||||
--ielement;
|
||||
data[ielement] = c;
|
||||
return c;
|
||||
}
|
||||
return traits::eof();
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT int showmanyc(){
|
||||
return data.length() - ielement;
|
||||
}
|
||||
virtual _UCXXEXPORT streamsize xsgetn(char_type* c, streamsize n){
|
||||
streamsize i = 0;
|
||||
while(ielement < data.length() && i < n ){
|
||||
c[i] = data[ielement];
|
||||
++i;
|
||||
++ielement;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT int_type overflow (int_type c = traits::eof()){
|
||||
//Nothing to do
|
||||
if(traits::eq_int_type(c,traits::eof())){
|
||||
return traits::not_eof(c);
|
||||
}
|
||||
|
||||
//Actually add character, if possible
|
||||
if(basic_streambuf<charT,traits>::openedFor & ios_base::out){
|
||||
if(oelement >= data.length()){
|
||||
data.push_back(c);
|
||||
}else{
|
||||
data[oelement] = c;
|
||||
}
|
||||
++oelement;
|
||||
return c;
|
||||
}
|
||||
//Not possible
|
||||
return traits::eof();
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT basic_streambuf<charT,traits>* setbuf(charT*, streamsize){
|
||||
//This function does nothing
|
||||
return this;
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT streamsize xsputn(const char_type* s, streamsize n){
|
||||
data.replace(oelement, n, s, n);
|
||||
oelement += n;
|
||||
return n;
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT pos_type seekoff(off_type off, ios_base::seekdir way,
|
||||
ios_base::openmode which = ios_base::in | ios_base::out)
|
||||
{
|
||||
//Test for invalid option
|
||||
if( (which & ios_base::in) && (which & ios_base::out) && (way == ios_base::cur)){
|
||||
return -1;
|
||||
}
|
||||
|
||||
//Calculate new location
|
||||
size_type newpos = 0;
|
||||
|
||||
if(way == ios_base::beg){
|
||||
newpos = off;
|
||||
}else if(way == ios_base::cur){
|
||||
if(which & ios_base::out){
|
||||
newpos = data.length() + off;
|
||||
}
|
||||
if(which & ios_base::in){
|
||||
newpos = ielement + off;
|
||||
}
|
||||
|
||||
}else{
|
||||
newpos = data.length() + off;
|
||||
}
|
||||
|
||||
//Test for error conditions
|
||||
if(newpos > data.length()){
|
||||
return -1;
|
||||
}
|
||||
|
||||
//Shuffle pointers
|
||||
|
||||
if(which & ios_base::in){
|
||||
ielement = newpos;
|
||||
}
|
||||
if(which & ios_base::out){
|
||||
data.resize(newpos);
|
||||
if(ielement > data.length()){
|
||||
ielement = data.length();
|
||||
}
|
||||
}
|
||||
|
||||
return newpos;
|
||||
}
|
||||
|
||||
virtual _UCXXEXPORT pos_type seekpos(pos_type sp,
|
||||
ios_base::openmode which = ios_base::in | ios_base::out)
|
||||
{
|
||||
return seekoff(sp, ios_base::beg, which);
|
||||
}
|
||||
|
||||
basic_string<charT,traits,Allocator> data;
|
||||
size_type ielement;
|
||||
size_type oelement;
|
||||
};
|
||||
|
||||
|
||||
template <class charT, class traits, class Allocator> class _UCXXEXPORT basic_istringstream
|
||||
: public basic_istream<charT,traits>
|
||||
{
|
||||
public:
|
||||
typedef charT char_type;
|
||||
typedef typename traits::int_type int_type;
|
||||
typedef typename traits::pos_type pos_type;
|
||||
typedef typename traits::off_type off_type;
|
||||
|
||||
|
||||
explicit _UCXXEXPORT basic_istringstream(ios_base::openmode m = ios_base::in)
|
||||
: basic_ios<charT, traits>(&sb), basic_istream<charT,traits>(&sb), sb(m)
|
||||
{
|
||||
}
|
||||
explicit _UCXXEXPORT basic_istringstream( const basic_string<charT,traits,Allocator>& str,
|
||||
ios_base::openmode which = ios_base::in)
|
||||
: basic_ios<charT, traits>(&sb), basic_istream<charT,traits>(&sb), sb(str, which)
|
||||
{
|
||||
}
|
||||
virtual _UCXXEXPORT ~basic_istringstream() { }
|
||||
_UCXXEXPORT basic_stringbuf<charT,traits,Allocator>* rdbuf() const{
|
||||
return &sb;
|
||||
}
|
||||
_UCXXEXPORT basic_string<charT,traits,Allocator> str() const{
|
||||
return sb.str();
|
||||
}
|
||||
_UCXXEXPORT void str(const basic_string<charT,traits,Allocator>& s){
|
||||
sb.str(s);
|
||||
basic_istream<charT,traits>::clear();
|
||||
}
|
||||
private:
|
||||
basic_stringbuf<charT,traits,Allocator> sb;
|
||||
};
|
||||
|
||||
|
||||
template <class charT, class traits, class Allocator> class _UCXXEXPORT basic_ostringstream
|
||||
: public basic_ostream<charT,traits>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef charT char_type;
|
||||
typedef typename traits::int_type int_type;
|
||||
typedef typename traits::pos_type pos_type;
|
||||
typedef typename traits::off_type off_type;
|
||||
|
||||
explicit _UCXXEXPORT basic_ostringstream(ios_base::openmode m = ios_base::out)
|
||||
: basic_ios<charT, traits>(&sb), basic_ostream<charT,traits>(&sb), sb(m)
|
||||
{
|
||||
}
|
||||
explicit _UCXXEXPORT basic_ostringstream(const basic_string<charT,traits,Allocator>& str,
|
||||
ios_base::openmode which = ios_base::out)
|
||||
: basic_ios<charT, traits>(&sb), basic_ostream<charT,traits>(&sb), sb(str, which)
|
||||
{
|
||||
}
|
||||
virtual _UCXXEXPORT ~basic_ostringstream() { }
|
||||
|
||||
_UCXXEXPORT basic_stringbuf<charT,traits,Allocator>* rdbuf() const{
|
||||
return &sb;
|
||||
}
|
||||
_UCXXEXPORT basic_string<charT,traits,Allocator> str() const{
|
||||
return sb.str();
|
||||
}
|
||||
_UCXXEXPORT void str(const basic_string<charT,traits,Allocator>& s){
|
||||
sb.str(s);
|
||||
basic_ostream<charT,traits>::clear();
|
||||
}
|
||||
private:
|
||||
basic_stringbuf<charT,traits,Allocator> sb;
|
||||
};
|
||||
|
||||
|
||||
template <class charT, class traits, class Allocator> class _UCXXEXPORT basic_stringstream
|
||||
: public basic_iostream<charT,traits>
|
||||
{
|
||||
public:
|
||||
|
||||
typedef charT char_type;
|
||||
typedef typename traits::int_type int_type;
|
||||
typedef typename traits::pos_type pos_type;
|
||||
typedef typename traits::off_type off_type;
|
||||
|
||||
explicit _UCXXEXPORT basic_stringstream(ios_base::openmode which = ios_base::out|ios_base::in)
|
||||
: basic_ios<charT, traits>(&sb), basic_iostream<charT,traits>(&sb), sb(which)
|
||||
{
|
||||
}
|
||||
|
||||
explicit _UCXXEXPORT basic_stringstream(const basic_string<charT,traits,Allocator>& str,
|
||||
ios_base::openmode which = ios_base::out|ios_base::in)
|
||||
: basic_ios<charT, traits>(&sb), basic_iostream<charT,traits>(&sb), sb(str, which)
|
||||
{
|
||||
}
|
||||
virtual _UCXXEXPORT ~basic_stringstream(){ }
|
||||
|
||||
_UCXXEXPORT basic_stringbuf<charT,traits,Allocator>* rdbuf(){
|
||||
return &sb;
|
||||
}
|
||||
_UCXXEXPORT basic_string<charT,traits,Allocator> str() const{
|
||||
return sb.str();
|
||||
}
|
||||
_UCXXEXPORT void str(const basic_string<charT,traits,Allocator>& s){
|
||||
sb.str(s);
|
||||
basic_iostream<charT,traits>::clear();
|
||||
}
|
||||
private:
|
||||
basic_stringbuf<charT, traits> sb;
|
||||
};
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_SSTREAM_CHAR__
|
||||
#ifndef __UCLIBCXX_COMPILE_SSTREAM__
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::
|
||||
basic_stringbuf(ios_base::openmode which);
|
||||
template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::~basic_stringbuf();
|
||||
|
||||
#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template <> _UCXXEXPORT basic_string<char, char_traits<char>, allocator<char> >
|
||||
basic_stringbuf<char, char_traits<char>, allocator<char> >::str() const;
|
||||
|
||||
template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::int_type
|
||||
basic_stringbuf<char, char_traits<char>, allocator<char> >::
|
||||
pbackfail(basic_stringbuf<char, char_traits<char>, allocator<char> >::int_type c);
|
||||
|
||||
template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::pos_type
|
||||
basic_stringbuf<char, char_traits<char>, allocator<char> >::
|
||||
seekoff (basic_stringbuf<char, char_traits<char>, allocator<char> >::off_type off,
|
||||
ios_base::seekdir way,
|
||||
ios_base::openmode which
|
||||
);
|
||||
|
||||
template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::int_type
|
||||
basic_stringbuf<char, char_traits<char>, allocator<char> >::
|
||||
overflow (basic_stringbuf<char, char_traits<char>, allocator<char> >::int_type c);
|
||||
|
||||
template <> _UCXXEXPORT basic_stringbuf<char, char_traits<char>, allocator<char> >::int_type
|
||||
basic_stringbuf<char, char_traits<char>, allocator<char> >::underflow ();
|
||||
|
||||
template <> _UCXXEXPORT streamsize basic_stringbuf<char, char_traits<char>, allocator<char> >::
|
||||
xsputn(const char* s, streamsize n);
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template <> _UCXXEXPORT basic_stringstream<char, char_traits<char>, allocator<char> >::
|
||||
basic_stringstream(ios_base::openmode which);
|
||||
template <> _UCXXEXPORT basic_stringstream<char, char_traits<char>, allocator<char> >::~basic_stringstream();
|
||||
template <> _UCXXEXPORT basic_istringstream<char, char_traits<char>, allocator<char> >::~basic_istringstream();
|
||||
template <> _UCXXEXPORT basic_ostringstream<char, char_traits<char>, allocator<char> >::~basic_ostringstream();
|
||||
|
||||
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <deque>
|
||||
|
||||
#ifndef __HEADER_STD_STACK
|
||||
#define __HEADER_STD_STACK 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
template <class T, class Container = deque<T> > class _UCXXEXPORT stack{
|
||||
protected:
|
||||
Container c;
|
||||
|
||||
public:
|
||||
typedef typename Container::value_type value_type;
|
||||
typedef typename Container::size_type size_type;
|
||||
typedef Container container_type;
|
||||
|
||||
explicit stack(const Container& a = Container()) : c(a) { };
|
||||
bool empty() const { return c.empty(); }
|
||||
size_type size() const { return c.size(); }
|
||||
value_type& top() { return c.back(); }
|
||||
const value_type& top() const { return c.back(); }
|
||||
void push(const value_type& x) { c.push_back(x); }
|
||||
void pop() { c.pop_back(); }
|
||||
|
||||
bool operator==(const stack<T, Container> &x) const{
|
||||
return x.c == c;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
template <class T, class Container> _UCXXEXPORT bool
|
||||
operator< (const stack<T, Container>& x, const stack<T, Container>& y)
|
||||
{
|
||||
return (x.c < y.c);
|
||||
}
|
||||
template <class T, class Container> _UCXXEXPORT bool
|
||||
operator!=(const stack<T, Container>& x, const stack<T, Container>& y)
|
||||
{
|
||||
return (x.c != y.c);
|
||||
}
|
||||
template <class T, class Container> _UCXXEXPORT bool
|
||||
operator> (const stack<T, Container>& x, const stack<T, Container>& y)
|
||||
{
|
||||
return (x.c > y.c);
|
||||
}
|
||||
template <class T, class Container> _UCXXEXPORT bool
|
||||
operator>=(const stack<T, Container>& x, const stack<T, Container>& y)
|
||||
{
|
||||
return (x.c >= y.c);
|
||||
}
|
||||
template <class T, class Container> _UCXXEXPORT bool
|
||||
operator<=(const stack<T, Container>& x, const stack<T, Container>& y)
|
||||
{
|
||||
return (x.c <= y.c);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <exception>
|
||||
#include <string>
|
||||
|
||||
#ifndef HEADER_STD_EXCEPTIONS
|
||||
#define HEADER_STD_EXCEPTIONS 1
|
||||
|
||||
//Don't include support if not needed
|
||||
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
//typedef basic_string<char> string;
|
||||
|
||||
class _UCXXEXPORT logic_error : public exception {
|
||||
protected:
|
||||
string mstring;
|
||||
public:
|
||||
logic_error() throw();
|
||||
logic_error(const string& what_arg);
|
||||
|
||||
virtual ~logic_error() throw() {}
|
||||
virtual const char * what() const throw();
|
||||
|
||||
};
|
||||
|
||||
class _UCXXEXPORT domain_error : public logic_error {
|
||||
public:
|
||||
domain_error() : logic_error() {}
|
||||
domain_error(const string& what_arg) : logic_error(what_arg) {}
|
||||
virtual ~domain_error() throw() {}
|
||||
};
|
||||
|
||||
class _UCXXEXPORT invalid_argument : public logic_error {
|
||||
public:
|
||||
invalid_argument() : logic_error(){}
|
||||
invalid_argument(const string& what_arg) : logic_error(what_arg){}
|
||||
virtual ~invalid_argument() throw() {}
|
||||
};
|
||||
|
||||
class _UCXXEXPORT length_error : public logic_error {
|
||||
public:
|
||||
length_error() : logic_error(){}
|
||||
length_error(const string& what_arg) : logic_error(what_arg){}
|
||||
virtual ~length_error() throw() {}
|
||||
};
|
||||
|
||||
class _UCXXEXPORT out_of_range : public logic_error{
|
||||
public:
|
||||
out_of_range();
|
||||
out_of_range(const string & what_arg);
|
||||
virtual ~out_of_range() throw() {}
|
||||
|
||||
};
|
||||
|
||||
class _UCXXEXPORT runtime_error : public exception{
|
||||
protected:
|
||||
string mstring;
|
||||
public:
|
||||
runtime_error();
|
||||
runtime_error(const string& what_arg);
|
||||
|
||||
virtual ~runtime_error() throw() {}
|
||||
virtual const char * what() const throw();
|
||||
};
|
||||
|
||||
class _UCXXEXPORT range_error : public runtime_error{
|
||||
public:
|
||||
range_error() : runtime_error(){}
|
||||
range_error(const string& what_arg) : runtime_error(what_arg) {}
|
||||
virtual ~range_error() throw(){ }
|
||||
};
|
||||
|
||||
|
||||
class _UCXXEXPORT overflow_error : public runtime_error{
|
||||
public:
|
||||
overflow_error() : runtime_error(){}
|
||||
overflow_error(const string& what_arg) : runtime_error(what_arg) {}
|
||||
virtual ~overflow_error() throw(){}
|
||||
};
|
||||
|
||||
class _UCXXEXPORT underflow_error : public runtime_error{
|
||||
public:
|
||||
underflow_error() : runtime_error(){}
|
||||
underflow_error(const string& what_arg) : runtime_error(what_arg) {}
|
||||
virtual ~underflow_error() throw(){}
|
||||
};
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
@ -0,0 +1,329 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <locale>
|
||||
#include <string>
|
||||
#include <iosfwd>
|
||||
|
||||
#ifndef HEADER_STD_STREAMBUF
|
||||
#define HEADER_STD_STREAMBUF 1
|
||||
|
||||
#include <ios>
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
template <class charT, class traits> class _UCXXEXPORT basic_streambuf{
|
||||
public:
|
||||
#ifdef __UCLIBCXX_SUPPORT_CDIR__
|
||||
friend ios_base::Init::Init();
|
||||
#endif
|
||||
// Types:
|
||||
typedef charT char_type;
|
||||
typedef typename traits::int_type int_type;
|
||||
typedef typename traits::pos_type pos_type;
|
||||
typedef typename traits::off_type off_type;
|
||||
typedef traits traits_type;
|
||||
|
||||
virtual ~basic_streambuf();
|
||||
|
||||
locale pubimbue(const locale &loc);
|
||||
|
||||
locale getloc() const{
|
||||
return myLocale;
|
||||
}
|
||||
|
||||
basic_streambuf<char_type,traits>* pubsetbuf(char_type* s, streamsize n){
|
||||
return setbuf(s,n);
|
||||
}
|
||||
pos_type pubseekoff(off_type off,
|
||||
typename ios_base::seekdir way,
|
||||
ios_base::openmode which = ios_base::in |
|
||||
ios_base::out
|
||||
)
|
||||
{
|
||||
return seekoff(off,way,which);
|
||||
}
|
||||
pos_type pubseekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out){
|
||||
return seekpos(sp,which);
|
||||
}
|
||||
int pubsync(){
|
||||
return sync();
|
||||
}
|
||||
|
||||
streamsize in_avail();
|
||||
|
||||
int_type snextc();
|
||||
|
||||
int_type sbumpc();
|
||||
|
||||
int_type sgetc();
|
||||
|
||||
streamsize sgetn(char_type* s, streamsize n){
|
||||
return xsgetn(s,n);
|
||||
}
|
||||
|
||||
int_type sputbackc(char_type c);
|
||||
|
||||
int_type sungetc();
|
||||
|
||||
int_type sputc(char_type c);
|
||||
|
||||
streamsize sputn(const char_type* s, streamsize n){
|
||||
if(openedFor & ios_base::app){
|
||||
seekoff(0, ios_base::end, ios_base::out);
|
||||
}
|
||||
return xsputn(s, n);
|
||||
}
|
||||
|
||||
protected:
|
||||
locale myLocale;
|
||||
//Pointers for the "get" buffers
|
||||
charT * mgbeg;
|
||||
charT * mgnext;
|
||||
charT * mgend;
|
||||
|
||||
//Pointers for the "put" buffers
|
||||
charT * mpbeg;
|
||||
charT * mpnext;
|
||||
charT * mpend;
|
||||
|
||||
//In the event of null buffers Lets us know what the buffer is opened for
|
||||
ios_base::openmode openedFor;
|
||||
|
||||
basic_streambuf();
|
||||
|
||||
basic_streambuf(const basic_streambuf<char, char_traits<char> > &)
|
||||
: myLocale(),
|
||||
mgbeg(0), mgnext(0), mgend(0), mpbeg(0), mpnext(0), mpend(0),
|
||||
openedFor(0)
|
||||
{ }
|
||||
basic_streambuf<char, char_traits<char> > & operator=(const basic_streambuf<char, char_traits<char> > &){
|
||||
return *this;
|
||||
}
|
||||
|
||||
char_type* eback() const{
|
||||
return mgbeg;
|
||||
}
|
||||
char_type* gptr() const{
|
||||
return mgnext;
|
||||
}
|
||||
char_type* egptr() const{
|
||||
return mgend;
|
||||
}
|
||||
void gbump(int n){
|
||||
mgnext+=n;
|
||||
}
|
||||
void setg(char_type* gbeg, char_type* gnext, char_type* gend){
|
||||
mgbeg = gbeg;
|
||||
mgnext = gnext;
|
||||
mgend = gend;
|
||||
}
|
||||
|
||||
char_type* pbase() const{
|
||||
return mpbeg;
|
||||
}
|
||||
char_type* pptr() const{
|
||||
return mpnext;
|
||||
}
|
||||
char_type* epptr() const{
|
||||
return mpend;
|
||||
}
|
||||
void pbump(int n){
|
||||
mpnext+=n;
|
||||
}
|
||||
void setp(char_type* pbeg, char_type* pend){
|
||||
mpbeg = pbeg;
|
||||
mpnext = pbeg;
|
||||
mpend = pend;
|
||||
}
|
||||
|
||||
virtual void imbue(const locale &loc){
|
||||
myLocale = loc;
|
||||
}
|
||||
|
||||
//Virtual functions which we will not implement
|
||||
|
||||
virtual basic_streambuf<char_type,traits>* setbuf(char_type* , streamsize){
|
||||
return 0;
|
||||
}
|
||||
virtual pos_type seekoff(off_type , ios_base::seekdir,
|
||||
ios_base::openmode = ios_base::in | ios_base::out)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
virtual pos_type seekpos(pos_type , ios_base::openmode = ios_base::in | ios_base::out){
|
||||
return 0;
|
||||
}
|
||||
virtual int sync(){
|
||||
return 0;
|
||||
}
|
||||
|
||||
virtual int showmanyc(){
|
||||
return 0;
|
||||
}
|
||||
virtual streamsize xsgetn(char_type* , streamsize ){
|
||||
return 0;
|
||||
}
|
||||
virtual int_type underflow(){
|
||||
return traits_type::eof();
|
||||
}
|
||||
virtual int_type uflow(){
|
||||
int_type ret = underflow();
|
||||
if (!traits_type::eq_int_type(ret, traits_type::eof()))
|
||||
gbump(1);
|
||||
return ret;
|
||||
}
|
||||
|
||||
virtual int_type pbackfail(int_type c = traits::eof()){
|
||||
return c;
|
||||
}
|
||||
virtual streamsize xsputn(const char_type* c, streamsize n){
|
||||
//This function is designed to be replaced by subclasses
|
||||
for(streamsize i = 0; i< n; ++i){
|
||||
if(sputc(c[i]) == traits::eof()){
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return n;
|
||||
}
|
||||
virtual int_type overflow (int_type c = traits::eof()){
|
||||
return c;
|
||||
}
|
||||
};
|
||||
|
||||
typedef basic_streambuf<char> streambuf;
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
typedef basic_streambuf<wchar_t> wstreambuf;
|
||||
#endif
|
||||
|
||||
|
||||
//Definitions put below to allow for easy expansion of code
|
||||
|
||||
template <class C, class T> basic_streambuf<C, T>::~basic_streambuf(){ }
|
||||
|
||||
template <class C, class T> locale basic_streambuf<C, T>::pubimbue(const locale &loc){
|
||||
locale temp = myLocale;
|
||||
myLocale = loc;
|
||||
return temp;
|
||||
}
|
||||
|
||||
template <class C, class T> streamsize basic_streambuf<C, T>::in_avail(){
|
||||
if(mgend !=0 && mgnext !=0){
|
||||
return mgend - mgnext;
|
||||
}
|
||||
return showmanyc();
|
||||
}
|
||||
|
||||
template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::sbumpc(){
|
||||
if(mgbeg == 0 || mgnext == mgend){
|
||||
return uflow();
|
||||
}
|
||||
int_type retval = T::to_int_type(*gptr());
|
||||
gbump(1);
|
||||
return retval;
|
||||
}
|
||||
|
||||
template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::snextc(){
|
||||
if(sbumpc() == T::eof() ){
|
||||
return T::eof() ;
|
||||
}
|
||||
return sgetc();
|
||||
}
|
||||
|
||||
template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::sgetc(){
|
||||
if(mgbeg == 0 || mgnext == mgend){
|
||||
return underflow();
|
||||
}
|
||||
return T::to_int_type(*gptr());
|
||||
}
|
||||
|
||||
template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::sputbackc(char_type c){
|
||||
if(mgbeg == 0 || mgnext == mgbeg || !T::eq(c, gptr()[-1] )){
|
||||
return pbackfail(T::to_int_type(c));
|
||||
}
|
||||
gbump(-1);
|
||||
return T::to_int_type(*gptr());
|
||||
}
|
||||
|
||||
template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::sungetc(){
|
||||
if(mgbeg == 0 || mgnext == mgbeg){
|
||||
return ios_base::failbit;
|
||||
}
|
||||
gbump(-1);
|
||||
return T::to_int_type(*gptr());
|
||||
}
|
||||
|
||||
template <class C, class T> typename basic_streambuf<C, T>::int_type basic_streambuf<C, T>::sputc(char_type c){
|
||||
if(openedFor & ios_base::app){
|
||||
seekoff(0, ios_base::end, ios_base::out);
|
||||
}
|
||||
if(mpnext < mpend){
|
||||
*mpnext = c;
|
||||
++mpnext;
|
||||
}else{
|
||||
return overflow( T::to_int_type(c) );
|
||||
}
|
||||
return T::to_int_type(c);
|
||||
}
|
||||
|
||||
template <class C, class T> basic_streambuf<C, T>::basic_streambuf()
|
||||
: myLocale(),
|
||||
mgbeg(0), mgnext(0), mgend(0), mpbeg(0), mpnext(0), mpend(0),
|
||||
openedFor(0)
|
||||
{ }
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_STREAMBUF_CHAR__
|
||||
#ifndef __UCLIBCXX_COMPILE_STREAMBUF__
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template <> _UCXXEXPORT streambuf::basic_streambuf();
|
||||
template <> _UCXXEXPORT streambuf::~basic_streambuf();
|
||||
|
||||
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template <> _UCXXEXPORT locale streambuf::pubimbue(const locale &loc);
|
||||
template <> _UCXXEXPORT streamsize streambuf::in_avail();
|
||||
template <> _UCXXEXPORT streambuf::int_type streambuf::sbumpc();
|
||||
template <> _UCXXEXPORT streambuf::int_type streambuf::snextc();
|
||||
template <> _UCXXEXPORT streambuf::int_type streambuf::sgetc();
|
||||
template <> _UCXXEXPORT streambuf::int_type streambuf::sputbackc(char_type c);
|
||||
template <> _UCXXEXPORT streambuf::int_type streambuf::sungetc();
|
||||
template <> _UCXXEXPORT streambuf::int_type streambuf::sputc(char_type c);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,146 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
#include <string>
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
#include <cwchar>
|
||||
#include <cwctype>
|
||||
#endif
|
||||
|
||||
#ifndef __HEADER_STD_STRING_IOSTREAM
|
||||
#define __HEADER_STD_STRING_IOSTREAM 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
template<class charT, class traits, class Allocator> _UCXXEXPORT basic_ostream<charT, traits>&
|
||||
operator<<(basic_ostream<charT, traits>& os, const basic_string<charT,traits,Allocator>& str)
|
||||
{
|
||||
return os.write(str.data(), str.length());
|
||||
}
|
||||
|
||||
template<class charT, class traits, class Allocator> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
operator>>(basic_istream<charT,traits>& is, basic_string<charT,traits,Allocator>& str)
|
||||
{
|
||||
|
||||
typename basic_istream<charT, traits>::sentry s(is);
|
||||
if(s == false){
|
||||
return is;
|
||||
}
|
||||
|
||||
str.clear();
|
||||
|
||||
typename basic_istream<charT, traits>::int_type c;
|
||||
typename Allocator::size_type n = is.width();
|
||||
bool exitnow = false;
|
||||
if(n == 0){
|
||||
n = str.max_size();
|
||||
}
|
||||
|
||||
// //Clear out preliminary spaces first
|
||||
// c = is.get();
|
||||
// while(isspace(c)){
|
||||
// c = is.get();
|
||||
// }
|
||||
//
|
||||
// is.putback(c);
|
||||
|
||||
do{
|
||||
c = is.get();
|
||||
if(c == traits::eof() || isspace(c) || n == 0){
|
||||
is.putback(c);
|
||||
exitnow = true;
|
||||
}else{
|
||||
str.append(1, traits::to_char_type(c) );
|
||||
--n;
|
||||
}
|
||||
}while(exitnow == false);
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class charT, class traits, class Allocator> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
getline(basic_istream<charT,traits>& is, basic_string<charT,traits,Allocator>& str, charT delim)
|
||||
{
|
||||
typename basic_istream<charT,traits>::sentry s(is);
|
||||
if(s == false){
|
||||
return is;
|
||||
}
|
||||
|
||||
str.erase();
|
||||
|
||||
streamsize i = 0;
|
||||
typename basic_istream<charT,traits>::int_type c_i;
|
||||
charT c;
|
||||
unsigned int n = str.max_size();
|
||||
for(i=0;i<n;++i){
|
||||
c_i=is.get();
|
||||
if(c_i == traits::eof() ){
|
||||
return is;
|
||||
}
|
||||
c = traits::to_char_type(c_i);
|
||||
if(c == delim){
|
||||
return is;
|
||||
}
|
||||
str.append(1, c);
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
template<class charT, class traits, class Allocator> _UCXXEXPORT basic_istream<charT,traits>&
|
||||
getline(basic_istream<charT,traits>& is, basic_string<charT,traits,Allocator>& str)
|
||||
{
|
||||
return getline(is, str, '\n');
|
||||
}
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_STRING_CHAR__
|
||||
#ifndef __UCLIBCXX_COMPILE_STRING__
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
|
||||
template<> _UCXXEXPORT basic_istream<char, char_traits<char> >& operator>>(
|
||||
basic_istream<char,char_traits<char> >& is,
|
||||
basic_string<char, char_traits<char>, allocator<char> >& str);
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
|
||||
template<> _UCXXEXPORT basic_ostream<char, char_traits<char> >&
|
||||
operator<<(basic_ostream<char, char_traits<char> >& os,
|
||||
const basic_string<char,char_traits<char>, std::allocator<char> >& str);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,165 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <exception>
|
||||
#include <cstdlib>
|
||||
#include <typeinfo>
|
||||
|
||||
#ifndef HEADER_ULC_SUPPORT
|
||||
#define HEADER_ULC_SUPPORT 1
|
||||
|
||||
using namespace std;
|
||||
|
||||
//From C++ ABI spec
|
||||
typedef enum {
|
||||
_URC_NO_REASON = 0,
|
||||
_URC_FOREIGN_EXCEPTION_CAUGHT = 1,
|
||||
_URC_FATAL_PHASE2_ERROR = 2,
|
||||
_URC_FATAL_PHASE1_ERROR = 3,
|
||||
_URC_NORMAL_STOP = 4,
|
||||
_URC_END_OF_STACK = 5,
|
||||
_URC_HANDLER_FOUND = 6,
|
||||
_URC_INSTALL_CONTEXT = 7,
|
||||
_URC_CONTINUE_UNWIND = 8
|
||||
} _Unwind_Reason_Code;
|
||||
|
||||
|
||||
typedef void (*_Unwind_Exception_Cleanup_Fn)
|
||||
(_Unwind_Reason_Code reason, struct _Unwind_Exception *exc);
|
||||
|
||||
//The following definitions were grabbed from the gcc implementation
|
||||
typedef unsigned _Unwind_Ptr __attribute__((__mode__(__pointer__)));
|
||||
typedef unsigned _Unwind_Word __attribute__((__mode__(__word__)));
|
||||
typedef signed _Unwind_Sword __attribute__((__mode__(__word__)));
|
||||
typedef unsigned _Unwind_Exception_Class __attribute__((__mode__(__DI__)));
|
||||
typedef void (*_Unwind_Exception_Cleanup_Fn) (_Unwind_Reason_Code, struct _Unwind_Exception *);
|
||||
|
||||
typedef int _Unwind_Action;
|
||||
static const _Unwind_Action _UA_SEARCH_PHASE = 1;
|
||||
static const _Unwind_Action _UA_CLEANUP_PHASE = 2;
|
||||
static const _Unwind_Action _UA_HANDLER_FRAME = 4;
|
||||
static const _Unwind_Action _UA_FORCE_UNWIND = 8;
|
||||
|
||||
const _Unwind_Exception_Class __uclibcxx_exception_class = ((((((((
|
||||
_Unwind_Exception_Class) 'u' << 8 | (_Unwind_Exception_Class) 'l') << 8
|
||||
| (_Unwind_Exception_Class) 'i') << 8 | (_Unwind_Exception_Class) 'b') << 8
|
||||
| (_Unwind_Exception_Class) 'C')<< 8 | (_Unwind_Exception_Class) '+') << 8
|
||||
| (_Unwind_Exception_Class) '+') << 8 | (_Unwind_Exception_Class) '\0');
|
||||
|
||||
|
||||
#define _UA_SEARCH_PHASE 1
|
||||
#define _UA_CLEANUP_PHASE 2
|
||||
#define _UA_HANDLER_FRAME 4
|
||||
#define _UA_FORCE_UNWIND 8
|
||||
#define _UA_END_OF_STACK 16
|
||||
|
||||
struct _Unwind_Exception{
|
||||
_Unwind_Exception_Class exception_class; //Type of exception, eg ulibC++\0
|
||||
_Unwind_Exception_Cleanup_Fn exception_cleanup; //Destructor if from diff runtime
|
||||
_Unwind_Word private_1; //Don't touch at all!
|
||||
_Unwind_Word private_2; //Don't touch at all!
|
||||
} __attribute__((__aligned__));
|
||||
|
||||
|
||||
//The following structure is system-dependent and defined by the compiler
|
||||
//Thus it's definition was copied from the gcc 3.4.0 header files
|
||||
struct _Unwind_Context;
|
||||
//{
|
||||
// void *reg[DWARF_FRAME_REGISTERS+1];
|
||||
// void *cfa;
|
||||
// void *ra;
|
||||
// void *lsda;
|
||||
// struct dwarf_eh_bases bases;
|
||||
// _Unwind_Word args_size;
|
||||
//};
|
||||
|
||||
|
||||
|
||||
_Unwind_Reason_Code _Unwind_RaiseException ( struct _Unwind_Exception *exception_object );
|
||||
|
||||
//_Unwind_ForcedUnwind
|
||||
|
||||
typedef _Unwind_Reason_Code (*_Unwind_Stop_Fn)
|
||||
(int version, _Unwind_Action actions, _Unwind_Exception_Class exceptionClass,
|
||||
struct _Unwind_Exception *exceptionObject,
|
||||
struct _Unwind_Context *context, void *stop_parameter );
|
||||
|
||||
_Unwind_Reason_Code _Unwind_ForcedUnwind (
|
||||
struct _Unwind_Exception *exception_object, _Unwind_Stop_Fn stop,
|
||||
void *stop_parameter );
|
||||
|
||||
void _Unwind_Resume (struct _Unwind_Exception *exception_object);
|
||||
void _Unwind_DeleteException (struct _Unwind_Exception *exception_object);
|
||||
|
||||
_Unwind_Word _Unwind_GetGR (struct _Unwind_Context *context, int index);
|
||||
void _Unwind_SetGR (struct _Unwind_Context *context, int index, _Unwind_Word);
|
||||
|
||||
_Unwind_Ptr _Unwind_GetIP (struct _Unwind_Context *context);
|
||||
void _Unwind_SetIP (struct _Unwind_Context *context, _Unwind_Ptr new_value);
|
||||
|
||||
_Unwind_Ptr _Unwind_GetLanguageSpecificData (struct _Unwind_Context *context);
|
||||
_Unwind_Ptr _Unwind_GetRegionStart (struct _Unwind_Context *context);
|
||||
|
||||
_Unwind_Reason_Code (*__personality_routine)
|
||||
(int version, //Should be 1
|
||||
_Unwind_Action actions, //Actions the routine will perform (bitmask)
|
||||
_Unwind_Exception_Class exceptionClass, //Type of exception - vendor is high 4 bytes
|
||||
struct _Unwind_Exception *exceptionObject, //Points to exception header
|
||||
struct _Unwind_Context *context); //Unwinder state information
|
||||
|
||||
|
||||
/*The following part is the Level II ABI which is required for compatability*/
|
||||
//This might be the only stuff that *I* need to implement
|
||||
|
||||
struct __cxa_exception {
|
||||
std::type_info *exceptionType; //Type of thrown exception
|
||||
void (*exceptionDestructor) (void *); //Pointer to the destructor
|
||||
unexpected_handler unexpectedHandler; //Unexpected handler to use
|
||||
terminate_handler terminateHandler; //Terminate handle to use
|
||||
__cxa_exception *nextException; //per thread linked list
|
||||
|
||||
int handlerCount; //How many handlers have caught this
|
||||
int handlerSwitchValue;
|
||||
const char *actionRecord;
|
||||
const char *languageSpecificData;
|
||||
void *catchTemp;
|
||||
void *adjustedPtr;
|
||||
|
||||
_Unwind_Exception unwindHeader;
|
||||
};
|
||||
|
||||
struct __cxa_eh_globals {
|
||||
__cxa_exception *caughtExceptions;
|
||||
unsigned int uncaughtExceptions;
|
||||
};
|
||||
|
||||
extern "C" __cxa_eh_globals *__cxa_get_globals(void); //Return ptr to the eh_globals object for current thread
|
||||
extern "C" __cxa_eh_globals *__cxa_get_globals_fast(void); //Same as above, assumes that above called at least once
|
||||
|
||||
extern "C" void *__cxa_allocate_exception(size_t thrown_size); //Allocate space for exception plus header
|
||||
extern "C" void __cxa_free_exception(void *thrown_exception); //Free space allocated from the above
|
||||
|
||||
extern "C" void __cxa_throw (void *thrown_exception, //This is the actual throw call
|
||||
// std::type_info *tinfo, //Type of object
|
||||
void * tinfo, //Type of object
|
||||
void (*dest) (void *) ); //Pointer to destructor destroy object
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
/*
|
||||
* Automatically generated C config: don't edit
|
||||
*/
|
||||
/*
|
||||
* Version Number
|
||||
*/
|
||||
#define __UCLIBCXX_MAJOR__ 0
|
||||
#define __UCLIBCXX_MINOR__ 2
|
||||
#define __UCLIBCXX_SUBLEVEL__ 4
|
||||
|
||||
/*
|
||||
* Target Features and Options
|
||||
*/
|
||||
#define __UCLIBCXX_HAS_FLOATS__ 1
|
||||
#define __UCLIBCXX_HAS_LONG_DOUBLE__ 1
|
||||
#define __UCLIBCXX_HAS_TLS__ 1
|
||||
#define __WARNINGS__ "-Wall"
|
||||
#define __BUILD_EXTRA_LIBRARIES__ ""
|
||||
#define __HAVE_DOT_CONFIG__ 1
|
||||
|
||||
/*
|
||||
* String and I/O Stream Support
|
||||
*/
|
||||
#undef __UCLIBCXX_HAS_WCHAR__
|
||||
#define __UCLIBCXX_IOSTREAM_BUFSIZE__ 32
|
||||
#define __UCLIBCXX_HAS_LFS__ 1
|
||||
#define __UCLIBCXX_SUPPORT_CDIR__ 1
|
||||
#define __UCLIBCXX_SUPPORT_CIN__ 1
|
||||
#define __UCLIBCXX_SUPPORT_COUT__ 1
|
||||
#define __UCLIBCXX_SUPPORT_CERR__ 1
|
||||
#undef __UCLIBCXX_SUPPORT_CLOG__
|
||||
|
||||
/*
|
||||
* STL and Code Expansion
|
||||
*/
|
||||
#define __UCLIBCXX_STL_BUFFER_SIZE__ 32
|
||||
#define __UCLIBCXX_CODE_EXPANSION__ 1
|
||||
#define __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__ 1
|
||||
#define __UCLIBCXX_EXPAND_STRING_CHAR__ 1
|
||||
#define __UCLIBCXX_EXPAND_VECTOR_BASIC__ 1
|
||||
#define __UCLIBCXX_EXPAND_IOS_CHAR__ 1
|
||||
#define __UCLIBCXX_EXPAND_STREAMBUF_CHAR__ 1
|
||||
#define __UCLIBCXX_EXPAND_ISTREAM_CHAR__ 1
|
||||
#define __UCLIBCXX_EXPAND_OSTREAM_CHAR__ 1
|
||||
#define __UCLIBCXX_EXPAND_FSTREAM_CHAR__ 1
|
||||
#define __UCLIBCXX_EXPAND_SSTREAM_CHAR__ 1
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
/* Copyright (C) 2005 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <string.h>
|
||||
#include <exception>
|
||||
#include <memory>
|
||||
#include <char_traits>
|
||||
|
||||
#ifndef __HEADER_TYPE_TRAITS
|
||||
#define __HEADER_TYPE_TRAITS 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
struct _UCXXEXPORT __true_type{};
|
||||
struct _UCXXEXPORT __false_type{};
|
||||
|
||||
template <class I> class _UCXXEXPORT __is_integer{
|
||||
public:
|
||||
typedef __false_type value;
|
||||
};
|
||||
|
||||
template <> class _UCXXEXPORT __is_integer <unsigned int>{
|
||||
public:
|
||||
typedef __true_type value;
|
||||
};
|
||||
|
||||
template <> class _UCXXEXPORT __is_integer <signed int>{
|
||||
public:
|
||||
typedef __true_type value;
|
||||
};
|
||||
|
||||
template <> class _UCXXEXPORT __is_integer <short unsigned int>{
|
||||
public:
|
||||
typedef __true_type value;
|
||||
};
|
||||
|
||||
template <> class _UCXXEXPORT __is_integer <short signed int>{
|
||||
public:
|
||||
typedef __true_type value;
|
||||
};
|
||||
|
||||
template <> class _UCXXEXPORT __is_integer <char>{
|
||||
public:
|
||||
typedef __true_type value;
|
||||
};
|
||||
|
||||
template <> class _UCXXEXPORT __is_integer <signed char>{
|
||||
public:
|
||||
typedef __true_type value;
|
||||
};
|
||||
|
||||
template <> class _UCXXEXPORT __is_integer <unsigned char>{
|
||||
public:
|
||||
typedef __true_type value;
|
||||
};
|
||||
|
||||
template <> class _UCXXEXPORT __is_integer <long unsigned int>{
|
||||
public:
|
||||
typedef __true_type value;
|
||||
};
|
||||
|
||||
template <> class _UCXXEXPORT __is_integer <long signed int>{
|
||||
public:
|
||||
typedef __true_type value;
|
||||
};
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,156 @@
|
|||
// RTTI support for -*- C++ -*-
|
||||
// Copyright (C) 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002
|
||||
// Free Software Foundation
|
||||
//
|
||||
// This file is part of GNU CC.
|
||||
//
|
||||
// GNU CC is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
//
|
||||
// GNU CC is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with GNU CC; see the file COPYING. If not, write to
|
||||
// the Free Software Foundation, 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
/** @file typeinfo
|
||||
* This header provides RTTI support.
|
||||
*/
|
||||
|
||||
#ifndef __TYPEINFO__
|
||||
#define __TYPEINFO__
|
||||
|
||||
#include <exception>
|
||||
|
||||
extern "C++" {
|
||||
|
||||
namespace __cxxabiv1
|
||||
{
|
||||
class __class_type_info;
|
||||
} // namespace __cxxabiv1
|
||||
|
||||
#if !__GXX_WEAK__
|
||||
// If weak symbols are not supported, typeinfo names are not merged.
|
||||
#define __GXX_MERGED_TYPEINFO_NAMES 0
|
||||
#else
|
||||
// On platforms that support weak symbols, typeinfo names are merged.
|
||||
#define __GXX_MERGED_TYPEINFO_NAMES 1
|
||||
#endif
|
||||
|
||||
namespace std
|
||||
{
|
||||
/**
|
||||
* @brief Part of RTTI.
|
||||
*
|
||||
* The @c type_info class describes type information generated by
|
||||
* an implementation.
|
||||
*/
|
||||
class type_info
|
||||
{
|
||||
public:
|
||||
/** Destructor. Being the first non-inline virtual function, this
|
||||
* controls in which translation unit the vtable is emitted. The
|
||||
* compiler makes use of that information to know where to emit
|
||||
* the runtime-mandated type_info structures in the new-abi. */
|
||||
virtual ~type_info();
|
||||
|
||||
private:
|
||||
/// Assigning type_info is not supported. Made private.
|
||||
type_info& operator=(const type_info&);
|
||||
type_info(const type_info&);
|
||||
|
||||
protected:
|
||||
const char *__name;
|
||||
|
||||
protected:
|
||||
explicit type_info(const char *__n): __name(__n) { }
|
||||
|
||||
public:
|
||||
// the public interface
|
||||
/** Returns an @e implementation-defined byte string; this is not
|
||||
* portable between compilers! */
|
||||
const char* name() const
|
||||
{ return __name; }
|
||||
|
||||
#if !__GXX_MERGED_TYPEINFO_NAMES
|
||||
bool before(const type_info& __arg) const;
|
||||
// In old abi, or when weak symbols are not supported, there can
|
||||
// be multiple instances of a type_info object for one
|
||||
// type. Uniqueness must use the _name value, not object address.
|
||||
bool operator==(const type_info& __arg) const;
|
||||
#else
|
||||
/** Returns true if @c *this precedes @c __arg in the implementation's
|
||||
* collation order. */
|
||||
// In new abi we can rely on type_info's NTBS being unique,
|
||||
// and therefore address comparisons are sufficient.
|
||||
bool before(const type_info& __arg) const
|
||||
{ return __name < __arg.__name; }
|
||||
bool operator==(const type_info& __arg) const
|
||||
{ return __name == __arg.__name; }
|
||||
#endif
|
||||
bool operator!=(const type_info& __arg) const
|
||||
{ return !operator==(__arg); }
|
||||
|
||||
// the internal interface
|
||||
public:
|
||||
// return true if this is a pointer type of some kind
|
||||
virtual bool __is_pointer_p() const;
|
||||
// return true if this is a function type
|
||||
virtual bool __is_function_p() const;
|
||||
|
||||
// Try and catch a thrown type. Store an adjusted pointer to the
|
||||
// caught type in THR_OBJ. If THR_TYPE is not a pointer type, then
|
||||
// THR_OBJ points to the thrown object. If THR_TYPE is a pointer
|
||||
// type, then THR_OBJ is the pointer itself. OUTER indicates the
|
||||
// number of outer pointers, and whether they were const
|
||||
// qualified.
|
||||
virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
|
||||
unsigned __outer) const;
|
||||
|
||||
// internally used during catch matching
|
||||
virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
|
||||
void **__obj_ptr) const;
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Thrown during incorrect typecasting.
|
||||
*
|
||||
* If you attempt an invalid @c dynamic_cast expression, an instance of
|
||||
* this class (or something derived from this class) is thrown. */
|
||||
class bad_cast : public exception
|
||||
{
|
||||
public:
|
||||
bad_cast() throw() { }
|
||||
// This declaration is not useless:
|
||||
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
|
||||
virtual ~bad_cast() throw();
|
||||
};
|
||||
|
||||
/** If you use a NULL pointer in a @c typeid expression, this is thrown. */
|
||||
class bad_typeid : public exception
|
||||
{
|
||||
public:
|
||||
bad_typeid () throw() { }
|
||||
// This declaration is not useless:
|
||||
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
|
||||
virtual ~bad_typeid() throw();
|
||||
};
|
||||
} // namespace std
|
||||
|
||||
} // extern "C++"
|
||||
#endif
|
||||
|
|
@ -0,0 +1,213 @@
|
|||
// -*- C++ -*- Exception handling and frame unwind runtime interface routines.
|
||||
// Copyright (C) 2001 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of GCC.
|
||||
//
|
||||
// GCC is free software; you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
//
|
||||
// GCC is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with GCC; see the file COPYING. If not, write to
|
||||
// the Free Software Foundation, 59 Temple Place - Suite 330,
|
||||
// Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// This is derived from the C++ ABI for IA-64. Where we diverge
|
||||
// for cross-architecture compatibility are noted with "@@@".
|
||||
|
||||
#ifndef _UNWIND_CXX_H
|
||||
#define _UNWIND_CXX_H 1
|
||||
|
||||
// Level 2: C++ ABI
|
||||
|
||||
#include <typeinfo>
|
||||
#include <exception>
|
||||
#include <cstddef>
|
||||
#include "unwind.h"
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace __cxxabiv1
|
||||
{
|
||||
|
||||
// A primary C++ exception object consists of a header, which is a wrapper
|
||||
// around an unwind object header with additional C++ specific information,
|
||||
// followed by the exception object itself.
|
||||
|
||||
struct __cxa_exception
|
||||
{
|
||||
// Manage the exception object itself.
|
||||
std::type_info *exceptionType;
|
||||
void (*exceptionDestructor)(void *);
|
||||
|
||||
// The C++ standard has entertaining rules wrt calling set_terminate
|
||||
// and set_unexpected in the middle of the exception cleanup process.
|
||||
std::unexpected_handler unexpectedHandler;
|
||||
std::terminate_handler terminateHandler;
|
||||
|
||||
// The caught exception stack threads through here.
|
||||
__cxa_exception *nextException;
|
||||
|
||||
// How many nested handlers have caught this exception. A negated
|
||||
// value is a signal that this object has been rethrown.
|
||||
int handlerCount;
|
||||
|
||||
// Cache parsed handler data from the personality routine Phase 1
|
||||
// for Phase 2 and __cxa_call_unexpected.
|
||||
int handlerSwitchValue;
|
||||
const unsigned char *actionRecord;
|
||||
const unsigned char *languageSpecificData;
|
||||
_Unwind_Ptr catchTemp;
|
||||
void *adjustedPtr;
|
||||
|
||||
// The generic exception header. Must be last.
|
||||
_Unwind_Exception unwindHeader;
|
||||
};
|
||||
|
||||
|
||||
// A dependent C++ exception object consists of a header, which is a wrapper
|
||||
// around an unwind object header with additional C++ specific information,
|
||||
// followed by the exception object itself.
|
||||
struct __cxa_dependent_exception
|
||||
{
|
||||
// The primary exception
|
||||
void *primaryException;
|
||||
|
||||
// The C++ standard has entertaining rules wrt calling set_terminate
|
||||
// and set_unexpected in the middle of the exception cleanup process.
|
||||
std::unexpected_handler unexpectedHandler;
|
||||
std::terminate_handler terminateHandler;
|
||||
|
||||
// The caught exception stack threads through here.
|
||||
__cxa_exception *nextException;
|
||||
|
||||
// How many nested handlers have caught this exception. A negated
|
||||
// value is a signal that this object has been rethrown.
|
||||
int handlerCount;
|
||||
|
||||
// Cache parsed handler data from the personality routine Phase 1
|
||||
// for Phase 2 and __cxa_call_unexpected.
|
||||
int handlerSwitchValue;
|
||||
const unsigned char *actionRecord;
|
||||
const unsigned char *languageSpecificData;
|
||||
_Unwind_Ptr catchTemp;
|
||||
void *adjustedPtr;
|
||||
|
||||
// The generic exception header. Must be last.
|
||||
_Unwind_Exception unwindHeader;
|
||||
};
|
||||
|
||||
|
||||
// Each thread in a C++ program has access to a __cxa_eh_globals object.
|
||||
struct __cxa_eh_globals
|
||||
{
|
||||
__cxa_exception *caughtExceptions;
|
||||
unsigned int uncaughtExceptions;
|
||||
};
|
||||
|
||||
|
||||
// The __cxa_eh_globals for the current thread can be obtained by using
|
||||
// either of the following functions. The "fast" version assumes at least
|
||||
// one prior call of __cxa_get_globals has been made from the current
|
||||
// thread, so no initialization is necessary.
|
||||
extern "C" __cxa_eh_globals *__cxa_get_globals () throw();
|
||||
extern "C" __cxa_eh_globals *__cxa_get_globals_fast () throw();
|
||||
|
||||
// Allocate memory for the primary exception plus the thrown object.
|
||||
extern "C" void *__cxa_allocate_exception(std::size_t thrown_size) throw();
|
||||
// Allocate memory for dependent exception.
|
||||
extern "C" __cxa_dependent_exception *__cxa_allocate_dependent_exception() throw();
|
||||
|
||||
// Free the space allocated for the primary exception.
|
||||
extern "C" void __cxa_free_exception(void *thrown_exception) throw();
|
||||
// Free the space allocated for the dependent exception.
|
||||
extern "C" void __cxa_free_dependent_exception(__cxa_dependent_exception *dependent_exception) throw();
|
||||
|
||||
// Throw the exception.
|
||||
extern "C" void __cxa_throw (void *thrown_exception,
|
||||
std::type_info *tinfo,
|
||||
void (*dest) (void *))
|
||||
__attribute__((noreturn));
|
||||
|
||||
// Used to implement exception handlers.
|
||||
extern "C" void *__cxa_begin_catch (void *) throw();
|
||||
extern "C" void __cxa_end_catch ();
|
||||
extern "C" void __cxa_rethrow () __attribute__((noreturn));
|
||||
|
||||
// These facilitate code generation for recurring situations.
|
||||
extern "C" void __cxa_bad_cast ();
|
||||
extern "C" void __cxa_bad_typeid ();
|
||||
|
||||
// @@@ These are not directly specified by the IA-64 C++ ABI.
|
||||
|
||||
// Handles re-checking the exception specification if unexpectedHandler
|
||||
// throws, and if bad_exception needs to be thrown. Called from the
|
||||
// compiler.
|
||||
extern "C" void __cxa_call_unexpected (void *) __attribute__((noreturn));
|
||||
|
||||
// Invokes given handler, dying appropriately if the user handler was
|
||||
// so inconsiderate as to return.
|
||||
extern void __terminate(std::terminate_handler) __attribute__((noreturn));
|
||||
extern void __unexpected(std::unexpected_handler) __attribute__((noreturn));
|
||||
|
||||
// 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 *);
|
||||
|
||||
// Acquire the C++ exception header from the C++ object.
|
||||
static inline __cxa_exception *
|
||||
__get_exception_header_from_obj (void *ptr)
|
||||
{
|
||||
return reinterpret_cast<__cxa_exception *>(ptr) - 1;
|
||||
}
|
||||
|
||||
// Acquire the C++ exception header from the generic exception header.
|
||||
static inline __cxa_exception *
|
||||
__get_exception_header_from_ue (_Unwind_Exception *exc)
|
||||
{
|
||||
return reinterpret_cast<__cxa_exception *>(exc + 1) - 1;
|
||||
}
|
||||
|
||||
} /* namespace __cxxabiv1 */
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif // _UNWIND_CXX_H
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
|
||||
#include <basic_definitions>
|
||||
|
||||
|
||||
#ifndef __STD_HEADER_UTILITY
|
||||
#define __STD_HEADER_UTILITY 1
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
namespace rel_ops {
|
||||
template<class T> inline bool operator!=(const T& x, const T& y){
|
||||
return !(x == y);
|
||||
}
|
||||
|
||||
template<class T> inline bool operator> (const T& x, const T& y){
|
||||
return ( y < x);
|
||||
}
|
||||
|
||||
template<class T> inline bool operator<=(const T& x, const T& y){
|
||||
return !( y < x );
|
||||
}
|
||||
|
||||
template<class T> inline bool operator>=(const T& x, const T& y){
|
||||
return !(x < y);
|
||||
}
|
||||
}
|
||||
|
||||
template <class T1, class T2> struct _UCXXEXPORT pair {
|
||||
typedef T1 first_type;
|
||||
typedef T2 second_type;
|
||||
|
||||
T1 first;
|
||||
T2 second;
|
||||
pair() : first(), second() { }
|
||||
pair(const T1& x, const T2& y) : first(x), second(y) { }
|
||||
template<class U, class V> pair(const pair<U, V> &p) : first(p.first), second(p.second) { }
|
||||
};
|
||||
|
||||
template <class T1, class T2> bool operator==(const pair<T1,T2>& x, const pair<T1,T2>& y){
|
||||
using namespace rel_ops;
|
||||
return (x.first == y.first && x.second==y.second);
|
||||
}
|
||||
template <class T1, class T2> bool operator< (const pair<T1,T2>& x, const pair<T1,T2>& y){
|
||||
return x.first < y.first || (!(y.first < x.first) && x.second < y.second);
|
||||
}
|
||||
template <class T1, class T2> bool operator!=(const pair<T1,T2>& x, const pair<T1,T2>& y){
|
||||
return !(x == y);
|
||||
}
|
||||
template <class T1, class T2> bool operator> (const pair<T1,T2>& x, const pair<T1,T2>& y){
|
||||
return y < x;
|
||||
}
|
||||
template <class T1, class T2> bool operator>=(const pair<T1,T2>& x, const pair<T1,T2>& y){
|
||||
return !(x < y);
|
||||
}
|
||||
template <class T1, class T2> bool operator<=(const pair<T1,T2>& x, const pair<T1,T2>& y){
|
||||
return !(y < x);
|
||||
}
|
||||
template <class T1, class T2> pair<T1,T2> make_pair(const T1& x, const T2& y){
|
||||
return pair<T1,T2>(x, y);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif //__STD_HEADER_UTILITY
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,517 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <memory>
|
||||
#include <iterator>
|
||||
#include <func_exception>
|
||||
#include <algorithm>
|
||||
#include <type_traits>
|
||||
|
||||
|
||||
#ifndef __STD_HEADER_VECTOR
|
||||
#define __STD_HEADER_VECTOR
|
||||
|
||||
#pragma GCC visibility push(default)
|
||||
|
||||
namespace std{
|
||||
|
||||
template <class T, class Allocator = allocator<T> > class vector;
|
||||
template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
||||
template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
||||
template <class T, class Allocator> void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
|
||||
|
||||
template <class T, class Allocator> class _UCXXEXPORT vector {
|
||||
public:
|
||||
|
||||
typedef typename Allocator::reference reference;
|
||||
typedef typename Allocator::const_reference const_reference;
|
||||
typedef typename Allocator::size_type size_type;
|
||||
typedef typename Allocator::difference_type difference_type;
|
||||
typedef typename Allocator::pointer pointer;
|
||||
typedef typename Allocator::const_pointer const_pointer;
|
||||
|
||||
typedef T* iterator;
|
||||
typedef const T* const_iterator;
|
||||
typedef T value_type;
|
||||
typedef Allocator allocator_type;
|
||||
typedef std::reverse_iterator<iterator> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
|
||||
explicit _UCXXEXPORT vector(const Allocator& al= Allocator()): data(0), //defaultValue(T()),
|
||||
data_size(__UCLIBCXX_STL_BUFFER_SIZE__), elements(0), a(al)
|
||||
{
|
||||
data = a.allocate(data_size);
|
||||
}
|
||||
|
||||
explicit _UCXXEXPORT vector(size_type n, const T& value = T(), const Allocator& al= Allocator()) :
|
||||
data(0), data_size(0), elements(0), a(al)
|
||||
{
|
||||
data_size = n + __UCLIBCXX_STL_BUFFER_SIZE__;
|
||||
data = a.allocate(data_size);
|
||||
|
||||
resize(n, value);
|
||||
}
|
||||
|
||||
template <class InputIterator> _UCXXEXPORT
|
||||
vector(InputIterator first, InputIterator last, const Allocator& al = Allocator()):
|
||||
data(0), data_size(__UCLIBCXX_STL_BUFFER_SIZE__), elements(0), a(al)
|
||||
{
|
||||
data = a.allocate(data_size);
|
||||
assign(first, last);
|
||||
}
|
||||
|
||||
_UCXXEXPORT vector(const vector<T,Allocator>& x){
|
||||
a = x.a;
|
||||
|
||||
elements = x.elements;
|
||||
data_size = elements + __UCLIBCXX_STL_BUFFER_SIZE__;
|
||||
data = a.allocate(data_size);
|
||||
|
||||
for(size_type i = 0; i < elements; i++){
|
||||
a.construct(data+i, x.data[i]);
|
||||
}
|
||||
}
|
||||
|
||||
_UCXXEXPORT ~vector(); //Below
|
||||
|
||||
_UCXXEXPORT vector<T,Allocator>& operator=(const vector<T,Allocator>& x){
|
||||
if(&x == this){
|
||||
return *this;
|
||||
}
|
||||
|
||||
reserve(x.elements); //Make sure that we have enough actual memory
|
||||
|
||||
|
||||
//Copy as many elements as possible
|
||||
|
||||
size_t minElements = elements;
|
||||
if(minElements > x.elements){
|
||||
minElements = x.elements;
|
||||
}
|
||||
for(size_t i = 0; i < minElements; ++i){
|
||||
data[i] = x.data[i];
|
||||
}
|
||||
|
||||
//If we need to add new elements
|
||||
if(elements < x.elements){
|
||||
for(size_t i = elements; i< x.elements; ++i){
|
||||
a.construct(data+i, x.data[i]);
|
||||
++elements;
|
||||
}
|
||||
}
|
||||
|
||||
if(elements > x.elements){
|
||||
downsize(x.elements);
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class InputIterator> _UCXXEXPORT void assign(InputIterator first, InputIterator last){
|
||||
clear();
|
||||
insert(begin(), first, last);
|
||||
}
|
||||
|
||||
template <class Size, class U> _UCXXEXPORT void assign(Size n, const U& u = U()){
|
||||
clear();
|
||||
resize(n, u);
|
||||
}
|
||||
|
||||
inline allocator_type get_allocator() const{
|
||||
return a;
|
||||
}
|
||||
|
||||
inline iterator begin(){
|
||||
return data;
|
||||
}
|
||||
|
||||
inline const_iterator begin() const{
|
||||
return data;
|
||||
}
|
||||
|
||||
inline iterator end(){
|
||||
return (data + elements);
|
||||
}
|
||||
|
||||
inline const_iterator end() const{
|
||||
return (data + elements);
|
||||
}
|
||||
|
||||
inline reverse_iterator rbegin(){
|
||||
return reverse_iterator(end());
|
||||
}
|
||||
|
||||
inline const_reverse_iterator rbegin() const{
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
|
||||
inline reverse_iterator rend(){
|
||||
return reverse_iterator(begin());
|
||||
}
|
||||
|
||||
inline const_reverse_iterator rend() const{
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
|
||||
inline size_type size() const{
|
||||
return elements;
|
||||
}
|
||||
|
||||
_UCXXEXPORT size_type max_size() const{
|
||||
return ((size_type)(-1)) / sizeof(T);
|
||||
}
|
||||
|
||||
void downsize(size_type sz);
|
||||
void resize(size_type sz, const T & c = T());
|
||||
|
||||
inline size_type capacity() const{
|
||||
return data_size;
|
||||
}
|
||||
|
||||
inline bool empty() const{
|
||||
return (size() == 0);
|
||||
}
|
||||
|
||||
void reserve(size_type n);
|
||||
|
||||
inline reference operator[](size_type n){
|
||||
return data[n];
|
||||
}
|
||||
|
||||
inline const_reference operator[](size_type n) const{
|
||||
return data[n];
|
||||
}
|
||||
|
||||
_UCXXEXPORT const_reference at(size_type n) const{
|
||||
if(n >= elements){
|
||||
__throw_out_of_range("Invalid subscript");
|
||||
}
|
||||
return data[n];
|
||||
}
|
||||
|
||||
_UCXXEXPORT reference at(size_type n){
|
||||
if(n >= elements){
|
||||
__throw_out_of_range("Invalid subscript");
|
||||
}
|
||||
return data[n];
|
||||
}
|
||||
|
||||
inline reference front(){
|
||||
return data[0];
|
||||
}
|
||||
|
||||
inline const_reference front() const{
|
||||
return data[0];
|
||||
}
|
||||
|
||||
inline reference back(){
|
||||
return data[ size() - 1];
|
||||
}
|
||||
|
||||
inline const_reference back() const{
|
||||
return data[ size() - 1 ];
|
||||
}
|
||||
|
||||
inline void push_back(const T& x){
|
||||
resize( size() + 1, x);
|
||||
}
|
||||
|
||||
inline void pop_back(){
|
||||
downsize(size() - 1);
|
||||
}
|
||||
|
||||
_UCXXEXPORT iterator insert(iterator position, const T& x = T()){
|
||||
size_type index = position - data;
|
||||
resize(size() + 1, x);
|
||||
for(size_type i = elements - 1; i > index; --i){
|
||||
data[i] = data[i-1];
|
||||
}
|
||||
data[index] = x;
|
||||
return (data + index);
|
||||
}
|
||||
|
||||
_UCXXEXPORT void _insert_fill(iterator position, size_type n, const T & x){
|
||||
size_type index = position - data;
|
||||
resize(size() + n, x);
|
||||
|
||||
for(size_type i = elements -1; (i > (index+n-1)); --i){
|
||||
data[i] = data[i-n];
|
||||
}
|
||||
for(size_type i = 0; i < n; i++){
|
||||
data[i + index] = x;
|
||||
}
|
||||
}
|
||||
|
||||
template <class InputIterator> _UCXXEXPORT
|
||||
void _insert_from_iterator(iterator position, InputIterator first, InputIterator last)
|
||||
{
|
||||
T temp;
|
||||
while(first !=last){
|
||||
temp = *first;
|
||||
position = insert(position, temp);
|
||||
++position;
|
||||
++first;
|
||||
}
|
||||
}
|
||||
|
||||
template <class InputIterator>
|
||||
inline void _dispatch_insert(iterator position, InputIterator first, InputIterator last, __true_type)
|
||||
{
|
||||
_insert_fill(position, first, last);
|
||||
}
|
||||
|
||||
template <class InputIterator>
|
||||
inline void _dispatch_insert(iterator position, InputIterator first, InputIterator last, __false_type)
|
||||
{
|
||||
_insert_from_iterator(position, first, last);
|
||||
}
|
||||
|
||||
inline void insert(iterator position, size_type n, const T& x ){
|
||||
_insert_fill(position, n, x);
|
||||
}
|
||||
|
||||
template <class InputIterator> inline void insert(iterator position, InputIterator first, InputIterator last){
|
||||
typedef typename __is_integer<InputIterator>::value __some_type;
|
||||
_dispatch_insert(position, first, last, __some_type());
|
||||
}
|
||||
|
||||
_UCXXEXPORT iterator erase(iterator position){
|
||||
size_type index = position - data;
|
||||
for(size_type i = index; i < (elements - 1); ++i){
|
||||
data[i] = data[i+1];
|
||||
}
|
||||
downsize(size() - 1);
|
||||
return (data + index);
|
||||
}
|
||||
|
||||
_UCXXEXPORT iterator erase(iterator first, iterator last){
|
||||
size_type index = first - data;
|
||||
size_type width = last - first;
|
||||
for(size_type i = index; i < (elements - width) ;++i){
|
||||
data[i] = data[i+width];
|
||||
}
|
||||
downsize(size() - width);
|
||||
return (data + index);
|
||||
}
|
||||
|
||||
_UCXXEXPORT void swap(vector<T,Allocator>& v){
|
||||
if(this == &v){ //Avoid dv.swap(v)
|
||||
return;
|
||||
}
|
||||
T* ptr;
|
||||
size_type temp;
|
||||
|
||||
//Swap pointers first
|
||||
ptr = data;
|
||||
data = v.data;
|
||||
v.data = ptr;
|
||||
|
||||
//Swap element counts
|
||||
temp = elements;
|
||||
elements = v.elements;
|
||||
v.elements = temp;
|
||||
|
||||
//Swap data size
|
||||
temp = data_size;
|
||||
data_size = v.data_size;
|
||||
v.data_size = temp;
|
||||
}
|
||||
|
||||
_UCXXEXPORT void clear(){
|
||||
downsize(0);
|
||||
}
|
||||
|
||||
protected:
|
||||
T* data;
|
||||
size_type data_size;
|
||||
size_type elements;
|
||||
Allocator a;
|
||||
};
|
||||
|
||||
|
||||
|
||||
//Here go template instantiations
|
||||
|
||||
template<class T, class Allocator> _UCXXEXPORT vector<T, Allocator>::~vector(){
|
||||
for(size_t i = 0; i < elements; ++i){
|
||||
a.destroy(data + i);
|
||||
}
|
||||
a.deallocate(data, data_size);
|
||||
}
|
||||
|
||||
|
||||
template<class T, class Allocator> _UCXXEXPORT void vector<T, Allocator>::reserve(size_type n){
|
||||
if(n > data_size){ //We never shrink...
|
||||
T * temp_ptr = data;
|
||||
size_type temp_size = data_size;
|
||||
|
||||
data_size = n;
|
||||
data = a.allocate(data_size);
|
||||
|
||||
for(size_type i = 0; i<elements; ++i){
|
||||
a.construct(data+i, temp_ptr[i]);
|
||||
a.destroy(temp_ptr+i);
|
||||
}
|
||||
a.deallocate(temp_ptr, temp_size);
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> _UCXXEXPORT void vector<T, Allocator>::resize(size_type sz, const T & c){
|
||||
if(sz > elements){ //Need to actually call constructor
|
||||
if(sz > data_size){
|
||||
reserve(sz + __UCLIBCXX_STL_BUFFER_SIZE__);
|
||||
}
|
||||
|
||||
for(size_type i = elements; i<sz ; ++i){
|
||||
a.construct(data+i, c);
|
||||
}
|
||||
elements = sz;
|
||||
}else{
|
||||
downsize(sz);
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class Allocator> _UCXXEXPORT void vector<T, Allocator>::downsize(size_type sz){
|
||||
if(sz < elements){ //Actually are downsizing
|
||||
for(size_t i = sz; i< elements; ++i){
|
||||
a.destroy(data+i);
|
||||
}
|
||||
elements = sz;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#ifndef __UCLIBCXX_COMPILE_VECTOR__
|
||||
#ifdef __UCLIBCXX_EXPAND_VECTOR_BASIC__
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
template<> _UCXXEXPORT vector<char, allocator<char> >::vector(const allocator<char>& al);
|
||||
template<> _UCXXEXPORT vector<char, allocator<char> >::vector(size_type n, const char & value, const allocator<char> & al);
|
||||
|
||||
template<> _UCXXEXPORT vector<char, allocator<char> >::~vector();
|
||||
template<> _UCXXEXPORT vector<unsigned char, allocator<unsigned char> >::~vector();
|
||||
|
||||
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template<> _UCXXEXPORT void vector<char, allocator<char> >::reserve(size_type n);
|
||||
template<> _UCXXEXPORT void vector<unsigned char, allocator<unsigned char> >::reserve(size_type n);
|
||||
template<> _UCXXEXPORT void vector<short int, allocator<short int> >::reserve(size_type n);
|
||||
template<> _UCXXEXPORT void vector<unsigned short int, allocator<unsigned short int> >::reserve(size_type n);
|
||||
template<> _UCXXEXPORT void vector<int, allocator<int> >::reserve(size_type n);
|
||||
template<> _UCXXEXPORT void vector<unsigned int, allocator<unsigned int> >::reserve(size_type n);
|
||||
template<> _UCXXEXPORT void vector<long int, allocator<long int> >::reserve(size_type n);
|
||||
template<> _UCXXEXPORT void vector<unsigned long int, allocator<unsigned long int> >::reserve(size_type n);
|
||||
template<> _UCXXEXPORT void vector<float, allocator<float> >::reserve(size_type n);
|
||||
template<> _UCXXEXPORT void vector<double, allocator<double> >::reserve(size_type n);
|
||||
template<> _UCXXEXPORT void vector<bool, allocator<bool> >::reserve(size_type n);
|
||||
|
||||
template<> _UCXXEXPORT void vector<char, allocator<char> >::resize(size_type sz, const char & c);
|
||||
template<> _UCXXEXPORT void
|
||||
vector<unsigned char, allocator<unsigned char> >::resize(size_type sz, const unsigned char & c);
|
||||
template<> _UCXXEXPORT void vector<short int, allocator<short int> >::resize(size_type sz, const short & c);
|
||||
template<> _UCXXEXPORT void
|
||||
vector<unsigned short int, allocator<unsigned short int> >::resize(size_type sz, const unsigned short int & c);
|
||||
template<> _UCXXEXPORT void vector<int, allocator<int> >::resize(size_type sz, const int & c);
|
||||
template<> _UCXXEXPORT void vector<unsigned int, allocator<unsigned int> >::resize(size_type sz, const unsigned int & c);
|
||||
template<> _UCXXEXPORT void vector<long int, allocator<long int> >::resize(size_type sz, const long int & c);
|
||||
template<> _UCXXEXPORT void
|
||||
vector<unsigned long int, allocator<unsigned long int> >::resize(size_type sz, const unsigned long int & c);
|
||||
template<> _UCXXEXPORT void vector<float, allocator<float> >::resize(size_type sz, const float & c);
|
||||
template<> _UCXXEXPORT void vector<double, allocator<double> >::resize(size_type sz, const double & c);
|
||||
template<> _UCXXEXPORT void vector<bool, allocator<bool> >::resize(size_type sz, const bool & c);
|
||||
|
||||
#elif defined __UCLIBCXX_EXPAND_STRING_CHAR__
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template<> _UCXXEXPORT vector<char, allocator<char> >::vector(const allocator<char>& al);
|
||||
template<> _UCXXEXPORT vector<char, allocator<char> >::vector(size_type n, const char & value, const allocator<char> & al);
|
||||
template<> _UCXXEXPORT vector<char, allocator<char> >::~vector();
|
||||
|
||||
#endif
|
||||
|
||||
template<> _UCXXEXPORT void vector<char, allocator<char> >::reserve(size_type n);
|
||||
template<> _UCXXEXPORT void vector<char, allocator<char> >::resize(size_type sz, const char & c);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
template <class T, class Allocator> _UCXXEXPORT bool
|
||||
operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y)
|
||||
{
|
||||
if(x.size() !=y.size() ){
|
||||
return false;
|
||||
}
|
||||
for(size_t i = 0; i < x.size(); ++i){
|
||||
if(x[i] != y[i]){
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class T, class Allocator> _UCXXEXPORT bool
|
||||
operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
|
||||
{
|
||||
less<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c;
|
||||
return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c);
|
||||
}
|
||||
template <class T, class Allocator> _UCXXEXPORT bool
|
||||
operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y)
|
||||
{
|
||||
return !(x == y);
|
||||
}
|
||||
template <class T, class Allocator> _UCXXEXPORT bool
|
||||
operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
|
||||
{
|
||||
greater<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c;
|
||||
return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c);
|
||||
}
|
||||
template <class T, class Allocator> _UCXXEXPORT bool
|
||||
operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y)
|
||||
{
|
||||
greater_equal<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c;
|
||||
return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c);
|
||||
}
|
||||
template <class T, class Allocator> _UCXXEXPORT bool
|
||||
operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y)
|
||||
{
|
||||
less_equal<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c;
|
||||
return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c);
|
||||
}
|
||||
|
||||
template <class T, class Allocator> _UCXXEXPORT void swap(vector<T,Allocator>& x, vector<T,Allocator>& y){
|
||||
x.swap(y);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,451 @@
|
|||
/* Copyright (C) 1991-1993,1995-2006,2007,2009 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#ifndef _FEATURES_H
|
||||
#define _FEATURES_H 1
|
||||
|
||||
/* These are defined by the user (or the compiler)
|
||||
to specify the desired environment:
|
||||
|
||||
__STRICT_ANSI__ ISO Standard C.
|
||||
_ISOC99_SOURCE Extensions to ISO C89 from ISO C99.
|
||||
_POSIX_SOURCE IEEE Std 1003.1.
|
||||
_POSIX_C_SOURCE If ==1, like _POSIX_SOURCE; if >=2 add IEEE Std 1003.2;
|
||||
if >=199309L, add IEEE Std 1003.1b-1993;
|
||||
if >=199506L, add IEEE Std 1003.1c-1995;
|
||||
if >=200112L, all of IEEE 1003.1-2004
|
||||
if >=200809L, all of IEEE 1003.1-2008
|
||||
_XOPEN_SOURCE Includes POSIX and XPG things. Set to 500 if
|
||||
Single Unix conformance is wanted, to 600 for the
|
||||
sixth revision, to 700 for the seventh revision.
|
||||
_XOPEN_SOURCE_EXTENDED XPG things and X/Open Unix extensions.
|
||||
_LARGEFILE_SOURCE Some more functions for correct standard I/O.
|
||||
_LARGEFILE64_SOURCE Additional functionality from LFS for large files.
|
||||
_FILE_OFFSET_BITS=N Select default filesystem interface.
|
||||
_BSD_SOURCE ISO C, POSIX, and 4.3BSD things.
|
||||
_SVID_SOURCE ISO C, POSIX, and SVID things.
|
||||
_ATFILE_SOURCE Additional *at interfaces.
|
||||
_GNU_SOURCE All of the above, plus GNU extensions.
|
||||
_REENTRANT Select additionally reentrant object.
|
||||
_THREAD_SAFE Same as _REENTRANT, often used by other systems.
|
||||
_FORTIFY_SOURCE If set to numeric value > 0 additional security
|
||||
measures are defined, according to level.
|
||||
|
||||
The `-ansi' switch to the GNU C compiler defines __STRICT_ANSI__.
|
||||
If none of these are defined, the default is to have _SVID_SOURCE,
|
||||
_BSD_SOURCE, and _POSIX_SOURCE set to one and _POSIX_C_SOURCE set to
|
||||
200112L. If more than one of these are defined, they accumulate.
|
||||
For example __STRICT_ANSI__, _POSIX_SOURCE and _POSIX_C_SOURCE
|
||||
together give you ISO C, 1003.1, and 1003.2, but nothing else.
|
||||
|
||||
These are defined by this file and are used by the
|
||||
header files to decide what to declare or define:
|
||||
|
||||
__USE_ISOC99 Define ISO C99 things.
|
||||
__USE_ISOC95 Define ISO C90 AMD1 (C95) things.
|
||||
__USE_POSIX Define IEEE Std 1003.1 things.
|
||||
__USE_POSIX2 Define IEEE Std 1003.2 things.
|
||||
__USE_POSIX199309 Define IEEE Std 1003.1, and .1b things.
|
||||
__USE_POSIX199506 Define IEEE Std 1003.1, .1b, .1c and .1i things.
|
||||
__USE_XOPEN Define XPG things.
|
||||
__USE_XOPEN_EXTENDED Define X/Open Unix things.
|
||||
__USE_UNIX98 Define Single Unix V2 things.
|
||||
__USE_XOPEN2K Define XPG6 things.
|
||||
__USE_XOPEN2K8 Define XPG7 things.
|
||||
__USE_LARGEFILE Define correct standard I/O things.
|
||||
__USE_LARGEFILE64 Define LFS things with separate names.
|
||||
__USE_FILE_OFFSET64 Define 64bit interface as default.
|
||||
__USE_BSD Define 4.3BSD things.
|
||||
__USE_SVID Define SVID things.
|
||||
__USE_MISC Define things common to BSD and System V Unix.
|
||||
__USE_ATFILE Define *at interfaces and AT_* constants for them.
|
||||
__USE_GNU Define GNU extensions.
|
||||
__USE_REENTRANT Define reentrant/thread-safe *_r functions.
|
||||
__USE_FORTIFY_LEVEL Additional security measures used, according to level.
|
||||
__FAVOR_BSD Favor 4.3BSD things in cases of conflict.
|
||||
|
||||
The macros `__GNU_LIBRARY__', `__GLIBC__', and `__GLIBC_MINOR__' are
|
||||
defined by this file unconditionally. `__GNU_LIBRARY__' is provided
|
||||
only for compatibility. All new code should use the other symbols
|
||||
to test for features.
|
||||
|
||||
All macros listed above as possibly being defined by this file are
|
||||
explicitly undefined if they are not explicitly defined.
|
||||
Feature-test macros that are not defined by the user or compiler
|
||||
but are implied by the other feature-test macros defined (or by the
|
||||
lack of any definitions) are defined by the file. */
|
||||
|
||||
|
||||
/* Undefine everything, so we get a clean slate. */
|
||||
#undef __USE_ISOC99
|
||||
#undef __USE_ISOC95
|
||||
#undef __USE_POSIX
|
||||
#undef __USE_POSIX2
|
||||
#undef __USE_POSIX199309
|
||||
#undef __USE_POSIX199506
|
||||
#undef __USE_XOPEN
|
||||
#undef __USE_XOPEN_EXTENDED
|
||||
#undef __USE_UNIX98
|
||||
#undef __USE_XOPEN2K
|
||||
#undef __USE_XOPEN2K8
|
||||
#undef __USE_LARGEFILE
|
||||
#undef __USE_LARGEFILE64
|
||||
#undef __USE_FILE_OFFSET64
|
||||
#undef __USE_BSD
|
||||
#undef __USE_SVID
|
||||
#undef __USE_MISC
|
||||
#undef __USE_ATFILE
|
||||
#undef __USE_GNU
|
||||
#undef __USE_REENTRANT
|
||||
#undef __USE_FORTIFY_LEVEL
|
||||
#undef __FAVOR_BSD
|
||||
#undef __KERNEL_STRICT_NAMES
|
||||
|
||||
/* Suppress kernel-name space pollution unless user expressedly asks
|
||||
for it. */
|
||||
#ifndef _LOOSE_KERNEL_NAMES
|
||||
# define __KERNEL_STRICT_NAMES
|
||||
#endif
|
||||
|
||||
/* Always use ISO C things. */
|
||||
#define __USE_ANSI 1
|
||||
|
||||
/* Convenience macros to test the versions of glibc and gcc.
|
||||
Use them like this:
|
||||
#if __GNUC_PREREQ (2,8)
|
||||
... code requiring gcc 2.8 or later ...
|
||||
#endif
|
||||
Note - they won't work for gcc1 or glibc1, since the _MINOR macros
|
||||
were not defined then. */
|
||||
#if defined __GNUC__ && defined __GNUC_MINOR__
|
||||
# define __GNUC_PREREQ(maj, min) \
|
||||
((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
|
||||
#else
|
||||
# define __GNUC_PREREQ(maj, min) 0
|
||||
#endif
|
||||
|
||||
|
||||
/* If _BSD_SOURCE was defined by the user, favor BSD over POSIX. */
|
||||
#if defined _BSD_SOURCE && \
|
||||
!(defined _POSIX_SOURCE || defined _POSIX_C_SOURCE || \
|
||||
defined _XOPEN_SOURCE || defined _XOPEN_SOURCE_EXTENDED || \
|
||||
defined _GNU_SOURCE || defined _SVID_SOURCE)
|
||||
# define __FAVOR_BSD 1
|
||||
#endif
|
||||
|
||||
/* If _GNU_SOURCE was defined by the user, turn on all the other features. */
|
||||
#ifdef _GNU_SOURCE
|
||||
# undef _ISOC99_SOURCE
|
||||
# define _ISOC99_SOURCE 1
|
||||
# undef _POSIX_SOURCE
|
||||
# define _POSIX_SOURCE 1
|
||||
# undef _POSIX_C_SOURCE
|
||||
# define _POSIX_C_SOURCE 200809L
|
||||
# undef _XOPEN_SOURCE
|
||||
# define _XOPEN_SOURCE 700
|
||||
# undef _XOPEN_SOURCE_EXTENDED
|
||||
# define _XOPEN_SOURCE_EXTENDED 1
|
||||
# undef _LARGEFILE64_SOURCE
|
||||
# define _LARGEFILE64_SOURCE 1
|
||||
# undef _BSD_SOURCE
|
||||
# define _BSD_SOURCE 1
|
||||
# undef _SVID_SOURCE
|
||||
# define _SVID_SOURCE 1
|
||||
# undef _ATFILE_SOURCE
|
||||
# define _ATFILE_SOURCE 1
|
||||
#endif
|
||||
|
||||
/* This macro indicates that the installed library is uClibc. Use
|
||||
* __UCLIBC_MAJOR__ and __UCLIBC_MINOR__ to test for the features in
|
||||
* specific releases. */
|
||||
#define __UCLIBC__ 1
|
||||
|
||||
#ifdef __UCLIBC__
|
||||
/* Load up the current set of uClibc supported features along
|
||||
* with the current uClibc major and minor version numbers.
|
||||
* For uClibc release 0.9.26, these numbers would be:
|
||||
* #define __UCLIBC_MAJOR__ 0
|
||||
* #define __UCLIBC_MINOR__ 9
|
||||
* #define __UCLIBC_SUBLEVEL__ 26
|
||||
*/
|
||||
# define __need_uClibc_config_h
|
||||
# include <bits/uClibc_config.h>
|
||||
# undef __need_uClibc_config_h
|
||||
|
||||
/* For uClibc, always optimize for size -- this should disable
|
||||
* a lot of expensive inlining...
|
||||
* TODO: this is wrong! __OPTIMIZE_SIZE__ is an indicator of
|
||||
* gcc -Os compile. We should not mess with compiler inlines.
|
||||
* We should instead disable __USE_EXTERN_INLINES unconditionally,
|
||||
* or maybe actually audit and test uclibc to work correctly
|
||||
* with __USE_EXTERN_INLINES on.
|
||||
*/
|
||||
# define __OPTIMIZE_SIZE__ 1
|
||||
|
||||
/* disable unsupported features */
|
||||
# undef __LDBL_COMPAT
|
||||
|
||||
# ifndef __UCLIBC_HAS_FORTIFY__
|
||||
# undef _FORTIFY_SOURCE
|
||||
# endif
|
||||
|
||||
# ifndef __UCLIBC_HAS_THREADS__
|
||||
# if defined _REENTRANT || defined _THREAD_SAFE
|
||||
# warning requested reentrant code, but thread support was disabled
|
||||
# undef _REENTRANT
|
||||
# undef _THREAD_SAFE
|
||||
# endif
|
||||
# endif
|
||||
|
||||
# ifndef __UCLIBC_HAS_LFS__
|
||||
# undef _LARGEFILE64_SOURCE
|
||||
/* NOTE: This is probably incorrect on a 64-bit arch... */
|
||||
# if defined _FILE_OFFSET_BITS && _FILE_OFFSET_BITS == 64
|
||||
# error It appears you have defined _FILE_OFFSET_BITS=64. Unfortunately, \
|
||||
uClibc was built without large file support enabled.
|
||||
# endif
|
||||
# elif defined __BCC__
|
||||
# error BCC does not support LFS, please disable it
|
||||
# endif
|
||||
#endif /* __UCLIBC__ */
|
||||
|
||||
/* If nothing (other than _GNU_SOURCE) is defined,
|
||||
define _BSD_SOURCE and _SVID_SOURCE. */
|
||||
#if (!defined __STRICT_ANSI__ && !defined _ISOC99_SOURCE && \
|
||||
!defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE && \
|
||||
!defined _XOPEN_SOURCE && !defined _XOPEN_SOURCE_EXTENDED && \
|
||||
!defined _BSD_SOURCE && !defined _SVID_SOURCE)
|
||||
# define _BSD_SOURCE 1
|
||||
# define _SVID_SOURCE 1
|
||||
#endif
|
||||
|
||||
/* This is to enable the ISO C99 extension. Also recognize the old macro
|
||||
which was used prior to the standard acceptance. This macro will
|
||||
eventually go away and the features enabled by default once the ISO C99
|
||||
standard is widely adopted. */
|
||||
#if (defined _ISOC99_SOURCE || defined _ISOC9X_SOURCE \
|
||||
|| (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L))
|
||||
# define __USE_ISOC99 1
|
||||
#endif
|
||||
|
||||
/* This is to enable the ISO C90 Amendment 1:1995 extension. */
|
||||
#if (defined _ISOC99_SOURCE || defined _ISOC9X_SOURCE \
|
||||
|| (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199409L))
|
||||
# define __USE_ISOC95 1
|
||||
#endif
|
||||
|
||||
/* If none of the ANSI/POSIX macros are defined, use POSIX.1 and POSIX.2
|
||||
(and IEEE Std 1003.1b-1993 unless _XOPEN_SOURCE is defined). */
|
||||
#if ((!defined __STRICT_ANSI__ || (_XOPEN_SOURCE - 0) >= 500) && \
|
||||
!defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE)
|
||||
# define _POSIX_SOURCE 1
|
||||
# if defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 500
|
||||
# define _POSIX_C_SOURCE 2
|
||||
# elif defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 600
|
||||
# define _POSIX_C_SOURCE 199506L
|
||||
# elif defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 700
|
||||
# define _POSIX_C_SOURCE 200112L
|
||||
# else
|
||||
# define _POSIX_C_SOURCE 200809L
|
||||
# endif
|
||||
# define __USE_POSIX_IMPLICITLY 1
|
||||
#endif
|
||||
|
||||
#if defined _POSIX_SOURCE || _POSIX_C_SOURCE >= 1 || defined _XOPEN_SOURCE
|
||||
# define __USE_POSIX 1
|
||||
#endif
|
||||
|
||||
#if defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 2 || defined _XOPEN_SOURCE
|
||||
# define __USE_POSIX2 1
|
||||
#endif
|
||||
|
||||
#if (_POSIX_C_SOURCE - 0) >= 199309L
|
||||
# define __USE_POSIX199309 1
|
||||
#endif
|
||||
|
||||
#if (_POSIX_C_SOURCE - 0) >= 199506L
|
||||
# define __USE_POSIX199506 1
|
||||
#endif
|
||||
|
||||
#if (_POSIX_C_SOURCE - 0) >= 200112L
|
||||
# define __USE_XOPEN2K 1
|
||||
# undef __USE_ISOC99
|
||||
# define __USE_ISOC99 1
|
||||
#endif
|
||||
|
||||
#if (_POSIX_C_SOURCE - 0) >= 200809L
|
||||
# define __USE_XOPEN2K8 1
|
||||
# undef _ATFILE_SOURCE
|
||||
# define _ATFILE_SOURCE 1
|
||||
#endif
|
||||
|
||||
#ifdef _XOPEN_SOURCE
|
||||
# define __USE_XOPEN 1
|
||||
# if (_XOPEN_SOURCE - 0) >= 500
|
||||
# define __USE_XOPEN_EXTENDED 1
|
||||
# define __USE_UNIX98 1
|
||||
# undef _LARGEFILE_SOURCE
|
||||
# define _LARGEFILE_SOURCE 1
|
||||
# if (_XOPEN_SOURCE - 0) >= 600
|
||||
# if (_XOPEN_SOURCE - 0) >= 700
|
||||
# define __USE_XOPEN2K8 1
|
||||
# endif
|
||||
# define __USE_XOPEN2K 1
|
||||
# undef __USE_ISOC99
|
||||
# define __USE_ISOC99 1
|
||||
# endif
|
||||
# else
|
||||
# ifdef _XOPEN_SOURCE_EXTENDED
|
||||
# define __USE_XOPEN_EXTENDED 1
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef _LARGEFILE_SOURCE
|
||||
# define __USE_LARGEFILE 1
|
||||
#endif
|
||||
|
||||
#ifdef _LARGEFILE64_SOURCE
|
||||
# define __USE_LARGEFILE64 1
|
||||
#endif
|
||||
|
||||
#if defined _FILE_OFFSET_BITS && _FILE_OFFSET_BITS == 64
|
||||
# define __USE_FILE_OFFSET64 1
|
||||
#endif
|
||||
|
||||
#if defined _BSD_SOURCE || defined _SVID_SOURCE
|
||||
# define __USE_MISC 1
|
||||
#endif
|
||||
|
||||
#ifdef _BSD_SOURCE
|
||||
# define __USE_BSD 1
|
||||
#endif
|
||||
|
||||
#ifdef _SVID_SOURCE
|
||||
# define __USE_SVID 1
|
||||
#endif
|
||||
|
||||
#ifdef _ATFILE_SOURCE
|
||||
# define __USE_ATFILE 1
|
||||
#endif
|
||||
|
||||
#ifdef _GNU_SOURCE
|
||||
# define __USE_GNU 1
|
||||
#endif
|
||||
|
||||
#if defined _REENTRANT || defined _THREAD_SAFE
|
||||
# define __USE_REENTRANT 1
|
||||
#endif
|
||||
|
||||
#if defined _FORTIFY_SOURCE && _FORTIFY_SOURCE > 0 \
|
||||
&& __GNUC_PREREQ (4, 1) && defined __OPTIMIZE__ && __OPTIMIZE__ > 0
|
||||
# if _FORTIFY_SOURCE > 1
|
||||
# define __USE_FORTIFY_LEVEL 2
|
||||
# else
|
||||
# define __USE_FORTIFY_LEVEL 1
|
||||
# endif
|
||||
#else
|
||||
# define __USE_FORTIFY_LEVEL 0
|
||||
#endif
|
||||
|
||||
/* We do support the IEC 559 math functionality, real and complex. */
|
||||
#ifdef __UCLIBC_HAS_FLOATS__
|
||||
#define __STDC_IEC_559__ 1
|
||||
#define __STDC_IEC_559_COMPLEX__ 1
|
||||
#endif
|
||||
|
||||
#ifdef __UCLIBC_HAS_WCHAR__
|
||||
/* wchar_t uses ISO 10646-1 (2nd ed., published 2000-09-15) / Unicode 3.1. */
|
||||
#define __STDC_ISO_10646__ 200009L
|
||||
#endif
|
||||
|
||||
/* There is an unwholesomely huge amount of code out there that depends on the
|
||||
* presence of GNU libc header files. We have GNU libc header files. So here
|
||||
* we commit a horrible sin. At this point, we _lie_ and claim to be GNU libc
|
||||
* to make things like /usr/include/linux/socket.h and lots of apps work as
|
||||
* their developers intended. This is IMHO, pardonable, since these defines
|
||||
* are not really intended to check for the presence of a particular library,
|
||||
* but rather are used to define an _interface_. */
|
||||
#if !defined __FORCE_NOGLIBC && (!defined _LIBC || defined __FORCE_GLIBC)
|
||||
/* This macro indicates that the installed library is the GNU C Library.
|
||||
For historic reasons the value now is 6 and this will stay from now
|
||||
on. The use of this variable is deprecated. */
|
||||
/* uClibc WARNING: leave these aligned to the left, don't put a space after '#', else
|
||||
* broken apps could fail the check. */
|
||||
#undef __GNU_LIBRARY__
|
||||
#define __GNU_LIBRARY__ 6
|
||||
|
||||
/* Major and minor version number of the GNU C library package. Use
|
||||
these macros to test for features in specific releases. */
|
||||
/* Don't do it, if you want to keep uClibc happy. */
|
||||
#define __GLIBC__ 2
|
||||
#define __GLIBC_MINOR__ 2
|
||||
#endif
|
||||
|
||||
#define __GLIBC_PREREQ(maj, min) \
|
||||
((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min))
|
||||
|
||||
#ifndef __UCLIBC__
|
||||
/* Decide whether a compiler supports the long long datatypes. */
|
||||
#if defined __GNUC__ \
|
||||
|| (defined __PGI && defined __i386__ ) \
|
||||
|| (defined __INTEL_COMPILER && (defined __i386__ || defined __ia64__)) \
|
||||
|| (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)
|
||||
# define __GLIBC_HAVE_LONG_LONG 1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* This is here only because every header file already includes this one. */
|
||||
#ifndef __ASSEMBLER__
|
||||
# ifndef _SYS_CDEFS_H
|
||||
# include <sys/cdefs.h>
|
||||
# endif
|
||||
|
||||
/* If we don't have __REDIRECT, prototypes will be missing if
|
||||
__USE_FILE_OFFSET64 but not __USE_LARGEFILE[64]. */
|
||||
# if defined __USE_FILE_OFFSET64 && !defined __REDIRECT
|
||||
# define __USE_LARGEFILE 1
|
||||
# ifdef __UCLIBC_HAS_LFS__
|
||||
# define __USE_LARGEFILE64 1
|
||||
# endif
|
||||
# endif
|
||||
|
||||
#endif /* !ASSEMBLER */
|
||||
|
||||
/* Decide whether we can, and are willing to define extern inline
|
||||
* functions in headers, even if this results in a slightly bigger
|
||||
* code for user programs built against uclibc.
|
||||
* Enabled only in -O2 compiles, not -Os.
|
||||
* uclibc itself is usually built without __USE_EXTERN_INLINES,
|
||||
* remove "&& !defined __OPTIMIZE_SIZE__" part to do otherwise.
|
||||
*/
|
||||
#if __GNUC_PREREQ (2, 7) && defined __OPTIMIZE__ \
|
||||
&& !defined __OPTIMIZE_SIZE__ && !defined __NO_INLINE__ \
|
||||
&& (defined __extern_inline || defined __GNUC_GNU_INLINE__ || defined __GNUC_STDC_INLINE__)
|
||||
# define __USE_EXTERN_INLINES 1
|
||||
#endif
|
||||
|
||||
#ifdef _LIBC
|
||||
# ifdef __UCLIBC_HAS_LFS__
|
||||
# undef _FILE_OFFSET_BITS
|
||||
# undef __USE_FILE_OFFSET64
|
||||
# endif
|
||||
# include <libc-internal.h>
|
||||
#endif
|
||||
|
||||
#endif /* features.h */
|
||||
|
|
@ -0,0 +1,312 @@
|
|||
#!/bin/bash
|
||||
|
||||
usage="USAGE: $0 <full path to the NuttX directory>"
|
||||
|
||||
lgpl="\n
|
||||
GNU LESSER GENERAL PUBLIC LICENSE\n
|
||||
\n
|
||||
Version 3, 29 June 2007\n
|
||||
\n
|
||||
Copyright © 2007 Free Software Foundation, Inc. <http://fsf.org/>\n
|
||||
\n
|
||||
Everyone is permitted to copy and distribute verbatim copies of this \n
|
||||
license document, but changing it is not allowed.\n
|
||||
\n
|
||||
This version of the GNU Lesser General Public License incorporates the\n
|
||||
terms and conditions of version 3 of the GNU General Public License,\n
|
||||
supplemented by the additional permissions listed below.\n
|
||||
\n
|
||||
0. Additional Definitions.\n
|
||||
\n
|
||||
As used herein, “this License” refers to version 3 of the GNU Lesser\n
|
||||
General Public License, and the “GNU GPL” refers to version 3 of the\n
|
||||
GNU General Public License.\n
|
||||
\n
|
||||
“The Library” refers to a covered work governed by this License, other\n
|
||||
than an Application or a Combined Work as defined below.\n
|
||||
\n
|
||||
An “Application” is any work that makes use of an interface provided\n
|
||||
by the Library, but which is not otherwise based on the Library. Defining\n
|
||||
a subclass of a class defined by the Library is deemed a mode of using an\n
|
||||
interface provided by the Library.\n
|
||||
\n
|
||||
A “Combined Work” is a work produced by combining or linking an\n
|
||||
Application with the Library. The particular version of the Library with\n
|
||||
which the Combined Work was made is also called the “Linked Version”.\n
|
||||
\n
|
||||
The “Minimal Corresponding Source” for a Combined Work means the\n
|
||||
Corresponding Source for the Combined Work, excluding any source code\n
|
||||
for portions of the Combined Work that, considered in isolation, are based\n
|
||||
on the Application, and not on the Linked Version.\n
|
||||
\n
|
||||
The “Corresponding Application Code” for a Combined Work means the object\n
|
||||
code and/or source code for the Application, including any data and utility\n
|
||||
programs needed for reproducing the Combined Work from the Application,\n
|
||||
but excluding the System Libraries of the Combined Work.\n
|
||||
\n
|
||||
1. Exception to Section 3 of the GNU GPL.\n
|
||||
\n
|
||||
You may convey a covered work under sections 3 and 4 of this License\n
|
||||
without being bound by section 3 of the GNU GPL.\n
|
||||
\n
|
||||
2. Conveying Modified Versions.\n
|
||||
\n
|
||||
If you modify a copy of the Library, and, in your modifications, a\n
|
||||
facility refers to a function or data to be supplied by an Application\n
|
||||
that uses the facility (other than as an argument passed when the facility\n
|
||||
is invoked), then you may convey a copy of the modified version:\n
|
||||
\n
|
||||
a) under this License, provided that you make a good faith effort to\n
|
||||
ensure that, in the event an Application does not supply the function\n
|
||||
or data, the facility still operates, and performs whatever part of\n
|
||||
its purpose remains meaningful, or\n
|
||||
b) under the GNU GPL, with none of the additional permissions of this\n
|
||||
License applicable to that copy.\n
|
||||
\n
|
||||
3. Object Code Incorporating Material from Library Header Files.\n
|
||||
\n
|
||||
The object code form of an Application may incorporate material from a\n
|
||||
header file that is part of the Library. You may convey such object code\n
|
||||
under terms of your choice, provided that, if the incorporated material is\n
|
||||
not limited to numerical parameters, data structure layouts and accessors, or\n
|
||||
small macros, inline functions and templates (ten or fewer lines in length),\n
|
||||
you do both of the following:\n
|
||||
\n
|
||||
a) Give prominent notice with each copy of the object code that the\n
|
||||
Library is used in it and that the Library and its use are covered\n
|
||||
by this License.\n
|
||||
b) Accompany the object code with a copy of the GNU GPL and this license\n
|
||||
document.\n
|
||||
\n
|
||||
4. Combined Works.\n
|
||||
\n
|
||||
You may convey a Combined Work under terms of your choice that, taken\n
|
||||
together, effectively do not restrict modification of the portions of the\n
|
||||
Library contained in the Combined Work and reverse engineering for debugging\n
|
||||
such modifications, if you also do each of the following:\n
|
||||
\n
|
||||
a) Give prominent notice with each copy of the Combined Work that the\n
|
||||
Library is used in it and that the Library and its use are covered by\n
|
||||
this License.\n
|
||||
b) Accompany the Combined Work with a copy of the GNU GPL and this\n
|
||||
license document.\n
|
||||
c) For a Combined Work that displays copyright notices during execution,\n
|
||||
include the copyright notice for the Library among these notices,\n
|
||||
as well as a reference directing the user to the copies of the\n
|
||||
GNU GPL and this license document.\n
|
||||
d) Do one of the following:\n
|
||||
\n
|
||||
0) Convey the Minimal Corresponding Source under the terms of\n
|
||||
this License, and the Corresponding Application Code in a form\n
|
||||
suitable for, and under terms that permit, the user to recombine\n
|
||||
or relink the Application with a modified version of the Linked\n
|
||||
Version to produce a modified Combined Work, in the manner\n
|
||||
specified by section 6 of the GNU GPL for conveying Corresponding\n
|
||||
Source.\n
|
||||
1) Use a suitable shared library mechanism for linking with the Library.\n
|
||||
A suitable mechanism is one that (a) uses at run time a copy of\n
|
||||
the Library already present on the user's computer system, and\n
|
||||
(b) will operate properly with a modified version of the Library\n
|
||||
that is interface-compatible with the Linked Version.\n
|
||||
\n
|
||||
e) Provide Installation Information, but only if you would otherwise\n
|
||||
be required to provide such information under section 6 of the\n
|
||||
GNU GPL, and only to the extent that such information is necessary\n
|
||||
to install and execute a modified version of the Combined Work\n
|
||||
produced by recombining or relinking the Application with a\n
|
||||
modified version of the Linked Version. (If you use option 4d0, the\n
|
||||
Installation Information must accompany the Minimal Corresponding\n
|
||||
Source and Corresponding Application Code. If you use option 4d1,\n
|
||||
you must provide the Installation Information in the manner\n
|
||||
specified by section 6 of the GNU GPL for conveying Corresponding\n
|
||||
Source.)\n
|
||||
\n
|
||||
5. Combined Libraries.\n
|
||||
\n
|
||||
You may place library facilities that are a work based on the Library\n
|
||||
side by side in a single library together with other library facilities\n
|
||||
that are not Applications and are not covered by this License, and convey\n
|
||||
such a combined library under terms of your choice, if you do both of the\n
|
||||
following:\n
|
||||
\n
|
||||
a) Accompany the combined library with a copy of the same work based\n
|
||||
on the Library, uncombined with any other library facilities,\n
|
||||
conveyed under the terms of this License.\n
|
||||
b) Give prominent notice with the combined library that part of it\n
|
||||
is a work based on the Library, and explaining where to find the\n
|
||||
accompanying uncombined form of the same work.\n
|
||||
\n
|
||||
6. Revised Versions of the GNU Lesser General Public License.\n
|
||||
\n
|
||||
The Free Software Foundation may publish revised and/or new versions of\n
|
||||
the GNU Lesser General Public License from time to time. Such new\n
|
||||
versions will be similar in spirit to the present version, but may\n
|
||||
differ in detail to address new problems or concerns.\n
|
||||
\n
|
||||
Each version is given a distinguishing version number. If the Library\n
|
||||
as you received it specifies that a certain numbered version of the\n
|
||||
GNU Lesser General Public License “or any later version” applies to\n
|
||||
it, you have the option of following the terms and conditions either\n
|
||||
of that published version or of any later version published by the Free\n
|
||||
Software Foundation. If the Library as you received it does not specify\n
|
||||
a version number of the GNU Lesser General Public License, you may\n
|
||||
choose any version of the GNU Lesser General Public License ever\n
|
||||
published by the Free Software Foundation.\n
|
||||
\n
|
||||
If the Library as you received it specifies that a proxy can decide\n
|
||||
whether future versions of the GNU Lesser General Public License shall\n
|
||||
apply, that proxy's public statement of acceptance of any version is\n
|
||||
permanent authorization for you to choose that version for the Library.\n"
|
||||
|
||||
# readans prompt default
|
||||
|
||||
function readans () {
|
||||
echo -n "$1 ($2): "
|
||||
IFS='@' read ans || exit 1
|
||||
[ -z "$ans" ] && ans=$2
|
||||
}
|
||||
|
||||
# readyn prompt default
|
||||
|
||||
function readyn () {
|
||||
while :; do
|
||||
readans "$1 [Y/N]" $2
|
||||
case "$ans" in
|
||||
[yY] | [yY]es )
|
||||
ans=y
|
||||
break ;;
|
||||
[nN] | [nN]o )
|
||||
ans=n
|
||||
break ;;
|
||||
* )
|
||||
echo "Please answer Y or N"
|
||||
;;
|
||||
esac
|
||||
done
|
||||
}
|
||||
|
||||
# Get the single, required command line argument
|
||||
|
||||
nuttx_path=$1
|
||||
if [ -z "${nuttx_path}" ]; then
|
||||
echo "ERROR: Missing path to the NuttX directory"
|
||||
echo $usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Lots of sanity checking so that we do not do anything too stupid
|
||||
|
||||
if [ ! -d libxx ]; then
|
||||
echo "ERROR: Directory libxx does not exist in this directory"
|
||||
echo " Please CD into the misc/uClibc++ directory and try again"
|
||||
echo $usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ ! -d include ]; then
|
||||
echo "ERROR: Directory include does not exist in this directory"
|
||||
echo " Please CD into the misc/uClibc++ directory and try again"
|
||||
echo $usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ ! -d "${nuttx_path}" ]; then
|
||||
echo "ERROR: Directory ${nuttx_path} does not exist"
|
||||
echo $usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ ! -f "${nuttx_path}/Makefile" ]; then
|
||||
echo "ERROR: Not Makefile in directory ${nuttx_path}"
|
||||
echo $usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
libxx_srcdir=${nuttx_path}/libxx
|
||||
|
||||
if [ ! -d "${libxx_srcdir}" ]; then
|
||||
echo "ERROR: Directory ${libxx_srcdir} does not exist"
|
||||
echo $usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ ! -f "${libxx_srcdir}/Makefile" ]; then
|
||||
echo "ERROR: No Makefile in directory ${libxx_srcdir}"
|
||||
echo $usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
uclibc_srcdir=${libxx_srcdir}/uClibc++
|
||||
|
||||
if [ -d "${uclibc_srcdir}" ]; then
|
||||
echo "ERROR: Directory ${uclibc_srcdir} already exists"
|
||||
echo " Please remove the ${uclibc_srcdir} directory and try again"
|
||||
echo $usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
nuttx_incdir=${nuttx_path}/include
|
||||
|
||||
if [ ! -d "${nuttx_incdir}" ]; then
|
||||
echo "ERROR: Directory ${nuttx_incdir} does not exist"
|
||||
echo $usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
nuttxcxx_incdir=${nuttx_incdir}/cxx
|
||||
|
||||
if [ ! -d "${nuttxcxx_incdir}" ]; then
|
||||
echo "ERROR: Directory ${nuttxcxx_incdir} does not exist"
|
||||
echo $usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Licensing
|
||||
|
||||
echo "You are about to install the uClibc++ library into the NuttX source"
|
||||
echo "tree. NuttX is licensed under a modified BSD License; uClibc is"
|
||||
echo "licensed under the GNU LGPL Version 3 license. When you install"
|
||||
echo "uClibc++ into the NuttX source tree, you must then comply with uClibc's"
|
||||
echo "stricter GNU LGPL Version 3 license."
|
||||
echo ""
|
||||
|
||||
readyn "Continue" "N"
|
||||
echo ""
|
||||
|
||||
if [ "X${ans}" != "Xy" -a "X${ans}" != "XY" ]; then
|
||||
echo "Good bye"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
echo "You must read and agree to the following license"
|
||||
echo ""
|
||||
|
||||
readyn "Continue" "N"
|
||||
echo ""
|
||||
|
||||
if [ "X${ans}" != "Xy" -a "X${ans}" != "XY" ]; then
|
||||
echo "Good bye"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
echo -e ${lgpl} | more
|
||||
echo ""
|
||||
|
||||
readyn "I agree to the termso the GNU LGPL Version 3 license" "N"
|
||||
echo ""
|
||||
|
||||
if [ "X${ans}" != "Xy" -a "X${ans}" != "XY" ]; then
|
||||
echo "Good bye"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
echo "Installing uClibc++ in the NuttX source tree"
|
||||
|
||||
cp -a ./libxx/* ${libxx_srcdir}/. ||
|
||||
{ echo "Copy from ./libxx/* to ${libxx_srcdir}/. failed"; exit 1; }
|
||||
|
||||
cp -a ./include/* ${nuttx_incdir}/. ||
|
||||
{ echo "Copy from ./include/* ${nuttx_incdir}/. failed"; exit 1; }
|
||||
|
||||
echo "Installation suceeded"
|
||||
echo ""
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
############################################################################
|
||||
# misc/uClibc++/libxx/uClibc++/Makefile
|
||||
#
|
||||
# Copyright (C) 2012 Gregory Nutt. All rights reserved.
|
||||
# Author: Gregory Nutt <spudmonkey@racsa.co.cr>
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in
|
||||
# the documentation and/or other materials provided with the
|
||||
# distribution.
|
||||
# 3. Neither the name NuttX nor the names of its contributors may be
|
||||
# used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
# POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
###########################################################################
|
||||
|
||||
# Add the uClibc++ sources
|
||||
|
||||
CXXSRCS += algorithm.cxx associative_base.cxx bitset.cxx char_traits.cxx
|
||||
CXXSRCS += complex.cxx del_op.cxx del_opnt.cxx del_opv.cxx del_opvnt.cxx
|
||||
CXXSRCS += deque.cxx eh_alloc.cxx eh_globals.cxx exception.cxx
|
||||
CXXSRCS += stream.cxx func_exception.cxx iomanip.cxx ios.cxx
|
||||
CXXSRCS += iostream.cxx istream.cxx iterator.cxx limits.cxx list.cxx
|
||||
CXXSRCS += locale.cxx map.cxx new_handler.cxx new_op.cxx new_opnt.cxx
|
||||
CXXSRCS += new_opv.cxx new_opvnt.cxx numeric.cxx ostream.cxx queue.cxx
|
||||
CXXSRCS += set.cxx sstream.cxx stack.cxx stdexcept.cxx streambuf.cxx
|
||||
CXXSRCS += string.cxx support.cxx typeinfo.cxx utility.cxx valarray.cxx
|
||||
CXXSRCS += vector.cxx
|
||||
|
||||
# Add the path to the uClibc++ subdirectory
|
||||
|
||||
DEPPATH += --dep-path .
|
||||
VPATH += uClibc++
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
/* Copyright (C) 2007 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
#include <associative_base>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
#include <bitset>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
#define __UCLIBCXX_COMPILE_CHAR_TRAITS__ 1
|
||||
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <char_traits>
|
||||
|
||||
namespace std{
|
||||
|
||||
_UCXXEXPORT const char_traits<char>::char_type* char_traits<char>::find(const char_type* s, int n, const char_type& a){
|
||||
for(int i=0; i < n; i++){
|
||||
if(eq(s[i], a)){
|
||||
return (s+i);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
_UCXXEXPORT bool char_traits<char>::eq(const char_type& c1, const char_type& c2){
|
||||
if(strncmp(&c1, &c2, 1) == 0){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
_UCXXEXPORT char_traits<char>::char_type char_traits<char>::to_char_type(const int_type & i){
|
||||
if(i > 0 && i <= 255){
|
||||
return (char)(unsigned char)i;
|
||||
}
|
||||
|
||||
//Out of range
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
|
||||
_UCXXEXPORT const char_traits<wchar_t>::char_type* char_traits<wchar_t>::find(const char_type* s, int n, const char_type& a){
|
||||
for(int i=0; i < n; i++){
|
||||
if(eq(s[i], a)){
|
||||
return (s+i);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
/* Copyright (C) 2005 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <complex>
|
||||
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
template class _UCXXEXPORT complex<float>;
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <new>
|
||||
#include <cstdlib>
|
||||
#include <func_exception>
|
||||
|
||||
_UCXXEXPORT void operator delete(void* ptr) throw(){
|
||||
free(ptr);
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <new>
|
||||
#include <cstdlib>
|
||||
#include <func_exception>
|
||||
|
||||
#ifndef NO_NOTHROW
|
||||
_UCXXEXPORT void operator delete(void* ptr, const std::nothrow_t& ) throw() {
|
||||
free(ptr);
|
||||
}
|
||||
#endif
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <new>
|
||||
#include <cstdlib>
|
||||
#include <func_exception>
|
||||
|
||||
_UCXXEXPORT void operator delete[](void * ptr) throw(){
|
||||
free(ptr);
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <new>
|
||||
#include <cstdlib>
|
||||
#include <func_exception>
|
||||
|
||||
#ifndef NO_NOTHROW
|
||||
_UCXXEXPORT void operator delete[](void* ptr, const std::nothrow_t& ) throw(){
|
||||
free(ptr);
|
||||
}
|
||||
#endif
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
#include <deque>
|
||||
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
/* Copyright (C) 2006 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation, version 2.1
|
||||
of the License.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <func_exception>
|
||||
|
||||
//This is a system-specific header which does all of the error-handling management
|
||||
#include <unwind-cxx.h>
|
||||
|
||||
namespace __cxxabiv1{
|
||||
|
||||
extern "C" void * __cxa_allocate_exception(std::size_t thrown_size) throw(){
|
||||
void *retval;
|
||||
//The sizeof crap is required by Itanium ABI because we need to provide space for
|
||||
//accounting information which is implementaion (gcc) specified
|
||||
retval = malloc (thrown_size + sizeof(__cxa_exception));
|
||||
if (0 == retval){
|
||||
std::terminate();
|
||||
}
|
||||
memset (retval, 0, sizeof(__cxa_exception));
|
||||
return (void *)((unsigned char *)retval + sizeof(__cxa_exception));
|
||||
}
|
||||
|
||||
extern "C" void __cxa_free_exception(void *vptr) throw(){
|
||||
free( (char *)(vptr) - sizeof(__cxa_exception) );
|
||||
}
|
||||
|
||||
|
||||
extern "C" __cxa_dependent_exception * __cxa_allocate_dependent_exception() throw(){
|
||||
__cxa_dependent_exception *retval;
|
||||
//The sizeof crap is required by Itanium ABI because we need to provide space for
|
||||
//accounting information which is implementaion (gcc) specified
|
||||
retval = static_cast<__cxa_dependent_exception*>(malloc (sizeof(__cxa_dependent_exception)));
|
||||
if (0 == retval){
|
||||
std::terminate();
|
||||
}
|
||||
memset (retval, 0, sizeof(__cxa_dependent_exception));
|
||||
return retval;
|
||||
}
|
||||
|
||||
extern "C" void __cxa_free_dependent_exception(__cxa_dependent_exception *vptr) throw(){
|
||||
free( (char *)(vptr) );
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
/* Copyright (C) 2006 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation, version 2.1
|
||||
of the License.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <func_exception>
|
||||
|
||||
//This is a system-specific header which does all of the error-handling management
|
||||
#include <unwind-cxx.h>
|
||||
|
||||
//The following functionality is derived from reading of the GNU libstdc++ code and making it...simple
|
||||
|
||||
|
||||
namespace __cxxabiv1{
|
||||
|
||||
static __UCLIBCXX_TLS __cxa_eh_globals eh_globals;
|
||||
|
||||
extern "C" __cxa_eh_globals* __cxa_get_globals() throw(){
|
||||
return &eh_globals;
|
||||
}
|
||||
|
||||
extern "C" __cxa_eh_globals* __cxa_get_globals_fast() throw(){
|
||||
return &eh_globals;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
#include <exception>
|
||||
|
||||
//We can't do this yet because gcc is too stupid to be able to handle
|
||||
//different implementations of exception class.
|
||||
|
||||
#undef __UCLIBCXX_EXCEPTION_SUPPORT__
|
||||
|
||||
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
|
||||
|
||||
namespace std{
|
||||
_UCXXEXPORT static char * __std_exception_what_value = "exception";
|
||||
|
||||
//We are providing our own versions to be sneaky
|
||||
|
||||
|
||||
_UCXXEXPORT exception::~exception() throw(){
|
||||
//Empty function
|
||||
}
|
||||
|
||||
_UCXXEXPORT const char* exception::what() const throw(){
|
||||
return __std_exception_what_value;
|
||||
}
|
||||
|
||||
_UCXXEXPORT bad_exception::~bad_exception() throw(){
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,174 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#define __UCLIBCXX_COMPILE_FSTREAM__ 1
|
||||
|
||||
#include <fstream>
|
||||
|
||||
namespace std{
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_FSTREAM_CHAR__
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT filebuf::basic_filebuf();
|
||||
template _UCXXEXPORT filebuf::~basic_filebuf();
|
||||
|
||||
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT filebuf::int_type filebuf::pbackfail(filebuf::int_type c);
|
||||
template _UCXXEXPORT filebuf * filebuf::open(const char* s, ios_base::openmode mode);
|
||||
template _UCXXEXPORT filebuf * filebuf::close();
|
||||
template _UCXXEXPORT filebuf::int_type filebuf::overflow(filebuf::int_type);
|
||||
template _UCXXEXPORT filebuf::int_type filebuf::underflow ();
|
||||
template _UCXXEXPORT streamsize filebuf::xsputn(const char* s, streamsize n);
|
||||
|
||||
template _UCXXEXPORT basic_streambuf<char, char_traits<char> >*
|
||||
filebuf::setbuf(char * s, streamsize n);
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT basic_ofstream<char, char_traits<char> >::basic_ofstream();
|
||||
template _UCXXEXPORT basic_ofstream<char, char_traits<char> >::basic_ofstream(const char* s, ios_base::openmode mode);
|
||||
template _UCXXEXPORT basic_ofstream<char, char_traits<char> >::~basic_ofstream();
|
||||
|
||||
template _UCXXEXPORT basic_ifstream<char, char_traits<char> >::basic_ifstream();
|
||||
template _UCXXEXPORT basic_ifstream<char, char_traits<char> >::basic_ifstream(const char* s, ios_base::openmode mode);
|
||||
template _UCXXEXPORT basic_ifstream<char, char_traits<char> >::~basic_ifstream();
|
||||
|
||||
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_WCHAR__
|
||||
|
||||
template <> _UCXXEXPORT basic_filebuf<wchar_t, char_traits<wchar_t> >::int_type
|
||||
basic_filebuf<wchar_t, char_traits<wchar_t> >::overflow(int_type c)
|
||||
{
|
||||
typedef basic_streambuf<wchar_t, char_traits<wchar_t> > wstreambuf;
|
||||
typedef char_traits<wchar_t> wtraits;
|
||||
|
||||
if(is_open() == false){
|
||||
//Can't do much
|
||||
return wtraits::eof();
|
||||
}
|
||||
|
||||
mbstate_t ps = { 0 };
|
||||
char out_array[8];
|
||||
size_t out_size;
|
||||
|
||||
|
||||
if( wstreambuf::pbase() != 0 ){
|
||||
|
||||
//Write all possible character from the existing array first
|
||||
size_t chars_written = 0;
|
||||
while(wstreambuf::pbase() && (wstreambuf::pbase() + chars_written !=wstreambuf::pptr()) ){
|
||||
out_size = wcrtomb(out_array, wstreambuf::pbase()[chars_written], &ps);
|
||||
if(out_size == (size_t)(-1) || fwrite(out_array, out_size, 1, fp) == 0){
|
||||
break;
|
||||
}
|
||||
++chars_written;
|
||||
}
|
||||
|
||||
if( wstreambuf::pbase() + chars_written == wstreambuf::pptr() ){
|
||||
wstreambuf::pbump(-chars_written);
|
||||
}else{
|
||||
//Shuffle data back into order
|
||||
size_t chars_left = wstreambuf::pptr() - wstreambuf::pbase() - chars_written;
|
||||
for(size_t i = 0; i < chars_left; ++i){
|
||||
wstreambuf::pbase()[i] = (wstreambuf::pptr() - chars_written)[i];
|
||||
}
|
||||
return wtraits::eof();
|
||||
}
|
||||
}
|
||||
|
||||
if( !wtraits::eq_int_type(c, wtraits::eof()) ){
|
||||
out_size = wcrtomb(out_array, c, &ps);
|
||||
if(out_size == (size_t)(-1) || fwrite(out_array, out_size, 1, fp) == 0){
|
||||
return wtraits::eof();
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
return wtraits::not_eof(c);
|
||||
}
|
||||
|
||||
|
||||
template <> _UCXXEXPORT basic_filebuf<wchar_t, char_traits<wchar_t> >::int_type
|
||||
basic_filebuf<wchar_t, char_traits<wchar_t> >::underflow()
|
||||
{
|
||||
/*Some variables used internally:
|
||||
Buffer pointers:
|
||||
|
||||
charT * mgbeg;
|
||||
charT * mgnext;
|
||||
charT * mgend;
|
||||
|
||||
eback() returns mgbeg
|
||||
gptr() returns mgnext
|
||||
egptr() returns mgend
|
||||
|
||||
gbump(int n) mgnext+=n
|
||||
*/
|
||||
|
||||
typedef char_traits<wchar_t> traits;
|
||||
typedef basic_streambuf<wchar_t, traits> wstreambuf;
|
||||
|
||||
|
||||
if(wstreambuf::eback() == wstreambuf::gptr() && 0 != wstreambuf::eback()){ //Buffer is full
|
||||
return traits::to_int_type(*wstreambuf::gptr());
|
||||
}
|
||||
|
||||
size_t in_size;
|
||||
|
||||
wchar_t c = 0;
|
||||
wint_t wi = 0;
|
||||
in_size = 0;
|
||||
|
||||
wi = fgetwc(fp);
|
||||
if(WEOF == wi){
|
||||
fprintf(stderr, "WEOF returned by fgetwc\n");
|
||||
return traits::eof();
|
||||
}
|
||||
|
||||
c = traits::to_char_type(wi);
|
||||
|
||||
if(wstreambuf::eback() == 0){
|
||||
return traits::to_int_type(c);
|
||||
}
|
||||
|
||||
for(wchar_t * i = wstreambuf::gptr(); i < wstreambuf::egptr(); ++i){
|
||||
*(i-1) = *i;
|
||||
}
|
||||
|
||||
*(wstreambuf::egptr()-1) = c;
|
||||
|
||||
wstreambuf::mgnext -= 1;
|
||||
|
||||
return traits::to_int_type(*wstreambuf::gptr());
|
||||
}
|
||||
|
||||
#endif // __UCLIBCXX_HAS_WCHAR__
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <exception>
|
||||
#include <func_exception>
|
||||
#include <stdexcept>
|
||||
#include <cstdlib>
|
||||
|
||||
namespace std{
|
||||
|
||||
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
|
||||
|
||||
_UCXXEXPORT void __throw_bad_alloc(){
|
||||
throw bad_alloc();
|
||||
}
|
||||
|
||||
_UCXXEXPORT void __throw_out_of_range( const char * message){
|
||||
if(message == 0){
|
||||
throw out_of_range();
|
||||
}
|
||||
throw out_of_range(message);
|
||||
}
|
||||
|
||||
_UCXXEXPORT void __throw_overflow_error( const char * message){
|
||||
if(message == 0){
|
||||
throw overflow_error();
|
||||
}
|
||||
throw overflow_error(message);
|
||||
}
|
||||
|
||||
_UCXXEXPORT void __throw_length_error(const char * message){
|
||||
if(message == 0){
|
||||
throw length_error();
|
||||
}
|
||||
throw length_error(message);
|
||||
}
|
||||
|
||||
_UCXXEXPORT void __throw_invalid_argument(const char * message){
|
||||
if(message == 0){
|
||||
throw invalid_argument();
|
||||
}
|
||||
throw invalid_argument(message);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
_UCXXEXPORT void __throw_bad_alloc(){
|
||||
abort();
|
||||
}
|
||||
|
||||
_UCXXEXPORT void __throw_out_of_range( const char * ){
|
||||
abort();
|
||||
}
|
||||
|
||||
_UCXXEXPORT void __throw_overflow_error( const char * ){
|
||||
abort();
|
||||
}
|
||||
|
||||
_UCXXEXPORT void __throw_length_error(const char * ){
|
||||
abort();
|
||||
}
|
||||
|
||||
_UCXXEXPORT void __throw_invalid_argument(const char *){
|
||||
abort();
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
/* Copyright (C) 2005 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <iomanip>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,189 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#define __UCLIBCXX_COMPILE_IOS__ 1
|
||||
|
||||
#include <ios>
|
||||
#include <ostream>
|
||||
#include <istream>
|
||||
#include <cstdio>
|
||||
#include <fstream>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_SUPPORT_CDIR__
|
||||
_UCXXLOCAL int ios_base::Init::init_cnt = 0; //Needed to ensure the static value is created
|
||||
|
||||
//Create buffers first
|
||||
#ifdef __UCLIBCXX_SUPPORT_COUT__
|
||||
_UCXXEXPORT filebuf _cout_filebuf;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CIN__
|
||||
_UCXXEXPORT filebuf _cin_filebuf;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CERR__
|
||||
_UCXXEXPORT filebuf _cerr_filebuf;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CLOG__
|
||||
_UCXXEXPORT filebuf _clog_filebuf;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCOUT__
|
||||
_UCXXEXPORT wfilebuf _wcout_filebuf;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCIN__
|
||||
_UCXXEXPORT wfilebuf _wcin_filebuf;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCERR__
|
||||
_UCXXEXPORT wfilebuf _wcerr_filebuf;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCLOG__
|
||||
_UCXXEXPORT wfilebuf _wclog_filebuf;
|
||||
#endif
|
||||
|
||||
//Then create streams
|
||||
#ifdef __UCLIBCXX_SUPPORT_COUT__
|
||||
_UCXXEXPORT ostream cout(&_cout_filebuf);
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CIN__
|
||||
_UCXXEXPORT istream cin(&_cin_filebuf);
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CERR__
|
||||
_UCXXEXPORT ostream cerr(&_cerr_filebuf);
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CLOG__
|
||||
_UCXXEXPORT ostream clog(&_clog_filebuf);
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCOUT__
|
||||
_UCXXEXPORT wostream wcout(&_wcout_filebuf);
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCIN__
|
||||
_UCXXEXPORT wistream wcin(&_wcin_filebuf);
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCERR__
|
||||
_UCXXEXPORT wostream wcerr(&_wcerr_filebuf);
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCLOG__
|
||||
_UCXXEXPORT wostream wclog(&_wclog_filebuf);
|
||||
#endif
|
||||
|
||||
|
||||
_UCXXEXPORT ios_base::Init::Init(){
|
||||
if(init_cnt == 0){ //Need to construct cout et al
|
||||
#ifdef __UCLIBCXX_SUPPORT_COUT__
|
||||
_cout_filebuf.fp = stdout;
|
||||
_cout_filebuf.openedFor = ios_base::out;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CERR__
|
||||
_cerr_filebuf.fp = stderr;
|
||||
_cerr_filebuf.openedFor = ios_base::out;
|
||||
cerr.mformat |= ios_base::unitbuf;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CLOG__
|
||||
_clog_filebuf.fp = stderr;
|
||||
_clog_filebuf.openedFor = ios_base::out;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_CIN__
|
||||
_cin_filebuf.fp = stdin;
|
||||
_cin_filebuf.openedFor = ios_base::in;
|
||||
|
||||
#ifdef __UCLIBCXX_SUPPORT_COUT__
|
||||
cin.tie(&cout);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCOUT__
|
||||
_wcout_filebuf.fp = stdout;
|
||||
_wcout_filebuf.openedFor = ios_base::out;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCERR__
|
||||
_wcerr_filebuf.fp = stderr;
|
||||
_wcerr_filebuf.openedFor = ios_base::out;
|
||||
wcerr.mformat |= ios_base::unitbuf;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCLOG__
|
||||
_wclog_filebuf.fp = stderr;
|
||||
_wclog_filebuf.openedFor = ios_base::out;
|
||||
#endif
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCIN__
|
||||
_wcin_filebuf.fp = stdin;
|
||||
_wcin_filebuf.openedFor = ios_base::in;
|
||||
|
||||
#ifdef __UCLIBCXX_SUPPORT_WCOUT__
|
||||
wcin.tie(&wcout);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
}
|
||||
init_cnt++;
|
||||
}
|
||||
|
||||
_UCXXEXPORT ios_base::Init::~Init(){
|
||||
--init_cnt;
|
||||
if(init_cnt==0){
|
||||
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_IOS_CHAR__
|
||||
|
||||
template _UCXXEXPORT void basic_ios<char, char_traits<char> >::clear(iostate state);
|
||||
template _UCXXEXPORT void basic_ios<char, char_traits<char> >::setstate(iostate state);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
_UCXXEXPORT ios_base::fmtflags ios_base::flags(fmtflags fmtfl){
|
||||
fmtflags temp = mformat;
|
||||
mformat = fmtfl;
|
||||
return temp;
|
||||
}
|
||||
|
||||
_UCXXEXPORT ios_base::fmtflags ios_base::setf(fmtflags fmtfl){
|
||||
return flags(flags() | fmtfl);
|
||||
}
|
||||
|
||||
_UCXXEXPORT ios_base::fmtflags ios_base::setf(fmtflags fmtfl, fmtflags mask ){
|
||||
return flags( (flags()& ~mask) | (fmtfl & mask));
|
||||
}
|
||||
|
||||
_UCXXEXPORT streamsize ios_base::precision(streamsize prec){
|
||||
streamsize temp = mprecision;
|
||||
mprecision = prec;
|
||||
return temp;
|
||||
}
|
||||
|
||||
_UCXXEXPORT streamsize ios_base::width(streamsize wide){
|
||||
streamsize temp = mwidth;
|
||||
mwidth = wide;
|
||||
return temp;
|
||||
}
|
||||
|
||||
_UCXXEXPORT locale ios_base::imbue(const locale& loc){
|
||||
locale retval = mLocale;
|
||||
mLocale = loc;
|
||||
return retval;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#define __UCLIBCXX_COMPILE_IOSTREAM__ 1
|
||||
|
||||
#include <iostream>
|
||||
|
||||
namespace std{
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
|
||||
#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
|
||||
|
||||
template _UCXXEXPORT basic_iostream<char, char_traits<char> >::
|
||||
basic_iostream(basic_streambuf<char, char_traits<char> >* sb);
|
||||
template _UCXXEXPORT basic_iostream<char, char_traits<char> >::~basic_iostream();
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,75 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
#define __UCLIBCXX_COMPILE_ISTREAM__ 1
|
||||
|
||||
#include <istream>
|
||||
|
||||
|
||||
namespace std{
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
|
||||
|
||||
template <> _UCXXEXPORT string _readToken<char, char_traits<char> >(istream & stream)
|
||||
{
|
||||
string temp;
|
||||
char_traits<char>::int_type c;
|
||||
while(true){
|
||||
c = stream.rdbuf()->sgetc();
|
||||
if(c != char_traits<char>::eof() && isspace(c) == false){
|
||||
stream.rdbuf()->sbumpc();
|
||||
temp.append(1, char_traits<char>::to_char_type(c));
|
||||
}else{
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (temp.size() == 0)
|
||||
stream.setstate(ios_base::eofbit|ios_base::failbit);
|
||||
|
||||
return temp;
|
||||
}
|
||||
|
||||
template _UCXXEXPORT istream::int_type istream::get();
|
||||
template _UCXXEXPORT istream & istream::get(char &c);
|
||||
|
||||
template _UCXXEXPORT istream & istream::operator>>(bool &n);
|
||||
template _UCXXEXPORT istream & istream::operator>>(short &n);
|
||||
template _UCXXEXPORT istream & istream::operator>>(unsigned short &n);
|
||||
template _UCXXEXPORT istream & istream::operator>>(int &n);
|
||||
template _UCXXEXPORT istream & istream::operator>>(unsigned int &n);
|
||||
template _UCXXEXPORT istream & istream::operator>>(long unsigned &n);
|
||||
template _UCXXEXPORT istream & istream::operator>>(long int &n);
|
||||
template _UCXXEXPORT istream & istream::operator>>(void *& p);
|
||||
template _UCXXEXPORT istream & operator>>(istream & is, char & c);
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_HAS_FLOATS__
|
||||
template _UCXXEXPORT istream & istream::operator>>(float &f);
|
||||
template _UCXXEXPORT istream & istream::operator>>(double &f);
|
||||
template _UCXXEXPORT istream & istream::operator>>(long double &f);
|
||||
#endif
|
||||
|
||||
template _UCXXEXPORT void __skipws(basic_istream<char, char_traits<char> >& is);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <iterator>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
/* Copyright (C) 2006 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
#include <limits>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <list>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <locale>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <stdexcept>
|
||||
#include <cctype>
|
||||
|
||||
namespace std{
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
#include <map>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
/* Copyright (C) 2005 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <new>
|
||||
|
||||
const std::nothrow_t std::nothrow = { };
|
||||
|
||||
//Name selected to be compatable with g++ code
|
||||
std::new_handler __new_handler;
|
||||
|
||||
_UCXXEXPORT std::new_handler std::set_new_handler(std::new_handler new_p) throw(){
|
||||
std::new_handler retval = __new_handler;
|
||||
__new_handler = new_p;
|
||||
return retval;
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <new>
|
||||
#include <cstdlib>
|
||||
#include <func_exception>
|
||||
|
||||
_UCXXEXPORT void* operator new(std::size_t numBytes) throw(std::bad_alloc){
|
||||
//C++ stardard 5.3.4.8 requires that a valid pointer be returned for
|
||||
//a call to new(0). Thus:
|
||||
if(numBytes == 0){
|
||||
numBytes = 1;
|
||||
}
|
||||
void * p = malloc(numBytes);
|
||||
if(p == 0){
|
||||
std::__throw_bad_alloc();
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <new>
|
||||
#include <cstdlib>
|
||||
#include <func_exception>
|
||||
|
||||
#ifndef NO_NOTHROW
|
||||
_UCXXEXPORT void* operator new(std::size_t numBytes, const std::nothrow_t& ) throw(){
|
||||
return malloc(numBytes);
|
||||
}
|
||||
#endif
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <new>
|
||||
#include <cstdlib>
|
||||
#include <func_exception>
|
||||
|
||||
_UCXXEXPORT void* operator new[](std::size_t numBytes) throw(std::bad_alloc){
|
||||
//C++ stardard 5.3.4.8 requires that a valid pointer be returned for
|
||||
//a call to new(0). Thus:
|
||||
if(numBytes == 0){
|
||||
numBytes = 1;
|
||||
}
|
||||
void * p = malloc(numBytes);
|
||||
if(p == 0){
|
||||
std::__throw_bad_alloc();
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <new>
|
||||
#include <cstdlib>
|
||||
#include <func_exception>
|
||||
|
||||
#ifndef NO_NOTHROW
|
||||
_UCXXEXPORT void* operator new[](std::size_t numBytes, const std::nothrow_t& ) throw(){
|
||||
return malloc(numBytes);
|
||||
}
|
||||
#endif
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <numeric>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#define __UCLIBCXX_COMPILE_OSTREAM__ 1
|
||||
|
||||
#include <ostream>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
template _UCXXEXPORT ostream::~basic_ostream();
|
||||
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT ostream & ostream::flush();
|
||||
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(bool n);
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(short int n);
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(unsigned short int n);
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(int n);
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(unsigned int n);
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(long n);
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(unsigned long n);
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(float f);
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(double f);
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(long double f);
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(void* p);
|
||||
template _UCXXEXPORT ostream & ostream::operator<<(basic_streambuf<char, char_traits<char> >* sb);
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT ostream::sentry::sentry(ostream & os);
|
||||
template _UCXXEXPORT ostream::sentry::~sentry();
|
||||
|
||||
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT ostream & endl(ostream & os);
|
||||
template _UCXXEXPORT ostream & flush(ostream & os);
|
||||
template _UCXXEXPORT ostream & operator<<(ostream & out, char c);
|
||||
template _UCXXEXPORT ostream & operator<<(ostream & out, const char* c);
|
||||
template _UCXXEXPORT ostream & operator<<(ostream & out, unsigned char c);
|
||||
template _UCXXEXPORT ostream & operator<<(ostream & out, const unsigned char* c);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <queue>
|
||||
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
#include <set>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#define __UCLIBCXX_COMPILE_SSTREAM__ 1
|
||||
|
||||
#include <sstream>
|
||||
|
||||
namespace std{
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_SSTREAM_CHAR__
|
||||
|
||||
typedef char_traits<char> tr_ch;
|
||||
typedef basic_stringbuf<char, tr_ch, allocator<char> > char_stringbuf;
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT char_stringbuf::basic_stringbuf(ios_base::openmode which);
|
||||
template _UCXXEXPORT char_stringbuf::~basic_stringbuf();
|
||||
|
||||
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT basic_string<char, char_traits<char>, allocator<char> > char_stringbuf::str() const;
|
||||
template _UCXXEXPORT char_stringbuf::int_type char_stringbuf::pbackfail(char_stringbuf::int_type c);
|
||||
template _UCXXEXPORT char_stringbuf::int_type char_stringbuf::overflow(char_stringbuf::int_type c);
|
||||
template _UCXXEXPORT char_stringbuf::pos_type
|
||||
char_stringbuf::seekoff(char_stringbuf::off_type, ios_base::seekdir, ios_base::openmode);
|
||||
template _UCXXEXPORT char_stringbuf::int_type char_stringbuf::underflow ();
|
||||
template _UCXXEXPORT streamsize char_stringbuf::xsputn(const char* s, streamsize n);
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT basic_stringstream<char, tr_ch, allocator<char> >::basic_stringstream(ios_base::openmode which);
|
||||
template _UCXXEXPORT basic_istringstream<char, tr_ch, allocator<char> >::~basic_istringstream();
|
||||
template _UCXXEXPORT basic_ostringstream<char, tr_ch, allocator<char> >::~basic_ostringstream();
|
||||
template _UCXXEXPORT basic_stringstream<char, tr_ch, allocator<char> >::~basic_stringstream();
|
||||
|
||||
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <stack>
|
||||
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <exception>
|
||||
#include <stdexcept>
|
||||
|
||||
#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
|
||||
|
||||
namespace std{
|
||||
|
||||
_UCXXEXPORT logic_error::logic_error() throw() : mstring(){
|
||||
|
||||
}
|
||||
|
||||
_UCXXEXPORT logic_error::logic_error(const string& what_arg) : mstring(what_arg){
|
||||
|
||||
}
|
||||
|
||||
_UCXXEXPORT const char * logic_error::what() const throw(){
|
||||
return mstring.c_str();
|
||||
}
|
||||
|
||||
|
||||
_UCXXEXPORT out_of_range::out_of_range() : logic_error(){
|
||||
|
||||
}
|
||||
|
||||
_UCXXEXPORT out_of_range::out_of_range(const string & what_arg) : logic_error(what_arg) {
|
||||
|
||||
}
|
||||
|
||||
_UCXXEXPORT runtime_error::runtime_error() : mstring(){
|
||||
|
||||
}
|
||||
|
||||
_UCXXEXPORT runtime_error::runtime_error(const string& what_arg) : mstring(what_arg){
|
||||
|
||||
}
|
||||
|
||||
_UCXXEXPORT const char * runtime_error::what() const throw(){
|
||||
return mstring.c_str();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#define __UCLIBCXX_COMPILE_STREAMBUF__ 1
|
||||
|
||||
#include <streambuf>
|
||||
|
||||
namespace std{
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_STREAMBUF_CHAR__
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT streambuf::basic_streambuf();
|
||||
template _UCXXEXPORT streambuf::~basic_streambuf();
|
||||
|
||||
#endif
|
||||
|
||||
template _UCXXEXPORT locale streambuf::pubimbue(const locale &loc);
|
||||
template _UCXXEXPORT streamsize streambuf::in_avail();
|
||||
template _UCXXEXPORT streambuf::int_type streambuf::sbumpc();
|
||||
template _UCXXEXPORT streambuf::int_type streambuf::snextc();
|
||||
template _UCXXEXPORT streambuf::int_type streambuf::sgetc();
|
||||
template _UCXXEXPORT streambuf::int_type streambuf::sputbackc(char_type c);
|
||||
template _UCXXEXPORT streambuf::int_type streambuf::sungetc();
|
||||
template _UCXXEXPORT streambuf::int_type streambuf::sputc(char_type c);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#define __UCLIBCXX_COMPILE_STRING__ 1
|
||||
|
||||
#include <basic_definitions>
|
||||
#include <char_traits>
|
||||
#include <string>
|
||||
#include <string_iostream>
|
||||
#include <string.h>
|
||||
#include <ostream>
|
||||
|
||||
namespace std{
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_STRING_CHAR__
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT string::basic_string(const allocator<char> &);
|
||||
template _UCXXEXPORT string::basic_string(size_type n, char c, const allocator<char> & );
|
||||
template _UCXXEXPORT string::basic_string(const char* s, const allocator<char>& al);
|
||||
template _UCXXEXPORT string::basic_string(const basic_string& str, size_type pos, size_type n, const allocator<char>& al);
|
||||
template _UCXXEXPORT string::~basic_string();
|
||||
|
||||
#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT string & string::append(const char * s, size_type n);
|
||||
|
||||
template _UCXXEXPORT string::size_type string::find(const string & str, size_type pos) const;
|
||||
template _UCXXEXPORT string::size_type string::find(const char* s, size_type pos) const;
|
||||
template _UCXXEXPORT string::size_type string::find (char c, size_type pos) const;
|
||||
template _UCXXEXPORT string::size_type string::rfind(const string & str, size_type pos) const;
|
||||
template _UCXXEXPORT string::size_type string::rfind(char c, size_type pos) const;
|
||||
template _UCXXEXPORT string::size_type string::rfind(const char* s, size_type pos) const;
|
||||
|
||||
template _UCXXEXPORT string::size_type string::find_first_of(const string &, size_type) const;
|
||||
template _UCXXEXPORT string::size_type string::find_first_of(const char *, size_type pos, size_type n) const;
|
||||
template _UCXXEXPORT string::size_type string::find_first_of(const char*, size_type pos) const;
|
||||
template _UCXXEXPORT string::size_type string::find_first_of(char c, size_type pos) const;
|
||||
|
||||
template _UCXXEXPORT string::size_type string::find_last_of (const string & , size_type pos) const;
|
||||
template _UCXXEXPORT string::size_type string::find_last_of (const char* s, size_type pos, size_type n) const;
|
||||
template _UCXXEXPORT string::size_type string::find_last_of (const char* s, size_type pos) const;
|
||||
template _UCXXEXPORT string::size_type string::find_last_of (char c, size_type pos) const;
|
||||
|
||||
template _UCXXEXPORT string::size_type string::find_first_not_of(const string &, size_type) const;
|
||||
template _UCXXEXPORT string::size_type string::find_first_not_of(const char*, size_type, size_type) const;
|
||||
template _UCXXEXPORT string::size_type string::find_first_not_of(const char*, size_type) const;
|
||||
template _UCXXEXPORT string::size_type string::find_first_not_of(char c, size_type) const;
|
||||
|
||||
template _UCXXEXPORT int string::compare(const string & str) const;
|
||||
// template _UCXXEXPORT int string::compare(size_type pos1, size_type n1, const string & str) const;
|
||||
template _UCXXEXPORT int string::compare(
|
||||
size_type pos1, size_type n1, const string & str, size_type pos2, size_type n2) const;
|
||||
|
||||
template _UCXXEXPORT string string::substr(size_type pos, size_type n) const;
|
||||
|
||||
template _UCXXEXPORT string & string::operator=(const string & str);
|
||||
template _UCXXEXPORT string & string::operator=(const char * s);
|
||||
|
||||
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 & 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 & lhs, const char * rhs);
|
||||
|
||||
template _UCXXEXPORT string operator+(const string & lhs, const char* rhs);
|
||||
template _UCXXEXPORT string operator+(const char* lhs, const string & rhs);
|
||||
template _UCXXEXPORT string operator+(const string & lhs, const string & rhs);
|
||||
|
||||
template _UCXXEXPORT bool operator> (const string & lhs, const string & rhs);
|
||||
template _UCXXEXPORT bool operator< (const string & lhs, const string & rhs);
|
||||
|
||||
|
||||
//Functions dependent upon OSTREAM
|
||||
#ifdef __UCLIBCXX_EXPAND_OSTREAM_CHAR__
|
||||
|
||||
template _UCXXEXPORT ostream & operator<<(ostream & os, const string & str);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
//Functions dependent upon ISTREAM
|
||||
#ifdef __UCLIBCXX_EXPAND_ISTREAM_CHAR__
|
||||
|
||||
template _UCXXEXPORT istream & operator>>(istream & is, string & str);
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <support>
|
||||
|
||||
extern "C" void *__cxa_allocate_exception(size_t thrown_size){
|
||||
void * retval;
|
||||
|
||||
// The amount of data needed is the size of the object *PLUS*
|
||||
// the size of the header. The header is of struct __cxa_exception
|
||||
// The address needs to be adjusted because the pointer we return
|
||||
// should not point to the start of the memory, but to the point
|
||||
// where the object being thrown actually starts
|
||||
//
|
||||
retval = malloc(thrown_size + sizeof(__cxa_exception));
|
||||
|
||||
// Check to see that we actuall allocated memory
|
||||
if(retval == 0){
|
||||
std::terminate();
|
||||
}
|
||||
|
||||
//Need to do a typecast to char* otherwize we are doing math with
|
||||
//a void* which makes the compiler cranky (Like me)
|
||||
return ((char *)retval + sizeof(__cxa_exception));
|
||||
}
|
||||
|
||||
extern "C" void __cxa_free_exception(void *thrown_exception){
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
extern "C" void __cxa_throw (void *thrown_exception, void *info,void (*dest) (void *) ){
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <typeinfo>
|
||||
|
||||
namespace std{
|
||||
|
||||
_UCXXEXPORT bad_cast::~bad_cast() throw(){
|
||||
|
||||
}
|
||||
|
||||
_UCXXEXPORT bad_typeid::~bad_typeid() throw(){
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
*/
|
||||
|
||||
|
||||
#include <utility>
|
||||
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <valarray>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
/* Copyright (C) 2004 Garrett A. Kajmowicz
|
||||
|
||||
This file is part of the uClibc++ Library.
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#define __UCLIBCXX_COMPILE_VECTOR__ 1
|
||||
|
||||
|
||||
#include <vector>
|
||||
|
||||
namespace std{
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_VECTOR_BASIC__
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT vector<char, allocator<char> >::vector(const allocator<char>& al);
|
||||
template _UCXXEXPORT vector<char, allocator<char> >::vector(size_type n, const char & value, const allocator<char> & al);
|
||||
|
||||
template _UCXXEXPORT vector<char, allocator<char> >::~vector();
|
||||
template _UCXXEXPORT vector<unsigned char, allocator<unsigned char> >::~vector();
|
||||
|
||||
#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT void vector<char, allocator<char> >::reserve(size_type n);
|
||||
template _UCXXEXPORT void vector<unsigned char, allocator<unsigned char> >::reserve(size_type n);
|
||||
template _UCXXEXPORT void vector<short int, allocator<short int> >::reserve(size_type n);
|
||||
template _UCXXEXPORT void vector<unsigned short int, allocator<unsigned short int> >::reserve(size_type n);
|
||||
template _UCXXEXPORT void vector<int, allocator<int> >::reserve(size_type n);
|
||||
template _UCXXEXPORT void vector<unsigned int, allocator<unsigned int> >::reserve(size_type n);
|
||||
template _UCXXEXPORT void vector<long int, allocator<long int> >::reserve(size_type n);
|
||||
template _UCXXEXPORT void vector<unsigned long int, allocator<unsigned long int> >::reserve(size_type n);
|
||||
template _UCXXEXPORT void vector<float, allocator<float> >::reserve(size_type n);
|
||||
template _UCXXEXPORT void vector<double, allocator<double> >::reserve(size_type n);
|
||||
template _UCXXEXPORT void vector<bool, allocator<bool> >::reserve(size_type n);
|
||||
|
||||
template _UCXXEXPORT void vector<char, allocator<char> >::resize(size_type sz, const char & c);
|
||||
template _UCXXEXPORT void vector<unsigned char, allocator<unsigned char> >::resize(size_type sz, const unsigned char & c);
|
||||
template _UCXXEXPORT void vector<short int, allocator<short int> >::resize(size_type sz, const short & c);
|
||||
template _UCXXEXPORT void vector<unsigned short int, allocator<unsigned short int> >
|
||||
::resize(size_type sz, const unsigned short int & c);
|
||||
template _UCXXEXPORT void vector<int, allocator<int> >::resize(size_type sz, const int & c);
|
||||
template _UCXXEXPORT void vector<unsigned int, allocator<unsigned int> >::resize(size_type sz, const unsigned int & c);
|
||||
template _UCXXEXPORT void vector<long int, allocator<long int> >::resize(size_type sz, const long int & c);
|
||||
template _UCXXEXPORT void vector<unsigned long int, allocator<unsigned long int> >::
|
||||
resize(size_type sz, const unsigned long int & c);
|
||||
template _UCXXEXPORT void vector<float, allocator<float> >::resize(size_type sz, const float & c);
|
||||
template _UCXXEXPORT void vector<double, allocator<double> >::resize(size_type sz, const double & c);
|
||||
template _UCXXEXPORT void vector<bool, allocator<bool> >::resize(size_type sz, const bool & c);
|
||||
|
||||
#elif defined __UCLIBCXX_EXPAND_STRING_CHAR__
|
||||
|
||||
|
||||
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
template _UCXXEXPORT vector<char, allocator<char> >::vector(const allocator<char>& al);
|
||||
template _UCXXEXPORT vector<char, allocator<char> >::vector(size_type n, const char & value, const allocator<char> & al);
|
||||
template _UCXXEXPORT vector<char, allocator<char> >::~vector();
|
||||
#endif // __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
|
||||
|
||||
template _UCXXEXPORT void vector<char, allocator<char> >::reserve(size_type n);
|
||||
template _UCXXEXPORT void vector<char, allocator<char> >::resize(size_type sz, const char & c);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -35,20 +35,37 @@
|
|||
|
||||
-include $(TOPDIR)/Make.defs
|
||||
|
||||
ASRCS =
|
||||
AOBJS = $(ASRCS:.S=$(OBJEXT))
|
||||
CSRCS =
|
||||
COBJS = $(CSRCS:.c=$(OBJEXT))
|
||||
CXXSRCS = libxx_cxapurevirtual.cxx libxx_delete.cxx libxx_deletea.cxx \
|
||||
libxx_eabi_atexit.cxx libxx_new.cxx libxx_newa.cxx
|
||||
CXXOBJS = $(CXXSRCS:.cxx=$(OBJEXT))
|
||||
# Sources
|
||||
|
||||
SRCS = $(ASRCS) $(CSRCS) $(CXXSRCS)
|
||||
OBJS = $(AOBJS) $(COBJS) $(CXXOBJS)
|
||||
ASRCS =
|
||||
CSRCS =
|
||||
CXXSRCS = libxx_cxapurevirtual.cxx libxx_delete.cxx libxx_deletea.cxx
|
||||
CXXSRCS += libxx_eabi_atexit.cxx libxx_new.cxx libxx_newa.cxx
|
||||
|
||||
BIN = liblibxx$(LIBEXT)
|
||||
# Paths
|
||||
|
||||
all: $(BIN)
|
||||
DEPPATH = --dep-path .
|
||||
VPATH = .
|
||||
|
||||
# Include the uClibc++ Make.defs file (if it is present). If is present,
|
||||
# the uClibc++/Make.defs file will add its files to the source file list,
|
||||
# add its DEPPATH info, and will add the appropriate paths to the VPATH
|
||||
# variable
|
||||
|
||||
-include/uClibc++/Make.defs
|
||||
|
||||
# Object Files
|
||||
|
||||
AOBJS = $(ASRCS:.S=$(OBJEXT))
|
||||
COBJS = $(CSRCS:.c=$(OBJEXT))
|
||||
CXXOBJS = $(CXXSRCS:.cxx=$(OBJEXT))
|
||||
|
||||
SRCS = $(ASRCS) $(CSRCS) $(CXXSRCS)
|
||||
OBJS = $(AOBJS) $(COBJS) $(CXXOBJS)
|
||||
|
||||
BIN = liblibxx$(LIBEXT)
|
||||
|
||||
all: $(BIN)
|
||||
|
||||
$(AOBJS): %$(OBJEXT): %.S
|
||||
$(call ASSEMBLE, $<, $@)
|
||||
|
|
@ -65,7 +82,7 @@ $(BIN): $(OBJS)
|
|||
done ; )
|
||||
|
||||
.depend: Makefile $(SRCS)
|
||||
@$(MKDEP) $(CXX) -- $(CXXFLAGS) -- $(SRCS) >Make.dep
|
||||
@$(MKDEP) $(DEPPATH) $(CXX) -- $(CXXFLAGS) -- $(SRCS) >Make.dep
|
||||
@touch $@
|
||||
|
||||
depend: .depend
|
||||
|
|
|
|||
Loading…
Reference in New Issue