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 S::size_type S::_Rep::_S_max_size;
  52   template S::size_type S::_S_empty_rep_storage[];
  53
  54   template S::basic_string(S const&);
  55   template S::_Rep* S::_Rep::_S_create(size_t, S::allocator_type const&);
  56   template void S::_Rep::_M_destroy(S::allocator_type const&) throw();
  57   template void __destroy_aux(S*, S*, __false_type);
  58
  59   template
  60     S::basic_string(S::size_type, C, S::allocator_type const&);
  61
  62   template
  63     S::basic_string(S::allocator_type const&);
  64
  65   template
  66     S::basic_string(S const&, S::size_type, S::size_type);
  67
  68   template
  69     S::basic_string(
  70       S const&, S::size_type, S::size_type, S::allocator_type const&);
  71
  72   template
  73     S::basic_string(
  74       C const*, S::size_type, S::allocator_type const&);
  75
  76   template
  77     S::basic_string(
  78       C const*, S::allocator_type const&);
  79
  80   template
  81     S::basic_string
  82     (C*, C*, const allocator<C>&);
  83
  84   template
  85     S::basic_string
  86     (S::iterator, S::iterator, const allocator<C>&);
  87
  88   template
  89     void S::_M_leak_hard();
  90   template
  91     void S::_M_mutate(S::size_type, S::size_type, S::size_type);
  92   template
  93     C* S::_Rep::_M_clone(S::allocator_type const&, S::size_type);
  94
  95   template
  96     void S::reserve(S::size_type);
  97
  98   template
  99     void S::swap(S&);
 100
 101 # ifdef _GLIBCPP_ALLOC_CONTROL
 102     template
 103       bool (* S::_Rep::_S_excess_slop)(size_t, size_t);
 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>
 126     (S::iterator, S::iterator);
 127
 128   template
 129     S&
 130     S::assign(S const&);
 131
 132   template
 133     S&
 134     S::assign<S::iterator>
 135     (S::iterator, S::iterator);
 136
 137   template
 138     void
 139     S::insert<S::iterator> //c*
 140     (S::iterator, S::iterator, S::iterator); //it, c+, c+ and temptype = char*
 141
 142   template
 143     S& S::replace(
 144       S::size_type, S::size_type, S const&, S::size_type, S::size_type);
 145
 146   template
 147     S& S::replace(S::iterator, S::iterator, S::size_type, C);
 148
 149   template
 150     S&
 151     S::replace<S::iterator> // c*
 152     (S::iterator, S::iterator, S::iterator, S::iterator); //it, it, c+, c+
 153
 154   template
 155     S&
 156     S::_M_replace<S::iterator>
 157     (S::iterator, S::iterator, S::iterator, S::iterator, forward_iterator_tag);
 158
 159   // Only one template keyword allowed here.
 160   // See core issue #46 (NAD)
 161   // http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_closed.html#46
 162   template
 163     S&
 164     S::_M_replace<S::const_iterator>
 165     (S::iterator, S::iterator,
 166      S::const_iterator, S::const_iterator, forward_iterator_tag);
 167
 168   template
 169     S&
 170     S::_M_replace<C*>
 171     (S::iterator, S::iterator, C*, C*, forward_iterator_tag);
 172
 173   template
 174     S&
 175     S::_M_replace<const C*>
 176     (S::iterator, S::iterator, const C*, const C*, forward_iterator_tag);
 177
 178   template
 179     S::size_type  S::copy(C*, S::size_type, S::size_type) const;
 180
 181   template
 182     C*
 183     S::_S_construct<S::iterator>
 184     (S::iterator, S::iterator, const allocator<C>&);
 185
 186   template
 187     C*
 188     S::_S_construct<S::iterator>
 189     (S::iterator, S::iterator, const allocator<C>&, forward_iterator_tag);
 190
 191   template
 192     C*
 193     S::_S_construct<C*>
 194     (C*, C*, const allocator<C>&, forward_iterator_tag);
 195
 196   template
 197     C*
 198     S::_S_construct<const C*>
 199     (const C*, const C*, const allocator<C>&, forward_iterator_tag);
 200
 201   template
 202     C*
 203     S::_S_construct(S::size_type, C, S::allocator_type const&);
 204
 205   // These members are explicitly specialized, and can only be in one
 206   // translation unit or else we get multiple copies. . .
 207 #if _GLIBCPP_INSTANTIATING_CHAR
 208   template<>
 209     const char*
 210     string::_S_find(const char* __beg, const char* __end, char __c)
 211     {
 212       const char* __ret = strchr(__beg, __c);
 213       return (__ret ? __ret : __end);
 214     }
 215 #else
 216   template<>
 217     const wchar_t*
 218     wstring::_S_find(const wchar_t* __beg, const wchar_t* __end, wchar_t __c)
 219     {
 220       return find_if(__beg, __end,
 221                      _Char_traits_match<wchar_t, traits_type>(__c));
 222     }
 223 #endif
 224
 225   template
 226     S::size_type S::find(C, S::size_type) const;
 227
 228   template
 229     S::size_type S::rfind(C const*, S::size_type, S::size_type) const;
 230
 231   template
 232     S::size_type S::rfind(C, S::size_type) const;
 233
 234   template
 235     S::size_type S::find_first_of(C const*, S::size_type, S::size_type) const;
 236
 237   template
 238     S::size_type S::find_last_of(C const*, S::size_type, S::size_type) const;
 239
 240   template
 241     S::size_type S::find_first_not_of(
 242       C const*, S::size_type, S::size_type) const;
 243
 244   template
 245     S::size_type S::find_last_not_of(
 246       C const*, S::size_type, S::size_type) const;
 247
 248   template
 249     S::size_type S::find_last_not_of(C, S::size_type) const;
 250
 251   template
 252     int S::compare(S::size_type, S::size_type, S const&) const;
 253
 254   template
 255     int S::compare(S::size_type, S::size_type, S const&, S::size_type,
 256                    S::size_type) const;
 257
 258   template
 259     int S::compare(C const*) const;
 260
 261   template
 262     int S::compare(
 263       S::size_type, S::size_type, C const*, S::size_type) const;
 264
 265   template S operator+(const C*, const S&);
 266
 267   template S operator+(C, const S&);
 268
 269   template bool operator==(const S::iterator&, const S::iterator&);
 270   template bool operator==(const S::const_iterator&, const S::const_iterator&);
 271
 272   template void _S_string_copy(const S&, C*, allocator<C>::size_type);
 273
 274 } // std
 275
 276
 277