Re: libstdc++/3829: missing template instantiations

Re: libstdc++/3829: missing template instantiations

[pme]

Synopsis: missing template instantiations

State-Changed-From-To: analyzed->closed
State-Changed-By: pme
State-Changed-When: Thu Dec 27 14:04:59 2001
State-Changed-Why:
    
    Fixed for 3.1 with
    
      2001-12-27  Phil Edwards  <pme@gcc.gnu.org>
    
         PR libstdc++/3829
         * src/misc-inst.cc:  Many additional I/O-related instantiations.
         * testsuite/27_io/instantiations.cc:  New file.
    
    I don't know why that didn't get automatically appended to
    this PR...

http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=3829

Re: libstdc++/3829: missing template instantiations

[pme]

Synopsis: missing template instantiations

Responsible-Changed-From-To: unassigned->pme
Responsible-Changed-By: pme
Responsible-Changed-When: Fri Dec 21 16:13:59 2001
Responsible-Changed-Why:
    It's my turn in the barrel.
State-Changed-From-To: open->analyzed
State-Changed-By: pme
State-Changed-When: Fri Dec 21 16:13:59 2001
State-Changed-Why:
    I'm finally getting a chance to play with this.  (Note that
    any future "patches" sent as simply a new copy of the entire
    file will be rejected outright; please see the URL I
    mentioned.)
    
    This change will not happen in the 3.0.x series, but should
    go in for 3.1.

http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=3829

Re: libstdc++/3829: missing template instantiations

[Phil Edwards]

The following reply was made to PR libstdc++/3829; it has been noted by GNATS.

From: Phil Edwards <pedwards@disaster.jaj.com>
To: martin.gerbershagen@icn.siemens.de
Cc: gcc-gnats@gcc.gnu.org
Subject: Re: libstdc++/3829: missing template instantiations
Date: Thu, 26 Jul 2001 12:42:58 -0400

 On Thu, Jul 26, 2001 at 11:04:05AM -0000, martin.gerbershagen@icn.siemens.de wrote:
 > I added the missing
 > template instantiations to 
 > gcc-3.0/libstdc++-v3/src/misc-inst.cc. 
 > See the attached version of misc-inst.cc.
 
 Thanks.  I'll try and look at this in the next several days.  Please see
 
     http://gcc.gnu.org/onlinedocs/libstdc++/17_intro/contribute.html
 
 especially #3, for ways to make this easier.
 
 
 Phil
 
 -- 
 Would I had phrases that are not known, utterances that are strange, in
 new language that has not been used, free from repetition, not an utterance
 which has grown stale, which men of old have spoken.
                                      - anonymous Egyptian scribe, c.1700 BC

libstdc++/3829: missing template instantiations

[martin.gerbershagen]

>Number:         3829
>Category:       libstdc++
>Synopsis:       missing template instantiations
>Confidential:   no
>Severity:       serious
>Priority:       medium
>Responsible:    unassigned
>State:          open
>Class:          sw-bug
>Submitter-Id:   net
>Arrival-Date:   Thu Jul 26 04:06:01 PDT 2001
>Closed-Date:
>Last-Modified:
>Originator:     Martin Gerbershagen
>Release:        gcc-3.0
>Organization:
>Environment:

>Description:
The template instantiations of iomanip classes are missing
int the libstdc++ library. This leads to link errors, when
compiling with -fno-implicit-templates. I added the missing
template instantiations to 
gcc-3.0/libstdc++-v3/src/misc-inst.cc. 
See the attached version of misc-inst.cc.
>How-To-Repeat:

>Fix:
// Explicit instantiation file.

// Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

//
// ISO C++ 14882:
//

#include <bits/std_string.h>
#include <bits/std_algorithm.h>
#include <bits/std_locale.h>
#include <bits/std_vector.h>
#include <bits/std_iterator.h>
#include <bits/std_streambuf.h>
#include <bits/std_sstream.h>
#include <bits/std_fstream.h>
#include <bits/std_ios.h>
#include <bits/basic_ios.tcc>
#include <bits/std_istream.h>
#include <bits/std_ostream.h>
#include <bits/std_string.h>
#include <bits/std_iomanip.h>
#include <bits/stl_algobase.h>

