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

   1 // Explicit instantiation file.
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001 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:
  32 //
  33
  34 #include <bits/std_string.h>
  35 #include <bits/std_algorithm.h>
  36 #include <bits/std_locale.h>
  37 #include <bits/std_vector.h>
  38 #include <bits/std_iterator.h>
  39 #include <bits/std_streambuf.h>
  40 #include <bits/std_sstream.h>
  41 #include <bits/std_fstream.h>
  42 #include <bits/std_ios.h>
  43 #include <bits/basic_ios.tcc>
  44 #include <bits/std_istream.h>
  45 #include <bits/std_ostream.h>
  46 #include <bits/std_string.h>
  47 #include <bits/std_iomanip.h>
  48
  49 // NB: unnecessary if the .h headers include these
  50 #ifndef  _GLIBCPP_FULLY_COMPLIANT_HEADERS
  51 #include <bits/sstream.tcc>
  52 #include <bits/fstream.tcc>
  53 #include <bits/streambuf.tcc>
  54 #include <bits/istream.tcc>
  55 #include <bits/ostream.tcc>
  56 #endif
  57
  58 namespace std
  59 {
  60
  61   //
  62   // streambuf
  63   //
  64   template class basic_streambuf<char>;
  65 #ifdef _GLIBCPP_USE_WCHAR_T
  66   template class basic_streambuf<wchar_t>;
  67 #endif
  68
  69
  70   //
  71   // stringstream
  72   //
  73   template class basic_stringbuf<char>;
  74 #ifdef _GLIBCPP_USE_WCHAR_T
  75   template class basic_stringbuf<wchar_t>;
  76 #endif
  77
  78
  79   //
  80   // fstream
  81   //
  82   template class basic_filebuf<char, char_traits<char> >;
  83 #ifdef _GLIBCPP_USE_WCHAR_T
  84   template class basic_filebuf<wchar_t, char_traits<wchar_t> >;
  85 #endif
  86
  87
  88   //
  89   // basic_ios
  90   //
  91   template class basic_ios<char>;
  92 #ifdef _GLIBCPP_USE_WCHAR_T
  93   template class basic_ios<wchar_t>;
  94 #endif
  95
  96
  97   //
  98   // iomanip
  99   //
 100   template class _Setfill<char>;
 101   template _Setfill<char> setfill(char);
 102 #ifdef _GLIBCPP_USE_WCHAR_T
 103   template class _Setfill<wchar_t>;
 104   template _Setfill<wchar_t> setfill(wchar_t);
 105 #endif
 106
 107
 108   //
 109   // istream
 110   //
 111   template class basic_istream<char>;
 112   template istream& ws(istream&);
 113   template istream& operator>>(istream&, char&);
 114   template istream& operator>>(istream&, unsigned char&);
 115   template istream& operator>>(istream&, signed char&);
 116   template istream& operator>>(istream&, char*);
 117   template istream& operator>>(istream&, unsigned char*);
 118   template istream& operator>>(istream&, signed char*);
 119
 120   template istream& operator>>(istream&, _Setiosflags);
 121   template istream& operator>>(istream&, _Resetiosflags);
 122   template istream& operator>>(istream&, _Setbase);
 123   template istream& operator>>(istream&, _Setfill<char>);
 124   template istream& operator>>(istream&, _Setprecision);
 125   template istream& operator>>(istream&, _Setw);
 126
 127 #ifdef _GLIBCPP_USE_WCHAR_T
 128   template class basic_istream<wchar_t>;
 129   template wistream& ws(wistream&);
 130   template wistream& operator>>(wistream&, wchar_t&);
 131   template wistream& operator>>(wistream&, wchar_t*);
 132   template wistream& operator>>(wistream&, _Setfill<wchar_t>);
 133 #endif
 134
 135
 136   //
 137   // ostream
 138   //
 139   template class basic_ostream<char>;
 140   template ostream& endl(ostream&);
 141   template ostream& ends(ostream&);
 142   template ostream& flush(ostream&);
 143   template ostream& operator<<(ostream&, char);
 144   template ostream& operator<<(ostream&, unsigned char);
 145   template ostream& operator<<(ostream&, signed char);
 146   template ostream& operator<<(ostream&, const char*);
 147   template ostream& operator<<(ostream&, const unsigned char*);
 148   template ostream& operator<<(ostream&, const signed char*);
 149
 150   template ostream& operator<<(ostream&, _Setiosflags);
 151   template ostream& operator<<(ostream&, _Resetiosflags);
 152   template ostream& operator<<(ostream&, _Setbase);
 153   template ostream& operator<<(ostream&, _Setfill<char>);
 154   template ostream& operator<<(ostream&, _Setprecision);
 155   template ostream& operator<<(ostream&, _Setw);
 156
 157 #ifdef _GLIBCPP_USE_WCHAR_T
 158   template class basic_ostream<wchar_t>;
 159   template wostream& endl(wostream&);
 160   template wostream& ends(wostream&);
 161   template wostream& flush(wostream&);
 162   template wostream& operator<<(wostream&, wchar_t);
 163   template wostream& operator<<(wostream&, char);
 164   template wostream& operator<<(wostream&, const wchar_t*);
 165   template wostream& operator<<(wostream&, const char*);
 166   template wostream& operator<<(wostream&, _Setfill<wchar_t>);
 167 #endif
 168
 169
 170   //
 171   // iostream
 172   //
 173   template class basic_iostream<char>;
 174 #ifdef _GLIBCPP_USE_WCHAR_T
 175   template class basic_iostream<wchar_t>;
 176 #endif
 177
 178
 179   //
 180   // ifstream
 181   //
 182   template class basic_ifstream<char>;
 183 #ifdef _GLIBCPP_USE_WCHAR_T
 184   template class basic_ifstream<wchar_t>;
 185 #endif
 186
 187
 188   //
 189   // ofstream
 190   //
 191   template class basic_ofstream<char>;
 192 #ifdef _GLIBCPP_USE_WCHAR_T
 193   template class basic_ofstream<wchar_t>;
 194 #endif
 195
 196
 197   //
 198   // istringstream
 199   //
 200   template class basic_istringstream<char>;
 201 #ifdef _GLIBCPP_USE_WCHAR_T
 202   template class basic_istringstream<wchar_t>;
 203 #endif
 204
 205
 206   //
 207   // ostringstream
 208   //
 209   template class basic_ostringstream<char>;
 210 #ifdef _GLIBCPP_USE_WCHAR_T
 211   template class basic_ostringstream<wchar_t>;
 212 #endif
 213
 214
 215   //
 216   // string related to iostreams
 217   //
 218   template
 219     basic_istream<char>&
 220     operator>>(basic_istream<char>&, string&);
 221   template
 222     basic_ostream<char>&
 223     operator<<(basic_ostream<char>&, const string&);
 224   template
 225     basic_istream<char>&
 226     getline(basic_istream<char>&, string&, char);
 227   template
 228     basic_istream<char>&
 229     getline(basic_istream<char>&, string&);
 230 #ifdef _GLIBCPP_USE_WCHAR_T
 231   template
 232     basic_istream<wchar_t>&
 233     operator>>(basic_istream<wchar_t>&, wstring&);
 234   template
 235     basic_ostream<wchar_t>&
 236     operator<<(basic_ostream<wchar_t>&, const wstring&);
 237   template
 238     basic_istream<wchar_t>&
 239     getline(basic_istream<wchar_t>&, wstring&, wchar_t);
 240   template
 241     basic_istream<wchar_t>&
 242     getline(basic_istream<wchar_t>&, wstring&);
 243 #endif
 244
 245   //
 246   // algorithm
 247   //
 248   typedef  _Char_traits_match<char, char_traits<char> > char_match;
 249
 250   template
 251     const char*
 252     find_if<const char *, char_match>
 253     (const char *, const char *, char_match, random_access_iterator_tag);
 254
 255 #ifdef _GLIBCPP_USE_WCHAR_T
 256   typedef  _Char_traits_match<wchar_t, char_traits<wchar_t> > wchar_match;
 257
 258   template const wchar_t*
 259     find_if<const wchar_t*, wchar_match>
 260     (const wchar_t*, const wchar_t*, wchar_match, random_access_iterator_tag);
 261 #endif
 262
 263   template
 264     string*
 265     __uninitialized_fill_n_aux<string*, size_t, string>
 266     (string*, size_t, string const &, __false_type);
 267
 268   template
 269     string*
 270     __uninitialized_copy_aux<vector<string>::const_iterator, string *>
 271     (vector<string>::const_iterator, vector<string>::const_iterator,
 272      string*, __false_type);
 273
 274   template
 275     streamsize
 276     __copy_streambufs(basic_ios<char>&, basic_streambuf<char>*,
 277                       basic_streambuf<char>*);
 278 #ifdef _GLIBCPP_USE_WCHAR_T
 279   template
 280     streamsize
 281     __copy_streambufs(basic_ios<wchar_t>&, basic_streambuf<wchar_t>*,
 282                       basic_streambuf<wchar_t>*);
 283 #endif
 284 } //std