libstdc++-v3/src/string-inst.cc

   1 // Components for manipulating sequences of characters -*- C++ -*-
   2
   3 // Copyright (C) 2000, 1999, 1998, 1997 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 2, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19 // USA.
  20
  21 // As a special exception, you may use this file as part of a free software
  22 // library without restriction.  Specifically, if other files instantiate
  23 // templates or use macros or inline functions from this file, or you compile
  24 // this file and link it with other files to produce an executable, this
  25 // file does not by itself cause the resulting executable to be covered by
  26 // the GNU General Public License.  This exception does not however
  27 // invalidate any other reasons why the executable file might be covered by
  28 // the GNU General Public License.
  29
  30 //
  31 // ISO C++ 14882: 21  Strings library
  32 //
  33
  34 // Written by Jason Merrill based upon the specification by Takanori Adachi
  35 // in ANSI X3J16/94-0013R2.  Rewritten by Nathan Myers.
  36
  37 #include <bits/std_string.h>
  38 #include <bits/std_algorithm.h>
  39
  40 // Instantiation configuration.
  41 #ifndef C
  42 # define C char
  43 # define _GLIBCPP_INSTANTIATING_CHAR 1
  44 #endif
  45
  46 namespace std
  47 {
  48   typedef basic_string<C> S;
  49
  50   template C S::_Rep::_S_terminal;
  51   template const S::size_type S::npos;
  52   template S::size_type S::_Rep::_S_max_size;
  53   template S::size_type S::_S_empty_rep_storage[];
  54   template S::_Rep* S::_Rep::_S_create(size_t, S::allocator_type const&);
  55   template void S::_Rep::_M_destroy(const S::allocator_type&) throw();
  56   template void __destroy_aux(S*, S*, __false_type);
  57
  58   template S::basic_string(S const&);
  59
  60   template
  61     S::basic_string(S::size_type, C, const S::allocator_type&);
  62
  63   template
  64     S::basic_string(const S::allocator_type&);
  65
  66   template
  67     S::basic_string(const S&, S::size_type, S::size_type);
  68
  69   template
  70     S::basic_string(const S&, S::size_type, S::size_type,
  71                     const S::allocator_type&);
  72
  73   template
  74     S::basic_string(C const*, S::size_type, const S::allocator_type&);
  75
  76   template
  77     S::basic_string(C const*, S::allocator_type const&);
  78
  79   template
  80     S::basic_string(C*, C*, const allocator<C>&);
  81
  82   template
  83     S::basic_string(S::iterator, S::iterator, const allocator<C>&);
  84
  85   template
  86     void S::_M_leak_hard();
  87
  88   template
  89     void S::_M_mutate(S::size_type, S::size_type, S::size_type);
  90
  91   template
  92     C* S::_Rep::_M_clone(S::allocator_type const&, S::size_type);
  93
  94   template
  95     void S::reserve(S::size_type);
  96
  97   template
  98     void S::swap(S&);
  99
 100 # ifdef _GLIBCPP_ALLOC_CONTROL
 101     template
 102       bool (* S::_Rep::_S_excess_slop)(size_t, size_t);
 103
 104     template
 105       bool S::_Rep::_S_default_excess(size_t, size_t);
 106 # endif
 107
 108   template
 109     void S::resize(S::size_type, C);
 110
 111   template
 112     S& S::append(S const&);
 113
 114   template
 115     S& S::append(S const&, S::size_type, S::size_type);
 116
 117   template
 118     S& S::append(C const*, S::size_type);
 119
 120   template
 121     S& S::append(S::size_type, C);
 122
 123   template
 124     S&
 125     S::append<S::iterator>(S::iterator, S::iterator);
 126
 127   template
 128     S&
 129     S::assign(S const&);
 130
 131   template
 132     S&
 133     S::assign<S::iterator>(S::iterator, S::iterator);
 134
 135   template
 136     void
 137     S::insert<S::iterator> //c*
 138     (S::iterator, S::iterator, S::iterator); //it, c+, c+ and temptype = char*
 139
 140   template
 141     S& S::replace(S::size_type, S::size_type, S const&,
 142                   S::size_type, S::size_type);
 143
 144   template
 145     S& S::replace(S::iterator, S::iterator, S::size_type, C);
 146
 147   template
 148     S&
 149     S::replace<S::iterator> // c*
 150     (S::iterator, S::iterator, S::iterator, S::iterator); //it, it, c+, c+
 151
 152   template
 153     S&
 154     S::_M_replace<S::iterator>
 155     (S::iterator, S::iterator, S::iterator, S::iterator, forward_iterator_tag);
 156
 157   // Only one template keyword allowed here.
 158   // See core issue #46 (NAD)
 159   // http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_closed.html#46
 160   template
 161     S&
 162     S::_M_replace<S::const_iterator>
 163     (S::iterator, S::iterator,
 164      S::const_iterator, S::const_iterator, forward_iterator_tag);
 165
 166   template
 167     S&
 168     S::_M_replace<C*>
 169     (S::iterator, S::iterator, C*, C*, forward_iterator_tag);
 170
 171   template
 172     S&
 173     S::_M_replace<const C*>
 174     (S::iterator, S::iterator, const C*, const C*, forward_iterator_tag);
 175
 176   template
 177     S::size_type  S::copy(C*, S::size_type, S::size_type) const;
 178
 179   template
 180     C*
 181     S::_S_construct<S::iterator>
 182     (S::iterator, S::iterator, const allocator<C>&);
 183
 184   template
 185     C*
 186     S::_S_construct<S::iterator>
 187     (S::iterator, S::iterator, const allocator<C>&, forward_iterator_tag);
 188
 189   template
 190     C*
 191     S::_S_construct<C*>
 192     (C*, C*, const allocator<C>&, forward_iterator_tag);
 193
 194   template
 195     C*
 196     S::_S_construct<const C*>
 197     (const C*, const C*, const allocator<C>&, forward_iterator_tag);
 198
 199   template
 200     C*
 201     S::_S_construct(S::size_type, C, S::allocator_type const&);
 202
 203   // These members are explicitly specialized, and can only be in one
 204   // translation unit or else we get multiple copies. . .
 205 #if _GLIBCPP_INSTANTIATING_CHAR
 206   template<>
 207     const char*
 208     string::_S_find(const char* __beg, const char* __end, char __c)
 209     {
 210       const char* __ret = strchr(__beg, __c);
 211       return (__ret ? __ret : __end);
 212     }
 213 #elif defined(_GLIBCPP_USE_WCHAR_T)
 214   template<>
 215     const wchar_t*
 216     wstring::_S_find(const wchar_t* __beg, const wchar_t* __end, wchar_t __c)
 217     {
 218       return find_if(__beg, __end,
 219                      _Char_traits_match<wchar_t, traits_type>(__c));
 220     }
 221 #endif
 222
 223   template
 224     S::size_type S::find(C, S::size_type) const;
 225
 226   template
 227     S::size_type S::rfind(C const*, S::size_type, S::size_type) const;
 228
 229   template
 230     S::size_type S::rfind(C, S::size_type) const;
 231
 232   template
 233     S::size_type S::find_first_of(C const*, S::size_type, S::size_type) const;
 234
 235   template
 236     S::size_type S::find_last_of(C const*, S::size_type, S::size_type) const;
 237
 238   template
 239     S::size_type S::find_first_not_of(
 240       C const*, S::size_type, S::size_type) const;
 241
 242   template
 243     S::size_type S::find_last_not_of(
 244       C const*, S::size_type, S::size_type) const;
 245
 246   template
 247     S::size_type S::find_last_not_of(C, S::size_type) const;
 248
 249   template
 250     int S::compare(S::size_type, S::size_type, S const&) const;
 251
 252   template
 253     int S::compare(S::size_type, S::size_type, S const&, S::size_type,
 254                    S::size_type) const;
 255
 256   template
 257     int S::compare(C const*) const;
 258
 259   template
 260     int S::compare(
 261       S::size_type, S::size_type, C const*, S::size_type) const;
 262
 263   template S operator+(const C*, const S&);
 264
 265   template S operator+(C, const S&);
 266
 267   template bool operator==(const S::iterator&, const S::iterator&);
 268   template bool operator==(const S::const_iterator&, const S::const_iterator&);
 269
 270   template void _S_string_copy(const S&, C*, allocator<C>::size_type);
 271
 272 } // std
 273
 274
 275
 276