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 #include <bits/std_istream.h>
  40 #include <bits/std_ostream.h>
  41
  42 // NB: Unnecessary if the .h headers include these
  43 #ifndef  _GLIBCPP_FULLY_COMPLIANT_HEADERS
  44 #include <bits/istream.tcc>
  45 #include <bits/ostream.tcc>
  46 #endif
  47
  48 // Instantiation configuration.
  49 #ifndef C
  50 # define C char
  51 # define _GLIBCPP_INSTANTIATING_CHAR 1
  52 #endif
  53
  54 namespace std
  55 {
  56   typedef basic_string<C> S;
  57
  58 #ifdef MAIN
  59   template C S::_Rep::_S_terminal;
  60   // XXX Fix me: 2000-04-18 g++ ICE.
  61 //  template S::size_type S::_S_max_size;
  62 //  template S::allocator_type::size_type S::S_empty_rep_storage[];
  63   template S::basic_string(S const&);
  64   template S::_Rep* S::_Rep::_S_create(size_t, S::allocator_type const&);
  65   template void S::_Rep::_M_destroy(S::allocator_type const&) throw();
  66 #endif
  67
  68 #ifdef CTORNC
  69   template
  70     S::basic_string(S::size_type, C, S::allocator_type const&);
  71 #endif
  72
  73 #ifdef CTORAL
  74   template
  75     S::basic_string(S::allocator_type const&);
  76 #endif
  77
  78 #ifdef CTORCPR
  79   template
  80     S::basic_string(S const&, S::size_type, S::size_type);
  81 #endif
  82
  83 #ifdef CTORCPRAL
  84   template
  85     S::basic_string(
  86       S const&, S::size_type, S::size_type, S::allocator_type const&);
  87 #endif
  88
  89 #ifdef CTORPRAL
  90   template
  91     S::basic_string(
  92       C const*, S::size_type, S::allocator_type const&);
  93 #endif
  94
  95 #ifdef CTORPAL
  96   template
  97     S::basic_string(
  98       C const*, S::allocator_type const&);
  99 #endif
 100
 101 #ifdef CTORDUPAL
 102   template
 103     S::basic_string(
 104       S::size_type, C, S::allocator_type const&);
 105 #endif
 106
 107 #ifdef CTORPP
 108   template
 109     S::basic_string
 110     (C*, C*, const allocator<C>&);
 111 #endif
 112
 113 #ifdef CTORII
 114   template
 115     S::basic_string
 116     (S::iterator, S::iterator, const allocator<C>&);
 117 #endif
 118
 119 #ifdef MUTATE
 120   template
 121     void S::_M_leak_hard();
 122   template
 123     void S::_M_mutate(S::size_type, S::size_type, S::size_type);
 124   template
 125     C* S::_Rep::_M_clone(S::allocator_type const&, S::size_type);
 126 #endif
 127
 128 #ifdef RESERVE
 129   template
 130     void S::reserve(S::size_type);
 131 #endif
 132
 133 #ifdef SWAP
 134   template
 135     void S::swap(S&);
 136 #endif
 137
 138 #ifdef SLOP
 139 # ifdef _GLIBCPP_ALLOC_CONTROL
 140     template
 141       bool (* S::_Rep::_S_excess_slop)(size_t, size_t);
 142     template
 143       bool S::_Rep::_S_default_excess(size_t, size_t);
 144 # endif
 145 #endif
 146
 147 #ifdef RESIZE
 148   template
 149     void S::resize(S::size_type, C);
 150 #endif
 151
 152 #ifdef APPCOPY
 153   template
 154     S& S::append(S const&);
 155 #endif
 156
 157 #ifdef APPCPR
 158   template
 159     S& S::append(S const&, S::size_type, S::size_type);
 160 #endif
 161
 162 #ifdef APPPR
 163   template
 164     S& S::append(C const*, S::size_type);
 165 #endif
 166
 167 #ifdef APPDUP
 168   template
 169     S& S::append(S::size_type, C);
 170 #endif
 171
 172 #ifdef APPII
 173   template
 174     S&
 175     S::append<S::iterator>
 176     (S::iterator, S::iterator);
 177 #endif
 178
 179 #ifdef ASSCP
 180   template
 181     S&
 182     S::assign(S const&);
 183 #endif
 184
 185 #ifdef ASSII
 186   template
 187     S&
 188     S::assign<S::iterator>
 189     (S::iterator, S::iterator);
 190 #endif
 191
 192 #ifdef INSII
 193   template
 194     void
 195     S::insert<S::iterator> //c*
 196     (S::iterator, S::iterator, S::iterator); //it, c+, c+ and temptype = char*
 197 #endif
 198
 199 #ifdef REPRR
 200   template
 201     S& S::replace(
 202       S::size_type, S::size_type, S const&, S::size_type, S::size_type);
 203 #endif
 204
 205 #ifdef REPIIDUP
 206   template
 207     S& S::replace(S::iterator, S::iterator, S::size_type, C);
 208 #endif
 209
 210 #ifdef REPII
 211   template
 212     S&
 213     S::replace<S::iterator> // c*
 214     (S::iterator, S::iterator, S::iterator, S::iterator); //it, it, c+, c+
 215 #endif
 216
 217 #ifdef REPIII
 218   template
 219     S&
 220     S::_M_replace<S::iterator>
 221     (S::iterator, S::iterator, S::iterator, S::iterator, forward_iterator_tag);
 222 #endif
 223
 224 #ifdef REP4I
 225   template
 226   template
 227     S&
 228     S::_M_replace<S::const_iterator>
 229     (S::iterator, S::iterator,
 230      S::const_iterator, S::const_iterator, forward_iterator_tag);
 231 #endif
 232
 233 #ifdef REPIIPP
 234   template
 235     S&
 236     S::_M_replace<C*>
 237     (S::iterator, S::iterator, C*, C*, forward_iterator_tag);
 238 #endif
 239
 240 #ifdef REPIIPP2
 241   template
 242     S&
 243     S::_M_replace<const C*>
 244     (S::iterator, S::iterator, const C*, const C*, forward_iterator_tag);
 245 #endif
 246
 247 #ifdef COPY
 248   template
 249     S::size_type  S::copy(C*, S::size_type, S::size_type) const;
 250 #endif
 251
 252 #ifdef CONII
 253   template
 254     C*
 255     S::_S_construct<S::iterator>
 256     (S::iterator, S::iterator, const allocator<C>&);
 257 #endif
 258
 259 #ifdef CONIIF
 260   template
 261     C*
 262     S::_S_construct<S::iterator>
 263     (S::iterator, S::iterator, const allocator<C>&, forward_iterator_tag);
 264 #endif
 265
 266 #ifdef CONPPF
 267   template
 268     C*
 269     S::_S_construct<C*>
 270     (C*, C*, const allocator<C>&, forward_iterator_tag);
 271 #endif
 272
 273 #ifdef CONPPF2
 274   template
 275     C*
 276     S::_S_construct<const C*>
 277     (const C*, const C*, const allocator<C>&, forward_iterator_tag);
 278 #endif
 279
 280 #ifdef CONSC
 281   template
 282     C*
 283     S::_S_construct(S::size_type, C, S::allocator_type const&);
 284 #endif
 285
 286 #ifdef FIND
 287   // These members are explicitly specialized, and can only be in one
 288   // translation unit or else we get multiple copies. . .
 289 #if _GLIBCPP_INSTANTIATING_CHAR
 290   template<>
 291     const char*
 292     string::_S_find(const char* __beg, const char* __end, char __c)
 293     {
 294       char* __retval = strchr(__beg, __c);
 295       return (__retval ? __retval : __end);
 296     }
 297 #else
 298   template<>
 299     const wchar_t*
 300     wstring::_S_find(const wchar_t* __beg, const wchar_t* __end, wchar_t __c)
 301     {
 302       return find_if(__beg, __end,
 303                      _Char_traits_match<wchar_t, traits_type>(__c));
 304     }
 305 #endif
 306 #endif
 307
 308 #ifdef FINDC
 309   template
 310     S::size_type S::find(C, S::size_type) const;
 311 #endif
 312
 313 #ifdef RFIND
 314   template
 315     S::size_type S::rfind(C const*, S::size_type, S::size_type) const;
 316 #endif
 317
 318 #ifdef RFINDC
 319   template
 320     S::size_type S::rfind(C, S::size_type) const;
 321 #endif
 322
 323 #ifdef FFO
 324   template
 325     S::size_type S::find_first_of(C const*, S::size_type, S::size_type) const;
 326 #endif
 327
 328 #ifdef FLO
 329   template
 330     S::size_type S::find_last_of(C const*, S::size_type, S::size_type) const;
 331 #endif
 332
 333 #ifdef FFNO
 334   template
 335     S::size_type S::find_first_not_of(
 336       C const*, S::size_type, S::size_type) const;
 337 #endif
 338
 339 #ifdef FLNO
 340   template
 341     S::size_type S::find_last_not_of(
 342       C const*, S::size_type, S::size_type) const;
 343 #endif
 344
 345 #ifdef FLNOC
 346   template
 347     S::size_type S::find_last_not_of(C, S::size_type) const;
 348 #endif
 349
 350 #ifdef COMPARE
 351   template
 352     int S::compare(S::size_type, S::size_type, S const&) const;
 353 #endif
 354
 355 #ifdef COMPARE2
 356   template
 357     int S::compare(S::size_type, S::size_type, S const&, S::size_type,
 358                    S::size_type) const;
 359 #endif
 360
 361 #ifdef COMPAREP
 362   template
 363     int S::compare(C const*) const;
 364 #endif
 365
 366 #ifdef COMPAREP2
 367   template
 368     int S::compare(
 369       S::size_type, S::size_type, C const*, S::size_type) const;
 370 #endif
 371
 372 #ifdef ADDPS
 373   template S operator+(const C*, const S&);
 374 #endif
 375
 376 #ifdef ADDCS
 377   template S operator+(C, const S&);
 378 #endif
 379
 380 #ifdef EQ
 381   template bool operator==(const S::iterator&, const S::iterator&);
 382   template bool operator==(const S::const_iterator&, const S::const_iterator&);
 383 #endif
 384
 385 #ifdef EXTRACT
 386   template basic_istream<C>& operator>>(basic_istream<C>&, S&);
 387 #endif
 388
 389 #ifdef INSERT
 390   template basic_ostream<C>& operator<<(basic_ostream<C>&, const S&);
 391 #endif
 392
 393 #ifdef GETLINE
 394   template basic_istream<C>& getline(basic_istream<C>&, S&, C);
 395   template basic_istream<C>& getline(basic_istream<C>&, S&);
 396 #endif
 397
 398 #ifdef SCOPY
 399   template void _S_string_copy(const S&, C*, allocator<C>::size_type);
 400 #endif
 401
 402 } // std
 403
 404
 405