computer programing help

 

Hardware and Software are in many items we use in our daily lives. Name a few items in your house or office that have some sort of hardware and software. Look beyond your computer and other devices used with your computer. Thinking of the software that they may have, what does the software provide and how does it make the device/hardware better? Respond to at least two of your classmates’ postings.

   

Install the application provided with the text. You should be installing Microsoft Visual C++ 2005 (Windows Vista users will also need to install Service Pack 1 before running the program).

 

You will also need to copy the zip file that provides the C++ libraries: Libraries.zip. Please read these Instructions on downloading the zip files to your hard drive.

 

As part of this exercise you will also use the sample code below to test the application, compile the code and communicate that your application was installed and working.

 

This is the sample code:

 

#include #include using namespace std;

 

int main() {   string str1(“Alpha”);   string str2(“Beta”);   string str3(“Omega”);   string str4;

 

  // assign a string   str4 = str1;   cout << str1 << "\n" << str3 << "\n";

 

  // concatenate two strings   str4 = str1 + str2;   cout << str4 << "\n";

 

  // concatenate a string with a C-string   str4 = str1 + ” to ” + str3;   cout << str4 << "\n";

 

  // compare strings   if(str3 > str1) cout << "str3 > str1\n”;   if(str3 == str1+str2)     cout << "str3 == str1+str2\n";

 

  /* A string object can also be      assigned a normal string. */   str1 = “This is a null-terminated string.\n”;   cout << str1;

 

  // create a string object using another string object   string str5(str1);   cout << str5;

 

  // input a string   cout << "Enter a string: ";   cin >> str5;   cout << str5;

 

system(“pause”); return 0;   }

 

The code above is a simple program that will output some string statements and then ask for one input and close after you enter text and then hit enter.

 

Try to change the text once you are successful and rename your source file. Play around with the strings. Report your experience and your efforts to the discussion board. Respond to at least two of your classmates’ postings.

   

How to add Libraries

 

–         

Open zip file and place then in a directory on your hard drive. I recommend adding the folder called library to:

 

C:\Program Files\Microsoft Visual Studio 8

 

–          When you are done you will have the following

; C:\Program Files\Microsoft Visual Studio 8\library

 

–          Now right click on the computer icon on your desktop and click on properties.  You will be in the “System Information” screen.

 

–          Click on “Advanced Settings” and when prompted, click on continue

 

–          Click on the “Environment Variables” button

 

–          In the second box on the screen called “System Variables”, click on the line with “Path”. This will highlight the whole line.

 

–          Click on the “Edit” button

 

–          Go to the end of the line and add the following:

 ; C:\Program Files\Microsoft Visual Studio 8\library 

–          When ready, click “ok”, “ok”, “ok”

 

Zip File

 

Download and open the library.zip file from the classroom.

 

Unzip and extract all the files to the directory we created:

 C:\Program Files\Microsoft Visual Studio 8 

-*- C++ -*- forwarding header.// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002// 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: 20.4.6  C library///** @file csignal *  This is a Standard C++ Library file.  You should @c #include this file *  in your programs, rather than any of the “*.h” implementation files. * *  This is the C++ version of the Standard C Library header @c signal.h, *  and its contents are (mostly) the same as that header, but are all *  contained in the namespace @c std. */#ifndef _GLIBCXX_CSIGNAL#define _GLIBCXX_CSIGNAL 1#pragma GCC system_header#include // Get rid of those macros defined in in lieu of real functions.#undef raisenamespace std{  using ::sig_atomic_t;  using ::signal;  using ::raise;}#endif

 

cstdlib
// -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
// 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: 20.4.6 C library
//
/** @file cstdlib
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c stdlib.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CSTDLIB
#define _GLIBCXX_CSTDLIB 1
#pragma GCC system_header
#include
#include
#include
// Get rid of those macros defined in in lieu of real functions.
#undef abort
#undef abs
#undef atexit
#undef atof
#undef atoi
#undef atol
#undef bsearch
#undef calloc
#undef div
#undef exit
#undef free
#undef getenv
#undef labs
#undef ldiv
#undef malloc
#undef mblen
#undef mbstowcs
#undef mbtowc
#undef qsort
#undef rand
#undef realloc
#undef srand
#undef strtod
#undef strtol
#undef strtoul
#undef system
#undef wcstombs
#undef wctomb
namespace std
{
using ::div_t;
using ::ldiv_t;
using ::abort;
using ::abs;
using ::atexit;
using ::atof;
using ::atoi;
using ::atol;
using ::bsearch;
using ::calloc;
using ::div;
using ::exit;
using ::free;
using ::getenv;
using ::labs;
using ::ldiv;
using ::malloc;
#ifdef _GLIBCXX_HAVE_MBSTATE_T
using ::mblen;
using ::mbstowcs;
using ::mbtowc;
#endif // _GLIBCXX_HAVE_MBSTATE_T
using ::qsort;
using ::rand;
using ::realloc;
using ::srand;
using ::strtod;
using ::strtol;
using ::strtoul;
using ::system;
#ifdef _GLIBCXX_USE_WCHAR_T
using ::wcstombs;
using ::wctomb;
#endif // _GLIBCXX_USE_WCHAR_T
inline long
abs(long __i) { return labs(__i); }
inline ldiv_t
div(long __i, long __j) { return ldiv(__i, __j); }
}
#if _GLIBCXX_USE_C99
#undef _Exit
#undef llabs
#undef lldiv
#undef atoll
#undef strtoll
#undef strtoull
#undef strtof
#undef strtold
namespace __gnu_cxx
{
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
using ::lldiv_t;
#endif
#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
extern “C” void (_Exit)(int);
#endif
#if !_GLIBCXX_USE_C99_DYNAMIC
using ::_Exit;
#endif
inline long long
abs(long long __x) { return __x >= 0 ? __x : -__x; }
inline long long
llabs(long long __x) { return __x >= 0 ? __x : -__x; }
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
inline lldiv_t
div(long long __n, long long __d)
{ lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
inline lldiv_t
lldiv(long long __n, long long __d)
{ lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
#endif
#if _GLIBCXX_USE_C99_LONG_LONG_CHECK || _GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
extern “C” long long int (atoll)(const char *);
extern “C” long long int
(strtoll)(const char * restrict, char ** restrict, int);
extern “C” unsigned long long int
(strtoull)(const char * restrict, char ** restrict, int);
#endif
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
using ::atoll;
using ::strtoll;
using ::strtoull;
#endif
using ::strtof;
using ::strtold;
}
namespace std
{
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
using __gnu_cxx::lldiv_t;
#endif
using __gnu_cxx::_Exit;
using __gnu_cxx::abs;
using __gnu_cxx::llabs;
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
using __gnu_cxx::div;
using __gnu_cxx::lldiv;
#endif
using __gnu_cxx::atoll;
using __gnu_cxx::strtof;
using __gnu_cxx::strtoll;
using __gnu_cxx::strtoull;
using __gnu_cxx::strtold;
}
#endif
#endif

cstdio
// -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
// 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: 27.8.2 C Library files
//
/** @file cstdio
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c stdio.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CSTDIO
#define _GLIBCXX_CSTDIO 1
#pragma GCC system_header
#include
#include
#include
// Get rid of those macros defined in in lieu of real functions.
#undef clearerr
#undef fclose
#undef feof
#undef ferror
#undef fflush
#undef fgetc
#undef fgetpos
#undef fgets
#undef fopen
#undef fprintf
#undef fputc
#undef fputs
#undef fread
#undef freopen
#undef fscanf
#undef fseek
#undef fsetpos
#undef ftell
#undef fwrite
#undef getc
#undef getchar
#undef gets
#undef perror
#undef printf
#undef putc
#undef putchar
#undef puts
#undef remove
#undef rename
#undef rewind
#undef scanf
#undef setbuf
#undef setvbuf
#undef sprintf
#undef sscanf
#undef tmpfile
#undef tmpnam
#undef ungetc
#undef vfprintf
#undef vprintf
#undef vsprintf
namespace std
{
using ::FILE;
using ::fpos_t;
using ::clearerr;
using ::fclose;
using ::feof;
using ::ferror;
using ::fflush;
using ::fgetc;
using ::fgetpos;
using ::fgets;
using ::fopen;
using ::fprintf;
using ::fputc;
using ::fputs;
using ::fread;
using ::freopen;
using ::fscanf;
using ::fseek;
using ::fsetpos;
using ::ftell;
using ::fwrite;
using ::getc;
using ::getchar;
using ::gets;
using ::perror;
using ::printf;
using ::putc;
using ::putchar;
using ::puts;
using ::remove;
using ::rename;
using ::rewind;
using ::scanf;
using ::setbuf;
using ::setvbuf;
using ::sprintf;
using ::sscanf;
using ::tmpfile;
using ::tmpnam;
using ::ungetc;
using ::vfprintf;
using ::vprintf;
using ::vsprintf;
}
#if _GLIBCXX_USE_C99
#undef snprintf
#undef vfscanf
#undef vscanf
#undef vsnprintf
#undef vsscanf
namespace __gnu_cxx
{
#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
extern “C” int
(snprintf)(char * restrict, size_t, const char * restrict, …);
extern “C” int
(vfscanf)(FILE * restrict, const char * restrict, __gnuc_va_list);
extern “C” int (vscanf)(const char * restrict, __gnuc_va_list);
extern “C” int
(vsnprintf)(char * restrict, size_t, const char * restrict, __gnuc_va_list);
extern “C” int
(vsscanf)(const char * restrict, const char * restrict, __gnuc_va_list);
#endif
#if !_GLIBCXX_USE_C99_DYNAMIC
using ::snprintf;
using ::vfscanf;
using ::vscanf;
using ::vsnprintf;
using ::vsscanf;
#endif
}
namespace std
{
using __gnu_cxx::snprintf;
using __gnu_cxx::vfscanf;
using __gnu_cxx::vscanf;
using __gnu_cxx::vsnprintf;
using __gnu_cxx::vsscanf;
}
#endif
#endif

cstddef
// -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000, 2002 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: 18.1 Types
//
/** @file cstddef
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c stddef.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CSTDDEF
#define _GLIBCXX_CSTDDEF 1
#pragma GCC system_header
#include
namespace std
{
using ::ptrdiff_t;
using ::size_t;
}
#endif

cstdarg
// -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000, 2002 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: 20.4.6 C library
//
/** @file cstdarg
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c stdarg.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CSTDARG
#define _GLIBCXX_CSTDARG 1
#pragma GCC system_header
#include
// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
#ifndef va_end
#define va_end(ap) va_end (ap)
#endif
namespace std
{
using ::va_list;
}
#endif

csignal
// -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
// 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: 20.4.6 C library
//
/** @file csignal
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c signal.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CSIGNAL
#define _GLIBCXX_CSIGNAL 1
#pragma GCC system_header
#include
// Get rid of those macros defined in in lieu of real functions.
#undef raise
namespace std
{
using ::sig_atomic_t;
using ::signal;
using ::raise;
}
#endif

csetjmp
// -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
// 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: 20.4.6 C library
//
/** @file csetjmp
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c setjmp.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CSETJMP
#define _GLIBCXX_CSETJMP 1
#pragma GCC system_header
#include
// Get rid of those macros defined in in lieu of real functions.
#undef longjmp
// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
#ifndef setjmp
#define setjmp(env) setjmp (env)
#endif
namespace std
{
using ::jmp_buf;
using ::longjmp;
}
#endif

complex
// The template and inlines for the -*- C++ -*- complex number classes.
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
// 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: 26.2 Complex Numbers
// Note: this is not a conforming implementation.
// Initially implemented by Ulrich Drepper
// Improved by Gabriel Dos Reis
//
/** @file complex
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_COMPLEX
#define _GLIBCXX_COMPLEX 1
#pragma GCC system_header
#include
#include
#include
#include
namespace std
{
// Forward declarations
template class complex;
template<> class complex;
template<> class complex;
template<> class complex;
/// Return magnitude of @a z.
template _Tp abs(const complex<_Tp>&);
/// Return phase angle of @a z.
template _Tp arg(const complex<_Tp>&);
/// Return @a z magnitude squared.
template _Tp norm(const complex<_Tp>&);
/// Return complex conjugate of @a z.
template complex<_Tp> conj(const complex<_Tp>&);
/// Return complex with magnitude @a rho and angle @a theta.
template complex<_Tp> polar(const _Tp&, const _Tp& = 0);
// Transcendentals:
/// Return complex cosine of @a z.
template complex<_Tp> cos(const complex<_Tp>&);
/// Return complex hyperbolic cosine of @a z.
template complex<_Tp> cosh(const complex<_Tp>&);
/// Return complex base e exponential of @a z.
template complex<_Tp> exp(const complex<_Tp>&);
/// Return complex natural logarithm of @a z.
template complex<_Tp> log(const complex<_Tp>&);
/// Return complex base 10 logarithm of @a z.
template complex<_Tp> log10(const complex<_Tp>&);
/// Return complex cosine of @a z.
template complex<_Tp> pow(const complex<_Tp>&, int);
/// Return @a x to the @a y’th power.
template complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
/// Return @a x to the @a y’th power.
template complex<_Tp> pow(const complex<_Tp>&,
const complex<_Tp>&);
/// Return @a x to the @a y’th power.
template complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
/// Return complex sine of @a z.
template complex<_Tp> sin(const complex<_Tp>&);
/// Return complex hyperbolic sine of @a z.
template complex<_Tp> sinh(const complex<_Tp>&);
/// Return complex square root of @a z.
template complex<_Tp> sqrt(const complex<_Tp>&);
/// Return complex tangent of @a z.
template complex<_Tp> tan(const complex<_Tp>&);
/// Return complex hyperbolic tangent of @a z.
template complex<_Tp> tanh(const complex<_Tp>&);
//@}

// 26.2.2 Primary template class complex
/**
* Template to represent complex numbers.
*
* Specializations for float, double, and long double are part of the
* library. Results with any other type are not guaranteed.
*
* @param Tp Type of real and imaginary values.
*/
template
class complex
{
public:
/// Value typedef.
typedef _Tp value_type;

/// Default constructor. First parameter is x, second parameter is y.
/// Unspecified parameters default to 0.
complex(const _Tp& = _Tp(), const _Tp & = _Tp());
// Lets the compiler synthesize the copy constructor
// complex (const complex<_Tp>&);
/// Copy constructor.
template
complex(const complex<_Up>&);
/// Return real part of complex number.
_Tp& real();
/// Return real part of complex number.
const _Tp& real() const;
/// Return imaginary part of complex number.
_Tp& imag();
/// Return imaginary part of complex number.
const _Tp& imag() const;
/// Assign this complex number to scalar @a t.
complex<_Tp>& operator=(const _Tp&);
/// Add @a t to this complex number.
complex<_Tp>& operator+=(const _Tp&);
/// Subtract @a t from this complex number.
complex<_Tp>& operator-=(const _Tp&);
/// Multiply this complex number by @a t.
complex<_Tp>& operator*=(const _Tp&);
/// Divide this complex number by @a t.
complex<_Tp>& operator/=(const _Tp&);
// Lets the compiler synthesize the
// copy and assignment operator
// complex<_Tp>& operator= (const complex<_Tp>&);
/// Assign this complex number to complex @a z.
template
complex<_Tp>& operator=(const complex<_Up>&);
/// Add @a z to this complex number.
template
complex<_Tp>& operator+=(const complex<_Up>&);
/// Subtract @a z from this complex number.
template
complex<_Tp>& operator-=(const complex<_Up>&);
/// Multiply this complex number by @a z.
template
complex<_Tp>& operator*=(const complex<_Up>&);
/// Divide this complex number by @a z.
template
complex<_Tp>& operator/=(const complex<_Up>&);
private:
_Tp _M_real;
_Tp _M_imag;
};
template
inline _Tp&
complex<_Tp>::real() { return _M_real; }
template
inline const _Tp&
complex<_Tp>::real() const { return _M_real; }
template
inline _Tp&
complex<_Tp>::imag() { return _M_imag; }
template
inline const _Tp&
complex<_Tp>::imag() const { return _M_imag; }
template
inline
complex<_Tp>::complex(const _Tp& __r, const _Tp& __i)
: _M_real(__r), _M_imag(__i) { }
template
template
inline
complex<_Tp>::complex(const complex<_Up>& __z)
: _M_real(__z.real()), _M_imag(__z.imag()) { }

template
complex<_Tp>&
complex<_Tp>::operator=(const _Tp& __t)
{
_M_real = __t;
_M_imag = _Tp();
return *this;
}
// 26.2.5/1
template
inline complex<_Tp>&
complex<_Tp>::operator+=(const _Tp& __t)
{
_M_real += __t;
return *this;
}
// 26.2.5/3
template
inline complex<_Tp>&
complex<_Tp>::operator-=(const _Tp& __t)
{
_M_real -= __t;
return *this;
}
// 26.2.5/5
template
complex<_Tp>&
complex<_Tp>::operator*=(const _Tp& __t)
{
_M_real *= __t;
_M_imag *= __t;
return *this;
}
// 26.2.5/7
template
complex<_Tp>&
complex<_Tp>::operator/=(const _Tp& __t)
{
_M_real /= __t;
_M_imag /= __t;
return *this;
}
template
template
complex<_Tp>&
complex<_Tp>::operator=(const complex<_Up>& __z)
{
_M_real = __z.real();
_M_imag = __z.imag();
return *this;
}
// 26.2.5/9
template
template
complex<_Tp>&
complex<_Tp>::operator+=(const complex<_Up>& __z)
{
_M_real += __z.real();
_M_imag += __z.imag();
return *this;
}
// 26.2.5/11
template
template
complex<_Tp>&
complex<_Tp>::operator-=(const complex<_Up>& __z)
{
_M_real -= __z.real();
_M_imag -= __z.imag();
return *this;
}
// 26.2.5/13
// XXX: This is a grammar school implementation.
template
template
complex<_Tp>&
complex<_Tp>::operator*=(const complex<_Up>& __z)
{
const _Tp __r = _M_real * __z.real() – _M_imag * __z.imag();
_M_imag = _M_real * __z.imag() + _M_imag * __z.real();
_M_real = __r;
return *this;
}
// 26.2.5/15
// XXX: This is a grammar school implementation.
template
template
complex<_Tp>&
complex<_Tp>::operator/=(const complex<_Up>& __z)
{
const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
const _Tp __n = std::norm(__z);
_M_imag = (_M_imag * __z.real() – _M_real * __z.imag()) / __n;
_M_real = __r / __n;
return *this;
}

// Operators:
//@{
/// Return new complex value @a x plus @a y.
template
inline complex<_Tp>
operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
{
complex<_Tp> __r = __x;
__r += __y;
return __r;
}
template
inline complex<_Tp>
operator+(const complex<_Tp>& __x, const _Tp& __y)
{
complex<_Tp> __r = __x;
__r.real() += __y;
return __r;
}
template
inline complex<_Tp>
operator+(const _Tp& __x, const complex<_Tp>& __y)
{
complex<_Tp> __r = __y;
__r.real() += __x;
return __r;
}
//@}
//@{
/// Return new complex value @a x minus @a y.
template
inline complex<_Tp>
operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
{
complex<_Tp> __r = __x;
__r -= __y;
return __r;
}

template
inline complex<_Tp>
operator-(const complex<_Tp>& __x, const _Tp& __y)
{
complex<_Tp> __r = __x;
__r.real() -= __y;
return __r;
}
template
inline complex<_Tp>
operator-(const _Tp& __x, const complex<_Tp>& __y)
{
complex<_Tp> __r(__x, -__y.imag());
__r.real() -= __y.real();
return __r;
}
//@}
//@{
/// Return new complex value @a x times @a y.
template
inline complex<_Tp>
operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
{
complex<_Tp> __r = __x;
__r *= __y;
return __r;
}
template
inline complex<_Tp>
operator*(const complex<_Tp>& __x, const _Tp& __y)
{
complex<_Tp> __r = __x;
__r *= __y;
return __r;
}
template
inline complex<_Tp>
operator*(const _Tp& __x, const complex<_Tp>& __y)
{
complex<_Tp> __r = __y;
__r *= __x;
return __r;
}
//@}
//@{
/// Return new complex value @a x divided by @a y.
template
inline complex<_Tp>
operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
{
complex<_Tp> __r = __x;
__r /= __y;
return __r;
}

