# misc-inst.cc

    00001 // Explicit instantiation file.
    00002
    00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
    00004 // Free Software Foundation, Inc.
    00005 //
    00006 // This file is part of the GNU ISO C++ Library.  This library is free
    00007 // software; you can redistribute it and/or modify it under the
    00008 // terms of the GNU General Public License as published by the
    00009 // Free Software Foundation; either version 2, or (at your option)
    00010 // any later version.
    00011
    00012 // This library is distributed in the hope that it will be useful,
    00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00015 // GNU General Public License for more details.
    00016
    00017 // You should have received a copy of the GNU General Public License along
    00018 // with this library; see the file COPYING.  If not, write to the Free
    00019 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    00020 // USA.
    00021
    00022 // As a special exception, you may use this file as part of a free software
    00023 // library without restriction.  Specifically, if other files instantiate
    00024 // templates or use macros or inline functions from this file, or you compile
    00025 // this file and link it with other files to produce an executable, this
    00026 // file does not by itself cause the resulting executable to be covered by
    00027 // the GNU General Public License.  This exception does not however
    00028 // invalidate any other reasons why the executable file might be covered by
    00029 // the GNU General Public License.
    00030
    00031 //
    00032 // ISO C++ 14882:
    00033 //
    00034
    00035 #include <string>
    00036 #include <algorithm>
    00037 #include <locale>
    00038 #include <vector>
    00039 #include <iterator>
    00040 #include <streambuf>
    00041 #include <sstream>
    00042 #include <fstream>
    00043 #include <ios>
    00044 #include <istream>
    00045 #include <ostream>
    00046 #include <iomanip>
    00047 #include <ext/stdio_filebuf.h>
    00048
    00049 // NB: Unnecessary if the .h headers already include these.
    00050 #ifndef  _GLIBCPP_FULLY_COMPLIANT_HEADERS
    00051 #include <bits/sstream.tcc>
    00052 #include <bits/fstream.tcc>
    00053 #include <bits/streambuf.tcc>
    00054 #include <bits/istream.tcc>
    00055 #include <bits/ostream.tcc>
    00056 #endif
    00057
    00058 namespace std
    00059 {
    00060   // streambuf
    00061   template class basic_streambuf<char>;
    00062 #ifdef _GLIBCPP_USE_WCHAR_T
    00063   template class basic_streambuf<wchar_t>;
    00064 #endif
    00065
    00066   // stringbuf
    00067   template class basic_stringbuf<char>;
    00068 #ifdef _GLIBCPP_USE_WCHAR_T
    00069   template class basic_stringbuf<wchar_t>;
    00070 #endif
    00071
    00072   // filebuf
    00073   template class basic_filebuf<char, char_traits<char> >;
    00074 #ifdef _GLIBCPP_USE_WCHAR_T
    00075   template class basic_filebuf<wchar_t, char_traits<wchar_t> >;
    00076 #endif
    00077
    00078   // basic_ios
    00079   template class basic_ios<char>;
    00080 #ifdef _GLIBCPP_USE_WCHAR_T
    00081   template class basic_ios<wchar_t>;
    00082 #endif
    00083
    00084   // iomanip
    00085   template class _Setfill<char>;
    00086   template _Setfill<char> setfill(char);
    00087 #ifdef _GLIBCPP_USE_WCHAR_T
    00088   template class _Setfill<wchar_t>;
    00089   template _Setfill<wchar_t> setfill(wchar_t);
    00090 #endif
    00091
    00092   // istream
    00093   template class basic_istream<char>;
    00094   template istream& ws(istream&);
    00095   template istream& operator>>(istream&, char&);
    00096   template istream& operator>>(istream&, unsigned char&);
    00097   template istream& operator>>(istream&, signed char&);
    00098   template istream& operator>>(istream&, char*);
    00099   template istream& operator>>(istream&, unsigned char*);
    00100   template istream& operator>>(istream&, signed char*);
    00101
    00102   template istream& operator>>(istream&, _Setfill<char>);
    00103   template istream& operator>>(istream&, _Setiosflags);
    00104   template istream& operator>>(istream&, _Resetiosflags);
    00105   template istream& operator>>(istream&, _Setbase);
    00106   template istream& operator>>(istream&, _Setprecision);
    00107   template istream& operator>>(istream&, _Setw);
    00108
    00109 #ifdef _GLIBCPP_USE_WCHAR_T
    00110   template class basic_istream<wchar_t>;
    00111   template wistream& ws(wistream&);
    00112   template wistream& operator>>(wistream&, wchar_t&);
    00113   template wistream& operator>>(wistream&, wchar_t*);
    00114
    00115   template wistream& operator>>(wistream&, _Setfill<wchar_t>);
    00116   template wistream& operator>>(wistream&, _Setiosflags);
    00117   template wistream& operator>>(wistream&, _Resetiosflags);
    00118   template wistream& operator>>(wistream&, _Setbase);
    00119   template wistream& operator>>(wistream&, _Setprecision);
    00120   template wistream& operator>>(wistream&, _Setw);
    00121 #endif
    00122
    00123   // ostream
    00124   template class basic_ostream<char>;
    00125   template ostream& endl(ostream&);
    00126   template ostream& ends(ostream&);
    00127   template ostream& flush(ostream&);
    00128   template ostream& operator<<(ostream&, char);
    00129   template ostream& operator<<(ostream&, unsigned char);
    00130   template ostream& operator<<(ostream&, signed char);
    00131   template ostream& operator<<(ostream&, const char*);
    00132   template ostream& operator<<(ostream&, const unsigned char*);
    00133   template ostream& operator<<(ostream&, const signed char*);
    00134
    00135   template ostream& operator<<(ostream&, _Setfill<char>);
    00136   template ostream& operator<<(ostream&, _Setiosflags);
    00137   template ostream& operator<<(ostream&, _Resetiosflags);
    00138   template ostream& operator<<(ostream&, _Setbase);
    00139   template ostream& operator<<(ostream&, _Setprecision);
    00140   template ostream& operator<<(ostream&, _Setw);
    00141
    00142 #ifdef _GLIBCPP_USE_WCHAR_T
    00143   template class basic_ostream<wchar_t>;
    00144   template wostream& endl(wostream&);
    00145   template wostream& ends(wostream&);
    00146   template wostream& flush(wostream&);
    00147   template wostream& operator<<(wostream&, wchar_t);
    00148   template wostream& operator<<(wostream&, char);
    00149   template wostream& operator<<(wostream&, const wchar_t*);
    00150   template wostream& operator<<(wostream&, const char*);
    00151
    00152   template wostream& operator<<(wostream&, _Setfill<wchar_t>);
    00153   template wostream& operator<<(wostream&, _Setiosflags);
    00154   template wostream& operator<<(wostream&, _Resetiosflags);
    00155   template wostream& operator<<(wostream&, _Setbase);
    00156   template wostream& operator<<(wostream&, _Setprecision);
    00157   template wostream& operator<<(wostream&, _Setw);
    00158 #endif
    00159
    00160
    00161   // iostream
    00162   template class basic_iostream<char>;
    00163 #ifdef _GLIBCPP_USE_WCHAR_T
    00164   template class basic_iostream<wchar_t>;
    00165 #endif
    00166
    00167   // ifstream
    00168   template class basic_ifstream<char>;
    00169 #ifdef _GLIBCPP_USE_WCHAR_T
    00170   template class basic_ifstream<wchar_t>;
    00171 #endif
    00172
    00173   // ofstream
    00174   template class basic_ofstream<char>;
    00175 #ifdef _GLIBCPP_USE_WCHAR_T
    00176   template class basic_ofstream<wchar_t>;
    00177 #endif
    00178
    00179   // fstream
    00180   template class basic_fstream<char>;
    00181 #ifdef _GLIBCPP_USE_WCHAR_T
    00182   template class basic_fstream<wchar_t>;
    00183 #endif
    00184
    00185   // istringstream
    00186   template class basic_istringstream<char>;
    00187 #ifdef _GLIBCPP_USE_WCHAR_T
    00188   template class basic_istringstream<wchar_t>;
    00189 #endif
    00190
    00191   // ostringstream
    00192   template class basic_ostringstream<char>;
    00193 #ifdef _GLIBCPP_USE_WCHAR_T
    00194   template class basic_ostringstream<wchar_t>;
    00195 #endif
    00196
    00197   // stringstream
    00198   template class basic_stringstream<char>;
    00199 #ifdef _GLIBCPP_USE_WCHAR_T
    00200   template class basic_stringstream<wchar_t>;
    00201 #endif
    00202
    00203   // string related to iostreams
    00204   template
    00205     basic_istream<char>&
    00206     operator>>(basic_istream<char>&, string&);
    00207   template
    00208     basic_ostream<char>&
    00209     operator<<(basic_ostream<char>&, const string&);
    00210   template
    00211     basic_istream<char>&
    00212     getline(basic_istream<char>&, string&, char);
    00213   template
    00214     basic_istream<char>&
    00215     getline(basic_istream<char>&, string&);
    00216 #ifdef _GLIBCPP_USE_WCHAR_T
    00217   template
    00218     basic_istream<wchar_t>&
    00219     operator>>(basic_istream<wchar_t>&, wstring&);
    00220   template
    00221     basic_ostream<wchar_t>&
    00222     operator<<(basic_ostream<wchar_t>&, const wstring&);
    00223   template
    00224     basic_istream<wchar_t>&
    00225     getline(basic_istream<wchar_t>&, wstring&, wchar_t);
    00226   template
    00227     basic_istream<wchar_t>&
    00228     getline(basic_istream<wchar_t>&, wstring&);
    00229 #endif
    00230
    00231   // algorithm
    00232   typedef  _Char_traits_match<char, char_traits<char> > char_match;
    00233
    00234   template
    00235     const char*
    00236     find_if<const char *, char_match>
    00237     (const char *, const char *, char_match, random_access_iterator_tag);
    00238
    00239 #ifdef _GLIBCPP_USE_WCHAR_T
    00240   typedef  _Char_traits_match<wchar_t, char_traits<wchar_t> > wchar_match;
    00241
    00242   template const wchar_t*
    00243     find_if<const wchar_t*, wchar_match>
    00244     (const wchar_t*, const wchar_t*, wchar_match, random_access_iterator_tag);
    00245 #endif
    00246
    00247   template
    00248     string*
    00249     __uninitialized_fill_n_aux<string*, size_t, string>
    00250     (string*, size_t, string const &, __false_type);
    00251
    00252   template
    00253     string*
    00254     __uninitialized_copy_aux<vector<string>::const_iterator, string *>
    00255     (vector<string>::const_iterator, vector<string>::const_iterator,
    00256      string*, __false_type);
    00257
    00258   template
    00259     streamsize
    00260     __copy_streambufs(basic_ios<char>&, basic_streambuf<char>*,
    00261               basic_streambuf<char>*);
    00262 #ifdef _GLIBCPP_USE_WCHAR_T
    00263   template
    00264     streamsize
    00265     __copy_streambufs(basic_ios<wchar_t>&, basic_streambuf<wchar_t>*,
    00266               basic_streambuf<wchar_t>*);
    00267 #endif
    00268
    00269   using __gnu_cxx::stdio_filebuf;
    00270   template class stdio_filebuf<char>;
    00271 #ifdef _GLIBCPP_USE_WCHAR_T
    00272   template class stdio_filebuf<wchar_t>;
    00273 #endif
    00274 } //std