Menu
▾
▴
[pygccxml-commit] SF.net SVN: pygccxml:[1565] gccxml_bin/v09/linux2/share/gccxml-0.9
|
From: <rom...@us...> - 2009-01-12 23:05:07
|
Revision: 1565
http://pygccxml.svn.sourceforge.net/pygccxml/?rev=1565&view=rev
Author: roman_yakovenko
Date: 2009-01-12 22:33:13 +0000 (Mon, 12 Jan 2009)
Log Message:
-----------
adding missing files
Added Paths:
-----------
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/bastring.cc
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/dcomplex.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/fcomplex.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/ldcomplex.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/straits.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/stl_alloc.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/stl_bvector.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/stl_deque.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/stl_list.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/stl_tree.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/stl_vector.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.2/bits/sstream.tcc
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.2/bits/valarray_meta.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.2/sstream
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.3/bits/fstream.tcc
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.3/bits/list.tcc
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.3/bits/sstream.tcc
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.3/bits/stl_deque.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.3/bits/stl_list.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.3/bits/stl_tree.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.3/bits/stl_vector.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.3/bits/valarray_meta.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.3/fstream
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.3/sstream
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/3.4/bits/gthr-default.h
gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/4.3/
gccxml_bin/v09/linux2/share/gccxml-0.9/Sun/
gccxml_bin/v09/linux2/share/gccxml-0.9/gccxml_identify_compiler.cc
Added: gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/bastring.cc
===================================================================
--- gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/bastring.cc (rev 0)
+++ gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/bastring.cc 2009-01-12 22:33:13 UTC (rev 1565)
@@ -0,0 +1,524 @@
+// Member templates for the -*- C++ -*- string classes.
+// Copyright (C) 1994, 1999 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification by Takanori Adachi
+// in ANSI X3J16/94-0013R2.
+
+extern "C++" {
+template <class charT, class traits, class Allocator>
+inline void * basic_string <charT, traits, Allocator>::Rep::
+operator new (size_t s, size_t extra)
+{
+ return Allocator::allocate(s + extra * sizeof (charT));
+}
+
+template <class charT, class traits, class Allocator>
+inline void basic_string <charT, traits, Allocator>::Rep::
+operator delete (void * ptr)
+{
+ Allocator::deallocate(ptr, sizeof(Rep) +
+ reinterpret_cast<Rep *>(ptr)->res *
+ sizeof (charT));
+}
+
+template <class charT, class traits, class Allocator>
+inline size_t basic_string <charT, traits, Allocator>::Rep::
+frob_size (size_t s)
+{
+ size_t i = 16;
+ while (i < s) i *= 2;
+ return i;
+}
+
+template <class charT, class traits, class Allocator>
+inline typename basic_string <charT, traits, Allocator>::Rep *
+basic_string <charT, traits, Allocator>::Rep::
+create (size_t extra)
+{
+ extra = frob_size (extra + 1);
+ Rep *p = new (extra) Rep;
+ p->res = extra;
+ p->ref = 1;
+ p->selfish = false;
+ return p;
+}
+
+template <class charT, class traits, class Allocator>
+charT * basic_string <charT, traits, Allocator>::Rep::
+clone ()
+{
+ Rep *p = Rep::create (len);
+ p->copy (0, data (), len);
+ p->len = len;
+ return p->data ();
+}
+
+template <class charT, class traits, class Allocator>
+inline bool basic_string <charT, traits, Allocator>::Rep::
+excess_slop (size_t s, size_t r)
+{
+ return 2 * (s <= 16 ? 16 : s) < r;
+}
+
+template <class charT, class traits, class Allocator>
+inline bool basic_string <charT, traits, Allocator>::
+check_realloc (basic_string::size_type s) const
+{
+ s += sizeof (charT);
+ rep ()->selfish = false;
+ return (rep ()->ref > 1
+ || s > capacity ()
+ || Rep::excess_slop (s, capacity ()));
+}
+
+template <class charT, class traits, class Allocator>
+void basic_string <charT, traits, Allocator>::
+alloc (basic_string::size_type __size, bool __save)
+{
+ if (! check_realloc (__size))
+ return;
+
+ Rep *p = Rep::create (__size);
+
+ if (__save)
+ {
+ p->copy (0, data (), length ());
+ p->len = length ();
+ }
+ else
+ p->len = 0;
+
+ repup (p);
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>&
+basic_string <charT, traits, Allocator>::
+replace (size_type pos1, size_type n1,
+ const basic_string& _str, size_type pos2, size_type n2)
+{
+ const size_t len2 = _str.length ();
+
+ if (pos1 == 0 && n1 >= length () && pos2 == 0 && n2 >= len2)
+ return operator= (_str);
+
+ OUTOFRANGE (pos2 > len2);
+
+ if (n2 > len2 - pos2)
+ n2 = len2 - pos2;
+
+ return replace (pos1, n1, _str.data () + pos2, n2);
+}
+
+template <class charT, class traits, class Allocator>
+inline void basic_string <charT, traits, Allocator>::Rep::
+copy (size_t pos, const charT *s, size_t n)
+{
+ if (n)
+ traits::copy (data () + pos, s, n);
+}
+
+template <class charT, class traits, class Allocator>
+inline void basic_string <charT, traits, Allocator>::Rep::
+move (size_t pos, const charT *s, size_t n)
+{
+ if (n)
+ traits::move (data () + pos, s, n);
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>&
+basic_string <charT, traits, Allocator>::
+replace (size_type pos, size_type n1, const charT* s, size_type n2)
+{
+ const size_type len = length ();
+ OUTOFRANGE (pos > len);
+ if (n1 > len - pos)
+ n1 = len - pos;
+ LENGTHERROR (len - n1 > max_size () - n2);
+ size_t newlen = len - n1 + n2;
+
+ if (check_realloc (newlen))
+ {
+ Rep *p = Rep::create (newlen);
+ p->copy (0, data (), pos);
+ p->copy (pos + n2, data () + pos + n1, len - (pos + n1));
+ p->copy (pos, s, n2);
+ repup (p);
+ }
+ else
+ {
+ rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));
+ rep ()->copy (pos, s, n2);
+ }
+ rep ()->len = newlen;
+
+ return *this;
+}
+
+template <class charT, class traits, class Allocator>
+inline void basic_string <charT, traits, Allocator>::Rep::
+set (size_t pos, const charT c, size_t n)
+{
+ traits::set (data () + pos, c, n);
+}
+
+template <class charT, class traits, class Allocator>
+basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>::
+replace (size_type pos, size_type n1, size_type n2, charT c)
+{
+ const size_t len = length ();
+ OUTOFRANGE (pos > len);
+ if (n1 > len - pos)
+ n1 = len - pos;
+ LENGTHERROR (len - n1 > max_size () - n2);
+ size_t newlen = len - n1 + n2;
+
+ if (check_realloc (newlen))
+ {
+ Rep *p = Rep::create (newlen);
+ p->copy (0, data (), pos);
+ p->copy (pos + n2, data () + pos + n1, len - (pos + n1));
+ p->set (pos, c, n2);
+ repup (p);
+ }
+ else
+ {
+ rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));
+ rep ()->set (pos, c, n2);
+ }
+ rep ()->len = newlen;
+
+ return *this;
+}
+
+template <class charT, class traits, class Allocator>
+void basic_string <charT, traits, Allocator>::
+resize (size_type n, charT c)
+{
+ LENGTHERROR (n > max_size ());
+
+ if (n > length ())
+ append (n - length (), c);
+ else
+ erase (n);
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+copy (charT* s, size_type n, size_type pos) const
+{
+ OUTOFRANGE (pos > length ());
+
+ if (n > length () - pos)
+ n = length () - pos;
+
+ traits::copy (s, data () + pos, n);
+ return n;
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find (const charT* s, size_type pos, size_type n) const
+{
+ size_t xpos = pos;
+ for (; xpos + n <= length (); ++xpos)
+ if (traits::eq (data () [xpos], *s)
+ && traits::compare (data () + xpos, s, n) == 0)
+ return xpos;
+ return npos;
+}
+
+template <class charT, class traits, class Allocator>
+inline typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+_find (const charT* ptr, charT c, size_type xpos, size_type len)
+{
+ for (; xpos < len; ++xpos)
+ if (traits::eq (ptr [xpos], c))
+ return xpos;
+ return npos;
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find (charT c, size_type pos) const
+{
+ return _find (data (), c, pos, length ());
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+rfind (const charT* s, size_type pos, size_type n) const
+{
+ if (n > length ())
+ return npos;
+
+ size_t xpos = length () - n;
+ if (xpos > pos)
+ xpos = pos;
+
+ for (++xpos; xpos-- > 0; )
+ if (traits::eq (data () [xpos], *s)
+ && traits::compare (data () + xpos, s, n) == 0)
+ return xpos;
+ return npos;
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+rfind (charT c, size_type pos) const
+{
+ if (1 > length ())
+ return npos;
+
+ size_t xpos = length () - 1;
+ if (xpos > pos)
+ xpos = pos;
+
+ for (++xpos; xpos-- > 0; )
+ if (traits::eq (data () [xpos], c))
+ return xpos;
+ return npos;
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_first_of (const charT* s, size_type pos, size_type n) const
+{
+ size_t xpos = pos;
+ for (; xpos < length (); ++xpos)
+ if (_find (s, data () [xpos], 0, n) != npos)
+ return xpos;
+ return npos;
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_last_of (const charT* s, size_type pos, size_type n) const
+{
+ if (length() == 0)
+ return npos;
+ size_t xpos = length () - 1;
+ if (xpos > pos)
+ xpos = pos;
+ for (++xpos; xpos-- > 0;)
+ if (_find (s, data () [xpos], 0, n) != npos)
+ return xpos;
+ return npos;
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_first_not_of (const charT* s, size_type pos, size_type n) const
+{
+ size_t xpos = pos;
+ for (; xpos < length (); ++xpos)
+ if (_find (s, data () [xpos], 0, n) == npos)
+ return xpos;
+ return npos;
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_first_not_of (charT c, size_type pos) const
+{
+ size_t xpos = pos;
+ for (; xpos < length (); ++xpos)
+ if (traits::ne (data () [xpos], c))
+ return xpos;
+ return npos;
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_last_not_of (const charT* s, size_type pos, size_type n) const
+{
+ if (length() == 0)
+ return npos;
+ size_t xpos = length () - 1;
+ if (xpos > pos)
+ xpos = pos;
+ for (++xpos; xpos-- > 0;)
+ if (_find (s, data () [xpos], 0, n) == npos)
+ return xpos;
+ return npos;
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::
+find_last_not_of (charT c, size_type pos) const
+{
+ if (length() == 0)
+ return npos;
+ size_t xpos = length () - 1;
+ if (xpos > pos)
+ xpos = pos;
+ for (++xpos; xpos-- > 0;)
+ if (traits::ne (data () [xpos], c))
+ return xpos;
+ return npos;
+}
+
+template <class charT, class traits, class Allocator>
+int basic_string <charT, traits, Allocator>::
+compare (const basic_string& _str, size_type pos, size_type n) const
+{
+ OUTOFRANGE (pos > length ());
+
+ size_t rlen = length () - pos;
+ if (rlen > n)
+ rlen = n;
+ if (rlen > _str.length ())
+ rlen = _str.length ();
+ int r = traits::compare (data () + pos, _str.data (), rlen);
+ if (r != 0)
+ return r;
+ if (rlen == n)
+ return 0;
+ return (length () - pos) - _str.length ();
+}
+
+template <class charT, class traits, class Allocator>
+int basic_string <charT, traits, Allocator>::
+compare (const charT* s, size_type pos, size_type n) const
+{
+ OUTOFRANGE (pos > length ());
+
+ size_t rlen = length () - pos;
+ if (rlen > n)
+ rlen = n;
+ int r = traits::compare (data () + pos, s, rlen);
+ if (r != 0)
+ return r;
+ return (length () - pos) - n;
+}
+
+#include <iostream.h>
+
+template <class charT, class traits, class Allocator>
+istream &
+operator>> (istream &is, basic_string <charT, traits, Allocator> &s)
+{
+ int w = is.width (0);
+ if (is.ipfx0 ())
+ {
+ register streambuf *sb = is.rdbuf ();
+ s.resize (0);
+ while (1)
+ {
+ int ch = sb->sbumpc ();
+ if (ch == EOF)
+ {
+ is.setstate (ios::eofbit);
+ break;
+ }
+ else if (traits::is_del (ch))
+ {
+ sb->sungetc ();
+ break;
+ }
+ s += static_cast<charT> (ch);
+ if (--w == 1)
+ break;
+ }
+ }
+
+ is.isfx ();
+ if (s.length () == 0)
+ is.setstate (ios::failbit);
+
+ return is;
+}
+
+template <class charT, class traits, class Allocator>
+ostream &
+operator<< (ostream &o, const basic_string <charT, traits, Allocator>& s)
+{
+ return o.write (s.data (), s.length ());
+}
+
+template <class charT, class traits, class Allocator>
+istream&
+getline (istream &is, basic_string <charT, traits, Allocator>& s, charT delim)
+{
+ if (is.ipfx1 ())
+ {
+ _IO_size_t _count = 0;
+ streambuf *sb = is.rdbuf ();
+ s.resize (0);
+
+ while (1)
+ {
+ int ch = sb->sbumpc ();
+ if (ch == EOF)
+ {
+ is.setstate (_count == 0
+ ? (ios::failbit|ios::eofbit)
+ : ios::eofbit);
+ break;
+ }
+
+ ++_count;
+
+ if (ch == delim)
+ break;
+
+ s += static_cast<charT> (ch);
+
+ if (s.length () == s.npos - 1)
+ {
+ is.setstate (ios::failbit);
+ break;
+ }
+ }
+ }
+
+ // We need to be friends with istream to do this.
+ // is._gcount = _count;
+ is.isfx ();
+
+ return is;
+}
+
+template <class charT, class traits, class Allocator>
+typename basic_string <charT, traits, Allocator>::Rep
+basic_string<charT, traits, Allocator>::nilRep = { 0, 0, 1, false };
+
+template <class charT, class traits, class Allocator>
+const typename basic_string <charT, traits, Allocator>::size_type
+basic_string <charT, traits, Allocator>::npos;
+
+} // extern "C++"
Added: gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/dcomplex.h
===================================================================
--- gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/dcomplex.h (rev 0)
+++ gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/dcomplex.h 2009-01-12 22:33:13 UTC (rev 1565)
@@ -0,0 +1,92 @@
+// The -*- C++ -*- double_complex class.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification in the 27 May 1994
+// C++ working paper, ANSI document X3J16/94-0098.
+
+#ifndef __DCOMPLEX__
+#define __DCOMPLEX__
+
+#ifdef __GNUG__
+#pragma interface "dcomplex"
+#endif
+
+extern "C++" {
+template <>
+class complex<double>
+{
+public:
+ complex (double r = 0, double i = 0): re (r), im (i) { }
+ complex (const complex<float>& r): re (r.real ()), im (r.imag ()) { }
+ explicit complex (const complex<long double>& r);
+
+ complex& operator+= (const complex& r) { return __doapl (this, r); }
+ complex& operator-= (const complex& r) { return __doami (this, r); }
+ complex& operator*= (const complex& r) { return __doaml (this, r); }
+ complex& operator/= (const complex& r) { return __doadv (this, r); }
+
+ double real () const { return re; }
+ double imag () const { return im; }
+private:
+ double re, im;
+
+ friend complex& __doapl<> (complex *, const complex&);
+ friend complex& __doami<> (complex *, const complex&);
+ friend complex& __doaml<> (complex *, const complex&);
+ friend complex& __doadv<> (complex *, const complex&);
+
+#ifndef __STRICT_ANSI__
+ friend inline complex operator + (const complex& x, double y)
+ { return operator+<> (x, y); }
+ friend inline complex operator + (double x, const complex& y)
+ { return operator+<> (x, y); }
+ friend inline complex operator - (const complex& x, double y)
+ { return operator-<> (x, y); }
+ friend inline complex operator - (double x, const complex& y)
+ { return operator-<> (x, y); }
+ friend inline complex operator * (const complex& x, double y)
+ { return operator*<> (x, y); }
+ friend inline complex operator * (double x, const complex& y)
+ { return operator*<> (x, y); }
+ friend inline complex operator / (const complex& x, double y)
+ { return operator/<> (x, y); }
+ friend inline complex operator / (double x, const complex& y)
+ { return operator/<> (x, y); }
+ friend inline bool operator == (const complex& x, double y)
+ { return operator==<> (x, y); }
+ friend inline bool operator == (double x, const complex& y)
+ { return operator==<> (x, y); }
+ friend inline bool operator != (const complex& x, double y)
+ { return operator!=<> (x, y); }
+ friend inline bool operator != (double x, const complex& y)
+ { return operator!=<> (x, y); }
+#endif /* __STRICT_ANSI__ */
+};
+
+inline complex<float>::complex (const complex<double>& r)
+: re (r.real ()), im (r.imag ())
+{ }
+} // extern "C++"
+
+#endif
Added: gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/fcomplex.h
===================================================================
--- gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/fcomplex.h (rev 0)
+++ gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/fcomplex.h 2009-01-12 22:33:13 UTC (rev 1565)
@@ -0,0 +1,88 @@
+// The -*- C++ -*- float_complex class.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification in the 27 May 1994
+// C++ working paper, ANSI document X3J16/94-0098.
+
+#ifndef __FCOMPLEX__
+#define __FCOMPLEX__
+
+#ifdef __GNUG__
+#pragma interface "fcomplex"
+#endif
+
+extern "C++" {
+template <>
+class complex<float>
+{
+public:
+ complex (float r = 0, float i = 0): re (r), im (i) { }
+ explicit complex (const complex<double>& r);
+ explicit complex (const complex<long double>& r);
+
+ complex& operator+= (const complex& r) { return __doapl (this, r); }
+ complex& operator-= (const complex& r) { return __doami (this, r); }
+ complex& operator*= (const complex& r) { return __doaml (this, r); }
+ complex& operator/= (const complex& r) { return __doadv (this, r); }
+
+ float real () const { return re; }
+ float imag () const { return im; }
+private:
+ float re, im;
+
+ friend complex& __doapl<> (complex *, const complex&);
+ friend complex& __doami<> (complex *, const complex&);
+ friend complex& __doaml<> (complex *, const complex&);
+ friend complex& __doadv<> (complex *, const complex&);
+
+#ifndef __STRICT_ANSI__
+ friend inline complex operator + (const complex& x, float y)
+ { return operator+<> (x, y); }
+ friend inline complex operator + (float x, const complex& y)
+ { return operator+<> (x, y); }
+ friend inline complex operator - (const complex& x, float y)
+ { return operator-<> (x, y); }
+ friend inline complex operator - (float x, const complex& y)
+ { return operator-<> (x, y); }
+ friend inline complex operator * (const complex& x, float y)
+ { return operator*<> (x, y); }
+ friend inline complex operator * (float x, const complex& y)
+ { return operator*<> (x, y); }
+ friend inline complex operator / (const complex& x, float y)
+ { return operator/<> (x, y); }
+ friend inline complex operator / (float x, const complex& y)
+ { return operator/<> (x, y); }
+ friend inline bool operator == (const complex& x, float y)
+ { return operator==<> (x, y); }
+ friend inline bool operator == (float x, const complex& y)
+ { return operator==<> (x, y); }
+ friend inline bool operator != (const complex& x, float y)
+ { return operator!=<> (x, y); }
+ friend inline bool operator != (float x, const complex& y)
+ { return operator!=<> (x, y); }
+#endif /* __STRICT_ANSI__ */
+};
+} // extern "C++"
+
+#endif
Added: gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/ldcomplex.h
===================================================================
--- gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/ldcomplex.h (rev 0)
+++ gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/ldcomplex.h 2009-01-12 22:33:13 UTC (rev 1565)
@@ -0,0 +1,96 @@
+// The -*- C++ -*- long_double_complex class.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification in the 27 May 1994
+// C++ working paper, ANSI document X3J16/94-0098.
+
+#ifndef __LDCOMPLEX__
+#define __LDCOMPLEX__
+
+#ifdef __GNUG__
+#pragma interface "ldcomplex"
+#endif
+
+extern "C++" {
+template <>
+class complex<long double>
+{
+public:
+ complex (long double r = 0, long double i = 0): re (r), im (i) { }
+ complex (const complex<float>& r): re (r.real ()), im (r.imag ()) { }
+ complex (const complex<double>& r): re (r.real ()), im (r.imag ()) { }
+
+ complex& operator+= (const complex& r) { return __doapl (this, r); }
+ complex& operator-= (const complex& r) { return __doami (this, r); }
+ complex& operator*= (const complex& r) { return __doaml (this, r); }
+ complex& operator/= (const complex& r) { return __doadv (this, r); }
+
+ long double real () const { return re; }
+ long double imag () const { return im; }
+private:
+ long double re, im;
+
+ friend complex& __doapl<> (complex *, const complex&);
+ friend complex& __doami<> (complex *, const complex&);
+ friend complex& __doaml<> (complex *, const complex&);
+ friend complex& __doadv<> (complex *, const complex&);
+
+#ifndef __STRICT_ANSI__
+ friend inline complex operator + (const complex& x, long double y)
+ { return operator+<> (x, y); }
+ friend inline complex operator + (long double x, const complex& y)
+ { return operator+<> (x, y); }
+ friend inline complex operator - (const complex& x, long double y)
+ { return operator-<> (x, y); }
+ friend inline complex operator - (long double x, const complex& y)
+ { return operator-<> (x, y); }
+ friend inline complex operator * (const complex& x, long double y)
+ { return operator*<> (x, y); }
+ friend inline complex operator * (long double x, const complex& y)
+ { return operator*<> (x, y); }
+ friend inline complex operator / (const complex& x, long double y)
+ { return operator/<> (x, y); }
+ friend inline complex operator / (long double x, const complex& y)
+ { return operator/<> (x, y); }
+ friend inline bool operator == (const complex& x, long double y)
+ { return operator==<> (x, y); }
+ friend inline bool operator == (long double x, const complex& y)
+ { return operator==<> (x, y); }
+ friend inline bool operator != (const complex& x, long double y)
+ { return operator!=<> (x, y); }
+ friend inline bool operator != (long double x, const complex& y)
+ { return operator!=<> (x, y); }
+#endif /* __STRICT_ANSI__ */
+};
+
+inline complex<float>::complex (const complex<long double>& r)
+: re (r.real ()), im (r.imag ())
+{ }
+
+inline complex<double>::complex (const complex<long double>& r)
+: re (r.real ()), im (r.imag ())
+{ }
+} // extern "C++"
+
+#endif
Added: gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/straits.h
===================================================================
--- gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/straits.h (rev 0)
+++ gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/std/straits.h 2009-01-12 22:33:13 UTC (rev 1565)
@@ -0,0 +1,162 @@
+// Character traits template for the -*- C++ -*- string classes.
+// Copyright (C) 1994 Free Software Foundation
+
+// This file is part of the GNU ANSI 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, if you link this library with files
+// compiled with a GNU compiler to produce an executable, this does not 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.
+
+// Written by Jason Merrill based upon the specification by Takanori Adachi
+// in ANSI X3J16/94-0013R2.
+
+#ifndef __STRING_CHAR_TRAITS__
+#define __STRING_CHAR_TRAITS__
+
+#ifdef __GNUG__
+// For string_char_traits <char>
+#pragma interface "std/straits.h"
+#endif
+
+#include <cstddef>
+
+extern "C++" {
+template <class charT>
+struct string_char_traits {
+ typedef charT char_type; // for users to acquire the basic character type
+
+ // constraints
+
+ static void assign (char_type& c1, const char_type& c2)
+ { c1 = c2; }
+ static bool eq (const char_type& c1, const char_type& c2)
+ { return (c1 == c2); }
+ static bool ne (const char_type& c1, const char_type& c2)
+ { return !(c1 == c2); }
+ static bool lt (const char_type& c1, const char_type& c2)
+ { return (c1 < c2); }
+ static char_type eos () { return char_type(); } // the null character
+ static bool is_del(char_type a) { return 0; }
+ // characteristic function for delimiters of charT
+
+ // speed-up functions
+
+ static int compare (const char_type* s1, const char_type* s2, size_t n)
+ {
+ size_t i;
+ for (i = 0; i < n; ++i)
+ if (ne (s1[i], s2[i]))
+ return lt (s1[i], s2[i]) ? -1 : 1;
+
+ return 0;
+ }
+
+ static size_t length (const char_type* s)
+ {
+ size_t l = 0;
+ while (ne (*s++, eos ()))
+ ++l;
+ return l;
+ }
+
+ static char_type* copy (char_type* s1, const char_type* s2, size_t n)
+ {
+ for (; n--; )
+ assign (s1[n], s2[n]);
+ return s1;
+ }
+
+ static char_type* move (char_type* s1, const char_type* s2, size_t n)
+ {
+ char_type a[n];
+ size_t i;
+ for (i = 0; i < n; ++i)
+ assign (a[i], s2[i]);
+ for (i = 0; i < n; ++i)
+ assign (s1[i], a[i]);
+ return s1;
+ }
+
+ static char_type* set (char_type* s1, const char_type& c, size_t n)
+ {
+ for (; n--; )
+ assign (s1[n], c);
+ return s1;
+ }
+};
+
+class istream;
+class ostream;
+#include <cctype>
+#include <cstring>
+
+template <>
+struct string_char_traits <char> {
+ typedef char char_type;
+
+ static void assign (char_type& c1, const char_type& c2)
+ { c1 = c2; }
+ static bool eq (const char_type & c1, const char_type& c2)
+ { return (c1 == c2); }
+ static bool ne (const char_type& c1, const char_type& c2)
+ { return (c1 != c2); }
+ static bool lt (const char_type& c1, const char_type& c2)
+ { return (c1 < c2); }
+ static char_type eos () { return 0; }
+ static bool is_del(char_type a) { return isspace(a); }
+
+ static int compare (const char_type* s1, const char_type* s2, size_t n)
+ { return memcmp (s1, s2, n); }
+ static size_t length (const char_type* s)
+ { return strlen (s); }
+ static char_type* copy (char_type* s1, const char_type* s2, size_t n)
+ { return (char_type*) memcpy (s1, s2, n); }
+ static char_type* move (char_type* s1, const char_type* s2, size_t n)
+ { return (char_type*) memmove (s1, s2, n); }
+ static char_type* set (char_type* s1, const char_type& c, size_t n)
+ { return (char_type*) memset (s1, c, n); }
+};
+
+#if 0
+#include <cwctype>
+struct string_char_traits <wchar_t> {
+ typedef wchar_t char_type;
+
+ static void assign (char_type& c1, const char_type& c2)
+ { c1 = c2; }
+ static bool eq (const char_type & c1, const char_type& c2)
+ { return (c1 == c2); }
+ static bool ne (const char_type& c1, const char_type& c2)
+ { return (c1 != c2); }
+ static bool lt (const char_type& c1, const char_type& c2)
+ { return (c1 < c2); }
+ static char_type eos () { return 0; }
+ static bool is_del(char_type a) { return iswspace(a); }
+
+ static int compare (const char_type* s1, const char_type* s2, size_t n)
+ { return wmemcmp (s1, s2, n); }
+ static size_t length (const char_type* s)
+ { return wcslen (s); }
+ static char_type* copy (char_type* s1, const char_type* s2, size_t n)
+ { return wmemcpy (s1, s2, n); }
+ static char_type* set (char_type* s1, const char_type& c, size_t n)
+ { return wmemset (s1, c, n); }
+};
+#endif
+} // extern "C++"
+#endif
Added: gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/stl_alloc.h
===================================================================
--- gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/stl_alloc.h (rev 0)
+++ gccxml_bin/v09/linux2/share/gccxml-0.9/GCC/2.95/stl_alloc.h 2009-01-12 22:33:13 UTC (rev 1565)
@@ -0,0 +1,1057 @@
+/*
+ * Copyright (c) 1996-1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef __SGI_STL_INTERNAL_ALLOC_H
+#define __SGI_STL_INTERNAL_ALLOC_H
+
+#ifdef __SUNPRO_CC
+# define __PRIVATE public
+ // Extra access restrictions prevent us from really making some things
+ // private.
+#else
+# define __PRIVATE private
+#endif
+
+#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
+# define __USE_MALLOC
+#endif
+
+
+// This implements some standard node allocators. These are
+// NOT the same as the allocators in the C++ draft standard or in
+// in the original STL. They do not encapsulate different pointer
+// types; indeed we assume that there is only one pointer type.
+// The allocation primitives are intended to allocate individual objects,
+// not larger arenas as with the original STL allocators.
+
+#ifdef __STL_USE_EXCEPTIONS
+# include <new>
+# define __THROW_BAD_ALLOC throw bad_alloc()
+#elif !defined(__THROW_BAD_ALLOC)
+# include <iostream.h>
+# define __THROW_BAD_ALLOC cerr << "out of memory" << endl; exit(1)
+#endif
+
+#ifdef __STL_WIN32THREADS
+# include <windows.h>
+#endif
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#ifndef __RESTRICT
+# define __RESTRICT
+#endif
+
+#if !defined(__STL_PTHREADS) && !defined(__STL_SOLTHREADS) \
+ && !defined(_NOTHREADS) \
+ && !defined(__STL_SGI_THREADS) && !defined(__STL_WIN32THREADS)
+# define _NOTHREADS
+#endif
+
+# ifdef __STL_PTHREADS
+ // POSIX Threads
+ // This is dubious, since this is likely to be a high contention
+ // lock. Performance may not be adequate.
+# include <pthread.h>
+# define __NODE_ALLOCATOR_LOCK \
+ if (threads) pthread_mutex_lock(&_S_node_allocator_lock)
+# define __NODE_ALLOCATOR_UNLOCK \
+ if (threads) pthread_mutex_unlock(&_S_node_allocator_lock)
+# define __NODE_ALLOCATOR_THREADS true
+# define __VOLATILE volatile // Needed at -O3 on SGI
+# endif
+# ifdef __STL_SOLTHREADS
+# include <thread.h>
+# define __NODE_ALLOCATOR_LOCK \
+ if (threads) mutex_lock(&_S_node_allocator_lock)
+# define __NODE_ALLOCATOR_UNLOCK \
+ if (threads) mutex_unlock(&_S_node_allocator_lock)
+# define __NODE_ALLOCATOR_THREADS true
+# define __VOLATILE
+# endif
+# ifdef __STL_WIN32THREADS
+ // The lock needs to be initialized by constructing an allocator
+ // objects of the right type. We do that here explicitly for alloc.
+# define __NODE_ALLOCATOR_LOCK \
+ EnterCriticalSection(&_S_node_allocator_lock)
+# define __NODE_ALLOCATOR_UNLOCK \
+ LeaveCriticalSection(&_S_node_allocator_lock)
+# define __NODE_ALLOCATOR_THREADS true
+# define __VOLATILE volatile // may not be needed
+# endif /* WIN32THREADS */
+# ifdef __STL_SGI_THREADS
+ // This should work without threads, with sproc threads, or with
+ // pthreads. It is suboptimal in all cases.
+ // It is unlikely to even compile on nonSGI machines.
+
+ extern "C" {
+ extern int __us_rsthread_malloc;
+ }
+ // The above is copied from malloc.h. Including <malloc.h>
+ // would be cleaner but fails with certain levels of standard
+ // conformance.
+# define __NODE_ALLOCATOR_LOCK if (threads && __us_rsthread_malloc) \
+ { _S_lock(&_S_node_allocator_lock); }
+# define __NODE_ALLOCATOR_UNLOCK if (threads && __us_rsthread_malloc) \
+ { _S_unlock(&_S_node_allocator_lock); }
+# define __NODE_ALLOCATOR_THREADS true
+# define __VOLATILE volatile // Needed at -O3 on SGI
+# endif
+# ifdef _NOTHREADS
+// Thread-unsafe
+# define __NODE_ALLOCATOR_LOCK
+# define __NODE_ALLOCATOR_UNLOCK
+# define __NODE_ALLOCATOR_THREADS false
+# define __VOLATILE
+# endif
+
+__STL_BEGIN_NAMESPACE
+
+#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+#pragma set woff 1174
+#endif
+
+// Malloc-based allocator. Typically slower than default alloc below.
+// Typically thread-safe and more storage efficient.
+#ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG
+# ifdef __DECLARE_GLOBALS_HERE
+ void (* __malloc_alloc_oom_handler)() = 0;
+ // g++ 2.7.2 does not handle static template data members.
+# else
+ extern void (* __malloc_alloc_oom_handler)();
+# endif
+#endif
+
+template <int __inst>
+class __malloc_alloc_template {
+
+private:
+
+ static void* _S_oom_malloc(size_t);
+ static void* _S_oom_realloc(void*, size_t);
+
+#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
+ static void (* __malloc_alloc_oom_handler)();
+#endif
+
+public:
+
+ static void* allocate(size_t __n)
+ {
+ void* __result = malloc(__n);
+ if (0 == __result) __result = _S_oom_malloc(__n);
+ return __result;
+ }
+
+ static void deallocate(void* __p, size_t /* __n */)
+ {
+ free(__p);
+ }
+
+ static void* reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)
+ {
+ void* __result = realloc(__p, __new_sz);
+ if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);
+ return __result;
+ }
+
+ static void (* __set_malloc_handler(void (*__f)()))()
+ {
+ void (* __old)() = __malloc_alloc_oom_handler;
+ __malloc_alloc_oom_handler = __f;
+ return(__old);
+ }
+
+};
+
+// malloc_alloc out-of-memory handling
+
+#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
+template <int __inst>
+void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;
+#endif
+
+template <int __inst>
+void*
+__malloc_alloc_template<__inst>::_S_oom_malloc(size_t __n)
+{
+ void (* __my_malloc_handler)();
+ void* __result;
+
+ for (;;) {
+ __my_malloc_handler = __malloc_alloc_oom_handler;
+ if (0 == __my_malloc_handler) { __THROW_BAD_ALLOC; }
+ (*__my_malloc_handler)();
+ __result = malloc(__n);
+ if (__result) return(__result);
+ }
+}
+
+template <int __inst>
+void* __malloc_alloc_template<__inst>::_S_oom_realloc(void* __p, size_t __n)
+{
+ void (* __my_malloc_handler)();
+ void* __result;
+
+ for (;;) {
+ __my_malloc_handler = __malloc_alloc_oom_handler;
+ if (0 == __my_malloc_handler) { __THROW_BAD_ALLOC; }
+ (*__my_malloc_handler)();
+ __result = realloc(__p, __n);
+ if (__result) return(__result);
+ }
+}
+
+typedef __malloc_alloc_template<0> malloc_alloc;
+
+template<class _Tp, class _Alloc>
+class simple_alloc {
+
+public:
+ static _Tp* allocate(size_t __n)
+ { return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); }
+ static _Tp* allocate(void)
+ { return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }
+ static void deallocate(_Tp* __p, size_t __n)
+ { if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); }
+ static void deallocate(_Tp* __p)
+ { _Alloc::deallocate(__p, sizeof (_Tp)); }
+};
+
+// Allocator adaptor to check size arguments for debugging.
+// Reports errors using assert. Checking can be disabled with
+// NDEBUG, but it's far better to just use the underlying allocator
+// instead when no checking is desired.
+// There is some evidence that this can confuse Purify.
+template <class _Alloc>
+class debug_alloc {
+
+private:
+
+ enum {_S_extra = 8}; // Size of space used to store size. Note
+ // that this must be large enough to preserve
+ // alignment.
+
+public:
+
+ static void* allocate(size_t __n)
+ {
+ char* __result = (char*)_Alloc::allocate(__n + _S_extra);
+ *(size_t*)__result = __n;
+ return __result + _S_extra;
+ }
+
+ static void deallocate(void* __p, size_t __n)
+ {
+ char* __real_p = (char*)__p - _S_extra;
+ assert(*(size_t*)__real_p == __n);
+ _Alloc::deallocate(__real_p, __n + _S_extra);
+ }
+
+ static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz)
+ {
+ char* __real_p = (char*)__p - _S_extra;
+ assert(*(size_t*)__real_p == __old_sz);
+ char* __result = (char*)
+ _Alloc::reallocate(__real_p, __old_sz + _S_extra, __new_sz + _S_extra);
+ *(size_t*)__result = __new_sz;
+ return __result + _S_extra;
+ }
+
+};
+
+
+# ifdef __USE_MALLOC
+
+typedef malloc_alloc alloc;
+typedef malloc_alloc single_client_alloc;
+
+# else
+
+
+// Default node allocator.
+// With a reasonable compiler, this should be roughly as fast as the
+// original STL class-specific allocators, but with less fragmentation.
+// Default_alloc_template parameters are experimental and MAY
+// DISAPPEAR in the future. Clients should just use alloc for now.
+//
+// Important implementation properties:
+// 1. If the client request an object of size > _MAX_BYTES, the resulting
+// object will be obtained directly from malloc.
+// 2. In all other cases, we allocate an object of size exactly
+// _S_round_up(requested_size). Thus the client has enough size
+// information that we can return the object to the proper free list
+// without permanently losing part of the object.
+//
+
+// The first template parameter specifies whether more than one thread
+// may use this allocator. It is safe to allocate an object from
+// one instance of a default_alloc and deallocate it with another
+// one. This effectively transfers its ownership to the second one.
+// This may have undesirable effects on reference locality.
+// The second parameter is unreferenced and serves only to allow the
+// creation of multiple default_alloc instances.
+// Node that containers built on different allocator instances have
+// different types, limiting the utility of this approach.
+#ifdef __SUNPRO_CC
+// breaks if we make these template class members:
+ enum {_ALIGN = 8};
+ enum {_MAX_BYTES = 128};
+ enum {_NFREELISTS = _MAX_BYTES/_ALIGN};
+#endif
+
+template <bool threads, int inst>
+class __default_alloc_template {
+
+private:
+ // Really we should use static const int x = N
+ // instead of enum { x = N }, but few compilers accept the former.
+# ifndef __SUNPRO_CC
+ enum {_ALIGN = 8};
+ enum {_MAX_BYTES = 128};
+ enum {_NFREELISTS = _MAX_BYTES/_ALIGN};
+# endif
+ static size_t
+ _S_round_up(size_t __bytes)
+ { return (((__bytes) + _ALIGN-1) & ~(_ALIGN - 1)); }
+
+__PRIVATE:
+ union _Obj {
+ union _Obj* _M_free_list_link;
+ char _M_client_data[1]; /* The client sees this. */
+ };
+private:
+# ifdef __SUNPRO_CC
+ static _Obj* __VOLATILE _S_free_list[];
+ // Specifying a size results in duplicate def for 4.1
+# else
+ static _Obj* __VOLATILE _S_free_list[_NFREELISTS];
+# endif
+ static size_t _S_freelist_index(size_t __bytes) {
+ return (((__bytes) + _ALIGN-1)/_ALIGN - 1);
+ }
+
+ // Returns an object of size __n, and optionally adds to size __n free list.
+ static void* _S_refill(size_t __n);
+ // Allocates a chunk for nobjs of size "size". nobjs may be reduced
+ // if it is inconvenient to allocate the requested number.
+ static char* _S_chunk_alloc(size_t __size, int& __nobjs);
+
+ // Chunk allocation state.
+ static char* _S_start_free;
+ static char* _S_end_free;
+ static size_t _S_heap_size;
+
+# ifdef __STL_SGI_THREADS
+ static volatile unsigned long _S_node_allocator_lock;
+ static void _S_lock(volatile unsigned long*);
+ static inline void _S_unlock(volatile unsigned long*);
+# endif
+
+# ifdef __STL_PTHREADS
+ static pthread_mutex_t _S_node_allocator_lock;
+# endif
+
+# ifdef __STL_SOLTHREADS
+ static mutex_t _S_node_allocator_lock;
+# endif
+
+# ifdef __STL_WIN32THREADS
+ static CRITICAL_SECTION _S_node_allocator_lock;
+ static bool _S_node_allocator_lock_initialized;
+
+ public:
+ __default_alloc_template() {
+ // This assumes the first constructor is called before threads
+ // are started.
+ if (!_S_node_allocator_lock_initialized) {
+ InitializeCriticalSection(&_S_node_allocator_lock);
+ _S_node_allocator_lock_initialized = true;
+ }
+ }
+ private:
+# endif
+
+ class _Lock {
+ public:
+ _Lock() { __NODE_ALLOCATOR_LOCK; }
+ ~_Lock() { __NODE_ALLOCATOR_UNLOCK; }
+ };
+ friend class _Lock;
+
+public:
+
+ /* __n must be > 0 */
+ static void* allocate(size_t __n)
+ {
+ _Obj* __VOLATILE* __my_free_list;
+ _Obj* __RESTRICT __result;
+
+ if (__n > (size_t) _MAX_BYTES) {
+ return(malloc_alloc::allocate(__n));
+ }
+ __my_free_list = _S_free_list + _S_freelist_index(__n);
+ // Acquire the lock here with a constructor call.
+ // This ensures that it is released in exit or during stack
+ // unwinding.
+# ifndef _NOTHREADS
+ /*REFERENCED*/
+ _Lock __lock_instance;
+# endif
+ __result = *__my_free_list;
+ if (__result == 0) {
+ void* __r = _S_refill(_S_round_up(__n));
+ return __r;
+ }
+ *__my_free_list = __result -> _M_free_list_link;
+ return (__result);
+ };
+
+ /* __p may not be 0 */
+ static void deallocate(void* __p, size_t __n)
+ {
+ _Obj* __q = (_Obj*)__p;
+ _Obj* __VOLATILE* __my_free_list;
+
+ if (__n > (size_t) _MAX_BYTES) {
+ malloc_alloc::deallocate(__p, __n);
+ return;
+ }
+ __my_free_list = _S_free_list + _S_freelist_index(__n);
+ // acquire lock
+# ifndef _NOTHREADS
+ /*REFERENCED*/
+ _Lock __lock_instance;
+# endif /* _NOTHREADS */
+ __q -> _M_free_list_link = *__my_free_list;
+ *__my_free_list = __q;
+ // lock is released here
+ }
+
+ static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz);
+
+} ;
+
+typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
+typedef __default_alloc_template<false, 0> single_client_alloc;
+
+
+
+/* We allocate memory in large chunks in order to avoid fragmenting */
+/* the malloc heap too much. */
+/* We assume that size is properly aligned. */
+/* We hold the allocation lock. */
+template <bool __threads, int __inst>
+char*
+__default_alloc_template<__threads, __inst>::_S_chunk_alloc(size_t __size,
+ int& __nobjs)
+{
+ char* __result;
+ size_t __total_bytes = __size * __nobjs;
+ size_t __bytes_left = _S_end_free - _S_start_free;
+
+ if (__bytes_left >= __total_bytes) {
+ __result = _S_start_free;
+ _S_start_free += __total_bytes;
+ return(__result);
+ } else if (__bytes_left >= __size) {
+ __nobjs = (int)(__bytes_left/__size);
+ __total_bytes = __size * __nobjs;
+ __result = _S_start_free;
+ _S_start_free += __total_bytes;
+ return(__result);
+ } else {
+ size_t __bytes_to_get =
+ 2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
+ // Try to make use of the left-over piece.
+ if (__bytes_left > 0) {
+ _Obj* __VOLATILE* __my_free_list =
+ _S_free_list + _S_freelist_index(__bytes_left);
+
+ ((_Obj*)_S_start_free) -> _M_free_list_link = *__my_free_list;
+ *__my_free_list = (_Obj*)_S_start_free;
+ }
+ _S_start_free = (char*)malloc(__bytes_to_get);
+ if (0 == _S_start_free) {
+ size_t __i;
+ _Obj* __VOLATILE* __my_free_list;
+ _Obj* __p;
+ // Try to make do with what we have. That can't
+ // hurt. We do not try smaller requests, since that tends
+ // to result in disaster on multi-process machines.
+ for (__i = __size; __i <= _MAX_BYTES; __i += _ALIGN) {
+ __my_free_list = _S_free_list + _S_freelist_index(__i);
+ __p = *__my_free_list;
+ if (0 != __p) {
+ *__my_free_list = __p -> _M_free_list_link;
+ _S_start_free = (char*)__p;
+ _S_end_free = _S_start_free + __i;
+ return(_S_chunk_alloc(__size, __nobjs));
+ // Any leftover piece will eventually make it to the
+ // right free list.
+ }
+ }
+ _S_end_free = 0; // In case of exception.
+ _S_start_free = (char*)malloc_alloc::allocate(__bytes_to_get);
+ // This should either throw an
+ // exception or remedy the situation. Thus we assume it
+ // succeeded.
+ }
+ _S_heap_size += __bytes_to_get;
+ _S_end_free = _S_start_free + __bytes_to_get;
+ return(_S_chunk_alloc(__size, __nobjs));
+ }
+}
+
+
+/* Returns an object of size __n, and optionally adds to size __n free list.*/
+/* We assume that __n is properly aligned. */
+/* We hold the allocation lock. */
+template <bool __threads, int __inst>
+void*
+__default_alloc_template<__threads, __inst>::_S_refill(size_t __n)
+{
+ int __nobjs = 20;
+ char* __chunk = _S_chunk_alloc(__n, __nobjs);
+ _Obj* __VOLATILE* __my_free_list;
+ _Obj* __result;
+ _Obj* __current_obj;
+ _Obj* __next_obj;
+ int __i;
+
+ if (1 == __nobjs) return(__chunk);
+ __my_free_list = _S_free_list + _S_freelist_index(__n);
+
+ /* Build free list in chunk */
+ __result = (_Obj*)__chunk;
+ *__my_free_list = __next_obj = (_Obj*)(__chunk + __n);
+ for (__i = 1; ; __i++) {
+ __current_obj = __next_obj;
+ __next_obj = (_Obj*)((char*)__next_obj + __n);
+ if (__nobjs - 1 == __i) {
+ __current_obj -> _M_free_list_link = 0;
+ break;
+ } else {
+ __current_obj -> _M_free_list_link = __next_obj;
+ }
+ }
+ return(__result);
+}
+
+template <bool threads, int inst>
+void*
+__default_alloc_template<threads, inst>::reallocate(void* __p,
+ size_t __old_sz,
+ size_t __new_sz)
+{
+ void* __result;
+ size_t __copy_sz;
+
+ if (__old_sz > (size_t) _MAX_BYTES && __new_sz > (size_t) _MAX_BYTES) {
+ return(realloc(__p, __new_sz));
+ }
+ if (_S_round_up(__old_sz) == _S_round_up(__new_sz)) return(__p);
+ __result = allocate(__new_sz);
+ __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
+ memcpy(__result, __p, __copy_sz);
+ deallocate(__p, __old_sz);
+ return(__result);
+}
+
+#ifdef __STL_PTHREADS
+ template <bool __threads, int __inst>
+ pthread_mutex_t
+ __default_alloc_template<__threads, __inst>::_S_node_allocator_lock
+ = PTHREAD_MUTEX_INITIALIZER;
+#endif
+
+#ifdef __STL_SOLTHREADS
+ template <bool __threads, int __inst>
+ mutex_t
+ __default_alloc_template<__threads, __inst>::_S_node_allocator_lock
+ = DEFAULTMUTEX;
+#endif
+
+#ifdef __STL_WIN32THREADS
+ template <bool __threads, int __inst>
+ CRITICAL_SECTION
+ __default_alloc_template<__threads, __inst>::
+ _S_node_allocator_lock;
+
+ template <bool __threads, int __inst>
+ bool
+ __default_alloc_template<__threads, __inst>::
+ _S_node_allocator_lock_initialized
+ = false;
+#endif
+
+#ifdef __STL_SGI_THREADS
+__STL_END_NAMESPACE
+#include <mutex.h>
+#include <time.h> /* XXX should use <ctime> */
+__STL_BEGIN_NAMESPACE
+// Somewhat generic lock implementations. We need only test-and-set
+// and some way to sleep. These should work with both SGI pthreads
+// and sproc threads. They may be useful on other systems.
+template <bool __threads, int __inst>
+volatile unsigned long
+__default_alloc_template<__threads, __inst>::_S_node_allocator_lock = 0;
+
+#if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64)) || defined(__GNUC__)
+# define __test_and_set(l,v) test_and_set(l,v)
+#endif
+
+template <bool __threads, int __inst>
+void
+__default_alloc_template<__threads, __inst>::
+ _S_lock(volatile unsigned long* __lock)
+{
+ const unsigned __low_spin_max = 30; // spins if we suspect uniprocessor
+ const unsigned __high_spin_max = 1000; // spins for multiprocessor
+ static unsigned __spin_max = __low_spin_max;
+ unsigned __my_spin_max;
+ static unsigned __last_spins = 0;
+ unsigned __my_last_spins;
+ unsigned __junk;
+# define __ALLOC_PAUSE \
+ __junk *= __junk; __junk *= __junk; __junk *= __junk; __junk *= __junk
+ int __i;
+
+ if (!__test_and_set((unsigned long*)__lock, 1)) {
+ return;
+ }
+ __my_spin_max = __spin_max;
+ __my_last_spins = __last_spins;
+ for (__i = 0; __i < __my_spin_max; __i++) {
+ if (__i < __my_last_spins/2 || *__lock) {
+ __ALLOC_PAUSE;
+ continue;
+ }
+ if (!__test_and_set((unsigned long*)__lock, 1)) {
+ // got it!
+ // Spinning worked. Thus we're probably not being scheduled
+ // against the other process with which we were contending.
+ // Thus it makes sense to spin longer the next time.
+ __last_spins = __i;
+ __spin_max = __high_spin_max;
+ return;
+ }
+ }
+ // We are probably being scheduled against the other process. Sleep.
+ __spin_max = __low_spin_max;
+ for (__i = 0 ;; ++__i) {
+ struct timespec __ts;
+ int __log_nsec = __i + 6;
+
+ if (!__test_and_set((unsigned long *)__lock, 1)) {
+ return;
+ }
+ if (__log_nsec > 27) __log_nsec = 27;
+ /* Max sleep is 2**27nsec ~ 60msec */
+ __ts.tv_sec = 0;
+ __ts.tv_nsec = 1 << __log_nsec;
+ nanosleep(&__ts, 0);
+ }
+}
+
+template <bool __threads, int __inst>
+inline void
+__default_alloc_template<__threads, __inst>::_S_unlock(
+ volatile unsigned long* __lock)
+{
+# if defined(__GNUC__) && __mips >= 3
+ asm("sync");
+ *__lock = 0;
+# elif __mips >= 3 && (defined (_ABIN32) || defined(_ABI64))
+ __lock_release(__lock);
+# else
+ *__lock = 0;
+ // This is not sufficient on many multiprocessors, since
+ // writes to protected variables and the lock may be reordered.
+# endif
+}
+#endif
+
+template <bool __threads, int __inst>
+char* __default_alloc_template<__threads, __inst>::_S_start_free = 0;
+
+template <bool __threads, int __inst>
+char* __default_alloc_template<__threads, __inst>::_S_end_free = 0;
+
+template <bool __threads, int __inst>
+size_t __default_alloc_template<__threads, __inst>::_S_heap_size = 0;
+
+template <bool __threads, int __inst>
+typename __default_alloc_template<__threads, __inst>::_Obj* __VOLATILE
+__default_alloc_template<__threads, __inst> ::_S_free_list[
+ _NFREELISTS
+] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
+// The 16 zeros are necessary to make version 4.1 of the SunPro
+// compiler happy. Otherwise it appears to allocate too little
+// space for the array.
+
+# ifdef __STL_WIN32THREADS
+ // Create one to get critical section initialized.
+ // We do this onece per file, but only the first constructor
+ // does anything.
+ static alloc __node_allocator_dummy_instance;
+# endif
+
+#endif /* ! __USE_MALLOC */
+
+// This implements allocators as specified in the C++ standard.
+//
+// Note that standard-conforming allocators use many language features
+// that are not yet widely implemented. In particular, they rely on
+// member templates, partial specialization, partial ordering of function
+// templates, the typename keyword, and the use of the template keyword
+// to refer to a template member of a dependent type.
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+template <class _Tp>
+class allocator {
+ typedef alloc _Alloc; // The underlying allocator.
+public:
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef _Tp* pointer;
+ typedef const _Tp* const_pointer;
+ typedef _Tp& reference;
+ typedef const _Tp& const_reference;
+ typedef _Tp value_type;
+
+ template <class _Tp1> struct rebind {
+ typedef allocator<_Tp1> other;
+ };
+
+ allocator() __STL_NOTHROW {}
+ allocator(const allocator&) __STL_NOTHROW {}
+ template <class _Tp1> allocator(const allocator<_Tp1>&) __STL_NOTHROW {}
+ ~allocator() __STL_NOTHROW {}
+
+ pointer address(reference __x) const { return &__x; }
+ const_pointer address(const_reference __x) const { return &__x; }
+
+ // __n is permitted to be 0. The C++ standard says nothing about what
+ // the return value is when __n == 0.
+ _Tp* allocate(size_type __n, const void* = 0) {
+ return __n != 0 ? static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)))
+ : 0;
+ }
+
+ // __p is not permitted to be a null pointer.
+ void deallocate(pointer __p, size_type __n)
+ { _Alloc::deallocate(__p, __n * sizeof(_Tp)); }
+
+ size_type max_size() const __STL_NOTHROW
+ { return size_t(-1) / sizeof(_Tp); }
+
+ void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
+ void destroy(pointer __p) { __p->~_Tp(); }
+};
+
+template<>
+class allocator<void> {
+ typedef size_t size_type;
+ typedef ptrdiff_t ...
[truncated message content] |