template
inline complex<_Tp>
operator/(const complex<_Tp>& __x, const _Tp& __y)
{
complex<_Tp> __r = __x;
__r /= __y;
return __r;
}
template
inline complex<_Tp>
operator/(const _Tp& __x, const complex<_Tp>& __y)
{
complex<_Tp> __r = __x;
__r /= __y;
return __r;
}
//@}
/// Return @a x.
template
inline complex<_Tp>
operator+(const complex<_Tp>& __x)
{ return __x; }
/// Return complex negation of @a x.
template
inline complex<_Tp>
operator-(const complex<_Tp>& __x)
{ return complex<_Tp>(-__x.real(), -__x.imag()); }
//@{
/// Return true if @a x is equal to @a y.
template
inline bool
operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
{ return __x.real() == __y.real() && __x.imag() == __y.imag(); }
template
inline bool
operator==(const complex<_Tp>& __x, const _Tp& __y)
{ return __x.real() == __y && __x.imag() == _Tp(); }
template
inline bool
operator==(const _Tp& __x, const complex<_Tp>& __y)
{ return __x == __y.real() && _Tp() == __y.imag(); }
//@}
//@{
/// Return false if @a x is equal to @a y.
template
inline bool
operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
{ return __x.real() != __y.real() || __x.imag() != __y.imag(); }
template
inline bool
operator!=(const complex<_Tp>& __x, const _Tp& __y)
{ return __x.real() != __y || __x.imag() != _Tp(); }
template
inline bool
operator!=(const _Tp& __x, const complex<_Tp>& __y)
{ return __x != __y.real() || _Tp() != __y.imag(); }
//@}
/// Extraction operator for complex values.
template
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
{
_Tp __re_x, __im_x;
_CharT __ch;
__is >> __ch;
if (__ch == ‘(‘)
{
__is >> __re_x >> __ch;
if (__ch == ‘,’)
{
__is >> __im_x >> __ch;
if (__ch == ‘)’)
__x = complex<_Tp>(__re_x, __im_x);
else
__is.setstate(ios_base::failbit);
}
else if (__ch == ‘)’)
__x = __re_x;
else
__is.setstate(ios_base::failbit);
}
else
{
__is.putback(__ch);
__is >> __re_x;
__x = __re_x;
}
return __is;
}
/// Insertion operator for complex values.
template
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
{
basic_ostringstream<_CharT, _Traits> __s;
__s.flags(__os.flags());
__s.imbue(__os.getloc());
__s.precision(__os.precision());
__s << '(' << __x.real() << ',' << __x.imag() << ')'; return __os << __s.str(); } // Values template
inline _Tp&
real(complex<_Tp>& __z)
{ return __z.real(); }

template
inline const _Tp&
real(const complex<_Tp>& __z)
{ return __z.real(); }

template
inline _Tp&
imag(complex<_Tp>& __z)
{ return __z.imag(); }

template
inline const _Tp&
imag(const complex<_Tp>& __z)
{ return __z.imag(); }
template
inline _Tp
abs(const complex<_Tp>& __z)
{
_Tp __x = __z.real();
_Tp __y = __z.imag();
const _Tp __s = std::max(abs(__x), abs(__y));
if (__s == _Tp()) // well …
return __s;
__x /= __s;
__y /= __s;
return __s * sqrt(__x * __x + __y * __y);
}
template
inline _Tp
arg(const complex<_Tp>& __z)
{ return atan2(__z.imag(), __z.real()); }
// 26.2.7/5: norm(__z) returns the squared magintude of __z.
// As defined, norm() is -not- a norm is the common mathematical
// sens used in numerics. The helper class _Norm_helper<> tries to
// distinguish between builtin floating point and the rest, so as
// to deliver an answer as close as possible to the real value.
template
struct _Norm_helper
{
template
static inline _Tp _S_do_it(const complex<_Tp>& __z)
{
const _Tp __x = __z.real();
const _Tp __y = __z.imag();
return __x * __x + __y * __y;
}
};
template<>
struct _Norm_helper {
template
static inline _Tp _S_do_it(const complex<_Tp>& __z)
{
_Tp __res = std::abs(__z);
return __res * __res;
}
};

template
inline _Tp
norm(const complex<_Tp>& __z)
{
return _Norm_helper<__is_floating<_Tp>::_M_type && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
}
template
inline complex<_Tp>
polar(const _Tp& __rho, const _Tp& __theta)
{ return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
template
inline complex<_Tp>
conj(const complex<_Tp>& __z)
{ return complex<_Tp>(__z.real(), -__z.imag()); }

// Transcendentals
template
inline complex<_Tp>
cos(const complex<_Tp>& __z)
{
const _Tp __x = __z.real();
const _Tp __y = __z.imag();
return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
}
template
inline complex<_Tp>
cosh(const complex<_Tp>& __z)
{
const _Tp __x = __z.real();
const _Tp __y = __z.imag();
return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
}
template
inline complex<_Tp>
exp(const complex<_Tp>& __z)
{ return std::polar(exp(__z.real()), __z.imag()); }
template
inline complex<_Tp>
log(const complex<_Tp>& __z)
{ return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
template
inline complex<_Tp>
log10(const complex<_Tp>& __z)
{ return std::log(__z) / log(_Tp(10.0)); }
template
inline complex<_Tp>
sin(const complex<_Tp>& __z)
{
const _Tp __x = __z.real();
const _Tp __y = __z.imag();
return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
}
template
inline complex<_Tp>
sinh(const complex<_Tp>& __z)
{
const _Tp __x = __z.real();
const _Tp __y = __z.imag();
return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
}
template
complex<_Tp>
sqrt(const complex<_Tp>& __z)
{
_Tp __x = __z.real();
_Tp __y = __z.imag();
if (__x == _Tp())
{
_Tp __t = sqrt(abs(__y) / 2);
return complex<_Tp>(__t, __y < _Tp() ? -__t : __t); } else { _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x))); _Tp __u = __t / 2; return __x > _Tp()
? complex<_Tp>(__u, __y / __t)
: complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u); } } template
inline complex<_Tp>
tan(const complex<_Tp>& __z)
{
return std::sin(__z) / std::cos(__z);
}
template
inline complex<_Tp>
tanh(const complex<_Tp>& __z)
{
return std::sinh(__z) / std::cosh(__z);
}
template
inline complex<_Tp>
pow(const complex<_Tp>& __z, int __n)
{
return std::__pow_helper(__z, __n);
}
template
complex<_Tp>
pow(const complex<_Tp>& __x, const _Tp& __y)
{
if (__x.imag() == _Tp() && __x.real() > _Tp())
return pow(__x.real(), __y);
complex<_Tp> __t = std::log(__x);
return std::polar(exp(__y * __t.real()), __y * __t.imag());
}
template
inline complex<_Tp>
pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
{
return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x));
}
template
inline complex<_Tp>
pow(const _Tp& __x, const complex<_Tp>& __y)
{
return __x > _Tp() ? std::polar(pow(__x, __y.real()),
__y.imag() * log(__x))
: std::pow(complex<_Tp>(__x, _Tp()), __y);
}
// 26.2.3 complex specializations
// complex specialization
template<> class complex
{
public:
typedef float value_type;

complex(float = 0.0f, float = 0.0f);
#ifdef _GLIBCXX_BUGGY_COMPLEX
complex(const complex& __z) : _M_value(__z._M_value) { }
#endif
explicit complex(const complex&);
explicit complex(const complex&);
float& real();
const float& real() const;
float& imag();
const float& imag() const;
complex& operator=(float);
complex& operator+=(float);
complex& operator-=(float);
complex& operator*=(float);
complex& operator/=(float);

// Let’s the compiler synthetize the copy and assignment
// operator. It always does a pretty good job.
// complex& operator= (const complex&);
template
complex&operator=(const complex<_Tp>&);
template
complex& operator+=(const complex<_Tp>&);
template
complex& operator-=(const complex<_Tp>&);
template
complex& operator*=(const complex<_Tp>&);
template
complex&operator/=(const complex<_Tp>&);
private:
typedef __complex__ float _ComplexT;
_ComplexT _M_value;
complex(_ComplexT __z) : _M_value(__z) { }

friend class complex;
friend class complex;
};
inline float&
complex::real()
{ return __real__ _M_value; }
inline const float&
complex::real() const
{ return __real__ _M_value; }
inline float&
complex::imag()
{ return __imag__ _M_value; }
inline const float&
complex::imag() const
{ return __imag__ _M_value; }
inline
complex::complex(float r, float i)
{
__real__ _M_value = r;
__imag__ _M_value = i;
}
inline complex&
complex::operator=(float __f)
{
__real__ _M_value = __f;
__imag__ _M_value = 0.0f;
return *this;
}
inline complex&
complex::operator+=(float __f)
{
__real__ _M_value += __f;
return *this;
}
inline complex&
complex::operator-=(float __f)
{
__real__ _M_value -= __f;
return *this;
}
inline complex&
complex::operator*=(float __f)
{
_M_value *= __f;
return *this;
}
inline complex&
complex::operator/=(float __f)
{
_M_value /= __f;
return *this;
}
template
inline complex&
complex::operator=(const complex<_Tp>& __z)
{
__real__ _M_value = __z.real();
__imag__ _M_value = __z.imag();
return *this;
}
template
inline complex&
complex::operator+=(const complex<_Tp>& __z)
{
__real__ _M_value += __z.real();
__imag__ _M_value += __z.imag();
return *this;
}

template
inline complex&
complex::operator-=(const complex<_Tp>& __z)
{
__real__ _M_value -= __z.real();
__imag__ _M_value -= __z.imag();
return *this;
}
template
inline complex&
complex::operator*=(const complex<_Tp>& __z)
{
_ComplexT __t;
__real__ __t = __z.real();
__imag__ __t = __z.imag();
_M_value *= __t;
return *this;
}
template
inline complex&
complex::operator/=(const complex<_Tp>& __z)
{
_ComplexT __t;
__real__ __t = __z.real();
__imag__ __t = __z.imag();
_M_value /= __t;
return *this;
}
// 26.2.3 complex specializations
// complex specialization
template<> class complex
{
public:
typedef double value_type;
complex(double =0.0, double =0.0);
#ifdef _GLIBCXX_BUGGY_COMPLEX
complex(const complex& __z) : _M_value(__z._M_value) { }
#endif
complex(const complex&);
explicit complex(const complex&);
double& real();
const double& real() const;
double& imag();
const double& imag() const;

complex& operator=(double);
complex& operator+=(double);
complex& operator-=(double);
complex& operator*=(double);
complex& operator/=(double);
// The compiler will synthetize this, efficiently.
// complex& operator= (const complex&);
template
complex& operator=(const complex<_Tp>&);
template
complex& operator+=(const complex<_Tp>&);
template
complex& operator-=(const complex<_Tp>&);
template
complex& operator*=(const complex<_Tp>&);
template
complex& operator/=(const complex<_Tp>&);
private:
typedef __complex__ double _ComplexT;
_ComplexT _M_value;
complex(_ComplexT __z) : _M_value(__z) { }

friend class complex;
friend class complex;
};
inline double&
complex::real()
{ return __real__ _M_value; }
inline const double&
complex::real() const
{ return __real__ _M_value; }
inline double&
complex::imag()
{ return __imag__ _M_value; }
inline const double&
complex::imag() const
{ return __imag__ _M_value; }
inline
complex::complex(double __r, double __i)
{
__real__ _M_value = __r;
__imag__ _M_value = __i;
}
inline complex&
complex::operator=(double __d)
{
__real__ _M_value = __d;
__imag__ _M_value = 0.0;
return *this;
}
inline complex&
complex::operator+=(double __d)
{
__real__ _M_value += __d;
return *this;
}
inline complex&
complex::operator-=(double __d)
{
__real__ _M_value -= __d;
return *this;
}
inline complex&
complex::operator*=(double __d)
{
_M_value *= __d;
return *this;
}
inline complex&
complex::operator/=(double __d)
{
_M_value /= __d;
return *this;
}
template
inline complex&
complex::operator=(const complex<_Tp>& __z)
{
__real__ _M_value = __z.real();
__imag__ _M_value = __z.imag();
return *this;
}

template
inline complex&
complex::operator+=(const complex<_Tp>& __z)
{
__real__ _M_value += __z.real();
__imag__ _M_value += __z.imag();
return *this;
}
template
inline complex&
complex::operator-=(const complex<_Tp>& __z)
{
__real__ _M_value -= __z.real();
__imag__ _M_value -= __z.imag();
return *this;
}
template
inline complex&
complex::operator*=(const complex<_Tp>& __z)
{
_ComplexT __t;
__real__ __t = __z.real();
__imag__ __t = __z.imag();
_M_value *= __t;
return *this;
}
template
inline complex&
complex::operator/=(const complex<_Tp>& __z)
{
_ComplexT __t;
__real__ __t = __z.real();
__imag__ __t = __z.imag();
_M_value /= __t;
return *this;
}
// 26.2.3 complex specializations
// complex specialization
template<> class complex
{
public:
typedef long double value_type;
complex(long double = 0.0L, long double = 0.0L);
#ifdef _GLIBCXX_BUGGY_COMPLEX
complex(const complex& __z) : _M_value(__z._M_value) { }
#endif
complex(const complex&);
complex(const complex&);
long double& real();
const long double& real() const;
long double& imag();
const long double& imag() const;
complex& operator= (long double);
complex& operator+= (long double);
complex& operator-= (long double);
complex& operator*= (long double);
complex& operator/= (long double);
// The compiler knows how to do this efficiently
// complex& operator= (const complex&);
template
complex& operator=(const complex<_Tp>&);
template
complex& operator+=(const complex<_Tp>&);
template
complex& operator-=(const complex<_Tp>&);
template
complex& operator*=(const complex<_Tp>&);
template
complex& operator/=(const complex<_Tp>&);
private:
typedef __complex__ long double _ComplexT;
_ComplexT _M_value;
complex(_ComplexT __z) : _M_value(__z) { }
friend class complex;
friend class complex;
};
inline
complex::complex(long double __r, long double __i)
{
__real__ _M_value = __r;
__imag__ _M_value = __i;
}
inline long double&
complex::real()
{ return __real__ _M_value; }
inline const long double&
complex::real() const
{ return __real__ _M_value; }
inline long double&
complex::imag()
{ return __imag__ _M_value; }
inline const long double&
complex::imag() const
{ return __imag__ _M_value; }
inline complex&
complex::operator=(long double __r)
{
__real__ _M_value = __r;
__imag__ _M_value = 0.0L;
return *this;
}
inline complex&
complex::operator+=(long double __r)
{
__real__ _M_value += __r;
return *this;
}
inline complex&
complex::operator-=(long double __r)
{
__real__ _M_value -= __r;
return *this;
}
inline complex&
complex::operator*=(long double __r)
{
_M_value *= __r;
return *this;
}
inline complex&
complex::operator/=(long double __r)
{
_M_value /= __r;
return *this;
}
template
inline complex&
complex::operator=(const complex<_Tp>& __z)
{
__real__ _M_value = __z.real();
__imag__ _M_value = __z.imag();
return *this;
}
template
inline complex&
complex::operator+=(const complex<_Tp>& __z)
{
__real__ _M_value += __z.real();
__imag__ _M_value += __z.imag();
return *this;
}
template
inline complex&
complex::operator-=(const complex<_Tp>& __z)
{
__real__ _M_value -= __z.real();
__imag__ _M_value -= __z.imag();
return *this;
}

template
inline complex&
complex::operator*=(const complex<_Tp>& __z)
{
_ComplexT __t;
__real__ __t = __z.real();
__imag__ __t = __z.imag();
_M_value *= __t;
return *this;
}
template
inline complex&
complex::operator/=(const complex<_Tp>& __z)
{
_ComplexT __t;
__real__ __t = __z.real();
__imag__ __t = __z.imag();
_M_value /= __t;
return *this;
}
// These bits have to be at the end of this file, so that the
// specializations have all been defined.
// ??? No, they have to be there because of compiler limitation at
// inlining. It suffices that class specializations be defined.
inline
complex::complex(const complex& __z)
: _M_value(_ComplexT(__z._M_value)) { }
inline
complex::complex(const complex& __z)
: _M_value(_ComplexT(__z._M_value)) { }
inline
complex::complex(const complex& __z)
: _M_value(_ComplexT(__z._M_value)) { }
inline
complex::complex(const complex& __z)
{
__real__ _M_value = __z.real();
__imag__ _M_value = __z.imag();
}
inline
complex::complex(const complex& __z)
: _M_value(_ComplexT(__z._M_value)) { }
inline
complex::complex(const complex& __z)
: _M_value(_ComplexT(__z._M_value)) { }
} // namespace std
#endif /* _GLIBCXX_COMPLEX */

cmath
// -*- C++ -*- C forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
// 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: 26.5 C library
//
/** @file cmath
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c math.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CMATH
#define _GLIBCXX_CMATH 1
#pragma GCC system_header
#include
#include
#include
// Get rid of those macros defined in in lieu of real functions.
#undef abs
#undef div
#undef acos
#undef asin
#undef atan
#undef atan2
#undef ceil
#undef cos
#undef cosh
#undef exp
#undef fabs
#undef floor
#undef fmod
#undef frexp
#undef ldexp
#undef log
#undef log10
#undef modf
#undef pow
#undef sin
#undef sinh
#undef sqrt
#undef tan
#undef tanh

namespace std
{
// Forward declaration of a helper function. This really should be
// an `exported’ forward declaration.
template _Tp __cmath_power(_Tp, unsigned int);
inline double
abs(double __x)
{ return __builtin_fabs(__x); }
inline float
abs(float __x)
{ return __builtin_fabsf(__x); }
inline long double
abs(long double __x)
{ return __builtin_fabsl(__x); }
using ::acos;
inline float
acos(float __x)
{ return __builtin_acosf(__x); }
inline long double
acos(long double __x)
{ return __builtin_acosl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
acos(_Tp __x)
{
return __builtin_acos(__x);
}
using ::asin;
inline float
asin(float __x)
{ return __builtin_asinf(__x); }
inline long double
asin(long double __x)
{ return __builtin_asinl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
asin(_Tp __x)
{ return __builtin_asin(__x); }
using ::atan;
inline float
atan(float __x)
{ return __builtin_atanf(__x); }
inline long double
atan(long double __x)
{ return __builtin_atanl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
atan(_Tp __x)
{ return __builtin_atan(__x); }
using ::atan2;
inline float
atan2(float __y, float __x)
{ return __builtin_atan2f(__y, __x); }
inline long double
atan2(long double __y, long double __x)
{ return __builtin_atan2l(__y, __x); }
template
inline typename __enable_if::_M_type
&& __is_integer<_Up>::_M_type>::_M_type
atan2(_Tp __y, _Up __x)
{ return __builtin_atan2(__y, __x); }
using ::ceil;
inline float
ceil(float __x)
{ return __builtin_ceilf(__x); }
inline long double
ceil(long double __x)
{ return __builtin_ceill(__x); }
template
inline typename __enable_if::_M_type>::_M_type
ceil(_Tp __x)
{ return __builtin_ceil(__x); }
using ::cos;
inline float
cos(float __x)
{ return __builtin_cosf(__x); }
inline long double
cos(long double __x)
{ return __builtin_cosl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
cos(_Tp __x)
{ return __builtin_cos(__x); }
using ::cosh;
inline float
cosh(float __x)
{ return __builtin_coshf(__x); }
inline long double
cosh(long double __x)
{ return __builtin_coshl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
cosh(_Tp __x)
{ return __builtin_cosh(__x); }
using ::exp;
inline float
exp(float __x)
{ return __builtin_expf(__x); }
inline long double
exp(long double __x)
{ return __builtin_expl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
exp(_Tp __x)
{ return __builtin_exp(__x); }
using ::fabs;
inline float
fabs(float __x)
{ return __builtin_fabsf(__x); }
inline long double
fabs(long double __x)
{ return __builtin_fabsl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
fabs(_Tp __x)
{ return __builtin_fabs(__x); }
using ::floor;
inline float
floor(float __x)
{ return __builtin_floorf(__x); }
inline long double
floor(long double __x)
{ return __builtin_floorl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
floor(_Tp __x)
{ return __builtin_floor(__x); }
using ::fmod;
inline float
fmod(float __x, float __y)
{ return __builtin_fmodf(__x, __y); }
inline long double
fmod(long double __x, long double __y)
{ return __builtin_fmodl(__x, __y); }
using ::frexp;
inline float
frexp(float __x, int* __exp)
{ return __builtin_frexpf(__x, __exp); }
inline long double
frexp(long double __x, int* __exp)
{ return __builtin_frexpl(__x, __exp); }
template
inline typename __enable_if::_M_type>::_M_type
frexp(_Tp __x, int* __exp)
{ return __builtin_frexp(__x, __exp); }
using ::ldexp;
inline float
ldexp(float __x, int __exp)
{ return __builtin_ldexpf(__x, __exp); }
inline long double
ldexp(long double __x, int __exp)
{ return __builtin_ldexpl(__x, __exp); }
template
inline typename __enable_if::_M_type>::_M_type
ldexp(_Tp __x, int __exp)
{ return __builtin_ldexp(__x, __exp); }
using ::log;
inline float
log(float __x)
{ return __builtin_logf(__x); }
inline long double
log(long double __x)
{ return __builtin_logl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
log(_Tp __x)
{ return __builtin_log(__x); }
using ::log10;
inline float
log10(float __x)
{ return __builtin_log10f(__x); }
inline long double
log10(long double __x)
{ return __builtin_log10l(__x); }
template
inline typename __enable_if::_M_type>::_M_type
log10(_Tp __x)
{ return __builtin_log10(__x); }
using ::modf;
inline float
modf(float __x, float* __iptr)
{ return __builtin_modff(__x, __iptr); }
inline long double
modf(long double __x, long double* __iptr)
{ return __builtin_modfl(__x, __iptr); }
template
inline _Tp
__pow_helper(_Tp __x, int __n)
{
return __n < 0 ? _Tp(1)/__cmath_power(__x, -__n) : __cmath_power(__x, __n); } using ::pow; inline float pow(float __x, float __y) { return __builtin_powf(__x, __y); } inline long double pow(long double __x, long double __y) { return __builtin_powl(__x, __y); } inline double pow(double __x, int __i) { return __pow_helper(__x, __i); } inline float pow(float __x, int __n) { return __pow_helper(__x, __n); } inline long double pow(long double __x, int __n) { return __pow_helper(__x, __n); } using ::sin; inline float sin(float __x) { return __builtin_sinf(__x); } inline long double sin(long double __x) { return __builtin_sinl(__x); } template
inline typename __enable_if::_M_type>::_M_type
sin(_Tp __x)
{ return __builtin_sin(__x); }
using ::sinh;
inline float
sinh(float __x)
{ return __builtin_sinhf(__x); }
inline long double
sinh(long double __x)
{ return __builtin_sinhl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
sinh(_Tp __x)
{ return __builtin_sinh(__x); }
using ::sqrt;
inline float
sqrt(float __x)
{ return __builtin_sqrtf(__x); }
inline long double
sqrt(long double __x)
{ return __builtin_sqrtl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
sqrt(_Tp __x)
{ return __builtin_sqrt(__x); }
using ::tan;
inline float
tan(float __x)
{ return __builtin_tanf(__x); }
inline long double
tan(long double __x)
{ return __builtin_tanl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
tan(_Tp __x)
{ return __builtin_tan(__x); }
using ::tanh;
inline float
tanh(float __x)
{ return __builtin_tanhf(__x); }
inline long double
tanh(long double __x)
{ return __builtin_tanhl(__x); }
template
inline typename __enable_if::_M_type>::_M_type
tanh(_Tp __x)
{ return __builtin_tanh(__x); }
}
#if _GLIBCXX_USE_C99_MATH
#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
// These are possible macros imported from C99-land. For strict
// conformance, remove possible C99-injected names from the global
// namespace, and sequester them in the __gnu_cxx extension namespace.
namespace __gnu_cxx
{
template
int
__capture_fpclassify(_Tp __f) { return fpclassify(__f); }
template
int
__capture_isfinite(_Tp __f) { return isfinite(__f); }
template
int
__capture_isinf(_Tp __f) { return isinf(__f); }
template
int
__capture_isnan(_Tp __f) { return isnan(__f); }
template
int
__capture_isnormal(_Tp __f) { return isnormal(__f); }
template
int
__capture_signbit(_Tp __f) { return signbit(__f); }
template
int
__capture_isgreater(_Tp __f1, _Tp __f2)
{ return isgreater(__f1, __f2); }
template
int
__capture_isgreaterequal(_Tp __f1, _Tp __f2)
{ return isgreaterequal(__f1, __f2); }
template
int
__capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
template
int
__capture_islessequal(_Tp __f1, _Tp __f2)
{ return islessequal(__f1, __f2); }
template
int
__capture_islessgreater(_Tp __f1, _Tp __f2)
{ return islessgreater(__f1, __f2); }
template
int
__capture_isunordered(_Tp __f1, _Tp __f2)
{ return isunordered(__f1, __f2); }
}
// Only undefine the C99 FP macros, if actually captured for namespace movement
#undef fpclassify
#undef isfinite
#undef isinf
#undef isnan
#undef isnormal
#undef signbit
#undef isgreater
#undef isgreaterequal
#undef isless
#undef islessequal
#undef islessgreater
#undef isunordered
#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
#endif
#if _GLIBCXX_USE_C99_MATH
#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
namespace __gnu_cxx
{
template
int
fpclassify(_Tp __f) { return __capture_fpclassify(__f); }
template
int
isfinite(_Tp __f) { return __capture_isfinite(__f); }
template
int
isinf(_Tp __f) { return __capture_isinf(__f); }
template
int
isnan(_Tp __f) { return __capture_isnan(__f); }
template
int
isnormal(_Tp __f) { return __capture_isnormal(__f); }
template
int
signbit(_Tp __f) { return __capture_signbit(__f); }
template
int
isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }
template
int
isgreaterequal(_Tp __f1, _Tp __f2)
{ return __capture_isgreaterequal(__f1, __f2); }
template
int
isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }
template
int
islessequal(_Tp __f1, _Tp __f2)
{ return __capture_islessequal(__f1, __f2); }
template
int
islessgreater(_Tp __f1, _Tp __f2)
{ return __capture_islessgreater(__f1, __f2); }
template
int
isunordered(_Tp __f1, _Tp __f2)
{ return __capture_isunordered(__f1, __f2); }
}
namespace std
{
using __gnu_cxx::fpclassify;
using __gnu_cxx::isfinite;
using __gnu_cxx::isinf;
using __gnu_cxx::isnan;
using __gnu_cxx::isnormal;
using __gnu_cxx::signbit;
using __gnu_cxx::isgreater;
using __gnu_cxx::isgreaterequal;
using __gnu_cxx::isless;
using __gnu_cxx::islessequal;
using __gnu_cxx::islessgreater;
using __gnu_cxx::isunordered;
}
#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
#endif
#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include
#endif
#endif

clocale
// -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
// 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: 18.2.2 Implementation properties: C library
//
/** @file clocale
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c locale.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CLOCALE
#define _GLIBCXX_CLOCALE 1
#pragma GCC system_header
#include
// Get rid of those macros defined in in lieu of real functions.
#undef setlocale
#undef localeconv
namespace std
{
using ::lconv;
using ::setlocale;
using ::localeconv;
}
#endif

climits
// -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000, 2002
// 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: 18.2.2 Implementation properties: C library
//
/** @file climits
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c limits.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CLIMITS
#define _GLIBCXX_CLIMITS 1
#pragma GCC system_header
#include #endif

ciso646
// -*- C++ -*- forwarding header.
// Copyright (C) 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.
/** @file ciso646
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c iso646.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/

cfloat
// -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000, 2002 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: 18.2.2 Implementation properties: C library
//
/** @file cfloat
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c float.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CFLOAT
#define _GLIBCXX_CFLOAT 1
#pragma GCC system_header
#include
#endif

cerrno
// The -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2001, 2002 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: 19.3 Error numbers
//
/** @file cerrno
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c errno.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CERRNO
#define _GLIBCXX_CERRNO 1
#pragma GCC system_header
#include
// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998
#ifndef errno
#define errno errno
#endif
#endif

cctype
// -*- C++ -*- forwarding header.
// 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:
//
/** @file cctype
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c ctype.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
#ifndef _GLIBCXX_CCTYPE
#define _GLIBCXX_CCTYPE 1
#pragma GCC system_header
#include
#include
// Get rid of those macros defined in in lieu of real functions.
#undef isalnum
#undef isalpha
#undef iscntrl
#undef isdigit
#undef isgraph
#undef islower
#undef isprint
#undef ispunct
#undef isspace
#undef isupper
#undef isxdigit
#undef tolower
#undef toupper
namespace std
{
using ::isalnum;
using ::isalpha;
using ::iscntrl;
using ::isdigit;
using ::isgraph;
using ::islower;
using ::isprint;
using ::ispunct;
using ::isspace;
using ::isupper;
using ::isxdigit;
using ::tolower;
using ::toupper;
}
#endif

cassert
// -*- C++ -*- forwarding header.
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
// 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: 19.2 Assertions
//
/** @file cassert
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the “*.h” implementation files.
*
* This is the C++ version of the Standard C Library header @c assert.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
*/
// No include guards on this header…
#pragma GCC system_header
#include

algorithm
// -*- C++ -*-
// Copyright (C) 2001, 2002 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.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* 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. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided “as is” without express or implied warranty.
*
*
* 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.
*/
/** @file algorithm
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_ALGORITHM
#define _GLIBCXX_ALGORITHM 1
#pragma GCC system_header
#include
#include
#include
#include
#endif /* _GLIBCXX_ALGORITHM */

locale
// Locale support -*- C++ -*-
// Copyright (C) 1997, 1998, 1999, 2002, 2003 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: 22.1 Locales
//
/** @file locale
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_LOCALE
#define _GLIBCXX_LOCALE 1
#pragma GCC system_header
#include
#include
#include
#include
#endif /* _GLIBCXX_LOCALE */

set
// -*- C++ -*-
// Copyright (C) 2001, 2002 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.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* 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. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided “as is” without express or implied warranty.
*
*
* 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.
*/
/** @file set
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_SET
#define _GLIBCXX_SET 1
#pragma GCC system_header
#include
#include
#include
#ifdef _GLIBCXX_DEBUG
# include
#endif
#endif /* _GLIBCXX_SET */

utility
// -*- C++ -*-
// Copyright (C) 2001, 2002 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.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* 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. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided “as is” without express or implied warranty.
*
*
* 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.
*/
/** @file utility
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_UTILITY
#define _GLIBCXX_UTILITY 1
#pragma GCC system_header
#include
#include
#include
#endif /* _GLIBCXX_UTILITY */

bitset
// -*- C++ -*-
// Copyright (C) 2001, 2002, 2003, 2004 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.
/*
* Copyright (c) 1998
* 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.
*/
/** @file bitset
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_BITSET
#define _GLIBCXX_BITSET 1
#pragma GCC system_header
#include // For size_t
#include // For memset
#include // For numeric_limits
#include
#include // For invalid_argument, out_of_range,
// overflow_error
#include // For ostream (operator<<) #include // For istream (operator>>)
#define _GLIBCXX_BITSET_BITS_PER_WORD numeric_limits::digits
#define _GLIBCXX_BITSET_WORDS(__n) \
((__n) < 1 ? 0 : ((__n) + _GLIBCXX_BITSET_BITS_PER_WORD - 1)/_GLIBCXX_BITSET_BITS_PER_WORD) namespace _GLIBCXX_STD { /** * @if maint * Base class, general case. It is a class inveriant that _Nw will be * nonnegative. * * See documentation for bitset. * @endif */ template
struct _Base_bitset
{
typedef unsigned long _WordT;
/// 0 is the least significant word.
_WordT _M_w[_Nw];
_Base_bitset() { _M_do_reset(); }
_Base_bitset(unsigned long __val)
{
_M_do_reset();
_M_w[0] = __val;
}
static size_t
_S_whichword(size_t __pos )
{ return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }
static size_t
_S_whichbyte(size_t __pos )
{ return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }
static size_t
_S_whichbit(size_t __pos )
{ return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }
static _WordT
_S_maskbit(size_t __pos )
{ return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } _WordT& _M_getword(size_t __pos) { return _M_w[_S_whichword(__pos)]; } _WordT _M_getword(size_t __pos) const { return _M_w[_S_whichword(__pos)]; } _WordT& _M_hiword() { return _M_w[_Nw - 1]; } _WordT _M_hiword() const { return _M_w[_Nw - 1]; } void _M_do_and(const _Base_bitset<_Nw>& __x)
{
for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] &= __x._M_w[__i]; } void _M_do_or(const _Base_bitset<_Nw>& __x)
{
for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] |= __x._M_w[__i]; } void _M_do_xor(const _Base_bitset<_Nw>& __x)
{
for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] ^= __x._M_w[__i]; } void _M_do_left_shift(size_t __shift); void _M_do_right_shift(size_t __shift); void _M_do_flip() { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] = ~_M_w[__i]; } void _M_do_set() { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] = ~static_cast<_WordT>(0);
}
void
_M_do_reset() { memset(_M_w, 0, _Nw * sizeof(_WordT)); }
bool
_M_is_equal(const _Base_bitset<_Nw>& __x) const
{
for (size_t __i = 0; __i < _Nw; ++__i) { if (_M_w[__i] != __x._M_w[__i]) return false; } return true; } bool _M_is_any() const { for (size_t __i = 0; __i < _Nw; __i++) { if (_M_w[__i] != static_cast<_WordT>(0))
return true;
}
return false;
}
size_t
_M_do_count() const
{
size_t __result = 0;
for (size_t __i = 0; __i < _Nw; __i++) __result += __builtin_popcountl(_M_w[__i]); return __result; } unsigned long _M_do_to_ulong() const; // find first "on" bit size_t _M_do_find_first(size_t __not_found) const; // find the next "on" bit that follows "prev" size_t _M_do_find_next(size_t __prev, size_t __not_found) const; }; // Definitions of non-inline functions from _Base_bitset. template
void
_Base_bitset<_Nw>::_M_do_left_shift(size_t __shift)
{
if (__builtin_expect(__shift != 0, 1))
{
const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD;
const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD;
if (__offset == 0)
for (size_t __n = _Nw – 1; __n >= __wshift; –__n)
_M_w[__n] = _M_w[__n – __wshift];
else
{
const size_t __sub_offset = _GLIBCXX_BITSET_BITS_PER_WORD – __offset;
for (size_t __n = _Nw – 1; __n > __wshift; –__n)
_M_w[__n] = (_M_w[__n – __wshift] << __offset) | (_M_w[__n - __wshift - 1] >> __sub_offset);
_M_w[__wshift] = _M_w[0] << __offset; } std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
}
}
template
void
_Base_bitset<_Nw>::_M_do_right_shift(size_t __shift)
{
if (__builtin_expect(__shift != 0, 1))
{
const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD;
const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD;
const size_t __limit = _Nw – __wshift – 1;
if (__offset == 0)
for (size_t __n = 0; __n <= __limit; ++__n) _M_w[__n] = _M_w[__n + __wshift]; else { const size_t __sub_offset = _GLIBCXX_BITSET_BITS_PER_WORD - __offset; for (size_t __n = 0; __n < __limit; ++__n) _M_w[__n] = (_M_w[__n + __wshift] >> __offset) |
(_M_w[__n + __wshift + 1] << __sub_offset); _M_w[__limit] = _M_w[_Nw-1] >> __offset;
}

std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
}
}
template
unsigned long
_Base_bitset<_Nw>::_M_do_to_ulong() const
{
for (size_t __i = 1; __i < _Nw; ++__i) if (_M_w[__i]) __throw_overflow_error(__N("_Base_bitset::_M_do_to_ulong")); return _M_w[0]; } template
size_t
_Base_bitset<_Nw>::_M_do_find_first(size_t __not_found) const
{
for (size_t __i = 0; __i < _Nw; __i++) { _WordT __thisword = _M_w[__i]; if (__thisword != static_cast<_WordT>(0))
return __i * _GLIBCXX_BITSET_BITS_PER_WORD
+ __builtin_ctzl(__thisword);
}
// not found, so return an indication of failure.
return __not_found;
}
template
size_t
_Base_bitset<_Nw>::_M_do_find_next(size_t __prev, size_t __not_found) const
{
// make bound inclusive
++__prev;
// check out of bounds
if (__prev >= _Nw * _GLIBCXX_BITSET_BITS_PER_WORD)
return __not_found;
// search first word
size_t __i = _S_whichword(__prev);
_WordT __thisword = _M_w[__i];
// mask off bits below bound
__thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev); if (__thisword != static_cast<_WordT>(0))
return __i * _GLIBCXX_BITSET_BITS_PER_WORD
+ __builtin_ctzl(__thisword);
// check subsequent words
__i++;
for ( ; __i < _Nw; __i++ ) { __thisword = _M_w[__i]; if (__thisword != static_cast<_WordT>(0))
return __i * _GLIBCXX_BITSET_BITS_PER_WORD
+ __builtin_ctzl(__thisword);
}
// not found, so return an indication of failure.
return __not_found;
} // end _M_do_find_next

/**
* @if maint
* Base class, specialization for a single word.
*
* See documentation for bitset.
* @endif
*/
template<>
struct _Base_bitset<1>
{
typedef unsigned long _WordT;
_WordT _M_w;
_Base_bitset( void ) : _M_w(0) {}
_Base_bitset(unsigned long __val) : _M_w(__val) {}
static size_t
_S_whichword(size_t __pos )
{ return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }
static size_t
_S_whichbyte(size_t __pos )
{ return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }
static size_t
_S_whichbit(size_t __pos )
{ return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }
static _WordT
_S_maskbit(size_t __pos )
{ return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } _WordT& _M_getword(size_t) { return _M_w; } _WordT _M_getword(size_t) const { return _M_w; } _WordT& _M_hiword() { return _M_w; } _WordT _M_hiword() const { return _M_w; } void _M_do_and(const _Base_bitset<1>& __x) { _M_w &= __x._M_w; }
void
_M_do_or(const _Base_bitset<1>& __x) { _M_w |= __x._M_w; }
void
_M_do_xor(const _Base_bitset<1>& __x) { _M_w ^= __x._M_w; }
void
_M_do_left_shift(size_t __shift) { _M_w <<= __shift; } void _M_do_right_shift(size_t __shift) { _M_w >>= __shift; }
void
_M_do_flip() { _M_w = ~_M_w; }
void
_M_do_set() { _M_w = ~static_cast<_WordT>(0); }
void
_M_do_reset() { _M_w = 0; }
bool
_M_is_equal(const _Base_bitset<1>& __x) const
{ return _M_w == __x._M_w; }
bool
_M_is_any() const { return _M_w != 0; }
size_t
_M_do_count() const { return __builtin_popcountl(_M_w); }
unsigned long
_M_do_to_ulong() const { return _M_w; }
size_t
_M_do_find_first(size_t __not_found) const
{
if (_M_w != 0)
return __builtin_ctzl(_M_w);
else
return __not_found;
}
// find the next “on” bit that follows “prev”
size_t
_M_do_find_next(size_t __prev, size_t __not_found) const
{
++__prev;
if (__prev >= ((size_t) _GLIBCXX_BITSET_BITS_PER_WORD))
return __not_found;
_WordT __x = _M_w >> __prev;
if (__x != 0)
return __builtin_ctzl(__x) + __prev;
else
return __not_found;
}
};

/**
* @if maint
* Base class, specialization for no storage (zero-length %bitset).
*
* See documentation for bitset.
* @endif
*/
template<>
struct _Base_bitset<0>
{
typedef unsigned long _WordT;
_Base_bitset() {}
_Base_bitset(unsigned long) {}
static size_t
_S_whichword(size_t __pos )
{ return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }
static size_t
_S_whichbyte(size_t __pos )
{ return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }
static size_t
_S_whichbit(size_t __pos )
{ return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }
static _WordT
_S_maskbit(size_t __pos )
{ return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } // This would normally give access to the data. The bounds-checking // in the bitset class will prevent the user from getting this far, // but (1) it must still return an lvalue to compile, and (2) the // user might call _Unchecked_set directly, in which case this /needs/ // to fail. Let's not penalize zero-length users unless they actually // make an unchecked call; all the memory ugliness is therefore // localized to this single should-never-get-this-far function. _WordT& _M_getword(size_t) const { __throw_out_of_range(__N("_Base_bitset::_M_getword")); return *new _WordT; } _WordT _M_hiword() const { return 0; } void _M_do_and(const _Base_bitset<0>&) { }
void
_M_do_or(const _Base_bitset<0>&) { }
void
_M_do_xor(const _Base_bitset<0>&) { }
void
_M_do_left_shift(size_t) { }
void
_M_do_right_shift(size_t) { }
void
_M_do_flip() { }
void
_M_do_set() { }
void
_M_do_reset() { }
// Are all empty bitsets equal to each other? Are they equal to
// themselves? How to compare a thing which has no state? What is
// the sound of one zero-length bitset clapping?
bool
_M_is_equal(const _Base_bitset<0>&) const { return true; }
bool
_M_is_any() const { return false; }
size_t
_M_do_count() const { return 0; }
unsigned long
_M_do_to_ulong() const { return 0; }
// Normally “not found” is the size, but that could also be
// misinterpreted as an index in this corner case. Oh well.
size_t
_M_do_find_first(size_t) const { return 0; }
size_t
_M_do_find_next(size_t, size_t) const { return 0; }
};

// Helper class to zero out the unused high-order bits in the highest word.
template
struct _Sanitize
{
static void _S_do_sanitize(unsigned long& __val)
{ __val &= ~((~static_cast(0)) << _Extrabits); } }; template<>
struct _Sanitize<0>
{ static void _S_do_sanitize(unsigned long) { } };

/**
* @brief The %bitset class represents a @e fixed-size sequence of bits.
*
* @ingroup Containers
*
* (Note that %bitset does @e not meet the formal requirements of a
* container. Mainly, it lacks iterators.)
*
* The template argument, @a Nb, may be any non-negative number,
* specifying the number of bits (e.g., “0”, “12”, “1024*1024”).
*
* In the general unoptimized case, storage is allocated in word-sized
* blocks. Let B be the number of bits in a word, then (Nb+(B-1))/B
* words will be used for storage. B – Nb%B bits are unused. (They are
* the high-order bits in the highest word.) It is a class invariant
* that those unused bits are always zero.
*
* If you think of %bitset as “a simple array of bits,” be aware that
* your mental picture is reversed: a %bitset behaves the same way as
* bits in integers do, with the bit at index 0 in the “least significant
* / right-hand” position, and the bit at index Nb-1 in the “most
* significant / left-hand” position. Thus, unlike other containers, a
* %bitset’s index “counts from right to left,” to put it very loosely.
*
* This behavior is preserved when translating to and from strings. For
* example, the first line of the following program probably prints
* “b(‘a’) is 0001100001” on a modern ASCII system.
*
* @code
* #include
* #include
* #include
*
* using namespace std;
*
* int main()
* {
* long a = ‘a’;
* bitset<10> b(a);
*
* cout << "b('a') is " << b << endl; * * ostringstream s; * s << b; * string str = s.str(); * cout << "index 3 in the string is " << str[3] << " but\n" * << "index 3 in the bitset is " << b[3] << endl; * } * @endcode * * Also see http://gcc.gnu.org/onlinedocs/libstdc++/ext/sgiexts.html#ch23 * for a description of extensions. * * @if maint * Most of the actual code isn't contained in %bitset<> itself, but in the
* base class _Base_bitset. The base class works with whole words, not with
* individual bits. This allows us to specialize _Base_bitset for the
* important special case where the %bitset is only a single word.
*
* Extra confusion can result due to the fact that the storage for
* _Base_bitset @e is a regular array, and is indexed as such. This is
* carefully encapsulated.
* @endif
*/
template
class bitset : private _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)>
{
private:
typedef _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> _Base;
typedef unsigned long _WordT;
void
_M_do_sanitize()
{
_Sanitize<_Nb%_GLIBCXX_BITSET_BITS_PER_WORD>::
_S_do_sanitize(this->_M_hiword());
}
public:
/**
* This encapsulates the concept of a single bit. An instance of this
* class is a proxy for an actual bit; this way the individual bit
* operations are done as faster word-size bitwise instructions.
*
* Most users will never need to use this class directly; conversions
* to and from bool are automatic and should be transparent. Overloaded
* operators help to preserve the illusion.
*
* (On a typical system, this “bit %reference” is 64 times the size of
* an actual bit. Ha.)
*/
class reference
{
friend class bitset;
_WordT *_M_wp;
size_t _M_bpos;
// left undefined
reference();
public:
reference(bitset& __b, size_t __pos)
{
_M_wp = &__b._M_getword(__pos);
_M_bpos = _Base::_S_whichbit(__pos);
}
~reference() { }
// For b[i] = __x;
reference&
operator=(bool __x)
{
if ( __x )
*_M_wp |= _Base::_S_maskbit(_M_bpos);
else
*_M_wp &= ~_Base::_S_maskbit(_M_bpos);
return *this;
}
// For b[i] = b[__j];
reference&
operator=(const reference& __j)
{
if ( (*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)) )
*_M_wp |= _Base::_S_maskbit(_M_bpos);
else
*_M_wp &= ~_Base::_S_maskbit(_M_bpos);
return *this;
}
// Flips the bit
bool
operator~() const
{ return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }
// For __x = b[i];
operator bool() const
{ return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }
// For b[i].flip();
reference&
flip()
{
*_M_wp ^= _Base::_S_maskbit(_M_bpos);
return *this;
}
};
friend class reference;
// 23.3.5.1 constructors:
/// All bits set to zero.
bitset() { }
/// Initial bits bitwise-copied from a single word (others set to zero).
bitset(unsigned long __val) : _Base(__val)
{ _M_do_sanitize(); }
/**
* @brief Use a subset of a string.
* @param s A string of ‘0’ and ‘1’ characters.
* @param position Index of the first character in @a s to use; defaults
* to zero.
* @throw std::out_of_range If @a pos is bigger the size of @a s.
* @throw std::invalid_argument If a character appears in the string
* which is neither ‘0’ nor ‘1’.
*/
template
explicit bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
size_t __position = 0) : _Base()
{
if (__position > __s.size())
__throw_out_of_range(__N(“bitset::bitset initial position ”
“not valid”));
_M_copy_from_string(__s, __position,
basic_string<_CharT, _Traits, _Alloc>::npos);
}
/**
* @brief Use a subset of a string.
* @param s A string of ‘0’ and ‘1’ characters.
* @param position Index of the first character in @a s to use.
* @param n The number of characters to copy.
* @throw std::out_of_range If @a pos is bigger the size of @a s.
* @throw std::invalid_argument If a character appears in the string
* which is neither ‘0’ nor ‘1’.
*/
template
bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
size_t __position, size_t __n) : _Base()
{
if (__position > __s.size())
__throw_out_of_range(__N(“bitset::bitset initial position ”
“not valid”));
_M_copy_from_string(__s, __position, __n);
}
// 23.3.5.2 bitset operations:
//@{
/**
* @brief Operations on bitsets.
* @param rhs A same-sized bitset.
*
* These should be self-explanatory.
*/
bitset<_Nb>&
operator&=(const bitset<_Nb>& __rhs)
{
this->_M_do_and(__rhs);
return *this;
}
bitset<_Nb>&
operator|=(const bitset<_Nb>& __rhs)
{
this->_M_do_or(__rhs);
return *this;
}
bitset<_Nb>&
operator^=(const bitset<_Nb>& __rhs)
{
this->_M_do_xor(__rhs);
return *this;
}
//@}
//@{
/**
* @brief Operations on bitsets.
* @param position The number of places to shift.
*
* These should be self-explanatory.
*/
bitset<_Nb>&
operator<<=(size_t __position) { if (__builtin_expect(__position < _Nb, 1)) { this->_M_do_left_shift(__position);
this->_M_do_sanitize();
}
else
this->_M_do_reset();
return *this;
}
bitset<_Nb>&
operator>>=(size_t __position)
{
if (__builtin_expect(__position < _Nb, 1)) { this->_M_do_right_shift(__position);
this->_M_do_sanitize();
}
else
this->_M_do_reset();
return *this;
}
//@}
//@{
/**
* These versions of single-bit set, reset, flip, and test are
* extensions from the SGI version. They do no range checking.
* @ingroup SGIextensions
*/
bitset<_Nb>&
_Unchecked_set(size_t __pos)
{
this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
return *this;
}
bitset<_Nb>&
_Unchecked_set(size_t __pos, int __val)
{
if (__val)
this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
else
this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
return *this;
}
bitset<_Nb>&
_Unchecked_reset(size_t __pos)
{
this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
return *this;
}
bitset<_Nb>&
_Unchecked_flip(size_t __pos)
{
this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
return *this;
}
bool
_Unchecked_test(size_t __pos) const
{
return (this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
!= static_cast<_WordT>(0);
}
//@}
// Set, reset, and flip.
/**
* @brief Sets every bit to true.
*/
bitset<_Nb>&
set()
{
this->_M_do_set();
this->_M_do_sanitize();
return *this;
}
/**
* @brief Sets a given bit to a particular value.
* @param position The index of the bit.
* @param val Either true or false, defaults to true.
* @throw std::out_of_range If @a pos is bigger the size of the %set.
*/
bitset<_Nb>&
set(size_t __position, bool __val = true)
{
if (__position >= _Nb)
__throw_out_of_range(__N(“bitset::set”));
return _Unchecked_set(__position, __val);
}
/**
* @brief Sets every bit to false.
*/
bitset<_Nb>&
reset()
{
this->_M_do_reset();
return *this;
}
/**
* @brief Sets a given bit to false.
* @param position The index of the bit.
* @throw std::out_of_range If @a pos is bigger the size of the %set.
*
* Same as writing @c set(pos,false).
*/
bitset<_Nb>&
reset(size_t __position)
{
if (__position >= _Nb)
__throw_out_of_range(__N(“bitset::reset”));
return _Unchecked_reset(__position);
}
/**
* @brief Toggles every bit to its opposite value.
*/
bitset<_Nb>&
flip()
{
this->_M_do_flip();
this->_M_do_sanitize();
return *this;
}
/**
* @brief Toggles a given bit to its opposite value.
* @param position The index of the bit.
* @throw std::out_of_range If @a pos is bigger the size of the %set.
*/
bitset<_Nb>&
flip(size_t __position)
{
if (__position >= _Nb)
__throw_out_of_range(__N(“bitset::flip”));
return _Unchecked_flip(__position);
}
/// See the no-argument flip().
bitset<_Nb>
operator~() const { return bitset<_Nb>(*this).flip(); }
//@{
/**
* @brief Array-indexing support.
* @param position Index into the %bitset.
* @return A bool for a ‘const %bitset’. For non-const bitsets, an
* instance of the reference proxy class.
* @note These operators do no range checking and throw no exceptions,
* as required by DR 11 to the standard.
*
* @if maint
* _GLIBCXX_RESOLVE_LIB_DEFECTS Note that this implementation already
* resolves DR 11 (items 1 and 2), but does not do the range-checking
* required by that DR’s resolution. -pme
* The DR has since been changed: range-checking is a precondition
* (users’ responsibility), and these functions must not throw. -pme
* @endif
*/
reference
operator[](size_t __position) { return reference(*this,__position); }
bool
operator[](size_t __position) const { return _Unchecked_test(__position); }
//@}
/**
* @brief Retuns a numerical interpretation of the %bitset.
* @return The integral equivalent of the bits.
* @throw std::overflow_error If there are too many bits to be
* represented in an @c unsigned @c long.
*/
unsigned long
to_ulong() const { return this->_M_do_to_ulong(); }
/**
* @brief Retuns a character interpretation of the %bitset.
* @return The string equivalent of the bits.
*
* Note the ordering of the bits: decreasing character positions
* correspond to increasing bit positions (see the main class notes for
* an example).
*
* Also note that you must specify the string’s template parameters
* explicitly. Given a bitset @c bs and a string @s:
* @code
* s = bs.to_string,allocator >();
* @endcode
*/
template
basic_string<_CharT, _Traits, _Alloc>
to_string() const
{
basic_string<_CharT, _Traits, _Alloc> __result;
_M_copy_to_string(__result);
return __result;
}
// Helper functions for string operations.
template
void
_M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s,
size_t, size_t);
template
void
_M_copy_to_string(basic_string<_CharT,_Traits,_Alloc>&) const;
/// Returns the number of bits which are set.
size_t
count() const { return this->_M_do_count(); }
/// Returns the total number of bits.
size_t
size() const { return _Nb; }
//@{
/// These comparisons for equality/inequality are, well, @e bitwise.
bool
operator==(const bitset<_Nb>& __rhs) const
{ return this->_M_is_equal(__rhs); }
bool
operator!=(const bitset<_Nb>& __rhs) const
{ return !this->_M_is_equal(__rhs); }
//@}
/**
* @brief Tests the value of a bit.
* @param position The index of a bit.
* @return The value at @a pos.
* @throw std::out_of_range If @a pos is bigger the size of the %set.
*/
bool
test(size_t __position) const
{
if (__position >= _Nb)
__throw_out_of_range(__N(“bitset::test”));
return _Unchecked_test(__position);
}
/**
* @brief Tests whether any of the bits are on.
* @return True if at least one bit is set.
*/
bool
any() const { return this->_M_is_any(); }
/**
* @brief Tests whether any of the bits are on.
* @return True if none of the bits are set.
*/
bool
none() const { return !this->_M_is_any(); }
//@{
/// Self-explanatory.
bitset<_Nb>
operator<<(size_t __position) const { return bitset<_Nb>(*this) <<= __position; } bitset<_Nb>
operator>>(size_t __position) const
{ return bitset<_Nb>(*this) >>= __position; }
//@}
/**
* @brief Finds the index of the first “on” bit.
* @return The index of the first bit set, or size() if not found.
* @ingroup SGIextensions
* @sa _Find_next
*/
size_t
_Find_first() const
{ return this->_M_do_find_first(_Nb); }
/**
* @brief Finds the index of the next “on” bit after prev.
* @return The index of the next bit set, or size() if not found.
* @param prev Where to start searching.
* @ingroup SGIextensions
* @sa _Find_first
*/
size_t
_Find_next(size_t __prev ) const
{ return this->_M_do_find_next(__prev, _Nb); }
};
// Definitions of non-inline member functions.
template
template
void
bitset<_Nb>::_M_copy_from_string(const basic_string<_CharT, _Traits, _Alloc>& __s, size_t __pos, size_t __n)
{
reset();
const size_t __nbits = std::min(_Nb, std::min(__n, __s.size() – __pos));
for (size_t __i = 0; __i < __nbits; ++__i) { switch(__s[__pos + __nbits - __i - 1]) { case '0': break; case '1': set(__i); break; default: __throw_invalid_argument(__N("bitset::_M_copy_from_string")); } } } template
template
void
bitset<_Nb>::_M_copy_to_string(basic_string<_CharT, _Traits, _Alloc>& __s) const
{
__s.assign(_Nb, ‘0’);
for (size_t __i = 0; __i < _Nb; ++__i) if (_Unchecked_test(__i)) __s[_Nb - 1 - __i] = '1'; } // 23.3.5.3 bitset operations: //@{ /** * @brief Global bitwise operations on bitsets. * @param x A bitset. * @param y A bitset of the same size as @a x. * @return A new bitset. * * These should be self-explanatory. */ template
inline bitset<_Nb>
operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
{
bitset<_Nb> __result(__x);
__result &= __y;
return __result;
}
template
inline bitset<_Nb>
operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
{
bitset<_Nb> __result(__x);
__result |= __y;
return __result;
}
template
inline bitset<_Nb>
operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
{
bitset<_Nb> __result(__x);
__result ^= __y;
return __result;
}
//@}
//@{
/**
* @brief Global I/O operators for bitsets.
*
* Direct I/O between streams and bitsets is supported. Output is
* straightforward. Input will skip whitespace, only accept ‘0’ and ‘1’
* characters, and will only extract as many digits as the %bitset will
* hold.
*/
template
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
{
typedef typename _Traits::char_type char_type;
basic_string<_CharT, _Traits> __tmp;
__tmp.reserve(_Nb);
ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __sentry(__is);
if (__sentry)
{
try
{
basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 303. Bitset input operator underspecified
const char_type __zero = __is.widen(‘0’);
const char_type __one = __is.widen(‘1’);
for (size_t __i = 0; __i < _Nb; ++__i) { static typename _Traits::int_type __eof = _Traits::eof(); typename _Traits::int_type __c1 = __buf->sbumpc();
if (_Traits::eq_int_type(__c1, __eof))
{
__state |= ios_base::eofbit;
break;
}
else
{
char_type __c2 = _Traits::to_char_type(__c1);
if (__c2 == __zero)
__tmp.push_back(‘0’);
else if (__c2 == __one)
__tmp.push_back(‘1’);
else if (_Traits::eq_int_type(__buf->sputbackc(__c2),
__eof))
{
__state |= ios_base::failbit;
break;
}
}
}
}
catch(…)
{ __is._M_setstate(ios_base::badbit); }
}
if (__tmp.empty() && _Nb)
__state |= ios_base::failbit;
else
__x._M_copy_from_string(__tmp, static_cast(0), _Nb);
if (__state)
__is.setstate(__state);
return __is;
}
template
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x)
{
basic_string<_CharT, _Traits> __tmp;
__x._M_copy_to_string(__tmp);
return __os << __tmp; } //@} } // namespace std #undef _GLIBCXX_BITSET_WORDS #undef _GLIBCXX_BITSET_BITS_PER_WORD #ifdef _GLIBCXX_DEBUG # include
#endif
#endif /* _GLIBCXX_BITSET */

vector
// -*- C++ -*-
// Copyright (C) 2001, 2002, 2003 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.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* 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. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided “as is” without express or implied warranty.
*
*
* Copyright (c) 1996
* 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.
*/
/** @file vector
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_VECTOR
#define _GLIBCXX_VECTOR 1
#pragma GCC system_header
#include
#include
#include
#include
#include
#include
#include
#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include
#endif
#ifdef _GLIBCXX_DEBUG
# include
#endif
#endif /* _GLIBCXX_VECTOR */

valarray
// The template and inlines for the -*- C++ -*- valarray class.
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2004
// 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.
// Written by Gabriel Dos Reis
/** @file valarray
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_VALARRAY
#define _GLIBCXX_VALARRAY 1
#pragma GCC system_header
#include
#include
#include
#include
#include
#include
#include
namespace std
{
template
class _Expr;
template
class _ValArray;
template class _Meta, class _Dom>
struct _UnClos;
template class _Meta1,
template class _Meta2,
class _Dom1, class _Dom2>
class _BinClos;
template class _Meta, class _Dom>
class _SClos;
template class _Meta, class _Dom>
class _GClos;

template class _Meta, class _Dom>
class _IClos;

template class _Meta, class _Dom>
class _ValFunClos;

template class _Meta, class _Dom>
class _RefFunClos;
template class valarray; // An array of type _Tp
class slice; // BLAS-like slice out of an array
template class slice_array;
class gslice; // generalized slice out of an array
template class gslice_array;
template class mask_array; // masked array
template class indirect_array; // indirected array
} // namespace std
#include
#include

namespace std
{
/**
* @brief Smart array designed to support numeric processing.
*
* A valarray is an array that provides constraints intended to allow for
* effective optimization of numeric array processing by reducing the
* aliasing that can result from pointer representations. It represents a
* one-dimensional array from which different multidimensional subsets can
* be accessed and modified.
*
* @param Tp Type of object in the array.
*/
template
class valarray
{
template
struct _UnaryOp
{
typedef typename __fun<_Op, _Tp>::result_type __rt;
typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt;
};
public:
typedef _Tp value_type;

// _lib.valarray.cons_ construct/destroy:
/// Construct an empty array.
valarray();
/// Construct an array with @a n elements.
explicit valarray(size_t);
/// Construct an array with @a n elements initialized to @a t.
valarray(const _Tp&, size_t);
/// Construct an array initialized to the first @a n elements of @a t.
valarray(const _Tp* __restrict__, size_t);
/// Copy constructor.
valarray(const valarray&);
/// Construct an array with the same size and values in @a sa.
valarray(const slice_array<_Tp>&);
/// Construct an array with the same size and values in @a ga.
valarray(const gslice_array<_Tp>&);
/// Construct an array with the same size and values in @a ma.
valarray(const mask_array<_Tp>&);
/// Construct an array with the same size and values in @a ia.
valarray(const indirect_array<_Tp>&);
template
valarray(const _Expr<_Dom,_Tp>& __e);
~valarray();
// _lib.valarray.assign_ assignment:
/**
* @brief Assign elements to an array.
*
* Assign elements of array to values in @a v. Results are undefined
* if @a v is not the same size as this array.
*
* @param v Valarray to get values from.
*/
valarray<_Tp>& operator=(const valarray<_Tp>&);
/**
* @brief Assign elements to a value.
*
* Assign all elements of array to @a t.
*
* @param t Value for elements.
*/
valarray<_Tp>& operator=(const _Tp&);
/**
* @brief Assign elements to an array subset.
*
* Assign elements of array to values in @a sa. Results are undefined
* if @a sa is not the same size as this array.
*
* @param sa Array slice to get values from.
*/
valarray<_Tp>& operator=(const slice_array<_Tp>&);
/**
* @brief Assign elements to an array subset.
*
* Assign elements of array to values in @a ga. Results are undefined
* if @a ga is not the same size as this array.
*
* @param ga Array slice to get values from.
*/
valarray<_Tp>& operator=(const gslice_array<_Tp>&);
/**
* @brief Assign elements to an array subset.
*
* Assign elements of array to values in @a ma. Results are undefined
* if @a ma is not the same size as this array.
*
* @param ma Array slice to get values from.
*/
valarray<_Tp>& operator=(const mask_array<_Tp>&);
/**
* @brief Assign elements to an array subset.
*
* Assign elements of array to values in @a ia. Results are undefined
* if @a ia is not the same size as this array.
*
* @param ia Array slice to get values from.
*/
valarray<_Tp>& operator=(const indirect_array<_Tp>&);
template valarray<_Tp>&
operator= (const _Expr<_Dom,_Tp>&);
// _lib.valarray.access_ element access:
/**
* Return a reference to the i’th array element.
*
* @param i Index of element to return.
* @return Reference to the i’th element.
*/
_Tp& operator[](size_t);
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 389. Const overload of valarray::operator[] returns by value.
const _Tp& operator[](size_t) const;
// _lib.valarray.sub_ subset operations:
/**
* @brief Return an array subset.
*
* Returns a new valarray containing the elements of the array
* indicated by the slice argument. The new valarray is the size of
* the input slice. @see slice.
*
* @param s The source slice.
* @return New valarray containing elements in @a s.
*/
_Expr<_SClos<_ValArray,_Tp>, _Tp> operator[](slice) const;
/**
* @brief Return a reference to an array subset.
*
* Returns a new valarray containing the elements of the array
* indicated by the slice argument. The new valarray is the size of
* the input slice. @see slice.
*
* @param s The source slice.
* @return New valarray containing elements in @a s.
*/
slice_array<_Tp> operator[](slice);
/**
* @brief Return an array subset.
*
* Returns a slice_array referencing the elements of the array
* indicated by the slice argument. @see gslice.
*
* @param s The source slice.
* @return Slice_array referencing elements indicated by @a s.
*/
_Expr<_GClos<_ValArray,_Tp>, _Tp> operator[](const gslice&) const;
/**
* @brief Return a reference to an array subset.
*
* Returns a new valarray containing the elements of the array
* indicated by the gslice argument. The new valarray is
* the size of the input gslice. @see gslice.
*
* @param s The source gslice.
* @return New valarray containing elements in @a s.
*/
gslice_array<_Tp> operator[](const gslice&);
/**
* @brief Return an array subset.
*
* Returns a new valarray containing the elements of the array
* indicated by the argument. The input is a valarray of bool which
* represents a bitmask indicating which elements should be copied into
* the new valarray. Each element of the array is added to the return
* valarray if the corresponding element of the argument is true.
*
* @param m The valarray bitmask.
* @return New valarray containing elements indicated by @a m.
*/
valarray<_Tp> operator[](const valarray&) const;
/**
* @brief Return a reference to an array subset.
*
* Returns a new mask_array referencing the elements of the array
* indicated by the argument. The input is a valarray of bool which
* represents a bitmask indicating which elements are part of the
* subset. Elements of the array are part of the subset if the
* corresponding element of the argument is true.
*
* @param m The valarray bitmask.
* @return New valarray containing elements indicated by @a m.
*/
mask_array<_Tp> operator[](const valarray&);
/**
* @brief Return an array subset.
*
* Returns a new valarray containing the elements of the array
* indicated by the argument. The elements in the argument are
* interpreted as the indices of elements of this valarray to copy to
* the return valarray.
*
* @param i The valarray element index list.
* @return New valarray containing elements in @a s.
*/
_Expr<_IClos<_ValArray, _Tp>, _Tp>
operator[](const valarray&) const;
/**
* @brief Return a reference to an array subset.
*
* Returns an indirect_array referencing the elements of the array
* indicated by the argument. The elements in the argument are
* interpreted as the indices of elements of this valarray to include
* in the subset. The returned indirect_array refers to these
* elements.
*
* @param i The valarray element index list.
* @return Indirect_array referencing elements in @a i.
*/
indirect_array<_Tp> operator[](const valarray&);
// _lib.valarray.unary_ unary operators:
/// Return a new valarray by applying unary + to each element.
typename _UnaryOp<__unary_plus>::_Rt operator+() const;
/// Return a new valarray by applying unary – to each element.
typename _UnaryOp<__negate>::_Rt operator-() const;
/// Return a new valarray by applying unary ~ to each element.
typename _UnaryOp<__bitwise_not>::_Rt operator~() const;
/// Return a new valarray by applying unary ! to each element.
typename _UnaryOp<__logical_not>::_Rt operator!() const;
// _lib.valarray.cassign_ computed assignment:
/// Multiply each element of array by @a t.
valarray<_Tp>& operator*=(const _Tp&);
/// Divide each element of array by @a t.
valarray<_Tp>& operator/=(const _Tp&);
/// Set each element e of array to e % @a t.
valarray<_Tp>& operator%=(const _Tp&);
/// Add @a t to each element of array.
valarray<_Tp>& operator+=(const _Tp&);
/// Subtract @a t to each element of array.
valarray<_Tp>& operator-=(const _Tp&);
/// Set each element e of array to e ^ @a t.
valarray<_Tp>& operator^=(const _Tp&);
/// Set each element e of array to e & @a t.
valarray<_Tp>& operator&=(const _Tp&);
/// Set each element e of array to e | @a t.
valarray<_Tp>& operator|=(const _Tp&);
/// Left shift each element e of array by @a t bits.
valarray<_Tp>& operator<<=(const _Tp&); /// Right shift each element e of array by @a t bits. valarray<_Tp>& operator>>=(const _Tp&);
/// Multiply elements of array by corresponding elements of @a v.
valarray<_Tp>& operator*=(const valarray<_Tp>&);
/// Divide elements of array by corresponding elements of @a v.
valarray<_Tp>& operator/=(const valarray<_Tp>&);
/// Modulo elements of array by corresponding elements of @a v.
valarray<_Tp>& operator%=(const valarray<_Tp>&);
/// Add corresponding elements of @a v to elements of array.
valarray<_Tp>& operator+=(const valarray<_Tp>&);
/// Subtract corresponding elements of @a v from elements of array.
valarray<_Tp>& operator-=(const valarray<_Tp>&);
/// Logical xor corresponding elements of @a v with elements of array.
valarray<_Tp>& operator^=(const valarray<_Tp>&);
/// Logical or corresponding elements of @a v with elements of array.
valarray<_Tp>& operator|=(const valarray<_Tp>&);
/// Logical and corresponding elements of @a v with elements of array.
valarray<_Tp>& operator&=(const valarray<_Tp>&);
/// Left shift elements of array by corresponding elements of @a v.
valarray<_Tp>& operator<<=(const valarray<_Tp>&);
/// Right shift elements of array by corresponding elements of @a v.
valarray<_Tp>& operator>>=(const valarray<_Tp>&);
template
valarray<_Tp>& operator*=(const _Expr<_Dom,_Tp>&);
template
valarray<_Tp>& operator/=(const _Expr<_Dom,_Tp>&);
template
valarray<_Tp>& operator%=(const _Expr<_Dom,_Tp>&);
template
valarray<_Tp>& operator+=(const _Expr<_Dom,_Tp>&);
template
valarray<_Tp>& operator-=(const _Expr<_Dom,_Tp>&);
template
valarray<_Tp>& operator^=(const _Expr<_Dom,_Tp>&);
template
valarray<_Tp>& operator|=(const _Expr<_Dom,_Tp>&);
template
valarray<_Tp>& operator&=(const _Expr<_Dom,_Tp>&);
template
valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&);
template
valarray<_Tp>& operator>>=(const _Expr<_Dom,_Tp>&);

// _lib.valarray.members_ member functions:
/// Return the number of elements in array.
size_t size() const;
/**
* @brief Return the sum of all elements in the array.
*
* Accumulates the sum of all elements into a Tp using +=. The order
* of adding the elements is unspecified.
*/
_Tp sum() const;
/// Return the minimum element using operator<(). _Tp min() const; /// Return the maximum element using operator<(). _Tp max() const; // // FIXME: Extension // _Tp product () const; /** * @brief Return a shifted array. * * A new valarray is constructed as a copy of this array with elements * in shifted positions. For an element with index i, the new position * is i - n. The new valarray is the same size as the current one. * New elements without a value are set to 0. Elements whos new * position is outside the bounds of the array are discarded. * * Positive arguments shift toward index 0, discarding elements [0, n). * Negative arguments discard elements from the top of the array. * * @param n Number of element positions to shift. * @return New valarray with elements in shifted positions. */ valarray<_Tp> shift (int) const;
/**
* @brief Return a rotated array.
*
* A new valarray is constructed as a copy of this array with elements
* in shifted positions. For an element with index i, the new position
* is (i – n) % size(). The new valarray is the same size as the
* current one. Elements that are shifted beyond the array bounds are
* shifted into the other end of the array. No elements are lost.
*
* Positive arguments shift toward index 0, wrapping around the top.
* Negative arguments shift towards the top, wrapping around to 0.
*
* @param n Number of element positions to rotate.
* @return New valarray with elements in shifted positions.
*/
valarray<_Tp> cshift(int) const;
/**
* @brief Apply a function to the array.
*
* Returns a new valarray with elements assigned to the result of
* applying func to the corresponding element of this array. The new
* array is the same size as this one.
*
* @param func Function of Tp returning Tp to apply.
* @return New valarray with transformed elements.
*/
_Expr<_ValFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(_Tp)) const;
/**
* @brief Apply a function to the array.
*
* Returns a new valarray with elements assigned to the result of
* applying func to the corresponding element of this array. The new
* array is the same size as this one.
*
* @param func Function of const Tp& returning Tp to apply.
* @return New valarray with transformed elements.
*/
_Expr<_RefFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(const _Tp&)) const;
/**
* @brief Resize array.
*
* Resize this array to be @a size and set all elements to @a c. All
* references and iterators are invalidated.
*
* @param size New array size.
* @param c New value for all elements.
*/
void resize(size_t __size, _Tp __c = _Tp());
private:
size_t _M_size;
_Tp* __restrict__ _M_data;

friend class _Array<_Tp>;
};

template
inline const _Tp&
valarray<_Tp>::operator[](size_t __i) const
{
__glibcxx_requires_subscript(__i);
return _M_data[__i];
}
template
inline _Tp&
valarray<_Tp>::operator[](size_t __i)
{
__glibcxx_requires_subscript(__i);
return _M_data[__i];
}
} // std::
#include
#include
#include
#include
#include
#include
namespace std
{
template
inline
valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {}
template
inline
valarray<_Tp>::valarray(size_t __n)
: _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
{ std::__valarray_default_construct(_M_data, _M_data + __n); }
template
inline
valarray<_Tp>::valarray(const _Tp& __t, size_t __n)
: _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
{ std::__valarray_fill_construct(_M_data, _M_data + __n, __t); }
template
inline
valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n)
: _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
{
_GLIBCXX_DEBUG_ASSERT(__p != 0 || __n == 0);
std::__valarray_copy_construct(__p, __p + __n, _M_data);
}
template
inline
valarray<_Tp>::valarray(const valarray<_Tp>& __v)
: _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size))
{ std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size, _M_data); }
template
inline
valarray<_Tp>::valarray(const slice_array<_Tp>& __sa)
: _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz))
{
std::__valarray_copy
(__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data));
}
template
inline
valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga)
: _M_size(__ga._M_index.size()),
_M_data(__valarray_get_storage<_Tp>(_M_size))
{
std::__valarray_copy
(__ga._M_array, _Array(__ga._M_index),
_Array<_Tp>(_M_data), _M_size);
}
template
inline
valarray<_Tp>::valarray(const mask_array<_Tp>& __ma)
: _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz))
{
std::__valarray_copy
(__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size);
}
template
inline
valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia)
: _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz))
{
std::__valarray_copy
(__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size);
}
template template
inline
valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e)
: _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size))
{ std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); }
template
inline
valarray<_Tp>::~valarray()
{
std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
std::__valarray_release_memory(_M_data);
}
template
inline valarray<_Tp>&
valarray<_Tp>::operator=(const valarray<_Tp>& __v)
{
_GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size);
std::__valarray_copy(__v._M_data, _M_size, _M_data);
return *this;
}
template
inline valarray<_Tp>&
valarray<_Tp>::operator=(const _Tp& __t)
{
std::__valarray_fill(_M_data, _M_size, __t);
return *this;
}
template
inline valarray<_Tp>&
valarray<_Tp>::operator=(const slice_array<_Tp>& __sa)
{
_GLIBCXX_DEBUG_ASSERT(_M_size == __sa._M_sz);
std::__valarray_copy(__sa._M_array, __sa._M_sz,
__sa._M_stride, _Array<_Tp>(_M_data));
return *this;
}
template
inline valarray<_Tp>&
valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga)
{
_GLIBCXX_DEBUG_ASSERT(_M_size == __ga._M_index.size());
std::__valarray_copy(__ga._M_array, _Array(__ga._M_index),
_Array<_Tp>(_M_data), _M_size);
return *this;
}
template
inline valarray<_Tp>&
valarray<_Tp>::operator=(const mask_array<_Tp>& __ma)
{
_GLIBCXX_DEBUG_ASSERT(_M_size == __ma._M_sz);
std::__valarray_copy(__ma._M_array, __ma._M_mask,
_Array<_Tp>(_M_data), _M_size);
return *this;
}
template
inline valarray<_Tp>&
valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia)
{
_GLIBCXX_DEBUG_ASSERT(_M_size == __ia._M_sz);
std::__valarray_copy(__ia._M_array, __ia._M_index,
_Array<_Tp>(_M_data), _M_size);
return *this;
}
template template
inline valarray<_Tp>&
valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e)
{
_GLIBCXX_DEBUG_ASSERT(_M_size == __e.size());
std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data));
return *this;
}
template
inline _Expr<_SClos<_ValArray,_Tp>, _Tp>
valarray<_Tp>::operator[](slice __s) const
{
typedef _SClos<_ValArray,_Tp> _Closure;
return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s));
}
template
inline slice_array<_Tp>
valarray<_Tp>::operator[](slice __s)
{
return slice_array<_Tp>(_Array<_Tp>(_M_data), __s);
}
template
inline _Expr<_GClos<_ValArray,_Tp>, _Tp>
valarray<_Tp>::operator[](const gslice& __gs) const
{
typedef _GClos<_ValArray,_Tp> _Closure;
return _Expr<_Closure, _Tp>
(_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index));
}
template
inline gslice_array<_Tp>
valarray<_Tp>::operator[](const gslice& __gs)
{
return gslice_array<_Tp>
(_Array<_Tp>(_M_data), __gs._M_index->_M_index);
}
template
inline valarray<_Tp>
valarray<_Tp>::operator[](const valarray& __m) const
{
size_t __s = 0;
size_t __e = __m.size();
for (size_t __i=0; __i<__e; ++__i) if (__m[__i]) ++__s; return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s,
_Array (__m)));
}
template
inline mask_array<_Tp>
valarray<_Tp>::operator[](const valarray& __m)
{
size_t __s = 0;
size_t __e = __m.size();
for (size_t __i=0; __i<__e; ++__i) if (__m[__i]) ++__s; return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array(__m));
}
template
inline _Expr<_IClos<_ValArray,_Tp>, _Tp>
valarray<_Tp>::operator[](const valarray& __i) const
{
typedef _IClos<_ValArray,_Tp> _Closure;
return _Expr<_Closure, _Tp>(_Closure(*this, __i));
}
template
inline indirect_array<_Tp>
valarray<_Tp>::operator[](const valarray& __i)
{
return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(),
_Array(__i));
}
template
inline size_t
valarray<_Tp>::size() const
{ return _M_size; }
template
inline _Tp
valarray<_Tp>::sum() const
{
_GLIBCXX_DEBUG_ASSERT(_M_size > 0);
return std::__valarray_sum(_M_data, _M_data + _M_size);
}
// template
// inline _Tp
// valarray<_Tp>::product () const
// {
// return __valarray_product(_M_data, _M_data + _M_size);
// }
template
inline valarray<_Tp>
valarray<_Tp>::shift(int __n) const
{
_Tp* const __a = static_cast<_Tp*>
(__builtin_alloca(sizeof(_Tp) * _M_size));
if (__n == 0) // no shift
std::__valarray_copy_construct(_M_data, _M_data + _M_size, __a);
else if (__n > 0) // __n > 0: shift left
{
if (size_t(__n) > _M_size)
std::__valarray_default_construct(__a, __a + __n);
else
{
std::__valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
std::__valarray_default_construct(__a+_M_size-__n, __a + _M_size);
}
}
else // __n < 0: shift right { std::__valarray_copy_construct (_M_data, _M_data+_M_size+__n, __a-__n); std::__valarray_default_construct(__a, __a - __n); } return valarray<_Tp> (__a, _M_size);
}
template
inline valarray<_Tp>
valarray<_Tp>::cshift (int __n) const
{
_Tp* const __a = static_cast<_Tp*>
(__builtin_alloca (sizeof(_Tp) * _M_size));
if (__n == 0) // no cshift
std::__valarray_copy_construct(_M_data, _M_data + _M_size, __a);
else if (__n > 0) // cshift left
{
std::__valarray_copy_construct(_M_data, _M_data+__n, __a+_M_size-__n);
std::__valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
}
else // cshift right
{
std::__valarray_copy_construct
(_M_data + _M_size+__n, _M_data + _M_size, __a);
std::__valarray_copy_construct
(_M_data, _M_data + _M_size+__n, __a – __n);
}
return valarray<_Tp>(__a, _M_size);
}
template
inline void
valarray<_Tp>::resize (size_t __n, _Tp __c)
{
// This complication is so to make valarray > work
// even though it is not required by the standard. Nobody should
// be saying valarray > anyway. See the specs.
std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
if (_M_size != __n)
{
std::__valarray_release_memory(_M_data);
_M_size = __n;
_M_data = __valarray_get_storage<_Tp>(__n);
}
std::__valarray_fill_construct(_M_data, _M_data + __n, __c);
}

template
inline _Tp
valarray<_Tp>::min() const
{
_GLIBCXX_DEBUG_ASSERT(_M_size > 0);
return *std::min_element (_M_data, _M_data+_M_size);
}
template
inline _Tp
valarray<_Tp>::max() const
{
_GLIBCXX_DEBUG_ASSERT(_M_size > 0);
return *std::max_element (_M_data, _M_data+_M_size);
}

template
inline _Expr<_ValFunClos<_ValArray,_Tp>,_Tp>
valarray<_Tp>::apply(_Tp func(_Tp)) const
{
typedef _ValFunClos<_ValArray,_Tp> _Closure;
return _Expr<_Closure,_Tp>(_Closure(*this, func));
}
template
inline _Expr<_RefFunClos<_ValArray,_Tp>,_Tp>
valarray<_Tp>::apply(_Tp func(const _Tp &)) const
{
typedef _RefFunClos<_ValArray,_Tp> _Closure;
return _Expr<_Closure,_Tp>(_Closure(*this, func));
}
#define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \
template \
inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt \
valarray<_Tp>::operator _Op() const \
{ \
typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \
typedef typename __fun<_Name, _Tp>::result_type _Rt; \
return _Expr<_Closure, _Rt>(_Closure(*this)); \
}
_DEFINE_VALARRAY_UNARY_OPERATOR(+, __unary_plus)
_DEFINE_VALARRAY_UNARY_OPERATOR(-, __negate)
_DEFINE_VALARRAY_UNARY_OPERATOR(~, __bitwise_not)
_DEFINE_VALARRAY_UNARY_OPERATOR (!, __logical_not)
#undef _DEFINE_VALARRAY_UNARY_OPERATOR
#define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \
template \
inline valarray<_Tp>& \
valarray<_Tp>::operator _Op##=(const _Tp &__t) \
{ \
_Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, __t); \
return *this; \
} \
\
template \
inline valarray<_Tp>& \
valarray<_Tp>::operator _Op##=(const valarray<_Tp> &__v) \
{ \
_GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size); \
_Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, \
_Array<_Tp>(__v._M_data)); \
return *this; \
}
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, __plus)
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, __minus)
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, __multiplies)
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, __divides)
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, __modulus)
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, __shift_left) _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right)
#undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT
#define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \
template template \
inline valarray<_Tp>& \
valarray<_Tp>::operator _Op##=(const _Expr<_Dom,_Tp>& __e) \
{ \
_Array_augmented_##_Name(_Array<_Tp>(_M_data), __e, _M_size); \
return *this; \
}
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, __plus)
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, __minus)
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, __multiplies)
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, __divides)
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, __modulus)
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, __shift_left) _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right)
#undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT

#define _DEFINE_BINARY_OPERATOR(_Op, _Name) \
template \
inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>, \
typename __fun<_Name, _Tp>::result_type> \
operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \
{ \
_GLIBCXX_DEBUG_ASSERT(__v.size() == __w.size()); \
typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \
typedef typename __fun<_Name, _Tp>::result_type _Rt; \
return _Expr<_Closure, _Rt>(_Closure(__v, __w)); \
} \
\
template \
inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>, \
typename __fun<_Name, _Tp>::result_type> \
operator _Op(const valarray<_Tp>& __v, const _Tp& __t) \
{ \
typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \
typedef typename __fun<_Name, _Tp>::result_type _Rt; \
return _Expr<_Closure, _Rt>(_Closure(__v, __t)); \
} \
\
template \
inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>, \
typename __fun<_Name, _Tp>::result_type> \
operator _Op(const _Tp& __t, const valarray<_Tp>& __v) \
{ \
typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \
typedef typename __fun<_Name, _Tp>::result_type _Rt; \
return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \
}
_DEFINE_BINARY_OPERATOR(+, __plus)
_DEFINE_BINARY_OPERATOR(-, __minus)
_DEFINE_BINARY_OPERATOR(*, __multiplies)
_DEFINE_BINARY_OPERATOR(/, __divides)
_DEFINE_BINARY_OPERATOR(%, __modulus)
_DEFINE_BINARY_OPERATOR(^, __bitwise_xor)
_DEFINE_BINARY_OPERATOR(&, __bitwise_and)
_DEFINE_BINARY_OPERATOR(|, __bitwise_or)
_DEFINE_BINARY_OPERATOR(<<, __shift_left) _DEFINE_BINARY_OPERATOR(>>, __shift_right)
_DEFINE_BINARY_OPERATOR(&&, __logical_and)
_DEFINE_BINARY_OPERATOR(||, __logical_or)
_DEFINE_BINARY_OPERATOR(==, __equal_to)
_DEFINE_BINARY_OPERATOR(!=, __not_equal_to)
_DEFINE_BINARY_OPERATOR(<, __less) _DEFINE_BINARY_OPERATOR(>, __greater)
_DEFINE_BINARY_OPERATOR(<=, __less_equal) _DEFINE_BINARY_OPERATOR(>=, __greater_equal)
} // namespace std
#endif /* _GLIBCXX_VALARRAY */

typeinfo
// RTTI support for -*- C++ -*-
// Copyright (C) 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002
// Free Software Foundation
//
// This file is part of GCC.
//
// GCC 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.
//
// GCC 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 GCC; 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.
/** @file typeinfo
* This header provides RTTI support.
*/
#ifndef _TYPEINFO
#define _TYPEINFO
#include
extern “C++” {
namespace __cxxabiv1
{
class __class_type_info;
} // namespace __cxxabiv1
#if !__GXX_WEAK__ || defined (__MINGW32__) || defined (__CYGWIN__)
// If weak symbols are not supported, typeinfo names are not merged.
#define __GXX_MERGED_TYPEINFO_NAMES 0
#else
// On platforms that support weak symbols, typeinfo names are merged.
#define __GXX_MERGED_TYPEINFO_NAMES 1
#endif
namespace std
{
/**
* @brief Part of RTTI.
*
* The @c type_info class describes type information generated by
* an implementation.
*/
class type_info
{
public:
/** Destructor. Being the first non-inline virtual function, this
* controls in which translation unit the vtable is emitted. The
* compiler makes use of that information to know where to emit
* the runtime-mandated type_info structures in the new-abi. */
virtual ~type_info();
private:
/// Assigning type_info is not supported. Made private.
type_info& operator=(const type_info&);
type_info(const type_info&);

protected:
const char *__name;

protected:
explicit type_info(const char *__n): __name(__n) { }

public:
// the public interface
/** Returns an @e implementation-defined byte string; this is not
* portable between compilers! */
const char* name() const
{ return __name; }
#if !__GXX_MERGED_TYPEINFO_NAMES
bool before(const type_info& __arg) const;
// In old abi, or when weak symbols are not supported, there can
// be multiple instances of a type_info object for one
// type. Uniqueness must use the _name value, not object address.
bool operator==(const type_info& __arg) const;
#else
/** Returns true if @c *this precedes @c __arg in the implementation’s
* collation order. */
// In new abi we can rely on type_info’s NTBS being unique,
// and therefore address comparisons are sufficient.
bool before(const type_info& __arg) const
{ return __name < __arg.__name; } bool operator==(const type_info& __arg) const { return __name == __arg.__name; } #endif bool operator!=(const type_info& __arg) const { return !operator==(__arg); } // the internal interface public: // return true if this is a pointer type of some kind virtual bool __is_pointer_p() const; // return true if this is a function type virtual bool __is_function_p() const; // Try and catch a thrown type. Store an adjusted pointer to the // caught type in THR_OBJ. If THR_TYPE is not a pointer type, then // THR_OBJ points to the thrown object. If THR_TYPE is a pointer // type, then THR_OBJ is the pointer itself. OUTER indicates the // number of outer pointers, and whether they were const // qualified. virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj, unsigned __outer) const; // internally used during catch matching virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target, void **__obj_ptr) const; }; /** * @brief Thrown during incorrect typecasting. * * If you attempt an invalid @c dynamic_cast expression, an instance of * this class (or something derived from this class) is thrown. */ class bad_cast : public exception { public: bad_cast() throw() { } // This declaration is not useless: // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118 virtual ~bad_cast() throw(); }; /** If you use a NULL pointer in a @c typeid expression, this is thrown. */ class bad_typeid : public exception { public: bad_typeid () throw() { } // This declaration is not useless: // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118 virtual ~bad_typeid() throw(); }; } // namespace std } // extern "C++" #endif string // Components for manipulating sequences of characters -*- C++ -*- // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003 // 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: 21 Strings library // /** @file string * This is a Standard C++ Library header. You should @c #include this header * in your programs, rather than any of the "st[dl]_*.h" implementation files. */ #ifndef _GLIBCXX_STRING #define _GLIBCXX_STRING 1 #pragma GCC system_header #include
#include
#include
#include // For allocator.
#include
#include // For operators >>, <<, and getline decls. #include
#include // For less
#include
#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include // for find_if
# include
#endif
#endif /* _GLIBCXX_STRING */

streambuf
// Stream buffer classes -*- C++ -*-
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
// 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: 27.5 Stream buffers
//
/** @file streambuf
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _CLIBXX_STREAMBUF
#define _CLIBXX_STREAMBUF 1
#pragma GCC system_header
#include
#include
#include
#include
namespace std
{
/**
* @if maint
* Does stuff.
* @endif
*/
template
streamsize
__copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout);

/**
* @brief The actual work of input and output (interface).
*
* This is a base class. Derived stream buffers each control a
* pair of character sequences: one for input, and one for output.
*
* Section [27.5.1] of the standard describes the requirements and
* behavior of stream buffer classes. That section (three paragraphs)
* is reproduced here, for simplicity and accuracy.
*
* -# Stream buffers can impose various constraints on the sequences
* they control. Some constraints are:
* – The controlled input sequence can be not readable.
* – The controlled output sequence can be not writable.
* – The controlled sequences can be associated with the contents of
* other representations for character sequences, such as external
* files.
* – The controlled sequences can support operations @e directly to or
* from associated sequences.
* – The controlled sequences can impose limitations on how the
* program can read characters from a sequence, write characters to
* a sequence, put characters back into an input sequence, or alter
* the stream position.
* .
* -# Each sequence is characterized by three pointers which, if non-null,
* all point into the same @c charT array object. The array object
* represents, at any moment, a (sub)sequence of characters from the
* sequence. Operations performed on a sequence alter the values
* stored in these pointers, perform reads and writes directly to or
* from associated sequences, and alter “the stream position” and
* conversion state as needed to maintain this subsequence relationship.
* The three pointers are:
* – the beginning pointer, or lowest element address in the
* array (called @e xbeg here);
* – the next pointer, or next element address that is a
* current candidate for reading or writing (called @e xnext here);
* – the end pointer, or first element address beyond the
* end of the array (called @e xend here).
* .
* -# The following semantic constraints shall always apply for any set
* of three pointers for a sequence, using the pointer names given
* immediately above:
* – If @e xnext is not a null pointer, then @e xbeg and @e xend shall
* also be non-null pointers into the same @c charT array, as
* described above; otherwise, @e xbeg and @e xend shall also be null.
* – If @e xnext is not a null pointer and @e xnext < @e xend for an * output sequence, then a write position is available.
* In this case, @e *xnext shall be assignable as the next element
* to write (to put, or to store a character value, into the sequence).
* – If @e xnext is not a null pointer and @e xbeg < @e xnext for an * input sequence, then a putback position is available.
* In this case, @e xnext[-1] shall have a defined value and is the
* next (preceding) element to store a character that is put back
* into the input sequence.
* – If @e xnext is not a null pointer and @e xnext< @e xend for an * input sequence, then a read position is available.
* In this case, @e *xnext shall have a defined value and is the
* next element to read (to get, or to obtain a character value,
* from the sequence).
*/
template
class basic_streambuf
{
public:
//@{
/**
* These are standard types. They permit a standardized way of
* referring to names of (or names dependant on) the template
* parameters, which are specific to the implementation.
*/
typedef _CharT char_type;
typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
//@}
//@{
/**
* @if maint
* This is a non-standard type.
* @endif
*/
typedef basic_streambuf __streambuf_type;
//@}

friend class basic_ios;
friend class basic_istream;
friend class basic_ostream;
friend class istreambuf_iterator;
friend class ostreambuf_iterator;
friend streamsize
__copy_streambufs<>(__streambuf_type* __sbin,
__streambuf_type* __sbout);

protected:
//@{
/**
* @if maint
* This is based on _IO_FILE, just reordered to be more consistent,
* and is intended to be the most minimal abstraction for an
* internal buffer.
* – get == input == read
* – put == output == write
* @endif
*/
char_type* _M_in_beg; // Start of get area.
char_type* _M_in_cur; // Current read area.
char_type* _M_in_end; // End of get area.
char_type* _M_out_beg; // Start of put area.
char_type* _M_out_cur; // Current put area.
char_type* _M_out_end; // End of put area.
/**
* @if maint
* Current locale setting.
* @endif
*/
locale _M_buf_locale;
public:
/// Destructor deallocates no buffer space.
virtual
~basic_streambuf()
{ }
// [27.5.2.2.1] locales
/**
* @brief Entry point for imbue().
* @param loc The new locale.
* @return The previous locale.
*
* Calls the derived imbue(loc).
*/
locale
pubimbue(const locale &__loc)
{
locale __tmp(this->getloc());
this->imbue(__loc);
_M_buf_locale = __loc;
return __tmp;
}
/**
* @brief Locale access.
* @return The current locale in effect.
*
* If pubimbue(loc) has been called, then the most recent @c loc
* is returned. Otherwise the global locale in effect at the time
* of construction is returned.
*/
locale
getloc() const
{ return _M_buf_locale; }
// [27.5.2.2.2] buffer management and positioning
//@{
/**
* @brief Entry points for derived buffer functions.
*
* The public versions of @c pubfoo dispatch to the protected
* derived @c foo member functions, passing the arguments (if any)
* and returning the result unchanged.
*/
__streambuf_type*
pubsetbuf(char_type* __s, streamsize __n)
{ return this->setbuf(__s, __n); }
pos_type
pubseekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out)
{ return this->seekoff(__off, __way, __mode); }
pos_type
pubseekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out)
{ return this->seekpos(__sp, __mode); }
int
pubsync() { return this->sync(); }
//@}
// [27.5.2.2.3] get area
/**
* @brief Looking ahead into the stream.
* @return The number of characters available.
*
* If a read position is available, returns the number of characters
* available for reading before the buffer must be refilled.
* Otherwise returns the derived @c showmanyc().
*/
streamsize
in_avail()
{
const streamsize __ret = this->egptr() – this->gptr();
return __ret ? __ret : this->showmanyc();
}
/**
* @brief Getting the next character.
* @return The next character, or eof.
*
* Calls @c sbumpc(), and if that function returns
* @c traits::eof(), so does this function. Otherwise, @c sgetc().
*/
int_type
snextc()
{
int_type __ret = traits_type::eof();
if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
__ret), true))
__ret = this->sgetc();
return __ret;
}
/**
* @brief Getting the next character.
* @return The next character, or eof.
*
* If the input read position is available, returns that character
* and increments the read pointer, otherwise calls and returns
* @c uflow().
*/
int_type
sbumpc()
{
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true))
{
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
}
else
__ret = this->uflow();
return __ret;
}
/**
* @brief Getting the next character.
* @return The next character, or eof.
*
* If the input read position is available, returns that character,
* otherwise calls and returns @c underflow(). Does not move the
* read position after fetching the character.
*/
int_type
sgetc()
{
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true))
__ret = traits_type::to_int_type(*this->gptr());
else
__ret = this->underflow();
return __ret;
}
/**
* @brief Entry point for xsgetn.
* @param s A buffer area.
* @param n A count.
*
* Returns xsgetn(s,n). The effect is to fill @a s[0] through
* @a s[n-1] with characters from the input sequence, if possible.
*/
streamsize
sgetn(char_type* __s, streamsize __n)
{ return this->xsgetn(__s, __n); }
// [27.5.2.2.4] putback
/**
* @brief Pushing characters back into the input stream.
* @param c The character to push back.
* @return The previous character, if possible.
*
* Similar to sungetc(), but @a c is pushed onto the stream instead
* of “the previous character”. If successful, the next character
* fetched from the input stream will be @a c.
*/
int_type
sputbackc(char_type __c)
{
int_type __ret;
const bool __testpos = this->eback() < this->gptr();
if (__builtin_expect(!__testpos ||
!traits_type::eq(__c, this->gptr()[-1]), false))
__ret = this->pbackfail(traits_type::to_int_type(__c));
else
{
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
}
return __ret;
}
/**
* @brief Moving backwards in the input stream.
* @return The previous character, if possible.
*
* If a putback position is available, this function decrements the
* input pointer and returns that character. Otherwise, calls and
* returns pbackfail(). The effect is to “unget” the last character
* “gotten”.
*/
int_type
sungetc()
{
int_type __ret;
if (__builtin_expect(this->eback() < this->gptr(), true))
{
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
}
else
__ret = this->pbackfail();
return __ret;
}
// [27.5.2.2.5] put area
/**
* @brief Entry point for all single-character output functions.
* @param c A character to output.
* @return @a c, if possible.
*
* One of two public output functions.
*
* If a write position is available for the output sequence (i.e.,
* the buffer is not full), stores @a c in that position, increments
* the position, and returns @c traits::to_int_type(c). If a write
* position is not available, returns @c overflow(c).
*/
int_type
sputc(char_type __c)
{
int_type __ret;
if (__builtin_expect(this->pptr() < this->epptr(), true))
{
*this->pptr() = __c;
this->pbump(1);
__ret = traits_type::to_int_type(__c);
}
else
__ret = this->overflow(traits_type::to_int_type(__c));
return __ret;
}
/**
* @brief Entry point for all single-character output functions.
* @param s A buffer read area.
* @param n A count.
*
* One of two public output functions.
*
*
* Returns xsputn(s,n). The effect is to write @a s[0] through
* @a s[n-1] to the output sequence, if possible.
*/
streamsize
sputn(const char_type* __s, streamsize __n)
{ return this->xsputn(__s, __n); }
protected:
/**
* @brief Base constructor.
*
* Only called from derived constructors, and sets up all the
* buffer data to zero, including the pointers described in the
* basic_streambuf class description. Note that, as a result,
* – the class starts with no read nor write positions available,
* – this is not an error
*/
basic_streambuf()
: _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
_M_out_beg(0), _M_out_cur(0), _M_out_end(0),
_M_buf_locale(locale())
{ }
// [27.5.2.3.1] get area access
//@{
/**
* @brief Access to the get area.
*
* These functions are only available to other protected functions,
* including derived classes.
*
* – eback() returns the beginning pointer for the input sequence
* – gptr() returns the next pointer for the input sequence
* – egptr() returns the end pointer for the input sequence
*/
char_type*
eback() const { return _M_in_beg; }
char_type*
gptr() const { return _M_in_cur; }
char_type*
egptr() const { return _M_in_end; }
//@}
/**
* @brief Moving the read position.
* @param n The delta by which to move.
*
* This just advances the read position without returning any data.
*/
void
gbump(int __n) { _M_in_cur += __n; }
/**
* @brief Setting the three read area pointers.
* @param gbeg A pointer.
* @param gnext A pointer.
* @param gend A pointer.
* @post @a gbeg == @c eback(), @a gnext == @c gptr(), and
* @a gend == @c egptr()
*/
void
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
{
_M_in_beg = __gbeg;
_M_in_cur = __gnext;
_M_in_end = __gend;
}
// [27.5.2.3.2] put area access
//@{
/**
* @brief Access to the put area.
*
* These functions are only available to other protected functions,
* including derived classes.
*
* – pbase() returns the beginning pointer for the output sequence
* – pptr() returns the next pointer for the output sequence
* – epptr() returns the end pointer for the output sequence
*/
char_type*
pbase() const { return _M_out_beg; }
char_type*
pptr() const { return _M_out_cur; }
char_type*
epptr() const { return _M_out_end; }
//@}
/**
* @brief Moving the write position.
* @param n The delta by which to move.
*
* This just advances the write position without returning any data.
*/
void
pbump(int __n) { _M_out_cur += __n; }
/**
* @brief Setting the three write area pointers.
* @param pbeg A pointer.
* @param pend A pointer.
* @post @a pbeg == @c pbase(), @a pbeg == @c pptr(), and
* @a pend == @c epptr()
*/
void
setp(char_type* __pbeg, char_type* __pend)
{
_M_out_beg = _M_out_cur = __pbeg;
_M_out_end = __pend;
}
// [27.5.2.4] virtual functions
// [27.5.2.4.1] locales
/**
* @brief Changes translations.
* @param loc A new locale.
*
* Translations done during I/O which depend on the current locale
* are changed by this call. The standard adds, “Between invocations
* of this function a class derived from streambuf can safely cache
* results of calls to locale functions and to members of facets
* so obtained.”
*
* @note Base class version does nothing.
*/
virtual void
imbue(const locale&)
{ }
// [27.5.2.4.2] buffer management and positioning
/**
* @brief Maniuplates the buffer.
*
* Each derived class provides its own appropriate behavior. See
* the next-to-last paragraph of
* http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2 for
* more on this function.
*
* @note Base class version does nothing, returns @c this.
*/
virtual basic_streambuf*
setbuf(char_type*, streamsize)
{ return this; }

/**
* @brief Alters the stream positions.
*
* Each derived class provides its own appropriate behavior.
* @note Base class version does nothing, returns a @c pos_type
* that represents an invalid stream position.
*/
virtual pos_type
seekoff(off_type, ios_base::seekdir,
ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
/**
* @brief Alters the stream positions.
*
* Each derived class provides its own appropriate behavior.
* @note Base class version does nothing, returns a @c pos_type
* that represents an invalid stream position.
*/
virtual pos_type
seekpos(pos_type,
ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
/**
* @brief Synchronizes the buffer arrays with the controlled sequences.
* @return -1 on failure.
*
* Each derived class provides its own appropriate behavior,
* including the definition of “failure”.
* @note Base class version does nothing, returns zero.
*/
virtual int
sync() { return 0; }
// [27.5.2.4.3] get area
/**
* @brief Investigating the data available.
* @return An estimate of the number of characters available in the
* input sequence, or -1.
*
* “If it returns a positive value, then successive calls to
* @c underflow() will not return @c traits::eof() until at least that
* number of characters have been supplied. If @c showmanyc()
* returns -1, then calls to @c underflow() or @c uflow() will fail.”
* [27.5.2.4.3]/1
*
* @note Base class version does nothing, returns zero.
* @note The standard adds that “the intention is not only that the
* calls [to underflow or uflow] will not return @c eof() but
* that they will return “immediately”.
* @note The standard adds that “the morphemes of @c showmanyc are
* “es-how-many-see”, not “show-manic”.
*/
virtual streamsize
showmanyc() { return 0; }
/**
* @brief Multiple character extraction.
* @param s A buffer area.
* @param n Maximum number of characters to assign.
* @return The number of characters assigned.
*
* Fills @a s[0] through @a s[n-1] with characters from the input
* sequence, as if by @c sbumpc(). Stops when either @a n characters
* have been copied, or when @c traits::eof() would be copied.
*
* It is expected that derived classes provide a more efficient
* implementation by overriding this definition.
*/
virtual streamsize
xsgetn(char_type* __s, streamsize __n);
/**
* @brief Fetches more data from the controlled sequence.
* @return The first character from the pending sequence.
*
* Informally, this function is called when the input buffer is
* exhausted (or does not exist, as buffering need not actually be
* done). If a buffer exists, it is “refilled”. In either case, the
* next available character is returned, or @c traits::eof() to
* indicate a null pending sequence.
*
* For a formal definiton of the pending sequence, see a good text
* such as Langer & Kreft, or [27.5.2.4.3]/7-14.
*
* A functioning input streambuf can be created by overriding only
* this function (no buffer area will be used). For an example, see
* http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#6
*
* @note Base class version does nothing, returns eof().
*/
virtual int_type
underflow()
{ return traits_type::eof(); }
/**
* @brief Fetches more data from the controlled sequence.
* @return The first character from the pending sequence.
*
* Informally, this function does the same thing as @c underflow(),
* and in fact is required to call that function. It also returns
* the new character, like @c underflow() does. However, this
* function also moves the read position forward by one.
*/
virtual int_type
uflow()
{
int_type __ret = traits_type::eof();
const bool __testeof = traits_type::eq_int_type(this->underflow(),
__ret);
if (!__testeof)
{
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
}
return __ret;
}
// [27.5.2.4.4] putback
/**
* @brief Tries to back up the input sequence.
* @param c The character to be inserted back into the sequence.
* @return eof() on failure, “some other value” on success
* @post The constraints of @c gptr(), @c eback(), and @c pptr()
* are the same as for @c underflow().
*
* @note Base class version does nothing, returns eof().
*/
virtual int_type
pbackfail(int_type /* __c */ = traits_type::eof())
{ return traits_type::eof(); }
// Put area:
/**
* @brief Multiple character insertion.
* @param s A buffer area.
* @param n Maximum number of characters to write.
* @return The number of characters written.
*
* Writes @a s[0] through @a s[n-1] to the output sequence, as if
* by @c sputc(). Stops when either @a n characters have been
* copied, or when @c sputc() would return @c traits::eof().
*
* It is expected that derived classes provide a more efficient
* implementation by overriding this definition.
*/
virtual streamsize
xsputn(const char_type* __s, streamsize __n);
/**
* @brief Consumes data from the buffer; writes to the
* controlled sequence.
* @param c An additional character to consume.
* @return eof() to indicate failure, something else (usually
* @a c, or not_eof())
*
* Informally, this function is called when the output buffer is full
* (or does not exist, as buffering need not actually be done). If a
* buffer exists, it is “consumed”, with “some effect” on the
* controlled sequence. (Typically, the buffer is written out to the
* sequence verbatim.) In either case, the character @a c is also
* written out, if @a c is not @c eof().
*
* For a formal definiton of this function, see a good text
* such as Langer & Kreft, or [27.5.2.4.5]/3-7.
*
* A functioning output streambuf can be created by overriding only
* this function (no buffer area will be used).
*
* @note Base class version does nothing, returns eof().
*/
virtual int_type
overflow(int_type /* __c */ = traits_type::eof())
{ return traits_type::eof(); }
#ifdef _GLIBCXX_DEPRECATED
// Annex D.6
public:
/**
* @brief Tosses a character.
*
* Advances the read pointer, ignoring the character that would have
* been read.
*
* See http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html
*
* @note This function has been deprecated by the standard. You
* must define @c _GLIBCXX_DEPRECATED to make this visible; see
* c++config.h.
*/
void
stossc()
{
if (this->gptr() < this->egptr())
this->gbump(1);
else
this->uflow();
}
#endif
private:
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// Side effect of DR 50.
basic_streambuf(const __streambuf_type& __sb)
: _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
_M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
_M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
_M_buf_locale(__sb._M_buf_locale)
{ }
__streambuf_type&
operator=(const __streambuf_type&) { return *this; };
};
} // namespace std
#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include
#endif
#endif /* _GLIBCXX_STREAMBUF */

stdexcept
// Standard exception classes -*- C++ -*-
// Copyright (C) 2001, 2002 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++ 19.1 Exception classes
//
/** @file stdexcept
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_STDEXCEPT
#define _GLIBCXX_STDEXCEPT 1
#pragma GCC system_header
#include
#include
namespace std
{
/** Logic errors represent problems in the internal logic of a program;
* in theory, these are preventable, and even detectable before the
* program runs (e.g., violations of class invariants).
* @brief One of two subclasses of exception.
*/
class logic_error : public exception
{
string _M_msg;
public:
/** Takes a character string describing the error. */
explicit
logic_error(const string& __arg);
virtual
~logic_error() throw();
/** Returns a C-style character string describing the general cause of
* the current error (the same string passed to the ctor). */
virtual const char*
what() const throw();
};
/** Thrown by the library, or by you, to report domain errors (domain in
* the mathmatical sense). */
class domain_error : public logic_error
{
public:
explicit domain_error(const string& __arg);
};
/** Thrown to report invalid arguments to functions. */
class invalid_argument : public logic_error
{
public:
explicit invalid_argument(const string& __arg);
};
/** Thrown when an object is constructed that would exceed its maximum
* permitted size (e.g., a basic_string instance). */
class length_error : public logic_error
{
public:
explicit length_error(const string& __arg);
};
/** This represents an argument whose value is not within the expected
* range (e.g., boundary checks in basic_string). */
class out_of_range : public logic_error
{
public:
explicit out_of_range(const string& __arg);
};
/** Runtime errors represent problems outside the scope of a program;
* they cannot be easily predicted and can generally only be caught as
* the program executes.
* @brief One of two subclasses of exception.
*/
class runtime_error : public exception
{
string _M_msg;
public:
/** Takes a character string describing the error. */
explicit
runtime_error(const string& __arg);
virtual
~runtime_error() throw();
/** Returns a C-style character string describing the general cause of
* the current error (the same string passed to the ctor). */
virtual const char*
what() const throw();
};
/** Thrown to indicate range errors in internal computations. */
class range_error : public runtime_error
{
public:
explicit range_error(const string& __arg);
};
/** Thrown to indicate arithmetic overflow. */
class overflow_error : public runtime_error
{
public:
explicit overflow_error(const string& __arg);
};
/** Thrown to indicate arithmetic underflow. */
class underflow_error : public runtime_error
{
public:
explicit underflow_error(const string& __arg);
};
} // namespace std
#endif /* _GLIBCXX_STDEXCEPT */

stack
// -*- C++ -*-
// Copyright (C) 2001, 2002, 2003 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.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* 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. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided “as is” without express or implied warranty.
*
*
* 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.
*/
/** @file stack
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_STACK
#define _GLIBCXX_STACK 1
#pragma GCC system_header
#include
#include
#include
#include
#include
#include
#endif /* _GLIBCXX_STACK */

sstream
// String based streams -*- C++ -*-
// Copyright (C) 1997, 1998, 1999, 2002, 2003, 2004
// 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: 27.7 String-based streams
//
/** @file sstream
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_SSTREAM
#define _GLIBCXX_SSTREAM 1
#pragma GCC system_header
#include
#include
namespace std
{
// [27.7.1] template class basic_stringbuf
/**
* @brief The actual work of input and output (for std::string).
*
* This class associates either or both of its input and output sequences
* with a sequence of characters, which can be initialized from, or made
* available as, a @c std::basic_string. (Paraphrased from [27.7.1]/1.)
*
* For this class, open modes (of type @c ios_base::openmode) have
* @c in set if the input sequence can be read, and @c out set if the
* output sequence can be written.
*/
template
class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
{
public:
// Types:
typedef _CharT char_type;
typedef _Traits traits_type;
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 251. basic_stringbuf missing allocator_type
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
//@{
/**
* @if maint
* @doctodo
* @endif
*/
typedef basic_streambuf __streambuf_type;
typedef basic_string __string_type;
typedef typename __string_type::size_type __size_type;
//@}
protected:
/**
* @if maint
* Place to stash in || out || in | out settings for current stringbuf.
* @endif
*/
ios_base::openmode _M_mode;
// Data Members:
/**
* @if maint
* @doctodo
* @endif
*/
__string_type _M_string;
public:
// Constructors:
/**
* @brief Starts with an empty string buffer.
* @param mode Whether the buffer can read, or write, or both.
*
* The default constructor initializes the parent class using its
* own default ctor.
*/
explicit
basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
: __streambuf_type(), _M_mode(), _M_string()
{ _M_stringbuf_init(__mode); }
/**
* @brief Starts with an existing string buffer.
* @param str A string to copy as a starting buffer.
* @param mode Whether the buffer can read, or write, or both.
*
* This constructor initializes the parent class using its
* own default ctor.
*/
explicit
basic_stringbuf(const __string_type& __str,
ios_base::openmode __mode = ios_base::in | ios_base::out)
: __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
{ _M_stringbuf_init(__mode); }
// Get and set:
/**
* @brief Copying out the string buffer.
* @return A copy of one of the underlying sequences.
*
* “If the buffer is only created in input mode, the underlying
* character sequence is equal to the input sequence; otherwise, it
* is equal to the output sequence.” [27.7.1.2]/1
*/
__string_type
str() const
{
const bool __testout = this->_M_mode & ios_base::out;
if (__testout)
{
// The current egptr() may not be the actual string end.
if (this->pptr() > this->egptr())
return __string_type(this->pbase(), this->pptr());
else
return __string_type(this->pbase(), this->egptr());
}
else
return _M_string;
}
/**
* @brief Setting a new buffer.
* @param s The string to use as a new sequence.
*
* Deallocates any previous stored sequence, then copies @a s to
* use as a new one.
*/
void
str(const __string_type& __s)
{
// Cannot use _M_string = __s, since v3 strings are COW.
_M_string.assign(__s.data(), __s.size());
_M_stringbuf_init(this->_M_mode);
}
protected:
// Common initialization code for both ctors goes here.
/**
* @if maint
* @doctodo
* @endif
*/
void
_M_stringbuf_init(ios_base::openmode __mode)
{
this->_M_mode = __mode;
__size_type __len = 0;
if (this->_M_mode & (ios_base::ate | ios_base::app))
__len = _M_string.size();
_M_sync(const_cast(_M_string.data()), 0, __len);
}
// [documentation is inherited]
virtual int_type
underflow();
// [documentation is inherited]
virtual int_type
pbackfail(int_type __c = traits_type::eof());
// [documentation is inherited]
virtual int_type
overflow(int_type __c = traits_type::eof());
/**
* @brief Manipulates the buffer.
* @param s Pointer to a buffer area.
* @param n Size of @a s.
* @return @c this
*
* If no buffer has already been created, and both @a s and @a n are
* non-zero, then @c s is used as a buffer; see
* http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2
* for more.
*/
virtual __streambuf_type*
setbuf(char_type* __s, streamsize __n)
{
if (__s && __n >= 0)
{
// This is implementation-defined behavior, and assumes
// that an external char_type array of length __n exists
// and has been pre-allocated. If this is not the case,
// things will quickly blow up.

// Step 1: Destroy the current internal array.
_M_string = __string_type(__s, __n);

// Step 2: Use the external array.
_M_sync(__s, 0, 0);
}
return this;
}
// [documentation is inherited]
virtual pos_type
seekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out);
// [documentation is inherited]
virtual pos_type
seekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out);
// Internal function for correctly updating the internal buffer
// for a particular _M_string, due to initialization or
// re-sizing of an existing _M_string.
// Assumes: contents of _M_string and internal buffer match exactly.
// __i == _M_in_cur – _M_in_beg
// __o == _M_out_cur – _M_out_beg
/**
* @if maint
* @doctodo
* @endif
*/
void
_M_sync(char_type* __base, __size_type __i, __size_type __o)
{
const bool __testin = this->_M_mode & ios_base::in;
const bool __testout = this->_M_mode & ios_base::out;
const __size_type __len = _M_string.size();
if (__testin)
this->setg(__base, __base + __i, __base + __len);
if (__testout)
{
this->setp(__base, __base + _M_string.capacity());
this->pbump(__o);
// We need a pointer to the string end anyway, even when
// !__testin: in that case, however, for the correct
// functioning of the streambuf inlines all the get area
// pointers must be identical.
if (!__testin)
this->setg(__base + __len, __base + __len, __base + __len);
}
}
// Internal function for correctly updating egptr() to the actual
// string end.
void
_M_update_egptr()
{
const bool __testin = this->_M_mode & ios_base::in;
const bool __testout = this->_M_mode & ios_base::out;
if (__testout && this->pptr() > this->egptr())
if (__testin)
this->setg(this->eback(), this->gptr(), this->pptr());
else
this->setg(this->pptr(), this->pptr(), this->pptr());
}
};

// [27.7.2] Template class basic_istringstream
/**
* @brief Controlling input for std::string.
*
* This class supports reading from objects of type std::basic_string,
* using the inherited functions from std::basic_istream. To control
* the associated sequence, an instance of std::basic_stringbuf is used,
* which this page refers to as @c sb.
*/
template
class basic_istringstream : public basic_istream<_CharT, _Traits>
{
public:
// Types:
typedef _CharT char_type;
typedef _Traits traits_type;
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 251. basic_stringbuf missing allocator_type
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
// Non-standard types:
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_istream __istream_type;
private:
/**
* @if maint
* @doctodo
* @endif
*/
__stringbuf_type _M_stringbuf;
public:
// Constructors:
/**
* @brief Default constructor starts with an empty string buffer.
* @param mode Whether the buffer can read, or write, or both.
*
* @c ios_base::in is automatically included in @a mode.
*
* Initializes @c sb using @c mode|in, and passes @c &sb to the base
* class initializer. Does not allocate any buffer.
*
* @if maint
* That’s a lie. We initialize the base class with NULL, because the
* string class does its own memory management.
* @endif
*/
explicit
basic_istringstream(ios_base::openmode __mode = ios_base::in)
: __istream_type(), _M_stringbuf(__mode | ios_base::in)
{ this->init(&_M_stringbuf); }
/**
* @brief Starts with an existing string buffer.
* @param str A string to copy as a starting buffer.
* @param mode Whether the buffer can read, or write, or both.
*
* @c ios_base::in is automatically included in @a mode.
*
* Initializes @c sb using @a str and @c mode|in, and passes @c &sb
* to the base class initializer.
*
* @if maint
* That’s a lie. We initialize the base class with NULL, because the
* string class does its own memory management.
* @endif
*/
explicit
basic_istringstream(const __string_type& __str,
ios_base::openmode __mode = ios_base::in)
: __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
{ this->init(&_M_stringbuf); }
/**
* @brief The destructor does nothing.
*
* The buffer is deallocated by the stringbuf object, not the
* formatting stream.
*/
~basic_istringstream()
{ }
// Members:
/**
* @brief Accessing the underlying buffer.
* @return The current basic_stringbuf buffer.
*
* This hides both signatures of std::basic_ios::rdbuf().
*/
__stringbuf_type*
rdbuf() const
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); }
/**
* @brief Copying out the string buffer.
* @return @c rdbuf()->str()
*/
__string_type
str() const
{ return _M_stringbuf.str(); }
/**
* @brief Setting a new buffer.
* @param s The string to use as a new sequence.
*
* Calls @c rdbuf()->str(s).
*/
void
str(const __string_type& __s)
{ _M_stringbuf.str(__s); }
};

// [27.7.3] Template class basic_ostringstream
/**
* @brief Controlling output for std::string.
*
* This class supports writing to objects of type std::basic_string,
* using the inherited functions from std::basic_ostream. To control
* the associated sequence, an instance of std::basic_stringbuf is used,
* which this page refers to as @c sb.
*/
template
class basic_ostringstream : public basic_ostream<_CharT, _Traits>
{
public:
// Types:
typedef _CharT char_type;
typedef _Traits traits_type;
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 251. basic_stringbuf missing allocator_type
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
// Non-standard types:
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_ostream __ostream_type;
private:
/**
* @if maint
* @doctodo
* @endif
*/
__stringbuf_type _M_stringbuf;
public:
// Constructors/destructor:
/**
* @brief Default constructor starts with an empty string buffer.
* @param mode Whether the buffer can read, or write, or both.
*
* @c ios_base::out is automatically included in @a mode.
*
* Initializes @c sb using @c mode|out, and passes @c &sb to the base
* class initializer. Does not allocate any buffer.
*
* @if maint
* That’s a lie. We initialize the base class with NULL, because the
* string class does its own memory management.
* @endif
*/
explicit
basic_ostringstream(ios_base::openmode __mode = ios_base::out)
: __ostream_type(), _M_stringbuf(__mode | ios_base::out)
{ this->init(&_M_stringbuf); }
/**
* @brief Starts with an existing string buffer.
* @param str A string to copy as a starting buffer.
* @param mode Whether the buffer can read, or write, or both.
*
* @c ios_base::out is automatically included in @a mode.
*
* Initializes @c sb using @a str and @c mode|out, and passes @c &sb
* to the base class initializer.
*
* @if maint
* That’s a lie. We initialize the base class with NULL, because the
* string class does its own memory management.
* @endif
*/
explicit
basic_ostringstream(const __string_type& __str,
ios_base::openmode __mode = ios_base::out)
: __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
{ this->init(&_M_stringbuf); }
/**
* @brief The destructor does nothing.
*
* The buffer is deallocated by the stringbuf object, not the
* formatting stream.
*/
~basic_ostringstream()
{ }
// Members:
/**
* @brief Accessing the underlying buffer.
* @return The current basic_stringbuf buffer.
*
* This hides both signatures of std::basic_ios::rdbuf().
*/
__stringbuf_type*
rdbuf() const
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); }
/**
* @brief Copying out the string buffer.
* @return @c rdbuf()->str()
*/
__string_type
str() const
{ return _M_stringbuf.str(); }
/**
* @brief Setting a new buffer.
* @param s The string to use as a new sequence.
*
* Calls @c rdbuf()->str(s).
*/
void
str(const __string_type& __s)
{ _M_stringbuf.str(__s); }
};

// [27.7.4] Template class basic_stringstream
/**
* @brief Controlling input and output for std::string.
*
* This class supports reading from and writing to objects of type
* std::basic_string, using the inherited functions from
* std::basic_iostream. To control the associated sequence, an instance
* of std::basic_stringbuf is used, which this page refers to as @c sb.
*/
template
class basic_stringstream : public basic_iostream<_CharT, _Traits>
{
public:
// Types:
typedef _CharT char_type;
typedef _Traits traits_type;
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 251. basic_stringbuf missing allocator_type
typedef _Alloc allocator_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
// Non-standard Types:
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
typedef basic_iostream __iostream_type;
private:
/**
* @if maint
* @doctodo
* @endif
*/
__stringbuf_type _M_stringbuf;
public:
// Constructors/destructors
/**
* @brief Default constructor starts with an empty string buffer.
* @param mode Whether the buffer can read, or write, or both.
*
* Initializes @c sb using @c mode, and passes @c &sb to the base
* class initializer. Does not allocate any buffer.
*
* @if maint
* That’s a lie. We initialize the base class with NULL, because the
* string class does its own memory management.
* @endif
*/
explicit
basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
: __iostream_type(), _M_stringbuf(__m)
{ this->init(&_M_stringbuf); }
/**
* @brief Starts with an existing string buffer.
* @param str A string to copy as a starting buffer.
* @param mode Whether the buffer can read, or write, or both.
*
* Initializes @c sb using @a str and @c mode, and passes @c &sb
* to the base class initializer.
*
* @if maint
* That’s a lie. We initialize the base class with NULL, because the
* string class does its own memory management.
* @endif
*/
explicit
basic_stringstream(const __string_type& __str,
ios_base::openmode __m = ios_base::out | ios_base::in)
: __iostream_type(), _M_stringbuf(__str, __m)
{ this->init(&_M_stringbuf); }
/**
* @brief The destructor does nothing.
*
* The buffer is deallocated by the stringbuf object, not the
* formatting stream.
*/
~basic_stringstream()
{ }
// Members:
/**
* @brief Accessing the underlying buffer.
* @return The current basic_stringbuf buffer.
*
* This hides both signatures of std::basic_ios::rdbuf().
*/
__stringbuf_type*
rdbuf() const
{ return const_cast<__stringbuf_type*>(&_M_stringbuf); }
/**
* @brief Copying out the string buffer.
* @return @c rdbuf()->str()
*/
__string_type
str() const
{ return _M_stringbuf.str(); }
/**
* @brief Setting a new buffer.
* @param s The string to use as a new sequence.
*
* Calls @c rdbuf()->str(s).
*/
void
str(const __string_type& __s)
{ _M_stringbuf.str(__s); }
};
} // namespace std
#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include
#endif
#endif /* _GLIBCXX_SSTREAM */

queue
// -*- C++ -*-
// Copyright (C) 2001, 2002, 2003 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.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* 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. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided “as is” without express or implied warranty.
*
*
* 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.
*/
/** @file queue
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_QUEUE
#define _GLIBCXX_QUEUE 1
#pragma GCC system_header
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#endif /* _GLIBCXX_QUEUE */

ostream
// Output streams -*- C++ -*-
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
// 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: 27.6.2 Output streams
//
/** @file ostream
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_OSTREAM
#define _GLIBCXX_OSTREAM 1
#pragma GCC system_header
#include
namespace std
{
// [27.6.2.1] Template class basic_ostream
/**
* @brief Controlling output.
*
* This is the base class for all output streams. It provides text
* formatting of all builtin types, and communicates with any class
* derived from basic_streambuf to do the actual output.
*/
template
class basic_ostream : virtual public basic_ios<_CharT, _Traits>
{
public:
// Types (inherited from basic_ios (27.4.4)):
typedef _CharT char_type;
typedef typename _Traits::int_type int_type;
typedef typename _Traits::pos_type pos_type;
typedef typename _Traits::off_type off_type;
typedef _Traits traits_type;

// Non-standard Types:
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
typedef basic_ios<_CharT, _Traits> __ios_type;
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
__num_put_type;
typedef ctype<_CharT> __ctype_type;
template
friend basic_ostream<_CharT2, _Traits2>&
operator<<(basic_ostream<_CharT2, _Traits2>&, _CharT2);

template
friend basic_ostream&
operator<<(basic_ostream&, char);

template
friend basic_ostream<_CharT2, _Traits2>&
operator<<(basic_ostream<_CharT2, _Traits2>&, const _CharT2*);

template
friend basic_ostream&
operator<<(basic_ostream&, const char*);

template
friend basic_ostream<_CharT2, _Traits2>&
operator<<(basic_ostream<_CharT2, _Traits2>&, const char*);
// [27.6.2.2] constructor/destructor
/**
* @brief Base constructor.
*
* This ctor is almost never called by the user directly, rather from
* derived classes’ initialization lists, which pass a pointer to
* their own stream buffer.
*/
explicit
basic_ostream(__streambuf_type* __sb)
{ this->init(__sb); }
/**
* @brief Base destructor.
*
* This does very little apart from providing a virtual base dtor.
*/
virtual
~basic_ostream() { }
// [27.6.2.3] prefix/suffix
class sentry;
friend class sentry;

// [27.6.2.5] formatted output
// [27.6.2.5.3] basic_ostream::operator<< //@{ /** * @brief Interface for manipulators. * * Manuipulators such as @c std::endl and @c std::hex use these * functions in constructs like "std::cout << std::endl". For more * information, see the iomanip header. */ inline __ostream_type& operator<<(__ostream_type& (*__pf)(__ostream_type&)); inline __ostream_type& operator<<(__ios_type& (*__pf)(__ios_type&)); inline __ostream_type& operator<<(ios_base& (*__pf) (ios_base&)); //@} // [27.6.2.5.2] arithmetic inserters /** * @name Arithmetic Inserters * * All the @c operator<< functions (aka formatted output
* functions) have some common behavior. Each starts by
* constructing a temporary object of type std::basic_ostream::sentry.
* This can have several effects, concluding with the setting of a
* status flag; see the sentry documentation for more.
*
* If the sentry status is good, the function tries to generate
* whatever data is appropriate for the type of the argument.
*
* If an exception is thrown during insertion, ios_base::badbit
* will be turned on in the stream’s error state without causing an
* ios_base::failure to be thrown. The original exception will then
* be rethrown.
*/
//@{
/**
* @brief Basic arithmetic inserters
* @param A variable of builtin type.
* @return @c *this if successful
*
* These functions use the stream’s current locale (specifically, the
* @c num_get facet) to perform numeric formatting.
*/
__ostream_type&
operator<<(long __n); __ostream_type& operator<<(unsigned long __n); __ostream_type& operator<<(bool __n); __ostream_type& operator<<(short __n) { ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt & ios_base::oct || __fmt & ios_base::hex)
return this->operator<<(static_cast
(static_cast(__n)));
else
return this->operator<<(static_cast(__n));
}
__ostream_type&
operator<<(unsigned short __n) { return this->operator<<(static_cast(__n)); }
__ostream_type&
operator<<(int __n) { ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
if (__fmt & ios_base::oct || __fmt & ios_base::hex)
return this->operator<<(static_cast
(static_cast(__n)));
else
return this->operator<<(static_cast(__n));
}
__ostream_type&
operator<<(unsigned int __n) { return this->operator<<(static_cast(__n)); }
#ifdef _GLIBCXX_USE_LONG_LONG
__ostream_type&
operator<<(long long __n); __ostream_type& operator<<(unsigned long long __n); #endif __ostream_type& operator<<(double __f); __ostream_type& operator<<(float __f) { return this->operator<<(static_cast(__f)); }
__ostream_type&
operator<<(long double __f); __ostream_type& operator<<(const void* __p); /** * @brief Extracting from another streambuf. * @param sb A pointer to a streambuf * * This function behaves like one of the basic arithmetic extractors, * in that it also constructs a sentry object and has the same error * handling behavior. * * If @a sb is NULL, the stream will set failbit in its error state. * * Characters are extracted from @a sb and inserted into @c *this * until one of the following occurs: * * - the input stream reaches end-of-file, * - insertion into the output sequence fails (in this case, the * character that would have been inserted is not extracted), or * - an exception occurs while getting a character from @a sb, which * sets failbit in the error state * * If the function inserts no characters, failbit is set. */ __ostream_type& operator<<(__streambuf_type* __sb); //@} // [27.6.2.6] unformatted output functions /** * @name Unformatted Output Functions * * All the unformatted output functions have some common behavior. * Each starts by constructing a temporary object of type * std::basic_ostream::sentry. This has several effects, concluding * with the setting of a status flag; see the sentry documentation * for more. * * If the sentry status is good, the function tries to generate * whatever data is appropriate for the type of the argument. * * If an exception is thrown during insertion, ios_base::badbit * will be turned on in the stream's error state. If badbit is on in * the stream's exceptions mask, the exception will be rethrown * without completing its actions. */ //@{ /** * @brief Simple insertion. * @param c The character to insert. * @return *this * * Tries to insert @a c. * * @note This function is not overloaded on signed char and * unsigned char. */ __ostream_type& put(char_type __c); // Core write functionality, without sentry. void _M_write(const char_type* __s, streamsize __n) { streamsize __put = this->rdbuf()->sputn(__s, __n);
if (__put != __n)
this->setstate(ios_base::badbit);
}
/**
* @brief Character string insertion.
* @param s The array to insert.
* @param n Maximum number of characters to insert.
* @return *this
*
* Characters are copied from @a s and inserted into the stream until
* one of the following happens:
*
* – @a n characters are inserted
* – inserting into the output sequence fails (in this case, badbit
* will be set in the stream’s error state)
*
* @note This function is not overloaded on signed char and
* unsigned char.
*/
__ostream_type&
write(const char_type* __s, streamsize __n);
//@}
/**
* @brief Synchronizing the stream buffer.
* @return *this
*
* If @c rdbuf() is a null pointer, changes nothing.
*
* Otherwise, calls @c rdbuf()->pubsync(), and if that returns -1,
* sets badbit.
*/
__ostream_type&
flush();
// [27.6.2.4] seek members
/**
* @brief Getting the current write position.
* @return A file position object.
*
* If @c fail() is not false, returns @c pos_type(-1) to indicate
* failure. Otherwise returns @c rdbuf()->pubseekoff(0,cur,out).
*/
pos_type
tellp();
/**
* @brief Changing the current write position.
* @param pos A file position object.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekpos(pos). If
* that function fails, sets failbit.
*/
__ostream_type&
seekp(pos_type);
/**
* @brief Changing the current write position.
* @param off A file offset object.
* @param dir The direction in which to seek.
* @return *this
*
* If @c fail() is not true, calls @c rdbuf()->pubseekoff(off,dir).
* If that function fails, sets failbit.
*/
__ostream_type&
seekp(off_type, ios_base::seekdir);

protected:
explicit
basic_ostream() { }
};
/**
* @brief Performs setup work for output streams.
*
* Objects of this class are created before all of the standard
* inserters are run. It is responsible for “exception-safe prefix and
* suffix operations.” Additional actions may be added by the
* implementation, and we list them in
* http://gcc.gnu.org/onlinedocs/libstdc++/17_intro/howto.html#5
* under [27.6] notes.
*/
template
class basic_ostream<_CharT, _Traits>::sentry
{
// Data Members:
bool _M_ok;
basic_ostream<_CharT,_Traits>& _M_os;

public:
/**
* @brief The constructor performs preparatory work.
* @param os The output stream to guard.
*
* If the stream state is good (@a os.good() is true), then if the
* stream is tied to another output stream, @c is.tie()->flush()
* is called to synchronize the output sequences.
*
* If the stream state is still good, then the sentry state becomes
* true (“okay”).
*/
explicit
sentry(basic_ostream<_CharT,_Traits>& __os);
/**
* @brief Possibly flushes the stream.
*
* If @c ios_base::unitbuf is set in @c os.flags(), and
* @c std::uncaught_exception() is true, the sentry destructor calls
* @c flush() on the output stream.
*/
~sentry()
{
// XXX MT
if (_M_os.flags() & ios_base::unitbuf && !uncaught_exception())
{
// Can’t call flush directly or else will get into recursive lock.
if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
_M_os.setstate(ios_base::badbit);
}
}
/**
* @brief Quick status checking.
* @return The sentry state.
*
* For ease of use, sentries may be converted to booleans. The
* return value is that of the sentry state (true == okay).
*/
operator bool() const
{ return _M_ok; }
};
// [27.6.2.5.4] character insertion templates
//@{
/**
* @brief Character inserters
* @param out An output stream.
* @param c A character.
* @return out
*
* Behaves like one of the formatted arithmetic inserters described in
* std::basic_ostream. After constructing a sentry object with good
* status, this function inserts a single character and any required
* padding (as determined by [22.2.2.2.2]). @c out.width(0) is then
* called.
*
* If @a c is of type @c char and the character type of the stream is not
* @c char, the character is widened before insertion.
*/
template
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c);
template
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
{ return (__out << __out.widen(__c)); } // Specialization template
basic_ostream&
operator<<(basic_ostream& __out, char __c);
// Signed and unsigned
template
basic_ostream&
operator<<(basic_ostream& __out, signed char __c)
{ return (__out << static_cast(__c)); }

template
basic_ostream&
operator<<(basic_ostream& __out, unsigned char __c)
{ return (__out << static_cast(__c)); }
//@}

//@{
/**
* @brief String inserters
* @param out An output stream.
* @param s A character string.
* @return out
* @pre @a s must be a non-NULL pointer
*
* Behaves like one of the formatted arithmetic inserters described in
* std::basic_ostream. After constructing a sentry object with good
* status, this function inserts @c traits::length(s) characters starting
* at @a s, widened if necessary, followed by any required padding (as
* determined by [22.2.2.2.2]). @c out.width(0) is then called.
*/
template
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s);
template
basic_ostream<_CharT, _Traits> &
operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
// Partial specializationss
template
basic_ostream&
operator<<(basic_ostream& __out, const char* __s);

// Signed and unsigned
template
basic_ostream&
operator<<(basic_ostream& __out, const signed char* __s)
{ return (__out << reinterpret_cast(__s)); }
template
basic_ostream &
operator<<(basic_ostream& __out, const unsigned char* __s)
{ return (__out << reinterpret_cast(__s)); }
//@}
// [27.6.2.7] standard basic_ostream manipulators
/**
* @brief Write a newline and flush the stream.
*
* This manipulator is often mistakenly used when a simple newline is
* desired, leading to poor buffering performance. See
* http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2 for more
* on this subject.
*/
template
basic_ostream<_CharT, _Traits>&
endl(basic_ostream<_CharT, _Traits>& __os)
{ return flush(__os.put(__os.widen(‘\n’))); }
/**
* @brief Write a null character into the output sequence.
*
* “Null character” is @c CharT() by definition. For CharT of @c char,
* this correctly writes the ASCII @c NUL character string terminator.
*/
template
basic_ostream<_CharT, _Traits>&
ends(basic_ostream<_CharT, _Traits>& __os)
{ return __os.put(_CharT()); }

/**
* @brief Flushes the output stream.
*
* This manipulator simply calls the stream’s @c flush() member function.
*/
template
basic_ostream<_CharT, _Traits>&
flush(basic_ostream<_CharT, _Traits>& __os)
{ return __os.flush(); }
} // namespace std
#ifndef _GLIBCXX_EXPORT_TEMPLATE
# include
#endif
#endif /* _GLIBCXX_OSTREAM */

numeric
// -*- C++ -*-
// Copyright (C) 2001, 2002 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.
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* 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. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided “as is” without express or implied warranty.
*
*
* 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.
*/
/** @file numeric
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_NUMERIC
#define _GLIBCXX_NUMERIC 1
#pragma GCC system_header
#include
#include
#include
#include
#include
#endif /* _GLIBCXX_NUMERIC */

new
// The -*- C++ -*- dynamic memory management header.
// Copyright (C) 1994, 1996, 1997, 1998, 2000, 2001, 2002
// Free Software Foundation
// This file is part of GCC.
//
// GCC 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.
//
// GCC 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 GCC; 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.
/** @file new
* The header @c new defines several functions to manage dynamic memory and
* handling memory allocation errors; see
* http://gcc.gnu.org/onlinedocs/libstdc++/18_support/howto.html#4 for more.
*/
#ifndef _NEW
#define _NEW
#include
#include
extern “C++” {
namespace std
{
/**
* @brief Exception possibly thrown by @c new.
*
* @c bad_alloc (or classes derived from it) is used to report allocation
* errors from the throwing forms of @c new. */
class bad_alloc : public exception
{
public:
bad_alloc() throw() { }
// This declaration is not useless:
// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
virtual ~bad_alloc() throw();
};
struct nothrow_t { };
extern const nothrow_t nothrow;
/** If you write your own error handler to be called by @c new, it must
* be of this type. */
typedef void (*new_handler)();
/// Takes a replacement handler as the argument, returns the previous handler.
new_handler set_new_handler(new_handler) throw();
} // namespace std
//@{
/** These are replaceable signatures:
* – normal single new and delete (no arguments, throw @c bad_alloc on error)
* – normal array new and delete (same)
* – @c nothrow single new and delete (take a @c nothrow argument, return
* @c NULL on error)
* – @c nothrow array new and delete (same)
*
* Placement new and delete signatures (take a memory address argument,
* does nothing) may not be replaced by a user’s program.
*/
void* operator new(std::size_t) throw (std::bad_alloc);
void* operator new[](std::size_t) throw (std::bad_alloc);
void operator delete(void*) throw();
void operator delete[](void*) throw();
void* operator new(std::size_t, const std::nothrow_t&) throw();
void* operator new[](std::size_t, const std::nothrow_t&) throw();
void operator delete(void*, const std::nothrow_t&) throw();
void operator delete[](void*, const std::nothrow_t&) throw();
// Default placement versions of operator new.
inline void* operator new(std::size_t, void* __p) throw() { return __p; }
inline void* operator new[](std::size_t, void* __p) throw() { return __p; }
// Default placement versions of operator delete.
inline void operator delete (void*, void*) throw() { }
inline void operator delete[](void*, void*) throw() { }
//@}
} // extern “C++”
#endif

memory
// -*- C++ -*-
// Copyright (C) 2001, 2002, 2004 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.
/*
* Copyright (c) 1997-1999
* 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.
*
*/
/** @file memory
* This is a Standard C++ Library header. You should @c #include this header
* in your programs, rather than any of the “st[dl]_*.h” implementation files.
*/
#ifndef _GLIBCXX_MEMORY
#define _GLIBCXX_MEMORY 1
#pragma GCC system_header
#include
#include
#include
#include //for iterator_traits
#include
#include
#include
namespace std
{
/**
* @if maint
* This is a helper function. The unused second parameter exists to
* permit the real get_temporary_buffer to use template parameter deduction.
*
* XXX This should perhaps use the pool.
* @endif
*/
template
pair<_Tp*, ptrdiff_t>
__get_temporary_buffer(ptrdiff_t __len, _Tp*)
{
if (__len > ptrdiff_t(INT_MAX / sizeof(_Tp)))
__len = INT_MAX / sizeof(_Tp);

while (__len > 0)
{
_Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
nothrow));
if (__tmp != 0)
return pair<_Tp*, ptrdiff_t>(__tmp, __len);
__len /= 2;
}
return pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
}
/**
* @brief Allocates a temporary buffer.
* @param len The number of objects of type Tp.
* @return See full description.
*
* Reinventing the wheel, but this time with prettier spokes!
*
* This function tries to obtain storage for @c len adjacent Tp
* objects. The objects themselves are not constructed, of course.
* A pair<> is returned containing “the buffer s address and
* capacity (in the units of sizeof(Tp)), or a pair of 0 values if
* no storage can be obtained.” Note that the capacity obtained
* may be less than that requested if the memory is unavailable;
* you should compare len with the .second return value.
*
* Provides the nothrow exception guarantee.
*/
template
inline pair<_Tp*,ptrdiff_t>
get_temporary_buffer(ptrdiff_t __len)
{ return std::__get_temporary_buffer(__len, static_cast<_Tp*>(0)); }
/**
* @brief The companion to get_temporary_buffer().
* @param p A buffer previously allocated by get_temporary_buffer.
* @return None.
*
* Frees the memory pointed to by p.
*/
template
void
return_temporary_buffer(_Tp* __p)
{ ::operator delete(__p, nothrow); }
/**
* A wrapper class to provide auto_ptr with reference semantics.
* For example, an auto_ptr can be assigned (or constructed from)
* the result of a function which returns an auto_ptr by value.
*
* All the auto_ptr_ref stuff should happen behind the scenes.
*/
template
struct auto_ptr_ref
{
_Tp1* _M_ptr;

explicit
auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
};

/**
* @brief A simple smart pointer providing strict ownership semantics.
*
* The Standard says:
*

   *  An @c auto_ptr owns the object it holds a pointer to.  Copying
   *  an @c auto_ptr copies the pointer and transfers ownership to the
   *  destination.  If more than one @c auto_ptr owns the same object
   *  at the same time the behavior of the program is undefined.
   *
   *  The uses of @c auto_ptr include providing temporary
   *  exception-safety for dynamically allocated memory, passing
   *  ownership of dynamically allocated memory to a function, and
   *  returning dynamically allocated memory from a function.  @c
   *  auto_ptr does not meet the CopyConstructible and Assignable
   *  requirements for Standard Library container elements and thus
   *  instantiating a Standard Library container with an @c auto_ptr
   *  results in undefined behavior.
   *  

* Quoted from [20.4.5]/3.
*
* Good examples of what can and cannot be done with auto_ptr can
* be found in the libstdc++ testsuite.
*
* @if maint
* _GLIBCXX_RESOLVE_LIB_DEFECTS
* 127. auto_ptr<> conversion issues
* These resolutions have all been incorporated.
* @endif
*/
template
class auto_ptr
{
private:
_Tp* _M_ptr;

public:
/// The pointed-to type.
typedef _Tp element_type;

/**
* @brief An %auto_ptr is usually constructed from a raw pointer.
* @param p A pointer (defaults to NULL).
*
* This object now @e owns the object pointed to by @a p.
*/
explicit
auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
/**
* @brief An %auto_ptr can be constructed from another %auto_ptr.
* @param a Another %auto_ptr of the same type.
*
* This object now @e owns the object previously owned by @a a,
* which has given up ownsership.
*/
auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
/**
* @brief An %auto_ptr can be constructed from another %auto_ptr.
* @param a Another %auto_ptr of a different but related type.
*
* A pointer-to-Tp1 must be convertible to a
* pointer-to-Tp/element_type.
*
* This object now @e owns the object previously owned by @a a,
* which has given up ownsership.
*/
template
auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
/**
* @brief %auto_ptr assignment operator.
* @param a Another %auto_ptr of the same type.
*
* This object now @e owns the object previously owned by @a a,
* which has given up ownsership. The object that this one @e
* used to own and track has been deleted.
*/
auto_ptr&
operator=(auto_ptr& __a) throw()
{
reset(__a.release());
return *this;
}
/**
* @brief %auto_ptr assignment operator.
* @param a Another %auto_ptr of a different but related type.
*
* A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type.
*
* This object now @e owns the object previously owned by @a a,
* which has given up ownsership. The object that this one @e
* used to own and track has been deleted.
*/
template
auto_ptr&
operator=(auto_ptr<_Tp1>& __a) throw()
{
reset(__a.release());
return *this;
}
/**
* When the %auto_ptr goes out of scope, the object it owns is
* deleted. If it no longer owns anything (i.e., @c get() is
* @c NULL), then this has no effect.
*
* @if maint
* The C++ standard says there is supposed to be an empty throw
* specification here, but omitting it is standard conforming. Its
* presence can be detected only if _Tp::~_Tp() throws, but this is
* prohibited. [17.4.3.6]/2
* @end maint
*/
~auto_ptr() { delete _M_ptr; }

/**
* @brief Smart pointer dereferencing.
*
* If this %auto_ptr no longer owns anything, then this
* operation will crash. (For a smart pointer, “no longer owns
* anything” is the same as being a null pointer, and you know
* what happens when you dereference one of those…)
*/
element_type&
operator*() const throw()
{
_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
return *_M_ptr;
}

/**
* @brief Smart pointer dereferencing.
*
* This returns the pointer itself, which the language then will
* automatically cause to be dereferenced.
*/
element_type*
operator->() const throw()
{
_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
return _M_ptr;
}

/**
* @brief Bypassing the smart pointer.
* @return The raw pointer being managed.
*
* You can get a copy of the pointer that this object owns, for
* situations such as passing to a function which only accepts
* a raw pointer.
*
* @note This %auto_ptr still owns the memory.
*/
element_type*
get() const throw() { return _M_ptr; }

/**
* @brief Bypassing the smart pointer.
* @return The raw pointer being managed.
*
* You can get a copy of the pointer that this object owns, for
* situations such as passing to a function which only accepts
* a raw pointer.
*
* @note This %auto_ptr no longer owns the memory. When this object
* goes out of scope, nothing will happen.
*/
element_type*
release() throw()
{
element_type* __tmp = _M_ptr;
_M_ptr = 0;
return __tmp;
}

/**
* @brief Forcibly deletes the managed object.
* @param p A pointer (defaults to NULL).
*
* This object now @e owns the object pointed to by @a p. The
* previous object has been deleted.
*/
void
reset(element_type* __p = 0) throw()
{
if (__p != _M_ptr)
{
delete _M_ptr;
_M_ptr = __p;
}
}

/** @{
* @brief Automatic conversions
*
* These operations convert an %auto_ptr into and from an auto_ptr_ref
* automatically as needed. This allows constructs such as
* @code
* auto_ptr func_returning_auto_ptr(…..);
* …
* auto_ptr ptr = func_returning_auto_ptr(…..);
* @endcode
*/
auto_ptr(auto_ptr_ref __ref) throw()
: _M_ptr(__ref._M_ptr) { }

auto_ptr&
operator=(auto_ptr_ref __ref) throw()
{
if (__ref._M_ptr != this->get())
{
delete _M_ptr;
_M_ptr = __ref._M_ptr;
}
return *this;
}

template
operator auto_ptr_ref<_Tp1>() throw()
{ return auto_ptr_ref<_Tp1>(this->release()); }
template
operator auto_ptr<_Tp1>() throw()
{ return auto_ptr<_Tp1>(this->release()); }
/** @} */
};
} // namespace std
#endif /* _GLIBCXX_MEMORY */

map
//