// NB: unnecessary if the .h headers include these
#ifndef  _GLIBCPP_FULLY_COMPLIANT_HEADERS
#include <bits/sstream.tcc>
#include <bits/fstream.tcc>
#include <bits/streambuf.tcc>
#include <bits/istream.tcc>
#include <bits/ostream.tcc>
#endif

namespace std
{

  //
  // streambuf
  // 
  template class basic_streambuf<char>;
#ifdef _GLIBCPP_USE_WCHAR_T
  template class basic_streambuf<wchar_t>;
#endif


  //
  // stringstream
  //
  template class basic_stringbuf<char>;
#ifdef _GLIBCPP_USE_WCHAR_T
  template class basic_stringbuf<wchar_t>;
#endif


  //
  // fstream
  //
  template class basic_fstream<char, char_traits<char> >;
  template class basic_filebuf<char, char_traits<char> >;
#ifdef _GLIBCPP_USE_WCHAR_T
  template class basic_filebuf<wchar_t, char_traits<wchar_t> >;
#endif


  //
  // basic_ios
  //
  template class basic_ios<char>;
#ifdef _GLIBCPP_USE_WCHAR_T
  template class basic_ios<wchar_t>;
#endif

  //
  // iomaniap _Setfill
  //
  template class _Setfill<char>;
  template _Setfill<char> setfill(char);

  //
  // istream
  //
  template class basic_istream<char>;
  template istream& ws(istream&);
  template istream& operator>>(istream&, char&);
  template istream& operator>>(istream&, unsigned char&);
  template istream& operator>>(istream&, signed char&);
  template istream& operator>>(istream&, char*);
  template istream& operator>>(istream&, unsigned char*);
  template istream& operator>>(istream&, signed char*);

  template istream& operator>>(istream&, _Setiosflags);
  template istream& operator>>(istream&, _Resetiosflags);
  template istream& operator>>(istream&, _Setbase);
  template istream& operator>>(istream&, _Setfill<char>);
  template istream& operator>>(istream&, _Setprecision);
  template istream& operator>>(istream&, _Setw);

#ifdef _GLIBCPP_USE_WCHAR_T
  template class basic_istream<wchar_t>;
  template wistream& ws(wistream&);
  template wistream& operator>>(wistream&, wchar_t&);
  template wistream& operator>>(wistream&, wchar_t*);
#endif


  //
  // ostream
  //
  template class basic_ostream<char>;
  template ostream& endl(ostream&);
  template ostream& ends(ostream&);
  template ostream& flush(ostream&);
  template ostream& operator<<(ostream&, char);
  template ostream& operator<<(ostream&, unsigned char);
  template ostream& operator<<(ostream&, signed char);
  template ostream& operator<<(ostream&, const char*);
  template ostream& operator<<(ostream&, const unsigned char*);
  template ostream& operator<<(ostream&, const signed char*);

  template ostream& operator<<(ostream&, _Setiosflags);
  template ostream& operator<<(ostream&, _Resetiosflags);
  template ostream& operator<<(ostream&, _Setbase);
  template ostream& operator<<(ostream&, _Setfill<char>);
  template ostream& operator<<(ostream&, _Setprecision);
  template ostream& operator<<(ostream&, _Setw);

#ifdef _GLIBCPP_USE_WCHAR_T
  template class basic_ostream<wchar_t>;
  template wostream& endl(wostream&);
  template wostream& ends(wostream&);
  template wostream& flush(wostream&);
  template wostream& operator<<(wostream&, wchar_t);
  template wostream& operator<<(wostream&, char);
  template wostream& operator<<(wostream&, const wchar_t*);
  template wostream& operator<<(wostream&, const char*);
#endif
  

  //
  // iostream
  //
  template class basic_iostream<char>;
#ifdef _GLIBCPP_USE_WCHAR_T
  template class basic_iostream<wchar_t>; 
#endif


  //
  // ifstream
  //
  template class basic_ifstream<char>;
#ifdef _GLIBCPP_USE_WCHAR_T
  template class basic_ifstream<wchar_t>;
#endif


  //
  // ofstream
  //
  template class basic_ofstream<char>;
#ifdef _GLIBCPP_USE_WCHAR_T
  template class basic_ofstream<wchar_t>;
#endif


