diff options
Diffstat (limited to 'contrib/libstdc++/std/bastring.h')
| -rw-r--r-- | contrib/libstdc++/std/bastring.h | 620 |
1 files changed, 620 insertions, 0 deletions
diff --git a/contrib/libstdc++/std/bastring.h b/contrib/libstdc++/std/bastring.h new file mode 100644 index 0000000..f188628 --- /dev/null +++ b/contrib/libstdc++/std/bastring.h @@ -0,0 +1,620 @@ +// Main templates for the -*- C++ -*- string classes. +// Copyright (C) 1994, 1995 Free Software Foundation + +// This file is part of the GNU ANSI 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, if you link this library with files +// compiled with a GNU compiler to produce an executable, this does not 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. + +// Written by Jason Merrill based upon the specification by Takanori Adachi +// in ANSI X3J16/94-0013R2. + +#ifndef __BASTRING__ +#define __BASTRING__ + +#ifdef __GNUG__ +#pragma interface +#endif + +#include <cstddef> +#include <std/straits.h> + +// NOTE : This does NOT conform to the draft standard and is likely to change +#include <alloc.h> + +extern "C++" { +class istream; class ostream; + +#include <iterator> + +#ifdef __STL_USE_EXCEPTIONS + +extern void __out_of_range (const char *); +extern void __length_error (const char *); + +#define OUTOFRANGE(cond) \ + do { if (cond) __out_of_range (#cond); } while (0) +#define LENGTHERROR(cond) \ + do { if (cond) __length_error (#cond); } while (0) + +#else + +#include <cassert> +#define OUTOFRANGE(cond) assert (!(cond)) +#define LENGTHERROR(cond) assert (!(cond)) + +#endif + +template <class charT, class traits = string_char_traits<charT>, + class Allocator = alloc > +class basic_string +{ +private: + struct Rep { + size_t len, res, ref; + bool selfish; + + charT* data () { return reinterpret_cast<charT *>(this + 1); } + charT& operator[] (size_t s) { return data () [s]; } + charT* grab () { if (selfish) return clone (); ++ref; return data (); } + void release () { if (--ref == 0) delete this; } + + inline static void * operator new (size_t, size_t); + inline static void operator delete (void *); + inline static Rep* create (size_t); + charT* clone (); + + inline void copy (size_t, const charT *, size_t); + inline void move (size_t, const charT *, size_t); + inline void set (size_t, const charT, size_t); + + inline static bool excess_slop (size_t, size_t); + inline static size_t frob_size (size_t); + + private: + Rep &operator= (const Rep &); + }; + +public: +// types: + typedef traits traits_type; + typedef typename traits::char_type value_type; + typedef Allocator allocator_type; + + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef charT& reference; + typedef const charT& const_reference; + typedef charT* pointer; + typedef const charT* const_pointer; + typedef pointer iterator; + typedef const_pointer const_iterator; + typedef ::reverse_iterator<iterator> reverse_iterator; + typedef ::reverse_iterator<const_iterator> const_reverse_iterator; + static const size_type npos = static_cast<size_type>(-1); + +private: + Rep *rep () const { return reinterpret_cast<Rep *>(dat) - 1; } + void repup (Rep *p) { rep ()->release (); dat = p->data (); } + +public: + const charT* data () const + { return rep ()->data(); } + size_type length () const + { return rep ()->len; } + size_type size () const + { return rep ()->len; } + size_type capacity () const + { return rep ()->res; } + size_type max_size () const + { return (npos - 1)/sizeof (charT); } // XXX + bool empty () const + { return size () == 0; } + +// _lib.string.cons_ construct/copy/destroy: + basic_string& operator= (const basic_string& str) + { + if (&str != this) { rep ()->release (); dat = str.rep ()->grab (); } + return *this; + } + + explicit basic_string (): dat (nilRep.grab ()) { } + basic_string (const basic_string& str): dat (str.rep ()->grab ()) { } + basic_string (const basic_string& str, size_type pos, size_type n = npos) + : dat (nilRep.grab ()) { assign (str, pos, n); } + basic_string (const charT* s, size_type n) + : dat (nilRep.grab ()) { assign (s, n); } + basic_string (const charT* s) + : dat (nilRep.grab ()) { assign (s); } + basic_string (size_type n, charT c) + : dat (nilRep.grab ()) { assign (n, c); } +#ifdef __STL_MEMBER_TEMPLATES + template<class InputIterator> + basic_string(InputIterator begin, InputIterator end) +#else + basic_string(const_iterator begin, const_iterator end) +#endif + : dat (nilRep.grab ()) { assign (begin, end); } + + ~basic_string () + { rep ()->release (); } + + void swap (basic_string &s) { charT *d = dat; dat = s.dat; s.dat = d; } + + basic_string& append (const basic_string& str, size_type pos = 0, + size_type n = npos) + { return replace (length (), 0, str, pos, n); } + basic_string& append (const charT* s, size_type n) + { return replace (length (), 0, s, n); } + basic_string& append (const charT* s) + { return append (s, traits::length (s)); } + basic_string& append (size_type n, charT c) + { return replace (length (), 0, n, c); } +#ifdef __STL_MEMBER_TEMPLATES + template<class InputIterator> + basic_string& append(InputIterator first, InputIterator last) +#else + basic_string& append(const_iterator first, const_iterator last) +#endif + { return replace (iend (), iend (), first, last); } + + basic_string& assign (const basic_string& str, size_type pos = 0, + size_type n = npos) + { return replace (0, npos, str, pos, n); } + basic_string& assign (const charT* s, size_type n) + { return replace (0, npos, s, n); } + basic_string& assign (const charT* s) + { return assign (s, traits::length (s)); } + basic_string& assign (size_type n, charT c) + { return replace (0, npos, n, c); } +#ifdef __STL_MEMBER_TEMPLATES + template<class InputIterator> + basic_string& assign(InputIterator first, InputIterator last) +#else + basic_string& assign(const_iterator first, const_iterator last) +#endif + { return replace (ibegin (), iend (), first, last); } + + basic_string& operator= (const charT* s) + { return assign (s); } + basic_string& operator= (charT c) + { return assign (1, c); } + + basic_string& operator+= (const basic_string& rhs) + { return append (rhs); } + basic_string& operator+= (const charT* s) + { return append (s); } + basic_string& operator+= (charT c) + { return append (1, c); } + + basic_string& insert (size_type pos1, const basic_string& str, + size_type pos2 = 0, size_type n = npos) + { return replace (pos1, 0, str, pos2, n); } + basic_string& insert (size_type pos, const charT* s, size_type n) + { return replace (pos, 0, s, n); } + basic_string& insert (size_type pos, const charT* s) + { return insert (pos, s, traits::length (s)); } + basic_string& insert (size_type pos, size_type n, charT c) + { return replace (pos, 0, n, c); } + iterator insert(iterator p, charT c) + { size_type __o = p - ibegin (); + insert (p - ibegin (), 1, c); selfish (); + return ibegin () + __o; } + iterator insert(iterator p, size_type n, charT c) + { size_type __o = p - ibegin (); + insert (p - ibegin (), n, c); selfish (); + return ibegin () + __o; } +#ifdef __STL_MEMBER_TEMPLATES + template<class InputIterator> + void insert(iterator p, InputIterator first, InputIterator last) +#else + void insert(iterator p, const_iterator first, const_iterator last) +#endif + { replace (p, p, first, last); } + + basic_string& erase (size_type pos = 0, size_type n = npos) + { return replace (pos, n, (size_type)0, (charT)0); } + iterator erase(iterator p) + { size_type __o = p - begin(); + replace (__o, 1, (size_type)0, (charT)0); selfish (); + return ibegin() + __o; } + iterator erase(iterator f, iterator l) + { size_type __o = f - ibegin(); + replace (__o, l-f, (size_type)0, (charT)0);selfish (); + return ibegin() + __o; } + + basic_string& replace (size_type pos1, size_type n1, const basic_string& str, + size_type pos2 = 0, size_type n2 = npos); + basic_string& replace (size_type pos, size_type n1, const charT* s, + size_type n2); + basic_string& replace (size_type pos, size_type n1, const charT* s) + { return replace (pos, n1, s, traits::length (s)); } + basic_string& replace (size_type pos, size_type n1, size_type n2, charT c); + basic_string& replace (size_type pos, size_type n, charT c) + { return replace (pos, n, 1, c); } + basic_string& replace (iterator i1, iterator i2, const basic_string& str) + { return replace (i1 - ibegin (), i2 - i1, str); } + basic_string& replace (iterator i1, iterator i2, const charT* s, size_type n) + { return replace (i1 - ibegin (), i2 - i1, s, n); } + basic_string& replace (iterator i1, iterator i2, const charT* s) + { return replace (i1 - ibegin (), i2 - i1, s); } + basic_string& replace (iterator i1, iterator i2, size_type n, charT c) + { return replace (i1 - ibegin (), i2 - i1, n, c); } +#ifdef __STL_MEMBER_TEMPLATES + template<class InputIterator> + basic_string& replace(iterator i1, iterator i2, + InputIterator j1, InputIterator j2); +#else + basic_string& replace(iterator i1, iterator i2, + const_iterator j1, const_iterator j2); +#endif + +private: + static charT eos () { return traits::eos (); } + void unique () { if (rep ()->ref > 1) alloc (length (), true); } + void selfish () { unique (); rep ()->selfish = true; } + +public: + charT operator[] (size_type pos) const + { + if (pos == length ()) + return eos (); + return data ()[pos]; + } + + reference operator[] (size_type pos) + { selfish (); return (*rep ())[pos]; } + + reference at (size_type pos) + { + OUTOFRANGE (pos >= length ()); + return (*this)[pos]; + } + const_reference at (size_type pos) const + { + OUTOFRANGE (pos >= length ()); + return data ()[pos]; + } + +private: + void terminate () const + { traits::assign ((*rep ())[length ()], eos ()); } + +public: + const charT* c_str () const + { if (length () == 0) return ""; terminate (); return data (); } + void resize (size_type n, charT c); + void resize (size_type n) + { resize (n, eos ()); } + void reserve (size_type) { } + + size_type copy (charT* s, size_type n, size_type pos = 0) const; + + size_type find (const basic_string& str, size_type pos = 0) const + { return find (str.data(), pos, str.length()); } + size_type find (const charT* s, size_type pos, size_type n) const; + size_type find (const charT* s, size_type pos = 0) const + { return find (s, pos, traits::length (s)); } + size_type find (charT c, size_type pos = 0) const; + + size_type rfind (const basic_string& str, size_type pos = npos) const + { return rfind (str.data(), pos, str.length()); } + size_type rfind (const charT* s, size_type pos, size_type n) const; + size_type rfind (const charT* s, size_type pos = npos) const + { return rfind (s, pos, traits::length (s)); } + size_type rfind (charT c, size_type pos = npos) const; + + size_type find_first_of (const basic_string& str, size_type pos = 0) const + { return find_first_of (str.data(), pos, str.length()); } + size_type find_first_of (const charT* s, size_type pos, size_type n) const; + size_type find_first_of (const charT* s, size_type pos = 0) const + { return find_first_of (s, pos, traits::length (s)); } + size_type find_first_of (charT c, size_type pos = 0) const + { return find (c, pos); } + + size_type find_last_of (const basic_string& str, size_type pos = npos) const + { return find_last_of (str.data(), pos, str.length()); } + size_type find_last_of (const charT* s, size_type pos, size_type n) const; + size_type find_last_of (const charT* s, size_type pos = npos) const + { return find_last_of (s, pos, traits::length (s)); } + size_type find_last_of (charT c, size_type pos = npos) const + { return rfind (c, pos); } + + size_type find_first_not_of (const basic_string& str, size_type pos = 0) const + { return find_first_not_of (str.data(), pos, str.length()); } + size_type find_first_not_of (const charT* s, size_type pos, size_type n) const; + size_type find_first_not_of (const charT* s, size_type pos = 0) const + { return find_first_not_of (s, pos, traits::length (s)); } + size_type find_first_not_of (charT c, size_type pos = 0) const; + + size_type find_last_not_of (const basic_string& str, size_type pos = npos) const + { return find_last_not_of (str.data(), pos, str.length()); } + size_type find_last_not_of (const charT* s, size_type pos, size_type n) const; + size_type find_last_not_of (const charT* s, size_type pos = npos) const + { return find_last_not_of (s, pos, traits::length (s)); } + size_type find_last_not_of (charT c, size_type pos = npos) const; + + basic_string substr (size_type pos = 0, size_type n = npos) const + { return basic_string (*this, pos, n); } + + int compare (const basic_string& str, size_type pos = 0, size_type n = npos) const; + // There is no 'strncmp' equivalent for charT pointers. + int compare (const charT* s, size_type pos, size_type n) const; + int compare (const charT* s, size_type pos = 0) const + { return compare (s, pos, traits::length (s)); } + + iterator begin () { selfish (); return &(*this)[0]; } + iterator end () { selfish (); return &(*this)[length ()]; } + +private: + iterator ibegin () const { return &(*rep ())[0]; } + iterator iend () const { return &(*rep ())[length ()]; } + +public: + const_iterator begin () const { return ibegin (); } + const_iterator end () const { return iend (); } + + 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 ()); } + +private: + void alloc (size_type size, bool save); + static size_type _find (const charT* ptr, charT c, size_type xpos, size_type len); + inline bool check_realloc (size_type s) const; + + static Rep nilRep; + charT *dat; +}; + +#ifdef __STL_MEMBER_TEMPLATES +template <class charT, class traits, class Allocator> template <class InputIterator> +basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>:: +replace (iterator i1, iterator i2, InputIterator j1, InputIterator j2) +#else +template <class charT, class traits, class Allocator> +basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>:: +replace (iterator i1, iterator i2, const_iterator j1, const_iterator j2) +#endif +{ + const size_type len = length (); + size_type pos = i1 - ibegin (); + size_type n1 = i2 - i1; + size_type n2 = j2 - j1; + + OUTOFRANGE (pos > len); + if (n1 > len - pos) + n1 = len - pos; + LENGTHERROR (len - n1 > max_size () - n2); + size_t newlen = len - n1 + n2; + + if (check_realloc (newlen)) + { + Rep *p = Rep::create (newlen); + p->copy (0, data (), pos); + p->copy (pos + n2, data () + pos + n1, len - (pos + n1)); + for (; j1 != j2; ++j1, ++pos) + traits::assign ((*p)[pos], *j1); + repup (p); + } + else + { + rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1)); + for (; j1 != j2; ++j1, ++pos) + traits::assign ((*rep ())[pos], *j1); + } + rep ()->len = newlen; + + return *this; +} + +template <class charT, class traits, class Allocator> +inline basic_string <charT, traits, Allocator> +operator+ (const basic_string <charT, traits, Allocator>& lhs, + const basic_string <charT, traits, Allocator>& rhs) +{ + basic_string <charT, traits, Allocator> str (lhs); + str.append (rhs); + return str; +} + +template <class charT, class traits, class Allocator> +inline basic_string <charT, traits, Allocator> +operator+ (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs) +{ + basic_string <charT, traits, Allocator> str (lhs); + str.append (rhs); + return str; +} + +template <class charT, class traits, class Allocator> +inline basic_string <charT, traits, Allocator> +operator+ (charT lhs, const basic_string <charT, traits, Allocator>& rhs) +{ + basic_string <charT, traits, Allocator> str (1, lhs); + str.append (rhs); + return str; +} + +template <class charT, class traits, class Allocator> +inline basic_string <charT, traits, Allocator> +operator+ (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs) +{ + basic_string <charT, traits, Allocator> str (lhs); + str.append (rhs); + return str; +} + +template <class charT, class traits, class Allocator> +inline basic_string <charT, traits, Allocator> +operator+ (const basic_string <charT, traits, Allocator>& lhs, charT rhs) +{ + basic_string <charT, traits, Allocator> str (lhs); + str.append (1, rhs); + return str; +} + +template <class charT, class traits, class Allocator> +inline bool +operator== (const basic_string <charT, traits, Allocator>& lhs, + const basic_string <charT, traits, Allocator>& rhs) +{ + return (lhs.compare (rhs) == 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator== (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs) +{ + return (rhs.compare (lhs) == 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator== (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs) +{ + return (lhs.compare (rhs) == 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator!= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs) +{ + return (rhs.compare (lhs) != 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator!= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs) +{ + return (lhs.compare (rhs) != 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator< (const basic_string <charT, traits, Allocator>& lhs, + const basic_string <charT, traits, Allocator>& rhs) +{ + return (lhs.compare (rhs) < 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator< (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs) +{ + return (rhs.compare (lhs) > 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator< (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs) +{ + return (lhs.compare (rhs) < 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator> (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs) +{ + return (rhs.compare (lhs) < 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator> (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs) +{ + return (lhs.compare (rhs) > 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator<= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs) +{ + return (rhs.compare (lhs) >= 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator<= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs) +{ + return (lhs.compare (rhs) <= 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator>= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs) +{ + return (rhs.compare (lhs) <= 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator>= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs) +{ + return (lhs.compare (rhs) >= 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator!= (const basic_string <charT, traits, Allocator>& lhs, + const basic_string <charT, traits, Allocator>& rhs) +{ + return (lhs.compare (rhs) != 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator> (const basic_string <charT, traits, Allocator>& lhs, + const basic_string <charT, traits, Allocator>& rhs) +{ + return (lhs.compare (rhs) > 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator<= (const basic_string <charT, traits, Allocator>& lhs, + const basic_string <charT, traits, Allocator>& rhs) +{ + return (lhs.compare (rhs) <= 0); +} + +template <class charT, class traits, class Allocator> +inline bool +operator>= (const basic_string <charT, traits, Allocator>& lhs, + const basic_string <charT, traits, Allocator>& rhs) +{ + return (lhs.compare (rhs) >= 0); +} + +class istream; class ostream; +template <class charT, class traits, class Allocator> istream& +operator>> (istream&, basic_string <charT, traits, Allocator>&); +template <class charT, class traits, class Allocator> ostream& +operator<< (ostream&, const basic_string <charT, traits, Allocator>&); +template <class charT, class traits, class Allocator> istream& +getline (istream&, basic_string <charT, traits, Allocator>&, charT delim = '\n'); + +} // extern "C++" + +#include <std/bastring.cc> + +#endif |