  //
  // istringstream
  //
  template class basic_istringstream<char>;
#ifdef _GLIBCPP_USE_WCHAR_T
  template class basic_istringstream<wchar_t>; 
#endif


  //
  // ostringstream
  //
  template class basic_ostringstream<char>;
#ifdef _GLIBCPP_USE_WCHAR_T
  template class basic_ostringstream<wchar_t>; 
#endif


  //
  // string related to iostreams
  //
  template 
    basic_istream<char>& 
    operator>>(basic_istream<char>&, string&);
  template 
    basic_ostream<char>& 
    operator<<(basic_ostream<char>&, const string&);
  template 
    basic_istream<char>& 
    getline(basic_istream<char>&, string&, char);
  template 
    basic_istream<char>& 
    getline(basic_istream<char>&, string&);
#ifdef _GLIBCPP_USE_WCHAR_T
  template 
    basic_istream<wchar_t>& 
    operator>>(basic_istream<wchar_t>&, wstring&);
  template 
    basic_ostream<wchar_t>& 
    operator<<(basic_ostream<wchar_t>&, const wstring&);
  template 
    basic_istream<wchar_t>& 
    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
  template 
    basic_istream<wchar_t>& 
    getline(basic_istream<wchar_t>&, wstring&);
#endif

  //
  // algorithm
  //

  template int __lexicographical_compare_3way<signed char const*, signed char const*>(signed char const*, signed char const*, signed char const*, signed char const*);
  template bool lexicographical_compare<signed char const*, signed char const*>(signed char const*, signed char const*, signed char const*, signed char const*);

  typedef  _Char_traits_match<char, char_traits<char> > char_match;

  template 
    const char*  
    find_if<const char *, char_match>
    (const char *, const char *, char_match, random_access_iterator_tag);

#ifdef _GLIBCPP_USE_WCHAR_T
  typedef  _Char_traits_match<wchar_t, char_traits<wchar_t> > wchar_match;

  template const wchar_t*  
    find_if<const wchar_t*, wchar_match>
    (const wchar_t*, const wchar_t*, wchar_match, random_access_iterator_tag);
#endif
  
  template 
    string* 
    __uninitialized_fill_n_aux<string*, size_t, string>
    (string*, size_t, string const &, _Bool<false>);

  template 
    string* 
    __uninitialized_copy_aux<vector<string>::const_iterator, string *>
    (vector<string>::const_iterator, vector<string>::const_iterator, 
     string*, _Bool<false>);

  template
    void 
    __pad_char(basic_ios<char>&, char*, const char*,
		const streamsize, const streamsize);
#ifdef _GLIBCPP_USE_WCHAR_T
  template
    void 
    __pad_char(basic_ios<wchar_t>&, wchar_t*, const wchar_t*,
		const streamsize, const streamsize);
#endif

  template
    ostreambuf_iterator<char>
    __pad_numeric(ostreambuf_iterator<char>, _Ios_Fmtflags, char, int,
		  const char*, const char*, const char*);
#ifdef _GLIBCPP_USE_WCHAR_T
  template
    ostreambuf_iterator<wchar_t>
    __pad_numeric(ostreambuf_iterator<wchar_t>, _Ios_Fmtflags, wchar_t, int,
		  const wchar_t*, const wchar_t*, const wchar_t*);
#endif

  template
    ostreambuf_iterator<char>
    __output_float(ostreambuf_iterator<char>, ios_base&, char, 
		   const char*, size_t);
#ifdef _GLIBCPP_USE_WCHAR_T
  template
    ostreambuf_iterator<wchar_t>
    __output_float(ostreambuf_iterator<wchar_t>, ios_base&, wchar_t, 
		   const char*, size_t);
#endif

  template
    streamsize
    __copy_streambufs(basic_ios<char>&, basic_streambuf<char>*,
		      basic_streambuf<char>*); 
#ifdef _GLIBCPP_USE_WCHAR_T
  template
    streamsize
    __copy_streambufs(basic_ios<wchar_t>&, basic_streambuf<wchar_t>*,
		      basic_streambuf<wchar_t>*); 
#endif
} //std
>Release-Note:
>Audit-Trail:
>Unformatted: